Compare commits

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

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

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

Fixes #109

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

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

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

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

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

* Signaling: always report Disconnected when the receiver stops

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

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

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

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

---------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 06:04:54 -07:00
VallierDevandClaude Opus 5.5 16ded48a99 Release v0.2.24
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 17:45:03 +08:00
d95053d490 X11: change the desktop resolution for the viewer's choice; survive live resizes (#86)
* Restart X11 capture at the new size when the desktop is resized mid-stream

A RandR resize during a session made x11grab fail with BadMatch on the old
size. read_encoder treated that as an encoder failure and walked the whole
fallback chain (NVENC -> CPU, HEVC -> H.264) with the stale size, then the
stream stopped ("Encoder output ended") and the viewer froze. New connections
already re-probed the geometry (#18); live ones did not.

- When an X11 stream fails and the root size differs, skip the encoder
  fallback and restart capture at the new size with the same settings.
- Absolute pointer mapping follows the refreshed X11 size.
- New connections compare the root size with their capture instead of the
  engine's change flag, which a live stream may already have consumed.

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

* Change the X11 desktop resolution when the viewer picks one

The official Windows host changes its display resolution for the viewer's
分辨率 choice; this host only scaled the encoded stream, so a smaller choice
made text smaller and blurrier instead of larger.

On X11 the capture/resolution RPC now switches the primary output's mode with
xrandr (an existing mode of that size, else a CVT reduced-blanking mode at
60 Hz, or 30 Hz above an HDMI 2.0 pixel clock), re-applying it when mutter
resets the mode after the list changes. resolution_type 3 (original) and the
end of the last desktop stream restore the mode in use before the first
change. The stream restarts capture at the new native size and reports it in
the screen sources and CaptureSettingSync. UU_DESKTOP_RESIZE=0 keeps the old
encoder scaling; Wayland is unchanged.

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

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 02:44:18 -07:00
VallierDevandClaude Opus 5.5 50ed54d77a Release v0.2.23
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-22 16:34:37 +08:00
d6752e77c8 Fix SRTP rollover counter rewinding on delayed NACK retransmissions (#83) (#84)
webrtc-srtp 0.12.0 stored every sequence number and used a 100-packet window to
guess the rollover counter. A NACK retransmission of a pre-wrap packet sent after
the wrap (65000 after 85) rewound that state, so the next new packets were
protected with ROC+1 and the viewer failed authentication on all of them: frozen
video after the Windows viewer returned from the background.

Vendor webrtc-srtp 0.12.0 with the RFC 3711 Appendix A half-space estimate and a
high-water index that retransmissions cannot move back. Regression tests fail on
upstream (65000 != 85) and pass with the fix for AES-CM/HMAC and AES-GCM.

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: AYssu <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-22 01:34:07 -07:00
84 changed files with 9596 additions and 492 deletions

No files matched your search

+5 -4
View File
@@ -32,8 +32,8 @@ body:
attributes:
label: 诊断信息 / Diagnostics
description: |
先复现一次问题,然后在被控的 Linux 上运行下面的命令,把输出粘贴到这里(IP 会被自动抹掉,不包含密码、令牌或剪贴板内容)。
Reproduce the problem, then run this on the Linux host and paste the output (IPs are masked; no passwords, tokens or clipboard data).
先复现一次问题,然后在被控 Linux 的**图形桌面里打开的终端**中运行下面的命令(SSH 或 tty 里缺少桌面环境变量,doctor 结果不准),把输出粘贴到这里(IPv4/IPv6/MAC 地址会被自动抹掉,不包含密码、令牌或剪贴板内容)。
Reproduce the problem, then run this in a terminal **inside the Linux graphical session** (SSH/tty lacks the desktop environment, so doctor would be misleading) and paste the output (IPv4/IPv6/MAC addresses are masked; no passwords, tokens or clipboard data).
```sh
{
@@ -45,8 +45,9 @@ body:
echo "== 显卡"; lspci 2>/dev/null | grep -iE 'vga|3d'
echo "== FFmpeg"; ffmpeg -hide_banner -encoders 2>/dev/null | grep -E 'h264_nvenc|libx264'
echo "== 日志"; journalctl --user -u uuremote-native.service --since "-30min" --no-pager -o cat \
| grep -E 'Starting|backend|Selected capture|Desktop encoder|Capture setting request|Desktop video settings|Offer for connection|WARN|ERROR' | tail -n 80
} 2>&1 | sed -E 's/[0-9]{1,3}(\.[0-9]{1,3}){3}/x.x.x.x/g'
| grep -E 'Starting|backend|Selected capture|Desktop encoder|Capture setting request|Desktop video settings|Offer for connection|PeerConnection State|Remote controller disconnected|ICE path|Port mapping|WARN|ERROR' \
| grep -vE 'webrtc_ice|webrtc_dtls|webrtc::mux' | tail -n 120
} 2>&1 | sed -E 's/[0-9]{1,3}(\.[0-9]{1,3}){3}/x.x.x.x/g; s/([0-9a-fA-F]{1,4}:){4,7}[0-9a-fA-F]{1,4}|[0-9a-fA-F]{0,4}::[0-9a-fA-F:]*[0-9a-fA-F]/x:x::x/g'
```
render: text
validations:
+15
View File
@@ -43,6 +43,21 @@ jobs:
uuremote-server --help | head -1
test -f /usr/lib/uu-remote-linux/libuu-wayland.so
systemd-analyze verify /usr/lib/systemd/user/uuremote-native.service
# The tarball installer must bring FFmpeg back on a machine without it (no FFmpeg = no picture).
- name: Tarball install script
run: |
shellcheck packaging/tarball/install.sh
sudo apt-get remove -y ffmpeg || true
if command -v ffmpeg; then echo "ffmpeg still present"; exit 1; fi
pkg=$(mktemp -d)
cp target/debug/uuremote-server target/debug/libuu-wayland.so packaging/tarball/install.sh "$pkg/"
cp -r contrib "$pkg/"
home=$(mktemp -d)
HOME=$home XDG_CONFIG_HOME=$home/.config "$pkg/install.sh" --yes
ffmpeg -hide_banner -encoders | grep -qw libx264
test -x "$home/.local/bin/uuremote-server" && test -f "$home/.local/lib/uu-remote-linux/libuu-wayland.so"
grep -q '^ExecStart=%h/.local/bin/uuremote-server$' "$home/.config/systemd/user/uuremote-native.service"
HOME=$home XDG_CONFIG_HOME=$home/.config "$pkg/install.sh" --yes | grep -q 'Kept existing'
test-viewer:
runs-on: ubuntu-22.04
+1 -1
View File
@@ -65,7 +65,7 @@ jobs:
name=uu-remote-linux-${GITHUB_REF_NAME}-${{ matrix.arch }}-linux
mkdir -p "$name"
cp target/release/uuremote-server target/release/uuremote-viewer target/release/libuu-wayland.so target/release/libuu-portal.so \
LICENSE README.md README.en.md config.example.json "$name/"
packaging/tarball/install.sh LICENSE README.md README.en.md config.example.json "$name/"
cp -r contrib "$name/"
tar czf "$name.tar.gz" "$name"
sha256sum "$name.tar.gz" > "$name.tar.gz.sha256"
+18 -10
View File
@@ -73,6 +73,9 @@ cargo build --release --features native-viewer,viewer-sdl --bin uuremote-viewer
X11 → default build. Hyprland → `--features wayland`. GNOME/KDE on Wayland → `--features wayland,portal`
(or advise the user to pick the "on Xorg" session at the login screen, which is the best-supported path).
2. Install dependencies and build (section 3). Copy the binary: `install -Dm755 target/release/uuremote-server ~/.local/bin/uuremote-server`.
From a release tarball run its `./install.sh` as the desktop user instead: it installs into `~/.local`, writes the user unit
(keeps an existing one) and installs FFmpeg with libx264 via sudo apt/pacman when missing (Fedora/openSUSE: prints the command).
The .deb depends on `ffmpeg`. Without FFmpeg the viewer waits on 正在传输画面; the host checks at startup and on each desktop offer, logs an error and tells the desktop user (freedesktop notification, else opens its window with a red line; `assist::show_problem`).
3. **Login (needs the human).** Run `uuremote-server login` inside the graphical session. A GTK window shows a QR
code; the user scans it with the UU Remote mobile app and confirms. Without a display use
`uuremote-server login --no-gui` (terminal QR). Credentials are written to `~/.config/uuremote/config.json`
@@ -114,14 +117,17 @@ viewer does not reconnect them automatically.
| Item | Meaning |
|---|---|
| `~/.config/uuremote/config.json` | user_id, device_id, client_id, system_id, machine_guid, token, csrf; optional `sign_key`, `ffmpeg_root`. `$UU_CONFIG` overrides the path |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent |
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent; optional `video_encoder` (`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by `set-encoder` / `set-codec` (0600, merge write). Non-`auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`. `set-encoder` and `set-codec` both send `SIGUSR2` to the pid in `host.pid` (same binary). Live desktop streams restart the encoder (`EncoderTask::restart`, sequence kept, first frame IDR) without dropping the peer. Codec preference is logged and applies on the next desktop stream. `SIGUSR2` does not re-probe. Hand edits: `kill -USR2 $(cat ~/.config/uuremote/host.pid)` |
| `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) |
| `UU_X11_MULTISCREEN=1`, `UU_X11_OUTPUT` | X11: advertise each RandR monitor (`xrandr --listmonitors`, read once at start; primary or `UU_X11_OUTPUT` is id 0) through the same screen-switch path as `UU_WAYLAND_MULTISCREEN` (`wayland::outputs`/`select`). x11grab reads `display+x,y` at the monitor size, XTest/uinput absolute input adds the monitor offset, the in-process engine and `desktop_mode` resize are skipped (分辨率 scales). Needs two or more monitors |
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
| `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset: NVENC→CPU only if `/proc/driver/nvidia/version` or `/dev/nvidia0` exists, else CPU (#10) |
| `UU_VIDEO_CODEC=h264` | force H.264 even when the viewer negotiated H.265 (default: H.265 when both sides support it) |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset/`auto`: background probe, one synthetic IDR per candidate, 3 s each. While #33 is open, auto is NVENC then CPU when `/proc/driver/nvidia/version` or `/dev/nvidia0` exists; with no NVIDIA the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the legacy rule (NVENC if NVIDIA is present, else CPU). On `--features inproc-av`, a process-only failure of NVENC when the native engine would try it first on X11 is `native_unprobed` and keeps that legacy NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence (`/proc/driver/nvidia/version` or `/dev/nvidia0`) matches the report. A later desktop connection whose presence differs treats the report as stale and starts one background re-probe (`warm_auto_probe`, non-blocking, one at a time) and still uses the cached encoder. A hardware-candidate failure (NVENC failed, chosen CPU) is cached for 10 minutes (`PROBE_FAILURE_TTL`); the next desktop connection after that starts the same re-probe and still uses the cached encoder. Explicit `cpu` / `vaapi` / `nvenc` (setting file or `UU_VIDEO_ENCODER`) does not start the probe. A later success selects NVENC again; another failure restarts the 10 minutes. `native_unprobed` is not a failure cache. Ignored when `host_settings.json` `video_encoder` is not `auto`. Explicit `vaapi` with 真彩 encodes 4:2:0 and reports that in CaptureSettingSync (field 3). VAAPI is not an auto candidate until #33 |
| `UU_VIDEO_CODEC=h264` | force H.264 even when the viewer negotiated H.265 (default: H.265 when both sides support it and the encoder is hardware). Same precedence as the encoder: setting file, then this variable, then auto |
| `UU_FFMPEG_ROOT` | FFmpeg prefix (`bin/ffmpeg`, libs in `lib/x86_64-linux-gnu`) |
| `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) |
| `UU_LOGIN_WINDOW=0` | don't auto-open the login window |
@@ -130,8 +136,9 @@ viewer does not reconnect them automatically.
| `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default |
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. The config is re-read
every 60 s.
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. `config.json` is parsed once
(`config::file()`); only a `LoginExpired` room answer re-reads it from disk (`config::read_fresh()`) before waiting
for a new QR login.
## 6. Code map
@@ -162,8 +169,7 @@ every 60 s.
| `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher |
| `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) |
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoders,
default codec, sign-in/service state; booleans and names only), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoder and codec with source, sign-in/service state; booleans and names only), `set-encoder auto|cpu|vaapi|nvenc` and `set-codec auto|h264|h265` (both notify a running host with SIGUSR2; live encoder switch, negotiated codec unchanged, codec preference on the next desktop stream; illegal values exit 2), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
`desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_CHROMA=444` 真彩; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`,
`portal-acceptance`, `help`. Unknown arguments exit with code 2. Builds up to v0.1.0 did **not** reject them and
started a second full host server instead, so check that a subcommand exists in the binary you run.
@@ -275,10 +281,12 @@ started a second full host server instead, so check that a subcommand exists in
- Update README.md / README.en.md when user-visible features or limitations change, and add
`docs/release-notes/<tag>.md` before tagging a release.
### VAAPI (opt-in / 显式启用)
### VAAPI
`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to
`/dev/dri/renderD128` (render-node permissions required). No automatic VAAPI selection.
`UU_VIDEO_ENCODER=vaapi` or `set-encoder vaapi` selects Intel/AMD H.264 VAAPI explicitly.
`UU_VAAPI_DEVICE` defaults to `/dev/dri/renderD128` (render-node permissions required).
Auto is NVENC then CPU when an NVIDIA driver is present, otherwise CPU. VAAPI is not an
auto candidate until #33.
The FFmpeg process pipeline uploads NV12 frames to a VAAPI frame pool. With `--features inproc-av` on X11, VAAPI
H.264/HEVC Main runs in process: a DRI3 DMA-BUF of the root (XShm upload without DRI3) goes through VPP to NV12
and VCN, with SPS/PPS(/VPS) and slice headers packed by the host as radeonsi (Mesa 26) needs; parameters follow
Generated
+1 -3
View File
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.2.22"
version = "0.2.33"
dependencies = [
"async-trait",
"base64 0.22.1",
@@ -3075,8 +3075,6 @@ dependencies = [
[[package]]
name = "webrtc-srtp"
version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "383b0f0f73ee6cce396bdbc4d54ec661861a59eae9fc988914c1a8d82c5ac272"
dependencies = [
"aead",
"aes",
+3 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.2.22"
version = "0.2.33"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
@@ -64,6 +64,8 @@ sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
cc = "1.0"
[patch.crates-io]
# RTP rollover counter survives delayed NACK retransmissions (vendor/webrtc-srtp/PATCHES.md).
webrtc-srtp = { path = "vendor/webrtc-srtp" }
webrtc-dtls = { path = "vendor/webrtc-dtls" }
# Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs).
webrtc = { path = "vendor/webrtc" }
+60 -13
View File
@@ -46,7 +46,7 @@
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; "other resolutions" are scaled by the encoder, the host monitor is left untouched |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder |
| Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete |
| Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename |
@@ -94,7 +94,7 @@ Existing screen-off and lock settings remain unchanged. Only capture recovery in
Locked black video requires FFmpeg's libx264/libx265 encoder for the negotiated H.264/H.265 codec; hardware encoding support alone does not satisfy this dependency. Encoder failures are logged explicitly. Synthetic video does not change capture permissions or advertised monitor dimensions. It pauses on unlock or unknown lock state, ends when capture is ready/rejected or the connection closes, and then hands the same video track to real capture. See [#29](../../issues/29) and [#34](../../pull/34) for the controlled experiment and validation scope.
The native Wayland backend needs `wlr-output-power-management` from the compositor to wake a turned-off screen; without it only wake is unavailable — capture and encoding are unaffected.
The native Wayland backend needs `wlr-output-power-management` from the compositor to wake a turned-off screen; without it only wake is unavailable — capture and encoding are unaffected. Display-wake failures at video startup or during streaming are logged and retried at the next interval without ending the video stream; capture, encoder and send errors retain their existing handling.
Native Wayland experiments: `UU_WAYLAND_PIPELINE=0` disables pipelining for comparison.
`UU_WAYLAND_DMABUF=1` explicitly tries dma-buf → GBM CPU mapping (off by default;
@@ -104,19 +104,21 @@ failure falls back to SHM. The virgl VM verified fallback only: successful impor
mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI;
`UU_VIDEO_ENCODER=vaapi` still uploads CPU frames through FFmpeg.
### Hyprland monitor switching (experimental)
### Monitor switching (experimental)
Native Wayland absolute pointer motion now targets the captured output by default, fixing multi-monitor click offsets. uinput may still handle keyboard, buttons and relative motion.
Set `UU_WAYLAND_MULTISCREEN=1` to select physical monitors from the phone client. `UU_WAYLAND_OUTPUT` chooses the initial output. Capture and absolute pointer targeting switch together across different resolutions, scales and desktop positions.
X11 sessions send all monitors as one combined picture by default. With `UU_X11_MULTISCREEN=1` the host lists the monitors from `xrandr --listmonitors`; the viewer selects one, only that region is captured, and absolute pointer positions are offset to that monitor. The primary monitor is the default; `UU_X11_OUTPUT` picks another (e.g. `HDMI-1`). The layout is read when the host starts; restart the service after changing it. In this mode the viewer's resolution setting scales the stream instead of changing the display mode. Experimental: unit tests and Xvfb virtual monitors only, not yet accepted with the official clients.
Switching reuses one video track and pauses input until the new source sends a frame. Capture/encoder failure or a first-frame timeout requests restoration of the previous source. The inventory uses `hyprctl` and supports unrotated outputs; restart the host after monitor hotplug or layout changes. Phone-side switching and clicks were tested on Omarchy / Hyprland with 2560×1440 at 125% and 1920×1080 at 133.33%.
## Not implemented / not supported
| Feature | Status |
|---|---|
| Switching between multiple monitors | Experimental on native Hyprland Wayland; see above |
| Switching between multiple monitors | Experimental on native Hyprland Wayland and on X11 (`UU_X11_MULTISCREEN=1`); see above |
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; `inproc-av` native NVENC encodes H.264 High 4:4:4 / HEVC FRExt; VAAPI stays 4:2:0 and reports that to the client |
| HDR | Not implemented |
| Super screen / virtual display | Not implemented |
@@ -139,16 +141,21 @@ uuremote-server login # scan the QR code with
systemctl --user enable --now uuremote-native.service # start with the graphical session
```
The deb installs the binaries, plugins, a systemd user unit and menu entries; uinput access stays opt-in (step 5).
The deb installs the binaries, plugins, a systemd user unit and menu entries, and pulls in FFmpeg as a dependency; uinput access stays opt-in (step 5).
GNOME and KDE pass the display environment to the unit; on desktops that don't (e.g. Xfce) add `DISPLAY` as in step 4.
**Other distributions**: download `uu-remote-linux-<version>-x86_64-linux.tar.gz` (ARM64: `aarch64-linux`) from [Releases](../../releases/latest), extract it, then:
**Other distributions**: download `uu-remote-linux-<version>-x86_64-linux.tar.gz` (ARM64: `aarch64-linux`) from [Releases](../../releases/latest), extract it, then run as your desktop user (not root):
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
cd uu-remote-linux-<version>-x86_64-linux
./install.sh # --yes: don't ask; --no-ffmpeg: check only
```
The script installs the binaries and plugins under `~/.local`, writes the systemd user unit (an existing one is kept) and checks
FFmpeg with libx264 (without it the viewer stays on 正在传输画面). A missing FFmpeg is installed through sudo with apt or pacman;
Fedora needs RPM Fusion and openSUSE needs Packman first, and the script only prints the command instead of adding third-party repositories.
The host also checks FFmpeg at startup and on every desktop connection: when it is not runnable it logs an error and shows a desktop notification (without a notification daemon it opens its window with a red hint), at most every 5 minutes. Install it and reconnect; no restart is needed.
One package covers X11, wlroots compositors (Hyprland, Sway, niri) and GNOME/KDE Wayland: the backend is chosen from the
running session at startup, and the matching `libuu-*.so` is loaded only on Wayland, so X11 hosts need no Wayland libraries.
@@ -330,13 +337,18 @@ Common environment variables:
|---|---|
| `UU_CONFIG` | Config file path (default `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless) |
| `UU_DESKTOP_RESIZE=0` | on X11, keep the desktop resolution and only scale the encoded stream when the viewer picks a resolution |
| `UU_NVENC_RGB=0` / `=1` | NVENC encodes BGRA directly (saves CPU). Off by default when a monitor is connected to the NVIDIA card (slower when the desktop is composited on the same GPU); `0` forces off, `1` forces on |
| `UU_WAYLAND_MULTISCREEN=1` | Enable Hyprland physical monitor switching (off by default) |
| `UU_WAYLAND_OUTPUT` | Initial native Wayland output name, e.g. `HDMI-A-1` |
| `UU_X11_MULTISCREEN=1` | Select and capture X11 monitors separately (experimental, off by default, needs `xrandr`) |
| `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) |
| `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` |
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset: NVENC only when an NVIDIA driver is loaded, else CPU |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 |
| `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution |
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default is 100-500 kbit, set `1000` when high-resolution keyframes blur and flicker once per GOP (#103) |
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
@@ -347,7 +359,27 @@ Common environment variables:
| `UU_USE_PROXY=1` | Honor HTTP/SOCKS proxy environment variables; by default proxies are ignored and NetEase servers are reached directly |
Host settings such as "lock after remote session" and "mute host" are stored in
`~/.config/uuremote/host_settings.json`.
`~/.config/uuremote/host_settings.json`. The same file stores `video_encoder`
(`auto`/`cpu`/`vaapi`/`nvenc`) and `video_codec` (`auto`/`h264`/`h265`), written by
`uuremote-server set-encoder` and `uuremote-server set-codec` (illegal arguments exit 2).
A value other than `auto` beats `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`; `auto` or a missing
field falls through to the environment, then to auto (NVENC then CPU when an NVIDIA driver
is loaded; CPU with no probe when it is not; codec stays H.265 on hardware and H.264 on CPU).
The probe runs in the background at startup and does not delay the first picture. A success
stays cached until the process exits, except when NVIDIA presence (`/proc/driver/nvidia/version`
or `/dev/nvidia0`) no longer matches the report: the next desktop connection then starts one
background re-probe (`warm_auto_probe`) and still uses the cached encoder until the new result
is stored. An NVENC failure is kept for 10 minutes, and the next desktop connection after that
starts the same background re-probe while still using the cached encoder. `set-encoder` and
`set-codec` both send `SIGUSR2` to the host in `host.pid` when that process is this program.
An encoder change switches each live desktop stream without disconnecting and keeps the codec
negotiated for that session. A failed start follows the existing fallback (in-process, then the
FFmpeg process, then CPU). After a hand edit, `kill -USR2 $(cat ~/.config/uuremote/host.pid)`
does the same. `SIGUSR2` does not re-probe. A codec change takes effect the next time a desktop
connection starts; the running host only logs it. Explicit `vaapi` with 真彩 stays on VAAPI,
encodes 4:2:0, and reports chroma 4:2:0 in CaptureSettingSync field 3. If the chosen encoder
cannot start, the stream falls back to CPU and logs a warning. VAAPI is not an auto candidate
until #33.
Custom bitrate follows the Mbps value selected in the client; for example, 1 Mbps sets an encoder cap of 1000 kbit/s.
@@ -425,10 +457,12 @@ AUD only at IRAPs and drops every other picture from the bitstream, so an AUD-ba
one "frame" and the IRAP gate then rejects all of them: the connection stalls at "transferring" while the host
sends about 12 kbit/s. `UU_VIDEO_CODEC=h265` selects H.265 explicitly for A/B diagnosis.
### VAAPI (opt-in / 显式启用)
### VAAPI
`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to
`/dev/dri/renderD128` (render-node permissions required). No automatic VAAPI selection.
`UU_VIDEO_ENCODER=vaapi` or `set-encoder vaapi` selects Intel/AMD H.264 VAAPI explicitly.
`UU_VAAPI_DEVICE` defaults to `/dev/dri/renderD128` (render-node permissions required).
`auto` is NVENC then CPU when an NVIDIA driver is present, and CPU otherwise. VAAPI is
selected only explicitly; putting it in auto waits on #33.
The FFmpeg process uploads NV12 frames to a VAAPI frame pool; a self-built `--features inproc-av`
binary instead runs VAAPI in process on X11 (a DRI3 DMA-BUF of the root window zero-copy, or XShm
upload without DRI3, then VPP to NV12 and VCN; H.264/HEVC).
@@ -537,6 +571,19 @@ GNOME-to-official-Mac bidirectional clipboard synchronization is still unverifie
- CLI: `connect DEVICE false - echo legacy [--view-only]` (desktop), `files DEVICE ls|get|put …`, `terminal DEVICE [SESSION]`,
`terminal-ui DEVICE NAME`, `portmap DEVICE LOCAL_PORT HOST PORT` (listens on 127.0.0.1 only), `power DEVICE reboot|shutdown`, `unbind DEVICE` (remove a device from the account; also under "More tools" in the launcher),
`assist CONNECT_ID` (the code is read from one stdin line, never an argument). See `uuremote-viewer --help`.
- **Secure `type` input** (inject keystrokes into an open desktop session — lock-screen PIN/password; never put secrets on argv):
```sh
# Preferred: open desktop via ui/connect first, then type (reuses the session; does not kick the live view)
UU_INPUT_ENV=UU_SECRET UU_SECRET='…' \
uuremote-viewer type DEVICE [--delay-ms 40] [--omit-last 1] [--snapshot /path/out.png]
# Or: printf '%s' '…' | uuremote-viewer type DEVICE
# Validate only, no network: uuremote-viewer type DEVICE --dry-run
# If no desktop viewer is running you must pass --new-session (opens a new peer and replaces any already-open desktop window; upstream #30)
```
Brace tokens: `{Enter}` `{Tab}` `{Esc}` `{Backspace}` `{Ctrl+Alt+Del}` …; `{{` is a literal `{`.
**Layout**: characters are mapped for **US QWERTY** only (non-US layouts may mistype symbols/letters).
**Windows numeric PIN**: Windows often submits automatically once enough digits are entered — usually no `{Enter}` needed. Use `--omit-last N` to omit the last N characters when you want to fill without signing in.
Logs and `--dry-run` report lengths/event counts only. When reusing a session, about one second after sending, a PNG frame is saved (default under `$XDG_RUNTIME_DIR/uu-viewer-type/`, mode 0600); the path is logged and printed as `snapshot=…`.
- Ctrl+Alt+F in the desktop window opens the files window on the same connection. `UU_VIEWER_AUDIO=0` disables sound,
`UU_VIEWER_CLIPBOARD=0` the clipboard, `UU_VIEWER_VIEW_ONLY=1` input; `UU_VIEWER_FFMPEG` selects the ffmpeg binary.
- Desktop offers H.264 / H.265; the host chooses the codec. `UU_VIEWER_CODEC=h264` limits both SDP and decoder capabilities to H.264.
+39 -14
View File
@@ -40,7 +40,7 @@
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
| 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;「其他分辨率」由编码器缩放,不改动主机显示器 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 |
| 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 |
@@ -85,24 +85,26 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。
原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。
原生 Wayland 后端需要合成器提供 `wlr-output-power-management` 才能唤醒已关闭的屏幕;缺少该协议不影响采集和编码。视频启动及运行期间,屏幕保活失败仅记录警告并在下轮重试,不终止视频;实际采集、编码或发送错误仍按原逻辑处理。
原生 Wayland 实验选项:`UU_WAYLAND_PIPELINE=0` 可关闭流水线做对照。`UU_WAYLAND_DMABUF=1` 显式尝试 dma-buf→GBM CPU 映射(默认关闭,需要运行时 libgbm;可用 `UU_WAYLAND_DMABUF_DEVICE` 指定 render node,默认 `/dev/dri/renderD128`)。仅支持显式线性修饰符、单平面 8-bit RGB,失败回退 SHM;virgl VM 中只验证了回退,成功导入/映射和硬件加速均未验证。这不是零拷贝 VAAPI 路径;选择 `UU_VIDEO_ENCODER=vaapi` 时仍由 FFmpeg 上传 CPU 帧。
首次连接时,桌面会弹窗请求「远程桌面 / 屏幕共享」授权,同意后会记住授权。
### Hyprland 多显示器切换(实验性)
### 多显示器切换(实验性)
原生 Wayland 的绝对鼠标定位默认绑定正在采集的输出,修复双屏桌面下的点击偏移。uinput 可继续用于键盘、按键和相对移动。
设置 `UU_WAYLAND_MULTISCREEN=1` 后,手机端可选择并切换物理显示器;`UU_WAYLAND_OUTPUT` 指定默认屏幕。画面与绝对鼠标定位同步切换,支持不同分辨率、缩放和桌面位置。
X11 会话默认把所有显示器拼成一张画面。设置 `UU_X11_MULTISCREEN=1` 后,主机按 `xrandr --listmonitors` 列出各个显示器,控制端可选择其中一块,只采集该区域,绝对鼠标坐标加上该屏幕在桌面中的偏移;默认屏幕为主显示器,`UU_X11_OUTPUT` 可指定其他屏幕(如 `HDMI-1`)。显示器布局在主机启动时读取,改动后需重启服务。此模式下控制端的「分辨率」改为缩放画面,不再修改显示模式。实验性:目前只有单元测试与 Xvfb 虚拟显示器实测,尚未经官方客户端实机验收。
切屏复用同一条视频轨道,过渡期间暂停输入,发送新屏首帧后恢复;采集或编码失败、等待首帧超时会请求恢复原屏。当前通过 `hyprctl` 枚举未旋转的显示器,显示器插拔或布局变化后需重启服务。已在 Omarchy / Hyprland 上用官方手机客户端实测 2560×1440(125%)与 1920×1080(133.33%)双屏切换及点击。
## 尚未实现 / 不支持
| 功能 | 状态 |
|---|---|
| 多显示器切换 | Hyprland 原生 Wayland 后端实验性支持,见上文 |
| 多显示器切换 | Hyprland 原生 Wayland 后端与 X11(`UU_X11_MULTISCREEN=1`)实验性支持,见上文 |
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;`inproc-av` 原生 NVENC 输出 H.264 High 4:4:4 / HEVC FRExt;VAAPI 管线仍为 4:2:0,并如实回报给客户端 |
| HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
@@ -125,16 +127,20 @@ uuremote-server login # 用 UU 远程 App 扫
systemctl --user enable --now uuremote-native.service # 随图形会话启动
```
deb 会安装程序、插件、用户级 systemd 服务和应用菜单图标;uinput 权限不会自动开启(见第 5 步)。
deb 会安装程序、插件、用户级 systemd 服务和应用菜单图标,并通过依赖自动装上 FFmpeg;uinput 权限不会自动开启(见第 5 步)。
GNOME / KDE 会把显示环境自动传给服务;Xfce 等不传的桌面需按第 4 步补 `DISPLAY`。
**其他发行版**:从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后:
**其他发行版**:从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后用普通桌面用户(不要 root)运行:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
install -Dm644 libuu-wayland.so libuu-portal.so -t ~/.local/lib/uu-remote-linux/
cd uu-remote-linux-<版本>-x86_64-linux
./install.sh # 加 --yes 不询问;--no-ffmpeg 只检查不安装
```
脚本把程序和插件装到 `~/.local`,写入用户级 systemd 服务(已有则保留),并检查 FFmpeg(需带 libx264,否则客户端会一直停在「正在传输画面」)。
缺 FFmpeg 时经 sudo 用 apt / pacman 安装;Fedora 需先启用 RPM Fusion,openSUSE 需 Packman 源,脚本只提示命令、不替你添加第三方源。
服务启动时和每次有人连接桌面时都会检查 FFmpeg:不可用就记 error,并弹桌面通知(没有通知服务时打开主窗口,顶部红字提示安装方法,最多每 5 分钟一次);装好后重新连接即可,不用重启服务。
同一个包支持 X11、Hyprland 等 wlroots 合成器和 GNOME/KDE Wayland:程序启动时按当前会话自动选择后端,只在 Wayland 会话里
才加载对应的 `libuu-*.so`,X11 用户不需要任何 Wayland 库。系统要求:
@@ -299,13 +305,18 @@ systemctl --user restart uuremote-native.service
|---|---|
| `UU_CONFIG` | 配置文件路径(默认 `~/.config/uuremote/config.json`) |
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) |
| `UU_DESKTOP_RESIZE=0` | X11 下控制端切换分辨率时不改桌面分辨率,只缩放编码画面 |
| `UU_NVENC_RGB=0` / `=1` | NVENC 直接编码 BGRA(省 CPU)。显示器接在 NVIDIA 卡上时默认关闭(同卡合成时直吃反而更慢),`0` 强制关,`1` 强制开 |
| `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) |
| `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` |
| `UU_X11_MULTISCREEN=1` | X11 下按显示器分别选择和采集(实验性,默认关闭,需要 `xrandr`) |
| `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
| `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` |
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置时检测到 NVIDIA 驱动才用 NVENC,否则用 CPU |
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto |
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认 100–500 kbit,1440p 等高分辨率下关键帧被压糊、按 GOP 周期闪烁时设 `1000`(#103) |
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
@@ -315,7 +326,7 @@ systemctl --user restart uuremote-native.service
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) |
| `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 |
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。同一文件里的 `video_encoder`(`auto`/`cpu`/`vaapi`/`nvenc`)和 `video_codec`(`auto`/`h264`/`h265`)用 `uuremote-server set-encoder`、`uuremote-server set-codec` 写入(非法参数退出码 2)。非 `auto` 的值优先于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`;`auto` 或留空则落到环境变量,再落到 auto(有 NVIDIA 时 NVENC 优先,失败再 CPU;没有 NVIDIA 时就是 CPU,不探测;codec 仍是硬件优先 H.265、CPU 用 H.264)。探测在启动时后台进行,不挡住第一路出图。成功结果缓存到进程退出,但 NVIDIA 是否存在(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)与报告不一致时,下一次桌面连接会在后台再探测一次(`warm_auto_probe`),这一路仍用缓存的编码器,直到新结果写入。NVENC 失败只缓存 10 分钟,到期后的桌面连接同样在后台再探测一次,这一路仍用当前结果。`set-encoder` 和 `set-codec` 写完后若 `host.pid` 指向正在运行的本程序,都会发 `SIGUSR2`:编码器变化时进行中的桌面流立刻换编码器(不断开,沿用本会话已协商的 codec;新编码器起不来时按进程内 → FFmpeg 进程 → CPU 回退)。手改文件后可 `kill -USR2 $(cat ~/.config/uuremote/host.pid)`。`SIGUSR2` 不重新探测。codec 偏好仍在下次建立桌面连接时生效(运行中的 host 只记日志,不重开编码)。显式 `vaapi` 请求真彩时仍用 VAAPI、编码 4:2:0,并在 CaptureSettingSync 的 field 3 回报 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。VAAPI 进入 auto 要等 #33。
自定义码率按客户端选择的 Mbps 生效,例如 1 Mbps 对应 1000 kbit/s 的编码上限。
@@ -381,11 +392,12 @@ HEVC 的访问单元按 RFC 7798 的图片边界切分,不依赖 AUD:`hevc_v
画面从码流里丢掉,读取端按 AUD 切分就会把整个 GOP 当成一帧,再被 IRAP 门控全部拒绝——对外表现为连接停在
「正在传输画面」,而主机侧只有约 12 kbit/s。`UU_VIDEO_CODEC=h265` 可显式选中 H.265,便于对照排查。
### VAAPI 硬件编码(显式启用)
### VAAPI 硬件编码
设置 `UU_VIDEO_ENCODER=vaapi` 使用 Intel/AMD H.264 VAAPI;`UU_VAAPI_DEVICE` 默认
`/dev/dri/renderD128`,运行用户需要 render 节点权限。不会自动选择 VAAPI;设备或驱动初始化
失败会明确警告并回退 libx264。外部 FFmpeg 先转 NV12 再上传硬件帧。
`UU_VIDEO_ENCODER=vaapi` 或 `set-encoder vaapi` 显式选择 Intel/AMD H.264 VAAPI。
`UU_VAAPI_DEVICE` 默认 `/dev/dri/renderD128`,运行用户需要 render 节点权限。
`auto` 有 NVIDIA 驱动时是 NVENC → CPU,没有 NVIDIA 时是 CPU。VAAPI 只通过显式选择启用,进入 auto 要等 #33。
设备或驱动初始化失败会明确警告并回退 libx264。外部 FFmpeg 先转 NV12 再上传硬件帧。
VBR 使用控制端码率预设及 CQ 对应的最小 QP,无 B 帧、async depth=1,并保留现有 GOP/VFR 规则。
Intel 核显(UHD 770,iHD 驱动)已实机验收:默认的外部 FFmpeg 管线用官方 Mac 控制端测试了各档画质、帧率、缩放和重连,全程硬件编码、无回退,CPU 占用比 libx264 低约 40%(该数字为 FFmpeg 进程管线时代的测量)。AMD 核显已在**进程内原生引擎**上实机验收(`--features inproc-av`):官方 Mac 客户端的端到端会话在 HawkPoint(Mesa 26.2.3)与 Cezanne(Mesa 26.2.5)上通过验收(HEVC,含画质档、帧率、缩放);Cezanne 上另以探测验证了 H.264 与两条采集路径——XShm 上传(码流可解码、画面正确)与 DRI3 DMA-BUF 零拷贝导入。同机实测(1920×1200@60,Cezanne iGPU + RTX 3050 Ti 双显卡):进程内 VAAPI 每帧编码 CPU 约为 libx264(FFmpeg 管线 superfast)的 **1/12**、进程内 NVENC 的 **1/5**;外部 FFmpeg 进程管线(预编译包使用)在 AMD 上未单独验证。
@@ -484,6 +496,19 @@ GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不
- 命令行:`connect DEVICE false - echo legacy [--view-only]`(桌面)、`files DEVICE ls|get|put …`、`terminal DEVICE [SESSION]`、
`terminal-ui DEVICE NAME`、`portmap DEVICE LOCAL_PORT HOST PORT`(只监听 127.0.0.1)、`power DEVICE reboot|shutdown`、`unbind DEVICE`(从账号删除设备,启动窗口「更多工具」里也有)、
`assist CONNECT_ID`(验证码从 stdin 读取一行,不能作为参数传入)。`uuremote-viewer --help` 查看全部参数。
- **安全输入 `type`**(向已打开的桌面会话注入键盘,适合锁屏 PIN / 密码;文本永不进 argv):
```sh
# 推荐:先 ui/connect 打开桌面,再 type(复用会话,不顶掉当前画面)
UU_INPUT_ENV=UU_SECRET UU_SECRET='……' \
uuremote-viewer type DEVICE [--delay-ms 40] [--omit-last 1] [--snapshot /path/out.png]
# 或:printf '%s' '……' | uuremote-viewer type DEVICE
# 只检查、不连网:uuremote-viewer type DEVICE --dry-run
# 没有正在运行的桌面会话时必须显式:--new-session(会新开连接,并顶掉已打开的桌面窗口,见上游 #30)
```
特殊键用花括号:`{Enter}` `{Tab}` `{Esc}` `{Backspace}` `{Ctrl+Alt+Del}` 等;`{{` 表示字面 `{`。
**布局**:字符按 **US QWERTY** 物理键位映射(非美式布局的符号/字母可能对不上)。
**Windows 数字 PIN**:输满位数后系统常会自动提交,一般不必再发 `{Enter}`;若只想填入、不登录,用 `--omit-last N` 省略最后 N 个字符。
日志与 `--dry-run` 输出只含长度/事件数,不含明文。复用会话时,发送约 1 秒后会保存一帧 PNG(默认写在 `$XDG_RUNTIME_DIR/uu-viewer-type/`,权限 0600),路径打在日志并打印 `snapshot=…`。
- 桌面窗口中按 Ctrl+Alt+F 打开文件窗口(复用同一连接)。`UU_VIEWER_AUDIO=0` 关闭声音,`UU_VIEWER_CLIPBOARD=0` 关闭剪贴板,
`UU_VIEWER_VIEW_ONLY=1` 只看不控,`UU_VIEWER_FFMPEG` 指定 ffmpeg 路径。
- 桌面同时提供 H.264 / H.265,由主机协商选择;`UU_VIEWER_CODEC=h264` 将 SDP 和解码能力限制为 H.264。
+91 -2
View File
@@ -57,6 +57,10 @@ static int suppress_tray;
static int cur_verify, cur_refresh, cur_has_custom;
static char current_id[64], current_code[64];
static int code_visible = 1, suppress_switch, start_hidden, close_hides;
// A problem only the person at the desktop can fix (e.g. FFmpeg missing): red line at the top.
static GtkWidget *problem_label;
static gchar *problem_text;
static pthread_mutex_t problem_lock = PTHREAD_MUTEX_INITIALIZER;
static GtkWidget *label(const char *text, const char *cls) {
GtkWidget *l = gtk_label_new(text);
@@ -305,6 +309,32 @@ static void on_status_menu(GtkStatusIcon *i, guint button, guint time, gpointer
(void)i; (void)button; (void)time; (void)d;
gtk_menu_popup_at_pointer(GTK_MENU(tray_menu), NULL);
}
// Monochrome tray icon that follows light/dark panels: GTK and the GNOME AppIndicator extension
// recolor "-symbolic" names, KDE recolors the ColorScheme-Text class. Installed into the user's
// hicolor theme (found by every panel's default lookup) and also offered as the icon theme path,
// so it needs no package install. KDE tries dash-trimmed names ("uu-remote-linux") in each theme
// before the next one, so the name must not trim into the colored app icon (#87).
static const char TRAY_ICON_NAME[] = "uuremote-tray-symbolic";
static const char TRAY_ICON_SVG[] =
"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\">"
"<style id=\"current-color-scheme\">.ColorScheme-Text{color:#232629}</style>"
"<path class=\"ColorScheme-Text\" fill=\"currentColor\" fill-rule=\"evenodd\" d=\"M2.5 2h11A1.5 1.5 0 0 1 15 3.5v7a1.5 1.5 0 0 1-1.5 1.5h-11"
"A1.5 1.5 0 0 1 1 10.5v-7A1.5 1.5 0 0 1 2.5 2zm0 1.5v7h11v-7z\"/>"
"<path class=\"ColorScheme-Text\" fill=\"currentColor\" d=\"M7.25 12h1.5v1.5H11a.75.75 0 0 1 0 1.5H5a.75.75 0 0 1 0-1.5h2.25z"
"M11.5 4.5v4l-1.35-1.35-3.1 3.1-1.2-1.2 3.1-3.1L7.5 4.5z\"/></svg>\n";
// Returns the icon theme root holding the icon ($XDG_DATA_HOME/icons), or NULL.
static gchar *write_tray_icon(void) {
gchar *root = g_build_filename(g_get_user_data_dir(), "icons", NULL);
gchar *apps = g_build_filename(root, "hicolor", "scalable", "apps", NULL);
gchar *file = g_strconcat(TRAY_ICON_NAME, ".svg", NULL);
gchar *path = g_build_filename(apps, file, NULL), *current = NULL;
// Rewriting an unchanged file would only make icon caches rescan.
int ok = g_file_get_contents(path, &current, NULL, NULL) && strcmp(current, TRAY_ICON_SVG) == 0;
if (!ok) ok = g_mkdir_with_parents(apps, 0755) == 0 && g_file_set_contents(path, TRAY_ICON_SVG, -1, NULL);
g_free(apps); g_free(file); g_free(path); g_free(current);
if (!ok) { g_free(root); return NULL; }
return root;
}
static void build_tray(void) {
tray_menu = gtk_menu_new();
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口");
@@ -318,7 +348,10 @@ static void build_tray(void) {
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new());
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), quit);
gtk_widget_show_all(tray_menu);
const char *icon = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
gchar *icon_path = write_tray_icon();
if (icon_path) gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), icon_path);
const char *fallback = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
const char *icon = icon_path ? TRAY_ICON_NAME : fallback;
// StatusNotifierItem (GNOME AppIndicator extension, KDE): libayatana-appindicator3 / libappindicator3.
const char *libs[] = { "libayatana-appindicator3.so.1", "libappindicator3.so.1" };
@@ -329,8 +362,11 @@ static void build_tray(void) {
void (*set_status)(void *, int) = (void (*)(void *, int))dlsym(h, "app_indicator_set_status");
void (*set_menu)(void *, GtkMenu *) = (void (*)(void *, GtkMenu *))dlsym(h, "app_indicator_set_menu");
void (*set_title)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_title");
void (*set_theme_path)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_icon_theme_path");
if (ind_new && set_status && set_menu) {
void *ind = ind_new("uu-remote-linux", icon, 0 /* APPLICATION_STATUS */);
// Without a theme path the panel cannot find the cached icon; keep the installed one.
void *ind = ind_new("uu-remote-linux", set_theme_path ? icon : fallback, 0 /* APPLICATION_STATUS */);
if (icon_path && set_theme_path) set_theme_path(ind, icon_path);
if (set_title) set_title(ind, "UU 远程 Linux 主机");
set_menu(ind, GTK_MENU(tray_menu));
set_status(ind, 1 /* ACTIVE */);
@@ -367,6 +403,11 @@ static void build_window(void) {
GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(root), 24);
gtk_container_add(GTK_CONTAINER(window), root);
problem_label = label("", "status");
gtk_style_context_add_class(gtk_widget_get_style_context(problem_label), "error");
gtk_label_set_line_wrap(GTK_LABEL(problem_label), TRUE);
gtk_label_set_max_width_chars(GTK_LABEL(problem_label), 40);
gtk_box_pack_start(GTK_BOX(root), problem_label, FALSE, FALSE, 0);
GtkWidget *card = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
@@ -477,6 +518,10 @@ static void build_window(void) {
gtk_widget_set_visible(assist_card, show_assist);
gtk_widget_set_visible(hint_label, show_assist);
gtk_widget_set_visible(account_card, show_account);
pthread_mutex_lock(&problem_lock);
gtk_label_set_text(GTK_LABEL(problem_label), problem_text ? problem_text : "");
gtk_widget_set_visible(problem_label, problem_text != NULL);
pthread_mutex_unlock(&problem_lock);
if (!start_hidden) gtk_widget_show(window);
}
@@ -659,6 +704,50 @@ void uu_login_ui_offer_refresh(int visible) {
g_idle_add(apply_qr_refresh, GINT_TO_POINTER(visible != 0));
}
int uu_login_ui_take_refresh(void) { return atomic_exchange(&qr_refresh_requested, 0); }
static gboolean apply_problem(gpointer data) {
(void)data;
if (window && problem_label) {
pthread_mutex_lock(&problem_lock);
gtk_label_set_text(GTK_LABEL(problem_label), problem_text ? problem_text : "");
gtk_widget_set_visible(problem_label, problem_text != NULL);
pthread_mutex_unlock(&problem_lock);
}
return G_SOURCE_REMOVE;
}
// Freedesktop notification through the session bus (no GTK main loop needed). Returns 0 when delivered.
static int notify_desktop(const char *summary, const char *body) {
GDBusConnection *bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!bus) return -1;
GVariantBuilder actions, hints;
g_variant_builder_init(&actions, G_VARIANT_TYPE("as"));
g_variant_builder_init(&hints, G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(&hints, "{sv}", "urgency", g_variant_new_byte(2)); // critical: stays until dismissed
GVariant *reply = g_dbus_connection_call_sync(bus, "org.freedesktop.Notifications", "/org/freedesktop/Notifications",
"org.freedesktop.Notifications", "Notify",
g_variant_new("(susssasa{sv}i)", "UU 远程 Linux 主机", 0u, "uu-remote-linux", summary, body, &actions, &hints, -1),
G_VARIANT_TYPE("(u)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
g_object_unref(bus);
if (!reply) return -1;
g_variant_unref(reply);
return 0;
}
// text NULL clears the window line. notify: also tell the person now, by a desktop notification or,
// without a notification daemon (e.g. bare Xfce), by opening the host window that shows the line.
// Returns 0 notified, 1 window opened, -1 neither (no notify requested, or no daemon and no window).
int uu_ui_set_problem(const char *summary, const char *text, int notify) {
pthread_mutex_lock(&problem_lock);
g_free(problem_text);
problem_text = text ? g_strdup(text) : NULL;
pthread_mutex_unlock(&problem_lock);
int window_ready = ui_started && init_state == 1 && !atomic_load(&closed);
if (window_ready) g_idle_add(apply_problem, NULL);
if (!notify || !text) return -1;
if (notify_desktop(summary ? summary : "", text) == 0) return 0;
if (!window_ready) return -1;
uu_assist_ui_present();
return 1;
}
void uu_login_ui_set_done(const char *text) { uu_ui_set_user(text); }
int uu_login_ui_closed(void) { return atomic_load(&closed); }
void uu_login_ui_close(void) { uu_assist_ui_close(); }
+3 -1
View File
@@ -732,7 +732,9 @@ int vaapi_encode_frame(
rc.window_size = 1000;
rc.initial_qp = 28;
rc.min_qp = 16;
rc.max_qp = 44;
// The driver's VBR raises QP only up to max_qp; 44 blocked the capped presets from reaching
// the QP 51 hardware floor on hard content (2560x1600 testsrc2: 4.16 -> 2.60 Mbps, #33)
rc.max_qp = 51;
rc.rc_flags.bits.disable_frame_skip = 1; // a remote desktop must not drop frames silently
b.misc[b.misc_n++] = vaapi_create_misc_buffer(engine, VAEncMiscParameterTypeRateControl, &rc, sizeof(rc));
+13
View File
@@ -0,0 +1,13 @@
长时间连接后画面冻结的修复。/ Fixes video freezing after long sessions.
### 修复 / Fixed
- **控制端切到后台再恢复后画面冻结、延迟显示 0**(#83,感谢 @AYssu 定位并提供补丁):RTP 序号每 65536 包回绕一次;
回绕后如果控制端补要(NACK)回绕前的旧包,webrtc-srtp 0.12.0 会把加密状态退回旧值,之后的新包都用错误的回绕计数加密,
控制端全部认证失败,画面停住且不再恢复。现按 RFC 3711 附录 A 估算回绕计数,重传不再让状态倒退。加密算法和报文格式不变。
回归测试在原库上失败、修复后通过(AES-CM/HMAC 与 AES-GCM);报告者在 Windows 控制端实测后台放置恢复正常,跨过两次回绕。
- SRTP rollover counter no longer rewinds when a pre-wrap packet is retransmitted after the wrap (frozen video, #83).
### 下载 / Download
`uu-remote-linux_0.2.23_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.23-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.23`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
X11 下切换分辨率会真正修改桌面分辨率。/ On X11 the viewer's resolution choice now changes the desktop resolution.
### 新增 / Added
- **控制端切换分辨率时真正修改桌面分辨率**,与官方 Windows 被控端一致:以前「其他分辨率」只缩放编码画面,选小分辨率反而让字更小更糊。
现在 X11 下用 xrandr 切换主显示器模式,列表里没有的分辨率会自动添加;选「原始」或断开连接后恢复原分辨率。
已用官方 Mac 控制端在 GNOME(X11)上实测切换与恢复。设置 `UU_DESKTOP_RESIZE=0` 可回到只缩放画面的旧行为;Wayland 不变。
- On X11 the resolution choice switches the display mode via xrandr (adding the mode when missing) and restores it for
"original" or on disconnect, like the official Windows host. `UU_DESKTOP_RESIZE=0` restores encoder scaling.
### 修复 / Fixed
- **连接中桌面分辨率变化后画面中断**:以前会把采集失败当成编码器故障,逐个换编码器后停止推流。现在按新尺寸重新采集,鼠标坐标随之更新。
- A desktop resize during a session no longer stops the stream; capture restarts at the new size and pointer mapping follows.
### 下载 / Download
`uu-remote-linux_0.2.24_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.24-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.24`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+12
View File
@@ -0,0 +1,12 @@
托盘图标随深色/浅色模式自动变色。/ The tray icon now follows light and dark panels.
### 修复 / Fixed
- **深色模式下托盘图标看不清**(#87):托盘改用内置单色符号图标,GNOME(AppIndicator 扩展)和 KDE 会按面板主题自动着色,
tarball 安装也不用另装图标。旧版 AppIndicator 库或缓存目录不可写时沿用原图标。目前只经过 CI 编译,尚未在 KDE / GNOME 面板上实机确认。
- The tray uses a built-in monochrome symbolic icon (written to the user cache and offered as the indicator's icon theme
path) that GNOME's AppIndicator extension and KDE recolor for the panel theme. Built in CI; not yet checked on a real panel.
### 下载 / Download
`uu-remote-linux_0.2.25_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.25-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.25`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复 KDE 托盘图标显示为未知图标;显示器接在 NVIDIA 卡上时默认不再让 NVENC 直接编码 BGRA。/ Fixes the KDE tray icon; NVENC skips direct BGRA input when NVIDIA drives the display.
### 修复 / Fixed
- **KDE 托盘显示成未知(空白页)图标**(#87,v0.2.25 引入):单色托盘图标改名为 `uuremote-tray-symbolic`,写到 `~/.local/share/icons/hicolor`,
各家面板的默认图标查找都能找到,仍会随深色/浅色面板着色。已在 Plasma 6.7 / KF6 上用 KIconLoader 按 Plasma 的查找方式验证,Plasma 6.8 面板待报告者确认。
v0.2.25 留下的 `~/.cache/uu-remote-linux/icons` 不再使用,可以删除。
- **同一张 NVIDIA 卡负责显示时编码变慢**(#16):显示、采集、编码都在同一张 NVIDIA 卡上时,NVENC 直接编码 BGRA 反而比 CPU 转换慢
(RTX 5070 4K:探针 82.6 vs 98 fps)。现在只要有显示器接在 NVIDIA 卡上就改用 CPU 转换;核显接显示器的机器不变。`UU_NVENC_RGB=1` 强制直接编码,`=0` 强制 CPU 转换。
- The tray icon is installed as `uuremote-tray-symbolic` in the user hicolor theme, so KDE's default lookup finds it
(v0.2.25 showed the unknown icon on Plasma 6.8). NVENC no longer takes packed BGRA when a connected monitor hangs off
an NVIDIA card (slower when the desktop is composited on the encoding GPU); `UU_NVENC_RGB=1` forces it.
### 下载 / Download
`uu-remote-linux_0.2.26_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.26-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.26`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+26
View File
@@ -0,0 +1,26 @@
可手动选择视频编码器和 codec,auto 改为后台探测;Wayland 屏幕保活失败不再中断画面;viewer 新增安全输入 `type`。/ Encoder and codec settings, background auto probe, display-wake failures no longer stop video, and a secure `type` command in the viewer.
### 新增 / Added
- **编码器与 codec 设置**(#85 第①②步,#92、#93,感谢 @ferstar):`uuremote-server set-encoder auto|cpu|vaapi|nvenc`、
`uuremote-server set-codec auto|h264|h265` 写入 `~/.config/uuremote/host_settings.json`,优先级高于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`,
下次建立桌面连接时生效;`doctor` 显示来源和最终 codec。auto 在启动时后台探测(每个候选编码一帧合成画面,限时 3 秒,不挡第一路出图):
有 NVIDIA 时 NVENC → CPU,没有 NVIDIA 时直接用 CPU 不探测。NVENC 探测失败只缓存 10 分钟,之后的桌面连接会在后台重探;
NVIDIA 驱动或设备中途出现/消失也会重探。显式指定编码器时不探测。VAAPI 要等 #33 解决后才进入 auto。
- **viewer 安全输入 `uuremote-viewer type`**(#70,感谢 @212duo):向已打开的桌面会话注入键盘(锁屏 PIN / 密码),文本不进 argv,
日志只记长度;按 US QWERTY 键位映射。本机 IPC 用私有目录和对端 uid 校验。
- `set-encoder` / `set-codec` write the video settings to `host_settings.json`; auto now probes NVENC then CPU in the background
(CPU only without NVIDIA, NVENC failures retried after 10 minutes). The viewer gains `type`, a secure key-injection command that
reuses the open desktop session.
### 修复 / Fixed
- **Wayland 运行中屏幕保活失败会停掉视频**(#94、#95,感谢 @AYssu):启动时和每 30 秒的屏幕保活改为尽力而为,失败只记警告、下轮重试,
画面继续发送;采集、编码、发送错误仍按原逻辑处理。
- A failed display wake at stream start or during the 30-second refresh is logged and retried instead of ending the video.
### 验证范围 / Validation
单元测试与 CI(x86_64、arm64、Wayland、inproc-av、viewer)通过;以上改动尚未在报告者现场或 NVIDIA 机器上实机验收。
### 下载 / Download
`uu-remote-linux_0.2.27_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.27-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.27`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
tar 包新增 `install.sh`,缺 FFmpeg 时自动安装;宿主缺 FFmpeg 时弹桌面提示,不再让客户端一直停在「正在传输画面」。/ The tarball gains `install.sh`, which installs FFmpeg when missing; the host tells the desktop user when FFmpeg is missing.
### 新增 / Added
- **tar 包安装脚本 `install.sh`**:解压后用普通桌面用户运行 `./install.sh`。程序和插件装到 `~/.local`,写入用户级 systemd 服务(已有则保留),
并检查 FFmpeg(需带 libx264)。缺失时询问后经 sudo 用 apt / pacman 安装(`--yes` 不询问,`--no-ffmpeg` 只检查);Fedora 需先启用 RPM Fusion,
openSUSE 需 Packman 源,脚本只打印命令、不替你添加第三方源。.deb 包本来就依赖 `ffmpeg`,不受影响。
- **缺 FFmpeg 时的桌面提示**:宿主在启动时和每次有人连接桌面时检查 FFmpeg。不可用时记 error,弹出「无法传输远程画面」桌面通知并给出安装命令;
没有通知服务的桌面(如精简 Xfce)改为打开宿主窗口,顶部红字提示。最多每 5 分钟一次;装好后重新连接即可,不用重启服务。
- `install.sh` installs into `~/.local`, writes the systemd user unit and installs FFmpeg with libx264 through apt or pacman when missing.
The host checks FFmpeg at startup and on every desktop connection and shows a desktop notification (or opens its window) when it is missing.
### 验证范围 / Validation
`install.sh` 在 Debian 13(Xfce)上实测:卸掉 FFmpeg 后 `--yes` 自动装回;CI 在 Ubuntu 22.04 上做同样的测试。通知和窗口红字用测试程序在 Xfce 上实测
(有/无通知服务两种情况);宿主内的完整流程只有编译与 CI 覆盖。
### 下载 / Download
`uu-remote-linux_0.2.28_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.28-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.28`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+22
View File
@@ -0,0 +1,22 @@
运行中切换编码器不再断开连接;X11 双屏/多屏可以只看其中一块屏幕(实验性)。/ Switch the encoder without dropping the session; select one monitor on X11 (experimental).
### 新增 / Added
- **运行中切换编码器(#85 第③步,#96,感谢 @ferstar)**:`uuremote-server set-encoder auto|cpu|vaapi|nvenc` 和 `set-codec` 写入设置后会通知正在运行的宿主(`SIGUSR2`),
已连接的桌面在下一帧边界换用新编码器,不用断开重连;VAAPI 不支持真彩 4:4:4 时自动降为 4:2:0 并通知客户端。只通知完整路径相同的宿主程序,
避免误杀旧版本宿主;没有通知到宿主时会打印提示(下次连接或重启服务后生效)。编码格式(H.264/H.265)偏好仍在下次连接时生效。
- **X11 单屏选择(#98,实验性)**:设置 `UU_X11_MULTISCREEN=1` 后,主机按 `xrandr --listmonitors` 列出各显示器,控制端可选择其中一块,只采集该区域,
鼠标绝对坐标加上该屏幕的偏移;默认主显示器,`UU_X11_OUTPUT` 可指定其他屏幕。显示器布局在启动时读取,改动后需重启服务;此模式下「分辨率」改为缩放画面。默认关闭,单屏用户不受影响。
- `set-encoder` / `set-codec` now switch a live desktop stream's encoder via `SIGUSR2` (same binary only) without reconnecting.
`UU_X11_MULTISCREEN=1` lets the viewer pick one X11 monitor (RandR monitors; capture and absolute input follow the selected monitor).
### 其他 / Other
- Issue 模板的诊断命令:保留连接状态和端口映射日志、过滤 WebRTC 内部噪音,并抹掉 IPv6 和 MAC 地址。
### 验证范围 / Validation
运行中切换编码器:单元测试与 CI,官方客户端下的切换时序尚未实机验证。X11 单屏选择:单元测试;在 Debian 13 上用两块 RandR 虚拟显示器实测,
鼠标落点与按区域采集正确;官方客户端在真实双屏上的切换尚未实机验证,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.29_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.29-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.29`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
先开端口映射再打开桌面时不再黑屏;VAAPI 低码率档能压到更低码率。/ Opening the desktop after a port mapping no longer shows a black screen; VAAPI low-bitrate presets go lower.
### 修复 / Fixed
- **端口映射后打开桌面黑屏(#99)**:已有端口映射连接时,Mac 控制端打开桌面不会新建连接,而是在原连接上发送 `capture_desktop`。
宿主现在会把这条连接转为桌面:画面、光标、剪贴板和会话计数都会启动,剪贴板能力也会重新通告。之后再打开新的桌面时,旧连接只停掉桌面,
端口映射照常可用。若此前 X11 分辨率有变化,会按新尺寸重建采集。限制:Wayland Portal 后端暂不支持这种方式;这条连接上没有声音。
- **VAAPI 低档码率(#33,#102,感谢 @ferstar)**:in-process VAAPI 编码的最大 QP 从 44 放宽到 51,复杂画面下低档可降到硬件能达到的最低码率;中高档不受影响。
- A viewer that opens the desktop on an existing port-mapping connection (`capture_desktop`) now gets video, cursor, clipboard and session handling on that connection;
a later desktop stops it without closing the port mappings. In-process VAAPI `max_qp` raised from 44 to 51.
### 验证范围 / Validation
#99:根因由报告者日志证实;修复只有单元测试与 CI,官方 Mac 控制端下尚未实机验证,欢迎反馈。#102:贡献者在 AMD 核显上实测(2560×1600 复杂画面最低档 4.16→2.60 Mbps,
中高档输出一致),我们这边仅 CI。
### 下载 / Download
`uu-remote-linux_0.2.30_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.30-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.30`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
NVENC 新增可选 VBV 缓冲开关,缓解高分辨率下关键帧按 GOP 周期闪烁。/ Opt-in NVENC VBV buffer for high-resolution keyframe pulsing.
### 新增 / Added
- **`UU_NVENC_BUFFER_MS`(#103,感谢 @zhl-HFUT 的分析)**:NVENC 的 VBV 缓冲(10–1000 ms,缓冲 = 码率上限 × 毫秒 / 1000),FFmpeg 进程管线和进程内引擎都生效。
默认缓冲(100–500 kbit)在 1440p 等高分辨率下会把关键帧压糊,画面按 GOP 周期“糊一下再变清”;遇到时可设 `UU_NVENC_BUFFER_MS=1000`。默认行为不变。
- New `UU_NVENC_BUFFER_MS` (10–1000 ms of the bitrate cap) for NVENC, applied to both the FFmpeg pipeline and the in-process engine. Default unchanged.
### 验证范围 / Validation
仅单元测试与 CI,尚未在 NVENC 实机上验证,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.31_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.31-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.31`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
修复端口映射在 ICE 瞬断恢复后被续房拆掉、信令卡死后长时间假在线,以及查看器 CLI 的指针偏移与滚轮。/ Fixes port-mapping teardown after ICE recovery, stalled signaling, and viewer CLI pointer/wheel input.
### 修复 / Fixed
- **ICE 瞬断恢复后连接被拆(#109,感谢 @sinoyster 的细致分析)**:WebRTC 的 ICE 状态回调读到的是占位 DTLS 对象,ICE `Disconnected → Connected` 恢复后 PeerConnection 停在 `New`,15 分钟续房把仍在使用的端口映射当成空闲,拆房并断开所有映射 TCP 流。现在恢复后会回到 `Connected`。
After a brief ICE drop the peer state settled on `New` instead of `Connected`, so the idle room renewal tore down live port-mapping streams.
- **信令投递卡住时心跳检测失效(#104,感谢 @RiverOnVenus)**:事件队列阻塞时 Engine.IO 超时不再执行,主机可能带着半关闭的连接“在线”数小时。现在有独立看门狗、发送超时和关闭超时。
Heartbeat detection keeps running when event delivery stalls; the host reconnects instead of staying half-online.
- **查看器 CLI**:16:10 等非 16:9 主机的指针按内容区域映射,不再内偏(#107,感谢 @liuyanghejerry);鼠标滚轮/触控板转发为滚动(#108,感谢 @liuyanghejerry)。
Viewer CLI: pointer mapped to the content rectangle of the padded canvas; mouse wheel forwarded.
### 验证范围 / Validation
单元测试与 CI;#109 的 ICE 恢复场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.32_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.32-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.32`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
修复 Wayland 锁屏或熄屏后,由工具连接(端口映射)升级的桌面视频结束后无法再次打开。/ Fixes a promoted tool connection whose desktop video could not be reopened after the screen locked or blanked.
### 修复 / Fixed
- **锁屏/熄屏后桌面无法重新打开(#114,感谢 @sinoyster 的完整报告)**:通过 capture_desktop 升级为桌面的工具连接上,若 Wayland 采集因锁屏或 DPMS 关闭而结束,再次 capture_desktop 不会重建视频,查看器只剩黑屏。现在会重新请求桌面并在原连接上重启视频,保留原输入租约。
On a tool connection promoted with capture_desktop, a desktop stream that ended (e.g. Wayland capture failing on lock/DPMS) is now restarted on the next capture_desktop, keeping the original input lease.
### 验证范围 / Validation
单元测试与 CI;#114 的锁屏场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.33_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.33-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.33`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+131
View File
@@ -0,0 +1,131 @@
#!/bin/sh
# Install uu-remote-linux from the release tarball for the current desktop user, and install FFmpeg
# (needed for desktop video) through the system package manager when it is missing.
# usage: ./install.sh [--yes] [--no-ffmpeg]
# --yes install FFmpeg without asking
# --no-ffmpeg only check FFmpeg, never install it
set -eu
assume_yes=0 ffmpeg_install=1
for arg in "$@"; do
case $arg in
-y|--yes) assume_yes=1 ;;
--no-ffmpeg) ffmpeg_install=0 ;;
-h|--help) sed -n '2,6p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
*) echo "unknown option: $arg (see --help)" >&2; exit 2 ;;
esac
done
if [ "$(id -u)" = 0 ]; then
echo "Run this as your desktop user, not root: the host is a per-user service. It asks for sudo only to install FFmpeg." >&2
exit 1
fi
src=$(cd "$(dirname "$0")" && pwd)
bin=$HOME/.local/bin lib=$HOME/.local/lib/uu-remote-linux share=$HOME/.local/share
unit_dir=${XDG_CONFIG_HOME:-$HOME/.config}/systemd/user
# A running binary cannot be overwritten in place ("text file busy"): copy, then rename.
put() { install -Dm"$1" "$2" "$3.new" && mv -f "$3.new" "$3"; }
[ -f "$src/uuremote-server" ] || { echo "uuremote-server not found next to install.sh" >&2; exit 1; }
put 755 "$src/uuremote-server" "$bin/uuremote-server"
[ -f "$src/uuremote-viewer" ] && put 755 "$src/uuremote-viewer" "$bin/uuremote-viewer"
for so in libuu-wayland.so libuu-portal.so; do
[ -f "$src/$so" ] && put 644 "$src/$so" "$lib/$so"
done
if [ -d "$src/contrib/desktop" ]; then
put 644 "$src/contrib/desktop/uu-remote-linux.svg" "$share/icons/hicolor/scalable/apps/uu-remote-linux.svg"
put 644 "$src/contrib/desktop/uu-remote-linux.desktop" "$share/applications/uu-remote-linux.desktop"
[ -f "$bin/uuremote-viewer" ] && put 644 "$src/contrib/desktop/uu-remote-linux-viewer.desktop" "$share/applications/uu-remote-linux-viewer.desktop"
fi
echo "Installed uuremote-server to $bin"
# Same unit as the .deb, pointing at ~/.local/bin. An existing unit is the user's: leave it alone.
if [ -f "$unit_dir/uuremote-native.service" ]; then
echo "Kept existing $unit_dir/uuremote-native.service"
else
mkdir -p "$unit_dir"
cat > "$unit_dir/uuremote-native.service" <<'UNIT'
[Unit]
Description=UU Remote Linux host (unofficial)
After=graphical-session.target
PartOf=graphical-session.target
[Service]
Environment=RUST_LOG=info
ExecStart=%h/.local/bin/uuremote-server
Restart=always
RestartSec=5
[Install]
WantedBy=graphical-session.target
UNIT
echo "Created $unit_dir/uuremote-native.service"
fi
if command -v systemctl >/dev/null 2>&1; then systemctl --user daemon-reload 2>/dev/null || true; fi
# FFmpeg with libx264 is required: without it the viewer waits on 正在传输画面 forever.
ffmpeg_ok() { command -v ffmpeg >/dev/null 2>&1 && ffmpeg -hide_banner -encoders 2>/dev/null | grep -qw libx264; }
ffmpeg_cmd=""
ffmpeg_note=""
if command -v apt-get >/dev/null 2>&1; then
ffmpeg_cmd="apt-get update && apt-get install -y ffmpeg"
elif command -v pacman >/dev/null 2>&1; then
ffmpeg_cmd="pacman -S --needed --noconfirm ffmpeg"
elif command -v dnf >/dev/null 2>&1; then
# Fedora's own ffmpeg-free has no libx264; the full build is in RPM Fusion, which we do not enable for you.
if dnf repolist --enabled 2>/dev/null | grep -qi rpmfusion-free; then
ffmpeg_cmd="dnf install -y --allowerasing ffmpeg"
else
ffmpeg_note="Enable RPM Fusion (https://rpmfusion.org/Configuration), then: sudo dnf install --allowerasing ffmpeg"
fi
elif command -v zypper >/dev/null 2>&1; then
ffmpeg_note="openSUSE's ffmpeg has no libx264; add the Packman repository, then: sudo zypper install ffmpeg"
else
ffmpeg_note="Install FFmpeg with libx264 from your distribution, or set \"ffmpeg_root\" in ~/.config/uuremote/config.json"
fi
ffmpeg_ready=1
if ffmpeg_ok; then
echo "FFmpeg with libx264: found"
else
if command -v ffmpeg >/dev/null 2>&1; then echo "FFmpeg is installed but has no libx264."; else echo "FFmpeg is not installed."; fi
if [ "$ffmpeg_install" = 1 ] && [ -n "$ffmpeg_cmd" ]; then
answer=n
if [ "$assume_yes" = 1 ]; then
answer=y
elif [ -t 0 ]; then
printf 'Install it now with: sudo sh -c "%s"? [Y/n] ' "$ffmpeg_cmd"
read -r answer || answer=n
case $answer in ""|y|Y|yes|YES) answer=y ;; esac
fi
if [ "$answer" = y ]; then
if [ "$(id -u)" != 0 ] && ! command -v sudo >/dev/null 2>&1; then
echo "sudo is not available; run as root: $ffmpeg_cmd" >&2
else
sudo sh -c "$ffmpeg_cmd" || echo "FFmpeg installation failed." >&2
fi
fi
fi
if ffmpeg_ok; then
echo "FFmpeg with libx264: installed"
else
ffmpeg_ready=0
if [ -n "$ffmpeg_cmd" ]; then echo "Install it with: sudo sh -c \"$ffmpeg_cmd\""; else echo "$ffmpeg_note"; fi
fi
fi
case ":$PATH:" in *":$bin:"*) ;; *) echo "Note: $bin is not on PATH; add it or call $bin/uuremote-server directly." ;; esac
cat <<NEXT
Next steps (as this user, inside the graphical session):
uuremote-server login # scan the QR code with the UU Remote app
systemctl --user enable --now uuremote-native.service # start with the graphical session
Desktops that do not export DISPLAY to systemd (e.g. Xfce) need a drop-in; see README step 4.
NEXT
if [ "$ffmpeg_ready" = 0 ]; then
echo "WARNING: desktop video will not start until FFmpeg with libx264 is installed." >&2
exit 1
fi
+14
View File
@@ -78,6 +78,20 @@ extern "C" {
fn uu_assist_ui_set(id: *const libc::c_char, code: *const libc::c_char, allowed: libc::c_int, verify: libc::c_int, refresh: libc::c_int, has_custom: libc::c_int);
fn uu_assist_ui_take_command(arg: *mut libc::c_char, len: libc::size_t) -> libc::c_int;
fn uu_assist_ui_close();
fn uu_ui_set_problem(summary: *const libc::c_char, text: *const libc::c_char, notify: libc::c_int) -> libc::c_int;
}
/// A problem only the person at the desktop can fix: a red line in the host window (`None` clears it)
/// and, with `notify`, a desktop notification, or the host window opened when no notification daemon
/// answers. Returns whether the person was told now.
pub fn show_problem(summary: &str, text: Option<&str>, notify: bool) -> bool {
#[cfg(uu_gtk)] {
let summary = std::ffi::CString::new(summary).unwrap_or_default();
let text = text.map(|t| std::ffi::CString::new(t).unwrap_or_default());
let text = text.as_ref().map_or(std::ptr::null(), |t| t.as_ptr());
unsafe { uu_ui_set_problem(summary.as_ptr(), text, i32::from(notify)) >= 0 }
}
#[cfg(not(uu_gtk))] { let _ = (summary, text, notify); false }
}
/// "243829726" -> "243 829 726", as the official client shows device IDs.
+18 -4
View File
@@ -46,14 +46,28 @@ unsafe fn x11_display_name() -> *const libc::c_char { b":0\0".as_ptr().cast() }
/// The X11 root can be resized while the host runs (RandR, xrdp reconnects); the
/// geometry read at startup then makes x11grab reject every new connection.
pub fn x11_resized() -> bool {
/// Re-reads the root size; None when the X11 engine is not in use or the query fails.
pub fn x11_size() -> Option<(u32, u32)> {
match unsafe { x11_refresh_geometry() } {
1 => true,
0 => false,
code => { log::warn!("X11 geometry query failed with code {code}"); false }
0 | 1 => x11_last_size(),
-1 => None,
code => { log::warn!("X11 geometry query failed with code {code}"); None }
}
}
/// The root size from the last refresh, without an X round trip (pointer mapping).
/// Display the X11 engine opened, once a capture has initialized it.
pub fn x11_display() -> Option<String> {
let name = unsafe { x11_display_name() };
if name.is_null() { None } else { Some(unsafe { std::ffi::CStr::from_ptr(name) }.to_string_lossy().into_owned()) }
}
pub fn x11_last_size() -> Option<(u32, u32)> {
let (mut w, mut h): (libc::c_int, libc::c_int) = (0, 0);
if unsafe { x11_get_dimensions(&mut w, &mut h) } != 0 || w <= 0 || h <= 0 { return None; }
Some((w as u32, h as u32))
}
pub struct ScreenCapture {
pub backend: crate::desktop_backend::DesktopBackend,
pub init_error: Option<String>,
+76 -10
View File
@@ -120,6 +120,7 @@ fn custom_bitrate_bps(value: u64) -> u32 {
bps.min(u64::from(u32::MAX)) as u32
}
#[cfg(test)]
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
handle_rpc_with_codecs(rpc, settings, native, true, false)
}
@@ -128,20 +129,50 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
/// lists H265 first in its offer) and a hardware encoder is selected. Software libx265 is about ten
/// times slower than libx264 (measured 15 vs 155 fps at 1080p on a 4-core ARM host, #59), so CPU
/// hosts default to H.264. UU_VIDEO_CODEC=h264 / h265 overrides.
pub fn preferred_codec(h264: bool, h265: bool) -> VideoCodec {
let forced = std::env::var("UU_VIDEO_CODEC").ok().map(|v| v.to_ascii_lowercase());
pick_codec(h264, h265, forced.as_deref(), crate::video::Encoder::requested() != crate::video::Encoder::Cpu)
#[cfg(test)]
fn test_selection() -> crate::video_select::Selection {
crate::video_select::resolve_pair(Some("auto"), None, Some("auto"), None, false, None)
}
fn pick_codec(h264: bool, h265: bool, forced: Option<&str>, hardware: bool) -> VideoCodec {
#[cfg(test)]
pub fn preferred_codec(h264: bool, h265: bool) -> VideoCodec {
preferred_codec_for(h264, h265, test_selection())
}
pub fn preferred_codec_for(h264: bool, h265: bool, selection: crate::video_select::Selection) -> VideoCodec {
pick_codec(h264, h265, crate::video_select::codec_force(selection.codec_pref), crate::video_select::hardware(selection.encoder))
}
pub(crate) fn pick_codec(h264: bool, h265: bool, forced: Option<&str>, hardware: bool) -> VideoCodec {
let wants_h265 = match forced { Some("h264") => false, Some("h265" | "hevc") => true, _ => hardware };
if h265 && (wants_h265 || !h264) { VideoCodec::H265 } else { VideoCodec::H264 }
}
#[cfg(test)]
pub fn handle_rpc_with_codecs(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool) -> Option<Vec<u8>> {
apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_available())
handle_rpc_for(rpc, settings, native, h264, h265, test_selection())
}
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, full_chroma: bool) -> Option<Vec<u8>> {
pub fn handle_rpc_for(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, selection: crate::video_select::Selection) -> Option<Vec<u8>> {
apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_for(selection.encoder), crate::video_select::codec_force(selection.codec_pref))
}
/// The resolution a capture/resolution RPC asks for, parsed like apply_rpc: X11 hosts apply it
/// to the display mode itself (desktop_mode), as the official Windows host changes its resolution.
pub fn requested_resolution(rpc: &[WireField]) -> Option<crate::desktop_mode::Request> {
use crate::desktop_mode::Request;
if let Some(request) = message(rpc, 2) {
let fields = decode_wire(request).ok()?;
if number(&fields, 10) == Some(3) { return Some(Request::Native); }
let (w, h) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6)))?;
Some(Request::Size(u32::try_from(w).ok()?, u32::try_from(h).ok()?))
} else if let Some(request) = message(rpc, 6) {
let fields = decode_wire(request).ok()?;
Some(Request::Size(u32::try_from(number(&fields, 1)?).ok()?, u32::try_from(number(&fields, 2)?).ok()?))
} else { None }
}
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), _h264: bool, h265: bool, full_chroma: bool, forced: Option<&str>) -> Option<Vec<u8>> {
let header = message(rpc, 1).unwrap_or(&[]);
let mut next = *settings.borrow();
if let Some(request) = message(rpc, 2) {
@@ -152,7 +183,9 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
// codec_type 13 (1 H264, 2 H265): like the official host (negotiateCodec), the host picks the
// codec from both capability lists; the Mac viewer sends its current codec (1 while receiving
// H.264), so only an explicit H.265 request switches, never one absent from the m-line.
if number(&fields, 13) == Some(2) && h265 { next.codec = VideoCodec::H265; }
// A forced codec (host_settings video_codec or UU_VIDEO_CODEC) wins over that switch, same
// rule as pick_codec at stream start: h264 stays H.264; auto/h265 still follow the request.
if number(&fields, 13) == Some(2) && h265 && forced != Some("h264") { next.codec = VideoCodec::H265; }
// Field 1 is the viewer's fps option index (1 = 30, 2 = 60, ...); 18 fpsCount is the frame rate.
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
@@ -318,12 +351,12 @@ mod tests {
let (tx, rx) = watch::channel(VideoSettings::default());
// Observed Mac viewer request with 真彩 on: field 7 = 3.
let request = rpc(5, 2, &[8, 2, 16, 4, 56, 3, 144, 1, 60]);
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, false).unwrap();
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, false, None).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_420);
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, true).unwrap();
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, true, None).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_444);
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_444));
apply_rpc(&decode_wire(&rpc(6, 2, &[56, 1])).unwrap(), &tx, (1920, 1080), true, false, true).unwrap();
apply_rpc(&decode_wire(&rpc(6, 2, &[56, 1])).unwrap(), &tx, (1920, 1080), true, false, true, None).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_420);
}
@@ -555,6 +588,39 @@ mod codec_tests {
assert_eq!(pick_codec(false, true, None, false), VideoCodec::H265);
assert_eq!(pick_codec(true, false, Some("h265"), true), VideoCodec::H264);
}
#[test]
fn forced_h264_ignores_later_h265_capture_request() {
let (tx, rx) = watch::channel(VideoSettings::default());
// Field 13 = 2 on a peer that negotiated both codecs.
let request = decode_wire(&[18, 2, 104, 2]).unwrap();
apply_rpc(&request, &tx, (1920, 1080), true, true, false, Some("h264")).unwrap();
assert_eq!(rx.borrow().codec, VideoCodec::H264);
apply_rpc(&request, &tx, (1920, 1080), true, true, false, None).unwrap();
assert_eq!(rx.borrow().codec, VideoCodec::H265);
let (tx, rx) = watch::channel(VideoSettings::default());
apply_rpc(&request, &tx, (1920, 1080), true, true, false, Some("h265")).unwrap();
assert_eq!(rx.borrow().codec, VideoCodec::H265);
}
#[test]
fn true_color_keeps_codec_and_vaapi_reports_420() {
// Field 7 = 3 (真彩). full_chroma false is the VAAPI 4:2:0 drop; true encodes 4:4:4.
let request = decode_wire(&[18, 2, 56, 3]).unwrap();
let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() });
apply_rpc(&request, &tx, (1920, 1080), true, true, true, None).unwrap();
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265));
// NVENC session (full chroma) that already chose H.265 stays H.265 when 真彩 is requested.
let nvenc = crate::video_select::resolve_pair(None, None, None, None, true, None);
assert_eq!(nvenc.encoder, crate::video::Encoder::Nvenc);
let (tx, rx) = watch::channel(VideoSettings { codec: preferred_codec_for(true, true, nvenc), ..VideoSettings::default() });
assert_eq!(rx.borrow().codec, VideoCodec::H265);
handle_rpc_for(&request, &tx, (1920, 1080), true, true, nvenc).unwrap();
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265));
let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() });
apply_rpc(&request, &tx, (1920, 1080), true, true, false, None).unwrap();
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_420, VideoCodec::H265));
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_420));
assert!(decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap().iter().all(|f| f.number != 13));
}
}
#[cfg(test)]
+7
View File
@@ -5,6 +5,13 @@
use std::path::PathBuf;
use std::sync::OnceLock;
/// Tests that point UU_CONFIG at a temp file must take this, or they race.
#[cfg(test)]
pub(crate) fn test_env_lock() -> &'static std::sync::Mutex<()> {
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
&LOCK
}
pub fn path() -> PathBuf {
if let Some(p) = std::env::var_os("UU_CONFIG") { return PathBuf::from(p); }
let base = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
+53
View File
@@ -215,3 +215,56 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
drop(lock);
}).await.expect("locked bootstrap/tool regression exceeded deadline");
}
#[tokio::test]
async fn capture_desktop_on_a_port_mapping_peer_promotes_it_once() {
tokio::time::timeout(Duration::from_secs(25), async {
let input = Arc::new(InputInjector::without_desktop());
let (host, mut viewer) = connect(input.clone(), false, None, &["CONTROL_DATA_CHANNEL", "FILE_DATA_CHANNEL"]).await;
let (requests, mut requested) = mpsc::unbounded_channel();
host.on_desktop_request(move || { let _ = requests.send(()); });
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
assert!(!host.role.is_desktop() && host.role.input().is_none());
// The Mac viewer opens the desktop on its existing port-mapping peer (#99).
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(5, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop());
assert!(host.role.input().is_some_and(|session| session.is_current()));
// CONTROL repeats the desktop initialization for the same viewer.
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
// The port-mapping session on this peer still answers.
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"still mapped")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
// A repeated capture_desktop does not ask again, and a later promote is a no-op.
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(6, 0, 3, &[8, 4])).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(7, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
assert!(requested.try_recv().is_err());
let lease = host.role.input().unwrap();
host.promote(None);
assert!(lease.is_current());
// Its video ended on its own (capture failed while locked, #114): capture_desktop restarts it
// on the same input lease.
let ended = tokio::spawn(async {});
*host.role.stream_task.lock().unwrap() = Some(ended.abort_handle());
ended.await.unwrap();
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(9, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && !host.role.stream_ended() && lease.is_current());
// A newer desktop demotes it; the port mapping stays, and capture_desktop promotes it again.
host.demote();
assert!(!host.role.is_desktop() && host.role.input().is_none());
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"after demotion")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(8, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && host.role.input().is_some_and(|session| session.is_current()));
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("capture_desktop promotion exceeded deadline");
}
+222
View File
@@ -0,0 +1,222 @@
//! X11 desktop resolution follows the viewer's 分辨率 choice, like the official Windows host:
//! the display mode itself changes (xrandr), not just the encoded size. The mode in use before
//! the first change is restored for 原始/follow-remote and when the last desktop stream ends.
//! Disable with UU_DESKTOP_RESIZE=0 (the viewer choice then scales the encoded stream instead).
use std::process::Command;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Request { Native, Size(u32, u32) }
struct Original { display: String, output: String, mode: String }
static ORIGINAL: Mutex<Option<Original>> = Mutex::new(None);
static STREAMS: AtomicUsize = AtomicUsize::new(0);
/// Upper bound per side (H.264 NVENC/VAAPI limit) and lower bound for a usable desktop.
const MAX_SIDE: u32 = 4096;
const MIN_SIZE: (u32, u32) = (640, 480);
pub fn enabled() -> bool { std::env::var("UU_DESKTOP_RESIZE").map_or(true, |v| v != "0") }
/// Keeps the changed mode while any desktop stream runs; the last one restores it.
pub struct StreamGuard;
impl StreamGuard {
pub fn new() -> Self { STREAMS.fetch_add(1, Ordering::SeqCst); Self }
}
impl Drop for StreamGuard {
fn drop(&mut self) {
if STREAMS.fetch_sub(1, Ordering::SeqCst) == 1 && ORIGINAL.lock().unwrap().is_some() {
// xrandr blocks; never run it on the async runtime thread dropping the stream.
std::thread::spawn(|| {
std::thread::sleep(std::time::Duration::from_secs(2));
if STREAMS.load(Ordering::SeqCst) == 0 { restore(); }
});
}
}
}
/// Applies the viewer's resolution request to the X11 display; returns the desktop size now in
/// use, or None when nothing changed hands (the caller keeps encoder scaling as the fallback).
pub fn apply(display: &str, request: Request) -> Option<(u32, u32)> {
match request {
Request::Native => { restore(); crate::capture::x11_size() },
Request::Size(w, h) => {
let target = fit(w, h)?;
match switch(display, target) {
Ok(()) => crate::capture::x11_size(),
Err(error) => { log::warn!("Desktop resolution change to {}x{} failed: {}", target.0, target.1, error); None },
}
},
}
}
/// Even sides within MIN_SIZE..=MAX_SIDE, keeping the aspect ratio when scaled down.
fn fit(w: u32, h: u32) -> Option<(u32, u32)> {
if w == 0 || h == 0 { return None; }
let scale = (f64::from(MAX_SIDE) / f64::from(w.max(h))).min(1.0);
let (w, h) = ((f64::from(w) * scale).round() as u32, (f64::from(h) * scale).round() as u32);
Some((w.max(MIN_SIZE.0) & !1, h.max(MIN_SIZE.1) & !1))
}
fn switch(display: &str, target: (u32, u32)) -> Result<(), String> {
let state = query(display)?;
if state.current == Some(target) { return Ok(()); }
{
let mut original = ORIGINAL.lock().unwrap();
if original.is_none() {
let mode = state.current_mode.clone().ok_or("current mode unknown")?;
log::info!("Desktop resolution: saving original mode {} on {}", mode, state.output);
*original = Some(Original { display: display.into(), output: state.output.clone(), mode });
}
}
let mode = match state.modes.iter().find(|(_, size)| *size == target) {
Some((name, _)) => name.clone(),
None => {
let (name, timings) = cvt_reduced(target.0, target.1);
// An existing mode of this name (earlier session) makes --newmode fail harmlessly.
let mut args = vec!["--newmode", name.as_str()];
args.extend(timings.iter().map(String::as_str));
let _ = xrandr(display, &args);
xrandr(display, &["--addmode", &state.output, &name])?;
name
},
};
set_mode(display, &state.output, &mode, target)?;
log::info!("Desktop resolution changed to {}x{} ({})", target.0, target.1, mode);
Ok(())
}
/// Restores the mode saved before the first change, if any.
pub fn restore() {
let Some(original) = ORIGINAL.lock().unwrap().take() else { return; };
let size = query(&original.display).ok().and_then(|state| state.modes.into_iter().find(|(name, _)| *name == original.mode).map(|(_, size)| size));
match size.ok_or_else(|| "original mode no longer listed".to_owned())
.and_then(|size| set_mode(&original.display, &original.output, &original.mode, size)) {
Ok(()) => log::info!("Desktop resolution restored to {}", original.mode),
Err(error) => log::warn!("Desktop resolution restore failed: {}", error),
}
let _ = crate::capture::x11_size();
}
/// GNOME/mutter may answer a mode list change by re-applying its preferred mode; set it again.
fn set_mode(display: &str, output: &str, mode: &str, size: (u32, u32)) -> Result<(), String> {
for _ in 0..3 {
xrandr(display, &["--output", output, "--mode", mode])?;
std::thread::sleep(std::time::Duration::from_millis(1500));
if query(display)?.current == Some(size) { return Ok(()); }
}
Err(format!("{output} did not keep {mode}"))
}
fn xrandr(display: &str, args: &[&str]) -> Result<String, String> {
let output = Command::new("xrandr").arg("--display").arg(display).args(args).output()
.map_err(|e| format!("xrandr unavailable: {}", e.kind()))?;
if !output.status.success() { return Err(format!("xrandr {} exited with {}", args.first().unwrap_or(&""), output.status)); }
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
struct State { output: String, current: Option<(u32, u32)>, current_mode: Option<String>, modes: Vec<(String, (u32, u32))> }
fn query(display: &str) -> Result<State, String> { parse(&xrandr(display, &["--query"])?).ok_or_else(|| "no connected output".into()) }
/// The primary connected output (else the first connected one with a mode) and its mode list.
fn parse(text: &str) -> Option<State> {
let mut outputs: Vec<(bool, State)> = Vec::new();
for line in text.lines() {
if let Some(rest) = line.strip_prefix(" ") {
let Some((_, state)) = outputs.last_mut() else { continue; };
let mut parts = rest.split_whitespace();
let Some(name) = parts.next() else { continue; };
let Some(size) = mode_size(name) else { continue; };
if parts.any(|rate| rate.contains('*')) { state.current = Some(size); state.current_mode = Some(name.into()); }
state.modes.push((name.into(), size));
} else if !line.starts_with(' ') {
let mut parts = line.split_whitespace();
let (Some(name), Some("connected")) = (parts.next(), parts.next()) else { outputs.push((false, State { output: String::new(), current: None, current_mode: None, modes: Vec::new() })); continue; };
let primary = line.contains(" connected primary ");
outputs.push((primary, State { output: name.into(), current: None, current_mode: None, modes: Vec::new() }));
}
}
let mut connected: Vec<(bool, State)> = outputs.into_iter().filter(|(_, s)| !s.output.is_empty() && s.current.is_some()).collect();
let index = connected.iter().position(|(primary, _)| *primary).unwrap_or(0);
(index < connected.len()).then(|| connected.swap_remove(index).1)
}
/// "1920x1080", "1920x1080R", "1920x1080_60.00", "1920x1080i" → (1920, 1080).
fn mode_size(name: &str) -> Option<(u32, u32)> {
let (w, rest) = name.split_once('x')?;
let h: String = rest.chars().take_while(char::is_ascii_digit).collect();
Some((w.parse().ok()?, h.parse().ok()?))
}
/// VESA CVT reduced-blanking (v1) timings: 60 Hz, or 30 Hz when 60 Hz exceeds an HDMI 2.0
/// pixel clock (virtual/forced connectors on integrated GPUs reject faster modes).
fn cvt_reduced(w: u32, h: u32) -> (String, Vec<String>) {
const H_BLANK: u32 = 160; const H_SYNC: u32 = 32; const H_FRONT: u32 = 48;
const V_FRONT: u32 = 3; const MIN_V_BACK: u32 = 6; const MIN_VBLANK_US: f64 = 460.0;
let v_sync = match (w * 3 == h * 4, w * 9 == h * 16, w * 10 == h * 16, w * 4 == h * 5, w * 9 == h * 15) {
(true, ..) => 4, (_, true, ..) => 5, (_, _, true, ..) => 6, (_, _, _, true, _) | (.., true) => 7, _ => 10,
};
let timing = |refresh: f64| {
let h_period = (1_000_000.0 / refresh - MIN_VBLANK_US) / f64::from(h);
let vbi = ((MIN_VBLANK_US / h_period) as u32 + 1).max(V_FRONT + v_sync + MIN_V_BACK);
let (total_h, total_v) = (w + H_BLANK, h + vbi);
let clock = (refresh * f64::from(total_h) * f64::from(total_v) / 1_000_000.0 / 0.25).floor() * 0.25;
(clock, total_h, total_v)
};
let (mut refresh, mut t) = (60, timing(60.0));
if t.0 > 590.0 { refresh = 30; t = timing(30.0); }
let (clock, total_h, total_v) = t;
let name = format!("{w}x{h}_{refresh}R");
let timings = [format!("{clock:.2}"), w.to_string(), (w + H_FRONT).to_string(), (w + H_FRONT + H_SYNC).to_string(), total_h.to_string(),
h.to_string(), (h + V_FRONT).to_string(), (h + V_FRONT + v_sync).to_string(), total_v.to_string(), "+hsync".into(), "-vsync".into()];
(name, timings.into())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reduced_blanking_matches_the_cvt_tool() {
// `cvt -r 1920 1080`: 138.50 1920 1968 2000 2080 1080 1083 1088 1111 +hsync -vsync
let (name, t) = cvt_reduced(1920, 1080);
assert_eq!(name, "1920x1080_60R");
assert_eq!(t.join(" "), "138.50 1920 1968 2000 2080 1080 1083 1088 1111 +hsync -vsync");
// `cvt -r 2560 1600`: 268.50 2560 2608 2640 2720 1600 1603 1609 1646
assert_eq!(cvt_reduced(2560, 1600).1.join(" "), "268.50 2560 2608 2640 2720 1600 1603 1609 1646 +hsync -vsync");
// 4K at 60 Hz needs 533 MHz (under the cap); a larger desktop drops to 30 Hz.
assert_eq!(cvt_reduced(3840, 2160).0, "3840x2160_60R");
assert_eq!(cvt_reduced(4096, 2560).0, "4096x2560_30R");
}
#[test]
fn requested_sizes_are_even_and_bounded() {
assert_eq!(fit(1280, 720), Some((1280, 720)));
assert_eq!(fit(4112, 2580), Some((4096, 2570)));
assert_eq!(fit(301, 201), Some((640, 480)));
assert_eq!(fit(0, 1080), None);
}
#[test]
fn parses_primary_output_modes_and_current_mode() {
let text = r"Screen 0: minimum 320 x 200, current 1920 x 1080, maximum 16384 x 16384
DP-1 disconnected (normal left inverted right x axis y axis)
HDMI-1 connected primary 1920x1080+0+0 (normal left inverted right x axis y axis) 0mm x 0mm
1024x768 60.00
3840x2160R 29.98
1920x1080R 59.93*+
HDMI-2 disconnected (normal left inverted right x axis y axis)
";
let state = parse(text).unwrap();
assert_eq!(state.output, "HDMI-1");
assert_eq!(state.current, Some((1920, 1080)));
assert_eq!(state.current_mode.as_deref(), Some("1920x1080R"));
assert_eq!(state.modes.len(), 3);
assert_eq!(state.modes[1], ("3840x2160R".to_owned(), (3840, 2160)));
assert!(parse("Screen 0: minimum 320 x 200\nDP-1 disconnected (normal)\n").is_none());
}
}
+25 -13
View File
@@ -16,6 +16,13 @@ fn env_state(name: &str) -> String {
fn line(key: &str, value: impl std::fmt::Display) { println!("{key:<22} {}", redact(&value.to_string())); }
fn format_probe(probe: &crate::video_select::ProbeReport) -> String {
let body = probe.order.iter().zip(probe.outcomes.iter())
.map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label()))
.collect::<Vec<_>>().join(" ");
if probe.expires_at.is_some() { format!("{body} (failure result, retried after 10 min)") } else { body }
}
fn glibc() -> String {
#[cfg(all(target_os = "linux", target_env = "gnu"))]
{
@@ -92,19 +99,24 @@ pub async fn run() -> Result<(), String> {
line("UU_INPUT_BACKEND", std::env::var("UU_INPUT_BACKEND").unwrap_or_else(|_| "auto".into()));
println!("-- video");
let encoder = crate::video::Encoder::requested();
line("encoder", format!("{encoder:?} (UU_VIDEO_ENCODER={})", std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "auto".into())));
line("default codec", format!("{:?}", crate::capture_setting::preferred_codec(true, true)));
let mut ffmpeg = crate::video::ffmpeg_command();
ffmpeg.args(["-hide_banner", "-encoders"]).kill_on_drop(true);
match tokio::time::timeout(std::time::Duration::from_secs(5), ffmpeg.output()).await {
Ok(Ok(output)) => {
let text = String::from_utf8_lossy(&output.stdout);
let found: Vec<&str> = ["libx264", "libx265", "h264_nvenc", "hevc_nvenc", "h264_vaapi", "hevc_vaapi"].into_iter()
.filter(|name| text.split_whitespace().any(|word| word == *name)).collect();
line("ffmpeg encoders", if found.is_empty() { "none of libx264/libx265/nvenc/vaapi".to_owned() } else { found.join(", ") });
}
_ => line("ffmpeg encoders", "ffmpeg not runnable (install ffmpeg or set ffmpeg_root)"),
let selection = crate::video_select::selection();
let env_enc = std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "unset".into());
let codec = match selection.codec_pref { crate::video_select::CodecPref::Auto => "auto", crate::video_select::CodecPref::H264 => "h264", crate::video_select::CodecPref::H265 => "h265" };
let probe_text = if selection.encoder_source == crate::video_select::Source::Auto {
format_probe(&crate::video::run_auto_probe().await)
} else {
crate::video_select::cached_probe().as_ref().map(format_probe).unwrap_or_else(|| "not yet run".to_owned())
};
let selection = if selection.encoder_source == crate::video_select::Source::Auto { crate::video_select::selection() } else { selection };
line("encoder probe", probe_text);
line("encoder", format!("{:?} (source={}; UU_VIDEO_ENCODER={env_enc})", selection.encoder, crate::video_select::encoder_source_label(selection.encoder_source)));
line("codec", format!("{codec} (source={})", crate::video_select::source_label(selection.codec_source)));
// Both codecs offered: hardware prefers H.265, CPU stays H.264 unless the preference forces one.
let resolved = crate::capture_setting::pick_codec(true, true, crate::video_select::codec_force(selection.codec_pref), crate::video_select::hardware(selection.encoder));
line("resolved codec", format!("{resolved:?}"));
match crate::video::ffmpeg_encoders().await {
Some(found) => line("ffmpeg encoders", if found.is_empty() { "none of libx264/libx265/nvenc/vaapi".to_owned() } else { found.join(", ") }),
None => line("ffmpeg encoders", "ffmpeg not runnable (install ffmpeg or set ffmpeg_root)"),
}
let mut version = crate::video::ffmpeg_command();
version.arg("-version").kill_on_drop(true);
+29 -1
View File
@@ -334,9 +334,12 @@ impl InputInjector {
let result=crate::wayland::move_pointer(x,y,false);
if result!=-2 { return result; }
}
// X11 multi-screen: the point is inside the selected monitor; XTest and uinput span the root.
let placement=if relative || self.backend!=crate::desktop_backend::DesktopBackend::X11 {None} else {crate::wayland::x11_placement()};
let (x,y)=placement.map_or((x,y),|(ox,oy)|(x+ox,y+oy));
if let Some(uinput)=&self.uinput {
if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
let (w,h)=*self.screen.lock().unwrap();
let (w,h)=placement.and_then(|_|crate::capture::x11_last_size()).unwrap_or(*self.screen.lock().unwrap());
if w > 1 && h > 1 {
let scale = |v: i32, extent: u32| (i64::from(v) * i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
@@ -700,3 +703,28 @@ mod output_pointer_tests {
}
}
}
#[cfg(all(test,target_os="linux"))]
mod x11_monitor_pointer_tests {
use super::*;
#[test]
#[ignore="requires an X11 display with two or more RandR monitors and UU_X11_MULTISCREEN=1; moves pointer only"]
fn absolute_pointer_lands_on_the_selected_x11_monitor() {
let _capture=crate::capture::ScreenCapture::new().unwrap();
let input=InputInjector::new();
assert_eq!(input.backend,crate::desktop_backend::DesktopBackend::X11);
let outputs=crate::wayland::outputs();assert!(crate::wayland::x11_multiscreen() && outputs.len()>=2,"needs two X11 monitors");
for (id,output) in outputs.iter().enumerate().chain(outputs.iter().enumerate().rev()) {
crate::wayland::select(id).unwrap();
for (x,y) in [(0.0,0.0),(0.5,0.5),(0.999,0.999),(0.1,0.9)] {
let size=(output.width,output.height);
let pixels=crate::input_mapping::normalized_pointer(x,y,size.0,size.1).unwrap();
input.mouse_absolute_normalized(x,y,size);input.flush_pointer();
let (mut ax,mut ay,mut mask)=(0,0,0);
assert_eq!(unsafe {x11_pointer_state(&mut ax,&mut ay,&mut mask)},0);
assert_eq!((ax,ay),(output.x+pixels.0,output.y+pixels.1),"monitor={} normalized=({x},{y})",output.name);
}
}
crate::wayland::select(0).unwrap();
}
}
+5 -5
View File
@@ -25,11 +25,11 @@ async fn black_frame(codec: VideoCodec) -> Result<Bytes, String> {
Ok(output.stdout.into())
}
pub async fn run(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop) -> Result<(), String> {
run_with_encoder(pc, track, desktop, black_frame).await
pub async fn run(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop, selection: crate::video_select::Selection) -> Result<(), String> {
run_with_encoder(pc, track, desktop, selection, black_frame).await
}
async fn run_with_encoder<F, Fut>(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop, mut encode: F) -> Result<(), String>
async fn run_with_encoder<F, Fut>(pc: &RTCPeerConnection, track: &VideoTrack, desktop: &PortalDesktop, selection: crate::video_select::Selection, mut encode: F) -> Result<(), String>
where F: FnMut(VideoCodec) -> Fut, Fut: std::future::Future<Output = Result<Bytes, String>> {
// #29: iPhone 4.42.0 cold ON/OFF/ON tests only sent action15 after black video.
// Keep CONTROL permissions truthful and use the existing video track until real capture is ready.
@@ -55,8 +55,8 @@ where F: FnMut(VideoCodec) -> Fut, Fut: std::future::Future<Output = Result<Byte
if !updates.borrow().waiting || *locked.borrow() != Some(true)
|| pc.connection_state() != RTCPeerConnectionState::Connected { continue; }
if frame.is_none() {
let codec = crate::capture_setting::preferred_codec(
track.supports(VideoCodec::H264), track.supports(VideoCodec::H265));
let codec = crate::capture_setting::preferred_codec_for(
track.supports(VideoCodec::H264), track.supports(VideoCodec::H265), selection);
let encoded = tokio::select! {
biased;
_ = updates.changed() => continue,
+4 -4
View File
@@ -206,7 +206,7 @@ async fn exercise_locked_video(codec: VideoCodec) {
let run_host = peers.host.clone();
let run_track = peers.track.clone();
let run_desktop = desktop.clone();
let task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop).await });
let task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop, crate::video_select::selection()).await });
assert_ne!(peers.host.connection_state(), RTCPeerConnectionState::Connected);
assert_no_rtp(&mut peers.packets, Duration::from_millis(150)).await;
@@ -273,7 +273,7 @@ async fn locked_video_rechecks_state_when_encoding_finishes() {
let (encoded_tx, mut encoded_rx) = mpsc::unbounded_channel();
let revision = peers.track.revision();
let task = tokio::spawn(async move {
run_with_encoder(&run_host, &run_track, &run_desktop, |_| {
run_with_encoder(&run_host, &run_track, &run_desktop, crate::video_select::selection(), |_| {
let desktop = run_desktop.clone();
let lock_tx = lock_tx.clone();
let encoded_tx = encoded_tx.clone();
@@ -317,7 +317,7 @@ async fn locked_video_stops_on_capture_rejection_and_terminal_peer_close() {
let run_host = peers.host.clone();
let run_track = peers.track.clone();
let run_desktop = rejected_desktop.clone();
let rejection_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop).await });
let rejection_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop, crate::video_select::selection()).await });
rejected_desktop.publish_test_screen(
Arc::new(ScreenCapture::unavailable("synthetic capture rejection".into())),
);
@@ -335,7 +335,7 @@ async fn locked_video_stops_on_capture_rejection_and_terminal_peer_close() {
let run_host = peers.host.clone();
let run_track = peers.track.clone();
let run_desktop = pending_desktop;
let close_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop).await });
let close_task = tokio::spawn(async move { run(&run_host, &run_track, &run_desktop, crate::video_select::selection()).await });
peers.host.close().await.unwrap();
tokio::time::timeout(Duration::from_secs(2), close_task).await
.expect("locked video task did not stop after terminal peer close")
+6 -2
View File
@@ -382,8 +382,11 @@ mod tests {
assert_eq!(qr_ticket(&json!({"token": "old"})), Some("old"));
assert_eq!(qr_ticket(&json!({"status_query_ticket": ""})), None);
}
#[tokio::test]
async fn service_waits_until_a_new_token_is_saved() {
#[test]
fn service_waits_until_a_new_token_is_saved() {
let _env = crate::config::test_env_lock().lock().unwrap();
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let dir = std::env::temp_dir().join(format!("uu-login-wait-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
@@ -399,6 +402,7 @@ mod tests {
let got = tokio::time::timeout(Duration::from_secs(10), wait_for_credentials(Some("old".into()))).await.unwrap();
assert_eq!(got.token, "new"); // the expired token in the file is not accepted
let _ = std::fs::remove_dir_all(&dir);
});
}
#[test]
+259 -22
View File
@@ -5,6 +5,7 @@ mod engine_plugin;
mod doctor;
mod wol;
mod desktop_backend;
mod desktop_mode;
mod desktop_session;
mod desktop_power;
mod portal;
@@ -29,6 +30,7 @@ mod signaling;
mod terminal;
mod webrtc;
mod video;
mod video_select;
mod video_track;
mod locked_video;
#[cfg(test)]
@@ -71,6 +73,14 @@ fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, des
sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop))
.map(|(id, _)| id.clone()).collect()
}
/// A peer whose transport is already broken can leave `PeerConnection::close`
/// waiting indefinitely; signaling must keep flowing without it.
async fn close_peer(pc: &::webrtc::peer_connection::RTCPeerConnection) {
if tokio::time::timeout(std::time::Duration::from_secs(5), pc.close()).await.is_err() {
log::warn!("Peer connection close timed out; continuing");
}
}
fn released_peer_ids<T>(sessions: &HashMap<String, T>, ice: Option<&serde_json::Value>) -> Vec<String> {
let ice = ice.map(|id| id.as_str().map(str::to_owned).unwrap_or_else(|| id.to_string()));
sessions.keys().filter(|id| ice.as_deref().map_or(true, |ice| id.as_str() == ice)).cloned().collect()
@@ -126,12 +136,179 @@ fn systemd_unit() -> Option<String> {
cgroup.lines().find_map(|l| l.rsplit('/').next().filter(|u| u.ends_with(".service")).map(str::to_owned))
}
fn display_present() -> bool { std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() }
fn set_video_pref() -> Result<(), Box<dyn std::error::Error>> {
let which = std::env::args().nth(1).unwrap_or_default();
let stored = std::env::args().nth(2).unwrap_or_default().trim().to_ascii_lowercase();
let stored = if stored == "hevc" { "h265".to_owned() } else { stored };
if let Err(e) = system_actions::merge_save(|settings| {
if which == "set-encoder" { settings.video_encoder = Some(stored.clone()); }
else { settings.video_codec = Some(stored.clone()); }
}) {
// Exit 2 is reserved for bad CLI input; a settings file that cannot be merged is exit 1.
eprintln!("{which}: {e}");
std::process::exit(1);
}
let selection = video_select::selection();
let codec = match selection.codec_pref { video_select::CodecPref::Auto => "auto", video_select::CodecPref::H264 => "h264", video_select::CodecPref::H265 => "h265" };
println!("encoder={:?} source={} codec_pref={codec} source={}", selection.encoder, video_select::encoder_source_label(selection.encoder_source), video_select::source_label(selection.codec_source));
// Both subcommands wake the host. Encoder changes restart live desktop streams; codec changes are logged only.
match notify_host(libc::SIGUSR2) {
Ok(()) => println!("notified the running host"),
Err(_) => println!(
"host not running, or the running host is not this binary: takes effect the next time a desktop connection starts, or after restarting the service"
),
}
if which == "set-codec" {
println!("takes effect the next time a desktop connection starts");
}
Ok(())
}
/// Signal the host recorded in host.pid only when `/proc/<pid>/exe` is exactly
/// `canonicalize(current_exe())`. A filename match is not enough: an older host
/// has no SIGUSR2 handler, and the default action terminates the process.
/// A replaced binary reads back as `… (deleted)` and does not match.
fn notify_host(signal: i32) -> Result<(), ()> {
let pid = std::fs::read_to_string(host_pid_path())
.ok()
.and_then(|s| s.trim().parse::<i32>().ok())
.filter(|p| *p > 1)
.ok_or(())?;
let exe = std::fs::read_link(format!("/proc/{pid}/exe")).map_err(|_| ())?;
let own = std::fs::canonicalize(std::env::current_exe().map_err(|_| ())?).map_err(|_| ())?;
if !same_host_binary(&exe, &own) {
return Err(());
}
if unsafe { libc::kill(pid, signal) } == 0 {
Ok(())
} else {
Err(())
}
}
/// `/proc/<pid>/exe` must equal the canonical path of this binary. A trailing ` (deleted)` does not match.
fn same_host_binary(proc_exe: &std::path::Path, own: &std::path::Path) -> bool {
proc_exe == own
}
/// Explicit command words for set-encoder / set-codec. Empty and whitespace are illegal.
pub(crate) fn cli_pref_ok(which: &str, value: &str) -> bool {
let value = value.trim();
if value.is_empty() { return false; }
let value = value.to_ascii_lowercase();
match which {
"set-encoder" => matches!(value.as_str(), "auto" | "cpu" | "vaapi" | "nvenc"),
"set-codec" => matches!(value.as_str(), "auto" | "h264" | "h265" | "hevc"),
_ => false,
}
}
const SUBCOMMANDS: [&str; 17] = ["doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
/// Unknown arguments and illegal set-encoder / set-codec values exit 2 (never start a second host).
/// help / -h / --help exit 0 so main prints usage instead of starting the host.
pub(crate) fn reject_cli(arg: Option<&str>, argc: usize, value_ok: bool) -> Option<i32> {
if matches!(arg, Some("help" | "-h" | "--help")) { return Some(0); }
if arg.is_some_and(|a| !SUBCOMMANDS.contains(&a)) { return Some(2); }
if matches!(arg, Some("set-encoder" | "set-codec")) && (argc != 3 || !value_ok) { return Some(2); }
None
}
#[cfg(test)]
mod cli_exit_tests {
#[test]
fn unknown_and_illegal_subcommand_exit_2() {
assert_eq!(super::reject_cli(Some("not-a-command"), 2, true), Some(2));
assert_eq!(super::reject_cli(Some("set-encoder"), 3, false), Some(2));
assert_eq!(super::reject_cli(Some("set-encoder"), 2, true), Some(2));
assert_eq!(super::reject_cli(Some("set-codec"), 4, true), Some(2));
assert_eq!(super::reject_cli(Some("set-encoder"), 3, true), None);
assert_eq!(super::reject_cli(Some("set-codec"), 3, true), None);
assert_eq!(super::reject_cli(Some("help"), 2, true), Some(0));
assert_eq!(super::reject_cli(Some("-h"), 2, true), Some(0));
assert_eq!(super::reject_cli(Some("--help"), 2, true), Some(0));
assert_eq!(super::reject_cli(None, 1, true), None);
assert!(!super::cli_pref_ok("set-encoder", ""));
assert!(!super::cli_pref_ok("set-encoder", " "));
assert!(!super::cli_pref_ok("set-codec", ""));
assert!(!super::cli_pref_ok("set-codec", "\t"));
assert!(!super::cli_pref_ok("set-encoder", "bogus"));
assert!(super::cli_pref_ok("set-encoder", " NVENC "));
assert!(super::cli_pref_ok("set-codec", "hevc"));
assert_eq!(super::reject_cli(Some("set-encoder"), 3, super::cli_pref_ok("set-encoder", "")), Some(2));
assert_eq!(super::reject_cli(Some("set-codec"), 3, super::cli_pref_ok("set-codec", " ")), Some(2));
}
/// SIGUSR1 and SIGUSR2 are installed with no assist UI. `host.pid` is written only after both exist.
#[test]
fn signal_handlers_install_without_assist() {
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir =
std::env::temp_dir().join(format!("uuremote-signal-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::env::set_var("UU_CONFIG", dir.join("config.json"));
assert!(super::install_host_signals(None));
let pid = std::fs::read_to_string(super::host_pid_path()).unwrap();
assert_eq!(pid.trim(), std::process::id().to_string());
std::env::remove_var("UU_CONFIG");
let _ = std::fs::remove_dir_all(&dir);
});
}
#[test]
fn sigusr2_requires_the_same_canonical_binary() {
let own = std::path::Path::new("/home/user/.local/bin/uuremote-server");
assert!(super::same_host_binary(own, own));
assert!(!super::same_host_binary(
std::path::Path::new("/tmp/unpack/uuremote-server"),
own
));
assert!(!super::same_host_binary(
std::path::Path::new("/home/user/.local/bin/uuremote-server (deleted)"),
own
));
}
}
/// SIGUSR1 (`uuremote-server show`) opens the host window.
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
// Install the handler before publishing the pid: SIGUSR1's default action terminates the process.
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
/// SIGUSR2 (set-encoder, set-codec, or `kill -USR2`) re-reads host_settings. Encoder changes switch live desktop streams; codec changes are logged for the next connection.
/// The default action of either signal terminates the process, so both handlers are installed before `host.pid` is written.
/// SIGUSR2 is independent of remote assistance: `UU_REMOTE_ASSIST=0` and a failed assist setup still switch live encoders.
/// SIGUSR1 is installed first as a no-op so `show` cannot terminate a host that has no assist window yet.
fn install_host_signals(ui: Option<std::sync::Arc<assist::LocalUi>>) -> bool {
static USR1: std::sync::Once = std::sync::Once::new();
static USR2: std::sync::Once = std::sync::Once::new();
let mut usr1_ok = true;
USR1.call_once(|| {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) {
Ok(mut usr1) => { tokio::spawn(async move { while usr1.recv().await.is_some() {} }); }
Err(_) => usr1_ok = false,
}
});
if !usr1_ok { return false; }
let mut usr2_ok = true;
USR2.call_once(|| {
match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined2()) {
Ok(mut usr2) => { tokio::spawn(async move { while usr2.recv().await.is_some() { crate::video_select::publish_reload(); } }); }
Err(_) => usr2_ok = false,
}
});
if !usr2_ok { return false; }
// Assist attaches later and replaces the no-op with the window. A second registration replaces the first.
if let Some(ui) = ui {
if let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) {
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
}
}
write_host_pid();
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
true
}
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
let _ = install_host_signals(Some(ui));
}
fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.pid") }
@@ -139,7 +316,9 @@ fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.p
fn write_host_pid() {
use std::os::unix::fs::OpenOptionsExt;
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(host_pid_path()) {
let path = host_pid_path();
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(path) {
let _ = write!(f, "{}", std::process::id());
}
}
@@ -225,16 +404,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
.filter_module("uuremote_server", log::LevelFilter::Info).init();
} else { env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init(); }
// An unknown argument must never fall through to starting a second full host server.
const SUBCOMMANDS: [&str; 15] = ["doctor", "show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
if let Some(arg) = std::env::args().nth(1).filter(|a| !SUBCOMMANDS.contains(&a.as_str())) {
let arg1 = std::env::args().nth(1);
let value_ok = match arg1.as_deref() {
Some(which @ ("set-encoder" | "set-codec")) => cli_pref_ok(which, &std::env::args().nth(2).unwrap_or_default()),
_ => true,
};
if let Some(code) = reject_cli(arg1.as_deref(), std::env::args().len(), value_ok) {
let usage = format!("usage: uuremote-server [{}]\n (no argument: run the host)", SUBCOMMANDS.join(" | "));
if matches!(arg.as_str(), "help" | "-h" | "--help") { println!("{usage}"); return Ok(()); }
if code == 0 { println!("{usage}"); return Ok(()); }
eprintln!("unknown argument\n{usage}");
std::process::exit(2);
std::process::exit(code);
}
if std::env::args().nth(1).as_deref() == Some("show") { return show_running_host(); }
if matches!(std::env::args().nth(1).as_deref(), Some("set-encoder") | Some("set-codec")) { return set_video_pref(); }
if assist_enabled && !unified {
if std::env::args().len() > 2 { return Err("assist accepts no additional arguments; configure it with a private UU_CONFIG".into()); }
assist::configure()?;
@@ -446,6 +629,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
let _ = install_host_signals(None);
video::warm_auto_probe();
video::check_ffmpeg_usable();
if !desktop_backend::headless() && desktop_backend::detect()? == desktop_backend::DesktopBackend::X11 && desktop_backend::wayland_session_running() {
// X11 capture inside a Wayland session reads XWayland's root window: all black, no error (#61).
@@ -506,7 +693,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if let Some(task) = command_task { task.abort(); }
// One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { let _ = old.pc.close().await; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
@@ -558,6 +745,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
let mut mac_by_ice: HashMap<String, bool> = HashMap::new();
let mut next_mac = false;
// Tool peers ask here to become the desktop (capture_desktop on an existing connection, #99).
let (desktop_requests, mut desktop_requested) = mpsc::unbounded_channel::<String>();
loop {
if *shutdown.borrow() {
@@ -642,6 +831,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
_ = shutdown.changed() => Some(SignalingEvent::Stop),
command = commands.recv(), if assist.is_some() => Some(SignalingEvent::AssistCommand(command.unwrap_or(assist::Command::Stop))),
_ = assist_tick.tick(), if assist.is_some() => Some(SignalingEvent::AssistTick),
Some(ice) = desktop_requested.recv() => Some(SignalingEvent::DesktopRequested(ice)),
event = rx_event.recv() => event,
};
let Some(evt) = event else { break; };
@@ -676,8 +866,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(id, _)| id.clone()).collect();
let mut desktop_ended = false;
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.desktop; let _ = s.pc.close().await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); close_peer(&s.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
SignalingEvent::Connected => {
@@ -764,8 +954,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect();
let mut desktop_ended = false;
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.desktop; let _ = old.pc.close().await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.role.is_desktop(); close_peer(&old.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
if soac.msg_type == "offer" {
@@ -775,16 +965,21 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
if desktop { input.set_mac_controller(controller_mac); }
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
// An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder.
if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); }
// Replace only this ICE id or a previous desktop, never tool peers.
for id in superseded_peer_ids(&sessions, &ice, desktop) {
if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; }
if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; }
}
// A tool peer promoted by capture_desktop stops its desktop but keeps its tools.
if desktop { for old in sessions.values() { old.demote(); } }
if desktop && desktop_backend::headless() {
log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)");
continue;
}
let resized=desktop && capture.init_error.is_none() && capture.backend==desktop_backend::DesktopBackend::X11
&& tokio::task::spawn_blocking(crate::capture::x11_resized).await.unwrap_or(false);
// Compare with this capture, not the engine: a live stream may already have refreshed it.
&& tokio::task::spawn_blocking(crate::capture::x11_size).await.ok().flatten().is_some_and(|size| size!=(capture.width,capture.height));
if resized { log::info!("Desktop geometry changed since startup; reinitializing capture"); }
let session_capture=if desktop && portal_desktop.is_none() && (capture.init_error.is_some() || resized) {
match tokio::task::spawn_blocking(ScreenCapture::new).await {
@@ -799,7 +994,12 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { if let Some(portal) = &portal_desktop { portal.begin(); } }
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport,
if desktop { portal_desktop.clone() } else { None }).await {
Ok(sess) => {
Ok(mut sess) => {
sess.controller_mac = controller_mac;
if !desktop {
let (requests, peer) = (desktop_requests.clone(), ice.clone());
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
}
// Register before awaiting SDP: shutdown can always close
// a peer whose answer may already be queued to the viewer.
sessions.insert(ice.clone(), sess);
@@ -822,7 +1022,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
}
Err(_) => {
log::error!("Failed to handle offer (details omitted)");
if let Some(session) = sessions.remove(&ice) { let _ = session.pc.close().await; }
if let Some(session) = sessions.remove(&ice) { close_peer(&session.pc).await; }
}
}},
Err(_) => log::error!("Create peer failed (details omitted)"),
@@ -844,13 +1044,50 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let mut desktop_ended = false;
for k in targets {
if let Some(old) = sessions.remove(&k) {
desktop_ended |= old.desktop;
if let Err(e) = old.pc.close().await { log::warn!("Close released peer failed: {}", e); }
desktop_ended |= old.role.is_desktop();
close_peer(&old.pc).await;
}
}
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
SignalingEvent::DesktopRequested(ice) => {
let mut sessions = webrtc_sessions.lock().await;
let Some(peer) = sessions.get(&ice).filter(|peer| !peer.role.is_desktop()) else { continue; };
if desktop_backend::headless() {
log::info!("Desktop request on a tool connection ignored: headless mode");
continue;
}
if portal_desktop.is_some() {
log::info!("Desktop request on a tool connection not supported with the Portal backend; open the desktop before port mapping");
continue;
}
let controller_mac = peer.controller_mac;
let current = peer.desktop_capture();
// Same recovery as a desktop offer: the display may have come up or been resized after this peer.
let resized = current.init_error.is_none() && current.backend == desktop_backend::DesktopBackend::X11
&& tokio::task::spawn_blocking(crate::capture::x11_size).await.ok().flatten().is_some_and(|size| size != (current.width, current.height));
if resized { log::info!("Desktop geometry changed since this connection opened; reinitializing capture"); }
let screen = if current.init_error.is_some() || resized {
match tokio::task::spawn_blocking(ScreenCapture::new).await {
Ok(Ok(screen)) => { capture = Arc::new(screen); Some(capture.clone()) },
Ok(Err(error)) => { log::info!("Desktop request on a tool connection ignored: {error}"); continue; },
Err(_) => { log::warn!("Desktop initialization worker failed"); continue; },
}
} else { None };
video::warm_auto_probe(); video::check_ffmpeg_usable();
input.set_mac_controller(controller_mac);
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone()));
// One desktop at a time, as for a new desktop offer. Peers offered as desktops
// close; a promoted tool peer only stops its desktop and keeps its tools.
let superseded: Vec<String> = sessions.iter().filter(|(id, old)| id.as_str() != ice && old.role.is_desktop())
.map(|(id, _)| id.clone()).collect();
for id in superseded {
if sessions[&id].desktop { if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; } }
else { sessions[&id].demote(); }
}
if let Some(peer) = sessions.get(&ice) { peer.promote(screen); }
}
SignalingEvent::Disconnected => {
capture_types.clear();
next_capture_type=None;
+166 -37
View File
@@ -3,12 +3,20 @@
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::Message;
/// A peer that stops reading must not park the heartbeat loop on a full queue.
/// Kept below the Engine.IO window so the protocol deadline still fires.
const SEND_STALL_TIMEOUT: Duration = Duration::from_secs(10);
/// How often the watchdog checks the last inbound frame.
const WATCHDOG_TICK: Duration = Duration::from_secs(1);
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoacMessage {
#[serde(rename = "type")]
@@ -46,6 +54,8 @@ pub enum SignalingEvent {
Released(Value),
Left(Value),
Disconnected,
/// capture_desktop on this tool peer (ice_id); raised by the peer, not by signaling.
DesktopRequested(String),
}
pub struct SignalingClient {
@@ -68,6 +78,11 @@ fn refreshed_key(ack:&Value)->Option<String> {
(!key.is_empty() && key.len()<=16384).then(||key.to_owned())
}
/// Deliver an event without letting a stalled consumer hide a dead socket.
async fn send_event(sender: &mpsc::Sender<SignalingEvent>, event: SignalingEvent) -> bool {
matches!(tokio::time::timeout(SEND_STALL_TIMEOUT, sender.send(event)).await, Ok(Ok(())))
}
#[cfg(test)]
mod refresh_tests {
use super::refreshed_key;
@@ -126,6 +141,73 @@ mod refresh_tests {
assert!(disconnected.is_ok(),"a socket without pings must be reported dead");
drop(hold_tx);
}
#[tokio::test]
async fn blocked_event_consumer_does_not_hide_a_dead_socket() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
let (closed_tx,closed_rx)=tokio::sync::oneshot::channel::<()>();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// Shortest accepted window (clamped to 5 s); never ping, only events.
sink.send(Message::Text(r#"0{"pingInterval":1000,"pingTimeout":1000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>match r {
None|Some(Err(_))|Some(Ok(Message::Close(_)))=>{let _=closed_tx.send(());return;}
_=>{}
},
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err() {
let _=closed_tx.send(());return;
}
}
}
}
});
// Capacity 1 and no reader: the first event fills the queue, so the
// receive loop would park inside `send().await` without the watchdog.
let (sender,_events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
let closed=tokio::time::timeout(std::time::Duration::from_secs(15),closed_rx).await;
assert!(closed.is_ok(),"a blocked consumer must not keep a dead signaling socket open");
}
#[tokio::test]
async fn stalled_event_delivery_still_reports_disconnected() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// A long window: the send stall must fire before the heartbeat deadline.
sink.send(Message::Text(r#"0{"pingInterval":30000,"pingTimeout":30000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>{ if matches!(r,None|Some(Err(_))|Some(Ok(Message::Close(_)))){return} }
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err(){return}
}
}
}
});
let (sender,mut events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
// Let SEND_STALL_TIMEOUT expire while nothing drains the queue.
tokio::time::sleep(std::time::Duration::from_secs(12)).await;
assert!(matches!(events.recv().await,Some(super::SignalingEvent::Connected)));
let disconnected=tokio::time::timeout(std::time::Duration::from_secs(5),events.recv()).await;
assert!(matches!(disconnected,Ok(Some(super::SignalingEvent::Disconnected))),"a stalled delivery must still report Disconnected");
}
}
impl SignalingClient {
@@ -156,17 +238,25 @@ impl SignalingClient {
log::info!("Connected to Engine.IO / Socket.IO");
let (mut write, mut read) = ws_stream.split();
let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32);
let started = Instant::now();
let last_rx = Arc::new(AtomicU64::new(0));
let ping_window_ms = Arc::new(AtomicU64::new(45_000));
let receiver_done = Arc::new(AtomicBool::new(false));
// 发送协程
let writer=tokio::spawn(async move {
while let Some(msg) = rx_outgoing.recv().await {
if let Err(e) = write.send(Message::Text(msg)).await {
let _ = e;
log::warn!("WS send failed (details omitted)");
break;
match tokio::time::timeout(SEND_STALL_TIMEOUT, write.send(Message::Text(msg))).await {
Ok(Ok(())) => {}
Ok(Err(_)) | Err(_) => {
// A peer that stopped reading must not park every producer.
log::warn!("WS send failed or stalled (details omitted)");
break;
}
}
}
});
let writer_abort = writer.abort_handle();
let tx_out_clone = tx_outgoing.clone();
static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -175,9 +265,12 @@ impl SignalingClient {
let refreshed=reconnect_key.clone();
// 接收与状态机协程
tokio::spawn(async move {
let watchdog_events = event_sender.clone();
let watchdog_last_rx = last_rx.clone();
let watchdog_ping_window_ms = ping_window_ms.clone();
let watchdog_done = receiver_done.clone();
let receiver = tokio::spawn(async move {
let mut req_counter = 10;
let started=std::time::Instant::now();
let mut last_ping=started;
let mut pings=0u64;
let mut pong_queued=0u64;
@@ -200,7 +293,7 @@ impl SignalingClient {
_=event_sender.closed()=>break,
_=tokio::time::sleep_until(ping_deadline) => {
log::warn!("Signaling heartbeat lost: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
},
// Official ControlledSession RefreshSignalTokenLoop: first
@@ -211,8 +304,8 @@ impl SignalingClient {
refresh_acks.push_back(req_counter);
if refresh_acks.len()>16 { refresh_acks.pop_front(); }
let packet=format!("42{}[\"refresh_reconnect_key\"]",req_counter);
if tx_out_clone.send(packet).await.is_err() {
let _=event_sender.send(SignalingEvent::Disconnected).await;break;
if tx_out_clone.try_send(packet).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(30);
log::info!("Signaling reconnect-key refresh requested: generation={} age_s={}",generation,started.elapsed().as_secs());
@@ -220,9 +313,14 @@ impl SignalingClient {
},
msg=read.next()=>match msg {
Some(msg)=>msg,
None=>{let _=event_sender.send(SignalingEvent::Disconnected).await;break;}
None=>{let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;}
},
};
// Any inbound frame proves the socket is alive. A reader parked on
// event delivery stops updating this, which the watchdog catches.
if msg_res.is_ok() {
last_rx.store(started.elapsed().as_millis() as u64, Ordering::Relaxed);
}
match msg_res {
Ok(Message::Text(txt)) => {
// Engine.IO 报文处理
@@ -231,16 +329,20 @@ impl SignalingClient {
log::info!("Signaling heartbeat config: generation={} ping_interval_ms={:?} ping_timeout_ms={:?}",generation,open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64));
if let (Some(interval),Some(timeout))=(open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)) {
ping_window=std::time::Duration::from_millis(interval.saturating_add(timeout).clamp(5_000,300_000));
ping_window_ms.store(ping_window.as_millis() as u64, Ordering::Relaxed);
ping_deadline=tokio::time::Instant::now()+ping_window;
}
}
// Open packet -> 发送 Socket.IO connect
let _ = tx_out_clone.send("40".into()).await;
if tx_out_clone.try_send("40".into()).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
} else if txt == "2" {
// Ping -> 回复 Pong
let gap=last_ping.elapsed().as_secs();last_ping=std::time::Instant::now();pings+=1;
ping_deadline=tokio::time::Instant::now()+ping_window;
if tx_out_clone.send("3".into()).await.is_ok() { pong_queued+=1; }
if tx_out_clone.try_send("3".into()).is_ok() { pong_queued+=1; }
else { let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break; }
if pings==1 || pings%12==0 {
log::info!("Signaling heartbeat progress: generation={} age_s={} pings={} pong_queued={} gap_s={}",generation,started.elapsed().as_secs(),pings,pong_queued,gap);
}
@@ -250,8 +352,10 @@ impl SignalingClient {
// Socket.IO connected -> 发送 room_info 请求
req_counter += 1;
let room_req = format!("42{}[\"room_info\"]", req_counter);
let _ = tx_out_clone.send(room_req).await;
let _ = event_sender.send(SignalingEvent::Connected).await;
if tx_out_clone.try_send(room_req).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
if !send_event(&event_sender, SignalingEvent::Connected).await { break; }
} else if txt.starts_with("43") {
// Socket.IO ack 回调
let begin=txt.find('[').unwrap_or(2);
@@ -270,7 +374,7 @@ impl SignalingClient {
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(300);
}
log::info!("Signaling reconnect-key refresh acknowledged: generation={} age_s={} success={}",generation,started.elapsed().as_secs(),success);
} else { let _ = event_sender.send(SignalingEvent::RoomInfoAck(v)).await; }
} else if !send_event(&event_sender, SignalingEvent::RoomInfoAck(v)).await { break; }
}
} else if txt.starts_with("45") || txt.starts_with("46") {
// Socket.IO binary event/ack: header text, attachments follow as binary frames.
@@ -294,14 +398,10 @@ impl SignalingClient {
match event_name {
"bmsg_push" => {
let _ = event_sender
.send(SignalingEvent::DeviceInfoChanged(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::DeviceInfoChanged(data.clone())).await { break; }
}
"be-controlled" => {
let _ = event_sender
.send(SignalingEvent::BeControlled(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::BeControlled(data.clone())).await { break; }
}
"soac" => {
// Offers only: structure (keys, types, lengths), never SDP text or ids.
@@ -324,9 +424,7 @@ impl SignalingClient {
if soac.client_id.is_none() {
soac.client_id = client_id_opt;
}
let _ = event_sender
.send(SignalingEvent::Soac(soac))
.await;
if !send_event(&event_sender, SignalingEvent::Soac(soac)).await { break; }
}
Err(e) => {
let _ = e;
@@ -336,20 +434,16 @@ impl SignalingClient {
}
"released" => {
log::info!("Cloud peer event: generation={} event=released age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let _ = event_sender
.send(SignalingEvent::Released(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::Released(data.clone())).await { break; }
}
"left" | "leave" => {
log::info!("Cloud peer event: generation={} event={} age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,event_name,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let ice_id = data.get("ice_id").and_then(|v| v.as_str()).unwrap_or("");
if ice_id.is_empty() {
log::warn!("Cloud room leave without peer identifier; renewing signaling (expiry cause unknown)");
let _ = event_sender.send(SignalingEvent::Disconnected).await;
if !send_event(&event_sender, SignalingEvent::Disconnected).await { break; }
} else {
let _ = event_sender
.send(SignalingEvent::Left(data.clone()))
.await;
if !send_event(&event_sender, SignalingEvent::Left(data.clone())).await { break; }
}
}
_ => {
@@ -399,28 +493,60 @@ impl SignalingClient {
let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4)
|| v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin")));
log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac);
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await;
if !send_event(&event_sender, SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await { break; }
}
}
}
Ok(Message::Close(frame)) => {
log::warn!("Signaling socket closed: generation={} age_s={} close_code={:?} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),frame.map(|f|u16::from(f.code)),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
}
Err(_) => {
log::warn!("Signaling socket receive failed: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await;
let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break;
}
_ => {}
}
}
// A stalled event queue or a writer that already stopped can end this
// loop without a delivered Disconnected. Hand one off from a detached
// task so the main loop always learns the room is dead; duplicates are
// harmless because it breaks on the first one.
let events = event_sender.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_done.store(true, Ordering::Relaxed);
log::info!("Signaling receiver stopped: generation={} age_s={}",generation,started.elapsed().as_secs());
// Live peer callbacks can retain the old SignalingClient sender.
// Explicitly drop its write half too when this room stops reading.
writer.abort();
});
let receiver_abort = receiver.abort_handle();
// Independent of the receive loop: a consumer that stops draining events
// parks the loop inside an `.await`, where the ping deadline can no longer
// be observed. The watchdog closes the socket anyway.
tokio::spawn(async move {
let mut tick = tokio::time::interval(WATCHDOG_TICK);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tick.tick().await;
if watchdog_done.load(Ordering::Relaxed) || watchdog_events.is_closed() { return; }
let window_ms = watchdog_ping_window_ms.load(Ordering::Relaxed);
let idle_ms = (started.elapsed().as_millis() as u64)
.saturating_sub(watchdog_last_rx.load(Ordering::Relaxed));
if idle_ms <= window_ms { continue; }
log::warn!("Signaling heartbeat lost (watchdog): idle_s={} window_ms={}", idle_ms/1000, window_ms);
// Deliver from a detached task: the receiver may be the one parked
// on a full queue, and the main loop still needs this event.
let events = watchdog_events.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_abort.abort();
writer_abort.abort();
return;
}
});
Ok(Self { tx_outgoing, _reconnect_key:reconnect_key })
}
@@ -428,7 +554,10 @@ impl SignalingClient {
pub async fn emit_event(&self, event: &str, payload: serde_json::Value) -> Result<(), String> {
let packet = format!("42{}", serde_json::json!([event, payload]));
log::info!("Emitting signaling event: {}", event);
self.tx_outgoing.send(packet).await.map_err(|e| e.to_string())
tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(packet))
.await
.map_err(|_| "signaling send stalled".to_string())?
.map_err(|e| e.to_string())
}
/// 发送 SOAC 消息(Answer 或 Candidate)
@@ -443,9 +572,9 @@ impl SignalingClient {
};
let msg = format!("42[\"soac\",{}]", payload);
log::info!("Emitting soac packet: type={}", soac.msg_type);
self.tx_outgoing
.send(msg)
tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(msg))
.await
.map_err(|_| "Send soac timed out".to_string())?
.map_err(|e| format!("Send soac error: {}", e))
}
}
+161 -12
View File
@@ -12,6 +12,8 @@ pub const FF_SIMPLE_ACTION: u8 = 2;
pub const FF_SYSTEM_METRICS: u8 = 2;
pub const SHOW_DESKTOP: u64 = 2;
/// Opens the desktop on an existing connection (the viewer's port mapping reuses its peer, #99).
pub const CAPTURE_DESKTOP: u64 = 4;
pub const REBOOT_SYSTEM: u64 = 9;
pub const LOCK_SYSTEM: u64 = 10;
pub const SHUTDOWN_SYSTEM: u64 = 12;
@@ -25,11 +27,27 @@ pub const SET_AUTO_LOCK: u64 = 19;
/// Host settings from the viewer's 安全 menu. The viewer sends them only when a switch is toggled
/// and shows what SystemMetrics reports, so they are host-wide and persisted (like the official
/// host), not per connection: a reconnect must still lock / mute.
#[derive(Debug, Default, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
struct Settings {
#[derive(Debug, Default, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub(crate) struct Settings {
#[serde(default)] auto_lock: bool,
#[serde(default)] keep_mute: bool,
#[serde(default)] mute_permanent: bool,
/// "auto" or absent does not override the environment. A non-string value becomes None so a bad
/// video field cannot drop auto_lock / mute when the document is loaded.
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_encoder: Option<String>,
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option<String>,
}
fn lenient_string<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
use serde::Deserialize;
match Option::<serde_json::Value>::deserialize(deserializer)? {
Some(serde_json::Value::String(s)) => Ok(Some(s)),
Some(_) => {
log::warn!("Ignoring non-string video_encoder/video_codec in host settings");
Ok(None)
}
None => Ok(None),
}
}
struct HostState {
@@ -39,22 +57,83 @@ struct HostState {
desktop_sessions: usize,
}
fn settings_path() -> std::path::PathBuf { crate::config::path().with_file_name("host_settings.json") }
pub(crate) fn settings_path() -> std::path::PathBuf { crate::config::path().with_file_name("host_settings.json") }
pub(crate) fn load_settings() -> Settings {
std::fs::read(settings_path()).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default()
}
/// Re-read, apply `patch`, write via a temp file and rename (mode 0600).
pub(crate) fn merge_save(patch: impl FnOnce(&mut Settings)) -> Result<Settings, String> {
merge_write(patch)?;
let settings = load_settings();
if let Ok(mut guard) = state().lock() { guard.settings = settings.clone(); }
Ok(settings)
}
fn state() -> &'static Mutex<HostState> {
static STATE: std::sync::OnceLock<Mutex<HostState>> = std::sync::OnceLock::new();
STATE.get_or_init(|| {
let settings = std::fs::read(settings_path()).ok()
.and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default();
let settings = load_settings();
Mutex::new(HostState { settings, restore: None, desktop_sessions: 0 })
})
}
fn save(settings: &Settings) {
/// Re-read, copy only the security switches from `settings`, keep video_* from disk.
fn save(settings: &Settings) -> Result<(), String> {
merge_write(|disk| {
disk.auto_lock = settings.auto_lock;
disk.keep_mute = settings.keep_mute;
disk.mute_permanent = settings.mute_permanent;
})
}
/// Held across read-patch-write-rename so set-* and a security-toggle save cannot clobber each other.
struct SettingsLock { file: std::fs::File }
impl SettingsLock {
fn acquire(path: &std::path::Path) -> Result<Self, String> {
use std::os::unix::fs::OpenOptionsExt;
let lock_path = path.with_file_name("host_settings.json.lock");
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).mode(0o600).open(&lock_path).map_err(|e| e.kind().to_string())?;
let rc = unsafe { libc::flock(std::os::unix::io::AsRawFd::as_raw_fd(&file), libc::LOCK_EX) };
if rc != 0 { return Err(std::io::Error::last_os_error().kind().to_string()); }
Ok(Self { file })
}
}
impl Drop for SettingsLock {
fn drop(&mut self) {
unsafe { libc::flock(std::os::unix::io::AsRawFd::as_raw_fd(&self.file), libc::LOCK_UN); }
}
}
/// NotFound starts from defaults. Any other read or parse error leaves the file untouched:
/// a bad document must not be rewritten with security switches forced off.
fn read_for_merge(path: &std::path::Path) -> Result<Settings, String> {
match std::fs::read(path) {
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Settings::default()),
Err(e) => Err(format!("host settings unreadable: {}", e.kind())),
// serde_json::Error's Display quotes the offending value; the journal and set-* must not.
Ok(bytes) => serde_json::from_slice(&bytes).map_err(|e| match (e.line(), e.column()) {
(0, 0) => "host_settings.json is not valid".to_owned(),
(line, column) => format!("host_settings.json is not valid (line {line}, column {column})"),
}),
}
}
fn merge_write(patch: impl FnOnce(&mut Settings)) -> Result<(), String> {
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
let path = settings_path();
let result = serde_json::to_vec_pretty(settings).map_err(|e| e.to_string())
.and_then(|json| std::fs::write(&path, json).map_err(|e| e.to_string()));
if let Err(e) = result { log::warn!("Host settings not saved: {}", e); }
if let Some(dir) = path.parent() { std::fs::create_dir_all(dir).map_err(|e| e.kind().to_string())?; }
let _lock = SettingsLock::acquire(&path)?;
let mut disk = read_for_merge(&path)?;
patch(&mut disk);
let json = serde_json::to_vec_pretty(&disk).map_err(|e| e.to_string())?;
let tmp = path.with_extension(format!("json.{}.tmp", std::process::id()));
let mut file = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp).map_err(|e| e.kind().to_string())?;
file.write_all(&json).map_err(|e| e.kind().to_string())?;
std::fs::rename(&tmp, &path).map_err(|e| e.kind().to_string())?;
Ok(())
}
/// Handle for one desktop connection (system actions are host-wide).
@@ -142,7 +221,7 @@ impl PeerActions {
_ => {}
}
let mut state = state().lock().unwrap();
let before = state.settings;
let before = state.settings.clone();
match action {
// 静音运行 on: the viewer sends MUTE_SYSTEM + MUTE_TEMPORARY (observed), off: MUTE_RESTORE.
MUTE_SYSTEM | MUTE_TEMPORARY => {
@@ -172,7 +251,7 @@ impl PeerActions {
}
_ => return false,
}
if state.settings != before { save(&state.settings); }
if state.settings != before { if let Err(e) = save(&state.settings) { log::warn!("Host settings not saved: {e}"); } }
true
}
@@ -205,7 +284,7 @@ impl PeerActions {
pub fn metrics_payload(&self, sound: bool, desktop: crate::system_metrics::Permission) -> Vec<u8> {
use crate::system_metrics::payload_with_settings;
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let current = state().lock().unwrap().settings;
let current = state().lock().unwrap().settings.clone();
payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings {
sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock,
})
@@ -274,6 +353,76 @@ mod tests {
assert!(plugin_response(&decode_wire(&[10, 2, 8, 9]).unwrap()).is_none());
}
#[test]
fn merge_save_keeps_security_fields_and_mode() {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir = std::env::temp_dir().join(format!("uu-settings-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let cfg = dir.join("config.json");
std::env::set_var("UU_CONFIG", &cfg);
let path = settings_path();
std::fs::write(&path, br#"{"auto_lock":true,"keep_mute":true,"mute_permanent":false}"#).unwrap();
let saved = merge_save(|s| s.video_encoder = Some("vaapi".into())).unwrap();
assert!(saved.auto_lock && saved.keep_mute && !saved.mute_permanent);
assert_eq!(saved.video_encoder.as_deref(), Some("vaapi"));
let again = merge_save(|s| s.video_codec = Some("h264".into())).unwrap();
assert_eq!(again.video_encoder.as_deref(), Some("vaapi"));
assert_eq!(again.video_codec.as_deref(), Some("h264"));
assert!(again.auto_lock);
let mode = { use std::os::unix::fs::PermissionsExt; std::fs::metadata(&path).unwrap().permissions().mode() & 0o777 };
assert_eq!(mode, 0o600);
// A mute/lock save must not drop video_* written after the in-memory copy was taken.
let mut memory = load_settings();
std::fs::write(&path, br#"{"auto_lock":true,"keep_mute":true,"mute_permanent":false,"video_encoder":"nvenc","video_codec":"h265"}"#).unwrap();
memory.keep_mute = false;
save(&memory).unwrap();
let disk: serde_json::Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
assert_eq!(disk["video_encoder"], "nvenc");
assert_eq!(disk["video_codec"], "h265");
assert_eq!(disk["keep_mute"], false);
assert_eq!(disk["auto_lock"], true);
// A non-string video field must not fail the whole document (security switches survive).
std::fs::write(&path, br#"{"auto_lock":true,"keep_mute":false,"mute_permanent":true,"video_encoder":1,"video_codec":{"x":1}}"#).unwrap();
let loaded = load_settings();
assert!(loaded.auto_lock && !loaded.keep_mute && loaded.mute_permanent);
assert!(loaded.video_encoder.is_none() && loaded.video_codec.is_none());
merge_save(|s| s.video_encoder = Some("cpu".into())).unwrap();
let disk: serde_json::Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
assert_eq!(disk["auto_lock"], true);
assert_eq!(disk["mute_permanent"], true);
assert_eq!(disk["video_encoder"], "cpu");
let _ = std::fs::remove_dir_all(&dir);
std::env::remove_var("UU_CONFIG");
}
#[test]
fn merge_write_refuses_malformed_or_unreadable_settings() {
let _guard = crate::config::test_env_lock().lock().unwrap();
let dir = std::env::temp_dir().join(format!("uu-settings-bad-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::env::set_var("UU_CONFIG", dir.join("config.json"));
let path = settings_path();
let malformed = br#"{"auto_lock":true, "keep_mute":"#;
std::fs::write(&path, malformed).unwrap();
let err = merge_write(|s| s.video_encoder = Some("cpu".into())).unwrap_err();
assert!(err.contains("not valid"), "{err}");
assert_eq!(std::fs::read(&path).unwrap(), malformed);
let bad_type = br#"{"auto_lock":"yes","keep_mute":false,"mute_permanent":false}"#;
std::fs::write(&path, bad_type).unwrap();
let err = merge_write(|s| s.video_codec = Some("h265".into())).unwrap_err();
assert!(err.contains("not valid"), "{err}");
assert!(err.contains("line ") && err.contains("column "), "{err}");
assert!(!err.contains("yes"), "{err}");
assert_eq!(std::fs::read(&path).unwrap(), bad_type);
std::fs::remove_file(&path).unwrap();
std::fs::create_dir(&path).unwrap();
let err = merge_write(|s| s.video_encoder = Some("cpu".into())).unwrap_err();
assert!(err.contains("unreadable"), "{err}");
assert!(path.is_dir());
let _ = std::fs::remove_dir_all(&dir);
std::env::remove_var("UU_CONFIG");
}
#[test]
fn args_shape_never_contains_values() {
let shape = args_shape(br#"{"enable":true,"secret":"abc"}"#);
assert!(shape.contains("enable") && !shape.contains("abc"));
+462 -102
View File
@@ -1,8 +1,12 @@
#[cfg(test)]
#[path = "video_wake_tests.rs"]
mod wake_tests;
use std::collections::HashMap;
use std::ffi::OsString;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, OnceLock};
use std::sync::atomic::AtomicBool;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::time::{Duration, Instant};
use tokio::io::AsyncReadExt;
use tokio::process::Command;
@@ -177,16 +181,9 @@ impl CompleteFrame {
const RTP_CLOCK: u64 = 90_000;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub(crate) enum Encoder { Cpu, Nvenc, Vaapi }
impl Encoder {
pub(crate) fn requested() -> Self { Self::from_setting(std::env::var("UU_VIDEO_ENCODER").ok().as_deref(), nvidia_present()) }
/// Unset/auto tries NVENC only with an NVIDIA driver loaded: `ffmpeg -encoders` lists h264_nvenc
/// on any machine, so without this every stream start first ran a doomed NVENC process (#10).
fn from_setting(value: Option<&str>, nvidia: bool) -> Self {
match value { Some("cpu") => Self::Cpu, Some("vaapi") => Self::Vaapi, Some("nvenc") => Self::Nvenc,
_ => if nvidia { Self::Nvenc } else { Self::Cpu } }
}
pub(crate) fn name_for(self, codec: VideoCodec) -> &'static str {
match (self, codec) {
(Self::Cpu, VideoCodec::H264) => "libx264", (Self::Cpu, VideoCodec::H265) => "libx265",
@@ -195,14 +192,12 @@ impl Encoder {
}
}
}
fn nvidia_present() -> bool {
pub(crate) fn nvidia_present() -> bool {
std::path::Path::new("/proc/driver/nvidia/version").exists() || std::path::Path::new("/dev/nvidia0").exists()
}
/// 真彩 (4:4:4): NVENC (in-process or FFmpeg) and libx264; h264_vaapi is 4:2:0 only.
/// A GPU without 4:4:4 NVENC falls back to libx264, which keeps 4:4:4.
pub fn full_chroma_available() -> bool {
Encoder::requested() != Encoder::Vaapi
}
pub(crate) fn full_chroma_for(encoder: Encoder) -> bool { encoder != Encoder::Vaapi }
/// (-profile:v, -pix_fmt) for NVENC / libx264 / libx265: 4:4:4 (真彩) needs a 4:4:4 profile.
fn chroma_args(settings: &VideoSettings, encoder: Encoder) -> (&'static str, &'static str) {
@@ -262,10 +257,29 @@ fn cpu_hevc_options(settings: &VideoSettings, gop: &str) -> Vec<String> {
/// NVENC converts packed RGB on the GPU (BT.601 limited range, tagged bt470bg like the swscale default;
/// compared on the 3090), so 4:2:0 without scaling skips the CPU BGRA→YUV pass (#16: ~2 cores at 4K).
/// `input` is the source pixel format; `UU_NVENC_RGB=0` restores CPU conversion.
/// When the desktop is composited on the NVIDIA card itself, the packed-RGB path is slower than CPU
/// conversion (#16: RTX 5070 at 4K, 82.6 vs 98 fps), so it stays off unless `UU_NVENC_RGB=1`.
/// `input` is the source pixel format; `UU_NVENC_RGB=0` always restores CPU conversion.
fn nvenc_rgb_input(settings: &VideoSettings, encoder: Encoder, input: &'static str) -> Option<&'static str> {
(encoder == Encoder::Nvenc && settings.chroma != crate::capture_setting::CHROMA_444 && settings.output.is_none()
&& std::env::var("UU_NVENC_RGB").as_deref() != Ok("0")).then_some(input)
let wanted = match std::env::var("UU_NVENC_RGB").as_deref() {
Ok("0") => false,
Ok("1") => true,
_ => !nvidia_drives_display(std::path::Path::new("/sys/class/drm")),
};
(encoder == Encoder::Nvenc && settings.chroma != crate::capture_setting::CHROMA_444 && settings.output.is_none() && wanted)
.then_some(input)
}
/// A connected DRM connector (`cardN-HDMI-A-1/status`) on a card bound to the nvidia driver.
/// Only visible with nvidia-drm modeset, which Wayland compositors require.
fn nvidia_drives_display(drm: &std::path::Path) -> bool {
std::fs::read_dir(drm).into_iter().flatten().flatten().any(|entry| {
let name = entry.file_name().to_string_lossy().into_owned();
let Some((card, _)) = name.split_once('-') else { return false; };
card.starts_with("card")
&& std::fs::read_to_string(entry.path().join("status")).is_ok_and(|s| s.trim() == "connected")
&& std::fs::read_link(drm.join(card).join("device/driver")).is_ok_and(|p| p.file_name().is_some_and(|n| n == "nvidia"))
})
}
fn encoder_options(settings: &VideoSettings, encoder: Encoder, gop: &str, rgb: Option<&'static str>) -> Vec<String> {
@@ -344,6 +358,52 @@ fn ffmpeg_spec() -> FfmpegSpec {
pub(crate) fn ffmpeg_command() -> Command { ffmpeg_spec().command() }
/// Encoders of interest that the configured FFmpeg lists; `None` when it cannot run (bounded to 5 s).
pub async fn ffmpeg_encoders() -> Option<Vec<&'static str>> {
let mut ffmpeg = ffmpeg_command();
ffmpeg.args(["-hide_banner", "-encoders"]).kill_on_drop(true);
let output = tokio::time::timeout(Duration::from_secs(5), ffmpeg.output()).await.ok()?.ok()?;
let text = String::from_utf8_lossy(&output.stdout);
Some(["libx264", "libx265", "h264_nvenc", "hevc_nvenc", "h264_vaapi", "hevc_vaapi"].into_iter()
.filter(|name| text.split_whitespace().any(|word| word == *name)).collect())
}
/// Without FFmpeg the desktop stream fails after the viewer connects and it waits on
/// 正在传输画面 with no message of its own. Checked at startup and on each desktop offer:
/// logged, shown in the host window, and sent as a desktop notification (at most every 5 minutes).
/// Installing FFmpeg clears the window line on the next check; no restart is needed.
pub fn check_ffmpeg_usable() {
if crate::desktop_backend::headless() { return; }
tokio::spawn(async {
static LAST_NOTICE: std::sync::Mutex<Option<Instant>> = std::sync::Mutex::new(None);
const SUMMARY: &str = "无法传输远程画面";
match ffmpeg_encoders().await {
None => {
log::error!("FFmpeg is not runnable: desktop video cannot start and viewers stay on 正在传输画面. Install ffmpeg (Debian/Ubuntu: sudo apt install ffmpeg; Arch: sudo pacman -S ffmpeg; Fedora: ffmpeg from RPM Fusion), or set ffmpeg_root, then check `uuremote-server doctor`");
let text = "未找到可运行的 FFmpeg,客户端会一直停在「正在传输画面」。\n请安装后重新连接:sudo apt install ffmpeg(Arch:sudo pacman -S ffmpeg;Fedora 需先启用 RPM Fusion)";
let previous = {
let mut last = LAST_NOTICE.lock().unwrap_or_else(|e| e.into_inner());
let previous = *last;
let due = previous.is_none_or(|at| at.elapsed() >= Duration::from_secs(300));
if due { *last = Some(Instant::now()); }
due.then_some(previous)
};
// The notification is a blocking D-Bus call (bounded to 3 s).
let told = tokio::task::spawn_blocking(move || crate::assist::show_problem(SUMMARY, Some(text), previous.is_some())).await.unwrap_or(false);
// Only a notice that reached the person starts the 5-minute quiet period.
if let (Some(previous), false) = (previous, told) {
*LAST_NOTICE.lock().unwrap_or_else(|e| e.into_inner()) = previous;
log::warn!("Missing FFmpeg: no desktop notification daemon and no host window to show it");
}
}
Some(found) => {
if !found.contains(&"libx264") { log::warn!("FFmpeg has no libx264: CPU encoding and the fallback after a hardware encoder failure are unavailable. Install a full ffmpeg build"); }
tokio::task::spawn_blocking(|| crate::assist::show_problem(SUMMARY, None, false));
}
}
});
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum FfmpegTimingMode { Modern, Legacy }
@@ -411,33 +471,153 @@ async fn ffmpeg_timing_mode(spec: &FfmpegSpec) -> FfmpegTimingMode {
*cell.get_or_init(|| probe_timing_mode(spec)).await
}
type HevcCache = Mutex<HashMap<(FfmpegSpec, Encoder), Arc<tokio::sync::OnceCell<bool>>>>;
fn hevc_cache() -> &'static HevcCache {
static CACHE: OnceLock<HevcCache> = OnceLock::new();
CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}
fn hevc_cell(cache: &HevcCache, spec: &FfmpegSpec, encoder: Encoder) -> Arc<tokio::sync::OnceCell<bool>> {
let mut cache = cache.lock().expect("HEVC probe cache poisoned");
cache.entry((spec.clone(), encoder)).or_insert_with(|| Arc::new(tokio::sync::OnceCell::const_new())).clone()
}
/// A compiled-in encoder name does not prove that its driver can initialize.
/// Probe one synthetic 4:2:0 frame once per process before advertising HEVC.
pub async fn hevc_available() -> bool {
static AVAILABLE: tokio::sync::OnceCell<bool> = tokio::sync::OnceCell::const_new();
*AVAILABLE.get_or_init(|| async {
let requested = Encoder::requested();
let mut candidates = vec![requested];
if requested != Encoder::Cpu { candidates.push(Encoder::Cpu); }
for encoder in candidates {
let settings = VideoSettings { codec: VideoCodec::H265, ..Default::default() };
let mut command = ffmpeg_command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
command.args(["-f", "lavfi", "-i", "color=black:size=256x256:rate=1", "-frames:v", "1", "-an"]);
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
command.args(encoder_options(&settings, encoder, "30", None));
command.args(["-f", "hevc", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
if let Ok(Ok(output)) = tokio::time::timeout(Duration::from_secs(5), command.output()).await {
if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H265) {
log::info!("HEVC encoder probe: {} ok", encoder.name_for(VideoCodec::H265));
return true;
}
/// Probe one synthetic 4:2:0 frame per resolved encoder and FFmpeg spec. The caller
/// passes the session's encoder so capability matches that snapshot. set-encoder
/// changes the snapshot for the next session, so a process-wide bool would keep advertising
/// the first session's result.
const AUTO_PROBE_BUDGET: Duration = Duration::from_secs(3);
/// One synthetic H.264 IDR. Failure reasons stay enum values: stderr and device paths are not logged.
pub(crate) async fn probe_encoder_idr(encoder: Encoder) -> crate::video_select::ProbeOutcome {
use crate::video_select::{ProbeFail, ProbeOutcome};
let settings = VideoSettings { codec: VideoCodec::H264, ..Default::default() };
let mut command = ffmpeg_command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
command.args(["-f", "lavfi", "-i", "color=c=black:s=256x256:r=1", "-frames:v", "1", "-an"]);
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
command.args(encoder_options(&settings, encoder, "30", None));
command.args(["-f", "h264", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
let process = match tokio::time::timeout(AUTO_PROBE_BUDGET, command.output()).await {
Ok(Ok(output)) if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H264) => ProbeOutcome::Ok,
Ok(Ok(output)) if output.status.success() => ProbeOutcome::Fail(ProbeFail::NoIdr),
Ok(Ok(_)) => ProbeOutcome::Fail(ProbeFail::Exit),
Ok(Err(_)) => ProbeOutcome::Fail(ProbeFail::Spawn),
Err(_) => ProbeOutcome::Fail(ProbeFail::Timeout),
};
// The native engine opens against a real X display, so a synthetic lavfi frame cannot
// exercise it. When this build would try that engine first, a process-only failure must
// not drop the candidate (NativeUnprobed → legacy auto for it).
crate::video_select::outcome_for_candidate(process, native_engine_would_run(encoder))
}
/// True when `read_encoder_with` would open the in-process engine for this candidate
/// on the selected desktop backend (X11 only; not Wayland, portal, KMS, or headless).
fn native_engine_would_run(encoder: Encoder) -> bool {
native_engine_eligible(encoder, native_display_kind())
}
fn native_display_kind() -> NativeDisplayKind {
if crate::desktop_backend::headless() { return NativeDisplayKind::None; }
match crate::desktop_backend::detect() {
Ok(crate::desktop_backend::DesktopBackend::Wayland) => NativeDisplayKind::Wayland,
Ok(crate::desktop_backend::DesktopBackend::Kms) => NativeDisplayKind::Kms,
Ok(crate::desktop_backend::DesktopBackend::Portal) => NativeDisplayKind::Portal,
_ => NativeDisplayKind::X11,
}
}
fn auto_probe_flight() -> &'static tokio::sync::Mutex<()> {
static FLIGHT: std::sync::OnceLock<tokio::sync::Mutex<()>> = std::sync::OnceLock::new();
FLIGHT.get_or_init(|| tokio::sync::Mutex::new(()))
}
/// Start the auto probe when auto is selected and the cache is empty or stale
/// (TTL, or NVIDIA presence changed since the report). Returns immediately.
/// One probe runs at a time; an in-flight probe is left alone.
/// Explicit encoder (setting or `UU_VIDEO_ENCODER`) does not spawn a probe.
pub fn warm_auto_probe() {
if !crate::video_select::should_warm_auto_probe(crate::video_select::selection().encoder_source) { return; }
if !crate::video_select::probe_needs_run(std::time::Instant::now(), nvidia_present()) { return; }
tokio::spawn(async { let _ = run_auto_probe().await; });
}
/// Diagnostics that encode must see the same auto choice as a warmed-up host.
/// An explicit encoder (setting or env) skips the probe.
pub async fn ensure_auto_probed() {
if crate::video_select::selection().encoder_source == crate::video_select::Source::Auto {
let _ = run_auto_probe().await;
}
}
/// Run the probe to completion (doctor, or the background warm-up).
/// A success or a CPU-only skip stays cached. A hardware failure expires after
/// `PROBE_FAILURE_TTL`; the next `warm_auto_probe` starts one background retry.
pub async fn run_auto_probe() -> crate::video_select::ProbeReport {
let now = std::time::Instant::now();
let nvidia = nvidia_present();
if let Some(cached) = crate::video_select::cached_probe() {
if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; }
}
let _flight = auto_probe_flight().lock().await;
let now = std::time::Instant::now();
let nvidia = nvidia_present();
if let Some(cached) = crate::video_select::cached_probe() {
if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; }
}
let reason = crate::video_select::reprobe_reason(crate::video_select::cached_probe().as_ref(), nvidia);
let nvidia = nvidia_present();
let order = crate::video_select::auto_order(nvidia);
// One candidate (CPU, no NVIDIA) has nothing to choose; skip the synthetic IDR.
let mut outcomes = Vec::with_capacity(order.len());
if order.len() == 1 {
outcomes.push(crate::video_select::ProbeOutcome::NotProbed);
} else {
for encoder in &order { outcomes.push(probe_encoder_idr(*encoder).await); }
}
let probed = crate::video_select::choose_from_probe(&order, &outcomes);
let chosen = crate::video_select::chosen_after_native(nvidia, &order, &outcomes, probed);
let report = crate::video_select::ProbeReport::fresh(order, outcomes, chosen, now, nvidia);
let parts: Vec<String> = report.order.iter().zip(report.outcomes.iter()).map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label())).collect();
if let Some(reason) = reason {
log::info!("Encoder probe: {reason} {}", parts.join(" "));
} else {
log::info!("Encoder probe: {}", parts.join(" "));
}
crate::video_select::store_probe(report.clone());
report
}
pub async fn hevc_available(requested: Encoder) -> bool {
let spec = ffmpeg_spec();
let cell = hevc_cell(hevc_cache(), &spec, requested);
*cell.get_or_init(|| probe_hevc(spec, requested)).await
}
async fn probe_hevc(spec: FfmpegSpec, requested: Encoder) -> bool {
let mut candidates = vec![requested];
if requested != Encoder::Cpu { candidates.push(Encoder::Cpu); }
for encoder in candidates {
let settings = VideoSettings { codec: VideoCodec::H265, ..Default::default() };
let mut command = spec.command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
command.args(["-f", "lavfi", "-i", "color=black:size=256x256:rate=1", "-frames:v", "1", "-an"]);
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
command.args(encoder_options(&settings, encoder, "30", None));
command.args(["-f", "hevc", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
if let Ok(Ok(output)) = tokio::time::timeout(Duration::from_secs(5), command.output()).await {
if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H265) {
log::info!("HEVC encoder probe: {} ok", encoder.name_for(VideoCodec::H265));
return true;
}
}
log::info!("HEVC encoder probe: unavailable");
false
}).await
}
log::info!("HEVC encoder probe: unavailable");
false
}
/// Round UP (+1ns float guard) so webrtc's floor(duration*90000) yields exactly `ticks`.
@@ -500,35 +680,69 @@ impl Drop for StopOnDrop { fn drop(&mut self) { self.0.store(true, std::sync::at
async fn read_encoder(
size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
latest: mpsc::Sender<Arc<CompleteFrame>>,
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
mut settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
selection: crate::video_select::Selection,
) -> Result<(), String> {
#[cfg(test)]
if display == wake_tests::DISPLAY { return wake_tests::encode(latest, settings, sequence, budget).await; }
// The sequence is shared so a CPU fallback or settings restart continues it (skip statistics stay correct).
let encoder = Encoder::requested();
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await; }
// `selection` is fixed for this desktop connection (taken where the codec is negotiated).
let encoder = selection.encoder;
if settings.chroma == crate::capture_setting::CHROMA_444 && !full_chroma_for(encoder) {
settings.chroma = crate::capture_setting::CHROMA_420;
log::info!("Chroma 4:4:4 requested; encoder={} source={} encodes 4:2:0", format!("{encoder:?}").to_ascii_lowercase(), crate::video_select::encoder_source_label(selection.encoder_source));
}
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await; }
#[cfg_attr(not(feature = "inproc-av"), allow(unused_mut))]
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone()).await;
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
// A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline.
#[cfg(feature = "inproc-av")]
if let Err(error) = &result {
if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) {
if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) && x11_resized(&display, portal.is_some(), size).is_none() {
log::warn!("In-process {} stream unavailable; switching to the FFmpeg process pipeline: {}",encoder.name_for(settings.codec),error);
result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone()).await;
result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,false,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
}
}
match result {
Ok(())=>Ok(()),
Err(error) if !latest.is_closed()=>{
Err(error) if !latest.is_closed() && x11_resized(&display, portal.is_some(), size).is_none()=>{
log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error);
read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget).await
read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await
},
Err(error)=>Err(error),
}
}
/// A resized X11 root fails every encoder alike (x11grab BadMatch on the old size);
/// returns the new size so the stream restarts capture instead of walking the fallback chain.
fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u32)> {
if portal || display.starts_with("wayland:") || display.starts_with("kms:") { return None; }
crate::capture::x11_size().filter(|current| *current != size)
}
/// Same predicate `native_inproc` uses: X11 only, and the in-process engine is selected.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum NativeDisplayKind { X11, Wayland, Portal, Kms, None }
pub(crate) fn native_engine_eligible(encoder: Encoder, kind: NativeDisplayKind) -> bool {
#[cfg(feature = "inproc-av")]
{ kind == NativeDisplayKind::X11 && crate::inproc_encoder::selected(encoder) }
#[cfg(not(feature = "inproc-av"))]
{ let _ = (encoder, kind); false }
}
/// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session).
#[cfg(feature = "inproc-av")]
fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool {
!display.starts_with("wayland:") && !display.starts_with("kms:") && !portal && crate::inproc_encoder::selected(encoder)
native_engine_eligible(encoder, display_kind(display, portal))
}
#[cfg(feature = "inproc-av")]
fn display_kind(display: &str, portal: bool) -> NativeDisplayKind {
if portal { NativeDisplayKind::Portal }
else if display.starts_with("wayland:") { NativeDisplayKind::Wayland }
else if display.starts_with("kms:") { NativeDisplayKind::Kms }
else { NativeDisplayKind::X11 }
}
/// Capture and encode inside this process; each packet is one access unit.
@@ -566,19 +780,20 @@ async fn read_inprocess(
/// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8).
/// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not.
fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
if encoder == Encoder::Cpu { max_kbps.clamp(500, 8000) }
else if encoder == Encoder::Vaapi {
let requested = std::env::var("UU_VAAPI_BUFFER_MS").ok();
vaapi_buffer_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500))
}
else { (max_kbps / 8).clamp(100, 500) }
let env = match encoder {
Encoder::Cpu => return max_kbps.clamp(500, 8000),
Encoder::Vaapi => "UU_VAAPI_BUFFER_MS",
Encoder::Nvenc => "UU_NVENC_BUFFER_MS",
};
let requested = std::env::var(env).ok();
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500))
}
/// Opt-in VAAPI VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` in 10-1000 ms.
/// The 100-500 kbit default is sized for NVENC; VAAPI quantizes a whole desktop keyframe when
/// the buffer is that small, which reads as a blur that sharpens over each GOP (#42).
/// Opt-in hardware VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With the 100-500 kbit default the encoder quantizes a
/// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42 VAAPI, #103 NVENC).
/// Unset, out of range or unparsable values keep the default buffer.
fn vaapi_buffer_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
fn buffer_ms_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?;
Some((max_kbps.saturating_mul(ms) / 1000).max(1))
}
@@ -598,11 +813,14 @@ async fn read_encoder_with(
size: (u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,latest:mpsc::Sender<Arc<CompleteFrame>>,encoder:Encoder,
#[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] allow_inproc: bool,sequence:Arc<std::sync::atomic::AtomicU64>,
settings: VideoSettings, #[cfg_attr(not(feature = "inproc-av"), allow(unused_variables))] idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
selection: crate::video_select::Selection,
)->Result<(),String>{
let selected_output=if display.starts_with("wayland:") {crate::wayland::source(settings.source_id)} else {None};
let selected_output=crate::wayland::capture_source(&display,portal.is_some(),settings.source_id);
let size=selected_output.map_or(size,|s|(s.width,s.height));
let kms=display.starts_with("kms:");
let wayland=kms || display.starts_with("wayland:");
// X11 multi-screen: x11grab reads only the selected monitor's region of the root.
let x11_region=selected_output.filter(|_|!wayland);
let (permits_tx,mut permits_rx)=mpsc::channel::<OwnedSemaphorePermit>(4);
let kms_capture=if kms {
let capture=tokio::task::spawn_blocking(crate::kms::Capture::open).await.map_err(|_|"KMS worker failed")??;
@@ -610,7 +828,7 @@ async fn read_encoder_with(
Some(Arc::new(capture))
} else { None };
#[cfg(feature = "inproc-av")]
if allow_inproc && native_inproc(&display, portal.is_some(), encoder) {
if allow_inproc && x11_region.is_none() && native_inproc(&display, portal.is_some(), encoder) {
let max_kbps = settings.max_kbps().unwrap_or(30_000) as i64;
let config = crate::inproc_encoder::Config {
display: display.clone(), input: size, output: settings.output, fps: u32::from(settings.fps),
@@ -619,8 +837,9 @@ async fn read_encoder_with(
max_bps: max_kbps * 1000, buffer_bits: i64::from(buffer_for(&settings, encoder)) * 1000, codec: settings.codec, chroma: settings.chroma,
vaapi: encoder == Encoder::Vaapi,
};
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} pipeline=in-process",
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec));
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} source={} pipeline=in-process",
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec),
crate::video_select::encoder_source_label(selection.encoder_source));
return read_inprocess(config, latest, sequence, idr, budget).await;
}
let source_size = size;
@@ -632,7 +851,7 @@ async fn read_encoder_with(
let cq = settings.cq().to_string();
// x11grab delivers bgr0; the Wayland/portal/KMS pipe is bgra.
let rgb = nvenc_rgb_input(&settings, encoder, if wayland { "bgra" } else { "bgr0" });
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} pix_fmt={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name_for(settings.codec),if encoder == Encoder::Vaapi { "nv12" } else { rgb.unwrap_or(chroma_args(&settings, encoder).1) });
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} source={} pix_fmt={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name_for(settings.codec),crate::video_select::encoder_source_label(selection.encoder_source),if encoder == Encoder::Vaapi { "nv12" } else { rgb.unwrap_or(chroma_args(&settings, encoder).1) });
// A bundled FFmpeg prefix (config ffmpeg_root / UU_FFMPEG_ROOT) or `ffmpeg` on PATH.
let ffmpeg = ffmpeg_spec();
let mut command = ffmpeg.command();
@@ -643,8 +862,9 @@ async fn read_encoder_with(
"-framerate",&fps,"-i","pipe:0","-an"]);
} else {
// The viewer draws its local pointer; do not bake a second into video.
let input=x11_region.map_or_else(||display.clone(),|o|format!("{display}+{},{}",o.x,o.y));
command.args(["-f","x11grab","-draw_mouse","0","-framerate",&fps,
"-video_size",&size,"-i",&display,"-an"]);
"-video_size",&size,"-i",&input,"-an"]);
}
// 其他分辨率: scale the captured desktop (the host display mode is left untouched).
command.args(scale_options(&settings, encoder, Some(source_size)));
@@ -784,7 +1004,9 @@ pub(crate) fn transport_closed(pc: &RTCPeerConnection) -> bool {
|| pc.sctp().state() == webrtc::sctp_transport::sctp_transport_state::RTCSctpTransportState::Closed
}
fn probe_settings() -> Result<VideoSettings,String> {
/// Encoder and settings for `desktop-video-probe` / `UU_PROBE_INPUT`.
/// `UU_PROBE_CHROMA=444` is the viewer's 真彩 request, applied when the selected encoder can do 4:4:4.
pub(crate) fn probe_plan() -> Result<(crate::video_select::Selection, VideoSettings), String> {
let fps=crate::wayland::capture_fps(std::env::var("UU_PROBE_FPS").ok().as_deref())?;
// UU_PROBE_QUALITY selects a viewer preset (1 fast 1M, 2 general 2M, 3 HD 8M, 4 bluray 20M,
// 5 auto); bitrate presets exercise the capped/ABR encoder path instead of CRF.
@@ -792,19 +1014,15 @@ fn probe_settings() -> Result<VideoSettings,String> {
None=>crate::capture_setting::QUALITY_AUTO,
Some(v)=>v.parse::<u64>().ok().filter(|q|(1..=5).contains(q)).ok_or("UU_PROBE_QUALITY must be 1-5")?,
};
let mut settings=VideoSettings {fps,quality,codec:probe_codec(),..VideoSettings::default()};
// UU_PROBE_CHROMA=444 requests 真彩 like the viewer does (only where full_chroma_available()).
if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") && full_chroma_available() { settings.chroma=crate::capture_setting::CHROMA_444; }
Ok(settings)
}
/// The probe follows `UU_VIDEO_CODEC` so the HEVC path can be measured at all (H.264 otherwise),
/// and its first access unit is then checked against that codec instead of always H.264.
fn probe_codec() -> VideoCodec {
match std::env::var("UU_VIDEO_CODEC").ok().as_deref().map(str::to_ascii_lowercase).as_deref() {
Some("h265") | Some("hevc") => VideoCodec::H265,
let mut settings=VideoSettings {fps,quality,..VideoSettings::default()};
let selection = crate::video_select::selection();
let chroma = if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") { crate::capture_setting::CHROMA_444 } else { crate::capture_setting::CHROMA_420 };
settings.codec = match crate::video_select::codec_force(selection.codec_pref) {
Some("h265") => VideoCodec::H265,
_ => VideoCodec::H264,
}
};
if chroma == crate::capture_setting::CHROMA_444 && full_chroma_for(selection.encoder) { settings.chroma = chroma; }
Ok((selection, settings))
}
fn probe_input_command(spec:&FfmpegSpec,input:&std::ffi::OsStr,loop_input:bool,settings:&VideoSettings,
@@ -839,13 +1057,14 @@ async fn probe_input_size(spec:&FfmpegSpec,input:&std::ffi::OsStr)->Result<(u32,
/// Fixed input bypasses desktop initialization and always uses the FFmpeg process encoder.
pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String> {
ensure_auto_probed().await;
use std::io::Write;
let settings=probe_settings()?;
let (selection, settings)=probe_plan()?;
let wanted:u64=std::env::var("UU_PROBE_FRAMES").ok().and_then(|v|v.parse().ok()).unwrap_or(5);
if wanted==0 { return Err("Fixed-input UU_PROBE_FRAMES must be positive".into()); }
let spec=ffmpeg_spec();
let size=probe_input_size(&spec,&input).await?;
let encoder=Encoder::requested();
let encoder = selection.encoder;
let (maxrate,_)=rate_args(&settings,encoder);
let output=settings.output.unwrap_or(size);
println!("Fixed input probe: source={}x{} output={}x{} fps={} cq={} maxrate={} encoder={}",
@@ -889,6 +1108,7 @@ pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String>
/// Exercise the real capture/encoder chain without UU auth or a network peer.
pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,path:Option<String>)->Result<(),String> {
ensure_auto_probed().await;
use std::io::Write;
let mut file=match path {
Some(path)=>Some(std::fs::OpenOptions::new().write(true).create_new(true).open(path).map_err(|e|format!("Video probe file: {e}"))?),
@@ -896,8 +1116,8 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
};
let (tx,mut rx)=mpsc::channel(4);
let sequence=Arc::new(std::sync::atomic::AtomicU64::new(0));
let settings=probe_settings()?;
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)))));
let (selection, settings)=probe_plan()?;
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)),selection)));
let mut count=0;
let mut bytes=0;
// UU_PROBE_FRAMES lengthens the sample for baseline measurements; default is 5 frames.
@@ -915,8 +1135,26 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
Ok(())
}
fn keep_stream_display_awake() {
#[cfg(test)]
let result = wake_tests::wake().unwrap_or_else(crate::capture::keep_display_awake);
#[cfg(not(test))]
let result = crate::capture::keep_display_awake();
// Waking the output is optional; a transient failure does not mean capture failed.
if result.is_err() { log::warn!("Display wake failed; continuing desktop stream and retrying next interval"); }
}
/// `sync_tx` receives a Message 25 payload when a live encoder switch changes the encoded chroma.
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>) -> Result<(), String> {
settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection, sync_tx: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>) -> Result<(), String> {
stream_desktop_at(pc, track, size, display, portal, settings, applied, idr, selection, sync_tx, crate::video_select::reload_generation_value()).await
}
pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection, sync_tx: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>, reload_at_session: u64) -> Result<(), String> {
let _desktop_mode = crate::desktop_mode::StreamGuard::new();
loop {
if transport_closed(&pc) { return Ok(()); }
if pc.connection_state() == RTCPeerConnectionState::Connected
@@ -925,7 +1163,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
}
// Portal power/idle policy belongs to its CONTROL-scoped supervisor,
// including when video has no frames or the user locks manually.
if portal.is_none() { crate::capture::keep_display_awake()?; }
if portal.is_none() { keep_stream_display_awake(); }
let portal_stream = portal.is_some();
let (latest, mut receiver) = mpsc::channel(4);
let budget=Arc::new(Semaphore::new(4));
@@ -936,7 +1174,26 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
applied.send_replace(current);
settings.borrow_and_update();
}
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone())));
// SIGUSR2 re-reads host_settings and restarts this encoder when the effective encoder changes.
// The negotiated codec stays; a codec-only change is logged and applied on the next connection.
let mut live_selection = selection;
let mut seen_codec_pref = selection.codec_pref;
let mut reload = crate::video_select::subscribe_reload();
// Only a SIGUSR2 since the session snapshot. A probe that finishes during setup is not a reload
// (sessions started before the probe keep the legacy encoder for their lifetime).
let mut reload_pending = crate::video_select::reload_since_session(reload_at_session, *reload.borrow());
let open = {
let display = display.clone();
let portal = portal.clone();
let latest = latest.clone();
let sequence = sequence.clone();
let idr = idr.clone();
let budget = budget.clone();
move |size: (u32, u32), selection: crate::video_select::Selection, settings: VideoSettings| {
read_encoder(size, display.clone(), portal.clone(), latest.clone(), settings, sequence.clone(), idr.clone(), budget.clone(), selection)
}
};
let mut reader = EncoderTask(tokio::spawn(open(size, live_selection, current)));
let mut previous = None;
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
let mut settings_open = true;
@@ -951,30 +1208,76 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
let (mut window_frames, mut window_skipped) = (0u64, 0u64);
let mut send_interrupted=false;
'stream: loop {
if reload.has_changed().unwrap_or(false) || reload_pending {
reload_pending = false;
// Mark the watch seen. An unconsumed has_changed stays true and restarts every frame.
let _ = reload.borrow_and_update();
let fresh = crate::video_select::selection();
let plan = crate::video_select::plan_switch(live_selection.encoder, seen_codec_pref, &fresh, current.chroma);
if let Some(plan) = plan.filter(|plan| plan.encoder.is_some()) {
let encoder = plan.encoder.unwrap();
let chroma = if plan.chroma_downgraded { "420" } else if current.chroma == crate::capture_setting::CHROMA_444 { "444" } else { "420" };
log::info!("Encoder switch: {} -> {} reason={} chroma={chroma}",
format!("{:?}", live_selection.encoder).to_ascii_lowercase(),
format!("{encoder:?}").to_ascii_lowercase(),
crate::video_select::encoder_source_label(fresh.encoder_source));
live_selection.encoder = encoder;
live_selection.encoder_source = fresh.encoder_source;
seen_codec_pref = fresh.codec_pref;
if plan.chroma_downgraded {
applied.send_modify(|value| value.chroma = plan.chroma);
current.chroma = plan.chroma;
settings.borrow_and_update();
if let Some(sync) = sync_tx.as_ref() {
// Wayland: x11_resized is None, and the connection size can be a previous output.
let native = x11_resized(&display, portal_stream, size).unwrap_or_else(|| crate::wayland::sync_native(&display, current.source_id, size));
let payload = crate::capture_setting::sync_payload(&current, native);
let _ = sync.send(payload);
}
}
// In-process engines honor this on the first frame; the process pipeline starts on an IDR.
idr.store(true, std::sync::atomic::Ordering::Relaxed);
reader.restart(open(size, live_selection, current)).await;
} else if plan.is_some() {
log::info!("Codec preference changed; takes effect the next time a desktop connection starts");
seen_codec_pref = fresh.codec_pref;
live_selection.codec_pref = fresh.codec_pref;
live_selection.codec_source = fresh.codec_source;
}
}
let next = *settings.borrow_and_update();
if next != current || send_interrupted {
let discard = next.codec != current.codec || next.source_generation != current.source_generation || next.source_id != current.source_id || send_interrupted;
current = next;
timeline.fps = u64::from(next.fps);
// A viewer resolution choice may have changed the X11 display mode (desktop_mode).
if let Some(resized) = x11_resized(&display, portal_stream, size) { size = resized; }
if discard {
reader.0.abort();
let _ = (&mut reader.0).await;
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone()));
reader.0 = tokio::spawn(open(size, live_selection, next));
} else {
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone())).await;
reader.restart(open(size, live_selection, next)).await;
}
send_interrupted=false;
}
tokio::select! {
result = &mut reader.0 => {
let result = result.map_err(|e| format!("Encoder reader task: {e}"))?;
if let Some(resized) = result.as_ref().err().and_then(|_| x11_resized(&display, portal_stream, size)) {
log::info!("Desktop geometry changed during the stream ({}x{} -> {}x{}); restarting capture", size.0, size.1, resized.0, resized.1);
size = resized;
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(open(size, live_selection, current));
continue;
}
if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) {
log::warn!("HEVC stream failed ({error}); falling back to negotiated H264");
applied.send_modify(|value| value.codec = VideoCodec::H264);
current = *settings.borrow_and_update();
while receiver.try_recv().is_ok() {}
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone()));
reader.0 = tokio::spawn(open(size, live_selection, current));
continue;
}
if result.is_err() && !crate::wayland::outputs().is_empty() && !crate::wayland::input_ready() {
@@ -1029,8 +1332,10 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
previous = Some(frame.sequence);
max_send_ms=max_send_ms.max(send_started.elapsed().as_millis());
frames += 1;
#[cfg(test)]
if wake_tests::active() { stats = Instant::now() - Duration::from_secs(30); }
if stats.elapsed() >= Duration::from_secs(30) {
if !portal_stream { crate::capture::keep_display_awake()?; }
if !portal_stream { keep_stream_display_awake(); }
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} window_s={} window_sent={} window_skipped={} max_slot_age_ms={} max_send_ms={}",
frames, skipped, frame.sequence, stats.elapsed().as_secs(), frames - window_frames, skipped - window_skipped, max_age_ms, max_send_ms);
(window_frames, window_skipped) = (frames, skipped);
@@ -1045,6 +1350,28 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
#[cfg(test)]
mod tests {
#[test]
fn nvidia_display_is_detected_from_connected_connectors() {
use std::os::unix::fs::symlink;
let root = std::env::temp_dir().join(format!("uu-drm-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
let card = |n: &str, driver: &str, connector: &str, status: &str| {
std::fs::create_dir_all(root.join(format!("drivers/{driver}"))).unwrap();
std::fs::create_dir_all(root.join(format!("drm/{n}/device"))).unwrap();
let _ = symlink(root.join(format!("drivers/{driver}")), root.join(format!("drm/{n}/device/driver")));
std::fs::create_dir_all(root.join(format!("drm/{n}-{connector}"))).unwrap();
std::fs::write(root.join(format!("drm/{n}-{connector}/status")), format!("{status}\n")).unwrap();
};
let drm = root.join("drm");
card("card0", "i915", "HDMI-A-1", "connected");
card("card1", "nvidia", "DP-1", "disconnected");
assert!(!super::nvidia_drives_display(&drm), "iGPU drives the display");
card("card1", "nvidia", "DP-2", "connected");
assert!(super::nvidia_drives_display(&drm), "NVIDIA drives a display");
assert!(!super::nvidia_drives_display(&root.join("missing")));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn native_frame_dimensions_are_padded_to_even() {
// A scaled compositor can report an odd logical desktop (e.g. two stacked 150% monitors →
@@ -1165,6 +1492,26 @@ mod tests {
assert!(!timing_args(FfmpegTimingMode::Modern, 60).contains(&"-r".to_owned()));
}
#[test]
fn native_unprobed_only_when_x11_inproc_is_eligible() {
use crate::video_select::{outcome_for_candidate, ProbeFail, ProbeOutcome};
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
for kind in [NativeDisplayKind::Wayland, NativeDisplayKind::Portal, NativeDisplayKind::Kms, NativeDisplayKind::None] {
assert!(!native_engine_eligible(Encoder::Nvenc, kind), "{kind:?}");
assert_eq!(outcome_for_candidate(exit, native_engine_eligible(Encoder::Nvenc, kind)), exit);
}
assert!(!native_engine_eligible(Encoder::Cpu, NativeDisplayKind::X11));
let x11 = native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11);
let stored = outcome_for_candidate(exit, x11);
if cfg!(feature = "inproc-av") && native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11) {
assert!(x11);
assert_eq!(stored, ProbeOutcome::NativeUnprobed);
} else {
assert!(!x11);
assert_eq!(stored, exit);
}
}
#[test]
fn timing_probe_failure_keeps_modern_args() {
let modern = b" -fps_mode mode\n -enc_time_base ratio\n";
@@ -1224,26 +1571,21 @@ mod tests {
}
#[test]
fn vaapi_buffer_env_is_opt_in_and_bounded() {
assert_eq!(vaapi_buffer_kbits(30_000, None), None);
assert_eq!(vaapi_buffer_kbits(30_000, Some("250")), Some(7500));
assert_eq!(vaapi_buffer_kbits(30_000, Some(" 10 ")), Some(300));
assert_eq!(vaapi_buffer_kbits(30_000, Some("1000")), Some(30_000));
fn hw_buffer_env_is_opt_in_and_bounded() {
assert_eq!(buffer_ms_kbits(30_000, None), None);
assert_eq!(buffer_ms_kbits(30_000, Some("250")), Some(7500));
assert_eq!(buffer_ms_kbits(30_000, Some(" 10 ")), Some(300));
assert_eq!(buffer_ms_kbits(30_000, Some("1000")), Some(30_000));
// Out of the documented range, empty or unparsable keeps the default buffer.
for value in ["", "9", "1001", "0", "abc", "-250", "250ms"] {
assert_eq!(vaapi_buffer_kbits(30_000, Some(value)), None, "{value}");
assert_eq!(buffer_ms_kbits(30_000, Some(value)), None, "{value}");
}
// A tiny cap must not produce a zero-sized buffer.
assert_eq!(vaapi_buffer_kbits(1, Some("10")), Some(1));
assert_eq!(buffer_ms_kbits(1, Some("10")), Some(1));
}
#[test]
fn vaapi_is_explicit_and_upload_follows_scale() {
assert_eq!(Encoder::from_setting(None, true), Encoder::Nvenc);
assert_eq!(Encoder::from_setting(None, false), Encoder::Cpu);
assert_eq!(Encoder::from_setting(Some("nvenc"), false), Encoder::Nvenc);
assert_eq!(Encoder::from_setting(Some("cpu"), true), Encoder::Cpu);
assert_eq!(Encoder::from_setting(Some("vaapi"), true), Encoder::Vaapi);
assert_eq!(vaapi_filter(None), "format=nv12,hwupload");
assert_eq!(vaapi_filter(Some((1280,720))), "scale=1280:720:flags=bilinear,format=nv12,hwupload");
let options = vaapi_options(&VideoSettings::default(), "30");
@@ -1373,7 +1715,25 @@ mod tests {
#[tokio::test]
#[ignore = "requires installed FFmpeg with a working HEVC encoder"]
async fn hevc_capability_probe_initializes_real_encoder() {
assert!(hevc_available().await);
assert!(hevc_available(crate::video_select::selection().encoder).await);
}
#[tokio::test]
async fn hevc_probe_cache_is_keyed_by_encoder_and_ffmpeg_spec() {
let cache = Mutex::new(HashMap::new());
let spec = FfmpegSpec { program: PathBuf::from("ffmpeg"), ld_library_path: None, path: None };
let other = FfmpegSpec { program: PathBuf::from("/opt/ffmpeg/bin/ffmpeg"), ld_library_path: None, path: None };
let calls = Arc::new(AtomicUsize::new(0));
let lookup = |spec: &FfmpegSpec, encoder: Encoder, result: bool| {
let cell = hevc_cell(&cache, spec, encoder);
let calls = calls.clone();
async move { *cell.get_or_init(|| async move { calls.fetch_add(1, Ordering::SeqCst); result }).await }
};
assert!(lookup(&spec, Encoder::Cpu, true).await);
assert!(lookup(&spec, Encoder::Cpu, false).await);
assert_eq!(calls.load(Ordering::SeqCst), 1);
assert!(!lookup(&spec, Encoder::Nvenc, false).await);
assert!(lookup(&other, Encoder::Cpu, true).await);
assert_eq!(calls.load(Ordering::SeqCst), 3);
}
#[test]
fn hevc_annex_b_boundaries_and_irap_use_two_byte_headers() {
+897
View File
@@ -0,0 +1,897 @@
//! Runtime encoder / codec preference. host_settings.json beats the environment,
//! and "auto" or a missing field falls through. Illegal values are ignored.
//! Auto follows `auto_order` (NVENC then CPU when NVIDIA is present, else CPU).
//! A finished background probe can replace that choice; an unfinished probe keeps
//! the legacy NVIDIA/CPU result so the first connection is not delayed.
use crate::video::Encoder;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Source {
Setting,
Env,
Auto,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CodecPref {
Auto,
H264,
H265,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Selection {
pub encoder: Encoder,
pub encoder_source: Source,
pub codec_pref: CodecPref,
pub codec_source: Source,
}
pub fn parse_encoder(value: Option<&str>) -> Option<Option<Encoder>> {
match value
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|s| s.to_ascii_lowercase())
{
None => Some(None),
Some(v) if v == "auto" => Some(None),
Some(v) if v == "cpu" => Some(Some(Encoder::Cpu)),
Some(v) if v == "vaapi" => Some(Some(Encoder::Vaapi)),
Some(v) if v == "nvenc" => Some(Some(Encoder::Nvenc)),
Some(_) => None,
}
}
pub fn parse_codec(value: Option<&str>) -> Option<Option<CodecPref>> {
match value
.map(str::trim)
.filter(|s| !s.is_empty())
.map(|s| s.to_ascii_lowercase())
{
None => Some(None),
Some(v) if v == "auto" => Some(None),
Some(v) if v == "h264" => Some(Some(CodecPref::H264)),
Some(v) if v == "h265" || v == "hevc" => Some(Some(CodecPref::H265)),
Some(_) => None,
}
}
fn file_fields() -> (Option<String>, Option<String>) {
let path = crate::system_actions::settings_path();
let Ok(bytes) = std::fs::read(path) else { return (None, None) };
let Ok(value) = serde_json::from_slice::<serde_json::Value>(&bytes) else { return (None, None) };
let field = |name: &str| value.get(name).and_then(|v| v.as_str()).map(str::to_owned);
(field("video_encoder"), field("video_codec"))
}
/// Unset/auto tries NVENC only with an NVIDIA driver loaded: `ffmpeg -encoders` lists h264_nvenc
/// on any machine, so without this every stream start first ran a doomed NVENC process (#10).
pub fn legacy_auto(nvidia: bool) -> Encoder {
if nvidia { Encoder::Nvenc } else { Encoder::Cpu }
}
/// Auto candidate order. NVIDIA present: NVENC then CPU. No NVIDIA: CPU only.
/// VAAPI is not an auto candidate until #33 (FFmpeg-process VAAPI ignores maxrate).
/// Explicit vaapi (setting or `UU_VIDEO_ENCODER`) is unchanged.
pub fn auto_order(nvidia: bool) -> Vec<Encoder> {
if nvidia { vec![Encoder::Nvenc, Encoder::Cpu] } else { vec![Encoder::Cpu] }
}
/// Why one candidate's synthetic IDR did not count. Logged as the variant name only.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProbeFail { Timeout, NoIdr, Spawn, Exit }
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProbeOutcome {
Ok,
Fail(ProbeFail),
/// inproc-av only: the FFmpeg process probe failed, but this session would try the native
/// engine first (`read_encoder_with`) on an X11 display (not Wayland, portal, or KMS).
/// Opening that engine needs a display, so the candidate is not failed here; auto falls
/// back to the pre-probe NVIDIA/CPU choice for it.
NativeUnprobed,
/// Single auto candidate (CPU, no NVIDIA): the synthetic IDR is skipped.
NotProbed,
}
impl ProbeOutcome {
/// Counts as a successful probe for `choose_from_probe`.
/// `NativeUnprobed` does not: that candidate was not shown to encode.
pub fn ok(self) -> bool { matches!(self, Self::Ok) }
pub fn label(self) -> &'static str {
match self {
Self::Ok => "ok",
Self::Fail(ProbeFail::Timeout) => "timeout",
Self::Fail(ProbeFail::NoIdr) => "no_idr",
Self::Fail(ProbeFail::Spawn) => "spawn",
Self::Fail(ProbeFail::Exit) => "exit",
Self::NativeUnprobed => "native_unprobed",
Self::NotProbed => "not probed (only candidate)",
}
}
}
/// How a process-probe result becomes the stored outcome.
/// `native_would_run` is true only on inproc-av when `inproc_encoder::selected` is true
/// (hardware, not `UU_VIDEO_PIPELINE=process` / `UU_CAPTURE=grab` / a bundled FFmpeg).
/// A process failure then becomes `NativeUnprobed` instead of disqualifying that candidate.
/// Default builds pass `native_would_run = false`, so the process result is unchanged.
pub fn outcome_for_candidate(process: ProbeOutcome, native_would_run: bool) -> ProbeOutcome {
if process.ok() || !native_would_run { process } else { ProbeOutcome::NativeUnprobed }
}
/// Encoder auto should use when a hardware candidate was left `NativeUnprobed`.
/// That candidate is skipped by `choose_from_probe`; if it was the legacy pick (NVENC when
/// NVIDIA is present), keep the legacy encoder. Otherwise use the probe choice.
pub fn chosen_after_native(nvidia: bool, order: &[Encoder], outcomes: &[ProbeOutcome], probed: Encoder) -> Encoder {
let legacy = legacy_auto(nvidia);
let native_legacy = order.iter().zip(outcomes.iter()).any(|(e, o)| {
*e == legacy && matches!(o, ProbeOutcome::NativeUnprobed)
});
if native_legacy { legacy } else { probed }
}
/// How long a hardware-candidate failure stays cached. A boot-time NVENC miss
/// (module not ready, GPU busy, consumer session limit) must not stick until exit.
pub const PROBE_FAILURE_TTL: std::time::Duration = std::time::Duration::from_secs(600);
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProbeReport {
pub order: Vec<Encoder>,
pub outcomes: Vec<ProbeOutcome>,
pub chosen: Encoder,
/// `None` means the result does not expire (success, or CPU-only `NotProbed`).
pub expires_at: Option<std::time::Instant>,
/// `nvidia_present()` at the time the report was stored. A later desktop
/// connection whose presence differs treats the report as stale.
pub nvidia: bool,
}
impl ProbeReport {
pub fn fresh(order: Vec<Encoder>, outcomes: Vec<ProbeOutcome>, chosen: Encoder, now: std::time::Instant, nvidia: bool) -> Self {
let expires_at = probe_failure_deadline(&order, &outcomes, chosen, now);
Self { order, outcomes, chosen, expires_at, nvidia }
}
}
/// Expiry is only for the hardware candidate that caused the CPU fallback
/// (NVENC `Fail` and `chosen == Cpu`). A `Fail` on CPU while NVENC is `Ok`
/// does not expire, and doctor does not label that report a failure.
/// `NotProbed` and `Ok` do not. `NativeUnprobed` keeps the legacy encoder
/// and is not a failure cache.
pub fn probe_failure_deadline(
order: &[Encoder],
outcomes: &[ProbeOutcome],
chosen: Encoder,
now: std::time::Instant,
) -> Option<std::time::Instant> {
let hardware_failed = order.iter().zip(outcomes).any(|(encoder, outcome)| {
*encoder != Encoder::Cpu && matches!(outcome, ProbeOutcome::Fail(_))
});
(hardware_failed && chosen == Encoder::Cpu).then_some(now + PROBE_FAILURE_TTL)
}
pub fn probe_expired(report: &ProbeReport, now: std::time::Instant) -> bool {
report.expires_at.is_some_and(|at| now >= at)
}
/// Time-to-live elapsed, or NVIDIA presence no longer matches the report.
/// Presence is `nvidia_present()` (proc version or `/dev/nvidia0`).
pub fn probe_stale(report: &ProbeReport, now: std::time::Instant, nvidia: bool) -> bool {
probe_expired(report, now) || report.nvidia != nvidia
}
/// Log suffix for a probe that replaces `previous`. `None` is a first probe.
/// A failure deadline (`expires_at`) is "retry after failure". A presence
/// mismatch without that deadline is "NVIDIA availability changed".
pub fn reprobe_reason(previous: Option<&ProbeReport>, nvidia_now: bool) -> Option<&'static str> {
let previous = previous?;
if previous.expires_at.is_some() {
Some("retry after failure")
} else if previous.nvidia != nvidia_now {
Some("NVIDIA availability changed")
} else {
None
}
}
/// Empty cache, or the cached report is stale for `nvidia` at `now`.
/// Callers still use the cached encoder until the replacement probe is stored.
pub fn probe_needs_run(now: std::time::Instant, nvidia: bool) -> bool {
match cached_probe() {
None => true,
Some(report) => probe_stale(&report, now, nvidia),
}
}
/// Background warm-up (startup and each new desktop connection) runs only for auto.
/// Setting or `UU_VIDEO_ENCODER` (non-auto) matches v0.2.23: no GPU probe.
pub fn should_warm_auto_probe(source: Source) -> bool {
source == Source::Auto
}
/// First candidate that produced an IDR, else CPU.
pub fn choose_from_probe(order: &[Encoder], outcomes: &[ProbeOutcome]) -> Encoder {
order.iter().zip(outcomes.iter()).find_map(|(e, o)| o.ok().then_some(*e)).unwrap_or(Encoder::Cpu)
}
fn cache() -> &'static std::sync::Mutex<Option<ProbeReport>> {
static CACHE: std::sync::OnceLock<std::sync::Mutex<Option<ProbeReport>>> = std::sync::OnceLock::new();
CACHE.get_or_init(|| std::sync::Mutex::new(None))
}
pub fn store_probe(report: ProbeReport) {
if let Ok(mut slot) = cache().lock() { *slot = Some(report); }
}
pub fn cached_probe() -> Option<ProbeReport> {
cache().lock().ok().and_then(|g| g.clone())
}
/// Tests that call `clear_probe` / `store_probe` share this lock. The probe
/// cache is process-global and `cargo test` runs tests in parallel.
#[cfg(test)]
pub(crate) static PROBE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
/// Tests that read or bump the process-global reload generation share this lock.
#[cfg(test)]
pub(crate) static RELOAD_TEST_LOCK:std::sync::Mutex<()> = std::sync::Mutex::new(());
#[cfg(test)]
pub fn clear_probe() {
if let Ok(mut slot) = cache().lock() { *slot = None; }
}
/// Why a live desktop encoder was asked to change.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SwitchReason {
/// Effective encoder differs. The log line uses `Selection::encoder_source`, not this variant.
Encoder,
/// Codec preference changed. The negotiated codec stays until the next stream.
CodecDeferred,
}
/// What SIGUSR2 should do to one live desktop stream.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SwitchPlan {
/// Restart the encoder. None keeps the running encoder (codec-only or no change).
pub encoder: Option<Encoder>,
pub reason: SwitchReason,
/// Chroma the restarted encoder can actually produce. VAAPI has no 4:4:4.
pub chroma: u64,
/// True when the request was 4:4:4 and the new encoder must report 4:2:0.
pub chroma_downgraded: bool,
}
/// Compare the selection this stream is using with a freshly read one.
/// Codec preference is the stored preference, not the negotiated m-line codec.
pub fn plan_switch(active_encoder: Encoder, previous_codec: CodecPref, next: &Selection, active_chroma: u64) -> Option<SwitchPlan> {
if next.encoder != active_encoder {
let chroma = if active_chroma == crate::capture_setting::CHROMA_444 && !crate::video::full_chroma_for(next.encoder) {
crate::capture_setting::CHROMA_420
} else {
active_chroma
};
return Some(SwitchPlan {
encoder: Some(next.encoder),
reason: SwitchReason::Encoder,
chroma,
chroma_downgraded: chroma != active_chroma,
});
}
if next.codec_pref != previous_codec {
return Some(SwitchPlan {
encoder: None,
reason: SwitchReason::CodecDeferred,
chroma: active_chroma,
chroma_downgraded: false,
});
}
None
}
/// Monotonic generation bumped by SIGUSR2. Streams watch it and re-read `selection()`.
fn reload_generation() -> &'static std::sync::atomic::AtomicU64 {
static GEN: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
&GEN
}
pub fn reload_generation_value() -> u64 {
reload_generation().load(std::sync::atomic::Ordering::Relaxed)
}
/// SIGUSR2: ask live desktop streams to re-read host_settings. Does not clear the probe cache.
pub fn notify_reload() {
reload_generation().fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
pub fn reload_watch() -> &'static tokio::sync::watch::Sender<u64> {
static WATCH: std::sync::OnceLock<tokio::sync::watch::Sender<u64>> = std::sync::OnceLock::new();
WATCH.get_or_init(|| {
let (tx, _) = tokio::sync::watch::channel(reload_generation_value());
tx
})
}
pub fn subscribe_reload() -> tokio::sync::watch::Receiver<u64> {
reload_watch().subscribe()
}
/// True when SIGUSR2 has bumped the generation since the session snapshot.
/// A background auto probe that finishes during setup does not bump it.
pub fn reload_since_session(at_session: u64, current: u64) -> bool {
current != at_session
}
/// Publish the generation so every subscribed desktop stream wakes.
pub fn publish_reload() {
notify_reload();
// send() drops the value when nobody is subscribed (the gap between desktop connections).
reload_watch().send_replace(reload_generation_value());
}
/// Setting (non-auto) beats the environment, which beats the NVIDIA/CPU default.
pub fn selection() -> Selection {
selection_with(cached_probe().as_ref())
}
/// Same as `selection`, but auto uses `report` when it is already cached.
/// `None` keeps the legacy NVIDIA/CPU result (the probe is still running or has not started).
pub fn selection_with(report: Option<&ProbeReport>) -> Selection {
let (file_enc, file_codec) = file_fields();
let env_enc = std::env::var("UU_VIDEO_ENCODER").ok();
let env_codec = std::env::var("UU_VIDEO_CODEC").ok();
resolve_pair(file_enc.as_deref(), env_enc.as_deref(), file_codec.as_deref(), env_codec.as_deref(), crate::video::nvidia_present(), report)
}
pub fn resolve_pair(
enc_setting: Option<&str>,
enc_env: Option<&str>,
codec_setting: Option<&str>,
codec_env: Option<&str>,
nvidia: bool,
probed: Option<&ProbeReport>,
) -> Selection {
let (encoder, encoder_source) = match parse_encoder(enc_setting) {
Some(Some(e)) => (e, Source::Setting),
None => {
log::warn!("Ignoring video_encoder value (not auto/cpu/vaapi/nvenc)");
pick_encoder(enc_env, nvidia, probed)
}
Some(None) => pick_encoder(enc_env, nvidia, probed),
};
let (codec_pref, codec_source) = match parse_codec(codec_setting) {
Some(Some(p)) => (p, Source::Setting),
None => {
log::warn!("Ignoring video_codec value (not auto/h264/h265)");
pick_codec(codec_env)
}
Some(None) => pick_codec(codec_env),
};
Selection {
encoder,
encoder_source,
codec_pref,
codec_source,
}
}
fn pick_encoder(env: Option<&str>, nvidia: bool, probed: Option<&ProbeReport>) -> (Encoder, Source) {
match parse_encoder(env) {
Some(Some(e)) => (e, Source::Env),
None => {
log::warn!("Ignoring UU_VIDEO_ENCODER value (not auto/cpu/vaapi/nvenc)");
(auto_encoder(nvidia, probed), Source::Auto)
}
Some(None) => (auto_encoder(nvidia, probed), Source::Auto),
}
}
fn auto_encoder(nvidia: bool, probed: Option<&ProbeReport>) -> Encoder {
probed.map(|p| p.chosen).unwrap_or_else(|| legacy_auto(nvidia))
}
fn pick_codec(env: Option<&str>) -> (CodecPref, Source) {
match parse_codec(env) {
Some(Some(p)) => (p, Source::Env),
None => {
log::warn!("Ignoring UU_VIDEO_CODEC value (not auto/h264/h265)");
(CodecPref::Auto, Source::Auto)
}
Some(None) => (CodecPref::Auto, Source::Auto),
}
}
pub fn codec_force(pref: CodecPref) -> Option<&'static str> {
match pref {
CodecPref::H264 => Some("h264"),
CodecPref::H265 => Some("h265"),
CodecPref::Auto => None,
}
}
/// Hardware (VAAPI / NVENC) prefers H.265 unless the preference forces a codec.
pub fn hardware(encoder: Encoder) -> bool {
encoder != Encoder::Cpu
}
pub fn source_label(source: Source) -> &'static str {
match source {
Source::Setting => "setting",
Source::Env => "env",
Source::Auto => "default",
}
}
pub fn encoder_source_label(source: Source) -> &'static str {
match source {
Source::Setting => "setting",
Source::Env => "env",
Source::Auto => "auto",
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sel(
es: Option<&str>,
ee: Option<&str>,
cs: Option<&str>,
ce: Option<&str>,
nvidia: bool,
) -> Selection {
resolve_pair(es, ee, cs, ce, nvidia, None)
}
#[test]
fn priority_matrix_and_illegal_values() {
let encoders = [
None,
Some("auto"),
Some("cpu"),
Some("vaapi"),
Some("nvenc"),
Some("bogus"),
];
let codecs = [None, Some("auto"), Some("h264"), Some("h265"), Some("nope")];
for setting in encoders {
for env in encoders {
let got = sel(setting, env, None, None, true);
let expect_enc = match (parse_encoder(setting), parse_encoder(env)) {
(Some(Some(e)), _) => (e, Source::Setting),
(None, Some(Some(e))) | (Some(None), Some(Some(e))) => (e, Source::Env),
_ => (Encoder::Nvenc, Source::Auto),
};
assert_eq!(
(got.encoder, got.encoder_source),
expect_enc,
"{setting:?} {env:?}"
);
}
}
for setting in codecs {
for env in codecs {
let got = sel(None, None, setting, env, false);
let expect = match (parse_codec(setting), parse_codec(env)) {
(Some(Some(p)), _) => (p, Source::Setting),
(None, Some(Some(p))) | (Some(None), Some(Some(p))) => (p, Source::Env),
_ => (CodecPref::Auto, Source::Auto),
};
assert_eq!(
(got.codec_pref, got.codec_source),
expect,
"{setting:?} {env:?}"
);
}
}
assert_eq!(
sel(Some("auto"), Some("cpu"), Some("auto"), Some("h264"), true).encoder,
Encoder::Cpu
);
assert_eq!(
sel(Some("auto"), None, None, None, false).encoder,
Encoder::Cpu
);
assert_eq!(
sel(None, Some("auto"), None, None, true).encoder,
Encoder::Nvenc
);
assert_eq!(
sel(Some(" NVENC "), None, Some(" HEVC "), None, false).encoder,
Encoder::Nvenc
);
assert_eq!(
sel(None, None, Some(" HEVC "), None, false).codec_pref,
CodecPref::H265
);
}
#[test]
fn process_failure_keeps_native_candidate_unprobed() {
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
assert_eq!(outcome_for_candidate(ProbeOutcome::Ok, true), ProbeOutcome::Ok);
assert_eq!(outcome_for_candidate(exit, false), exit, "default build keeps the process result");
assert_eq!(outcome_for_candidate(exit, true), ProbeOutcome::NativeUnprobed);
assert!(!ProbeOutcome::NativeUnprobed.ok());
assert_eq!(ProbeOutcome::NativeUnprobed.label(), "native_unprobed");
}
#[test]
fn native_unprobed_hardware_uses_legacy_choice() {
let order = auto_order(true);
let outcomes = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok];
let probed = choose_from_probe(&order, &outcomes);
assert_eq!(probed, Encoder::Cpu);
assert_eq!(chosen_after_native(true, &order, &outcomes, probed), Encoder::Nvenc);
let cpu_only = auto_order(false);
assert_eq!(chosen_after_native(false, &cpu_only, &[ProbeOutcome::Ok], Encoder::Cpu), Encoder::Cpu);
let both_ok = [ProbeOutcome::Ok, ProbeOutcome::Ok];
assert_eq!(chosen_after_native(true, &order, &both_ok, Encoder::Nvenc), Encoder::Nvenc);
}
fn probe_report(nvidia: bool, outcomes: &[ProbeOutcome]) -> ProbeReport {
let order = auto_order(nvidia);
let chosen = choose_from_probe(&order, outcomes);
ProbeReport::fresh(order, outcomes.to_vec(), chosen, std::time::Instant::now(), nvidia)
}
#[test]
fn auto_order_keeps_nvenc_when_nvidia_is_present() {
assert_eq!(auto_order(true), vec![Encoder::Nvenc, Encoder::Cpu]);
assert_eq!(auto_order(false), vec![Encoder::Cpu]);
assert_eq!(legacy_auto(true), Encoder::Nvenc);
assert_eq!(legacy_auto(false), Encoder::Cpu);
}
#[test]
fn auto_falls_back_when_the_first_candidate_fails() {
let both = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Fail(ProbeFail::Exit)]);
assert_eq!(both.chosen, Encoder::Cpu);
let nv = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
assert_eq!(nv.chosen, Encoder::Nvenc);
let failed = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok]);
assert_eq!(failed.chosen, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, true, Some(&nv)).encoder, Encoder::Nvenc);
assert_eq!(resolve_pair(None, None, None, None, true, Some(&failed)).encoder, Encoder::Cpu);
let cpu = probe_report(false, &[ProbeOutcome::Ok]);
assert_eq!(cpu.chosen, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, false, Some(&cpu)).encoder, Encoder::Cpu);
let skipped = probe_report(false, &[ProbeOutcome::NotProbed]);
assert_eq!(skipped.chosen, Encoder::Cpu);
assert_eq!(ProbeOutcome::NotProbed.label(), "not probed (only candidate)");
assert!(!ProbeOutcome::NotProbed.ok());
assert_eq!(resolve_pair(None, None, None, None, false, Some(&skipped)).encoder, Encoder::Cpu);
}
#[test]
fn explicit_env_and_setting_ignore_the_probe() {
let va = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, Some(&va)).encoder, Encoder::Nvenc);
assert_eq!(resolve_pair(None, Some("cpu"), None, None, true, Some(&va)).encoder, Encoder::Cpu);
assert_eq!(resolve_pair(Some("vaapi"), Some("nvenc"), None, None, true, Some(&va)).encoder, Encoder::Vaapi);
assert_eq!(resolve_pair(Some("nvenc"), None, None, None, false, Some(&va)).encoder_source, Source::Setting);
assert_eq!(resolve_pair(None, Some("cpu"), None, None, false, Some(&va)).encoder_source, Source::Env);
assert_eq!(resolve_pair(Some("auto"), Some("vaapi"), None, None, false, None).encoder, Encoder::Vaapi);
assert_eq!(resolve_pair(None, None, None, Some("h264"), false, Some(&va)).codec_pref, CodecPref::H264);
}
fn selection_of(encoder: Encoder, codec: CodecPref) -> Selection {
Selection { encoder, encoder_source: Source::Setting, codec_pref: codec, codec_source: Source::Setting }
}
#[test]
fn live_switch_restarts_encoder_and_defers_codec() {
let nv = selection_of(Encoder::Nvenc, CodecPref::Auto);
assert!(plan_switch(Encoder::Nvenc, CodecPref::Auto, &nv, crate::capture_setting::CHROMA_420).is_none());
let to_cpu = plan_switch(Encoder::Nvenc, CodecPref::Auto, &selection_of(Encoder::Cpu, CodecPref::Auto), crate::capture_setting::CHROMA_444).unwrap();
assert_eq!(to_cpu.encoder, Some(Encoder::Cpu));
assert_eq!(to_cpu.reason, SwitchReason::Encoder);
assert!(!to_cpu.chroma_downgraded);
assert_eq!(to_cpu.chroma, crate::capture_setting::CHROMA_444);
let to_vaapi = plan_switch(Encoder::Nvenc, CodecPref::H265, &selection_of(Encoder::Vaapi, CodecPref::H265), crate::capture_setting::CHROMA_444).unwrap();
assert_eq!(to_vaapi.encoder, Some(Encoder::Vaapi));
assert!(to_vaapi.chroma_downgraded);
assert_eq!(to_vaapi.chroma, crate::capture_setting::CHROMA_420);
let codec = plan_switch(Encoder::Nvenc, CodecPref::Auto, &selection_of(Encoder::Nvenc, CodecPref::H264), crate::capture_setting::CHROMA_420).unwrap();
assert_eq!(codec.encoder, None);
assert_eq!(codec.reason, SwitchReason::CodecDeferred);
let both = plan_switch(Encoder::Cpu, CodecPref::Auto, &selection_of(Encoder::Nvenc, CodecPref::H264), crate::capture_setting::CHROMA_420).unwrap();
assert_eq!(both.encoder, Some(Encoder::Nvenc));
assert_eq!(both.reason, SwitchReason::Encoder);
// The log reason is the source of the new selection (setting / env / auto), not a fixed word.
for (source, label) in [(Source::Setting, "setting"), (Source::Env, "env"), (Source::Auto, "auto")] {
let mut next = selection_of(Encoder::Vaapi, CodecPref::Auto);
next.encoder_source = source;
let plan = plan_switch(Encoder::Nvenc, CodecPref::Auto, &next, crate::capture_setting::CHROMA_420).unwrap();
assert!(plan.encoder.is_some());
assert_eq!(encoder_source_label(next.encoder_source), label);
}
}
#[test]
fn reload_does_not_clear_the_probe_cache() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let report = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
store_probe(report.clone());
let before = reload_generation_value();
notify_reload();
assert_eq!(reload_generation_value(), before + 1);
assert_eq!(cached_probe(), Some(report));
assert!(reload_since_session(before, reload_generation_value()));
assert!(!reload_since_session(reload_generation_value(), reload_generation_value()));
clear_probe();
}
#[test]
fn probe_finish_is_not_a_reload_since_the_session_snapshot() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let at_session = reload_generation_value();
// A finished background probe updates the cache only. It does not bump the generation.
assert!(!reload_since_session(at_session, reload_generation_value()));
notify_reload();
assert!(reload_since_session(at_session, reload_generation_value()));
}
#[test]
fn mark_reload_seen_clears_has_changed() {
let _reload = RELOAD_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
rt.block_on(async {
let mut watch = subscribe_reload();
let _ = watch.borrow_and_update();
publish_reload();
assert!(watch.has_changed().unwrap());
let _ = watch.borrow_and_update();
assert!(!watch.has_changed().unwrap());
});
}
/// Codec at CONTROL open is `preferred_codec_for` on the session snapshot.
/// Auto + CPU uses H.264 when both codecs are negotiated; auto + NVENC keeps H.265.
/// Forced codec ignores the encoder. 真彩 does not switch codec (true_color_keeps_codec_and_vaapi_reports_420).
#[test]
fn auto_codec_follows_the_encoder_chosen_at_session_setup() {
use crate::capture_setting::{preferred_codec_for, VideoCodec};
let cpu_fallback = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Ok]);
let session = resolve_pair(None, None, None, None, true, Some(&cpu_fallback));
assert_eq!((session.encoder, session.encoder_source, session.codec_pref), (Encoder::Cpu, Source::Auto, CodecPref::Auto));
assert_eq!(preferred_codec_for(true, true, session), VideoCodec::H264);
// Not the H.265 an unfinished probe would pick for legacy NVENC.
let early_nvenc = resolve_pair(None, None, None, None, true, None);
assert_eq!(early_nvenc.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, early_nvenc), VideoCodec::H265);
let nvenc_ok = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
let nvenc = resolve_pair(None, None, None, None, true, Some(&nvenc_ok));
assert_eq!(nvenc.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, nvenc), VideoCodec::H265);
let order = auto_order(true);
let unprobed = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok];
let chosen = chosen_after_native(true, &order, &unprobed, choose_from_probe(&order, &unprobed));
let report = ProbeReport::fresh(order.clone(), unprobed.to_vec(), chosen, std::time::Instant::now(), true);
let native = resolve_pair(None, None, None, None, true, Some(&report));
assert_eq!(native.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, native), VideoCodec::H265);
let forced_h264 = resolve_pair(None, None, Some("h264"), None, true, Some(&nvenc_ok));
assert_eq!(forced_h264.encoder, Encoder::Nvenc);
assert_eq!(preferred_codec_for(true, true, forced_h264), VideoCodec::H264);
let forced_h265 = resolve_pair(None, None, None, Some("h265"), true, Some(&cpu_fallback));
assert_eq!(forced_h265.encoder, Encoder::Cpu);
assert_eq!(preferred_codec_for(true, true, forced_h265), VideoCodec::H265);
}
#[test]
fn session_before_probe_uses_legacy_auto() {
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
clear_probe();
assert!(cached_probe().is_none());
let early = resolve_pair(None, None, None, None, false, None);
assert_eq!((early.encoder, early.encoder_source), (Encoder::Cpu, Source::Auto));
assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc);
store_probe(probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok]));
assert_eq!(cached_probe().unwrap().chosen, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, Encoder::Cpu);
// A snapshot taken before the cache filled stays on the legacy encoder.
assert_eq!(early.encoder, Encoder::Cpu);
assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc);
clear_probe();
}
#[test]
fn success_and_not_probed_do_not_expire() {
let now = std::time::Instant::now();
let later = now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1);
let ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true);
assert!(ok.expires_at.is_none());
assert!(!probe_expired(&ok, later));
let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
assert!(skipped.expires_at.is_none());
assert!(!probe_expired(&skipped, later));
let native = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok],
Encoder::Nvenc,
now,
true,
);
assert!(native.expires_at.is_none(), "native_unprobed is not a recorded process failure");
assert!(!probe_expired(&native, later));
}
#[test]
fn hardware_failure_expires_after_ttl() {
let now = std::time::Instant::now();
let failed = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok],
Encoder::Cpu,
now,
true,
);
assert!(!probe_expired(&failed, now + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1)));
assert!(probe_expired(&failed, now + PROBE_FAILURE_TTL));
assert_eq!(failed.chosen, Encoder::Cpu);
}
/// NVENC produced an IDR and CPU failed: the session uses NVENC, so this is
/// not the hardware-fallback cache. No TTL, and doctor (which keys off
/// `expires_at`) does not append the failure label.
#[test]
fn nvenc_ok_cpu_fail_does_not_expire() {
let now = std::time::Instant::now();
let report = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Ok, ProbeOutcome::Fail(ProbeFail::Exit)],
Encoder::Nvenc,
now,
true,
);
assert_eq!(report.chosen, Encoder::Nvenc);
assert!(report.expires_at.is_none());
assert!(!probe_expired(&report, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1)));
let cpu_only_fail = ProbeReport::fresh(
auto_order(false),
vec![ProbeOutcome::Fail(ProbeFail::Exit)],
Encoder::Cpu,
now,
false,
);
assert!(cpu_only_fail.expires_at.is_none(), "a CPU-only Fail is not a hardware fallback");
}
/// Failed NVENC stays CPU until `PROBE_FAILURE_TTL`. After that a desktop connection
/// asks for one background re-probe (`probe_needs_run`, what `warm_auto_probe` checks)
/// and still selects the cached CPU encoder. A successful re-probe selects NVENC and
/// does not expire. A second failure restarts the TTL.
#[test]
fn failure_then_reprobe_success_selects_nvenc() {
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
clear_probe();
let t0 = std::time::Instant::now();
let failed = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok],
Encoder::Cpu,
t0,
true,
);
store_probe(failed);
let before = t0 + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1);
assert!(!probe_needs_run(before, true), "no re-probe before the failure expires");
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Cpu
);
let after = t0 + PROBE_FAILURE_TTL;
assert!(probe_expired(cached_probe().as_ref().unwrap(), after));
assert!(probe_needs_run(after, true), "desktop connection starts one background re-probe");
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Cpu,
"the connection that notices expiry still uses the cached encoder"
);
let retried = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Ok, ProbeOutcome::Ok],
Encoder::Nvenc,
after,
true,
);
store_probe(retried);
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Nvenc
);
assert!(!probe_needs_run(after + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), true));
let failed_again = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok],
Encoder::Cpu,
after,
true,
);
store_probe(failed_again);
assert!(!probe_needs_run(after + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1), true));
assert!(probe_needs_run(after + PROBE_FAILURE_TTL, true));
clear_probe();
}
/// A CPU-only `NotProbed` report does not expire by time. When NVIDIA appears
/// (module or device after the user service started), the next desktop
/// connection treats it as stale and `probe_needs_run` asks for one background
/// re-probe. The inverse (NVENC success, device gone) is stale the same way.
/// The connection that notices still selects the cached encoder.
#[test]
fn nvidia_presence_change_makes_probe_stale() {
let now = std::time::Instant::now();
let cpu_only = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
assert!(!probe_stale(&cpu_only, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), false));
assert!(probe_stale(&cpu_only, now, true), "NVIDIA appeared after the CPU-only skip");
let nvenc_ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true);
assert!(!probe_stale(&nvenc_ok, now, true));
assert!(probe_stale(&nvenc_ok, now, false), "NVIDIA gone after a successful NVENC probe");
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
clear_probe();
store_probe(cpu_only);
assert!(!probe_needs_run(now, false));
assert!(probe_needs_run(now, true));
assert_eq!(
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
Encoder::Cpu,
"the connection that notices the presence change still uses the cached encoder"
);
clear_probe();
}
#[test]
fn reprobe_reason_follows_previous_state() {
let now = std::time::Instant::now();
assert_eq!(reprobe_reason(None, false), None);
assert_eq!(reprobe_reason(None, true), None);
let failed = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok],
Encoder::Cpu,
now,
true,
);
assert!(failed.expires_at.is_some());
assert_eq!(reprobe_reason(Some(&failed), true), Some("retry after failure"));
assert_eq!(reprobe_reason(Some(&failed), false), Some("retry after failure"));
let nvenc_ok = ProbeReport::fresh(
auto_order(true),
vec![ProbeOutcome::Ok, ProbeOutcome::Ok],
Encoder::Nvenc,
now,
true,
);
assert_eq!(reprobe_reason(Some(&nvenc_ok), true), None);
assert_eq!(reprobe_reason(Some(&nvenc_ok), false), Some("NVIDIA availability changed"));
let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
assert_eq!(reprobe_reason(Some(&skipped), false), None);
assert_eq!(reprobe_reason(Some(&skipped), true), Some("NVIDIA availability changed"));
assert_ne!(reprobe_reason(Some(&nvenc_ok), false), Some("retry after failure"));
assert_ne!(reprobe_reason(Some(&skipped), true), Some("retry after failure"));
}
#[test]
fn warm_probe_only_when_encoder_source_is_auto() {
assert!(should_warm_auto_probe(Source::Auto));
assert!(!should_warm_auto_probe(Source::Setting));
assert!(!should_warm_auto_probe(Source::Env));
assert_eq!(resolve_pair(Some("cpu"), None, None, None, true, None).encoder_source, Source::Setting);
assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, None).encoder_source, Source::Env);
assert_eq!(resolve_pair(None, Some("auto"), None, None, false, None).encoder_source, Source::Auto);
}
}
+123
View File
@@ -0,0 +1,123 @@
//! Exercise the real video loop and RTP transport without cloud or desktop access.
//! Thread-local faults are confined to each test's current-thread Tokio runtime.
use super::*;
use std::cell::RefCell;
use webrtc::{api::{APIBuilder, media_engine::MediaEngine},
peer_connection::configuration::RTCConfiguration,
rtp_transceiver::rtp_codec::RTPCodecType};
pub(super) const DISPLAY: &str = "wayland:test-wake";
struct Faults { wake_calls: AtomicUsize, fail_wake: usize, fail_capture: bool, stop: AtomicBool }
thread_local! { static FAULTS: RefCell<Option<Arc<Faults>>> = const { RefCell::new(None) }; }
struct Reset;
impl Drop for Reset { fn drop(&mut self) { FAULTS.with(|value| *value.borrow_mut() = None); } }
pub(super) fn active() -> bool { FAULTS.with(|value| value.borrow().is_some()) }
pub(super) fn wake() -> Option<Result<(), String>> {
FAULTS.with(|value| value.borrow().as_ref().map(|faults| {
let call = faults.wake_calls.fetch_add(1, Ordering::SeqCst) + 1;
if call == faults.fail_wake { Err("Wayland output power control unavailable".into()) } else { Ok(()) }
}))
}
pub(super) async fn encode(latest: mpsc::Sender<Arc<CompleteFrame>>, settings: VideoSettings,
sequence: Arc<std::sync::atomic::AtomicU64>, budget: Arc<Semaphore>) -> Result<(), String> {
let faults = FAULTS.with(|value| value.borrow().clone()).expect("test faults installed");
loop {
tokio::time::sleep(Duration::from_millis(10)).await;
if faults.stop.load(Ordering::SeqCst) { return Ok(()); }
if faults.fail_capture && sequence.load(Ordering::Relaxed) >= 4 {
return Err("synthetic capture failed".into());
}
let permit = budget.clone().acquire_owned().await.map_err(|_| "test budget closed")?;
let frame = Arc::new(CompleteFrame {
source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1,
completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2], _permit: Some(permit),
});
if latest.send(frame).await.is_err() { return Ok(()); }
}
}
async fn exercise(fail_wake: usize, fail_capture: bool) {
tokio::time::timeout(Duration::from_secs(15), async {
let faults = Arc::new(Faults { wake_calls: AtomicUsize::new(0), fail_wake, fail_capture, stop: AtomicBool::new(false) });
FAULTS.with(|value| *value.borrow_mut() = Some(faults.clone()));
let _reset = Reset;
let (host_setting, remote_setting, router) = crate::test_network::virtual_network().await;
let mut media = MediaEngine::default();
media.register_default_codecs().unwrap();
let host = Arc::new(APIBuilder::new().with_setting_engine(host_setting).with_media_engine(media)
.build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let mut media = MediaEngine::default();
media.register_default_codecs().unwrap();
let remote = APIBuilder::new().with_setting_engine(remote_setting).with_media_engine(media)
.build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
remote.add_transceiver_from_kind(RTPCodecType::Video, None).await.unwrap();
let _control = remote.create_data_channel("CONTROL_DATA_CHANNEL", None).await.unwrap();
let track = Arc::new(crate::video_track::VideoTrack::new());
host.add_track(track.clone()).await.unwrap();
let (packets, mut received) = mpsc::unbounded_channel();
remote.on_track(Box::new(move |track, _, _| {
let packets = packets.clone();
Box::pin(async move {
tokio::spawn(async move {
while let Ok((packet, _)) = track.read_rtp().await {
if packets.send(packet).is_err() { break; }
}
});
})
}));
let mut gathered = remote.gathering_complete_promise().await;
remote.set_local_description(remote.create_offer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
host.set_remote_description(remote.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
host.set_local_description(host.create_answer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
remote.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
let settings = VideoSettings { source_id: 0, source_generation: 0, ..Default::default() };
let (settings_tx, settings_rx) = tokio::sync::watch::channel(settings);
let selection = crate::video_select::resolve_pair(Some("cpu"), None, Some("h264"), None, false, None);
let mut task = tokio::spawn(stream_desktop(host.clone(), track.clone(), (640, 480),
DISPLAY.into(), None, settings_rx, Arc::new(settings_tx), Arc::new(AtomicBool::new(false)), selection, None));
let result = if fail_capture {
Some((&mut task).await.unwrap())
} else {
let mut previous: Option<u16> = None;
for _ in 0..6 {
tokio::select! {
result = &mut task => panic!("video stopped after a recoverable wake failure: {result:?}"),
packet = received.recv() => {
let packet = packet.expect("RTP receiver closed");
if let Some(sequence) = previous {
assert_eq!(packet.header.sequence_number, sequence.wrapping_add(1));
}
previous = Some(packet.header.sequence_number);
}
}
}
assert!(faults.wake_calls.load(Ordering::SeqCst) > fail_wake, "wake was not retried");
None
};
assert!(track.revision() >= 4, "video must continue across wake failure");
let result = match result {
Some(result) => result,
None => {
faults.stop.store(true, Ordering::SeqCst);
task.await.unwrap()
},
};
host.close().await.unwrap();
remote.close().await.unwrap();
router.lock().await.stop().await.unwrap();
assert_eq!(result, if fail_capture { Err("synthetic capture failed".into()) } else { Ok(()) });
}).await.expect("video wake regression timed out");
}
#[tokio::test]
async fn startup_wake_failure_does_not_stop_video() { exercise(1, false).await; }
#[tokio::test]
async fn periodic_wake_failure_does_not_stop_video() { exercise(2, false).await; }
#[tokio::test]
async fn capture_failure_still_stops_video_after_wake_failure() { exercise(2, true).await; }
+1 -1
View File
@@ -37,7 +37,7 @@ impl Decoder for Ffmpeg {
let mut rgb=av::frame::Video::empty();scaler.run(&decoded,&mut rgb).map_err(|_|"Frame conversion failed")?;
let mut data=Vec::with_capacity(w as usize*h as usize*3);
for row in 0..h as usize {let start=row*rgb.stride(0);data.extend_from_slice(&rgb.data(0)[start..start+w as usize*3]);}
frames.push(Frame{width:w,height:h,rgb:data});
frames.push(Frame{width:w,height:h,rgb:data,content:None});
} Ok(frames)
}
}
+46 -8
View File
@@ -1,13 +1,16 @@
//! H.264/H.265 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
//! Needs only the ffmpeg CLI, not FFmpeg development libraries.
//! Output is scaled into a fixed letterboxed size so every frame has a known byte length.
//! Output is scaled into a fixed letterboxed canvas so every frame has a known byte length; the
//! source size from ffmpeg's stream line tells the window which sub-rectangle is picture content.
use super::desktop::{Decoder,Frame};
use super::media::Codec;
use std::io::{Read,Write};
use std::io::{BufRead,Read,Write};
use std::process::{Child,ChildStdin,Command,Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64,Ordering};
use std::sync::mpsc::{Receiver,TryRecvError};
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32 }
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32, source:Arc<AtomicU64> }
impl Cli {
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
@@ -23,16 +26,27 @@ impl Cli {
let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2");
let passthrough=passthrough_args(&ffmpeg);
let mut child=Command::new(&ffmpeg)
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
.args(["-hide_banner","-loglevel","info","-nostats","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an","-vf",&filter,
"-pix_fmt","rgb24",
// Raw H.264/H.265 carries no timestamps; constant-rate output dropped almost every frame of
// the official Mac host's stream (270 → 2). Pass frames through unchanged.
passthrough.0,passthrough.1,"-f","rawvideo","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null())
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped())
.spawn().map_err(|e|format!("Start ffmpeg decoder: {e}"))?;
let input=child.stdin.take().ok_or("ffmpeg stdin missing")?;
let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?;
// Source picture size from the one-time stream line; 0 until parsed. Only the numbers are kept.
let source=Arc::new(AtomicU64::new(0));
if let Some(stderr)=child.stderr.take() {
let source=source.clone();
let _=std::thread::Builder::new().name("uu-viewer-ffmpeg-info".into()).spawn(move||{
for line in std::io::BufReader::new(stderr).lines().map_while(Result::ok) {
if source.load(Ordering::Relaxed)!=0 {continue}
if let Some((w,h))=parse_video_size(&line) {source.store((u64::from(w)<<32)|u64::from(h),Ordering::Relaxed);}
}
});
}
let size=width as usize*height as usize*3;
// Bounded: a slow window drops decoded frames instead of growing memory.
let (tx,frames)=std::sync::mpsc::sync_channel(2);
@@ -43,10 +57,23 @@ impl Cli {
match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
}
}).map_err(|e|format!("Decoder reader: {e}"))?;
Ok(Self{child,input:Some(input),codec,frames,width,height})
Ok(Self{child,input:Some(input),codec,frames,width,height,source})
}
}
/// `30000/1001`-style or display strings are irrelevant here: the first WxH on a `Video:` line is the
/// coded picture size, which is the aspect the scale+pad filter letterboxes into the canvas.
fn parse_video_size(line:&str)->Option<(u32,u32)> {
let rest=line.split_once("Video:")?.1;
rest.split(|c:char|c==','||c==' '||c=='('||c==')'||c=='['||c==']').find_map(|token|{
let token=token.trim_matches(|c:char|!c.is_ascii_digit()&&c!='x');
let (w,h)=token.split_once('x')?;
if w.is_empty()||h.is_empty()||!w.bytes().all(|b|b.is_ascii_digit())||!h.bytes().all(|b|b.is_ascii_digit()) {return None}
let (w,h)=(w.parse::<u32>().ok()?,h.parse::<u32>().ok()?);
((16..=16384).contains(&w)&&(16..=16384).contains(&h)).then_some((w,h))
})
}
/// FFmpeg ≥ 5.1 has `-fps_mode`; FFmpeg 8+ removed `-vsync`, and Ubuntu 22.04's 4.4 lacks `-fps_mode`.
/// Probe once per binary with a one-frame null run instead of parsing version strings.
fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) {
@@ -75,7 +102,11 @@ impl Decoder for Cli {
let mut out=Vec::new();
loop {
match self.frames.try_recv() {
Ok(rgb)=>out.push(Frame{width:self.width,height:self.height,rgb}),
Ok(rgb)=>{
let source=self.source.load(Ordering::Relaxed);
let content=(source!=0).then(||((source>>32) as u32,source as u32));
out.push(Frame{width:self.width,height:self.height,rgb,content})
},
Err(TryRecvError::Empty)=>break,
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
}
@@ -115,7 +146,7 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
// Exercise the same streaming process and RGB conversion as SDL, then drain at EOF.
let mut frames=cli.decode(data).unwrap();drop(cli.input.take());
loop {match cli.frames.recv_timeout(std::time::Duration::from_secs(5)) {
Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb}),
Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb,content:None}),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break,
Err(e)=>panic!("{codec:?} decoder did not finish: {e}"),
}}
@@ -128,4 +159,11 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
}
}
}
#[test] fn source_size_is_read_from_the_ffmpeg_stream_line(){
assert_eq!(super::parse_video_size(" Stream #0:0: Video: h264 (High), yuv420p(progressive), 3024x1964, 25 fps"),Some((3024,1964)));
assert_eq!(super::parse_video_size("Stream #0:0: Video: hevc, yuv420p, 1920x1080 [SAR 1:1 DAR 16:9]"),Some((1920,1080)));
assert_eq!(super::parse_video_size("Stream #0:0: Audio: opus, 48000 Hz, stereo"),None);
assert_eq!(super::parse_video_size("frame= 1 fps=0.0 q=0.0"),None);
assert_eq!(super::parse_video_size("Stream #0:0: Video: h264, 1920xsynth"),None);
}
}
+3 -2
View File
@@ -5,7 +5,8 @@ pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<Ato
impl Default for Desktop {
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
}
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8> }
/// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); }
pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
/// Counts only (access units, presented frames, decode errors) for the periodic stats line.
@@ -29,7 +30,7 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
}
#[cfg(test)] mod tests {
use super::*;
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3]}])}} fn reset(&mut self){self.0=false;}}
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3],content:None}])}} fn reset(&mut self){self.0=false;}}
struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}}
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
}
+43
View File
@@ -35,6 +35,15 @@ pub fn mac_keycode(scan:i32)->Option<i32>{
_=>return None,
})
}
/// The content rectangle inside a decoder canvas padded to a fixed size (ffmpeg's scale+pad).
/// Mirrors `force_original_aspect_ratio=decrease,pad=…:(ow-iw)/2:(oh-ih)/2` so pointer input
/// ignores the padding instead of compressing the valid area.
pub fn content_rect(canvas:(u32,u32),content:(u32,u32))->Option<(f64,f64,f64,f64)> {
if canvas.0==0||canvas.1==0||content.0==0||content.1==0 {return None}
let scale=(canvas.0 as f64/content.0 as f64).min(canvas.1 as f64/content.1 as f64);
let(w,h)=(content.0 as f64*scale,content.1 as f64*scale);
Some(((canvas.0 as f64-w)/2.,(canvas.1 as f64-h)/2.,w,h))
}
#[derive(Clone,Copy,Debug,PartialEq)]
pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 }
impl Viewport {
@@ -75,6 +84,14 @@ impl Input {
let changed=if down{self.buttons.insert(button)}else{self.buttons.remove(&button)};
changed.then(||json!({"action":if down{"mouse_press"}else{"mouse_release"},"button":button}))
}
/// SDL wheel units are notches; the wire uses the Mac convention (one notch = 120).
/// Positive y is wheel-up, matching the host's `mouse_scroll` (button 4).
pub fn scroll(&mut self,x:f64,y:f64)->Option<Value> {
if self.view_only {return None}
let(dx,dy)=((x*120.).round() as i32,(y*120.).round() as i32);
if dx==0&&dy==0 {return None}
Some(json!({"action":"mouse_scroll","delta_x":dx,"delta_y":dy}))
}
pub fn release_all(&mut self)->Vec<Value> {
let mut out=Vec::new();
for key in std::mem::take(&mut self.keys).into_values().collect::<BTreeSet<_>>() {out.push(json!({"action":"kbd_release","key":key}));}
@@ -117,6 +134,15 @@ impl Input {
assert!(view_only(None,Some("1")).unwrap());assert!(view_only(Some("--view-only"),Some("0")).unwrap());
assert!(view_only(Some("invalid"),None).is_err());
}
#[test] fn wheel_notches_use_mac_wire_units(){
let mut i=Input::default();
assert_eq!(i.scroll(0.,1.).unwrap(),json!({"action":"mouse_scroll","delta_x":0,"delta_y":120}));
assert_eq!(i.scroll(0.,-1.).unwrap()["delta_y"],-120);
assert_eq!(i.scroll(1.,-2.).unwrap(),json!({"action":"mouse_scroll","delta_x":120,"delta_y":-240}));
assert_eq!(i.scroll(0.,0.1).unwrap()["delta_y"],12); // precise trackpad deltas
assert!(i.scroll(0.,0.).is_none());
assert!(Input::new(true).scroll(0.,1.).is_none());
}
#[test] fn mappings_encoding_and_focus() {
for (scan,vk) in [(4,65),(29,90),(39,48),(58,112),(80,37),(224,162),(230,165),(52,222)] {assert_eq!(windows_vk(scan),Some(vk));}
assert_eq!(windows_vk(100),None);
@@ -138,4 +164,21 @@ assert!(i.release_all().is_empty());
assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0);
assert!(v.motion(f64::NAN,0.).is_none());
}
#[test] fn padded_canvas_maps_only_its_content_rectangle(){
// 16:10 picture inside the default 16:9 canvas: 1728x1080 centred, 96 px pillarbox each side.
assert_eq!(content_rect((1920,1080),(1280,800)),Some((96.,0.,1728.,1080.)));
assert_eq!(content_rect((1920,1080),(1920,1080)),Some((0.,0.,1920.,1080.)));
// 4:3 picture: 1440x1080 centred, 240 px each side.
assert_eq!(content_rect((1920,1080),(640,480)),Some((240.,0.,1440.,1080.)));
assert_eq!(content_rect((0,1080),(640,480)),None);
// The content rectangle's edges are the screen edges, not the canvas edges.
let (x,y,w,h)=content_rect((1920,1080),(1280,800)).unwrap();
let v=Viewport::fit((1920,1080),(1280,800));
assert_eq!((x,y,w,h),(v.x,v.y,v.width,v.height));
let abs=|px:f64|v.motion(px,540.).unwrap();
assert_eq!(abs(96.)["abs_x"],0.0);
assert_eq!(abs(960.)["abs_x"],0.5);
assert_eq!(abs(1824.)["abs_x"],1.0);
assert_eq!(abs(0.)["abs_x"],0.0); // padding is clamped to the screen edge
}
}
+2
View File
@@ -21,6 +21,8 @@ pub mod tools;
pub mod clipboard;
pub mod power;
pub mod secure_input;
pub mod type_ipc;
fn device_label(name:Option<&str>)->&str{
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
+246 -9
View File
@@ -1,7 +1,9 @@
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
#[derive(Debug)] enum Command { Files, Type }
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest> }
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest>,
pub last_frame:Option<Frame> }
impl Window {
pub fn new()->Result<Self,String>{
let sdl=sdl2::init()?;let video=sdl.video()?;
@@ -9,7 +11,7 @@ impl Window {
let canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
let events=sdl.event_pump()?;let clipboard=video.clipboard();
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16);
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests})
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests,last_frame:None})
}
pub fn clipboard_bridge(&self)->super::clipboard::Bridge{super::clipboard::Bridge::sdl(self.clipboard_tx.clone())}
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
@@ -79,6 +81,11 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64),
Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
Event::MouseButtonUp{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,false)),
Event::MouseWheel{x,y,precise_x,precise_y,direction,..}=>{
let(dx,dy)=if precise_x!=0.||precise_y!=0.{(f64::from(precise_x),f64::from(precise_y))}else{(f64::from(x),f64::from(y))};
let(dx,dy)=match direction{sdl2::mouse::MouseWheelDirection::Flipped=>(-dx,-dy),_=>(dx,dy)};
input.scroll(dx,dy)
},
_=>None,
};if let Some(m)=message{messages.push(m);}
} (quit,messages)
@@ -87,28 +94,47 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}}
impl FrameSink for Window {
fn present(&mut self,frame:&Frame)->Result<(),String>{
self.frame=(frame.width,frame.height);let v=self.viewport();let creator=self.canvas.texture_creator();
self.last_frame=Some(Frame{width:frame.width,height:frame.height,rgb:frame.rgb.clone(),content:frame.content});
// Pad bars belong to the decoded canvas, not the remote picture: viewport and input use the
// content aspect, and only the content sub-rectangle of the texture is drawn.
let content=frame.content.unwrap_or((frame.width,frame.height));
self.frame=content;let v=self.viewport();let creator=self.canvas.texture_creator();
let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?;
texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?;
self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();
self.canvas.copy(&texture,None,Some(Rect::new(v.x as i32,v.y as i32,v.width as u32,v.height as u32)))?;self.canvas.present();Ok(())
let src=super::input::content_rect((frame.width,frame.height),content)
.map(|(x,y,w,h)|Rect::new(x.round() as i32,y.round() as i32,w.round().max(1.) as u32,h.round().max(1.) as u32));
self.canvas.copy(&texture,src,Some(Rect::new(v.x.round() as i32,v.y.round() as i32,v.width.round().max(1.) as u32,v.height.round().max(1.) as u32)))?;self.canvas.present();Ok(())
}
}
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool)->Result<(),String>{
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool,device:&str)->Result<(),String>{
#[cfg(uu_gtk)]
let mut files:Option<tokio::task::JoinHandle<Result<(),String>>>=None;
let(tx,mut commands)=tokio::sync::mpsc::channel(8);
let(tx,mut commands)=tokio::sync::mpsc::channel::<Command>(8);
if std::env::var("UU_VIEWER_COMMANDS").as_deref()==Ok("1") {
std::thread::spawn(move||{
use std::io::Read;
let mut input=std::io::stdin().lock();let mut line=Vec::new();let mut byte=[0];
while input.read(&mut byte).ok()==Some(1){
if byte[0]==b'\n'{if line==b"files" && tx.blocking_send(()).is_err(){break}line.clear();}
if byte[0]==b'\n'{
let cmd=match line.as_slice(){b"files"=>Some(Command::Files),b"type"=>Some(Command::Type),_=>None};
line.clear();
if let Some(cmd)=cmd { if tx.blocking_send(cmd).is_err(){break} }
}
else if line.len()<32{line.push(byte[0]);}else{break}
}
});
}else{drop(tx);}
let mut command_open=true;let mut requested=false;
let(type_tx,mut type_rx)=tokio::sync::mpsc::channel::<super::type_ipc::PendingType>(4);
let type_ipc=match super::type_ipc::Server::bind(device).await {
Ok(server)=>{
log::info!("Type IPC ready for device key {}", &super::type_ipc::device_key(device)[..12]);
Some(tokio::spawn(async move { server.run(type_tx).await; }))
}
Err(e)=>{ log::warn!("Type IPC not started: {e}"); None }
};
let mut command_open=true;let mut requested=false;let mut type_requested=false;
let mut type_job:Option<TypeJob>=None;
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
let mut audio=super::audio::Playback::new(&window._sdl,session.peer.audio.clone());
let mut input=Input::new(view_only);input.set_mac(window.mac);let mut tick=tokio::time::interval(std::time::Duration::from_millis(8));
@@ -116,7 +142,32 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
let deadline=tokio::time::sleep(std::time::Duration::from_secs(30));tokio::pin!(deadline);
let result=async {
loop {tokio::select!{
command=commands.recv(),if command_open=>{if command.is_some(){requested=true}else{command_open=false}},
command=commands.recv(),if command_open=>{
match command {
Some(Command::Files)=>{requested=true},
Some(Command::Type)=>{type_requested=true},
None=>{command_open=false},
}
},
pending=type_rx.recv()=>{
if let Some(mut pending)=pending {
if type_job.is_some() {
let _=pending.reply.send(super::type_ipc::TypeResponse{ok:false,events:0,chars:0,snapshot:None,error:Some("Secure input busy".into())});
} else {
let mut snapshot_create_new=false;
if pending.request.snapshot.as_ref().map_or(true, |s| s.is_empty()) {
if let Ok(path)=super::type_ipc::default_snapshot_path(device) {
pending.request.snapshot=Some(path.display().to_string());
snapshot_create_new=true;
}
}
match start_type_job(pending, window.mac, input.enabled(), snapshot_create_new) {
Ok(job)=>type_job=Some(job),
Err(())=>{},
}
}
}
},
_=terminate.recv()=>return Ok(()),
_=tokio::signal::ctrl_c()=>return Ok(()),
result=session.step()=>result?,
@@ -145,6 +196,34 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
}
}
#[cfg(not(uu_gtk))] {if requested{log::warn!("File window requires GTK3");requested=false;}}
if type_requested {
type_requested=false;
if type_job.is_some() {
log::warn!("Secure type command ignored: busy");
} else if !input.enabled() {
log::warn!("Secure type command ignored: view-only session");
} else if std::env::var_os("UU_INPUT_ENV").is_none() {
log::warn!("Secure type command ignored: set UU_INPUT_ENV (stdin is the command channel)");
} else {
match super::secure_input::load_secret(std::io::Cursor::new([] as [u8;0])) {
Ok(mut secret)=>{
match enqueue_local_type(&mut type_job, &mut secret, window.mac, None, 0, std::time::Duration::ZERO, None) {
Ok(())=>{},
Err(e)=>log::warn!("Secure type failed: {e}"),
}
}
Err(e)=>log::warn!("Secure type load failed: {e}"),
}
}
}
if let Some(job)=type_job.as_mut() {
if let Err(e)=pump_type_job(job, session, window).await {
log::warn!("Secure type job failed: {e}");
type_job=None;
} else if job.done {
type_job=None;
}
}
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
else {input.release_all();}
if quit{return Ok(())}
@@ -157,10 +236,150 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
}}
}.await;
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
if let Some(t)=type_ipc {t.abort();let _=t.await;}
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
result
}
struct TypeJob {
actions: super::secure_input::ActionList,
index: usize,
delay: std::time::Duration,
next_at: tokio::time::Instant,
chars: usize,
snapshot_path: Option<std::path::PathBuf>,
snapshot_create_new: bool,
phase: TypePhase,
reply: Option<tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>>,
done: bool,
}
enum TypePhase { Sending, WaitSnap(tokio::time::Instant) }
fn start_type_job(mut pending: super::type_ipc::PendingType, mac: bool, enabled: bool, snapshot_create_new: bool) -> Result<TypeJob, ()> {
let reply = pending.reply;
let respond_err = |reply: tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>, msg: String| {
let _ = reply.send(super::type_ipc::TypeResponse{ok:false,events:0,chars:0,snapshot:None,error:Some(msg)});
};
if !enabled {
respond_err(reply, "view-only session".into());
return Err(());
}
let mut secret = super::secure_input::Secret::new(std::mem::take(&mut pending.request.secret));
if let Err(e) = secret.omit_last_chars(pending.request.omit_last) {
respond_err(reply, e);
return Err(());
}
let chars = secret.chars_count();
let actions = match super::secure_input::expand(secret.as_str(), mac) {
Ok(a) => a,
Err(e) => { respond_err(reply, e); return Err(()); }
};
drop(secret);
log::info!("Secure input prepared: chars={} events={} delay_ms={}", chars, actions.len(), pending.request.delay_ms);
let snapshot_path = pending.request.snapshot.as_ref().filter(|s| !s.is_empty()).map(std::path::PathBuf::from);
Ok(TypeJob {
actions,
index: 0,
delay: std::time::Duration::from_millis(pending.request.delay_ms.min(5_000)),
next_at: tokio::time::Instant::now(),
chars,
snapshot_path,
snapshot_create_new,
phase: TypePhase::Sending,
reply: Some(reply),
done: false,
})
}
fn enqueue_local_type(
slot: &mut Option<TypeJob>,
secret: &mut super::secure_input::Secret,
mac: bool,
snapshot: Option<std::path::PathBuf>,
omit_last: usize,
delay: std::time::Duration,
reply: Option<tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>>,
) -> Result<(), String> {
secret.omit_last_chars(omit_last)?;
let chars = secret.chars_count();
let actions = super::secure_input::expand(secret.as_str(), mac)?;
drop(std::mem::replace(secret, super::secure_input::Secret::new(String::new())));
log::info!("Secure input prepared: chars={} events={}", chars, actions.len());
*slot = Some(TypeJob {
actions,
index: 0,
delay,
next_at: tokio::time::Instant::now(),
chars,
snapshot_path: snapshot,
snapshot_create_new: false,
phase: TypePhase::Sending,
reply,
done: false,
});
Ok(())
}
async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Window) -> Result<(), String> {
use super::type_ipc::TypeResponse;
match job.phase {
TypePhase::Sending => {
if !session.peer.ready(super::rtc::ReadyPolicy::EchoOnly, false) {
return Ok(());
}
if tokio::time::Instant::now() < job.next_at {
return Ok(());
}
if job.index >= job.actions.len() {
let wait = tokio::time::Instant::now() + std::time::Duration::from_secs(1);
job.phase = TypePhase::WaitSnap(wait);
return Ok(());
}
let action = &job.actions[job.index];
session.peer.send_input(&action.to_json()).await?;
job.index += 1;
if !job.delay.is_zero() {
job.next_at = tokio::time::Instant::now() + job.delay;
}
Ok(())
}
TypePhase::WaitSnap(deadline) => {
if tokio::time::Instant::now() < deadline {
return Ok(());
}
let mut snap = None;
if let Some(path) = job.snapshot_path.clone() {
if let Some(frame) = window.last_frame.as_ref() {
match super::type_ipc::write_png_rgb(&path, frame.width, frame.height, &frame.rgb, job.snapshot_create_new) {
Ok(()) => {
log::info!("Secure input snapshot written: {}", path.display());
snap = Some(path.display().to_string());
}
Err(e) => log::warn!("Secure input snapshot failed: {e}"),
}
} else {
log::warn!("Secure input snapshot skipped: no decoded frame yet");
}
}
let events = job.actions.len();
let chars = job.chars;
if let Some(reply) = job.reply.take() {
let _ = reply.send(TypeResponse {
ok: true,
events,
chars,
snapshot: snap,
error: None,
});
} else {
log::info!("Secure input finished: chars={} events={}", chars, events);
}
job.done = true;
Ok(())
}
}
}
#[cfg(test)] mod tests {
use super::*;
// macOS: SDL video must start on the main thread, which the test harness does not use; CI runs it on Linux.
@@ -223,6 +442,24 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
assert!(input.release_all().is_empty());
}
}
#[test] fn wheel_events_become_scroll_messages(){
use sdl2::mouse::MouseWheelDirection;
let mut input=Input::default();let mut focused=true;
let v=Viewport::fit((800,600),(1920,1080));
let wheel=|direction,x,y|Event::MouseWheel{timestamp:0,window_id:1,which:0,mouse_x:0,mouse_y:0,x,y,precise_x:0.,precise_y:0.,direction};
let(_,out)=translate([wheel(MouseWheelDirection::Normal,0,1),wheel(MouseWheelDirection::Flipped,0,1),wheel(MouseWheelDirection::Normal,0,0)],&mut input,v,&mut focused);
assert_eq!(out.len(),2);
assert_eq!(out[0]["action"],"mouse_scroll");
assert_eq!(out[0]["delta_y"],120);
assert_eq!(out[1]["delta_y"],-120);
// Trackpads report fractional precise deltas; a quarter notch is 30 wire units.
let precise=Event::MouseWheel{timestamp:0,window_id:1,which:0,mouse_x:0,mouse_y:0,x:0,y:0,precise_x:0.,precise_y:-0.25,direction:MouseWheelDirection::Normal};
let(_,out)=translate([precise],&mut input,v,&mut focused);
assert_eq!(out[0]["delta_y"],-30);
let mut watch=Input::new(true);let mut watching=true;
let(_,out)=translate([wheel(MouseWheelDirection::Normal,0,1)],&mut watch,v,&mut watching);
assert!(out.is_empty());
}
#[test] fn watch_events_never_emit_input_and_still_close(){
let mut input=Input::new(true);let mut focused=true;
assert!(input.key(4,true).is_none());assert!(input.button(1,true).is_none());assert!(!input.enabled());
+731
View File
@@ -0,0 +1,731 @@
//! Compose CONTROL keyboard JSON for scripted typing. Secrets never appear in logs or Debug.
use serde_json::{json, Value};
use std::fmt;
use std::io::{BufRead, Read};
use std::ops::{Deref, DerefMut};
#[cfg(test)]
use std::sync::Mutex;
use std::time::Duration;
/// Serializes tests that mutate process environment.
#[cfg(test)]
pub static ENV_LOCK: Mutex<()> = Mutex::new(());
/// Holds secret text; Debug/Display only show length.
pub struct Secret(String);
impl Secret {
pub fn new(value: String) -> Self {
Self(value)
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn chars_count(&self) -> usize {
self.0.chars().count()
}
/// Drop the last `n` Unicode scalars (fill-without-submit for Windows PIN).
pub fn omit_last_chars(&mut self, n: usize) -> Result<(), String> {
let count = self.0.chars().count();
if n > count {
return Err("omit-last exceeds secret length".into());
}
if n == 0 {
return Ok(());
}
let keep = count - n;
let truncated: String = self.0.chars().take(keep).collect();
zeroize_str(&mut self.0);
self.0 = truncated;
Ok(())
}
}
impl fmt::Debug for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Secret(len={})", self.0.len())
}
}
impl fmt::Display for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "*** ({} bytes)", self.0.len())
}
}
impl Drop for Secret {
fn drop(&mut self) {
zeroize_str(&mut self.0);
}
}
fn zeroize_str(s: &mut String) {
let bytes = unsafe { s.as_bytes_mut() };
for b in bytes.iter_mut() {
*b = 0;
}
s.clear();
}
/// One CONTROL keyboard action (Windows VK or Mac keycode in `key`).
#[derive(Clone, Debug, PartialEq)]
pub enum KeyAction {
Press(i32),
Release(i32),
}
impl KeyAction {
pub fn to_json(&self) -> Value {
match self {
Self::Press(k) => json!({"action":"kbd_press","key":k}),
Self::Release(k) => json!({"action":"kbd_release","key":k}),
}
}
fn zeroize(&mut self) {
match self {
Self::Press(k) | Self::Release(k) => *k = 0,
}
}
}
/// Key event list that wipes key codes on drop.
pub struct ActionList(Vec<KeyAction>);
impl std::fmt::Debug for ActionList {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "ActionList(len={})", self.0.len())
}
}
impl ActionList {
pub fn new(actions: Vec<KeyAction>) -> Self {
Self(actions)
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn as_slice(&self) -> &[KeyAction] {
&self.0
}
}
impl Deref for ActionList {
type Target = [KeyAction];
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for ActionList {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl Drop for ActionList {
fn drop(&mut self) {
for a in &mut self.0 {
a.zeroize();
}
self.0.clear();
}
}
pub fn parse_delay_ms(raw: Option<&str>) -> Result<Duration, String> {
let Some(raw) = raw else {
return Ok(Duration::ZERO);
};
let ms: u64 = raw
.parse()
.map_err(|_| String::from("delay must be a non-negative integer (milliseconds)"))?;
if ms > 5_000 {
return Err("delay must be at most 5000 ms".into());
}
Ok(Duration::from_millis(ms))
}
pub fn parse_omit_last(raw: Option<&str>) -> Result<usize, String> {
let Some(raw) = raw else {
return Ok(0);
};
let n: usize = raw
.parse()
.map_err(|_| String::from("omit-last must be a non-negative integer"))?;
if n > 64 {
return Err("omit-last must be at most 64".into());
}
Ok(n)
}
/// `UU_INPUT_ENV` names another variable that holds the secret; otherwise one stdin line.
/// After reading a named secret variable, that variable is removed from the environment.
pub fn load_secret(stdin: impl BufRead) -> Result<Secret, String> {
if let Ok(name) = std::env::var("UU_INPUT_ENV") {
validate_env_name(&name)?;
let value = std::env::var(&name)
.map_err(|_| "Environment variable named by UU_INPUT_ENV is not set".to_string())?;
std::env::remove_var(&name);
if value.is_empty() {
return Err("Secret environment variable is empty".into());
}
if value.len() > 16 * 1024 {
return Err("Secret exceeds 16 KiB".into());
}
return Ok(Secret::new(value));
}
let mut line = String::new();
stdin
.take(16 * 1024 + 1)
.read_to_string(&mut line)
.map_err(|_| "Cannot read secret from stdin")?;
if line.len() > 16 * 1024 {
return Err("Secret exceeds 16 KiB".into());
}
if line.ends_with('\n') {
line.pop();
if line.ends_with('\r') {
line.pop();
}
}
if line.is_empty() {
return Err("Secret stdin is empty (set UU_INPUT_ENV or pipe text)".into());
}
Ok(Secret::new(line))
}
fn validate_env_name(name: &str) -> Result<(), String> {
if name.is_empty() || name.len() > 128 {
return Err("UU_INPUT_ENV must be a non-empty variable name".into());
}
if !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
return Err("UU_INPUT_ENV must be an alphanumeric variable name".into());
}
Ok(())
}
/// Expand template text into key actions. Brace tokens: `{Enter}`, `{Tab}`, `{Esc}`,
/// `{Backspace}`, `{Delete}`, `{Space}`, `{Ctrl+Alt+Del}`, arrows, `{Home}`, `{End}`, `{F1}`…`{F12}`.
/// Plain characters use a US QWERTY VK/Mac mapping (Shift for uppercase/symbols).
/// Errors never include the offending character or token text — only a 0-based char index.
pub fn expand(text: &str, mac: bool) -> Result<ActionList, String> {
let mut out = Vec::new();
let mut chars = text.chars().peekable();
let mut index = 0usize;
while let Some(c) = chars.next() {
if c == '{' {
if chars.peek() == Some(&'{') {
chars.next();
push_char(&mut out, '{', mac, index)?;
index += 1;
continue;
}
let start = index;
let mut name = String::new();
let mut closed = false;
for n in chars.by_ref() {
if n == '}' {
closed = true;
break;
}
if n == '{' || name.len() > 32 {
zeroize_str(&mut name);
return Err(format!("Invalid special-key token at index {start}"));
}
name.push(n);
}
if !closed {
zeroize_str(&mut name);
return Err(format!("Unclosed special-key token at index {start}"));
}
// Advance index past '{' + name + '}'
index += 1 + name.chars().count() + 1;
let result = push_special(&mut out, &name, mac, start);
zeroize_str(&mut name);
result?;
continue;
}
if c.is_control() && c != '\t' && c != '\n' && c != '\r' {
return Err(format!("Control character at index {index}"));
}
match c {
'\n' | '\r' => push_special(&mut out, "Enter", mac, index)?,
'\t' => push_special(&mut out, "Tab", mac, index)?,
_ => push_char(&mut out, c, mac, index)?,
}
index += 1;
}
Ok(ActionList::new(out))
}
fn push_special(
out: &mut Vec<KeyAction>,
name: &str,
mac: bool,
index: usize,
) -> Result<(), String> {
let key = match name {
"Enter" | "Return" => Some(vk_or_mac(0x0d, 36, mac)),
"Tab" => Some(vk_or_mac(0x09, 48, mac)),
"Esc" | "Escape" => Some(vk_or_mac(0x1b, 53, mac)),
"Backspace" => Some(vk_or_mac(0x08, 51, mac)),
"Delete" | "Del" => Some(vk_or_mac(0x2e, 117, mac)),
"Space" => Some(vk_or_mac(0x20, 49, mac)),
"Up" => Some(vk_or_mac(0x26, 126, mac)),
"Down" => Some(vk_or_mac(0x28, 125, mac)),
"Left" => Some(vk_or_mac(0x25, 123, mac)),
"Right" => Some(vk_or_mac(0x27, 124, mac)),
"Home" => Some(vk_or_mac(0x24, 115, mac)),
"End" => Some(vk_or_mac(0x23, 119, mac)),
"Ctrl+Alt+Del" | "CAD" => {
let ctrl = vk_or_mac(0xa2, 59, mac);
let alt = vk_or_mac(0xa4, 58, mac);
let del = vk_or_mac(0x2e, 117, mac);
out.push(KeyAction::Press(ctrl));
out.push(KeyAction::Press(alt));
out.push(KeyAction::Press(del));
out.push(KeyAction::Release(del));
out.push(KeyAction::Release(alt));
out.push(KeyAction::Release(ctrl));
return Ok(());
}
other if other.len() >= 2 && other.as_bytes()[0] == b'F' => {
let n: u32 = other[1..]
.parse()
.map_err(|_| format!("Unknown special key at index {index}"))?;
if !(1..=12).contains(&n) {
return Err(format!("Unknown special key at index {index}"));
}
let vk = 0x70 + (n as i32 - 1);
let mac_code = match n {
1 => 122,
2 => 120,
3 => 99,
4 => 118,
5 => 96,
6 => 97,
7 => 98,
8 => 100,
9 => 101,
10 => 109,
11 => 103,
12 => 111,
_ => unreachable!(),
};
Some(vk_or_mac(vk, mac_code, mac))
}
_ => return Err(format!("Unknown special key at index {index}")),
};
let Some(key) = key else {
return Ok(());
};
out.push(KeyAction::Press(key));
out.push(KeyAction::Release(key));
Ok(())
}
fn vk_or_mac(vk: i32, mac: i32, is_mac: bool) -> i32 {
if is_mac {
mac
} else {
vk
}
}
fn push_char(out: &mut Vec<KeyAction>, c: char, mac: bool, index: usize) -> Result<(), String> {
let (vk, shift) = us_qwerty_vk(c)
.ok_or_else(|| format!("Unsupported character at index {index}"))?;
let key = if mac {
mac_from_vk(vk).ok_or_else(|| format!("Unsupported character at index {index}"))?
} else {
vk
};
let shift_key = vk_or_mac(0xa0, 56, mac);
if shift {
out.push(KeyAction::Press(shift_key));
}
out.push(KeyAction::Press(key));
out.push(KeyAction::Release(key));
if shift {
out.push(KeyAction::Release(shift_key));
}
Ok(())
}
fn us_qwerty_vk(c: char) -> Option<(i32, bool)> {
match c {
'a'..='z' => Some((0x41 + (c as i32 - 'a' as i32), false)),
'A'..='Z' => Some((0x41 + (c as i32 - 'A' as i32), true)),
'0' => Some((0x30, false)),
'1'..='9' => Some((0x30 + (c as i32 - '0' as i32), false)),
' ' => Some((0x20, false)),
'-' => Some((0xbd, false)),
'_' => Some((0xbd, true)),
'=' => Some((0xbb, false)),
'+' => Some((0xbb, true)),
'[' => Some((0xdb, false)),
'{' => Some((0xdb, true)),
']' => Some((0xdd, false)),
'}' => Some((0xdd, true)),
'\\' => Some((0xdc, false)),
'|' => Some((0xdc, true)),
';' => Some((0xba, false)),
':' => Some((0xba, true)),
'\'' => Some((0xde, false)),
'"' => Some((0xde, true)),
'`' => Some((0xc0, false)),
'~' => Some((0xc0, true)),
',' => Some((0xbc, false)),
'<' => Some((0xbc, true)),
'.' => Some((0xbe, false)),
'>' => Some((0xbe, true)),
'/' => Some((0xbf, false)),
'?' => Some((0xbf, true)),
'!' => Some((0x31, true)),
'@' => Some((0x32, true)),
'#' => Some((0x33, true)),
'$' => Some((0x34, true)),
'%' => Some((0x35, true)),
'^' => Some((0x36, true)),
'&' => Some((0x37, true)),
'*' => Some((0x38, true)),
'(' => Some((0x39, true)),
')' => Some((0x30, true)),
_ => None,
}
}
fn mac_from_vk(vk: i32) -> Option<i32> {
let scan = match vk {
0x41..=0x5a => 4 + (vk - 0x41),
0x31..=0x39 => 30 + (vk - 0x31),
0x30 => 39,
0x0d => 40,
0x1b => 41,
0x08 => 42,
0x09 => 43,
0x20 => 44,
0xbd => 45,
0xbb => 46,
0xdb => 47,
0xdd => 48,
0xdc => 49,
0xba => 51,
0xde => 52,
0xc0 => 53,
0xbc => 54,
0xbe => 55,
0xbf => 56,
0xa0 => 225,
_ => return None,
};
super::input::mac_keycode(scan)
}
pub async fn send_actions(
send: impl Fn(Value) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), String>> + Send>>,
actions: &[KeyAction],
delay: Duration,
) -> Result<(), String> {
for (i, action) in actions.iter().enumerate() {
send(action.to_json()).await?;
if !delay.is_zero() && i + 1 != actions.len() {
tokio::time::sleep(delay).await;
}
}
Ok(())
}
/// Wait for CONTROL echo on an open desktop session, then send key actions.
pub async fn run_session(
session: &mut super::session::Session,
actions: &[KeyAction],
delay: Duration,
) -> Result<(), String> {
use std::sync::atomic::Ordering;
let ready = async {
loop {
if session.peer.observed.control_open.load(Ordering::Acquire)
&& session.peer.observed.echo_received.load(Ordering::Acquire)
{
return Ok::<_, String>(());
}
tokio::select! {
r = session.step() => r?,
_ = tokio::time::sleep(Duration::from_millis(20)) => {}
}
}
};
tokio::time::timeout(Duration::from_secs(30), ready)
.await
.map_err(|_| "CONTROL echo timed out")??;
for (i, action) in actions.iter().enumerate() {
session.peer.send_input(&action.to_json()).await?;
if !delay.is_zero() && i + 1 != actions.len() {
tokio::time::sleep(delay).await;
}
}
Ok(())
}
/// Dry-run summary: lengths only, never the secret or key codes.
pub fn dry_run_report(secret: &Secret, omit_last: usize, mac: bool) -> Result<String, String> {
let mut owned = Secret::new(secret.as_str().to_owned());
owned.omit_last_chars(omit_last)?;
let actions = expand(owned.as_str(), mac)?;
Ok(format!(
"dry-run: chars={} omit_last={} events={} mac={}",
owned.chars_count(),
omit_last,
actions.len(),
mac
))
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
#[test]
fn secret_debug_and_display_never_leak() {
let s = Secret::new("hunter2".into());
let d = format!("{s:?}");
let p = format!("{s}");
assert!(d.contains("len=7"));
assert!(!d.contains("hunter"));
assert!(!p.contains("hunter"));
assert!(p.contains("***"));
}
#[test]
fn action_list_debug_shows_len_only() {
let list = ActionList::new(vec![
KeyAction::Press(0x41),
KeyAction::Release(0x41),
KeyAction::Press(0x42),
KeyAction::Release(0x42),
]);
let d = format!("{list:?}");
assert_eq!(d, "ActionList(len=4)");
assert!(!d.contains("0x41"));
assert!(!d.contains("Press"));
assert!(!d.contains("41"));
}
#[test]
fn letters_digits_and_shift_symbols_map_to_windows_vk() {
let actions = expand("Ab1!", false).unwrap();
assert_eq!(
&actions[0..4],
&[
KeyAction::Press(0xa0),
KeyAction::Press(0x41),
KeyAction::Release(0x41),
KeyAction::Release(0xa0),
]
);
assert_eq!(
&actions[4..6],
&[KeyAction::Press(0x42), KeyAction::Release(0x42)]
);
assert_eq!(
&actions[6..8],
&[KeyAction::Press(0x31), KeyAction::Release(0x31)]
);
assert_eq!(
&actions[8..12],
&[
KeyAction::Press(0xa0),
KeyAction::Press(0x31),
KeyAction::Release(0x31),
KeyAction::Release(0xa0),
]
);
}
#[test]
fn special_keys_and_ctrl_alt_del() {
let a = expand("{Enter}{Tab}{Esc}{Backspace}{Ctrl+Alt+Del}", false).unwrap();
assert!(a
.windows(2)
.any(|w| w == [KeyAction::Press(0x0d), KeyAction::Release(0x0d)]));
let cad: Vec<_> = a.iter().rev().take(6).rev().cloned().collect();
assert_eq!(
cad,
vec![
KeyAction::Press(0xa2),
KeyAction::Press(0xa4),
KeyAction::Press(0x2e),
KeyAction::Release(0x2e),
KeyAction::Release(0xa4),
KeyAction::Release(0xa2),
]
);
}
#[test]
fn unknown_special_key_errors_without_echoing_payload() {
let err = expand("{NotAKey}", false).unwrap_err();
assert!(err.contains("Unknown special key at index"));
assert!(!err.contains("NotAKey"));
assert!(!err.contains("password"));
}
#[test]
fn unsupported_char_errors_without_codepoint_or_char() {
let err = expand("a中", false).unwrap_err();
assert!(err.contains("Unsupported character at index 1"));
assert!(!err.contains('中'));
assert!(!err.contains("4E2D"));
assert!(!err.contains("U+"));
}
#[test]
fn unclosed_token_and_control_char_rejected() {
assert!(expand("{Enter", false).is_err());
assert!(expand("a\u{0001}b", false).is_err());
}
#[test]
fn load_from_named_env_and_stdin() {
let _g = ENV_LOCK.lock().unwrap();
std::env::set_var("UU_INPUT_ENV", "UU_SECRET");
std::env::set_var("UU_SECRET", "pin-value");
let s = load_secret(Cursor::new(b"")).unwrap();
assert_eq!(s.as_str(), "pin-value");
assert!(!format!("{s:?}").contains("pin"));
assert!(std::env::var("UU_SECRET").is_err());
std::env::remove_var("UU_INPUT_ENV");
let s = load_secret(Cursor::new(b"from-stdin\n")).unwrap();
assert_eq!(s.as_str(), "from-stdin");
}
#[test]
fn invalid_env_name_and_empty_secret() {
let _g = ENV_LOCK.lock().unwrap();
std::env::set_var("UU_INPUT_ENV", "bad-name!");
assert!(load_secret(Cursor::new(b"")).is_err());
std::env::remove_var("UU_INPUT_ENV");
std::env::set_var("UU_INPUT_ENV", "EMPTY_SECRET_TEST");
std::env::set_var("EMPTY_SECRET_TEST", "");
assert!(load_secret(Cursor::new(b"")).is_err());
std::env::remove_var("UU_INPUT_ENV");
std::env::remove_var("EMPTY_SECRET_TEST");
assert!(load_secret(Cursor::new(b"\n")).is_err());
}
#[test]
fn delay_and_omit_bounds() {
assert_eq!(parse_delay_ms(None).unwrap(), Duration::ZERO);
assert_eq!(
parse_delay_ms(Some("50")).unwrap(),
Duration::from_millis(50)
);
assert!(parse_delay_ms(Some("-1")).is_err());
assert!(parse_delay_ms(Some("5001")).is_err());
assert_eq!(parse_omit_last(None).unwrap(), 0);
assert_eq!(parse_omit_last(Some("2")).unwrap(), 2);
assert!(parse_omit_last(Some("65")).is_err());
}
#[test]
fn omit_last_and_dry_run() {
let mut s = Secret::new("1234567".into());
s.omit_last_chars(1).unwrap();
assert_eq!(s.as_str(), "123456");
let report = dry_run_report(&Secret::new("1234567".into()), 1, false).unwrap();
assert!(report.contains("chars=6"));
assert!(report.contains("omit_last=1"));
assert!(report.contains("events="));
assert!(report.contains("omit_last=1"));
assert!(!report.contains("123456"));
assert!(!report.contains("1234567"));
}
#[test]
fn brace_escape_types_literal_brace() {
let a = expand("{{a", false).unwrap();
assert_eq!(
&a[0..4],
&[
KeyAction::Press(0xa0),
KeyAction::Press(0xdb),
KeyAction::Release(0xdb),
KeyAction::Release(0xa0),
]
);
assert_eq!(
&a[4..6],
&[KeyAction::Press(0x41), KeyAction::Release(0x41)]
);
}
#[test]
fn password_with_enter_suffix() {
let a = expand("secret{Enter}", false).unwrap();
assert_eq!(a.last(), Some(&KeyAction::Release(0x0d)));
assert_eq!(a[a.len() - 2], KeyAction::Press(0x0d));
}
#[test]
fn action_list_zeroizes_on_drop() {
let mut a = KeyAction::Press(0x41);
a.zeroize();
assert_eq!(a, KeyAction::Press(0));
let list = ActionList::new(vec![KeyAction::Press(7), KeyAction::Release(7)]);
assert_eq!(list.len(), 2);
drop(list);
}
#[tokio::test]
async fn send_actions_respects_delay_and_order() {
use std::sync::{Arc, Mutex};
let log = Arc::new(Mutex::new(Vec::new()));
let recorded = log.clone();
let actions = expand("a{Enter}", false).unwrap();
let start = std::time::Instant::now();
send_actions(
|v| {
let recorded = recorded.clone();
Box::pin(async move {
recorded.lock().unwrap().push(v);
Ok(())
})
},
actions.as_slice(),
Duration::from_millis(20),
)
.await
.unwrap();
assert!(start.elapsed() >= Duration::from_millis(50));
let keys: Vec<_> = log
.lock()
.unwrap()
.iter()
.map(|v| {
(
v["action"].as_str().unwrap().to_owned(),
v["key"].as_i64().unwrap(),
)
})
.collect();
assert_eq!(
keys,
vec![
("kbd_press".into(), 0x41),
("kbd_release".into(), 0x41),
("kbd_press".into(), 0x0d),
("kbd_release".into(), 0x0d),
]
);
}
}
+627
View File
@@ -0,0 +1,627 @@
//! Local Unix-socket bridge: `uuremote-viewer type` hands secrets to a running desktop session.
//! Frames are length-prefixed JSON; secrets never appear in logs. Peer UID must match.
use serde::{Deserialize, Serialize};
use std::{
os::unix::fs::DirBuilderExt,
path::{Path, PathBuf},
};
use tokio::{
io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
net::{UnixListener, UnixStream},
sync::mpsc,
};
/// Max JSON frame (header + secret). 16 KiB secret + margin.
pub const MAX_FRAME: usize = 20 * 1024;
#[derive(Serialize, Deserialize)]
pub struct TypeRequest {
pub delay_ms: u64,
pub omit_last: usize,
pub snapshot: Option<String>,
/// Secret text; Debug only exposes length.
pub secret: String,
}
impl std::fmt::Debug for TypeRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TypeRequest")
.field("delay_ms", &self.delay_ms)
.field("omit_last", &self.omit_last)
.field(
"snapshot",
&self.snapshot.as_ref().map(|s| format!("len={}", s.len())),
)
.field("secret_len", &self.secret.len())
.finish()
}
}
impl Drop for TypeRequest {
fn drop(&mut self) {
zeroize_string(&mut self.secret);
if let Some(s) = self.snapshot.as_mut() {
zeroize_string(s);
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TypeResponse {
pub ok: bool,
pub events: usize,
pub chars: usize,
pub snapshot: Option<String>,
pub error: Option<String>,
}
fn zeroize_string(s: &mut String) {
// Best-effort wipe before drop.
let bytes = unsafe { s.as_bytes_mut() };
for b in bytes.iter_mut() {
*b = 0;
}
s.clear();
}
/// Ensure `dir` is a real directory owned by us with mode & 0o077 == 0 (no symlink).
pub fn validate_private_dir(dir: &Path) -> Result<(), String> {
use std::os::unix::fs::{MetadataExt, PermissionsExt};
let meta = std::fs::symlink_metadata(dir).map_err(|_| "Cannot inspect type-ipc directory")?;
if meta.file_type().is_symlink() {
return Err("Type-ipc path is a symlink".into());
}
if !meta.file_type().is_dir() {
return Err("Type-ipc path is not a directory".into());
}
let me = unsafe { libc::getuid() };
if meta.uid() != me {
return Err("Type-ipc directory owner mismatch".into());
}
if meta.permissions().mode() & 0o077 != 0 {
return Err("Type-ipc directory permissions too open".into());
}
Ok(())
}
pub fn runtime_dir() -> Result<PathBuf, String> {
let base = std::env::var_os("XDG_RUNTIME_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| {
PathBuf::from(format!(
"{}/uu-viewer-type-{}",
std::env::temp_dir().display(),
unsafe { libc::getuid() }
))
});
let dir = if base.ends_with("uu-viewer-type") || base.file_name().is_some_and(|n| {
n.to_string_lossy().starts_with("uu-viewer-type")
}) {
base
} else {
base.join("uu-viewer-type")
};
// Use symlink_metadata so a pre-planted symlink is not followed before we decide.
match std::fs::symlink_metadata(&dir) {
Ok(_) => {
validate_private_dir(&dir)?;
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
std::fs::DirBuilder::new()
.recursive(true)
.mode(0o700)
.create(&dir)
.map_err(|_| "Cannot create private type-ipc directory")?;
validate_private_dir(&dir)?;
}
Err(_) => return Err("Cannot inspect type-ipc directory".into()),
}
Ok(dir)
}
pub fn device_key(device: &str) -> String {
use sha2::{Digest, Sha256};
hex::encode(Sha256::digest(device.as_bytes()))
}
pub fn socket_path(device: &str) -> Result<PathBuf, String> {
Ok(runtime_dir()?.join(format!("{}.sock", device_key(device))))
}
pub fn default_snapshot_path(device: &str) -> Result<PathBuf, String> {
let ts = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis())
.unwrap_or(0);
Ok(runtime_dir()?.join(format!("snap-{}-{ts}.png", &device_key(device)[..12])))
}
pub async fn read_frame(r: &mut (impl AsyncRead + Unpin)) -> Result<Vec<u8>, String> {
let n = r.read_u32().await.map_err(|_| "Type IPC closed")? as usize;
if n > MAX_FRAME {
return Err("Type IPC frame exceeds size limit".into());
}
let mut b = vec![0; n];
r.read_exact(&mut b)
.await
.map_err(|_| "Type IPC closed")?;
Ok(b)
}
pub async fn write_frame(w: &mut (impl AsyncWrite + Unpin), body: &[u8]) -> Result<(), String> {
if body.len() > MAX_FRAME {
return Err("Type IPC frame exceeds size limit".into());
}
w.write_u32(body.len() as u32)
.await
.map_err(|_| "Type IPC closed")?;
w.write_all(body).await.map_err(|_| "Type IPC closed")?;
Ok(())
}
fn check_peer(stream: &UnixStream) -> Result<(), String> {
let cred = stream
.peer_cred()
.map_err(|_| "Type IPC peer credentials unavailable")?;
let uid = cred.uid();
let me = unsafe { libc::getuid() };
if uid != me {
return Err("Type IPC peer uid mismatch".into());
}
Ok(())
}
pub struct Server {
pub path: PathBuf,
listener: Option<UnixListener>,
}
impl Drop for Server {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
impl Server {
pub async fn bind(device: &str) -> Result<Self, String> {
let path = socket_path(device)?;
if path.exists() {
match UnixStream::connect(&path).await {
Ok(_) => return Err("A desktop viewer is already listening for this device".into()),
Err(_) => {
let _ = std::fs::remove_file(&path);
}
}
}
let listener = UnixListener::bind(&path).map_err(|_| "Cannot bind type IPC socket")?;
use std::os::unix::fs::PermissionsExt;
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
Ok(Self { path, listener: Some(listener) })
}
/// Accept connections and forward validated TypeRequests to `tx`.
pub async fn run(mut self, tx: mpsc::Sender<PendingType>) {
let path = self.path.clone();
let listener = self.listener.take().expect("type IPC listener");
// Prevent Drop from removing the socket twice while we still hold `path` in a guard.
self.path = PathBuf::new();
struct Guard(PathBuf);
impl Drop for Guard {
fn drop(&mut self) {
if !self.0.as_os_str().is_empty() {
let _ = std::fs::remove_file(&self.0);
}
}
}
let _guard = Guard(path);
loop {
let accepted = listener.accept().await;
let Ok((stream, _)) = accepted else { break };
if check_peer(&stream).is_err() {
continue;
}
let tx = tx.clone();
tokio::spawn(async move {
let _ = serve_client(stream, tx).await;
});
}
}
}
pub struct PendingType {
pub request: TypeRequest,
pub reply: tokio::sync::oneshot::Sender<TypeResponse>,
}
async fn serve_client(mut stream: UnixStream, tx: mpsc::Sender<PendingType>) -> Result<(), String> {
let body = read_frame(&mut stream).await?;
let request: TypeRequest =
serde_json::from_slice(&body).map_err(|_| "Invalid type IPC request")?;
let mut body = body;
for b in &mut body {
*b = 0;
}
let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
// Move request into PendingType; zeroize on drop if send fails.
if tx
.send(PendingType {
request,
reply: reply_tx,
})
.await
.is_err()
{
return Err("Desktop session is gone".into());
}
let response = reply_rx.await.map_err(|_| "Desktop session is gone")?;
let out = serde_json::to_vec(&response).map_err(|_| "Type IPC encode failed")?;
write_frame(&mut stream, &out).await
}
/// Client: deliver a type request to a running viewer. Returns response or connection error.
pub async fn send_to_viewer(device: &str, mut request: TypeRequest) -> Result<TypeResponse, String> {
let path = socket_path(device)?;
let mut stream = UnixStream::connect(&path)
.await
.map_err(|_| "No running desktop viewer for this device")?;
check_peer(&stream)?;
let body = serde_json::to_vec(&request).map_err(|_| "Type IPC encode failed")?;
// Clear serde copy in request early — response path still needs omit metadata only.
zeroize_string(&mut request.secret);
write_frame(&mut stream, &body).await?;
// Wipe encoded body
let mut body = body;
for b in &mut body {
*b = 0;
}
let resp_body = read_frame(&mut stream).await?;
let response: TypeResponse =
serde_json::from_slice(&resp_body).map_err(|_| "Invalid type IPC response")?;
Ok(response)
}
/// Encode an RGB24 frame as a minimal PNG (8-bit RGB, no filtering beyond None).
/// Write RGB24 as PNG. Always uses O_NOFOLLOW + mode 0600.
/// `create_new`: true for default runtime paths (refuse overwrite); false for user `--snapshot`.
pub fn write_png_rgb(
path: &Path,
width: u32,
height: u32,
rgb: &[u8],
create_new: bool,
) -> Result<(), String> {
let expected = width as usize * height as usize * 3;
if rgb.len() != expected || width == 0 || height == 0 {
return Err("Snapshot frame size mismatch".into());
}
use flate2::{write::ZlibEncoder, Compression};
use std::io::Write;
let mut raw = Vec::with_capacity((width as usize * 3 + 1) * height as usize);
for row in 0..height as usize {
raw.push(0); // filter None
let start = row * width as usize * 3;
raw.extend_from_slice(&rgb[start..start + width as usize * 3]);
}
let mut enc = ZlibEncoder::new(Vec::new(), Compression::fast());
enc.write_all(&raw).map_err(|_| "Snapshot zlib failed")?;
for b in &mut raw {
*b = 0;
}
let compressed = enc.finish().map_err(|_| "Snapshot zlib failed")?;
fn chunk(tag: &[u8; 4], data: &[u8], out: &mut Vec<u8>) {
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
out.extend_from_slice(tag);
out.extend_from_slice(data);
let mut crc = crc32_ieee_update(0xffff_ffff, tag);
crc = crc32_ieee_update(crc, data);
out.extend_from_slice(&(crc ^ 0xffff_ffff).to_be_bytes());
}
let mut png = Vec::with_capacity(compressed.len() + 128);
png.extend_from_slice(&[137, 80, 78, 71, 13, 10, 26, 10]);
let mut ihdr = Vec::with_capacity(13);
ihdr.extend_from_slice(&width.to_be_bytes());
ihdr.extend_from_slice(&height.to_be_bytes());
ihdr.extend_from_slice(&[8, 2, 0, 0, 0]); // 8-bit RGB
chunk(b"IHDR", &ihdr, &mut png);
chunk(b"IDAT", &compressed, &mut png);
chunk(b"IEND", &[], &mut png);
use std::os::unix::fs::OpenOptionsExt;
let mut opts = std::fs::OpenOptions::new();
opts.write(true).mode(0o600).custom_flags(libc::O_NOFOLLOW);
if create_new {
opts.create_new(true);
} else {
opts.create(true).truncate(true);
}
let mut file = opts
.open(path)
.map_err(|_| "Cannot write snapshot file")?;
file.write_all(&png).map_err(|_| "Cannot write snapshot file")?;
Ok(())
}
fn crc32_ieee(data: &[u8]) -> u32 {
crc32_ieee_update(0xffff_ffff, data) ^ 0xffff_ffff
}
fn crc32_ieee_update(mut crc: u32, data: &[u8]) -> u32 {
for &b in data {
crc ^= u32::from(b);
for _ in 0..8 {
let mask = (!(crc & 1)).wrapping_add(1); // 0 or 0xFFFFFFFF
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
}
}
crc
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn frame_limit_rejects_oversized_length() {
// Unit-level: MAX_FRAME constant is the contract used by read_frame.
assert!(MAX_FRAME >= 16 * 1024);
assert!(MAX_FRAME < 1024 * 1024);
}
#[test]
fn device_key_is_stable_hex() {
let a = device_key("device-1");
let b = device_key("device-1");
assert_eq!(a, b);
assert_eq!(a.len(), 64);
assert!(a.chars().all(|c| c.is_ascii_hexdigit()));
assert_ne!(device_key("device-1"), device_key("device-2"));
}
#[test]
fn png_roundtrip_header_and_mode() {
let dir = tempfile_dir();
let path = dir.join("t.png");
write_png_rgb(&path, 2, 2, &[255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255], true).unwrap();
let meta = std::fs::metadata(&path).unwrap();
use std::os::unix::fs::PermissionsExt;
assert_eq!(meta.permissions().mode() & 0o777, 0o600);
let bytes = std::fs::read(&path).unwrap();
assert_eq!(&bytes[..8], &[137, 80, 78, 71, 13, 10, 26, 10]);
let _ = std::fs::remove_dir_all(dir);
}
fn tempfile_dir() -> PathBuf {
use std::os::unix::fs::DirBuilderExt;
let dir = std::env::temp_dir().join(format!("uu-type-ipc-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::DirBuilder::new()
.mode(0o700)
.create(&dir)
.unwrap();
dir
}
#[tokio::test]
async fn server_client_roundtrip_and_uid_gate() {
let device = format!("ipc-test-{}", uuidish());
let server = Server::bind(&device).await.unwrap();
let path = server.path.clone();
let (tx, mut rx) = mpsc::channel::<PendingType>(4);
let run = tokio::spawn(async move { server.run(tx).await });
// Handle one request in background
let worker = tokio::spawn(async move {
if let Some(pending) = rx.recv().await {
assert_eq!(pending.request.secret, "sentinel-SECRET-9f3a");
assert_eq!(pending.request.delay_ms, 10);
assert_eq!(pending.request.omit_last, 1);
let _ = pending.reply.send(TypeResponse {
ok: true,
events: 12,
chars: 6,
snapshot: Some("/tmp/fake.png".into()),
error: None,
});
}
});
let response = send_to_viewer(
&device,
TypeRequest {
delay_ms: 10,
omit_last: 1,
snapshot: None,
secret: "sentinel-SECRET-9f3a".into(),
},
)
.await
.unwrap();
assert!(response.ok);
assert_eq!(response.events, 12);
assert_eq!(response.snapshot.as_deref(), Some("/tmp/fake.png"));
worker.abort();
run.abort();
let _ = std::fs::remove_file(path);
}
#[tokio::test]
async fn connect_without_server_errors_without_secret() {
let device = format!("missing-{}", uuidish());
let err = send_to_viewer(
&device,
TypeRequest {
delay_ms: 0,
omit_last: 0,
snapshot: None,
secret: "sentinel-SECRET-9f3a".into(),
},
)
.await
.unwrap_err();
assert!(err.contains("No running desktop viewer"));
assert!(!err.contains("sentinel"));
}
#[tokio::test]
async fn oversized_frame_rejected() {
let device = format!("oversize-{}", uuidish());
let server = Server::bind(&device).await.unwrap();
let path = server.path.clone();
let (tx, mut rx) = mpsc::channel::<PendingType>(1);
let run = tokio::spawn(async move { server.run(tx).await });
// Drain so accept happens
let _drain = tokio::spawn(async move { while rx.recv().await.is_some() {} });
let mut stream = UnixStream::connect(&path).await.unwrap();
let huge = vec![0u8; MAX_FRAME + 1];
let result = write_frame(&mut stream, &huge).await;
// Client-side write_frame rejects before send
assert!(result.is_err());
assert!(!format!("{result:?}").contains("sentinel"));
run.abort();
let _ = std::fs::remove_file(path);
}
#[test]
fn validate_private_dir_rejects_symlink_and_open_mode() {
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
let base = std::env::temp_dir().join(format!(
"uu-type-ipc-val-{}-{}",
std::process::id(),
uuidish()
));
let _ = std::fs::remove_dir_all(&base);
std::fs::DirBuilder::new().mode(0o700).create(&base).unwrap();
let open = base.join("open");
std::fs::DirBuilder::new().mode(0o755).create(&open).unwrap();
let err = validate_private_dir(&open).unwrap_err();
assert!(err.contains("permissions"), "{err}");
assert!(!err.contains("sentinel"));
let good = base.join("good");
std::fs::DirBuilder::new().mode(0o700).create(&good).unwrap();
validate_private_dir(&good).unwrap();
let link = base.join("link");
std::os::unix::fs::symlink(&good, &link).unwrap();
let err = validate_private_dir(&link).unwrap_err();
assert!(err.contains("symlink"), "{err}");
let file = base.join("file");
std::fs::write(&file, b"x").unwrap();
let err = validate_private_dir(&file).unwrap_err();
assert!(err.contains("not a directory"), "{err}");
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn runtime_dir_rejects_preexisting_open_or_symlink() {
use std::os::unix::fs::DirBuilderExt;
// Serialize against other tests that read/write process environment.
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap();
let base = std::env::temp_dir().join(format!(
"uu-type-ipc-rt-{}-{}",
std::process::id(),
uuidish()
));
let _ = std::fs::remove_dir_all(&base);
std::fs::DirBuilder::new().mode(0o700).create(&base).unwrap();
// Point XDG_RUNTIME_DIR at a private base; plant a bad uu-viewer-type child.
let child = base.join("uu-viewer-type");
std::fs::DirBuilder::new().mode(0o755).create(&child).unwrap();
let _guard = EnvGuard::set("XDG_RUNTIME_DIR", base.to_str().unwrap());
let err = runtime_dir().unwrap_err();
assert!(err.contains("permissions"), "{err}");
let _ = std::fs::remove_dir_all(&child);
let target = base.join("target");
std::fs::DirBuilder::new().mode(0o700).create(&target).unwrap();
std::os::unix::fs::symlink(&target, &child).unwrap();
let err = runtime_dir().unwrap_err();
assert!(err.contains("symlink"), "{err}");
let _ = std::fs::remove_file(&child);
// Fresh create succeeds and validates.
let dir = runtime_dir().unwrap();
assert!(dir.ends_with("uu-viewer-type"));
validate_private_dir(&dir).unwrap();
let _ = std::fs::remove_dir_all(&base);
}
#[test]
fn write_png_refuses_symlink_target() {
let dir = tempfile_dir();
let real = dir.join("real.png");
let link = dir.join("link.png");
std::fs::write(&real, b"old").unwrap();
std::os::unix::fs::symlink(&real, &link).unwrap();
let err = write_png_rgb(
&link,
1,
1,
&[1, 2, 3],
false,
)
.unwrap_err();
assert!(err.contains("Cannot write snapshot"), "{err}");
// Original untouched
assert_eq!(std::fs::read(&real).unwrap(), b"old");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn write_png_create_new_refuses_existing() {
let dir = tempfile_dir();
let path = dir.join("exists.png");
std::fs::write(&path, b"old").unwrap();
let err = write_png_rgb(&path, 1, 1, &[1, 2, 3], true).unwrap_err();
assert!(err.contains("Cannot write snapshot"), "{err}");
assert_eq!(std::fs::read(&path).unwrap(), b"old");
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn type_request_debug_shows_secret_len_only() {
let req = TypeRequest {
delay_ms: 40,
omit_last: 1,
snapshot: Some("/tmp/out.png".into()),
secret: "sentinel-SECRET-9f3a".into(),
};
let d = format!("{req:?}");
assert!(d.contains("secret_len: 20") || d.contains("secret_len: 20,"), "{d}");
assert!(!d.contains("sentinel"));
assert!(!d.contains("SECRET"));
assert!(!d.contains("9f3a"));
}
struct EnvGuard {
key: &'static str,
prev: Option<std::ffi::OsString>,
}
impl EnvGuard {
fn set(key: &'static str, val: &str) -> Self {
let prev = std::env::var_os(key);
std::env::set_var(key, val);
Self { key, prev }
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
match &self.prev {
Some(v) => std::env::set_var(self.key, v),
None => std::env::remove_var(self.key),
}
}
}
fn uuidish() -> String {
format!(
"{:x}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
)
}
}
+109 -3
View File
@@ -13,7 +13,7 @@ use viewer::clipboard;
#[cfg(test)] #[path="initialization.rs"] mod initialization;
use viewer::{api::Api,rtc::ReadyPolicy,session::{Options,Session},wire::Shape};
use std::time::Duration;
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer unbind DEVICE [--shared] (从账号删除设备 / remove a device from the account)\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nVideo: UU_VIEWER_CODEC=h264 forces H.264; UU_VIEWER_CHROMA=444 requests true color (default 4:2:0).\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer type DEVICE [options] (secret from UU_INPUT_ENV or stdin; reuses running viewer)\n options: --delay-ms MS --omit-last N --snapshot PATH --dry-run --new-session\n uuremote-viewer unbind DEVICE [--shared] (从账号删除设备 / remove a device from the account)\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nVideo: UU_VIEWER_CODEC=h264 forces H.264; UU_VIEWER_CHROMA=444 requests true color (default 4:2:0).\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
const DEFAULT_SHAPE:&str=r#"{"capture_type":1,"platform":3,"client_version":"4.42.0","width":1920,"height":1080,"fps":60,"chroma":1,
"decoders":[{"fps":60,"codec":1,"width":3840,"height":2160,"chroma":1}],"display_modes":[[1920,1080,60]],
"displays":[{"id":1,"fps":60,"type":0,"hdr":0}],
@@ -60,6 +60,7 @@ async fn run(args:&[String])->Result<(),String> {
println!("已从账号删除设备");Ok(())
}
Some("power")=>power_command(args).await,
Some("type")=>type_command(args).await,
Some("terminal-local") if args.len()==2 || args.len()==3=>{
let session=if args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
viewer::tools::terminal_ipc::client(std::path::Path::new(&args[1]),session).await
@@ -111,11 +112,93 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy,clipboard};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
#[cfg(feature="viewer-sdl")]
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only).await}else{session.run().await};
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only,&args[1]).await}else{session.run().await};
#[cfg(not(feature="viewer-sdl"))]
let result=session.run().await;
session.close().await;result
}
async fn type_command(args:&[String])->Result<(),String>{
// type DEVICE [--delay-ms MS] [--omit-last N] [--snapshot PATH] [--dry-run] [--new-session]
if args.len()<2 || args[1].trim().is_empty() { return Err(HELP.into()) }
let device=&args[1];
let mut delay_ms:Option<&str>=None;
let mut omit_last:Option<&str>=None;
let mut snapshot:Option<String>=None;
let mut dry_run=false;
let mut new_session=false;
let mut i=2;
while i<args.len() {
match args[i].as_str() {
"--delay-ms" => {
i+=1; delay_ms=Some(args.get(i).map(String::as_str).ok_or_else(||HELP.to_string())?);
}
"--omit-last" => {
i+=1; omit_last=Some(args.get(i).map(String::as_str).ok_or_else(||HELP.to_string())?);
}
"--snapshot" => {
i+=1; snapshot=Some(args.get(i).cloned().ok_or_else(||HELP.to_string())?);
}
"--dry-run" => { dry_run=true; }
"--new-session" => { new_session=true; }
_ => return Err(HELP.into()),
}
i+=1;
}
let delay=viewer::secure_input::parse_delay_ms(delay_ms)?;
let omit=viewer::secure_input::parse_omit_last(omit_last)?;
let mut secret=viewer::secure_input::load_secret(std::io::stdin().lock())?;
if dry_run {
let report=viewer::secure_input::dry_run_report(&secret, omit, false)?;
drop(secret);
println!("{report}");
return Ok(());
}
secret.omit_last_chars(omit)?;
// Prefer a running desktop viewer (avoids force-replacing the live session, upstream #30).
match viewer::type_ipc::socket_path(device) {
Ok(path) if path.exists() && !new_session => {
let req=viewer::type_ipc::TypeRequest{
delay_ms: delay.as_millis() as u64,
omit_last: 0, // already applied locally
snapshot,
secret: secret.as_str().to_owned(),
};
drop(secret);
let response=viewer::type_ipc::send_to_viewer(device, req).await?;
if !response.ok {
return Err(response.error.unwrap_or_else(||"Secure input failed on running viewer".into()));
}
println!("安全输入已发送({} 个按键事件,{} 字符)。", response.events, response.chars);
if let Some(path)=response.snapshot {
println!("snapshot={path}");
log::info!("Secure input snapshot: {path}");
}
return Ok(());
}
_ => {}
}
if !new_session {
drop(secret);
return Err("No running desktop viewer for this device; open a connect/ui session first, or pass --new-session".into());
}
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in type shape")?;
shape.capture_type=1;
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
let room=api.join(device,false,true).await.map_err(|e|e.to_string())?;
let mac=api.target_is_mac(&room,Some(device)).await.map_err(|e|e.to_string())?;
let actions=viewer::secure_input::expand(secret.as_str(),mac)?;
let event_count=actions.len();
let char_count=secret.chars_count();
drop(secret);
log::info!("Secure input prepared (new session): chars={} events={} delay_ms={} mac={}", char_count, event_count, delay.as_millis(), mac);
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
let result=viewer::secure_input::run_session(&mut session,actions.as_slice(),delay).await;
session.close().await;
if result.is_ok(){println!("安全输入已发送({event_count} 个按键事件);新会话路径无截图。");}
result
}
fn credentials()->Result<auth::Credentials,String> {auth::Credentials::load(config::read_fresh().map_err(|_|"Cannot read credential configuration")?.as_ref())}
fn api()->Result<Api,String> {Ok(Api::new(auth::UUAuthClient::new(credentials()?),auth::BASE_URL))}
@@ -128,11 +211,34 @@ mod cli_tests {
use super::*;
#[tokio::test]
async fn invalid_commands_never_fall_through_to_login_or_host_service() {
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"],vec!["unbind"],vec!["unbind",""],vec!["unbind","device","--other"],vec!["unbind","device","--shared","extra"]] {
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["type"],vec!["type","device","--delay-ms"],vec!["type","device","--delay-ms","x"],vec!["type","device","extra"],vec!["type","device","--omit-last"],vec!["type","device","--snapshot"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"],vec!["unbind"],vec!["unbind",""],vec!["unbind","device","--other"],vec!["unbind","device","--shared","extra"]] {
assert!(run(&args.into_iter().map(str::to_owned).collect::<Vec<_>>()).await.is_err());
}
}
#[tokio::test]
async fn type_dry_run_and_no_viewer_paths_are_redacted() {
let _g = viewer::secure_input::ENV_LOCK.lock().unwrap();
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
let out = {
// dry-run
let args: Vec<String> = ["type","missing-device-id","--dry-run"].into_iter().map(str::to_owned).collect();
// reload env for dry-run — previous load_secret removed the var
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
run(&args).await
};
assert!(out.is_ok(), "{out:?}");
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
let err = run(&["type".into(),"missing-device-id".into()]).await.unwrap_err();
assert!(err.contains("No running desktop viewer") || err.contains("--new-session"), "{err}");
assert!(!err.contains("sentinel"));
assert!(!err.contains("SECRET"));
std::env::remove_var("UU_INPUT_ENV");
std::env::remove_var("UU_TYPE_SENTINEL_ENV");
}
#[tokio::test]
async fn login_reuses_companion_subcommand_with_a_local_process_mock() {
use std::os::unix::fs::PermissionsExt;
let path=std::env::temp_dir().join(format!("uu-viewer-login-mock-{}",viewer::wire::uuid()));
+136 -9
View File
@@ -204,11 +204,13 @@ pub fn text_probe()->Result<(),String> {
Ok(())
}
// Opt-in single-track monitor switching for Hyprland. The existing native engine owns
// capture/pointer binding; no compositor layout or user credentials are modified.
// Opt-in single-track monitor switching: Hyprland outputs (UU_WAYLAND_MULTISCREEN) or X11 RandR
// monitors (UU_X11_MULTISCREEN). The existing engines own capture/pointer binding; X11 crops the
// root to the selected monitor. No compositor layout or user credentials are modified.
#[derive(Clone, Debug)]
pub struct Output { pub name:String, pub width:u32, pub height:u32, pub fps:i32 }
static OUTPUTS: std::sync::OnceLock<Vec<Output>> = std::sync::OnceLock::new();
pub struct Output { pub name:String, pub width:u32, pub height:u32, pub fps:i32, pub x:i32, pub y:i32 }
struct Inventory { outputs:Vec<Output>, x11:bool }
static OUTPUTS: std::sync::OnceLock<Inventory> = std::sync::OnceLock::new();
#[derive(Default)]
struct Selection { id:usize, generation:u64, presented:Option<u64>, failed:bool }
impl Selection {
@@ -221,19 +223,77 @@ impl Selection {
fn ready(&self)->bool {self.presented==Some(self.generation)}
}
static SELECTION:std::sync::Mutex<Selection>=std::sync::Mutex::new(Selection {id:0,generation:0,presented:None,failed:false});
pub fn outputs() -> &'static [Output] {
fn inventory() -> &'static Inventory {
OUTPUTS.get_or_init(|| {
let backend=crate::desktop_backend::detect().ok();
if backend==Some(crate::desktop_backend::DesktopBackend::X11) && !crate::desktop_backend::headless()
&& std::env::var("UU_X11_MULTISCREEN").ok().as_deref()==Some("1") {
let outputs=x11_outputs();
return Inventory {x11:!outputs.is_empty(),outputs};
}
if !cfg!(all(target_os="linux",feature="wayland"))
|| std::env::var("UU_WAYLAND_MULTISCREEN").ok().as_deref()!=Some("1")
|| crate::desktop_backend::detect().ok()!=Some(crate::desktop_backend::DesktopBackend::Wayland) {return Vec::new();}
|| backend!=Some(crate::desktop_backend::DesktopBackend::Wayland) {return Inventory {outputs:Vec::new(),x11:false};}
let output=std::process::Command::new("hyprctl").args(["monitors","-j"]).output();
let result=output.map_err(|_|"hyprctl unavailable").and_then(|output| {
if !output.status.success() {return Err("hyprctl failed");}
parse_outputs(&output.stdout,&std::env::var("UU_WAYLAND_OUTPUT").unwrap_or_default())
});
match result {Ok(outputs)=>outputs,Err(reason)=>{log::warn!("Wayland multi-screen disabled: {}",reason);Vec::new()}}
let outputs=match result {Ok(outputs)=>outputs,Err(reason)=>{log::warn!("Wayland multi-screen disabled: {}",reason);Vec::new()}};
Inventory {outputs,x11:false}
})
}
pub fn outputs() -> &'static [Output] {&inventory().outputs}
/// X11 monitors are advertised: the stream captures the selected monitor's region of the root.
pub fn x11_multiscreen()->bool {inventory().x11}
/// Read once, like the Hyprland inventory: a changed monitor layout needs a host restart.
fn x11_outputs()->Vec<Output> {
let mut command=std::process::Command::new("xrandr");
if let Some(display)=crate::capture::x11_display().or_else(||std::env::var("DISPLAY").ok()).filter(|d|!d.is_empty()) {
command.arg("--display").arg(display);
}
let result=command.arg("--listmonitors").output().map_err(|_|"xrandr unavailable").and_then(|output| {
if !output.status.success() {return Err("xrandr failed");}
parse_x11_monitors(&String::from_utf8_lossy(&output.stdout),&std::env::var("UU_X11_OUTPUT").unwrap_or_default(),crate::video::display_fps() as i32)
});
match result {
Ok(outputs) if outputs.len()>=2=>{log::info!("X11 multi-screen: {} monitors",outputs.len());outputs},
Ok(_)=>{log::warn!("X11 multi-screen disabled: fewer than two monitors");Vec::new()},
Err(reason)=>{log::warn!("X11 multi-screen disabled: {}",reason);Vec::new()},
}
}
/// `xrandr --listmonitors`: ` 0: +*HDMI-0 1920/527x1080/296+1920+0 HDMI-0` (`*` = primary).
/// The preferred monitor (UU_X11_OUTPUT, else the primary) is id 0; the rest go left to right.
fn parse_x11_monitors(text:&str,preferred:&str,fps:i32)->Result<Vec<Output>,&'static str> {
fn geometry(text:&str)->Option<(u32,u32,i32,i32)> {
let (width,rest)=text.split_once('x')?;
let split=rest.find('+')?;
let (height,offsets)=rest.split_at(split);
let mut offsets=offsets[1..].split('+');
let size=|v:&str|v.split('/').next()?.parse::<u32>().ok();
let (x,y)=(offsets.next()?.parse::<i32>().ok()?,offsets.next()?.parse::<i32>().ok()?);
if offsets.next().is_some() || x<0 || y<0 {return None;}
Some((size(width)?,size(height)?,x,y))
}
let mut seen=std::collections::HashSet::new();
let mut primary=String::new();
let mut outputs=Vec::new();
for line in text.lines().skip(1) {
let mut fields=line.split_whitespace();
let (Some(_),Some(tag),Some(rect))=(fields.next(),fields.next(),fields.next()) else {continue};
let name=tag.trim_start_matches(['+','*']);
let Some((width,height,x,y))=geometry(rect) else {continue};
if name.is_empty() || name.len()>127 || !seen.insert(name.to_owned())
|| width<2 || height<2 || width>16384 || height>16384 || u64::from(width)*u64::from(height)*4>256*1024*1024 {continue;}
if tag.contains('*') {primary=name.to_owned();}
outputs.push(Output {name:name.into(),width,height,fps,x,y});
}
let first=if preferred.is_empty() {primary} else {preferred.to_owned()};
outputs.sort_by_key(|m| (m.name!=first,m.x,m.y));
outputs.truncate(16);
if outputs.is_empty() || (!preferred.is_empty() && outputs[0].name!=preferred) {return Err("No capturable preferred output");}
Ok(outputs)
}
fn parse_outputs(json:&[u8],preferred:&str)->Result<Vec<Output>,&'static str> {
let monitors=serde_json::from_slice::<Vec<serde_json::Value>>(json).map_err(|_|"Invalid monitor inventory")?;
let mut seen=std::collections::HashSet::new();
@@ -244,7 +304,7 @@ fn parse_outputs(json:&[u8],preferred:&str)->Result<Vec<Output>,&'static str> {
let height=u32::try_from(m["height"].as_u64()?).ok()?;
if name.is_empty() || name.len()>127 || name.contains('\0') || !seen.insert(name.to_owned())
|| width<2 || height<2 || width>16384 || height>16384 || u64::from(width)*u64::from(height)*4>256*1024*1024 {return None;}
Some(Output {name:name.into(),width,height,fps:m["refreshRate"].as_f64()?.round().clamp(1.0,240.0) as i32})
Some(Output {name:name.into(),width,height,fps:m["refreshRate"].as_f64()?.round().clamp(1.0,240.0) as i32,x:0,y:0})
}).collect();
outputs.sort_by_key(|m| (m.name!=preferred,m.name.clone()));
outputs.truncate(16);
@@ -255,6 +315,35 @@ pub fn selection()->(usize,u64) {let s=SELECTION.lock().unwrap();(s.id,s.generat
pub fn selected()->usize {selection().0}
pub fn source(id:usize)->Option<&'static Output> {outputs().get(id)}
pub fn input_size(fallback:(u32,u32))->(u32,u32) {source(selected()).map_or(fallback,|s|(s.width,s.height))}
/// Region the encoder captures for this display: the Wayland output, or the selected X11 monitor.
pub fn capture_source(display:&str,portal:bool,id:usize)->Option<&'static Output> {
if display.starts_with("wayland:") || (!portal && !display.starts_with("kms:") && x11_multiscreen()) {source(id)} else {None}
}
/// Offset of the selected X11 monitor in the root: absolute input is relative to that monitor.
pub fn x11_placement()->Option<(i32,i32)> {
if !x11_multiscreen() {return None;}
source(selected()).map(|s|(s.x,s.y))
}
/// Pixel size of one advertised output. Unknown ids keep `fallback` (connection size).
pub fn source_size(id:usize,fallback:(u32,u32))->(u32,u32) {
#[cfg(test)]
if let Some(outputs)=*test_outputs().lock().unwrap_or_else(|e|e.into_inner()) {
return outputs.get(id).map_or(fallback,|s|(s.width,s.height));
}
source(id).map_or(fallback,|s|(s.width,s.height))
}
#[cfg(test)]
fn test_outputs()->&'static std::sync::Mutex<Option<&'static [Output]>> {
static SLOT:std::sync::OnceLock<std::sync::Mutex<Option<&'static [Output]>>>=std::sync::OnceLock::new();
SLOT.get_or_init(||std::sync::Mutex::new(None))
}
/// Native size written into CaptureSettingSync. Wayland uses the output the encoder is reading
/// (`source_id`), which can differ from the size captured when the connection opened; so does an
/// X11 monitor with UU_X11_MULTISCREEN. Otherwise X11, portal and KMS keep the connection size
/// (X11 mode changes go through `x11_resized`).
pub fn sync_native(display:&str,source_id:usize,connection:(u32,u32))->(u32,u32) {
if display.starts_with("wayland:") || (!display.starts_with("kms:") && x11_multiscreen()) {source_size(source_id,connection)} else {connection}
}
pub fn input_ready()->bool {outputs().is_empty() || SELECTION.lock().unwrap().ready()}
pub fn switch_failed()->bool {SELECTION.lock().unwrap().failed}
pub fn presented(id:usize,generation:u64) {SELECTION.lock().unwrap().sent(id,generation);}
@@ -263,7 +352,12 @@ pub fn failed(id:usize,generation:u64) {
if (state.id,state.generation)==(id,generation) {state.failed=true;}
}
pub fn select(id:usize)->Result<(),String> {
let output=source(id).ok_or("Unknown Wayland screen")?;
let output=source(id).ok_or("Unknown screen")?;
if x11_multiscreen() {
SELECTION.lock().unwrap().begin(id);
log::info!("X11 screen selected: id={} source={}x{}+{}+{}",id,output.width,output.height,output.x,output.y);
return Ok(());
}
#[cfg(all(target_os="linux",feature="wayland"))]
{
let name=std::ffi::CString::new(output.name.as_str()).map_err(|_|"Invalid output name")?;
@@ -353,4 +447,37 @@ mod selection_regressions {
assert_eq!(outputs.len(),1);assert_eq!(outputs[0].name,"normal");
assert!(parse_outputs(b"not JSON","").is_err());
}
#[test]
fn x11_monitors_keep_their_root_offsets() {
// #98: GNOME/X11, two 1920x1080 monitors side by side, primary on the right.
let text="Monitors: 2\n 0: +*HDMI-0 1920/527x1080/296+1920+0 HDMI-0\n 1: +HDMI-1 1920/521x1080/293+0+0 HDMI-1\n";
let outputs=parse_x11_monitors(text,"",60).unwrap();
assert_eq!(outputs.iter().map(|m|(m.name.as_str(),m.width,m.height,m.x,m.y)).collect::<Vec<_>>(),
vec![("HDMI-0",1920,1080,1920,0),("HDMI-1",1920,1080,0,0)]);
let outputs=parse_x11_monitors(text,"HDMI-1",60).unwrap();
assert_eq!((outputs[0].name.as_str(),outputs[1].name.as_str()),("HDMI-1","HDMI-0"));
assert!(parse_x11_monitors(text,"DP-9",60).is_err());
// xrandr --setmonitor virtual monitors (output "none"); no primary: left to right.
let virtual_monitors="Monitors: 3\n 0: +A 1280/338x1024/270+1280+0 none\n 1: +B 1280/338x1024/270+0+0 none\n 2: C 0/0x0/0+0+0 none\n";
let outputs=parse_x11_monitors(virtual_monitors,"",30).unwrap();
assert_eq!(outputs.iter().map(|m|(m.name.as_str(),m.x)).collect::<Vec<_>>(),vec![("B",0),("A",1280)]);
assert!(parse_x11_monitors("Monitors: 1\n 0: +*X 1920/1x1080/1-10+0 X\n","",60).is_err());
assert!(parse_x11_monitors("garbage","",60).is_err());
}
#[test]
fn sync_native_follows_the_wayland_source_id() {
assert_eq!(sync_native(":0",1,(1920,1080)),(1920,1080));
assert_eq!(sync_native("kms:/dev/dri/card0",1,(1920,1080)),(1920,1080));
let inventory:&'static [Output]=Box::leak(vec![
Output {name:"eDP-1".into(),width:1920,height:1080,fps:60,x:0,y:0},
Output {name:"HDMI-A-1".into(),width:2560,height:1440,fps:75,x:0,y:0},
].into_boxed_slice());
*test_outputs().lock().unwrap()=Some(inventory);
// Connection opened on the first output; the encoder is reading the second.
assert_eq!(sync_native("wayland:wayland-0",1,(1920,1080)),(2560,1440));
assert_eq!(source_size(0,(800,600)),(1920,1080));
assert_eq!(sync_native("wayland:wayland-0",9,(800,600)),(800,600));
assert_eq!(sync_native(":0",1,(1920,1080)),(1920,1080));
*test_outputs().lock().unwrap()=None;
}
}
+482 -194
View File
@@ -42,12 +42,173 @@ pub struct SessionContext {
pub bundle_media: Option<(String, u16)>,
}
/// Desktop role of one peer. A tool peer (file transfer, terminal, port mapping) gains it
/// when the viewer opens the desktop on that same connection with SimpleAction 4
/// capture_desktop instead of a new desktop offer (#99).
pub struct DesktopRole {
active: tokio::sync::watch::Sender<bool>,
input: std::sync::Mutex<Option<Arc<crate::input::DesktopInputSession>>>,
stream: std::sync::Mutex<Option<DesktopStream>>,
/// The running stream of a promoted peer; aborted on demotion so a quick re-promotion
/// never leaves two encoders on one track.
stream_task: std::sync::Mutex<Option<tokio::task::AbortHandle>>,
/// Capture reinitialized at promotion; the peer's own capture was unavailable when offered.
screen: std::sync::Mutex<Option<Arc<ScreenCapture>>>,
/// One session tracker per peer follows every promotion and demotion.
tracking: std::sync::atomic::AtomicBool,
request: std::sync::OnceLock<Box<dyn Fn() + Send + Sync>>,
}
impl DesktopRole {
fn new(desktop: bool) -> Self {
Self { active: tokio::sync::watch::channel(desktop).0, input: Default::default(),
stream: Default::default(), stream_task: Default::default(), screen: Default::default(), tracking: Default::default(), request: Default::default() }
}
pub fn is_desktop(&self) -> bool { *self.active.borrow() }
/// A promoted peer whose video ended on its own (capture failed while locked or off, #114);
/// capture_desktop on it starts the video again.
fn stream_ended(&self) -> bool { self.stream_task.lock().unwrap().as_ref().is_some_and(|task| task.is_finished()) }
fn input(&self) -> Option<Arc<crate::input::DesktopInputSession>> { self.input.lock().unwrap().clone() }
fn screen_or(&self, screen: &Arc<ScreenCapture>) -> Arc<ScreenCapture> {
self.screen.lock().unwrap().clone().unwrap_or_else(|| screen.clone())
}
/// Waits until this peer is a desktop; false once the channel closes first.
async fn wait_desktop(&self, channel: &RTCDataChannel) -> bool {
let mut active = self.active.subscribe();
loop {
if *active.borrow_and_update() { return true; }
tokio::select! {
changed = active.changed() => if changed.is_err() { return false; },
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return false; }
}
}
}
}
}
/// Live desktop video for one peer; a tool peer keeps it unstarted until it becomes a desktop.
#[derive(Clone)]
struct DesktopStream {
pc: std::sync::Weak<RTCPeerConnection>,
track: Arc<crate::video_track::VideoTrack>,
portal_desktop: Option<Arc<crate::desktop_session::PortalDesktop>>,
capture_size: (u32, u32),
capture_display: String,
portal: Option<Arc<crate::portal::PortalSession>>,
settings_rx: tokio::sync::watch::Receiver<crate::capture_setting::VideoSettings>,
settings: Arc<tokio::sync::watch::Sender<crate::capture_setting::VideoSettings>>,
idr_request: Arc<std::sync::atomic::AtomicBool>,
selection: crate::video_select::Selection,
chroma_sync: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>,
reload_at_session: u64,
}
pub struct WebRtcSession {
pub pc: Arc<RTCPeerConnection>,
pub capture: Arc<ScreenCapture>,
pub input: Arc<InputInjector>,
/// The role this peer was offered with; `role` also covers a later capture_desktop.
pub desktop: bool,
pub role: Arc<DesktopRole>,
pub controller_mac: bool,
pub context: Arc<Mutex<SessionContext>>,
actions: Arc<crate::system_actions::PeerActions>,
}
/// Counts a desktop session once it is connected (a failed offer is not a session), while the
/// peer is the desktop. Started once per peer, so a quick demote and re-promote cannot end the
/// count of a session that is still streaming.
fn track_session(end_pc: Arc<RTCPeerConnection>, actions: Arc<crate::system_actions::PeerActions>, role: &DesktopRole) {
if role.tracking.swap(true, std::sync::atomic::Ordering::AcqRel) { return; }
let active = role.active.subscribe();
tokio::spawn(async move {
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
loop {
while end_pc.connection_state() != State::Connected || !*active.borrow() {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) && *active.borrow() {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed);
let ending = actions.clone();
let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await;
if closed { return; }
}
});
}
type EchoReplay = (Arc<std::sync::atomic::AtomicU64>, Arc<std::sync::atomic::AtomicBool>, Arc<std::sync::atomic::AtomicBool>);
/// A promoted tool peer starts its TEXT clipboard after the viewer's echo was answered without
/// ff_clipboard; declare it again on CONTROL once the bridge is ready, as the Portal path does.
fn replay_clipboard_echo(channel: Arc<RTCDataChannel>, sequence: Arc<std::sync::atomic::AtomicU64>,
(echo_request, echo_seen, clipboard_ready): EchoReplay, role: Arc<DesktopRole>) {
tokio::spawn(async move {
for _ in 0..100 {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
if !role.is_desktop() || channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
if !clipboard_ready.load(std::sync::atomic::Ordering::Acquire) { continue; }
// echo_seen is published after the request seq, so reading it first gives a current seq.
if echo_seen.load(std::sync::atomic::Ordering::Acquire) {
let request_seq = echo_request.load(std::sync::atomic::Ordering::Acquire);
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let response = crate::control_protocol::encode_echo_response_with_clipboard(
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), timestamp, request_seq, true);
let _ = channel.send(&bytes::Bytes::from(response)).await;
log::info!("CONTROL clipboard capability declared after capture_desktop");
}
return;
}
});
}
impl DesktopStream {
/// Encode current frames only while the peer is connected and still the desktop.
fn spawn(self, screen: Option<Arc<ScreenCapture>>, mut active: tokio::sync::watch::Receiver<bool>) -> Option<tokio::task::AbortHandle> {
let streaming_pc = self.pc.upgrade()?;
let DesktopStream { track: video_track, portal_desktop, capture_size, capture_display, portal,
settings_rx, settings, idr_request, selection, chroma_sync, reload_at_session, .. } = self;
let (capture_size, capture_display, portal) = screen.map_or((capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
Some(tokio::spawn(async move { tokio::select! {
_ = active.wait_for(|active| !*active) => log::info!("Live desktop stream stopped: a newer desktop took over"),
_ = async move {
let screen = if let Some(desktop) = portal_desktop {
if let Err(error) = crate::locked_video::run(&streaming_pc, &video_track, &desktop, selection).await {
log::warn!("Locked desktop video unavailable: {error}");
}
let mut updates = desktop.subscribe();
loop {
let state = updates.borrow_and_update().clone();
if state.ready() { break Some(state.screen); }
if !state.waiting { return; }
if crate::video::transport_closed(&streaming_pc) { return; }
tokio::select! {
changed = updates.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
}
}
} else { None };
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
let state_pc = streaming_pc.clone();
if let Err(e) = crate::video::stream_desktop_at(streaming_pc, video_track, capture_size, capture_display, portal, settings_rx, settings, idr_request, selection, chroma_sync, reload_at_session).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
} else {
log::error!("Live desktop stream stopped: {}", e);
}
}
} => {},
} }).abort_handle())
}
}
impl WebRtcSession {
@@ -63,7 +224,12 @@ impl WebRtcSession {
m.register_default_codecs()
.map_err(|e| format!("Register standard codecs failed: {}", e))?;
let hevc = desktop && crate::video::hevc_available().await;
// Encoder, codec preference and 4:4:4 stay fixed for this peer (codec is negotiated at CONTROL open).
// Read once before the HEVC probe so a concurrent set-encoder/set-codec cannot split capability from CONTROL.
// reload_at_session is the generation at that snapshot. A probe that finishes later is not a reload.
let reload_at_session = crate::video_select::reload_generation_value();
let video_selection = crate::video_select::selection();
let hevc = desktop && crate::video::hevc_available(video_selection.encoder).await;
if hevc { crate::video_track::register_hevc(&mut m).map_err(|e| format!("Register HEVC failed: {e}"))?; }
m.register_header_extension(
@@ -101,7 +267,8 @@ impl WebRtcSession {
.map_err(|e| format!("Create PeerConnection failed: {}", e))?,
);
let input_session=desktop.then(||input.desktop_session());
let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc));
@@ -159,14 +326,16 @@ impl WebRtcSession {
}));
let connected_context = context.clone();
let connection_input=input_session.clone();
let connection_role=role.clone();
let connected_signal = signaling_client.clone();
let notified = Arc::new(std::sync::atomic::AtomicBool::new(false));
let connected_selection = video_selection;
pc.on_peer_connection_state_change(Box::new(move |state| {
let ctx = connected_context.clone();
let input=connection_input.clone();
let input=connection_role.input();
let sig = connected_signal.clone();
let notified = notified.clone();
let video_selection = connected_selection;
Box::pin(async move {
log::info!("PeerConnection State changed: {:?}", state);
if let Some(session)=input.as_ref() {
@@ -177,10 +346,10 @@ impl WebRtcSession {
tokio::spawn(async move {
let ctx = ctx.lock().await.clone();
if let (Some(client), Some(ice)) = (&ctx.client_id, ctx.ice_id.as_ref().and_then(|v| v.as_str())) {
let encoder = crate::video::Encoder::requested();
let encoder = video_selection.encoder;
let codec_impl = if encoder == crate::video::Encoder::Nvenc { crate::capability::CODEC_IMPL_NVENC } else { 5 };
let payload = crate::capability::device_capability(client, ice, 0, crate::video::display_fps() as i32, codec_impl,
hevc, crate::video::full_chroma_available());
hevc, crate::video::full_chroma_for(encoder));
if let Err(e) = sig.emit_event(crate::capability::FORWARD_SETTING_EVENT, payload).await {
log::error!("Device capability notification failed: {}", e);
}
@@ -275,67 +444,24 @@ impl WebRtcSession {
let video_settings = Arc::new(video_settings);
// Per-connection mute / lock-after-session settings (安全 menu).
let peer_actions = Arc::new(crate::system_actions::PeerActions::default());
let session_actions = peer_actions.clone();
let desktop_sound = desktop && crate::audio::enabled();
if desktop && !cfg!(test) {
let (end_pc, actions) = (pc.clone(), peer_actions.clone());
tokio::spawn(async move {
{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
// Count the session once it is actually connected (a failed offer is not a session).
while end_pc.connection_state() != State::Connected {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
}
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
drop(end_pc);
let _ = tokio::task::spawn_blocking(move || actions.session_ended()).await;
});
}
let portal=capture.portal.clone();
let stream_desktop = portal_desktop.clone();
// File/terminal/port-mapping connections carry no desktop video.
if desktop && !cfg!(test) { track_session(pc.clone(), peer_actions.clone(), &role); }
// Live encoder switch (SIGUSR2) sends CaptureSettingSync when chroma is downgraded.
let (chroma_sync_tx, chroma_sync_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let chroma_sync_rx = Arc::new(std::sync::Mutex::new((!cfg!(test)).then_some(chroma_sync_rx)));
// File/terminal/port-mapping connections carry no desktop video until capture_desktop.
let control_video_track = video_track.clone();
let stream_settings = video_settings.clone();
if desktop && !cfg!(test) {
let state_pc = streaming_pc.clone();
tokio::spawn(async move {
let screen = if let Some(desktop) = stream_desktop {
if let Err(error) = crate::locked_video::run(&streaming_pc, &video_track, &desktop).await {
log::warn!("Locked desktop video unavailable: {error}");
}
let mut updates = desktop.subscribe();
loop {
let state = updates.borrow_and_update().clone();
if state.ready() { break Some(state.screen); }
if !state.waiting { return; }
if crate::video::transport_closed(&streaming_pc) { return; }
tokio::select! {
changed = updates.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
}
}
} else { None };
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
} else {
log::error!("Live desktop stream stopped: {}", e);
}
}
});
} else {
drop((streaming_pc, video_track, capture_size, capture_display, video_settings_rx));
}
let stream = DesktopStream {
pc: Arc::downgrade(&streaming_pc), track: video_track, portal_desktop: portal_desktop.clone(),
capture_size, capture_display, portal: capture.portal.clone(), settings_rx: video_settings_rx,
settings: video_settings.clone(), idr_request, selection: video_selection,
chroma_sync: (!cfg!(test)).then_some(chroma_sync_tx), reload_at_session,
};
drop(streaming_pc);
if cfg!(test) { drop(stream); }
else if desktop { let _ = stream.spawn(None, role.active.subscribe()); }
else { *role.stream.lock().unwrap() = Some(stream); }
let input_clone = input.clone();
let control_capture = capture.clone();
let desktop_pc = Arc::downgrade(&pc);
@@ -393,6 +519,7 @@ impl WebRtcSession {
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(()));
let data_role = role.clone();
// 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string();
@@ -400,7 +527,7 @@ impl WebRtcSession {
let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone();
let channel_input_session=input_session.clone();
let channel_role=data_role.clone();
let screen = control_capture.clone();
let portal_desktop = portal_desktop.clone();
let desktop_pc = desktop_pc.clone();
@@ -414,6 +541,8 @@ impl WebRtcSession {
let peer_video_settings = video_settings.clone();
let peer_video_track = control_video_track.clone();
let peer_actions = peer_actions.clone();
let peer_selection = video_selection;
let chroma_sync_rx = chroma_sync_rx.clone();
if label == "FILE_DATA_CHANNEL" { *file_channel.lock().unwrap() = Some(d.clone()); }
Box::pin(async move {
@@ -428,24 +557,54 @@ impl WebRtcSession {
let rich_state=Arc::new(std::sync::Mutex::new(crate::clipboard_rich::State::default()));
let clipboard_enabled = shared_clipboard_ready.clone();
if label=="CONTROL_DATA_CHANNEL" {
let closing=channel_input_session.clone();
let closing=channel_role.clone();
d.on_close(Box::new(move || {
let closing=closing.clone();
let closing=closing.input();
Box::pin(async move {if let Some(session)=closing {session.disconnected();}})
}));
}
// Ordered outbound queue for protocol replies produced outside this callback.
let (outbound, mut outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
// webrtc-rs announces the channel before handle_open (ready_state Connecting);
// send() returns ErrClosedPipe until Open. Draining CONTROL here would drop
// Message 25 and every later reply. Start CONTROL from the on_open below
// (one handler; a second on_open replaces it). Receiver taken once.
let mut control_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
if label == "CONTROL_DATA_CHANNEL" {
if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() {
let sync_out = outbound.clone();
let sync_seq = reply_sequence.clone();
tokio::spawn(async move {
while let Some(payload) = chroma_sync_rx.recv().await {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let seq = sync_seq.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let _ = sync_out.send(crate::initialization::envelope(seq, timestamp, 25, &payload));
}
});
}
}
{
let out_channel = d.clone();
let out_label = label.clone();
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
let outbound_rx = outbound_rx.clone();
let start_drain = move || {
let out_channel = out_channel.clone();
let out_label = out_label.clone();
let outbound_rx = outbound_rx.clone();
Box::pin(async move {
let Some(mut outbound_rx) = take_outbound_once(&outbound_rx).await else { return; };
tokio::spawn(async move {
while let Some(message) = outbound_rx.recv().await {
if let Err(e) = out_channel.send(&bytes::Bytes::from(message)).await {
log::warn!("{} send failed: {}", out_label, e); break;
}
}
});
}) as std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
};
if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); }
else { control_drain = Some(Box::new(start_drain)); }
}
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
@@ -456,8 +615,9 @@ impl WebRtcSession {
let manager = portal_desktop.clone();
let channel = Arc::downgrade(&d);
let initial_screen = screen.clone();
let switch_owner=channel_input_session.clone();
let capture_role=channel_role.clone();
let settings_serial=peer_settings_serial.clone();
let capture_selection = peer_selection;
tokio::spawn(async move {
let mut health = tokio::time::interval(std::time::Duration::from_millis(100));
loop {
@@ -473,6 +633,7 @@ impl WebRtcSession {
}
};
let _serial=settings_serial.lock().await;
let (desktop,switch_owner)=(capture_role.is_desktop(),capture_role.input());
if desktop && switch_owner.as_ref().is_none_or(|owner|!owner.is_current()) {continue;}
let reject=|reason:&str| {
if let Some(response)=crate::capture_setting::rejected_request(&request,reason) {
@@ -518,10 +679,10 @@ impl WebRtcSession {
if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; }
}
} else {
Some(initial_screen.clone())
Some(capture_role.screen_or(&initial_screen))
}
} else {
Some(initial_screen.clone())
Some(capture_role.screen_or(&initial_screen))
};
let Some(active_screen) = active_screen else { continue; };
let input_size = if active_screen.init_error.is_none() {
@@ -560,17 +721,35 @@ impl WebRtcSession {
(21, WireValue::Bytes(rpc)) => Some(*rpc), _ => None,
}) else { continue; };
let Ok(rpc_fields) = crate::protocol::decode_wire(rpc) else { continue; };
// X11: 分辨率 changes the display mode itself, like the official Windows host; the stream
// then carries the new native size instead of a scaled one (desktop_mode). With
// UU_X11_MULTISCREEN the monitor layout stays as it is and the stream is scaled.
let resized = if desktop && active_screen.init_error.is_none() && active_screen.portal.is_none()
&& active_screen.backend == crate::desktop_backend::DesktopBackend::X11 && crate::desktop_mode::enabled()
&& !crate::wayland::x11_multiscreen() {
match crate::capture_setting::requested_resolution(&rpc_fields) {
Some(request) => {
let display = active_screen.display.clone();
tokio::task::spawn_blocking(move || crate::desktop_mode::apply(&display, request)).await.ok().flatten()
.filter(|size| *size != input_size)
},
None => None,
}
} else { None };
let input_size = resized.unwrap_or(input_size);
let before = *settings.borrow();
let output_before = before.output;
let revision = track.revision();
let apply=|| crate::capture_setting::handle_rpc_with_codecs(
let apply=|| crate::capture_setting::handle_rpc_for(
&rpc_fields, &settings, input_size,
track.supports(crate::capture_setting::VideoCodec::H264),
track.supports(crate::capture_setting::VideoCodec::H265));
track.supports(crate::capture_setting::VideoCodec::H265), capture_selection);
let response=if let Some(owner)=&switch_owner {
let mut response=None;owner.with_current(||response=apply());response
} else {apply()};
let Some(response)=response else {continue;};
// Restart capture even when the encoded settings are unchanged (native size, no scaling).
if resized.is_some() { settings.send_modify(|s| s.source_generation = s.source_generation.wrapping_add(1)); }
let codec_changed = settings.borrow().codec != before.codec;
if desktop && codec_changed && !track.wait_for_applied(revision, &settings).await {
log::warn!("Codec switch did not produce a transmitted frame; success reply withheld");
@@ -581,7 +760,7 @@ impl WebRtcSession {
let next = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let _ = response_tx.send(crate::initialization::envelope(next(), timestamp, 22, &response));
let current = *settings.borrow();
if current.output != output_before {
if current.output != output_before || resized.is_some() {
match crate::capture_setting::screen_sources(next(), timestamp, input_size, current.output, "Linux desktop") {
Ok(screens) => { let _ = response_tx.send(screens); }
Err(error) => log::warn!("Screen sources update failed: {}", error),
@@ -612,9 +791,12 @@ impl WebRtcSession {
let open_video = channel_video_settings.clone();
let open_track = peer_video_track.clone();
let open_desktop = portal_desktop.clone();
let open_owner = channel_input_session.clone();
let open_owner = channel_role.input();
let open_role = channel_role.clone();
let open_screen = screen.clone();
let open_selection = peer_selection;
d.on_open(Box::new(move || {
if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); }
let init_actions = open_actions.clone();
let init_video = open_video.clone();
let init_track = open_track.clone();
@@ -626,82 +808,91 @@ impl WebRtcSession {
let rich_outgoing=rich_outgoing.clone();
let portal_desktop = open_desktop.clone();
let owner = open_owner.clone();
let role = open_role.clone();
let pc = desktop_pc.upgrade();
Box::pin(async move {
// Permission dialogs and first-frame waits must not occupy the
// channel-open callback or delay CONTROL message dispatch.
tokio::spawn(async move {
if channel.label() == "TEXT_DATA_CHANNEL" {
if !desktop { return; }
let screen = if let Some(desktop) = &portal_desktop {
let mut updates = desktop.subscribe();
let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; };
let mut locked = desktop.lock_state();
loop {
let state = desktop.snapshot();
if !state.waiting && state.screen.init_error.is_some() { return; }
if let Some(session) = state.screen.portal.as_ref() {
if session.is_alive() && *locked.borrow() == Some(false) {
break state.screen;
}
}
tokio::select! {
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
changed = locked.changed() => if changed.is_err() { return; },
_ = async {
loop {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
} => return,
}
}
} else { screen };
let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) };
*clipboard_sink.lock().unwrap() = Some(bridge.incoming);
let clipboard_channel = channel.clone();
let clipboard_sequence = sequence.clone();
let clipboard_cleanup = clipboard_sink.clone();
let ready = bridge.ready.await.unwrap_or(false);
clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed);
tokio::spawn(async move {
if !ready {
*clipboard_cleanup.lock().unwrap() = None;
log::warn!("Native text clipboard unavailable"); return;
}
log::info!("Native text clipboard bridge ready");
let mut updates = bridge.outgoing;
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
loop {
tokio::select! {
_ = health.tick() => {
if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
},
changed = updates.changed() => {
if changed.is_err() { break; }
let text = updates.borrow_and_update().clone();
let Some(text) = text else { continue; };
{
let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) {
Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;}
};
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload);
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) {
log::warn!("Native clipboard RPC send failed"); break;
}
}
log::info!("Native clipboard text format offered: bytes={}",text.len());
}
}
}
*clipboard_cleanup.lock().unwrap() = None;
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed);
});
return;
loop {
if !role.is_desktop() && !role.wait_desktop(&channel).await { return; }
let screen = if let Some(desktop) = &portal_desktop {
let mut updates = desktop.subscribe();
let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; };
let mut locked = desktop.lock_state();
loop {
let state = desktop.snapshot();
if !state.waiting && state.screen.init_error.is_some() { return; }
if let Some(session) = state.screen.portal.as_ref() {
if session.is_alive() && *locked.borrow() == Some(false) {
break state.screen;
}
}
tokio::select! {
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
changed = locked.changed() => if changed.is_err() { return; },
_ = async {
loop {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
} => return,
}
}
} else { role.screen_or(&screen) };
let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) };
*clipboard_sink.lock().unwrap() = Some(bridge.incoming);
let clipboard_channel = channel.clone();
let clipboard_sequence = sequence.clone();
let clipboard_cleanup = clipboard_sink.clone();
let rich_outgoing = rich_outgoing.clone();
let ready = bridge.ready.await.unwrap_or(false);
clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed);
{
if !ready {
*clipboard_cleanup.lock().unwrap() = None;
log::warn!("Native text clipboard unavailable"); return;
}
log::info!("Native text clipboard bridge ready");
let mut updates = bridge.outgoing;
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
let mut active = role.active.subscribe();
loop {
tokio::select! {
_ = health.tick() => {
if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
},
_ = async { let _ = active.wait_for(|active| !*active).await; } => break,
changed = updates.changed() => {
if changed.is_err() { break; }
let text = updates.borrow_and_update().clone();
let Some(text) = text else { continue; };
{
let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) {
Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;}
};
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload);
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) {
log::warn!("Native clipboard RPC send failed"); break;
}
}
log::info!("Native clipboard text format offered: bytes={}",text.len());
}
}
}
*clipboard_cleanup.lock().unwrap() = None;
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed);
}
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
// A newer desktop took over this promoted tool peer; capture_desktop restarts the clipboard.
log::info!("Native text clipboard stopped: a newer desktop took over");
}
}
let replay = (last_echo_request.clone(), echo_seen.clone(), clipboard_ready.clone());
let early_desktop_selection = desktop && portal_desktop.is_some();
if early_desktop_selection {
// Android 4.43.0's unlock presenter requires CaptureChange
@@ -788,58 +979,75 @@ impl WebRtcSession {
}
} else { snapshot.screen }
} else { screen };
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let next_seq = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
// Default file-transfer folder: the desktop user's home directory.
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
// Tool peers are permitted without a desktop; the port-mapping viewer aborts on Reject.
let desktop_permission=if screen.init_error.is_none() || !desktop {
crate::system_metrics::Permission::Allow
} else { crate::system_metrics::Permission::Reject };
// Without a desktop (headless/portal before consent) the port-mapping tool still waits
// for ScreenSources/CaptureChange and aborts otherwise: tool peers get a nominal screen.
let screen_size=crate::wayland::input_size(if screen.init_error.is_none() { (screen.width, screen.height) } else { (1920, 1080) });
let messages = [
(8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, crate::wayland::selected() as i32, "Linux desktop")),
(13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))),
(26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26,
&crate::system_metrics::remote_download_path(&home)))),
(18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18,
&crate::capture_setting::codec_negotiation(screen_size, crate::video::display_fps(), init_track.supports(crate::capture_setting::VideoCodec::H265))))),
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")),
];
if desktop && screen.init_error.is_none() {
let codec = crate::capture_setting::preferred_codec(init_track.supports(crate::capture_setting::VideoCodec::H264),
init_track.supports(crate::capture_setting::VideoCodec::H265));
init_video.send_if_modified(|current| if current.codec != codec {
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
}
for (field, message) in messages {
if early_desktop_selection && field == 8 { continue; }
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; }
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; }
let message = match message {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop);
let mut screen = screen;
loop {
loop {
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
// Tool peers are permitted without a desktop; the port-mapping viewer aborts on Reject.
let desktop_permission=if screen.init_error.is_none() || !desktop {
crate::system_metrics::Permission::Allow
} else { crate::system_metrics::Permission::Reject };
// Without a desktop (headless/portal before consent) the port-mapping tool still waits
// for ScreenSources/CaptureChange and aborts otherwise: tool peers get a nominal screen.
let screen_size=crate::wayland::input_size(if screen.init_error.is_none() { (screen.width, screen.height) } else { (1920, 1080) });
let messages = [
(8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, crate::wayland::selected() as i32, "Linux desktop")),
(13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))),
(26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26,
&crate::system_metrics::remote_download_path(&home)))),
(18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18,
&crate::capture_setting::codec_negotiation(screen_size, crate::video::display_fps(), init_track.supports(crate::capture_setting::VideoCodec::H265))))),
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")),
];
if desktop && screen.init_error.is_none() {
let codec = crate::capture_setting::preferred_codec_for(init_track.supports(crate::capture_setting::VideoCodec::H264),
init_track.supports(crate::capture_setting::VideoCodec::H265), open_selection);
init_video.send_if_modified(|current| if current.codec != codec {
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
}
log::info!("CONTROL initialization field {} sent", field);
for (field, message) in messages {
if early_desktop_selection && field == 8 { continue; }
if promoted && field == 26 { continue; }
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; }
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; }
let message = match message {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
}
log::info!("CONTROL initialization field {} sent", field);
}
if desktop { break; }
// The viewer opened the desktop on this tool connection (#99): repeat the
// desktop initialization once the host has started its video and input.
if !role.wait_desktop(&channel).await { return; }
(desktop, promoted) = (true, true);
screen = role.screen_or(&screen);
replay_clipboard_echo(channel.clone(), sequence.clone(), replay.clone(), role.clone());
}
if !lock_reported {
lock_reported = true;
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
}
// Mirror the Linux pointer shape; the video itself carries no pointer.
if !desktop { return; }
let mut shapes = crate::cursor::monitor(&screen.display);
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
let mut sent = 0usize;
loop {
let mut active = role.active.subscribe();
'cursor: loop {
let current = shapes.borrow_and_update().clone();
if let Some(cursor) = current {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::cursor::encode_cursor_shape(next_seq(), timestamp, &cursor);
if channel.send(&bytes::Bytes::from(message)).await.is_err() { break; }
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
sent += 1;
if sent <= 3 || sent % 100 == 0 {
log::info!("Cursor shape sent: count={} size={}x{} hotspot={},{} png_bytes={}", sent, cursor.width, cursor.height, cursor.hot_x, cursor.hot_y, cursor.png.len());
@@ -848,12 +1056,18 @@ impl WebRtcSession {
loop {
tokio::select! {
changed = shapes.changed() => { if changed.is_err() { return; } break; },
_ = active.wait_for(|active| !*active) => break 'cursor,
_ = health.tick() => {
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
},
}
}
}
// A newer desktop took over this promoted tool peer; wait for capture_desktop again.
if !role.wait_desktop(&channel).await { return; }
screen = role.screen_or(&screen);
replay_clipboard_echo(channel.clone(), sequence.clone(), replay.clone(), role.clone());
}
});
})
}));
@@ -862,14 +1076,15 @@ impl WebRtcSession {
d.on_message(Box::new(move |msg: DataChannelMessage| {
// Keep the whole state: a cached screen waiting for a closed Portal is not ready for input.
let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (screen.clone(), true), |desktop| {
let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (channel_role.screen_or(&screen), true), |desktop| {
let state = desktop.snapshot();
let ready = state.ready();
(state.screen, ready)
});
let channel_name = lbl.clone();
let input_worker = inp.clone();
let message_input_session=channel_input_session.clone();
let message_input_session=channel_role.input();
let message_role=channel_role.clone();
let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone();
let reply_chan = d_reply.clone();
@@ -889,6 +1104,8 @@ impl WebRtcSession {
Box::pin(async move {
let input_size = crate::wayland::input_size((screen.width, screen.height));
// After a RandR resize the stream restarts capture at the new size; map the pointer to it.
let live_x11 = screen.init_error.is_none() && screen.portal.is_none() && screen.backend == crate::desktop_backend::DesktopBackend::X11;
if let Some(term) = &terminal_worker {
if crate::terminal::is_frame(&msg.data) { term.handle(&msg.data); return; }
}
@@ -1101,6 +1318,19 @@ impl WebRtcSession {
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
}
});
} else if action == sa::CAPTURE_DESKTOP && channel_name == "CONTROL_DATA_CHANNEL" {
if message_role.is_desktop() && !message_role.stream_ended() {
log::info!("SimpleAction 4 (capture_desktop) received on a desktop connection");
} else if let Some(request) = message_role.request.get() {
if message_role.is_desktop() {
log::info!("SimpleAction 4 (capture_desktop) received on a tool connection whose desktop video ended; restarting it");
} else {
log::info!("SimpleAction 4 (capture_desktop) received on a tool connection; starting the desktop");
}
request();
} else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
}
} else if action > 1 && action != 15 {
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
@@ -1160,7 +1390,7 @@ impl WebRtcSession {
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(input_size)),
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),
@@ -1223,10 +1453,53 @@ impl WebRtcSession {
capture,
input,
desktop,
role,
controller_mac: false,
context,
actions: session_actions,
})
}
/// Route for capture_desktop on this tool peer; the caller decides whether it may become the desktop.
pub fn on_desktop_request(&self, request: impl Fn() + Send + Sync + 'static) {
let _ = self.role.request.set(Box::new(request));
}
/// Makes this tool peer the desktop: it takes the input lease, starts the video it negotiated
/// (H.264; audio was never negotiated) and repeats the desktop CONTROL initialization.
/// `screen` replaces a capture that was unavailable when the peer was offered.
/// A promoted peer whose video ended keeps its input lease and only restarts the video.
pub fn promote(&self, screen: Option<Arc<ScreenCapture>>) {
let restart = self.role.is_desktop();
if restart && !self.role.stream_ended() { return; }
if let Some(screen) = screen { *self.role.screen.lock().unwrap() = Some(screen); }
if !restart {
let session = self.input.desktop_session();
if self.pc.connection_state() == RTCPeerConnectionState::Connected { session.connected(); }
*self.role.input.lock().unwrap() = Some(session);
self.role.active.send_replace(true);
}
let stream = self.role.stream.lock().unwrap().clone();
let task = stream.and_then(|stream| stream.spawn(self.role.screen.lock().unwrap().clone(), self.role.active.subscribe()));
if let Some(old) = std::mem::replace(&mut *self.role.stream_task.lock().unwrap(), task) { old.abort(); }
if restart { log::info!("Desktop video restarted on a tool connection after its stream ended"); return; }
if !cfg!(test) { track_session(self.pc.clone(), self.actions.clone(), &self.role); }
log::info!("Desktop started on an existing tool connection");
}
/// The capture this peer's desktop uses: its own, or the one reinitialized at promotion.
pub fn desktop_capture(&self) -> Arc<ScreenCapture> { self.role.screen_or(&self.capture) }
/// A newer desktop took over a promoted tool peer: stop its video, input and session count,
/// keep the connection's tools. capture_desktop on it promotes it again.
pub fn demote(&self) {
if self.desktop || !self.role.is_desktop() { return; }
self.role.active.send_replace(false);
if let Some(task) = self.role.stream_task.lock().unwrap().take() { task.abort(); }
if let Some(session) = self.role.input.lock().unwrap().take() { session.disconnected(); }
log::info!("Desktop on a tool connection stopped: a newer desktop took over");
}
/// 应用远端 Offer,生成并返回 Answer
pub async fn handle_offer(&self, soac: &SoacMessage) -> Result<String, String> {
// 同步当前的客户端与房间会话上下文
@@ -1395,6 +1668,11 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
None
}
/// First drain owns the outbound receiver; a later open must not start another.
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
slot.lock().await.take()
}
#[cfg(test)]
mod tests {
use super::negotiated_bundle_media;
@@ -1417,6 +1695,16 @@ mod tests {
let sdp = "a=group:BUNDLE data video\nm=video 9 RTP 98\na=mid:video\nm=application 9 SCTP 0\na=mid:data\n";
assert_eq!(negotiated_bundle_media(sdp), Some(("data".into(), 1)));
}
#[tokio::test]
async fn outbound_receiver_is_taken_once() {
let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let slot = std::sync::Arc::new(tokio::sync::Mutex::new(Some(rx)));
let first = super::take_outbound_once(&slot).await;
let second = super::take_outbound_once(&slot).await;
assert!(first.is_some());
assert!(second.is_none());
drop(tx);
}
}
#[cfg(test)]
+11
View File
@@ -0,0 +1,11 @@
# Generated by Cargo
# will have compiled files and executables
/target/
/.idea/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock
# These are backup files generated by rustfmt
**/*.rs.bk
+19
View File
@@ -0,0 +1,19 @@
# webrtc-srtp changelog
## Unreleased
## v0.9.1
* Increased minimum support rust version to `1.60.0`.
* Increased required `webrtc-util` version to `0.7.0`.
## v0.9.0
* [#8 update deps + loosen some requirements](https://github.com/webrtc-rs/srtp/pull/8) by [@melekes](https://github.com/melekes).
* Increased min version of `log` dependency to `0.4.16`. [#250 Fix log at ^0.4.16 to make tests compile](https://github.com/webrtc-rs/webrtc/pull/250) by [@k0nserv](https://github.com/k0nserv).
## Prior to 0.8.9
Before 0.8.9 there was no changelog, previous changes are sometimes, but not always, available in the [GitHub Releases](https://github.com/webrtc-rs/srtp/releases).
+100
View File
@@ -0,0 +1,100 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies.
#
# If you are reading this file be aware that the original Cargo.toml
# will likely look very different (and much more reasonable).
# See Cargo.toml.orig for the original contents.
[package]
edition = "2021"
name = "webrtc-srtp"
version = "0.12.0"
authors = ["Rain Liu <[email protected]>"]
description = "A pure Rust implementation of SRTP"
homepage = "https://webrtc.rs"
documentation = "https://docs.rs/webrtc-srtp"
readme = "README.md"
license = "MIT OR Apache-2.0"
repository = "https://github.com/webrtc-rs/srtp"
[[bench]]
name = "srtp_bench"
harness = false
[dependencies.aead]
version = "0.5"
features = ["std"]
[dependencies.aes]
version = "0.8"
[dependencies.aes-gcm]
version = "0.10"
features = ["std"]
[dependencies.byteorder]
version = "1"
[dependencies.bytes]
version = "1"
[dependencies.ctr]
version = "0.9"
[dependencies.hmac]
version = "0.12"
features = ["std"]
[dependencies.log]
version = "0.4"
[dependencies.openssl]
version = "0.10.57"
optional = true
[dependencies.rtcp]
version = "0.10.1"
[dependencies.rtp]
version = "0.10.0"
[dependencies.sha1]
version = "0.10"
[dependencies.subtle]
version = "2"
[dependencies.thiserror]
version = "1"
[dependencies.tokio]
version = "1.32.0"
features = ["full"]
[dependencies.util]
version = "0.8.1"
features = [
"conn",
"buffer",
"marshal",
]
default-features = false
package = "webrtc-util"
[dev-dependencies.criterion]
version = "0.5"
features = ["async_futures"]
[dev-dependencies.lazy_static]
version = "1"
[dev-dependencies.tokio-test]
version = "0.4"
[features]
openssl = ["dep:openssl"]
vendored-openssl = ["openssl/vendored"]
+46
View File
@@ -0,0 +1,46 @@
[package]
name = "webrtc-srtp"
version = "0.12.0"
authors = ["Rain Liu <[email protected]>"]
edition = "2021"
description = "A pure Rust implementation of SRTP"
license = "MIT OR Apache-2.0"
documentation = "https://docs.rs/webrtc-srtp"
homepage = "https://webrtc.rs"
repository = "https://github.com/webrtc-rs/srtp"
[features]
openssl = ["dep:openssl"]
vendored-openssl = ["openssl/vendored"]
[dependencies]
util = { version = "0.8.1", path = "../util", package = "webrtc-util", default-features = false, features = [
"conn",
"buffer",
"marshal",
] }
rtp = { version = "0.10.0", path = "../rtp" }
rtcp = { version = "0.10.1", path = "../rtcp" }
byteorder = "1"
bytes = "1"
thiserror = "1"
hmac = { version = "0.12", features = ["std"] }
sha1 = "0.10"
ctr = "0.9"
aes = "0.8"
subtle = "2"
tokio = { version = "1.32.0", features = ["full"] }
log = "0.4"
aead = { version = "0.5", features = ["std"] }
aes-gcm = { version = "0.10", features = ["std"] }
openssl = { version = "0.10.57", optional = true }
[dev-dependencies]
criterion = { version = "0.5", features = ["async_futures"] }
tokio-test = "0.4"
lazy_static = "1"
[[bench]]
name = "srtp_bench"
harness = false
+201
View File
@@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2021 WebRTC.rs
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+14
View File
@@ -0,0 +1,14 @@
# Local patch to webrtc-srtp 0.12.0
Source: crates.io webrtc-srtp 0.12.0 (MIT / Apache-2.0; upstream licenses retained).
`SrtpSsrcState` estimates the rollover counter with the half-sequence-space rule from
RFC 3711 Appendix A and only advances to the highest packet index seen. Upstream used a
100-packet window and stored every sequence number, so a NACK retransmission of a
pre-wrap packet sent after the wrap (e.g. 65000 after 85) moved the state back and the
next new packet was protected with ROC+1; the receiver then failed authentication for
every following packet (frozen video, #83). Fix and regression tests contributed by
@AYssu. Cipher code, wire format and SRTCP are unchanged.
The upstream lifecycle test jumped from 5004 to 65535, outside the half-space window;
bridge packets keep it consecutive and the known-answer vectors are unchanged.
+30
View File
@@ -0,0 +1,30 @@
<h1 align="center">
<a href="https://webrtc.rs"><img src="./doc/webrtc.rs.png" alt="WebRTC.rs"></a>
<br>
</h1>
<p align="center">
<a href="https://github.com/webrtc-rs/srtp/actions">
<img src="https://github.com/webrtc-rs/srtp/workflows/cargo/badge.svg">
</a>
<a href="https://codecov.io/gh/webrtc-rs/srtp">
<img src="https://codecov.io/gh/webrtc-rs/srtp/branch/main/graph/badge.svg">
</a>
<a href="https://deps.rs/repo/github/webrtc-rs/srtp">
<img src="https://deps.rs/repo/github/webrtc-rs/srtp/status.svg">
</a>
<a href="https://crates.io/crates/webrtc-srtp">
<img src="https://img.shields.io/crates/v/webrtc-srtp.svg">
</a>
<a href="https://docs.rs/webrtc-srtp">
<img src="https://docs.rs/webrtc-srtp/badge.svg">
</a>
<a href="https://doc.rust-lang.org/1.6.0/complement-project-faq.html#why-dual-mitasl2-license">
<img src="https://img.shields.io/badge/license-MIT%2FApache--2.0-blue" alt="License: MIT/Apache 2.0">
</a>
<a href="https://discord.gg/4Ju8UHdXMs">
<img src="https://img.shields.io/discord/800204819540869120?logo=discord" alt="Discord">
</a>
</p>
<p align="center">
A pure Rust implementation of SRTP. Rewrite <a href="https://github.com/pion/srtp/releases/tag/v1.5.2">Pion</a> SRTP in Rust
</p>
+158
View File
@@ -0,0 +1,158 @@
use bytes::BytesMut;
use criterion::{criterion_group, criterion_main, Criterion};
use util::Marshal;
use webrtc_srtp::{context::Context, protection_profile::ProtectionProfile};
const MASTER_KEY: &[u8] = &[
96, 180, 31, 4, 119, 137, 128, 252, 75, 194, 252, 44, 63, 56, 61, 55,
];
const MASTER_SALT: &[u8] = &[247, 26, 49, 94, 99, 29, 79, 94, 5, 111, 252, 216, 62, 195];
const RAW_RTCP: &[u8] = &[
0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
];
fn benchmark_encrypt_rtp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
let mut ctx = Context::new(
MASTER_KEY,
MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
.unwrap();
let mut pld = BytesMut::new();
for i in 0..1200 {
pld.extend_from_slice(&[i as u8]);
}
c.bench_function("Benchmark RTP encrypt", |b| {
let mut seq = 1;
b.iter_batched(
|| {
let pkt = rtp::packet::Packet {
header: rtp::header::Header {
sequence_number: seq,
timestamp: seq.into(),
extension_profile: 48862,
marker: true,
padding: false,
extension: true,
payload_type: 96,
..Default::default()
},
payload: pld.clone().into(),
};
seq += 1;
pkt.marshal().unwrap()
},
|pkt_raw| {
ctx.encrypt_rtp(&pkt_raw).unwrap();
},
criterion::BatchSize::LargeInput,
);
});
}
fn benchmark_decrypt_rtp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
let mut setup_ctx = Context::new(
MASTER_KEY,
MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
.unwrap();
let mut ctx = Context::new(
MASTER_KEY,
MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
.unwrap();
let mut pld = BytesMut::new();
for i in 0..1200 {
pld.extend_from_slice(&[i as u8]);
}
c.bench_function("Benchmark RTP decrypt", |b| {
let mut seq = 1;
b.iter_batched(
|| {
let pkt = rtp::packet::Packet {
header: rtp::header::Header {
sequence_number: seq,
timestamp: seq.into(),
extension_profile: 48862,
marker: true,
padding: false,
extension: true,
payload_type: 96,
..Default::default()
},
payload: pld.clone().into(),
};
seq += 1;
setup_ctx.encrypt_rtp(&pkt.marshal().unwrap()).unwrap()
},
|encrypted| ctx.decrypt_rtp(&encrypted).unwrap(),
criterion::BatchSize::LargeInput,
);
});
}
fn benchmark_encrypt_rtcp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
let mut ctx = Context::new(
MASTER_KEY,
MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
.unwrap();
c.bench_function("Benchmark RTCP encrypt", |b| {
b.iter(|| {
ctx.encrypt_rtcp(RAW_RTCP).unwrap();
});
});
}
fn benchmark_decrypt_rtcp_aes_128_cm_hmac_sha1(c: &mut Criterion) {
let encrypted = Context::new(
MASTER_KEY,
MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
.unwrap()
.encrypt_rtcp(RAW_RTCP)
.unwrap();
let mut ctx = Context::new(
MASTER_KEY,
MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
.unwrap();
c.bench_function("Benchmark RTCP decrypt", |b| {
b.iter(|| ctx.decrypt_rtcp(&encrypted).unwrap());
});
}
criterion_group!(
benches,
benchmark_encrypt_rtp_aes_128_cm_hmac_sha1,
benchmark_decrypt_rtp_aes_128_cm_hmac_sha1,
benchmark_encrypt_rtcp_aes_128_cm_hmac_sha1,
benchmark_decrypt_rtcp_aes_128_cm_hmac_sha1
);
criterion_main!(benches);
+23
View File
@@ -0,0 +1,23 @@
codecov:
require_ci_to_pass: yes
max_report_age: off
token: d65de923-7c3d-4836-8d9a-5183b356be4f
coverage:
precision: 2
round: down
range: 50..90
status:
project:
default:
enabled: no
threshold: 0.2
if_not_found: success
patch:
default:
enabled: no
if_not_found: success
changes:
default:
enabled: no
if_not_found: success
Binary file not shown.

After

Width:  |  Height:  |  Size: 32 KiB

+247
View File
@@ -0,0 +1,247 @@
use aes_gcm::aead::generic_array::GenericArray;
use aes_gcm::aead::{Aead, Payload};
use aes_gcm::{Aes128Gcm, KeyInit, Nonce};
use byteorder::{BigEndian, ByteOrder};
use bytes::{Bytes, BytesMut};
use util::marshal::*;
use super::Cipher;
use crate::error::{Error, Result};
use crate::key_derivation::*;
pub const CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN: usize = 16;
const RTCP_ENCRYPTION_FLAG: u8 = 0x80;
/// AEAD Cipher based on AES.
pub(crate) struct CipherAeadAesGcm {
srtp_cipher: aes_gcm::Aes128Gcm,
srtcp_cipher: aes_gcm::Aes128Gcm,
srtp_session_salt: Vec<u8>,
srtcp_session_salt: Vec<u8>,
}
impl Cipher for CipherAeadAesGcm {
fn auth_tag_len(&self) -> usize {
CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN
}
fn encrypt_rtp(
&mut self,
payload: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes> {
// Grow the given buffer to fit the output.
let header_len = header.marshal_size();
let mut writer = BytesMut::with_capacity(payload.len() + self.auth_tag_len());
// Copy header unencrypted.
writer.extend_from_slice(&payload[..header_len]);
let nonce = self.rtp_initialization_vector(header, roc);
let encrypted = self.srtp_cipher.encrypt(
Nonce::from_slice(&nonce),
Payload {
msg: &payload[header_len..],
aad: &writer,
},
)?;
writer.extend(encrypted);
Ok(writer.freeze())
}
fn decrypt_rtp(
&mut self,
ciphertext: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes> {
if ciphertext.len() < self.auth_tag_len() {
return Err(Error::ErrFailedToVerifyAuthTag);
}
let nonce = self.rtp_initialization_vector(header, roc);
let payload_offset = header.marshal_size();
let decrypted_msg: Vec<u8> = self.srtp_cipher.decrypt(
Nonce::from_slice(&nonce),
Payload {
msg: &ciphertext[payload_offset..],
aad: &ciphertext[..payload_offset],
},
)?;
let mut writer = BytesMut::with_capacity(payload_offset + decrypted_msg.len());
writer.extend_from_slice(&ciphertext[..payload_offset]);
writer.extend(decrypted_msg);
Ok(writer.freeze())
}
fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
let iv = self.rtcp_initialization_vector(srtcp_index, ssrc);
let aad = self.rtcp_additional_authenticated_data(decrypted, srtcp_index);
let encrypted_data = self.srtcp_cipher.encrypt(
Nonce::from_slice(&iv),
Payload {
msg: &decrypted[8..],
aad: &aad,
},
)?;
let mut writer = BytesMut::with_capacity(encrypted_data.len() + aad.len());
writer.extend_from_slice(&decrypted[..8]);
writer.extend(encrypted_data);
writer.extend_from_slice(&aad[8..]);
Ok(writer.freeze())
}
fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
if encrypted.len() < self.auth_tag_len() + SRTCP_INDEX_SIZE {
return Err(Error::ErrFailedToVerifyAuthTag);
}
let nonce = self.rtcp_initialization_vector(srtcp_index, ssrc);
let aad = self.rtcp_additional_authenticated_data(encrypted, srtcp_index);
let decrypted_data = self.srtcp_cipher.decrypt(
Nonce::from_slice(&nonce),
Payload {
msg: &encrypted[8..(encrypted.len() - SRTCP_INDEX_SIZE)],
aad: &aad,
},
)?;
let mut writer = BytesMut::with_capacity(8 + decrypted_data.len());
writer.extend_from_slice(&encrypted[..8]);
writer.extend(decrypted_data);
Ok(writer.freeze())
}
fn get_rtcp_index(&self, input: &[u8]) -> usize {
let pos = input.len() - 4;
let val = BigEndian::read_u32(&input[pos..]);
(val & !((RTCP_ENCRYPTION_FLAG as u32) << 24)) as usize
}
}
impl CipherAeadAesGcm {
/// Create a new AEAD instance.
pub(crate) fn new(master_key: &[u8], master_salt: &[u8]) -> Result<CipherAeadAesGcm> {
let srtp_session_key = aes_cm_key_derivation(
LABEL_SRTP_ENCRYPTION,
master_key,
master_salt,
0,
master_key.len(),
)?;
let srtp_block = GenericArray::from_slice(&srtp_session_key);
let srtp_cipher = Aes128Gcm::new(srtp_block);
let srtcp_session_key = aes_cm_key_derivation(
LABEL_SRTCP_ENCRYPTION,
master_key,
master_salt,
0,
master_key.len(),
)?;
let srtcp_block = GenericArray::from_slice(&srtcp_session_key);
let srtcp_cipher = Aes128Gcm::new(srtcp_block);
let srtp_session_salt = aes_cm_key_derivation(
LABEL_SRTP_SALT,
master_key,
master_salt,
0,
master_key.len(),
)?;
let srtcp_session_salt = aes_cm_key_derivation(
LABEL_SRTCP_SALT,
master_key,
master_salt,
0,
master_key.len(),
)?;
Ok(CipherAeadAesGcm {
srtp_cipher,
srtcp_cipher,
srtp_session_salt,
srtcp_session_salt,
})
}
/// The 12-octet IV used by AES-GCM SRTP is formed by first concatenating
/// 2 octets of zeroes, the 4-octet SSRC, the 4-octet rollover counter
/// (ROC), and the 2-octet sequence number (SEQ). The resulting 12-octet
/// value is then XORed to the 12-octet salt to form the 12-octet IV.
///
/// https://tools.ietf.org/html/rfc7714#section-8.1
pub(crate) fn rtp_initialization_vector(
&self,
header: &rtp::header::Header,
roc: u32,
) -> Vec<u8> {
let mut iv = vec![0u8; 12];
BigEndian::write_u32(&mut iv[2..], header.ssrc);
BigEndian::write_u32(&mut iv[6..], roc);
BigEndian::write_u16(&mut iv[10..], header.sequence_number);
for (i, v) in iv.iter_mut().enumerate() {
*v ^= self.srtp_session_salt[i];
}
iv
}
/// The 12-octet IV used by AES-GCM SRTCP is formed by first
/// concatenating 2 octets of zeroes, the 4-octet SSRC identifier,
/// 2 octets of zeroes, a single "0" bit, and the 31-bit SRTCP index.
/// The resulting 12-octet value is then XORed to the 12-octet salt to
/// form the 12-octet IV.
///
/// https://tools.ietf.org/html/rfc7714#section-9.1
pub(crate) fn rtcp_initialization_vector(&self, srtcp_index: usize, ssrc: u32) -> Vec<u8> {
let mut iv = vec![0u8; 12];
BigEndian::write_u32(&mut iv[2..], ssrc);
BigEndian::write_u32(&mut iv[8..], srtcp_index as u32);
for (i, v) in iv.iter_mut().enumerate() {
*v ^= self.srtcp_session_salt[i];
}
iv
}
/// In an SRTCP packet, a 1-bit Encryption flag is prepended to the
/// 31-bit SRTCP index to form a 32-bit value we shall call the
/// "ESRTCP word"
///
/// https://tools.ietf.org/html/rfc7714#section-17
pub(crate) fn rtcp_additional_authenticated_data(
&self,
rtcp_packet: &[u8],
srtcp_index: usize,
) -> Vec<u8> {
let mut aad = vec![0u8; 12];
aad[..8].copy_from_slice(&rtcp_packet[..8]);
BigEndian::write_u32(&mut aad[8..], srtcp_index as u32);
aad[8] |= RTCP_ENCRYPTION_FLAG;
aad
}
}
@@ -0,0 +1,220 @@
use aes::cipher::generic_array::GenericArray;
use aes::cipher::{KeyIvInit, StreamCipher, StreamCipherSeek};
use bytes::{BufMut, Bytes};
use rtcp::header::{HEADER_LENGTH, SSRC_LENGTH};
use subtle::ConstantTimeEq;
use util::marshal::*;
use super::{Cipher, CipherInner};
use crate::error::{Error, Result};
use crate::key_derivation::*;
type Aes128Ctr = ctr::Ctr128BE<aes::Aes128>;
pub(crate) struct CipherAesCmHmacSha1 {
inner: CipherInner,
srtp_session_key: Vec<u8>,
srtcp_session_key: Vec<u8>,
}
impl CipherAesCmHmacSha1 {
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
let inner = CipherInner::new(master_key, master_salt)?;
let srtp_session_key = aes_cm_key_derivation(
LABEL_SRTP_ENCRYPTION,
master_key,
master_salt,
0,
master_key.len(),
)?;
let srtcp_session_key = aes_cm_key_derivation(
LABEL_SRTCP_ENCRYPTION,
master_key,
master_salt,
0,
master_key.len(),
)?;
Ok(CipherAesCmHmacSha1 {
inner,
srtp_session_key,
srtcp_session_key,
})
}
}
impl Cipher for CipherAesCmHmacSha1 {
fn auth_tag_len(&self) -> usize {
self.inner.auth_tag_len()
}
fn get_rtcp_index(&self, input: &[u8]) -> usize {
self.inner.get_rtcp_index(input)
}
fn encrypt_rtp(
&mut self,
plaintext: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes> {
let mut writer = Vec::with_capacity(plaintext.len() + self.auth_tag_len());
// Write the plaintext to the destination buffer.
writer.extend_from_slice(plaintext);
// Encrypt the payload
let counter = generate_counter(
header.sequence_number,
roc,
header.ssrc,
&self.inner.srtp_session_salt,
);
let key = GenericArray::from_slice(&self.srtp_session_key);
let nonce = GenericArray::from_slice(&counter);
let mut stream = Aes128Ctr::new(key, nonce);
stream.apply_keystream(&mut writer[header.marshal_size()..]);
// Generate the auth tag.
let auth_tag = &self.inner.generate_srtp_auth_tag(&writer, roc)[..self.auth_tag_len()];
writer.extend(auth_tag);
Ok(Bytes::from(writer))
}
fn decrypt_rtp(
&mut self,
encrypted: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes> {
let encrypted_len = encrypted.len();
if encrypted_len < self.auth_tag_len() {
return Err(Error::SrtpTooSmall(encrypted_len, self.auth_tag_len()));
}
let mut writer = Vec::with_capacity(encrypted_len - self.auth_tag_len());
// Split the auth tag and the cipher text into two parts.
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
// Generate the auth tag we expect to see from the ciphertext.
let expected_tag =
&self.inner.generate_srtp_auth_tag(cipher_text, roc)[..self.auth_tag_len()];
// See if the auth tag actually matches.
// We use a constant time comparison to prevent timing attacks.
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
return Err(Error::RtpFailedToVerifyAuthTag);
}
// Write cipher_text to the destination buffer.
writer.extend_from_slice(cipher_text);
// Decrypt the ciphertext for the payload.
let counter = generate_counter(
header.sequence_number,
roc,
header.ssrc,
&self.inner.srtp_session_salt,
);
let key = GenericArray::from_slice(&self.srtp_session_key);
let nonce = GenericArray::from_slice(&counter);
let mut stream = Aes128Ctr::new(key, nonce);
stream.seek(0);
stream.apply_keystream(&mut writer[header.marshal_size()..]);
Ok(Bytes::from(writer))
}
fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
let mut writer =
Vec::with_capacity(decrypted.len() + SRTCP_INDEX_SIZE + self.auth_tag_len());
// Write the decrypted to the destination buffer.
writer.extend_from_slice(decrypted);
// Encrypt everything after header
let counter = generate_counter(
(srtcp_index & 0xFFFF) as u16,
(srtcp_index >> 16) as u32,
ssrc,
&self.inner.srtcp_session_salt,
);
let key = GenericArray::from_slice(&self.srtcp_session_key);
let nonce = GenericArray::from_slice(&counter);
let mut stream = Aes128Ctr::new(key, nonce);
stream.apply_keystream(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]);
// Add SRTCP index and set Encryption bit
writer.put_u32(srtcp_index as u32 | (1u32 << 31));
// Generate the auth tag.
let auth_tag = &self.inner.generate_srtcp_auth_tag(&writer)[..self.auth_tag_len()];
writer.extend(auth_tag);
Ok(Bytes::from(writer))
}
fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
let encrypted_len = encrypted.len();
if encrypted_len < self.auth_tag_len() + SRTCP_INDEX_SIZE {
return Err(Error::SrtcpTooSmall(
encrypted_len,
self.auth_tag_len() + SRTCP_INDEX_SIZE,
));
}
let tail_offset = encrypted_len - (self.auth_tag_len() + SRTCP_INDEX_SIZE);
let mut writer = Vec::with_capacity(tail_offset);
writer.extend_from_slice(&encrypted[0..tail_offset]);
let is_encrypted = encrypted[tail_offset] >> 7;
if is_encrypted == 0 {
return Ok(Bytes::from(writer));
}
// Split the auth tag and the cipher text into two parts.
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
if actual_tag.len() != self.auth_tag_len() {
return Err(Error::RtcpInvalidLengthAuthTag(
actual_tag.len(),
self.auth_tag_len(),
));
}
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
// Generate the auth tag we expect to see from the ciphertext.
let expected_tag = &self.inner.generate_srtcp_auth_tag(cipher_text)[..self.auth_tag_len()];
// See if the auth tag actually matches.
// We use a constant time comparison to prevent timing attacks.
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
return Err(Error::RtcpFailedToVerifyAuthTag);
}
let counter = generate_counter(
(srtcp_index & 0xFFFF) as u16,
(srtcp_index >> 16) as u32,
ssrc,
&self.inner.srtcp_session_salt,
);
let key = GenericArray::from_slice(&self.srtcp_session_key);
let nonce = GenericArray::from_slice(&counter);
let mut stream = Aes128Ctr::new(key, nonce);
stream.seek(0);
stream.apply_keystream(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]);
Ok(Bytes::from(writer))
}
}
@@ -0,0 +1,133 @@
use byteorder::{BigEndian, ByteOrder};
use hmac::{Hmac, Mac};
use sha1::Sha1;
use super::Cipher;
use crate::error::{Error, Result};
use crate::key_derivation::*;
use crate::protection_profile::*;
#[cfg(not(feature = "openssl"))]
mod ctrcipher;
#[cfg(feature = "openssl")]
mod opensslcipher;
#[cfg(not(feature = "openssl"))]
pub(crate) use ctrcipher::CipherAesCmHmacSha1;
#[cfg(feature = "openssl")]
pub(crate) use opensslcipher::CipherAesCmHmacSha1;
type HmacSha1 = Hmac<Sha1>;
pub const CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN: usize = 10;
pub(crate) struct CipherInner {
srtp_session_salt: Vec<u8>,
srtp_session_auth: HmacSha1,
srtcp_session_salt: Vec<u8>,
srtcp_session_auth: HmacSha1,
}
impl CipherInner {
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
let srtp_session_salt = aes_cm_key_derivation(
LABEL_SRTP_SALT,
master_key,
master_salt,
0,
master_salt.len(),
)?;
let srtcp_session_salt = aes_cm_key_derivation(
LABEL_SRTCP_SALT,
master_key,
master_salt,
0,
master_salt.len(),
)?;
let auth_key_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_key_len();
let srtp_session_auth_tag = aes_cm_key_derivation(
LABEL_SRTP_AUTHENTICATION_TAG,
master_key,
master_salt,
0,
auth_key_len,
)?;
let srtcp_session_auth_tag = aes_cm_key_derivation(
LABEL_SRTCP_AUTHENTICATION_TAG,
master_key,
master_salt,
0,
auth_key_len,
)?;
let srtp_session_auth = HmacSha1::new_from_slice(&srtp_session_auth_tag)
.map_err(|e| Error::Other(e.to_string()))?;
let srtcp_session_auth = HmacSha1::new_from_slice(&srtcp_session_auth_tag)
.map_err(|e| Error::Other(e.to_string()))?;
Ok(Self {
srtp_session_salt,
srtp_session_auth,
srtcp_session_salt,
srtcp_session_auth,
})
}
/// https://tools.ietf.org/html/rfc3711#section-4.2
/// In the case of SRTP, M SHALL consist of the Authenticated
/// Portion of the packet (as specified in Figure 1) concatenated with
/// the roc, M = Authenticated Portion || roc;
///
/// The pre-defined authentication transform for SRTP is HMAC-SHA1
/// [RFC2104]. With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL
/// be 0. For SRTP (respectively SRTCP), the HMAC SHALL be applied to
/// the session authentication key and M as specified above, i.e.,
/// HMAC(k_a, M). The HMAC output SHALL then be truncated to the n_tag
/// left-most bits.
/// - Authenticated portion of the packet is everything BEFORE MKI
/// - k_a is the session message authentication key
/// - n_tag is the bit-length of the output authentication tag
fn generate_srtp_auth_tag(&self, buf: &[u8], roc: u32) -> [u8; 20] {
let mut signer = self.srtp_session_auth.clone();
signer.update(buf);
// For SRTP only, we need to hash the rollover counter as well.
signer.update(&roc.to_be_bytes());
signer.finalize().into_bytes().into()
}
/// https://tools.ietf.org/html/rfc3711#section-4.2
///
/// The pre-defined authentication transform for SRTP is HMAC-SHA1
/// [RFC2104]. With HMAC-SHA1, the SRTP_PREFIX_LENGTH (Figure 3) SHALL
/// be 0. For SRTP (respectively SRTCP), the HMAC SHALL be applied to
/// the session authentication key and M as specified above, i.e.,
/// HMAC(k_a, M). The HMAC output SHALL then be truncated to the n_tag
/// left-most bits.
/// - Authenticated portion of the packet is everything BEFORE MKI
/// - k_a is the session message authentication key
/// - n_tag is the bit-length of the output authentication tag
fn generate_srtcp_auth_tag(&self, buf: &[u8]) -> [u8; 20] {
let mut signer = self.srtcp_session_auth.clone();
signer.update(buf);
signer.finalize().into_bytes().into()
}
fn auth_tag_len(&self) -> usize {
CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN
}
fn get_rtcp_index(&self, input: &[u8]) -> usize {
let tail_offset = input.len() - (self.auth_tag_len() + SRTCP_INDEX_SIZE);
(BigEndian::read_u32(&input[tail_offset..tail_offset + SRTCP_INDEX_SIZE]) & !(1 << 31))
as usize
}
}
@@ -0,0 +1,261 @@
use bytes::{BufMut, Bytes};
use openssl::cipher_ctx::CipherCtx;
use rtcp::header::{HEADER_LENGTH, SSRC_LENGTH};
use subtle::ConstantTimeEq;
use util::marshal::*;
use super::{Cipher, CipherInner};
use crate::{
error::{Error, Result},
key_derivation::*,
};
pub(crate) struct CipherAesCmHmacSha1 {
inner: CipherInner,
rtp_ctx: CipherCtx,
rtcp_ctx: CipherCtx,
}
impl CipherAesCmHmacSha1 {
pub fn new(master_key: &[u8], master_salt: &[u8]) -> Result<Self> {
let inner = CipherInner::new(master_key, master_salt)?;
let srtp_session_key = aes_cm_key_derivation(
LABEL_SRTP_ENCRYPTION,
master_key,
master_salt,
0,
master_key.len(),
)?;
let srtcp_session_key = aes_cm_key_derivation(
LABEL_SRTCP_ENCRYPTION,
master_key,
master_salt,
0,
master_key.len(),
)?;
let t = openssl::cipher::Cipher::aes_128_ctr();
let mut rtp_ctx = CipherCtx::new().map_err(|e| Error::Other(e.to_string()))?;
rtp_ctx
.encrypt_init(Some(t), Some(&srtp_session_key[..]), None)
.map_err(|e| Error::Other(e.to_string()))?;
let t = openssl::cipher::Cipher::aes_128_ctr();
let mut rtcp_ctx = CipherCtx::new().map_err(|e| Error::Other(e.to_string()))?;
rtcp_ctx
.encrypt_init(Some(t), Some(&srtcp_session_key[..]), None)
.map_err(|e| Error::Other(e.to_string()))?;
Ok(Self {
inner,
rtp_ctx,
rtcp_ctx,
})
}
}
impl Cipher for CipherAesCmHmacSha1 {
fn auth_tag_len(&self) -> usize {
self.inner.auth_tag_len()
}
fn get_rtcp_index(&self, input: &[u8]) -> usize {
self.inner.get_rtcp_index(input)
}
fn encrypt_rtp(
&mut self,
plaintext: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes> {
let header_len = header.marshal_size();
let mut writer = Vec::with_capacity(plaintext.len() + self.auth_tag_len());
// Copy the header unencrypted.
writer.extend_from_slice(&plaintext[..header_len]);
// Encrypt the payload
let nonce = generate_counter(
header.sequence_number,
roc,
header.ssrc,
&self.inner.srtp_session_salt,
);
writer.resize(plaintext.len(), 0);
self.rtp_ctx.encrypt_init(None, None, Some(&nonce)).unwrap();
let count = self
.rtp_ctx
.cipher_update(&plaintext[header_len..], Some(&mut writer[header_len..]))
.unwrap();
self.rtp_ctx
.cipher_final(&mut writer[header_len + count..])
.unwrap();
// Generate and write the auth tag.
let auth_tag = &self.inner.generate_srtp_auth_tag(&writer, roc)[..self.auth_tag_len()];
writer.extend_from_slice(auth_tag);
Ok(Bytes::from(writer))
}
fn decrypt_rtp(
&mut self,
encrypted: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes> {
let encrypted_len = encrypted.len();
if encrypted_len < self.auth_tag_len() {
return Err(Error::SrtpTooSmall(encrypted_len, self.auth_tag_len()));
}
let header_len = header.marshal_size();
let mut writer = Vec::with_capacity(encrypted_len - self.auth_tag_len());
// Split the auth tag and the cipher text into two parts.
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
// Generate the auth tag we expect to see from the ciphertext.
let expected_tag =
&self.inner.generate_srtp_auth_tag(cipher_text, roc)[..self.auth_tag_len()];
// See if the auth tag actually matches.
// We use a constant time comparison to prevent timing attacks.
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
return Err(Error::RtpFailedToVerifyAuthTag);
}
// Write cipher_text to the destination buffer.
writer.extend_from_slice(&cipher_text[..header_len]);
// Decrypt the ciphertext for the payload.
let nonce = generate_counter(
header.sequence_number,
roc,
header.ssrc,
&self.inner.srtp_session_salt,
);
writer.resize(encrypted_len - self.auth_tag_len(), 0);
self.rtp_ctx.decrypt_init(None, None, Some(&nonce)).unwrap();
let count = self
.rtp_ctx
.cipher_update(&cipher_text[header_len..], Some(&mut writer[header_len..]))
.unwrap();
self.rtp_ctx
.cipher_final(&mut writer[header_len + count..])
.unwrap();
Ok(Bytes::from(writer))
}
fn encrypt_rtcp(&mut self, decrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
let decrypted_len = decrypted.len();
let mut writer = Vec::with_capacity(decrypted_len + SRTCP_INDEX_SIZE + self.auth_tag_len());
// Write the decrypted to the destination buffer.
writer.extend_from_slice(&decrypted[..HEADER_LENGTH + SSRC_LENGTH]);
// Encrypt everything after header
let nonce = generate_counter(
(srtcp_index & 0xFFFF) as u16,
(srtcp_index >> 16) as u32,
ssrc,
&self.inner.srtcp_session_salt,
);
writer.resize(decrypted_len, 0);
self.rtcp_ctx
.encrypt_init(None, None, Some(&nonce))
.unwrap();
let count = self
.rtcp_ctx
.cipher_update(
&decrypted[HEADER_LENGTH + SSRC_LENGTH..],
Some(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]),
)
.unwrap();
self.rtcp_ctx
.cipher_final(&mut writer[HEADER_LENGTH + SSRC_LENGTH + count..])
.unwrap();
// Add SRTCP index and set Encryption bit
writer.put_u32(srtcp_index as u32 | (1u32 << 31));
// Generate the auth tag.
let auth_tag = &self.inner.generate_srtcp_auth_tag(&writer)[..self.auth_tag_len()];
writer.extend(auth_tag);
Ok(Bytes::from(writer))
}
fn decrypt_rtcp(&mut self, encrypted: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes> {
let encrypted_len = encrypted.len();
if encrypted_len < self.auth_tag_len() + SRTCP_INDEX_SIZE {
return Err(Error::SrtcpTooSmall(
encrypted_len,
self.auth_tag_len() + SRTCP_INDEX_SIZE,
));
}
let tail_offset = encrypted_len - (self.auth_tag_len() + SRTCP_INDEX_SIZE);
let mut writer = Vec::with_capacity(tail_offset);
writer.extend_from_slice(&encrypted[..HEADER_LENGTH + SSRC_LENGTH]);
let is_encrypted = encrypted[tail_offset] >> 7;
if is_encrypted == 0 {
return Ok(Bytes::from(writer));
}
// Split the auth tag and the cipher text into two parts.
let actual_tag = &encrypted[encrypted_len - self.auth_tag_len()..];
if actual_tag.len() != self.auth_tag_len() {
return Err(Error::RtcpInvalidLengthAuthTag(
actual_tag.len(),
self.auth_tag_len(),
));
}
let cipher_text = &encrypted[..encrypted_len - self.auth_tag_len()];
// Generate the auth tag we expect to see from the ciphertext.
let expected_tag = &self.inner.generate_srtcp_auth_tag(cipher_text)[..self.auth_tag_len()];
// See if the auth tag actually matches.
// We use a constant time comparison to prevent timing attacks.
if actual_tag.ct_eq(expected_tag).unwrap_u8() != 1 {
return Err(Error::RtcpFailedToVerifyAuthTag);
}
let nonce = generate_counter(
(srtcp_index & 0xFFFF) as u16,
(srtcp_index >> 16) as u32,
ssrc,
&self.inner.srtcp_session_salt,
);
writer.resize(tail_offset, 0);
self.rtcp_ctx
.decrypt_init(None, None, Some(&nonce))
.unwrap();
let count = self
.rtcp_ctx
.cipher_update(
&encrypted[HEADER_LENGTH + SSRC_LENGTH..tail_offset],
Some(&mut writer[HEADER_LENGTH + SSRC_LENGTH..]),
)
.unwrap();
self.rtcp_ctx
.cipher_final(&mut writer[HEADER_LENGTH + SSRC_LENGTH + count..])
.unwrap();
Ok(Bytes::from(writer))
}
}
+61
View File
@@ -0,0 +1,61 @@
pub mod cipher_aead_aes_gcm;
pub mod cipher_aes_cm_hmac_sha1;
use bytes::Bytes;
use crate::error::Result;
///NOTE: Auth tag and AEAD auth tag are placed at the different position in SRTCP
///
///In non-AEAD cipher, the authentication tag is placed *after* the ESRTCP word
///(Encrypted-flag and SRTCP index).
///
///> AES_128_CM_HMAC_SHA1_80
///> | RTCP Header | Encrypted payload |E| SRTCP Index | Auth tag |
///> ^ |----------|
///> | ^
///> | authTagLen=10
///> aeadAuthTagLen=0
///
///In AEAD cipher, the AEAD authentication tag is embedded in the ciphertext.
///It is *before* the ESRTCP word (Encrypted-flag and SRTCP index).
///
///> AEAD_AES_128_GCM
///> | RTCP Header | Encrypted payload | AEAD auth tag |E| SRTCP Index |
///> |---------------| ^
///> ^ authTagLen=0
///> aeadAuthTagLen=16
///
///See https://tools.ietf.org/html/rfc7714 for the full specifications.
/// Cipher represents a implementation of one
/// of the SRTP Specific ciphers.
pub(crate) trait Cipher {
/// Get authenticated tag length.
fn auth_tag_len(&self) -> usize;
/// Retrieved RTCP index.
fn get_rtcp_index(&self, input: &[u8]) -> usize;
/// Encrypt RTP payload.
fn encrypt_rtp(
&mut self,
payload: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes>;
/// Decrypt RTP payload.
fn decrypt_rtp(
&mut self,
payload: &[u8],
header: &rtp::header::Header,
roc: u32,
) -> Result<Bytes>;
/// Encrypt RTCP payload.
fn encrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes>;
/// Decrypt RTCP payload.
fn decrypt_rtcp(&mut self, payload: &[u8], srtcp_index: usize, ssrc: u32) -> Result<Bytes>;
}
+83
View File
@@ -0,0 +1,83 @@
use util::KeyingMaterialExporter;
use crate::error::Result;
use crate::option::*;
use crate::protection_profile::*;
const LABEL_EXTRACTOR_DTLS_SRTP: &str = "EXTRACTOR-dtls_srtp";
/// SessionKeys bundles the keys required to setup an SRTP session
#[derive(Default, Debug, Clone)]
pub struct SessionKeys {
pub local_master_key: Vec<u8>,
pub local_master_salt: Vec<u8>,
pub remote_master_key: Vec<u8>,
pub remote_master_salt: Vec<u8>,
}
/// Config is used to configure a session.
/// You can provide either a KeyingMaterialExporter to export keys
/// or directly pass the keys themselves.
/// After a Config is passed to a session it must not be modified.
#[derive(Default)]
pub struct Config {
pub keys: SessionKeys,
pub profile: ProtectionProfile,
//LoggerFactory: logging.LoggerFactory
/// List of local/remote context options.
/// ReplayProtection is enabled on remote context by default.
/// Default replay protection window size is 64.
pub local_rtp_options: Option<ContextOption>,
pub remote_rtp_options: Option<ContextOption>,
pub local_rtcp_options: Option<ContextOption>,
pub remote_rtcp_options: Option<ContextOption>,
}
impl Config {
/// ExtractSessionKeysFromDTLS allows setting the Config SessionKeys by
/// extracting them from DTLS. This behavior is defined in RFC5764:
/// https://tools.ietf.org/html/rfc5764
pub async fn extract_session_keys_from_dtls(
&mut self,
exporter: impl KeyingMaterialExporter,
is_client: bool,
) -> Result<()> {
let key_len = self.profile.key_len();
let salt_len = self.profile.salt_len();
let keying_material = exporter
.export_keying_material(
LABEL_EXTRACTOR_DTLS_SRTP,
&[],
(key_len * 2) + (salt_len * 2),
)
.await?;
let mut offset = 0;
let client_write_key = keying_material[offset..offset + key_len].to_vec();
offset += key_len;
let server_write_key = keying_material[offset..offset + key_len].to_vec();
offset += key_len;
let client_write_salt = keying_material[offset..offset + salt_len].to_vec();
offset += salt_len;
let server_write_salt = keying_material[offset..offset + salt_len].to_vec();
if is_client {
self.keys.local_master_key = client_write_key;
self.keys.local_master_salt = client_write_salt;
self.keys.remote_master_key = server_write_key;
self.keys.remote_master_salt = server_write_salt;
} else {
self.keys.local_master_key = server_write_key;
self.keys.local_master_salt = server_write_salt;
self.keys.remote_master_key = client_write_key;
self.keys.remote_master_salt = client_write_salt;
}
Ok(())
}
}
+341
View File
@@ -0,0 +1,341 @@
use bytes::Bytes;
use lazy_static::lazy_static;
use super::*;
use crate::key_derivation::*;
const CIPHER_CONTEXT_ALGO: ProtectionProfile = ProtectionProfile::Aes128CmHmacSha1_80;
const DEFAULT_SSRC: u32 = 0;
#[test]
fn test_context_roc() -> Result<()> {
let key_len = CIPHER_CONTEXT_ALGO.key_len();
let salt_len = CIPHER_CONTEXT_ALGO.salt_len();
let mut c = Context::new(
&vec![0; key_len],
&vec![0; salt_len],
CIPHER_CONTEXT_ALGO,
None,
None,
)?;
let roc = c.get_roc(123);
assert!(roc.is_none(), "ROC must return None for unused SSRC");
c.set_roc(123, 100);
let roc = c.get_roc(123);
if let Some(r) = roc {
assert_eq!(r, 100, "ROC is set to 100, but returned {r}")
} else {
panic!("ROC must return value for used SSRC");
}
Ok(())
}
#[test]
fn test_context_index() -> Result<()> {
let key_len = CIPHER_CONTEXT_ALGO.key_len();
let salt_len = CIPHER_CONTEXT_ALGO.salt_len();
let mut c = Context::new(
&vec![0; key_len],
&vec![0; salt_len],
CIPHER_CONTEXT_ALGO,
None,
None,
)?;
let index = c.get_index(123);
assert!(index.is_none(), "Index must return None for unused SSRC");
c.set_index(123, 100);
let index = c.get_index(123);
if let Some(i) = index {
assert_eq!(i, 100, "Index is set to 100, but returned {i}");
} else {
panic!("Index must return true for used SSRC")
}
Ok(())
}
#[test]
fn test_key_len() -> Result<()> {
let key_len = CIPHER_CONTEXT_ALGO.key_len();
let salt_len = CIPHER_CONTEXT_ALGO.salt_len();
let result = Context::new(&[], &vec![0; salt_len], CIPHER_CONTEXT_ALGO, None, None);
assert!(result.is_err(), "CreateContext accepted a 0 length key");
let result = Context::new(&vec![0; key_len], &[], CIPHER_CONTEXT_ALGO, None, None);
assert!(result.is_err(), "CreateContext accepted a 0 length salt");
let result = Context::new(
&vec![0; key_len],
&vec![0; salt_len],
CIPHER_CONTEXT_ALGO,
None,
None,
);
assert!(
result.is_ok(),
"CreateContext failed with a valid length key and salt"
);
Ok(())
}
#[test]
fn test_valid_packet_counter() -> Result<()> {
let master_key = vec![
0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28,
0x89,
];
let master_salt = vec![
0x62, 0x77, 0x60, 0x38, 0xc0, 0x6d, 0xc9, 0x41, 0x9f, 0x6d, 0xd9, 0x43, 0x3e, 0x7c,
];
let srtp_session_salt = aes_cm_key_derivation(
LABEL_SRTP_SALT,
&master_key,
&master_salt,
0,
master_salt.len(),
)?;
let s = SrtpSsrcState {
ssrc: 4160032510,
..Default::default()
};
let expected_counter = [
0xcf, 0x90, 0x1e, 0xa5, 0xda, 0xd3, 0x2c, 0x15, 0x00, 0xa2, 0x24, 0xae, 0xae, 0xaf, 0x00,
0x00,
];
let counter = generate_counter(32846, s.rollover_counter, s.ssrc, &srtp_session_salt);
assert_eq!(
counter, expected_counter,
"Session Key {counter:?} does not match expected {expected_counter:?}",
);
Ok(())
}
#[test]
fn test_rollover_count() -> Result<()> {
let mut s = SrtpSsrcState {
ssrc: DEFAULT_SSRC,
..Default::default()
};
// Set initial seqnum
let roc = s.next_rollover_count(65530);
assert_eq!(roc, 0, "Initial rolloverCounter must be 0");
s.update_rollover_count(65530);
// Invalid packets never update ROC
s.next_rollover_count(0);
s.next_rollover_count(0x4000);
s.next_rollover_count(0x8000);
s.next_rollover_count(0xFFFF);
s.next_rollover_count(0);
// We rolled over to 0
let roc = s.next_rollover_count(0);
assert_eq!(roc, 1, "rolloverCounter was not updated after it crossed 0");
s.update_rollover_count(0);
let roc = s.next_rollover_count(65530);
assert_eq!(
roc, 0,
"rolloverCounter was not updated when it rolled back, failed to handle out of order"
);
s.update_rollover_count(65530);
let roc = s.next_rollover_count(5);
assert_eq!(
roc, 1,
"rolloverCounter was not updated when it rolled over initial, to handle out of order"
);
s.update_rollover_count(5);
s.next_rollover_count(6);
s.update_rollover_count(6);
s.next_rollover_count(7);
s.update_rollover_count(7);
let roc = s.next_rollover_count(8);
assert_eq!(
roc, 1,
"rolloverCounter was improperly updated for non-significant packets"
);
s.update_rollover_count(8);
// valid packets never update ROC
let roc = s.next_rollover_count(0x4000);
assert_eq!(
roc, 1,
"rolloverCounter was improperly updated for non-significant packets"
);
s.update_rollover_count(0x4000);
let roc = s.next_rollover_count(0x8000);
assert_eq!(
roc, 1,
"rolloverCounter was improperly updated for non-significant packets"
);
s.update_rollover_count(0x8000);
let roc = s.next_rollover_count(0xFFFF);
assert_eq!(
roc, 1,
"rolloverCounter was improperly updated for non-significant packets"
);
s.update_rollover_count(0xFFFF);
let roc = s.next_rollover_count(0);
assert_eq!(
roc, 2,
"rolloverCounter must be incremented after wrapping, got {roc}"
);
Ok(())
}
lazy_static! {
static ref MASTER_KEY: Bytes = Bytes::from_static(&[
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
0x0f,
]);
static ref MASTER_SALT: Bytes = Bytes::from_static(&[
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab,
]);
static ref DECRYPTED_RTP_PACKET: Bytes = Bytes::from_static(&[
0x80, 0x0f, 0x12, 0x34, 0xde, 0xca, 0xfb, 0xad, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab,
0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
]);
static ref ENCRYPTED_RTP_PACKET: Bytes = Bytes::from_static(&[
0x80, 0x0f, 0x12, 0x34, 0xde, 0xca, 0xfb, 0xad, 0xca, 0xfe, 0xba, 0xbe, 0xc5, 0x00, 0x2e,
0xde, 0x04, 0xcf, 0xdd, 0x2e, 0xb9, 0x11, 0x59, 0xe0, 0x88, 0x0a, 0xa0, 0x6e, 0xd2, 0x97,
0x68, 0x26, 0xf7, 0x96, 0xb2, 0x01, 0xdf, 0x31, 0x31, 0xa1, 0x27, 0xe8, 0xa3, 0x92,
]);
static ref DECRYPTED_RTCP_PACKET: Bytes = Bytes::from_static(&[
0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
]);
static ref ENCRYPTED_RTCP_PACKET: Bytes = Bytes::from_static(&[
0x81, 0xc8, 0x00, 0x0b, 0xca, 0xfe, 0xba, 0xbe, 0xc9, 0x8b, 0x8b, 0x5d, 0xf0, 0x39, 0x2a,
0x55, 0x85, 0x2b, 0x6c, 0x21, 0xac, 0x8e, 0x70, 0x25, 0xc5, 0x2c, 0x6f, 0xbe, 0xa2, 0xb3,
0xb4, 0x46, 0xea, 0x31, 0x12, 0x3b, 0xa8, 0x8c, 0xe6, 0x1e, 0x80, 0x00, 0x00, 0x01,
]);
}
#[test]
fn test_encrypt_rtp() {
let mut ctx = Context::new(
&MASTER_KEY,
&MASTER_SALT,
ProtectionProfile::AeadAes128Gcm,
None,
None,
)
.expect("Error creating srtp context");
let gotten_encrypted_rtp_packet = ctx
.encrypt_rtp(&DECRYPTED_RTP_PACKET)
.expect("Error encrypting rtp payload");
assert_eq!(gotten_encrypted_rtp_packet, *ENCRYPTED_RTP_PACKET)
}
#[test]
fn test_decrypt_rtp() {
let mut ctx = Context::new(
&MASTER_KEY,
&MASTER_SALT,
ProtectionProfile::AeadAes128Gcm,
None,
None,
)
.expect("Error creating srtp context");
let gotten_decrypted_rtp_packet = ctx
.decrypt_rtp(&ENCRYPTED_RTP_PACKET)
.expect("Error decrypting rtp payload");
assert_eq!(gotten_decrypted_rtp_packet, *DECRYPTED_RTP_PACKET)
}
#[test]
fn test_encrypt_rtcp() {
let mut ctx = Context::new(
&MASTER_KEY,
&MASTER_SALT,
ProtectionProfile::AeadAes128Gcm,
None,
None,
)
.expect("Error creating srtp context");
let gotten_encrypted_rtcp_packet = ctx
.encrypt_rtcp(&DECRYPTED_RTCP_PACKET)
.expect("Error encrypting rtcp payload");
assert_eq!(gotten_encrypted_rtcp_packet, *ENCRYPTED_RTCP_PACKET)
}
#[test]
fn test_decrypt_rtcp() {
let mut ctx = Context::new(
&MASTER_KEY,
&MASTER_SALT,
ProtectionProfile::AeadAes128Gcm,
None,
None,
)
.expect("Error creating srtp context");
let gotten_decrypted_rtcp_packet = ctx
.decrypt_rtcp(&ENCRYPTED_RTCP_PACKET)
.expect("Error decrypting rtcp payload");
assert_eq!(gotten_decrypted_rtcp_packet, *DECRYPTED_RTCP_PACKET)
}
#[test]
fn test_rollover_high_water_mark() {
let mut state = super::SrtpSsrcState::default();
for seq in [65000, 65535, 85] {
state.update_rollover_count(seq);
}
for seq in [65000, 65530, 84, 0] {
state.update_rollover_count(seq);
assert_eq!(state.rollover_counter, 1);
assert_eq!(state.last_sequence_number, 85);
}
assert_eq!(state.next_rollover_count(86), 1);
state.update_rollover_count(1000);
state.update_rollover_count(32000);
state.update_rollover_count(64000);
assert_eq!(state.next_rollover_count(1000), 2);
state.update_rollover_count(1000);
assert_eq!(state.rollover_counter, 2);
assert_eq!(state.last_sequence_number, 1000);
}
#[test]
fn test_rollover_initial_zero_and_counter_wrap() {
let mut state = super::SrtpSsrcState::default();
state.update_rollover_count(0);
assert_eq!(state.next_rollover_count(65535), u32::MAX);
state.update_rollover_count(65535);
assert_eq!(state.rollover_counter, 0);
assert_eq!(state.last_sequence_number, 0);
state.rollover_counter = u32::MAX;
state.last_sequence_number = 65535;
state.update_rollover_count(0);
assert_eq!(state.rollover_counter, 0);
assert_eq!(state.last_sequence_number, 0);
}
+177
View File
@@ -0,0 +1,177 @@
#[cfg(test)]
mod context_test;
#[cfg(test)]
mod rollover_regression_test;
#[cfg(test)]
mod srtcp_test;
#[cfg(test)]
mod srtp_test;
use std::collections::HashMap;
use util::replay_detector::*;
use crate::cipher::cipher_aead_aes_gcm::*;
use crate::cipher::cipher_aes_cm_hmac_sha1::*;
use crate::cipher::*;
use crate::error::{Error, Result};
use crate::option::*;
use crate::protection_profile::*;
pub mod srtcp;
pub mod srtp;
const SEQUENCE_HALF_RANGE: i32 = 1 << 15;
/// Encrypt/Decrypt state for a single SRTP SSRC
#[derive(Default)]
pub(crate) struct SrtpSsrcState {
ssrc: u32,
rollover_counter: u32,
rollover_has_processed: bool,
last_sequence_number: u16,
replay_detector: Option<Box<dyn ReplayDetector + Send + 'static>>,
}
/// Encrypt/Decrypt state for a single SRTCP SSRC
#[derive(Default)]
pub(crate) struct SrtcpSsrcState {
srtcp_index: usize,
ssrc: u32,
replay_detector: Option<Box<dyn ReplayDetector + Send + 'static>>,
}
impl SrtpSsrcState {
pub fn next_rollover_count(&self, sequence_number: u16) -> u32 {
let roc = self.rollover_counter;
if !self.rollover_has_processed {
return roc;
}
// RFC 3711 Appendix A: estimate the index nearest the highest packet.
let last = i32::from(self.last_sequence_number);
let seq = i32::from(sequence_number);
if last < SEQUENCE_HALF_RANGE {
if seq - last > SEQUENCE_HALF_RANGE {
return roc.wrapping_sub(1);
}
} else if last - SEQUENCE_HALF_RANGE > seq {
return roc.wrapping_add(1);
}
roc
}
pub fn update_rollover_count(&mut self, sequence_number: u16) {
let roc = self.next_rollover_count(sequence_number);
// Retransmissions must never move the highest authenticated index back.
if !self.rollover_has_processed
|| (roc == self.rollover_counter && sequence_number > self.last_sequence_number)
|| roc == self.rollover_counter.wrapping_add(1)
{
self.rollover_counter = roc;
self.last_sequence_number = sequence_number;
self.rollover_has_processed = true;
}
}
}
/// Context represents a SRTP cryptographic context
/// Context can only be used for one-way operations
/// it must either used ONLY for encryption or ONLY for decryption
pub struct Context {
cipher: Box<dyn Cipher + Send>,
srtp_ssrc_states: HashMap<u32, SrtpSsrcState>,
srtcp_ssrc_states: HashMap<u32, SrtcpSsrcState>,
new_srtp_replay_detector: ContextOption,
new_srtcp_replay_detector: ContextOption,
}
impl Context {
/// CreateContext creates a new SRTP Context
pub fn new(
master_key: &[u8],
master_salt: &[u8],
profile: ProtectionProfile,
srtp_ctx_opt: Option<ContextOption>,
srtcp_ctx_opt: Option<ContextOption>,
) -> Result<Context> {
let key_len = profile.key_len();
let salt_len = profile.salt_len();
if master_key.len() != key_len {
return Err(Error::SrtpMasterKeyLength(key_len, master_key.len()));
} else if master_salt.len() != salt_len {
return Err(Error::SrtpSaltLength(salt_len, master_salt.len()));
}
let cipher: Box<dyn Cipher + Send> = match profile {
ProtectionProfile::Aes128CmHmacSha1_80 => {
Box::new(CipherAesCmHmacSha1::new(master_key, master_salt)?)
}
ProtectionProfile::AeadAes128Gcm => {
Box::new(CipherAeadAesGcm::new(master_key, master_salt)?)
}
};
let srtp_ctx_opt = if let Some(ctx_opt) = srtp_ctx_opt {
ctx_opt
} else {
srtp_no_replay_protection()
};
let srtcp_ctx_opt = if let Some(ctx_opt) = srtcp_ctx_opt {
ctx_opt
} else {
srtcp_no_replay_protection()
};
Ok(Context {
cipher,
srtp_ssrc_states: HashMap::new(),
srtcp_ssrc_states: HashMap::new(),
new_srtp_replay_detector: srtp_ctx_opt,
new_srtcp_replay_detector: srtcp_ctx_opt,
})
}
fn get_srtp_ssrc_state(&mut self, ssrc: u32) -> &mut SrtpSsrcState {
let s = SrtpSsrcState {
ssrc,
replay_detector: Some((self.new_srtp_replay_detector)()),
..Default::default()
};
self.srtp_ssrc_states.entry(ssrc).or_insert(s)
}
fn get_srtcp_ssrc_state(&mut self, ssrc: u32) -> &mut SrtcpSsrcState {
let s = SrtcpSsrcState {
ssrc,
replay_detector: Some((self.new_srtcp_replay_detector)()),
..Default::default()
};
self.srtcp_ssrc_states.entry(ssrc).or_insert(s)
}
/// roc returns SRTP rollover counter value of specified SSRC.
fn get_roc(&self, ssrc: u32) -> Option<u32> {
self.srtp_ssrc_states.get(&ssrc).map(|s| s.rollover_counter)
}
/// set_roc sets SRTP rollover counter value of specified SSRC.
fn set_roc(&mut self, ssrc: u32, roc: u32) {
self.get_srtp_ssrc_state(ssrc).rollover_counter = roc;
}
/// index returns SRTCP index value of specified SSRC.
fn get_index(&self, ssrc: u32) -> Option<usize> {
self.srtcp_ssrc_states.get(&ssrc).map(|s| s.srtcp_index)
}
/// set_index sets SRTCP index value of specified SSRC.
fn set_index(&mut self, ssrc: u32, index: usize) {
self.get_srtcp_ssrc_state(ssrc).srtcp_index = index;
}
}
@@ -0,0 +1,73 @@
use crate::{context::Context, protection_profile::ProtectionProfile};
fn packet(seq: u16) -> (Vec<u8>, rtp::header::Header) {
let h = rtp::header::Header {
version: 2,
sequence_number: seq,
ssrc: 1,
..Default::default()
};
let mut b = vec![0x80, 96];
b.extend(seq.to_be_bytes());
b.extend(0u32.to_be_bytes());
b.extend(1u32.to_be_bytes());
b.extend([1, 2, 3, 4]);
(b, h)
}
fn run(profile: ProtectionProfile, retransmits: bool) -> usize {
let mut tx = Context::new(
&vec![0; 16],
&vec![
0;
match profile {
ProtectionProfile::Aes128CmHmacSha1_80 => 14,
_ => 12,
}
],
profile,
None,
None,
)
.unwrap();
let mut rx = Context::new(
&vec![0; 16],
&vec![
0;
match profile {
ProtectionProfile::Aes128CmHmacSha1_80 => 14,
_ => 12,
}
],
profile,
None,
None,
)
.unwrap();
for seq in (65000u16..=65535).chain(0..=85) {
let (b, h) = packet(seq);
let e = tx.encrypt_rtp_with_header(&b, &h).unwrap();
rx.decrypt_rtp(&e).unwrap();
}
if retransmits {
for seq in [65000, 65530] {
let (b, h) = packet(seq);
let _ = tx.encrypt_rtp_with_header(&b, &h).unwrap();
}
}
let mut failures = 0;
for seq in 86..=1000 {
let (b, h) = packet(seq);
let e = tx.encrypt_rtp_with_header(&b, &h).unwrap();
failures += usize::from(rx.decrypt_rtp(&e).is_err());
}
failures
}
#[test]
fn delayed_retransmissions_preserve_authentication() {
for profile in [
ProtectionProfile::Aes128CmHmacSha1_80,
ProtectionProfile::AeadAes128Gcm,
] {
assert_eq!(run(profile, false), 0);
assert_eq!(run(profile, true), 0);
}
}
+50
View File
@@ -0,0 +1,50 @@
use bytes::Bytes;
use util::marshal::*;
use super::*;
use crate::error::Result;
impl Context {
/// DecryptRTCP decrypts a RTCP packet with an encrypted payload
pub fn decrypt_rtcp(&mut self, encrypted: &[u8]) -> Result<Bytes> {
let mut buf = encrypted;
rtcp::header::Header::unmarshal(&mut buf)?;
let index = self.cipher.get_rtcp_index(encrypted);
let ssrc = u32::from_be_bytes([encrypted[4], encrypted[5], encrypted[6], encrypted[7]]);
if let Some(replay_detector) = &mut self.get_srtcp_ssrc_state(ssrc).replay_detector {
if !replay_detector.check(index as u64) {
return Err(Error::SrtcpSsrcDuplicated(ssrc, index));
}
}
let dst = self.cipher.decrypt_rtcp(encrypted, index, ssrc)?;
if let Some(replay_detector) = &mut self.get_srtcp_ssrc_state(ssrc).replay_detector {
replay_detector.accept();
}
Ok(dst)
}
/// EncryptRTCP marshals and encrypts an RTCP packet, writing to the dst buffer provided.
/// If the dst buffer does not have the capacity to hold `len(plaintext) + 14` bytes, a new one will be allocated and returned.
pub fn encrypt_rtcp(&mut self, decrypted: &[u8]) -> Result<Bytes> {
let mut buf = decrypted;
rtcp::header::Header::unmarshal(&mut buf)?;
let ssrc = u32::from_be_bytes([decrypted[4], decrypted[5], decrypted[6], decrypted[7]]);
let index = {
let state = self.get_srtcp_ssrc_state(ssrc);
state.srtcp_index += 1;
if state.srtcp_index > MAX_SRTCP_INDEX {
state.srtcp_index = 0;
}
state.srtcp_index
};
self.cipher.encrypt_rtcp(decrypted, index, ssrc)
}
}
+257
View File
@@ -0,0 +1,257 @@
use bytes::{Buf, Bytes, BytesMut};
use lazy_static::lazy_static;
use super::*;
use crate::key_derivation::*;
pub struct RTCPTestCase {
ssrc: u32,
index: usize,
encrypted: Bytes,
decrypted: Bytes,
}
lazy_static! {
static ref RTCP_TEST_MASTER_KEY: Bytes = Bytes::from_static(&[
0xfd, 0xa6, 0x25, 0x95, 0xd7, 0xf6, 0x92, 0x6f, 0x7d, 0x9c, 0x02, 0x4c, 0xc9, 0x20, 0x9f,
0x34
]);
static ref RTCP_TEST_MASTER_SALT: Bytes = Bytes::from_static(&[
0xa9, 0x65, 0x19, 0x85, 0x54, 0x0b, 0x47, 0xbe, 0x2f, 0x27, 0xa8, 0xb8, 0x81, 0x23
]);
static ref RTCP_TEST_CASES: Vec<RTCPTestCase> = vec![
RTCPTestCase {
ssrc: 0x66ef91ff,
index: 0,
encrypted: Bytes::from_static(&[
0x80, 0xc8, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0xcd, 0x34, 0xc5, 0x78, 0xb2, 0x8b,
0xe1, 0x6b, 0xc5, 0x09, 0xd5, 0x77, 0xe4, 0xce, 0x5f, 0x20, 0x80, 0x21, 0xbd, 0x66,
0x74, 0x65, 0xe9, 0x5f, 0x49, 0xe5, 0xf5, 0xc0, 0x68, 0x4e, 0xe5, 0x6a, 0x78, 0x07,
0x75, 0x46, 0xed, 0x90, 0xf6, 0xdc, 0x9d, 0xef, 0x3b, 0xdf, 0xf2, 0x79, 0xa9, 0xd8,
0x80, 0x00, 0x00, 0x01, 0x60, 0xc0, 0xae, 0xb5, 0x6f, 0x40, 0x88, 0x0e, 0x28, 0xba
]),
decrypted: Bytes::from_static(&[
0x80, 0xc8, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0xdf, 0x48, 0x80, 0xdd, 0x61, 0xa6,
0x2e, 0xd3, 0xd8, 0xbc, 0xde, 0xbe, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x16, 0x04,
0x81, 0xca, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0x01, 0x10, 0x52, 0x6e, 0x54, 0x35,
0x43, 0x6d, 0x4a, 0x68, 0x7a, 0x79, 0x65, 0x74, 0x41, 0x78, 0x77, 0x2b, 0x00, 0x00
]),
},
RTCPTestCase{
ssrc: 0x11111111,
index: 0,
encrypted: Bytes::from_static(&[
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11,
0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46,
0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38,
0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad,
0x80, 0x00, 0x00, 0x01, 0x34, 0x3c, 0x2e, 0x83, 0x17, 0x13, 0x93, 0x69, 0xcf, 0xc0
]),
decrypted: Bytes::from_static(&[
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0xdf, 0x48, 0x80, 0xdd, 0x61, 0xa6,
0x2e, 0xd3, 0xd8, 0xbc, 0xde, 0xbe, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x16, 0x04,
0x81, 0xca, 0x00, 0x06, 0x66, 0xef, 0x91, 0xff, 0x01, 0x10, 0x52, 0x6e, 0x54, 0x35,
0x43, 0x6d, 0x4a, 0x68, 0x7a, 0x79, 0x65, 0x74, 0x41, 0x78, 0x77, 0x2b, 0x00, 0x00
]),
},
RTCPTestCase{
ssrc: 0x11111111,
index: 0x7ffffffe, // Upper boundary of index
encrypted: Bytes::from_static(&[
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11,
0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46,
0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38,
0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad,
0xff, 0xff, 0xff, 0xff, 0x5a, 0x99, 0xce, 0xed, 0x9f, 0x2e, 0x4d, 0x9d, 0xfa, 0x97
]),
decrypted: Bytes::from_static(&[
0x80, 0xc8, 0x0, 0x6, 0x11, 0x11, 0x11, 0x11, 0x4, 0x99, 0x47, 0x53, 0xc4, 0x1e,
0xb9, 0xde, 0x52, 0xa3, 0x1d, 0x77, 0x2f, 0xff, 0xcc, 0x75, 0xbb, 0x6a, 0x29, 0xb8,
0x1, 0xb7, 0x2e, 0x4b, 0x4e, 0xcb, 0xa4, 0x81, 0x2d, 0x46, 0x4, 0x5e, 0x86, 0x90,
0x17, 0x4f, 0x4d, 0x78, 0x2f, 0x58, 0xb8, 0x67, 0x91, 0x89, 0xe3, 0x61, 0x1, 0x7d
]),
},
RTCPTestCase{
ssrc: 0x11111111,
index: 0x7fffffff, // Will be wrapped to 0
encrypted: Bytes::from_static(&[
0x80, 0xc8, 0x00, 0x06, 0x11, 0x11, 0x11, 0x11, 0x17, 0x8c, 0x15, 0xf1, 0x4b, 0x11,
0xda, 0xf5, 0x74, 0x53, 0x86, 0x2b, 0xc9, 0x07, 0x29, 0x40, 0xbf, 0x22, 0xf6, 0x46,
0x11, 0xa4, 0xc1, 0x3a, 0xff, 0x5a, 0xbd, 0xd0, 0xf8, 0x8b, 0x38, 0xe4, 0x95, 0x38,
0x5d, 0xcf, 0x1b, 0xf5, 0x27, 0x77, 0xfb, 0xdb, 0x3f, 0x10, 0x68, 0x99, 0xd8, 0xad,
0x80, 0x00, 0x00, 0x00, 0x7d, 0x51, 0xf8, 0x0e, 0x56, 0x40, 0x72, 0x7b, 0x9e, 0x02
]),
decrypted: Bytes::from_static(&[
0x80, 0xc8, 0x0, 0x6, 0x11, 0x11, 0x11, 0x11, 0xda, 0xb5, 0xe0, 0x56, 0x9a, 0x4a,
0x74, 0xed, 0x8a, 0x54, 0xc, 0xcf, 0xd5, 0x9, 0xb1, 0x40, 0x1, 0x42, 0xc3, 0x9a,
0x76, 0x0, 0xa9, 0xd4, 0xf7, 0x29, 0x9e, 0x51, 0xfb, 0x3c, 0xc1, 0x74, 0x72, 0xf9,
0x52, 0xb1, 0x92, 0x31, 0xca, 0x22, 0xab, 0x3e, 0xc5, 0x5f, 0x83, 0x34, 0xf0, 0x28
]),
},
];
}
#[test]
fn test_rtcp_lifecycle() -> Result<()> {
let mut encrypt_context = Context::new(
&RTCP_TEST_MASTER_KEY,
&RTCP_TEST_MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)?;
let mut decrypt_context = Context::new(
&RTCP_TEST_MASTER_KEY,
&RTCP_TEST_MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)?;
for test_case in &*RTCP_TEST_CASES {
let decrypt_result = decrypt_context.decrypt_rtcp(&test_case.encrypted)?;
assert_eq!(
decrypt_result, test_case.decrypted,
"RTCP failed to decrypt"
);
encrypt_context.set_index(test_case.ssrc, test_case.index);
let encrypt_result = encrypt_context.encrypt_rtcp(&test_case.decrypted)?;
assert_eq!(
encrypt_result, test_case.encrypted,
"RTCP failed to encrypt"
);
}
Ok(())
}
#[test]
fn test_rtcp_invalid_auth_tag() -> Result<()> {
let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
let mut decrypt_context = Context::new(
&RTCP_TEST_MASTER_KEY,
&RTCP_TEST_MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)?;
let decrypt_result = decrypt_context.decrypt_rtcp(&RTCP_TEST_CASES[0].encrypted)?;
assert_eq!(
decrypt_result, RTCP_TEST_CASES[0].decrypted,
"RTCP failed to decrypt"
);
// Zero out auth tag
let mut rtcp_packet = BytesMut::new();
rtcp_packet.extend_from_slice(&RTCP_TEST_CASES[0].encrypted);
let rtcp_packet_len = rtcp_packet.len();
rtcp_packet[rtcp_packet_len - auth_tag_len..].copy_from_slice(&vec![0; auth_tag_len]);
let rtcp_packet = rtcp_packet.freeze();
let decrypt_result = decrypt_context.decrypt_rtcp(&rtcp_packet);
assert!(
decrypt_result.is_err(),
"Was able to decrypt RTCP packet with invalid Auth Tag"
);
Ok(())
}
#[test]
fn test_rtcp_replay_detector_separation() -> Result<()> {
let mut decrypt_context = Context::new(
&RTCP_TEST_MASTER_KEY,
&RTCP_TEST_MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
Some(srtcp_replay_protection(10)),
)?;
let rtcp_packet1 = RTCP_TEST_CASES[0].encrypted.clone();
let decrypt_result1 = decrypt_context.decrypt_rtcp(&rtcp_packet1)?;
assert_eq!(
decrypt_result1, RTCP_TEST_CASES[0].decrypted,
"RTCP failed to decrypt"
);
let rtcp_packet2 = RTCP_TEST_CASES[1].encrypted.clone();
let decrypt_result2 = decrypt_context.decrypt_rtcp(&rtcp_packet2)?;
assert_eq!(
decrypt_result2, RTCP_TEST_CASES[1].decrypted,
"RTCP failed to decrypt"
);
let result = decrypt_context.decrypt_rtcp(&rtcp_packet1);
assert!(
result.is_err(),
"Was able to decrypt duplicated RTCP packet"
);
let result = decrypt_context.decrypt_rtcp(&rtcp_packet2);
assert!(
result.is_err(),
"Was able to decrypt duplicated RTCP packet"
);
Ok(())
}
fn get_rtcp_index(encrypted: &Bytes, auth_tag_len: usize) -> u32 {
let tail_offset = encrypted.len() - (auth_tag_len + SRTCP_INDEX_SIZE);
let reader = &mut encrypted.slice(tail_offset..tail_offset + SRTCP_INDEX_SIZE);
//^(1 << 31)
reader.get_u32() & 0x7FFFFFFF
}
#[test]
fn test_encrypt_rtcp_separation() -> Result<()> {
let mut encrypt_context = Context::new(
&RTCP_TEST_MASTER_KEY,
&RTCP_TEST_MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)?;
let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
let mut decrypt_context = Context::new(
&RTCP_TEST_MASTER_KEY,
&RTCP_TEST_MASTER_SALT,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
Some(srtcp_replay_protection(10)),
)?;
let inputs = vec![
RTCP_TEST_CASES[0].decrypted.clone(),
RTCP_TEST_CASES[1].decrypted.clone(),
RTCP_TEST_CASES[0].decrypted.clone(),
RTCP_TEST_CASES[1].decrypted.clone(),
];
let mut encrypted_rctps = vec![];
for input in &inputs {
let encrypted = encrypt_context.encrypt_rtcp(input)?;
encrypted_rctps.push(encrypted);
}
for (i, expected_index) in [1, 1, 2, 2].iter().enumerate() {
assert_eq!(
*expected_index,
get_rtcp_index(&encrypted_rctps[i], auth_tag_len),
"RTCP index does not match"
);
}
for (i, output) in encrypted_rctps.iter().enumerate() {
let decrypted = decrypt_context.decrypt_rtcp(output)?;
assert_eq!(inputs[i], decrypted);
}
Ok(())
}
+70
View File
@@ -0,0 +1,70 @@
use bytes::Bytes;
use util::marshal::*;
use super::*;
use crate::error::Result;
impl Context {
pub fn decrypt_rtp_with_header(
&mut self,
encrypted: &[u8],
header: &rtp::header::Header,
) -> Result<Bytes> {
let roc = {
let state = self.get_srtp_ssrc_state(header.ssrc);
if let Some(replay_detector) = &mut state.replay_detector {
if !replay_detector.check(header.sequence_number as u64) {
return Err(Error::SrtpSsrcDuplicated(
header.ssrc,
header.sequence_number,
));
}
}
state.next_rollover_count(header.sequence_number)
};
let dst = self.cipher.decrypt_rtp(encrypted, header, roc)?;
{
let state = self.get_srtp_ssrc_state(header.ssrc);
if let Some(replay_detector) = &mut state.replay_detector {
replay_detector.accept();
}
state.update_rollover_count(header.sequence_number);
}
Ok(dst)
}
/// DecryptRTP decrypts a RTP packet with an encrypted payload
pub fn decrypt_rtp(&mut self, encrypted: &[u8]) -> Result<Bytes> {
let mut buf = encrypted;
let header = rtp::header::Header::unmarshal(&mut buf)?;
self.decrypt_rtp_with_header(encrypted, &header)
}
pub fn encrypt_rtp_with_header(
&mut self,
payload: &[u8],
header: &rtp::header::Header,
) -> Result<Bytes> {
let roc = self
.get_srtp_ssrc_state(header.ssrc)
.next_rollover_count(header.sequence_number);
let dst = self.cipher.encrypt_rtp(payload, header, roc)?;
self.get_srtp_ssrc_state(header.ssrc)
.update_rollover_count(header.sequence_number);
Ok(dst)
}
/// EncryptRTP marshals and encrypts an RTP packet, writing to the dst buffer provided.
/// If the dst buffer does not have the capacity to hold `len(plaintext) + 10` bytes, a new one will be allocated and returned.
pub fn encrypt_rtp(&mut self, plaintext: &[u8]) -> Result<Bytes> {
let mut buf = plaintext;
let header = rtp::header::Header::unmarshal(&mut buf)?;
self.encrypt_rtp_with_header(plaintext, &header)
}
}
+188
View File
@@ -0,0 +1,188 @@
use bytes::Bytes;
use lazy_static::lazy_static;
use util::marshal::*;
use super::*;
struct RTPTestCase {
sequence_number: u16,
encrypted: Bytes,
}
lazy_static! {
static ref RTP_TEST_CASE_DECRYPTED: Bytes = Bytes::from_static(&[0x00, 0x01, 0x02, 0x03, 0x04, 0x05]);
static ref RTP_TEST_CASES: Vec<RTPTestCase> = vec![
RTPTestCase {
sequence_number: 5000,
encrypted: Bytes::from_static(&[
0x6d, 0xd3, 0x7e, 0xd5, 0x99, 0xb7, 0x2d, 0x28, 0xb1, 0xf3, 0xa1, 0xf0, 0xc, 0xfb,
0xfd, 0x8
]),
},
RTPTestCase {
sequence_number: 5001,
encrypted: Bytes::from_static(&[
0xda, 0x47, 0xb, 0x2a, 0x74, 0x53, 0x65, 0xbd, 0x2f, 0xeb, 0xdc, 0x4b, 0x6d, 0x23,
0xf3, 0xde
]),
},
RTPTestCase {
sequence_number: 5002,
encrypted: Bytes::from_static(&[
0x6e, 0xa7, 0x69, 0x8d, 0x24, 0x6d, 0xdc, 0xbf, 0xec, 0x2, 0x1c, 0xd1, 0x60, 0x76,
0xc1, 0x0e
]),
},
RTPTestCase {
sequence_number: 5003,
encrypted: Bytes::from_static(&[
0x24, 0x7e, 0x96, 0xc8, 0x7d, 0x33, 0xa2, 0x92, 0x8d, 0x13, 0x8d, 0xe0, 0x76, 0x9f,
0x08, 0xdc
]),
},
RTPTestCase {
sequence_number: 5004,
encrypted: Bytes::from_static(&[
0x75, 0x43, 0x28, 0xe4, 0x3a, 0x77, 0x59, 0x9b, 0x2e, 0xdf, 0x7b, 0x12, 0x68, 0x0b,
0x57, 0x49
]),
},
RTPTestCase{
sequence_number: 65535, // upper boundary
encrypted: Bytes::from_static(&[
0xaf, 0xf7, 0xc2, 0x70, 0x37, 0x20, 0x83, 0x9c, 0x2c, 0x63, 0x85, 0x15, 0x0e, 0x44,
0xca, 0x36
]),
},
];
}
fn build_test_context() -> Result<Context> {
let master_key = Bytes::from_static(&[
0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28,
0x89,
]);
let master_salt = Bytes::from_static(&[
0x62, 0x77, 0x60, 0x38, 0xc0, 0x6d, 0xc9, 0x41, 0x9f, 0x6d, 0xd9, 0x43, 0x3e, 0x7c,
]);
Context::new(
&master_key,
&master_salt,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)
}
#[test]
fn test_rtp_invalid_auth() -> Result<()> {
let master_key = Bytes::from_static(&[
0x0d, 0xcd, 0x21, 0x3e, 0x4c, 0xbc, 0xf2, 0x8f, 0x01, 0x7f, 0x69, 0x94, 0x40, 0x1e, 0x28,
0x89,
]);
let invalid_salt = Bytes::from_static(&[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]);
let mut encrypt_context = build_test_context()?;
let mut invalid_context = Context::new(
&master_key,
&invalid_salt,
ProtectionProfile::Aes128CmHmacSha1_80,
None,
None,
)?;
for test_case in &*RTP_TEST_CASES {
let pkt = rtp::packet::Packet {
header: rtp::header::Header {
sequence_number: test_case.sequence_number,
..Default::default()
},
payload: RTP_TEST_CASE_DECRYPTED.clone(),
};
let pkt_raw = pkt.marshal()?;
let out = encrypt_context.encrypt_rtp(&pkt_raw)?;
let result = invalid_context.decrypt_rtp(&out);
assert!(
result.is_err(),
"Managed to decrypt with incorrect salt for packet with SeqNum: {}",
test_case.sequence_number
);
}
Ok(())
}
#[test]
fn test_rtp_lifecycle() -> Result<()> {
let mut encrypt_context = build_test_context()?;
let mut decrypt_context = build_test_context()?;
let auth_tag_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
for test_case in RTP_TEST_CASES.iter() {
// Keep consecutive indices within RFC 3711's half-sequence-space window.
// The known-answer vector at 65535 still uses ROC 0, as before.
if test_case.sequence_number == 65535 {
for sequence_number in [32000, 64000] {
let bridge = rtp::packet::Packet {
header: rtp::header::Header {
sequence_number,
..Default::default()
},
payload: RTP_TEST_CASE_DECRYPTED.clone(),
}
.marshal()?;
let encrypted = encrypt_context.encrypt_rtp(&bridge)?;
assert_eq!(decrypt_context.decrypt_rtp(&encrypted)?, bridge);
}
}
let decrypted_pkt = rtp::packet::Packet {
header: rtp::header::Header {
sequence_number: test_case.sequence_number,
..Default::default()
},
payload: RTP_TEST_CASE_DECRYPTED.clone(),
};
let decrypted_raw = decrypted_pkt.marshal()?;
let encrypted_pkt = rtp::packet::Packet {
header: rtp::header::Header {
sequence_number: test_case.sequence_number,
..Default::default()
},
payload: test_case.encrypted.clone(),
};
let encrypted_raw = encrypted_pkt.marshal()?;
let actual_encrypted = encrypt_context.encrypt_rtp(&decrypted_raw)?;
assert_eq!(
actual_encrypted, encrypted_raw,
"RTP packet with SeqNum invalid encryption: {}",
test_case.sequence_number
);
let actual_decrypted = decrypt_context.decrypt_rtp(&encrypted_raw)?;
assert_ne!(
encrypted_raw[..encrypted_raw.len() - auth_tag_len].to_vec(),
actual_decrypted,
"DecryptRTP improperly encrypted in place"
);
assert_eq!(
actual_decrypted, decrypted_raw,
"RTP packet with SeqNum invalid decryption: {}",
test_case.sequence_number,
)
}
Ok(())
}
//TODO: BenchmarkEncryptRTP
//TODO: BenchmarkEncryptRTPInPlace
//TODO: BenchmarkDecryptRTP
+120
View File
@@ -0,0 +1,120 @@
use std::io;
use thiserror::Error;
use tokio::sync::mpsc::error::SendError as MpscSendError;
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Error, Debug, PartialEq)]
#[non_exhaustive]
pub enum Error {
#[error("duplicated packet")]
ErrDuplicated,
#[error("SRTP master key is not long enough")]
ErrShortSrtpMasterKey,
#[error("SRTP master salt is not long enough")]
ErrShortSrtpMasterSalt,
#[error("no such SRTP Profile")]
ErrNoSuchSrtpProfile,
#[error("indexOverKdr > 0 is not supported yet")]
ErrNonZeroKdrNotSupported,
#[error("exporter called with wrong label")]
ErrExporterWrongLabel,
#[error("no config provided")]
ErrNoConfig,
#[error("no conn provided")]
ErrNoConn,
#[error("failed to verify auth tag")]
ErrFailedToVerifyAuthTag,
#[error("packet is too short to be rtcp packet")]
ErrTooShortRtcp,
#[error("payload differs")]
ErrPayloadDiffers,
#[error("started channel used incorrectly, should only be closed")]
ErrStartedChannelUsedIncorrectly,
#[error("stream has not been inited, unable to close")]
ErrStreamNotInited,
#[error("stream is already closed")]
ErrStreamAlreadyClosed,
#[error("stream is already inited")]
ErrStreamAlreadyInited,
#[error("failed to cast child")]
ErrFailedTypeAssertion,
#[error("index_over_kdr > 0 is not supported yet")]
UnsupportedIndexOverKdr,
#[error("SRTP Master Key must be len {0}, got {1}")]
SrtpMasterKeyLength(usize, usize),
#[error("SRTP Salt must be len {0}, got {1}")]
SrtpSaltLength(usize, usize),
#[error("SyntaxError: {0}")]
ExtMapParse(String),
#[error("srtp ssrc={0} index={1}: duplicated")]
SrtpSsrcDuplicated(u32, u16),
#[error("srtcp ssrc={0} index={1}: duplicated")]
SrtcpSsrcDuplicated(u32, usize),
#[error("ssrc {0} not exist in srtcp_ssrc_state")]
SsrcMissingFromSrtcp(u32),
#[error("Stream with ssrc {0} exists")]
StreamWithSsrcExists(u32),
#[error("Session RTP/RTCP type must be same as input buffer")]
SessionRtpRtcpTypeMismatch,
#[error("Session EOF")]
SessionEof,
#[error("too short SRTP packet: only {0} bytes, expected > {1} bytes")]
SrtpTooSmall(usize, usize),
#[error("too short SRTCP packet: only {0} bytes, expected > {1} bytes")]
SrtcpTooSmall(usize, usize),
#[error("failed to verify rtp auth tag")]
RtpFailedToVerifyAuthTag,
#[error("too short auth tag: only {0} bytes, expected > {1} bytes")]
RtcpInvalidLengthAuthTag(usize, usize),
#[error("failed to verify rtcp auth tag")]
RtcpFailedToVerifyAuthTag,
#[error("SessionSRTP has been closed")]
SessionSrtpAlreadyClosed,
#[error("this stream is not a RTPStream")]
InvalidRtpStream,
#[error("this stream is not a RTCPStream")]
InvalidRtcpStream,
#[error("{0}")]
Io(#[source] IoError),
#[error("{0}")]
KeyingMaterial(#[from] util::KeyingMaterialExporterError),
#[error("mpsc send: {0}")]
MpscSend(String),
#[error("{0}")]
Util(#[from] util::Error),
#[error("{0}")]
Rtcp(#[from] rtcp::Error),
#[error("aes gcm: {0}")]
AesGcm(#[from] aes_gcm::Error),
#[error("{0}")]
Other(String),
}
#[derive(Debug, Error)]
#[error("io error: {0}")]
pub struct IoError(#[from] pub io::Error);
// Workaround for wanting PartialEq for io::Error.
impl PartialEq for IoError {
fn eq(&self, other: &Self) -> bool {
self.0.kind() == other.0.kind()
}
}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Self {
Error::Io(IoError(e))
}
}
// Because Tokio SendError is parameterized, we sadly lose the backtrace.
impl<T> From<MpscSendError<T>> for Error {
fn from(e: MpscSendError<T>) -> Self {
Error::MpscSend(e.to_string())
}
}
+173
View File
@@ -0,0 +1,173 @@
use aes::cipher::generic_array::GenericArray;
use aes::cipher::BlockEncrypt;
use aes::Aes128;
use aes_gcm::KeyInit;
use crate::error::{Error, Result};
pub const LABEL_SRTP_ENCRYPTION: u8 = 0x00;
pub const LABEL_SRTP_AUTHENTICATION_TAG: u8 = 0x01;
pub const LABEL_SRTP_SALT: u8 = 0x02;
pub const LABEL_SRTCP_ENCRYPTION: u8 = 0x03;
pub const LABEL_SRTCP_AUTHENTICATION_TAG: u8 = 0x04;
pub const LABEL_SRTCP_SALT: u8 = 0x05;
pub(crate) const SRTCP_INDEX_SIZE: usize = 4;
pub(crate) fn aes_cm_key_derivation(
label: u8,
master_key: &[u8],
master_salt: &[u8],
index_over_kdr: usize,
out_len: usize,
) -> Result<Vec<u8>> {
if index_over_kdr != 0 {
// 24-bit "index DIV kdr" must be xored to prf input.
return Err(Error::UnsupportedIndexOverKdr);
}
// https://tools.ietf.org/html/rfc3711#appendix-B.3
// The input block for AES-CM is generated by exclusive-oring the master salt with the
// concatenation of the encryption key label 0x00 with (index DIV kdr),
// - index is 'rollover count' and DIV is 'divided by'
let n_master_key = master_key.len();
let n_master_salt = master_salt.len();
let mut prf_in = vec![0u8; n_master_key];
prf_in[..n_master_salt].copy_from_slice(master_salt);
prf_in[7] ^= label;
//The resulting value is then AES encrypted using the master key to get the cipher key.
let key = GenericArray::from_slice(master_key);
let block = Aes128::new(key);
let mut out = vec![0u8; ((out_len + n_master_key) / n_master_key) * n_master_key];
for (i, n) in (0..out_len).step_by(n_master_key).enumerate() {
//BigEndian.PutUint16(prfIn[nMasterKey-2:], i)
prf_in[n_master_key - 2] = ((i >> 8) & 0xFF) as u8;
prf_in[n_master_key - 1] = (i & 0xFF) as u8;
out[n..n + n_master_key].copy_from_slice(&prf_in);
let out_key = GenericArray::from_mut_slice(&mut out[n..n + n_master_key]);
block.encrypt_block(out_key);
}
Ok(out[..out_len].to_vec())
}
/// Generate IV https://tools.ietf.org/html/rfc3711#section-4.1.1
/// where the 128-bit integer value IV SHALL be defined by the SSRC, the
/// SRTP packet index i, and the SRTP session salting key k_s, as below.
/// ROC = a 32-bit unsigned rollover counter (roc), which records how many
/// times the 16-bit RTP sequence number has been reset to zero after
/// passing through 65,535
/// ```nobuild
/// i = 2^16 * roc + SEQ
/// IV = (salt*2 ^ 16) | (ssrc*2 ^ 64) | (i*2 ^ 16)
/// ```
pub(crate) fn generate_counter(
sequence_number: u16,
rollover_counter: u32,
ssrc: u32,
session_salt: &[u8],
) -> [u8; 16] {
assert!(session_salt.len() <= 16);
let mut counter = [0; 16];
let ssrc_be = ssrc.to_be_bytes();
let rollover_be = rollover_counter.to_be_bytes();
let seq_be = ((sequence_number as u32) << 16).to_be_bytes();
counter[4..8].copy_from_slice(&ssrc_be);
counter[8..12].copy_from_slice(&rollover_be);
counter[12..16].copy_from_slice(&seq_be);
for i in 0..session_salt.len() {
counter[i] ^= session_salt[i];
}
counter
}
#[cfg(test)]
mod test {
use super::*;
use crate::protection_profile::*;
#[test]
fn test_valid_session_keys() -> Result<()> {
// Key Derivation Test Vectors from https://tools.ietf.org/html/rfc3711#appendix-B.3
let master_key = vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
];
let master_salt = vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
];
let expected_session_key = vec![
0xC6, 0x1E, 0x7A, 0x93, 0x74, 0x4F, 0x39, 0xEE, 0x10, 0x73, 0x4A, 0xFE, 0x3F, 0xF7,
0xA0, 0x87,
];
let expected_session_salt = vec![
0x30, 0xCB, 0xBC, 0x08, 0x86, 0x3D, 0x8C, 0x85, 0xD4, 0x9D, 0xB3, 0x4A, 0x9A, 0xE1,
];
let expected_session_auth_tag = vec![
0xCE, 0xBE, 0x32, 0x1F, 0x6F, 0xF7, 0x71, 0x6B, 0x6F, 0xD4, 0xAB, 0x49, 0xAF, 0x25,
0x6A, 0x15, 0x6D, 0x38, 0xBA, 0xA4,
];
let session_key = aes_cm_key_derivation(
LABEL_SRTP_ENCRYPTION,
&master_key,
&master_salt,
0,
master_key.len(),
)?;
assert_eq!(
session_key, expected_session_key,
"Session Key:\n{session_key:?} \ndoes not match expected:\n{expected_session_key:?}\nMaster Key:\n{master_key:?}\nMaster Salt:\n{master_salt:?}\n",
);
let session_salt = aes_cm_key_derivation(
LABEL_SRTP_SALT,
&master_key,
&master_salt,
0,
master_salt.len(),
)?;
assert_eq!(
session_salt, expected_session_salt,
"Session Salt {session_salt:?} does not match expected {expected_session_salt:?}"
);
let auth_key_len = ProtectionProfile::Aes128CmHmacSha1_80.auth_key_len();
let session_auth_tag = aes_cm_key_derivation(
LABEL_SRTP_AUTHENTICATION_TAG,
&master_key,
&master_salt,
0,
auth_key_len,
)?;
assert_eq!(
session_auth_tag, expected_session_auth_tag,
"Session Auth Tag {session_auth_tag:?} does not match expected {expected_session_auth_tag:?}",
);
Ok(())
}
// This test asserts that calling aesCmKeyDerivation with a non-zero indexOverKdr fails
// Currently this isn't supported, but the API makes sure we can add this in the future
#[test]
fn test_index_over_kdr() -> Result<()> {
let result = aes_cm_key_derivation(LABEL_SRTP_AUTHENTICATION_TAG, &[], &[], 1, 0);
assert!(result.is_err());
Ok(())
}
}
+14
View File
@@ -0,0 +1,14 @@
#![warn(rust_2018_idioms)]
#![allow(dead_code)]
mod cipher;
pub mod config;
pub mod context;
mod error;
mod key_derivation;
pub mod option;
pub mod protection_profile;
pub mod session;
pub mod stream;
pub use error::Error;
+36
View File
@@ -0,0 +1,36 @@
use util::replay_detector::*;
pub type ContextOption = Box<dyn (Fn() -> Box<dyn ReplayDetector + Send + 'static>) + Send + Sync>;
pub(crate) const MAX_SEQUENCE_NUMBER: u16 = 65535;
pub(crate) const MAX_SRTCP_INDEX: usize = 0x7FFFFFFF;
/// srtp_replay_protection sets SRTP replay protection window size.
pub fn srtp_replay_protection(window_size: usize) -> ContextOption {
Box::new(move || -> Box<dyn ReplayDetector + Send> {
Box::new(WrappedSlidingWindowDetector::new(
window_size,
MAX_SEQUENCE_NUMBER as u64,
))
})
}
/// Sets SRTCP replay protection window size.
pub fn srtcp_replay_protection(window_size: usize) -> ContextOption {
Box::new(move || -> Box<dyn ReplayDetector + Send> {
Box::new(WrappedSlidingWindowDetector::new(
window_size,
MAX_SRTCP_INDEX as u64,
))
})
}
/// srtp_no_replay_protection disables SRTP replay protection.
pub fn srtp_no_replay_protection() -> ContextOption {
Box::new(|| -> Box<dyn ReplayDetector + Send> { Box::<NoOpReplayDetector>::default() })
}
/// srtcp_no_replay_protection disables SRTCP replay protection.
pub fn srtcp_no_replay_protection() -> ContextOption {
Box::new(|| -> Box<dyn ReplayDetector + Send> { Box::<NoOpReplayDetector>::default() })
}
+37
View File
@@ -0,0 +1,37 @@
/// ProtectionProfile specifies Cipher and AuthTag details, similar to TLS cipher suite
#[derive(Default, Debug, Clone, Copy)]
#[repr(u8)]
pub enum ProtectionProfile {
#[default]
Aes128CmHmacSha1_80 = 0x0001,
AeadAes128Gcm = 0x0007,
}
impl ProtectionProfile {
pub(crate) fn key_len(&self) -> usize {
match *self {
ProtectionProfile::Aes128CmHmacSha1_80 | ProtectionProfile::AeadAes128Gcm => 16,
}
}
pub(crate) fn salt_len(&self) -> usize {
match *self {
ProtectionProfile::Aes128CmHmacSha1_80 => 14,
ProtectionProfile::AeadAes128Gcm => 12,
}
}
pub(crate) fn auth_tag_len(&self) -> usize {
match *self {
ProtectionProfile::Aes128CmHmacSha1_80 => 10, //CIPHER_AES_CM_HMAC_SHA1AUTH_TAG_LEN,
ProtectionProfile::AeadAes128Gcm => 16, //CIPHER_AEAD_AES_GCM_AUTH_TAG_LEN,
}
}
pub(crate) fn auth_key_len(&self) -> usize {
match *self {
ProtectionProfile::Aes128CmHmacSha1_80 => 20,
ProtectionProfile::AeadAes128Gcm => 0,
}
}
}
+271
View File
@@ -0,0 +1,271 @@
#[cfg(test)]
mod session_rtcp_test;
#[cfg(test)]
mod session_rtp_test;
use std::collections::{HashMap, HashSet};
use std::marker::{Send, Sync};
use std::sync::Arc;
use bytes::Bytes;
use tokio::sync::{mpsc, Mutex};
use util::conn::Conn;
use util::marshal::*;
use crate::config::*;
use crate::context::*;
use crate::error::{Error, Result};
use crate::option::*;
use crate::stream::*;
const DEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOW: usize = 64;
const DEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOW: usize = 64;
/// Session implements io.ReadWriteCloser and provides a bi-directional SRTP session
/// SRTP itself does not have a design like this, but it is common in most applications
/// for local/remote to each have their own keying material. This provides those patterns
/// instead of making everyone re-implement
pub struct Session {
local_context: Arc<Mutex<Context>>,
streams_map: Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
new_stream_rx: Arc<Mutex<mpsc::Receiver<Arc<Stream>>>>,
close_stream_tx: mpsc::Sender<u32>,
close_session_tx: mpsc::Sender<()>,
pub(crate) udp_tx: Arc<dyn Conn + Send + Sync>,
is_rtp: bool,
}
impl Session {
pub async fn new(
conn: Arc<dyn Conn + Send + Sync>,
config: Config,
is_rtp: bool,
) -> Result<Self> {
let local_context = Context::new(
&config.keys.local_master_key,
&config.keys.local_master_salt,
config.profile,
config.local_rtp_options,
config.local_rtcp_options,
)?;
let mut remote_context = Context::new(
&config.keys.remote_master_key,
&config.keys.remote_master_salt,
config.profile,
if config.remote_rtp_options.is_none() {
Some(srtp_replay_protection(
DEFAULT_SESSION_SRTP_REPLAY_PROTECTION_WINDOW,
))
} else {
config.remote_rtp_options
},
if config.remote_rtcp_options.is_none() {
Some(srtcp_replay_protection(
DEFAULT_SESSION_SRTCP_REPLAY_PROTECTION_WINDOW,
))
} else {
config.remote_rtcp_options
},
)?;
let streams_map = Arc::new(Mutex::new(HashMap::new()));
let (mut new_stream_tx, new_stream_rx) = mpsc::channel(8);
let (close_stream_tx, mut close_stream_rx) = mpsc::channel(8);
let (close_session_tx, mut close_session_rx) = mpsc::channel(8);
let udp_tx = Arc::clone(&conn);
let udp_rx = Arc::clone(&conn);
let cloned_streams_map = Arc::clone(&streams_map);
let cloned_close_stream_tx = close_stream_tx.clone();
tokio::spawn(async move {
let mut buf = vec![0u8; 8192];
loop {
let incoming_stream = Session::incoming(
&udp_rx,
&mut buf,
&cloned_streams_map,
&cloned_close_stream_tx,
&mut new_stream_tx,
&mut remote_context,
is_rtp,
);
let close_stream = close_stream_rx.recv();
let close_session = close_session_rx.recv();
tokio::select! {
result = incoming_stream => match result{
Ok(()) => {},
Err(err) => log::info!("{}", err),
},
opt = close_stream => if let Some(ssrc) = opt {
Session::close_stream(&cloned_streams_map, ssrc).await
},
_ = close_session => break
}
}
});
Ok(Session {
local_context: Arc::new(Mutex::new(local_context)),
streams_map,
new_stream_rx: Arc::new(Mutex::new(new_stream_rx)),
close_stream_tx,
close_session_tx,
udp_tx,
is_rtp,
})
}
async fn close_stream(streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>, ssrc: u32) {
let mut streams = streams_map.lock().await;
streams.remove(&ssrc);
}
async fn incoming(
udp_rx: &Arc<dyn Conn + Send + Sync>,
buf: &mut [u8],
streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
close_stream_tx: &mpsc::Sender<u32>,
new_stream_tx: &mut mpsc::Sender<Arc<Stream>>,
remote_context: &mut Context,
is_rtp: bool,
) -> Result<()> {
let n = udp_rx.recv(buf).await?;
if n == 0 {
return Err(Error::SessionEof);
}
let decrypted = if is_rtp {
remote_context.decrypt_rtp(&buf[0..n])?
} else {
remote_context.decrypt_rtcp(&buf[0..n])?
};
let mut buf = &decrypted[..];
let ssrcs = if is_rtp {
vec![rtp::header::Header::unmarshal(&mut buf)?.ssrc]
} else {
let pkts = rtcp::packet::unmarshal(&mut buf)?;
destination_ssrc(&pkts)
};
for ssrc in ssrcs {
let (stream, is_new) =
Session::get_or_create_stream(streams_map, close_stream_tx.clone(), is_rtp, ssrc)
.await;
if is_new {
log::trace!(
"srtp session got new {} stream {}",
if is_rtp { "rtp" } else { "rtcp" },
ssrc
);
new_stream_tx.send(Arc::clone(&stream)).await?;
}
match stream.buffer.write(&decrypted).await {
Ok(_) => {}
Err(err) => {
// Silently drop data when the buffer is full.
if util::Error::ErrBufferFull != err {
return Err(err.into());
}
}
}
}
Ok(())
}
async fn get_or_create_stream(
streams_map: &Arc<Mutex<HashMap<u32, Arc<Stream>>>>,
close_stream_tx: mpsc::Sender<u32>,
is_rtp: bool,
ssrc: u32,
) -> (Arc<Stream>, bool) {
let mut streams = streams_map.lock().await;
if let Some(stream) = streams.get(&ssrc) {
(Arc::clone(stream), false)
} else {
let stream = Arc::new(Stream::new(ssrc, close_stream_tx, is_rtp));
streams.insert(ssrc, Arc::clone(&stream));
(stream, true)
}
}
/// open on the given SSRC to create a stream, it can be used
/// if you want a certain SSRC, but don't want to wait for Accept
pub async fn open(&self, ssrc: u32) -> Arc<Stream> {
let (stream, _) = Session::get_or_create_stream(
&self.streams_map,
self.close_stream_tx.clone(),
self.is_rtp,
ssrc,
)
.await;
stream
}
/// accept returns a stream to handle RTCP for a single SSRC
pub async fn accept(&self) -> Result<Arc<Stream>> {
let mut new_stream_rx = self.new_stream_rx.lock().await;
let result = new_stream_rx.recv().await;
if let Some(stream) = result {
Ok(stream)
} else {
Err(Error::SessionSrtpAlreadyClosed)
}
}
pub async fn close(&self) -> Result<()> {
self.close_session_tx.send(()).await?;
Ok(())
}
pub async fn write(&self, buf: &Bytes, is_rtp: bool) -> Result<usize> {
if self.is_rtp != is_rtp {
return Err(Error::SessionRtpRtcpTypeMismatch);
}
let encrypted = {
let mut local_context = self.local_context.lock().await;
if is_rtp {
local_context.encrypt_rtp(buf)?
} else {
local_context.encrypt_rtcp(buf)?
}
};
Ok(self.udp_tx.send(&encrypted).await?)
}
pub async fn write_rtp(&self, pkt: &rtp::packet::Packet) -> Result<usize> {
let raw = pkt.marshal()?;
self.write(&raw, true).await
}
pub async fn write_rtcp(
&self,
pkt: &(dyn rtcp::packet::Packet + Send + Sync),
) -> Result<usize> {
let raw = pkt.marshal()?;
self.write(&raw, false).await
}
}
/// create a list of Destination SSRCs
/// that's a superset of all Destinations in the slice.
fn destination_ssrc(pkts: &[Box<dyn rtcp::packet::Packet + Send + Sync>]) -> Vec<u32> {
let mut ssrc_set = HashSet::new();
for p in pkts {
for ssrc in p.destination_ssrc() {
ssrc_set.insert(ssrc);
}
}
ssrc_set.into_iter().collect()
}
+239
View File
@@ -0,0 +1,239 @@
use std::sync::Arc;
use bytes::{Bytes, BytesMut};
use rtcp::payload_feedbacks::*;
use tokio::sync::{mpsc, Mutex};
use util::conn::conn_pipe::*;
use super::*;
use crate::error::Result;
use crate::protection_profile::*;
async fn build_session_srtcp_pair() -> Result<(Session, Session)> {
let (ua, ub) = pipe();
let ca = Config {
profile: ProtectionProfile::Aes128CmHmacSha1_80,
keys: SessionKeys {
local_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
local_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
remote_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
remote_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
},
local_rtp_options: None,
remote_rtp_options: None,
local_rtcp_options: None,
remote_rtcp_options: None,
};
let cb = Config {
profile: ProtectionProfile::Aes128CmHmacSha1_80,
keys: SessionKeys {
local_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
local_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
remote_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
remote_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
},
local_rtp_options: None,
remote_rtp_options: None,
local_rtcp_options: None,
remote_rtcp_options: None,
};
let sa = Session::new(Arc::new(ua), ca, false).await?;
let sb = Session::new(Arc::new(ub), cb, false).await?;
Ok((sa, sb))
}
const TEST_SSRC: u32 = 5000;
#[tokio::test]
async fn test_session_srtcp_accept() -> Result<()> {
let (sa, sb) = build_session_srtcp_pair().await?;
let rtcp_packet = picture_loss_indication::PictureLossIndication {
media_ssrc: TEST_SSRC,
..Default::default()
};
let test_payload = rtcp_packet.marshal()?;
sa.write_rtcp(&rtcp_packet).await?;
let read_stream = sb.accept().await?;
let ssrc = read_stream.get_ssrc();
assert_eq!(
ssrc, TEST_SSRC,
"SSRC mismatch during accept exp({TEST_SSRC}) actual({ssrc})"
);
let mut read_buffer = BytesMut::with_capacity(test_payload.len());
read_buffer.resize(test_payload.len(), 0u8);
read_stream.read(&mut read_buffer).await?;
assert_eq!(
&test_payload[..],
&read_buffer[..],
"Sent buffer does not match the one received exp({:?}) actual({:?})",
&test_payload[..],
&read_buffer[..]
);
sa.close().await?;
sb.close().await?;
Ok(())
}
#[tokio::test]
async fn test_session_srtcp_listen() -> Result<()> {
let (sa, sb) = build_session_srtcp_pair().await?;
let rtcp_packet = picture_loss_indication::PictureLossIndication {
media_ssrc: TEST_SSRC,
..Default::default()
};
let test_payload = rtcp_packet.marshal()?;
let read_stream = sb.open(TEST_SSRC).await;
sa.write_rtcp(&rtcp_packet).await?;
let mut read_buffer = BytesMut::with_capacity(test_payload.len());
read_buffer.resize(test_payload.len(), 0u8);
read_stream.read(&mut read_buffer).await?;
assert_eq!(
&test_payload[..],
&read_buffer[..],
"Sent buffer does not match the one received exp({:?}) actual({:?})",
&test_payload[..],
&read_buffer[..]
);
sa.close().await?;
sb.close().await?;
Ok(())
}
fn encrypt_srtcp(
context: &mut Context,
pkt: &(dyn rtcp::packet::Packet + Send + Sync),
) -> Result<Bytes> {
let decrypted = pkt.marshal()?;
let encrypted = context.encrypt_rtcp(&decrypted)?;
Ok(encrypted)
}
const PLI_PACKET_SIZE: usize = 8;
async fn get_sender_ssrc(read_stream: &Arc<Stream>) -> Result<u32> {
let auth_tag_size = ProtectionProfile::Aes128CmHmacSha1_80.auth_tag_len();
let mut read_buffer = BytesMut::with_capacity(PLI_PACKET_SIZE + auth_tag_size);
read_buffer.resize(PLI_PACKET_SIZE + auth_tag_size, 0u8);
let pkts = read_stream.read_rtcp(&mut read_buffer).await?;
let mut bytes = &pkts[0].marshal()?[..];
let pli = picture_loss_indication::PictureLossIndication::unmarshal(&mut bytes)?;
Ok(pli.sender_ssrc)
}
#[tokio::test]
async fn test_session_srtcp_replay_protection() -> Result<()> {
let (sa, sb) = build_session_srtcp_pair().await?;
let read_stream = sb.open(TEST_SSRC).await;
// Generate test packets
let mut packets = vec![];
let mut expected_ssrc = vec![];
{
let mut local_context = sa.local_context.lock().await;
for i in 0..0x10u32 {
expected_ssrc.push(i);
let packet = picture_loss_indication::PictureLossIndication {
media_ssrc: TEST_SSRC,
sender_ssrc: i,
};
let encrypted = encrypt_srtcp(&mut local_context, &packet)?;
packets.push(encrypted);
}
}
let (done_tx, mut done_rx) = mpsc::channel::<()>(1);
let received_ssrc = Arc::new(Mutex::new(vec![]));
let cloned_received_ssrc = Arc::clone(&received_ssrc);
let count = expected_ssrc.len();
tokio::spawn(async move {
let mut i = 0;
while i < count {
match get_sender_ssrc(&read_stream).await {
Ok(ssrc) => {
let mut r = cloned_received_ssrc.lock().await;
r.push(ssrc);
i += 1;
}
Err(_) => break,
}
}
drop(done_tx);
});
// Write with replay attack
for packet in &packets {
sa.udp_tx.send(packet).await?;
// Immediately replay
sa.udp_tx.send(packet).await?;
}
for packet in &packets {
// Delayed replay
sa.udp_tx.send(packet).await?;
}
done_rx.recv().await;
sa.close().await?;
sb.close().await?;
{
let received_ssrc = received_ssrc.lock().await;
assert_eq!(&expected_ssrc[..], &received_ssrc[..]);
}
Ok(())
}
+308
View File
@@ -0,0 +1,308 @@
use std::collections::HashMap;
use std::sync::Arc;
use bytes::{Bytes, BytesMut};
use tokio::net::UdpSocket;
use tokio::sync::{mpsc, Mutex};
use super::*;
use crate::error::Result;
use crate::protection_profile::*;
async fn build_session_srtp_pair() -> Result<(Session, Session)> {
let ua = UdpSocket::bind("127.0.0.1:0").await?;
let ub = UdpSocket::bind("127.0.0.1:0").await?;
ua.connect(ub.local_addr()?).await?;
ub.connect(ua.local_addr()?).await?;
let ca = Config {
profile: ProtectionProfile::Aes128CmHmacSha1_80,
keys: SessionKeys {
local_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
local_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
remote_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
remote_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
},
local_rtp_options: None,
remote_rtp_options: None,
local_rtcp_options: None,
remote_rtcp_options: None,
};
let cb = Config {
profile: ProtectionProfile::Aes128CmHmacSha1_80,
keys: SessionKeys {
local_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
local_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
remote_master_key: vec![
0xE1, 0xF9, 0x7A, 0x0D, 0x3E, 0x01, 0x8B, 0xE0, 0xD6, 0x4F, 0xA3, 0x2C, 0x06, 0xDE,
0x41, 0x39,
],
remote_master_salt: vec![
0x0E, 0xC6, 0x75, 0xAD, 0x49, 0x8A, 0xFE, 0xEB, 0xB6, 0x96, 0x0B, 0x3A, 0xAB, 0xE6,
],
},
local_rtp_options: None,
remote_rtp_options: None,
local_rtcp_options: None,
remote_rtcp_options: None,
};
let sa = Session::new(Arc::new(ua), ca, true).await?;
let sb = Session::new(Arc::new(ub), cb, true).await?;
Ok((sa, sb))
}
const TEST_SSRC: u32 = 5000;
const RTP_HEADER_SIZE: usize = 12;
#[tokio::test]
async fn test_session_srtp_accept() -> Result<()> {
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len());
read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8);
let (sa, sb) = build_session_srtp_pair().await?;
let packet = rtp::packet::Packet {
header: rtp::header::Header {
ssrc: TEST_SSRC,
..Default::default()
},
payload: test_payload.clone(),
};
sa.write_rtp(&packet).await?;
let read_stream = sb.accept().await?;
let ssrc = read_stream.get_ssrc();
assert_eq!(
ssrc, TEST_SSRC,
"SSRC mismatch during accept exp({TEST_SSRC}) actual({ssrc})"
);
read_stream.read(&mut read_buffer).await?;
assert_eq!(
&test_payload[..],
&read_buffer[RTP_HEADER_SIZE..],
"Sent buffer does not match the one received exp({:?}) actual({:?})",
&test_payload[..],
&read_buffer[RTP_HEADER_SIZE..]
);
sa.close().await?;
sb.close().await?;
Ok(())
}
#[tokio::test]
async fn test_session_srtp_listen() -> Result<()> {
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len());
read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8);
let (sa, sb) = build_session_srtp_pair().await?;
let packet = rtp::packet::Packet {
header: rtp::header::Header {
ssrc: TEST_SSRC,
..Default::default()
},
payload: test_payload.clone(),
};
let read_stream = sb.open(TEST_SSRC).await;
sa.write_rtp(&packet).await?;
read_stream.read(&mut read_buffer).await?;
assert_eq!(
&test_payload[..],
&read_buffer[RTP_HEADER_SIZE..],
"Sent buffer does not match the one received exp({:?}) actual({:?})",
&test_payload[..],
&read_buffer[RTP_HEADER_SIZE..]
);
sa.close().await?;
sb.close().await?;
Ok(())
}
#[tokio::test]
async fn test_session_srtp_multi_ssrc() -> Result<()> {
let ssrcs = vec![5000, 5001, 5002];
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
let mut read_buffer = BytesMut::with_capacity(RTP_HEADER_SIZE + test_payload.len());
read_buffer.resize(RTP_HEADER_SIZE + test_payload.len(), 0u8);
let (sa, sb) = build_session_srtp_pair().await?;
let mut read_streams = HashMap::new();
for ssrc in &ssrcs {
let read_stream = sb.open(*ssrc).await;
read_streams.insert(*ssrc, read_stream);
}
for ssrc in &ssrcs {
let packet = rtp::packet::Packet {
header: rtp::header::Header {
ssrc: *ssrc,
..Default::default()
},
payload: test_payload.clone(),
};
sa.write_rtp(&packet).await?;
if let Some(read_stream) = read_streams.get_mut(ssrc) {
read_stream.read(&mut read_buffer).await?;
assert_eq!(
&test_payload[..],
&read_buffer[RTP_HEADER_SIZE..],
"Sent buffer does not match the one received exp({:?}) actual({:?})",
&test_payload[..],
&read_buffer[RTP_HEADER_SIZE..]
);
} else {
panic!("ssrc {} not found", *ssrc);
}
}
sa.close().await?;
sb.close().await?;
Ok(())
}
fn encrypt_srtp(context: &mut Context, pkt: &rtp::packet::Packet) -> Result<Bytes> {
let decrypted = pkt.marshal()?;
let encrypted = context.encrypt_rtp(&decrypted)?;
Ok(encrypted)
}
async fn payload_srtp(
read_stream: &Arc<Stream>,
header_size: usize,
expected_payload: &[u8],
) -> Result<u16> {
let mut read_buffer = BytesMut::with_capacity(header_size + expected_payload.len());
read_buffer.resize(header_size + expected_payload.len(), 0u8);
let pkt = read_stream.read_rtp(&mut read_buffer).await?;
assert_eq!(
expected_payload,
&pkt.payload[..],
"Sent buffer does not match the one received exp({:?}) actual({:?})",
expected_payload,
&pkt.payload[..]
);
Ok(pkt.header.sequence_number)
}
#[tokio::test]
async fn test_session_srtp_replay_protection() -> Result<()> {
let test_payload = Bytes::from_static(&[0x00, 0x01, 0x03, 0x04]);
let (sa, sb) = build_session_srtp_pair().await?;
let read_stream = sb.open(TEST_SSRC).await;
// Generate test packets
let mut packets = vec![];
let mut expected_sequence_number = vec![];
{
let mut local_context = sa.local_context.lock().await;
let mut i = 0xFFF0u16;
while i != 0x10 {
expected_sequence_number.push(i);
let packet = rtp::packet::Packet {
header: rtp::header::Header {
ssrc: TEST_SSRC,
sequence_number: i,
..Default::default()
},
payload: test_payload.clone(),
};
let encrypted = encrypt_srtp(&mut local_context, &packet)?;
packets.push(encrypted);
if i == 0xFFFF {
i = 0;
} else {
i += 1;
}
}
}
let (done_tx, mut done_rx) = mpsc::channel::<()>(1);
let received_sequence_number = Arc::new(Mutex::new(vec![]));
let cloned_received_sequence_number = Arc::clone(&received_sequence_number);
let count = expected_sequence_number.len();
tokio::spawn(async move {
let mut i = 0;
while i < count {
let seq = payload_srtp(&read_stream, RTP_HEADER_SIZE, &test_payload)
.await
.unwrap();
let mut r = cloned_received_sequence_number.lock().await;
r.push(seq);
i += 1;
}
drop(done_tx);
});
// Write with replay attack
for packet in &packets {
sa.udp_tx.send(packet).await?;
// Immediately replay
sa.udp_tx.send(packet).await?;
}
for packet in &packets {
// Delayed replay
sa.udp_tx.send(packet).await?;
}
done_rx.recv().await;
sa.close().await?;
sb.close().await?;
{
let received_sequence_number = received_sequence_number.lock().await;
assert_eq!(&received_sequence_number[..], &expected_sequence_number[..]);
}
Ok(())
}
+91
View File
@@ -0,0 +1,91 @@
use tokio::sync::mpsc;
use util::marshal::*;
use util::Buffer;
use crate::error::{Error, Result};
/// Limit the buffer size to 1MB
pub const SRTP_BUFFER_SIZE: usize = 1000 * 1000;
/// Limit the buffer size to 100KB
pub const SRTCP_BUFFER_SIZE: usize = 100 * 1000;
/// Stream handles decryption for a single RTP/RTCP SSRC
#[derive(Debug)]
pub struct Stream {
ssrc: u32,
tx: mpsc::Sender<u32>,
pub(crate) buffer: Buffer,
is_rtp: bool,
}
impl Stream {
/// Create a new stream
pub fn new(ssrc: u32, tx: mpsc::Sender<u32>, is_rtp: bool) -> Self {
Stream {
ssrc,
tx,
// Create a buffer with a 1MB limit
buffer: Buffer::new(
0,
if is_rtp {
SRTP_BUFFER_SIZE
} else {
SRTCP_BUFFER_SIZE
},
),
is_rtp,
}
}
/// GetSSRC returns the SSRC we are demuxing for
pub fn get_ssrc(&self) -> u32 {
self.ssrc
}
/// Check if RTP is a stream.
pub fn is_rtp_stream(&self) -> bool {
self.is_rtp
}
/// Read reads and decrypts full RTP packet from the nextConn
pub async fn read(&self, buf: &mut [u8]) -> Result<usize> {
Ok(self.buffer.read(buf, None).await?)
}
/// ReadRTP reads and decrypts full RTP packet and its header from the nextConn
pub async fn read_rtp(&self, buf: &mut [u8]) -> Result<rtp::packet::Packet> {
if !self.is_rtp {
return Err(Error::InvalidRtpStream);
}
let n = self.buffer.read(buf, None).await?;
let mut b = &buf[..n];
let pkt = rtp::packet::Packet::unmarshal(&mut b)?;
Ok(pkt)
}
/// read_rtcp reads and decrypts full RTP packet and its header from the nextConn
pub async fn read_rtcp(
&self,
buf: &mut [u8],
) -> Result<Vec<Box<dyn rtcp::packet::Packet + Send + Sync>>> {
if self.is_rtp {
return Err(Error::InvalidRtcpStream);
}
let n = self.buffer.read(buf, None).await?;
let mut b = &buf[..n];
let pkt = rtcp::packet::unmarshal(&mut b)?;
Ok(pkt)
}
/// Close removes the ReadStream from the session and cleans up any associated state
pub async fn close(&self) -> Result<()> {
self.buffer.close().await;
let _ = self.tx.send(self.ssrc).await;
Ok(())
}
}
@@ -121,13 +121,17 @@ impl PeerConnectionInternal {
ice_gather_policy: configuration.ice_transport_policy,
})?);
// Create the ice transport
pc.ice_transport = pc.create_ice_transport(api).await;
// Create the ice transport. Its state callback must read the real DTLS
// transport, which only exists after the ICE transport, so it is wired
// in through a weak slot (the placeholder would always report New).
let dtls_slot = Arc::new(std::sync::OnceLock::new());
pc.ice_transport = pc.create_ice_transport(api, Arc::clone(&dtls_slot)).await;
// Create the DTLS transport
let certificates = configuration.certificates.drain(..).collect();
pc.dtls_transport =
Arc::new(api.new_dtls_transport(Arc::clone(&pc.ice_transport), certificates)?);
let _ = dtls_slot.set(Arc::downgrade(&pc.dtls_transport));
// Create the SCTP transport
pc.sctp_transport = Arc::new(api.new_sctp_transport(Arc::clone(&pc.dtls_transport))?);
@@ -1106,13 +1110,16 @@ impl PeerConnectionInternal {
}
}
pub(super) async fn create_ice_transport(&self, api: &API) -> Arc<RTCIceTransport> {
pub(super) async fn create_ice_transport(
&self,
api: &API,
dtls_slot: Arc<std::sync::OnceLock<Weak<RTCDtlsTransport>>>,
) -> Arc<RTCIceTransport> {
let ice_transport = Arc::new(api.new_ice_transport(Arc::clone(&self.ice_gatherer)));
let ice_connection_state = Arc::clone(&self.ice_connection_state);
let peer_connection_state = Arc::clone(&self.peer_connection_state);
let is_closed = Arc::clone(&self.is_closed);
let dtls_transport = Arc::clone(&self.dtls_transport);
let on_ice_connection_state_change_handler =
Arc::clone(&self.on_ice_connection_state_change_handler);
let on_peer_connection_state_change_handler =
@@ -1139,7 +1146,11 @@ impl PeerConnectionInternal {
let on_peer_connection_state_change_handler2 =
Arc::clone(&on_peer_connection_state_change_handler);
let is_closed2 = Arc::clone(&is_closed);
let dtls_transport_state = dtls_transport.state();
let dtls_transport_state = dtls_slot
.get()
.and_then(Weak::upgrade)
.map(|dtls| dtls.state())
.unwrap_or(RTCDtlsTransportState::New);
let peer_connection_state2 = Arc::clone(&peer_connection_state);
Box::pin(async move {
RTCPeerConnection::do_ice_connection_state_change(