mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d7e52a098b | ||
|
|
94ff1f1c02 | ||
|
|
aafc17e626 | ||
|
|
cd6df7f03f | ||
|
|
2815a01569 | ||
|
|
664c96941c | ||
|
|
8967dfdd4b | ||
|
|
c38b41b543 | ||
|
|
3d4d8d1d64 | ||
|
|
843e4aa342 | ||
|
|
73c1d9b54d | ||
|
|
432593083e | ||
|
|
e5e6a04b5d | ||
|
|
23aec299bb | ||
|
|
9a91000e0a | ||
|
|
693660ed85 | ||
|
|
5c5958115a | ||
|
|
1054af0950 | ||
|
|
94fd3c2fa7 | ||
|
|
1b10a22c8c | ||
|
|
809ce1697d |
No files matched your search
@@ -19,6 +19,20 @@ jobs:
|
||||
- uses: Swatinem/rust-cache@v2
|
||||
- run: cargo test --locked
|
||||
|
||||
test-viewer:
|
||||
runs-on: ubuntu-22.04
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install build dependencies (X11 + GTK + SDL2 + ffmpeg CLI for the viewer)
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y build-essential pkg-config \
|
||||
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev libsdl2-dev ffmpeg
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- uses: Swatinem/rust-cache@v2
|
||||
- run: cargo test --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
|
||||
- run: cargo build --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
|
||||
|
||||
test-wayland:
|
||||
runs-on: ubuntu-24.04
|
||||
steps:
|
||||
|
||||
@@ -17,15 +17,17 @@ jobs:
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y build-essential pkg-config \
|
||||
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev
|
||||
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev libsdl2-dev
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- run: cargo test --release --locked
|
||||
- run: cargo build --release --locked
|
||||
# Experimental viewer; built after the host so uuremote-server keeps the default features.
|
||||
- run: cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
|
||||
- name: Package
|
||||
run: |
|
||||
name=uu-remote-linux-${GITHUB_REF_NAME}-x86_64-linux
|
||||
mkdir -p "$name"
|
||||
cp target/release/uuremote-server LICENSE README.md README.en.md config.example.json "$name/"
|
||||
cp target/release/uuremote-server target/release/uuremote-viewer 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"
|
||||
|
||||
@@ -7,8 +7,9 @@ This file is written for large language model agents (Claude Code, Codex, Cursor
|
||||
## 1. What this project is
|
||||
|
||||
- An **unofficial Linux host** for NetEase UU Remote (网易 UU 远程). The official Mac / Windows / mobile
|
||||
clients connect to it and control the Linux desktop. There is no viewer/controller side here.
|
||||
- One Rust binary, `uuremote-server` (Cargo package `uu-remote-linux`), plus small C engines in `c_engine/`
|
||||
clients connect to it and control the Linux desktop. An experimental Linux viewer/controller, `uuremote-viewer`
|
||||
(`src/viewer_main.rs`, `src/viewer/`, feature `native-viewer`), connects to other hosts with the same protocol.
|
||||
- One host binary, `uuremote-server` (Cargo package `uu-remote-linux`), plus small C engines in `c_engine/`
|
||||
compiled by `build.rs`. No Wine, no NetEase binaries.
|
||||
- The host registers with the UU cloud as a **Windows PC** (`x-param-plat=1`) so the official clients accept it.
|
||||
- License GPL-3.0. Not affiliated with NetEase.
|
||||
@@ -50,6 +51,7 @@ cargo test # unit tests (macOS builds use C st
|
||||
cargo build --release # X11 host
|
||||
cargo build --release --features wayland # + Hyprland/wlroots
|
||||
cargo build --release --features wayland,portal # + GNOME/KDE Wayland via xdg-desktop-portal
|
||||
cargo build --release --features native-viewer,viewer-sdl --bin uuremote-viewer # viewer (needs libsdl2-dev)
|
||||
```
|
||||
|
||||
- `build.rs` links X11/Xext/Xtst/Xfixes and `dl` (PAM is loaded at runtime with `dlopen`), and builds the GTK3
|
||||
@@ -144,6 +146,8 @@ every 60 s.
|
||||
| `c_engine/x11_engine.c`, `c_engine/clipboard.c` | X11 capture/input/selection |
|
||||
| `c_engine/wayland_engine.c`, `c_engine/portal_engine.c` | Wayland and portal engines |
|
||||
| `src/assist.rs`, `c_engine/assist_window.c` | remote assistance (guest + account) and the unified GTK main window (assist + account/QR card) |
|
||||
| `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher |
|
||||
| `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) |
|
||||
|
||||
Diagnostic subcommands: `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
|
||||
`desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`,
|
||||
|
||||
Generated
+32
-1
@@ -2050,6 +2050,30 @@ dependencies = [
|
||||
"untrusted 0.9.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sdl2"
|
||||
version = "0.37.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3b498da7d14d1ad6c839729bd4ad6fc11d90a57583605f3b4df2cd709a9cd380"
|
||||
dependencies = [
|
||||
"bitflags 1.3.2",
|
||||
"lazy_static",
|
||||
"libc",
|
||||
"sdl2-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sdl2-sys"
|
||||
version = "0.37.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "951deab27af08ed9c6068b7b0d05a93c91f0a8eb16b6b816a5e73452a43521d3"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"libc",
|
||||
"pkg-config",
|
||||
"version-compare",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sdp"
|
||||
version = "0.6.2"
|
||||
@@ -2717,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.31"
|
||||
version = "0.2.5"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.22.1",
|
||||
@@ -2735,6 +2759,7 @@ dependencies = [
|
||||
"qrcode",
|
||||
"rand 0.8.8",
|
||||
"reqwest",
|
||||
"sdl2",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
@@ -2761,6 +2786,12 @@ version = "0.2.15"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
|
||||
|
||||
[[package]]
|
||||
name = "version-compare"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.5"
|
||||
|
||||
+12
-1
@@ -1,7 +1,8 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.31"
|
||||
version = "0.2.5"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
|
||||
readme = "README.md"
|
||||
@@ -13,8 +14,16 @@ repository = "https://github.com/VallierDev/uu-remote-linux"
|
||||
name = "uuremote-server"
|
||||
path = "src/main.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "uuremote-viewer"
|
||||
path = "src/viewer_main.rs"
|
||||
required-features = ["native-viewer"]
|
||||
|
||||
[features]
|
||||
default = []
|
||||
native-viewer = []
|
||||
viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"]
|
||||
viewer-sdl = ["native-viewer", "dep:sdl2"]
|
||||
wayland = []
|
||||
# Experimental direct linear framebuffer capture; never enabled in release builds.
|
||||
kms = []
|
||||
@@ -47,6 +56,8 @@ env_logger = "0.11"
|
||||
ffmpeg-next = { version = "6.1", optional = true, default-features = false, features = ["codec", "format", "device", "software-scaling", "software-resampling"] }
|
||||
x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], optional = true }
|
||||
|
||||
sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1.0"
|
||||
|
||||
|
||||
+58
-2
@@ -45,7 +45,7 @@
|
||||
| Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked |
|
||||
| Lock after remote session | Stored on the host, so it still applies after reconnecting |
|
||||
| Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards |
|
||||
| System actions | Lock, show desktop, task manager (system monitor), reboot, shut down |
|
||||
| System actions | Lock, show desktop, task manager (system monitor), reboot, shut down (via `systemctl`; needs polkit permission for the user, usually an active local graphical session; without it the action fails and is logged, no password dialog appears on the host) |
|
||||
| Port mapping | The official "port mapping" tool: forwards a local port on the viewer to an address reachable from the Linux host (e.g. 127.0.0.1:22); `UU_PORT_MAPPING=0` disables it |
|
||||
| Reconnects | Every tool window has its own connection; they do not disturb each other |
|
||||
| Headless servers | Goes online without a monitor with terminal, file transfer and port mapping; an Xvfb virtual desktop gives a full remote desktop (see below) |
|
||||
@@ -107,7 +107,7 @@ mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI
|
||||
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
|
||||
| Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
|
||||
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
|
||||
| Acting as a viewer (controlling other machines from Linux) | Out of scope |
|
||||
| Acting as a viewer (controlling other machines from Linux) | 🧪 Experimental `uuremote-viewer`, see [below](#experimental-native-viewer-uuremote-viewer) |
|
||||
|
||||
## Installation
|
||||
|
||||
@@ -403,3 +403,59 @@ This capability is broad: it applies to the whole network-facing process and can
|
||||
The VM GDM greeter capture was solid black (failed visual acceptance); lock/greeter support and Intel/AMD hardware remain unverified. Use uinput for input; clipboard
|
||||
is unavailable without a desktop session. No default release behavior changes.
|
||||
No official "no desktop" error code was found for headless desktop offers, so the existing offer behavior is retained.
|
||||
|
||||
## Experimental native viewer (uuremote-viewer)
|
||||
|
||||
`uuremote-viewer` is a Linux **viewer/controller**: it connects to and controls other devices on your UU account (official Windows / Mac
|
||||
hosts or this project's Linux host), and can start remote assistance with someone's device ID and code. It is experimental and
|
||||
separate from the host `uuremote-server`; the default host build and behaviour are unchanged.
|
||||
|
||||
**Get it**: release tarballs include `uuremote-viewer` (x86_64) from this version on. Runtime needs GTK3, SDL2 (Ubuntu/Debian:
|
||||
`libsdl2-2.0-0`) and the `ffmpeg` command; SDL desktop windows synchronize text clipboard directly on Wayland/X11 without extra clipboard tools; the terminal needs a local
|
||||
terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsdl2-dev`, then
|
||||
`cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`.
|
||||
|
||||
SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37).
|
||||
Synchronization runs only while that window is focused and keeps the 30 KiB text limit. Selections without a supported
|
||||
text format are skipped; empty-text detection depends on the SDL2 backend. Builds without SDL retain the command backend.
|
||||
SDL2 reads selections synchronously, so a slow selection owner can temporarily block the window; the bridge timeout cannot interrupt it.
|
||||
GNOME-to-official-Mac bidirectional clipboard synchronization is still unverified; this change does not resolve host compatibility.
|
||||
|
||||
**Use**:
|
||||
- `uuremote-viewer login`: QR login (reuses the sibling `uuremote-server` login window; `--no-gui` prints a terminal QR). The viewer
|
||||
shares `~/.config/uuremote/config.json` with the host (`UU_CONFIG` selects another), so it **cannot connect to a host on the same
|
||||
machine with the same identity**; other devices are fine.
|
||||
- `uuremote-viewer ui`: launcher listing your devices: desktop, view-only, files, terminal, port mapping, reboot/shutdown, assistance.
|
||||
- CLI: `connect DEVICE false - echo legacy [--view-only]` (desktop), `files DEVICE ls|get|put …`, `terminal DEVICE [SESSION]`,
|
||||
`terminal-ui DEVICE NAME`, `portmap DEVICE LOCAL_PORT HOST PORT` (listens on 127.0.0.1 only), `power DEVICE reboot|shutdown`, `unbind DEVICE` (remove a device from the account; also under "More tools" in the launcher),
|
||||
`assist CONNECT_ID` (the code is read from one stdin line, never an argument). See `uuremote-viewer --help`.
|
||||
- Ctrl+Alt+F in the desktop window opens the files window on the same connection. `UU_VIEWER_AUDIO=0` disables sound,
|
||||
`UU_VIEWER_CLIPBOARD=0` the clipboard, `UU_VIEWER_VIEW_ONLY=1` input; `UU_VIEWER_FFMPEG` selects the ffmpeg binary.
|
||||
- Desktop offers H.264 / H.265; the host chooses the codec. `UU_VIEWER_CODEC=h264` limits both SDP and decoder capabilities to H.264.
|
||||
The default request stays 4:2:0; `UU_VIEWER_CHROMA=444` requests true color (4:4:4) after CONTROL opens. The host may fall back to
|
||||
4:2:0, as reported by CaptureSettingSync. FFmpeg converts either chroma format to RGB24 for display.
|
||||
|
||||
Mac targets use native macOS keycodes; Windows / Linux targets retain Windows VK. Keys follow physical positions, without
|
||||
automatically translating Ctrl to Command; on a Mac target the PC Super / Windows key acts as Command. Only verified target
|
||||
platform values 1 (Windows / this project's Linux host) and 4 (Mac) are accepted; unknown values fail explicitly. Account
|
||||
connections look up the selected device only when the platform is absent; assistance requires it in the join response.
|
||||
View-only sessions skip this lookup. Media keys and some JIS-specific keys are not mapped; Mac platform detection for remote
|
||||
assistance and ISO / JIS keyboards have not been tested live.
|
||||
|
||||
**Tested live** (author's setup, not full acceptance):
|
||||
| Feature | Official Windows host | Official Mac host | This project's Linux host |
|
||||
|---|---|---|---|
|
||||
| Desktop video (H.264) | ✅ | ✅ | ✅ |
|
||||
| H.265, 4:4:4 true color | — | — | ✅ (VM, libx265) |
|
||||
| Keyboard, mouse | ✅ | — | ✅ |
|
||||
| File list / download / upload | ✅ | — | ✅ |
|
||||
| Port mapping, terminal | ✅ (PowerShell terminal) | — | ✅ |
|
||||
| Clipboard (text) | host → viewer only; viewer → Windows not applied yet | — | ✅ both ways (VM) |
|
||||
| Sound | unconfirmed (no audio packets while the host is silent) | — | ✅ (VM) |
|
||||
| Remote assistance (ID + code) | — | — | ✅ (VM, guest host) |
|
||||
| Terminal session list (create, double-click reattach, end) | — | — | ✅ (VM) |
|
||||
| Reboot, shutdown | — | — | ✅ (VM) |
|
||||
| Wayland desktop window and clipboard | — | — | ✅ Hyprland, KDE; GNOME window works; clipboard switched to SDL in v0.2.3 (#37, final revision not re-verified live) |
|
||||
|
||||
"—" = not tested yet. Only use reboot/shutdown on machines you can restart. **Not tested live**: H.265 / 4:4:4 with official hosts, multiple monitors. Logs carry field
|
||||
numbers, sizes and states only, never keystrokes, clipboard or file contents, codes or credentials.
|
||||
@@ -41,7 +41,7 @@
|
||||
| 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 |
|
||||
| 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 |
|
||||
| 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 |
|
||||
| 系统操作 | 锁屏、显示桌面、任务管理器(系统监视器)、重启、关机 |
|
||||
| 系统操作 | 锁屏、显示桌面、任务管理器(系统监视器)、重启、关机(通过 `systemctl`,需要当前用户有 polkit 权限:通常本机有活动的图形会话即可;没有权限时直接失败并记日志,不会在被控端弹出密码框) |
|
||||
| 端口映射 | 官方「端口映射」工具:把控制端本地端口转发到 Linux 能访问到的地址(如 127.0.0.1:22);`UU_PORT_MAPPING=0` 可关闭 |
|
||||
| 多次重连 | 每个工具窗口独立连接,互不影响 |
|
||||
| 无头服务器 | 没有显示器也能上线,提供终端、文件传输和端口映射;也可以用 Xvfb 虚拟桌面提供完整远程桌面(见下文) |
|
||||
@@ -94,7 +94,7 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
|
||||
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
|
||||
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
|
||||
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
|
||||
| 作为控制端(在 Linux 上控制别的电脑) | 不在本项目范围 |
|
||||
| 作为控制端(在 Linux 上控制别的电脑) | 🧪 实验性 `uuremote-viewer`,见[下文](#实验性原生控制端uuremote-viewer) |
|
||||
|
||||
## 安装
|
||||
|
||||
@@ -370,3 +370,52 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
|
||||
当前仅为线性帧缓冲原型:VM 的 GDM 截图仍是黑屏,**没有通过登录界面视觉验收**,不承诺锁屏可用。
|
||||
键鼠需 uinput;没有桌面会话时不提供剪贴板。
|
||||
无头模式下桌面连接没有找到官方的「无桌面」错误码,因此保持原有 offer 行为。
|
||||
|
||||
## 实验性原生控制端(uuremote-viewer)
|
||||
|
||||
`uuremote-viewer` 是 Linux 上的**控制端**:用你的 UU 账号连接并控制其他设备(官方 Windows / Mac 被控端,或本项目的 Linux 主机),
|
||||
也可以凭对方的设备 ID 和验证码发起远程协助。它是实验性功能,与主机 `uuremote-server` 相互独立,默认主机构建和行为不变。
|
||||
|
||||
**获取**:Release 包从本版本起附带 `uuremote-viewer`(x86_64)。运行时需要 GTK3、SDL2(Ubuntu/Debian:`libsdl2-2.0-0`)和
|
||||
`ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
|
||||
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
|
||||
|
||||
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。仅在桌面窗口获得焦点时同步,
|
||||
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
|
||||
SDL2 同步读取选择内容,慢速的剪贴板提供者可能暂时阻塞窗口,桥接超时无法中断该原生调用。
|
||||
GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。
|
||||
|
||||
**使用**:
|
||||
- `uuremote-viewer login`:扫码登录(复用同目录下 `uuremote-server` 的登录窗口;`--no-gui` 为终端二维码)。控制端与主机共用
|
||||
`~/.config/uuremote/config.json`(可用 `UU_CONFIG` 另指定),因此**不能用同一身份连接本机上的主机**;控制其他设备不受影响。
|
||||
- `uuremote-viewer ui`:启动窗口,列出账号下的设备,可进入桌面、只看模式、文件传输、终端、端口映射、重启/关机、远程协助。
|
||||
- 命令行:`connect DEVICE false - echo legacy [--view-only]`(桌面)、`files DEVICE ls|get|put …`、`terminal DEVICE [SESSION]`、
|
||||
`terminal-ui DEVICE NAME`、`portmap DEVICE LOCAL_PORT HOST PORT`(只监听 127.0.0.1)、`power DEVICE reboot|shutdown`、`unbind DEVICE`(从账号删除设备,启动窗口「更多工具」里也有)、
|
||||
`assist CONNECT_ID`(验证码从 stdin 读取一行,不能作为参数传入)。`uuremote-viewer --help` 查看全部参数。
|
||||
- 桌面窗口中按 Ctrl+Alt+F 打开文件窗口(复用同一连接)。`UU_VIEWER_AUDIO=0` 关闭声音,`UU_VIEWER_CLIPBOARD=0` 关闭剪贴板,
|
||||
`UU_VIEWER_VIEW_ONLY=1` 只看不控,`UU_VIEWER_FFMPEG` 指定 ffmpeg 路径。
|
||||
- 桌面同时提供 H.264 / H.265,由主机协商选择;`UU_VIEWER_CODEC=h264` 将 SDP 和解码能力限制为 H.264。
|
||||
默认请求 4:2:0;`UU_VIEWER_CHROMA=444` 在 CONTROL 打开后请求真彩(4:4:4)。主机可能回落到 4:2:0,
|
||||
以 CaptureSettingSync 回报为准。两种色度均由 FFmpeg 转为 RGB24 显示。
|
||||
|
||||
Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command;
|
||||
控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac),
|
||||
未知值会报错,不猜测键码。账号连接缺少平台字段时查询目标设备;远程协助必须由连接响应提供平台。只看模式不需要此识别。
|
||||
媒体键和部分 JIS 专用键尚未映射;远程协助的 Mac 平台识别及 ISO / JIS 键盘尚未实机验收。
|
||||
|
||||
**已实测**(作者环境,非全面验收):
|
||||
| 功能 | 官方 Windows 被控端 | 官方 Mac 被控端 | 本项目 Linux 主机 |
|
||||
|---|---|---|---|
|
||||
| 桌面画面(H.264) | ✅ | ✅ | ✅ |
|
||||
| H.265、4:4:4 真彩 | — | — | ✅(虚拟机,libx265) |
|
||||
| 键盘、鼠标 | ✅ | — | ✅ |
|
||||
| 文件列表 / 下载 / 上传 | ✅ | — | ✅ |
|
||||
| 端口映射、终端 | ✅(终端为 PowerShell) | — | ✅ |
|
||||
| 剪贴板(文本) | 仅被控端 → 控制端;控制端 → Windows 未生效 | — | ✅ 双向(虚拟机) |
|
||||
| 声音 | 未确认(被控端未播放声音时没有音频包) | — | ✅(虚拟机) |
|
||||
| 远程协助(ID + 验证码) | — | — | ✅(虚拟机,访客主机) |
|
||||
| 终端会话列表(新建、双击接回、结束) | — | — | ✅(虚拟机) |
|
||||
| 重启、关机 | — | — | ✅(虚拟机) |
|
||||
| Wayland 下的桌面窗口与剪贴板 | — | — | ✅ Hyprland、KDE;GNOME 窗口正常,剪贴板已于 v0.2.3 改为 SDL 直连(#37,最终版本未重新实机验收) |
|
||||
|
||||
「—」表示尚未测试。重启/关机只应在可以重启的机器上使用。**未实测**:官方被控端的 H.265 / 4:4:4、多显示器。日志只记录字段号、大小和状态,不记录键盘、剪贴板、文件内容、验证码或凭据。
|
||||
@@ -3,6 +3,8 @@ fn main() {
|
||||
println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/clipboard.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/assist_window.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/viewer_window.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/viewer_tools.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/pam_check.c");
|
||||
println!("cargo:rerun-if-env-changed=UU_NO_GTK");
|
||||
println!("cargo:rustc-check-cfg=cfg(uu_gtk)");
|
||||
@@ -36,7 +38,7 @@ fn main() {
|
||||
match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() {
|
||||
Some((cflags, libs)) => {
|
||||
let mut build = cc::Build::new();
|
||||
build.file("c_engine/assist_window.c").flag_if_supported("-Wno-deprecated-declarations");
|
||||
build.file("c_engine/assist_window.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").flag_if_supported("-Wno-deprecated-declarations");
|
||||
for flag in cflags.split_whitespace() { build.flag(flag); }
|
||||
build.compile("uu_login_window");
|
||||
for flag in libs.split_whitespace() {
|
||||
|
||||
@@ -475,6 +475,8 @@ static void build_window(void) {
|
||||
static void *ui_main(void *arg) {
|
||||
(void)arg;
|
||||
int ok = gtk_init_check(NULL, NULL);
|
||||
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
|
||||
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
|
||||
if (ok) build_window();
|
||||
pthread_mutex_lock(&init_lock);
|
||||
init_state = ok ? 1 : -1;
|
||||
|
||||
@@ -0,0 +1,496 @@
|
||||
// GTK3 tool windows for the native viewer: file transfer (`files-ui`) and port mapping (`portmap-ui`).
|
||||
// One tool window per process; desktop files reuse the desktop peer. GTK runs on its own thread; Rust pushes state with g_idle_add and polls commands. Paths and
|
||||
// names stay inside this window; nothing here logs.
|
||||
#include <gtk/gtk.h>
|
||||
#include <pthread.h>
|
||||
#include <stdatomic.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define QSIZE 64
|
||||
static char queue[QSIZE][4096];
|
||||
static int q_head, q_len;
|
||||
static pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static atomic_int closed;
|
||||
static int init_state;
|
||||
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
|
||||
static GtkWidget *window, *toast;
|
||||
static char remote_name[256];
|
||||
|
||||
static void push(const char *cmd) {
|
||||
pthread_mutex_lock(&q_lock);
|
||||
if (q_len < QSIZE) { snprintf(queue[(q_head + q_len) % QSIZE], sizeof queue[0], "%s", cmd); q_len++; }
|
||||
pthread_mutex_unlock(&q_lock);
|
||||
}
|
||||
int uu_tools_ui_take(char *out, size_t len) {
|
||||
pthread_mutex_lock(&q_lock);
|
||||
int got = q_len > 0;
|
||||
if (got) { snprintf(out, len, "%s", queue[q_head]); q_head = (q_head + 1) % QSIZE; q_len--; }
|
||||
pthread_mutex_unlock(&q_lock);
|
||||
return got;
|
||||
}
|
||||
int uu_tools_ui_closed(void) { return atomic_load(&closed); }
|
||||
static void add_class(GtkWidget *w, const char *cls) { gtk_style_context_add_class(gtk_widget_get_style_context(w), cls); }
|
||||
static GtkWidget *hbox(int s) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, s); }
|
||||
static GtkWidget *vbox(int s) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, s); }
|
||||
static GtkWidget *label(const char *text, const char *cls) { GtkWidget *l = gtk_label_new(text); if (cls) add_class(l, cls); gtk_label_set_xalign(GTK_LABEL(l), 0); return l; }
|
||||
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
|
||||
static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; }
|
||||
static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); }
|
||||
static gboolean toast_idle(gpointer d) { show_toast(d); g_free(d); return G_SOURCE_REMOVE; }
|
||||
void uu_tools_ui_toast(const char *text) { g_idle_add(toast_idle, g_strdup(text)); }
|
||||
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); atomic_store(&closed, 1); return TRUE; }
|
||||
|
||||
static const char *css =
|
||||
"window { background: #f5f6f8; }\n"
|
||||
".title { font-size: 22px; font-weight: bold; color: #111827; }\n"
|
||||
".tag { background: #e5e7eb; color: #4b5563; border-radius: 6px; padding: 2px 8px; }\n"
|
||||
".tag.remote { background: #d1fae5; color: #047857; }\n"
|
||||
".card { background: white; border: 1px solid #e5e7eb; border-radius: 10px; padding: 8px; }\n"
|
||||
".section { font-size: 17px; font-weight: bold; }\n"
|
||||
".toast { background: rgba(17,24,39,0.88); color: white; border-radius: 8px; padding: 10px 18px; }\n"
|
||||
".primary { background-image: none; background-color: #10b981; color: white; border: none; }\n"
|
||||
".empty { color: #6b7280; font-size: 15px; }\n"
|
||||
".online { color: #10b981; }\n";
|
||||
|
||||
static GtkWidget *frame(const char *title, GtkWidget **content) {
|
||||
GtkCssProvider *p = gtk_css_provider_new(); gtk_css_provider_load_from_data(p, css, -1, NULL);
|
||||
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(p), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), title);
|
||||
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
|
||||
GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14);
|
||||
gtk_container_set_border_width(GTK_CONTAINER(*content), 22);
|
||||
gtk_container_add(GTK_CONTAINER(overlay), *content);
|
||||
toast = label("", "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_END);
|
||||
gtk_widget_set_margin_bottom(toast, 30); gtk_widget_set_no_show_all(toast, TRUE);
|
||||
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), toast);
|
||||
gtk_container_add(GTK_CONTAINER(window), overlay);
|
||||
return overlay;
|
||||
}
|
||||
static GtkWidget *add_column(GtkWidget *view, const char *title, int col, int expand) {
|
||||
GtkCellRenderer *r = gtk_cell_renderer_text_new();
|
||||
if (expand) g_object_set(r, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
|
||||
GtkTreeViewColumn *c = gtk_tree_view_column_new_with_attributes(title, r, "text", col, NULL);
|
||||
gtk_tree_view_column_set_resizable(c, TRUE); gtk_tree_view_column_set_expand(c, expand);
|
||||
if (expand) gtk_tree_view_column_set_min_width(c, 160);
|
||||
gtk_tree_view_append_column(GTK_TREE_VIEW(view), c);
|
||||
return view;
|
||||
}
|
||||
static GtkWidget *scrolled(GtkWidget *child, int height) {
|
||||
GtkWidget *s = gtk_scrolled_window_new(NULL, NULL);
|
||||
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(s), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
|
||||
gtk_widget_set_size_request(s, -1, height); gtk_container_add(GTK_CONTAINER(s), child);
|
||||
return s;
|
||||
}
|
||||
static void format_size(guint64 size, int kind, char *out, size_t len) {
|
||||
if (kind != 4) { snprintf(out, len, "--"); return; }
|
||||
if (size < 1024) snprintf(out, len, "%llu B", (unsigned long long)size);
|
||||
else if (size < 1024 * 1024) snprintf(out, len, "%.2f KB", size / 1024.0);
|
||||
else if (size < 1024ull * 1024 * 1024) snprintf(out, len, "%.2f MB", size / 1048576.0);
|
||||
else snprintf(out, len, "%.2f GB", size / 1073741824.0);
|
||||
}
|
||||
static void format_time(guint64 secs, char *out, size_t len) {
|
||||
if (!secs) { snprintf(out, len, "--"); return; }
|
||||
time_t t = (time_t)secs; struct tm tm; localtime_r(&t, &tm);
|
||||
strftime(out, len, "%Y年%m月%d日", &tm);
|
||||
}
|
||||
static const char *kind_name(int kind) { return kind == 4 ? "文件" : kind == 3 ? "磁盘" : "文件夹"; }
|
||||
|
||||
/* ---------------- file transfer ---------------- */
|
||||
enum { C_NAME, C_TIME, C_TYPE, C_SIZE, C_PATH, C_KIND, C_N };
|
||||
enum { T_ID, T_NAME, T_STATUS, T_SIZE, T_FROM, T_TO, T_DONE, T_N };
|
||||
static GtkListStore *local_store, *remote_store, *task_store;
|
||||
static GtkWidget *local_view, *remote_view, *local_path, *remote_path;
|
||||
static char local_dir[2048] = "", remote_dir[2048] = ":/";
|
||||
|
||||
static void load_local(const char *path) {
|
||||
char *dir = g_strdup(path); /* path may alias local_dir */
|
||||
GDir *d = g_dir_open(dir, 0, NULL);
|
||||
if (!d) { show_toast("无法打开本机目录"); g_free(dir); return; }
|
||||
snprintf(local_dir, sizeof local_dir, "%s", dir); g_free(dir);
|
||||
gtk_entry_set_text(GTK_ENTRY(local_path), local_dir);
|
||||
gtk_list_store_clear(local_store);
|
||||
const char *name;
|
||||
GPtrArray *names = g_ptr_array_new_with_free_func(g_free);
|
||||
while ((name = g_dir_read_name(d))) if (name[0] != '.') g_ptr_array_add(names, g_strdup(name));
|
||||
g_dir_close(d);
|
||||
for (int pass = 0; pass < 2; pass++) for (guint i = 0; i < names->len; i++) {
|
||||
char *full = g_build_filename(local_dir, names->pdata[i], NULL); struct stat st;
|
||||
if (stat(full, &st) == 0 && (S_ISDIR(st.st_mode) ? pass == 0 : pass == 1)) {
|
||||
int kind = S_ISDIR(st.st_mode) ? 0 : 4; char size[32], when[64];
|
||||
format_size(st.st_size, kind, size, sizeof size); format_time(st.st_mtime, when, sizeof when);
|
||||
GtkTreeIter it; gtk_list_store_append(local_store, &it);
|
||||
gtk_list_store_set(local_store, &it, C_NAME, names->pdata[i], C_TIME, when, C_TYPE, kind_name(kind), C_SIZE, size, C_PATH, full, C_KIND, kind, -1);
|
||||
}
|
||||
g_free(full);
|
||||
}
|
||||
g_ptr_array_free(names, TRUE);
|
||||
}
|
||||
static void request_remote(const char *path) { char cmd[2100]; snprintf(cmd, sizeof cmd, "ls\t%s", path); push(cmd); }
|
||||
static void on_local_up(GtkButton *b, gpointer d) { (void)b; (void)d; char *p = g_path_get_dirname(local_dir); load_local(p); g_free(p); }
|
||||
static void on_local_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; load_local(local_dir); }
|
||||
static void on_local_path(GtkEntry *e, gpointer d) { (void)d; load_local(gtk_entry_get_text(e)); }
|
||||
static void on_remote_up(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d;
|
||||
if (!strcmp(remote_dir, ":/") || !strcmp(remote_dir, "/")) { request_remote(":/"); return; }
|
||||
char *p = g_path_get_dirname(remote_dir); request_remote(p); g_free(p);
|
||||
}
|
||||
static void on_remote_refresh(GtkButton *b, gpointer d) { (void)b; (void)d; request_remote(remote_dir); }
|
||||
static void on_remote_path(GtkEntry *e, gpointer d) { (void)d; request_remote(gtk_entry_get_text(e)); }
|
||||
static void on_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *col, gpointer remote) {
|
||||
(void)col; GtkTreeModel *m = gtk_tree_view_get_model(view); GtkTreeIter it; char *full; int kind;
|
||||
if (!gtk_tree_model_get_iter(m, &it, path)) return;
|
||||
gtk_tree_model_get(m, &it, C_PATH, &full, C_KIND, &kind, -1);
|
||||
if (kind != 4) { if (remote) request_remote(full); else load_local(full); }
|
||||
g_free(full);
|
||||
}
|
||||
static char *ask_name(const char *title) {
|
||||
GtkWidget *dlg = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "确定", GTK_RESPONSE_OK, NULL);
|
||||
GtkWidget *entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
|
||||
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
|
||||
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dlg)); gtk_container_set_border_width(GTK_CONTAINER(area), 16);
|
||||
gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0); gtk_widget_show_all(dlg);
|
||||
char *name = NULL;
|
||||
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
|
||||
const char *t = gtk_entry_get_text(GTK_ENTRY(entry));
|
||||
if (*t && !strchr(t, '/') && strcmp(t, ".") && strcmp(t, "..")) name = g_strdup(t); else if (*t) show_toast("名称无效");
|
||||
}
|
||||
gtk_widget_destroy(dlg);
|
||||
return name;
|
||||
}
|
||||
static void on_local_mkdir(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d; char *name = ask_name("新建文件夹"); if (!name) return;
|
||||
char *full = g_build_filename(local_dir, name, NULL);
|
||||
if (mkdir(full, 0755) != 0) show_toast("无法创建文件夹"); else load_local(local_dir);
|
||||
g_free(full); g_free(name);
|
||||
}
|
||||
static void on_remote_mkdir(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d;
|
||||
if (!strcmp(remote_dir, ":/")) { show_toast("请先进入一个文件夹"); return; }
|
||||
char *name = ask_name("新建文件夹"); if (!name) return;
|
||||
char *full = g_build_filename(remote_dir, name, NULL); char cmd[2200];
|
||||
snprintf(cmd, sizeof cmd, "mkdir\t%s", full); push(cmd); g_free(full); g_free(name);
|
||||
}
|
||||
/* Each selected row becomes one queued transfer. Remote folders download recursively; local folders
|
||||
* are not supported by the upload RPC sequence implemented here. */
|
||||
static void on_send(GtkButton *b, gpointer upload) {
|
||||
(void)b; GtkTreeView *view = GTK_TREE_VIEW(upload ? local_view : remote_view);
|
||||
GtkTreeModel *m; GList *rows = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(view), &m);
|
||||
if (!rows) { show_toast("请先选择要发送的文件"); return; }
|
||||
if (upload && !strcmp(remote_dir, ":/")) { show_toast("请先在远端进入目标文件夹"); g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free); return; }
|
||||
int skipped = 0;
|
||||
for (GList *r = rows; r; r = r->next) {
|
||||
GtkTreeIter it; char *full, *name; int kind;
|
||||
if (!gtk_tree_model_get_iter(m, &it, r->data)) continue;
|
||||
gtk_tree_model_get(m, &it, C_PATH, &full, C_NAME, &name, C_KIND, &kind, -1);
|
||||
char cmd[4096];
|
||||
if (upload && kind != 4) skipped++;
|
||||
else if (!upload && kind == 3) skipped++;
|
||||
else {
|
||||
if (upload) snprintf(cmd, sizeof cmd, "put\t%s\t%s", full, remote_dir);
|
||||
else snprintf(cmd, sizeof cmd, "get\t%s\t%s", full, local_dir);
|
||||
push(cmd);
|
||||
}
|
||||
g_free(full); g_free(name);
|
||||
}
|
||||
g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
|
||||
if (skipped) show_toast(upload ? "暂不支持上传文件夹,已跳过" : "不能下载整个磁盘,已跳过");
|
||||
}
|
||||
static void on_cancel_all(GtkButton *b, gpointer d) { (void)b; (void)d; push("cancel"); }
|
||||
static void on_clear_done(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d; GtkTreeIter it; gboolean ok = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(task_store), &it);
|
||||
while (ok) { int done; gtk_tree_model_get(GTK_TREE_MODEL(task_store), &it, T_DONE, &done, -1);
|
||||
ok = done ? gtk_list_store_remove(task_store, &it) : gtk_tree_model_iter_next(GTK_TREE_MODEL(task_store), &it); }
|
||||
}
|
||||
static GtkWidget *pane(int remote) {
|
||||
GtkWidget *card = vbox(6); add_class(card, "card");
|
||||
GtkWidget *bar = hbox(6), *up = button("↑", NULL), *refresh = button("刷新", NULL), *mk = button("新建文件夹", NULL), *path = gtk_entry_new();
|
||||
gtk_widget_set_tooltip_text(up, "上一级"); gtk_widget_set_tooltip_text(refresh, "刷新");
|
||||
gtk_box_pack_start(GTK_BOX(bar), up, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), refresh, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(bar), mk, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), path, TRUE, TRUE, 0);
|
||||
GtkListStore *store = gtk_list_store_new(C_N, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
|
||||
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
|
||||
add_column(view, "名称", C_NAME, 1); add_column(view, "修改日期", C_TIME, 0); add_column(view, "类型", C_TYPE, 0); add_column(view, "大小", C_SIZE, 0);
|
||||
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE);
|
||||
g_signal_connect(view, "row-activated", G_CALLBACK(on_row_activated), GINT_TO_POINTER(remote));
|
||||
g_signal_connect(up, "clicked", G_CALLBACK(remote ? on_remote_up : on_local_up), NULL);
|
||||
g_signal_connect(refresh, "clicked", G_CALLBACK(remote ? on_remote_refresh : on_local_refresh), NULL);
|
||||
g_signal_connect(mk, "clicked", G_CALLBACK(remote ? on_remote_mkdir : on_local_mkdir), NULL);
|
||||
g_signal_connect(path, "activate", G_CALLBACK(remote ? on_remote_path : on_local_path), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(card), bar, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(card), scrolled(view, 300), TRUE, TRUE, 0);
|
||||
if (remote) { remote_store = store; remote_view = view; remote_path = path; }
|
||||
else { local_store = store; local_view = view; local_path = path; }
|
||||
return card;
|
||||
}
|
||||
static void build_files(void) {
|
||||
GtkWidget *content; frame("文件传输", &content);
|
||||
gtk_window_set_default_size(GTK_WINDOW(window), 1100, 760);
|
||||
GtkWidget *head = gtk_grid_new(); gtk_grid_set_column_homogeneous(GTK_GRID(head), TRUE); gtk_grid_set_column_spacing(GTK_GRID(head), 24);
|
||||
GtkWidget *left = hbox(10), *right = hbox(10);
|
||||
char host[256]; if (gethostname(host, sizeof host) != 0) snprintf(host, sizeof host, "本机"); host[sizeof host - 1] = 0;
|
||||
GtkWidget *tag_l = label("本机", "tag"), *tag_r = label("远端", "tag"); add_class(tag_r, "remote");
|
||||
GtkWidget *send_r = button("发送 →", NULL), *send_l = button("← 发送", NULL);
|
||||
g_signal_connect(send_r, "clicked", G_CALLBACK(on_send), GINT_TO_POINTER(1));
|
||||
g_signal_connect(send_l, "clicked", G_CALLBACK(on_send), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(left), label(host, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(left), tag_l, FALSE, FALSE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(left), send_r, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(right), send_l, FALSE, FALSE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(right), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(right), tag_r, FALSE, FALSE, 0);
|
||||
gtk_grid_attach(GTK_GRID(head), left, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(head), right, 1, 0, 1, 1);
|
||||
gtk_grid_attach(GTK_GRID(head), pane(0), 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(head), pane(1), 1, 1, 1, 1);
|
||||
gtk_grid_set_row_spacing(GTK_GRID(head), 14);
|
||||
gtk_box_pack_start(GTK_BOX(content), head, TRUE, TRUE, 0);
|
||||
GtkWidget *tasks = vbox(8); add_class(tasks, "card");
|
||||
GtkWidget *tbar = hbox(8), *cancel = button("全部取消", NULL), *clear = button("清除完结任务", NULL);
|
||||
g_signal_connect(cancel, "clicked", G_CALLBACK(on_cancel_all), NULL); g_signal_connect(clear, "clicked", G_CALLBACK(on_clear_done), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(tbar), label("传输列表", "section"), FALSE, FALSE, 4);
|
||||
gtk_box_pack_end(GTK_BOX(tbar), clear, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(tbar), cancel, FALSE, FALSE, 0);
|
||||
task_store = gtk_list_store_new(T_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
|
||||
GtkWidget *tview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(task_store));
|
||||
add_column(tview, "名称", T_NAME, 1); add_column(tview, "状态", T_STATUS, 0); add_column(tview, "大小", T_SIZE, 0);
|
||||
add_column(tview, "发送路径", T_FROM, 1); add_column(tview, "接收路径", T_TO, 1);
|
||||
gtk_box_pack_start(GTK_BOX(tasks), tbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(tasks), scrolled(tview, 180), TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(content), tasks, TRUE, TRUE, 0);
|
||||
const char *home = g_get_home_dir(); load_local(home ? home : "/");
|
||||
gtk_entry_set_text(GTK_ENTRY(remote_path), "此电脑");
|
||||
}
|
||||
|
||||
struct listing { char *path; char *rows; };
|
||||
static gboolean remote_idle(gpointer d) {
|
||||
struct listing *l = d;
|
||||
snprintf(remote_dir, sizeof remote_dir, "%s", l->path);
|
||||
gtk_entry_set_text(GTK_ENTRY(remote_path), strcmp(remote_dir, ":/") ? remote_dir : "此电脑");
|
||||
gtk_list_store_clear(remote_store);
|
||||
char **lines = g_strsplit(l->rows, "\n", -1);
|
||||
for (char **line = lines; *line; line++) {
|
||||
char **f = g_strsplit(*line, "\t", 5);
|
||||
if (g_strv_length(f) == 5) {
|
||||
int kind = atoi(f[0]); char size[32], when[64];
|
||||
format_size(g_ascii_strtoull(f[2], NULL, 10), kind, size, sizeof size); format_time(g_ascii_strtoull(f[3], NULL, 10), when, sizeof when);
|
||||
GtkTreeIter it; gtk_list_store_append(remote_store, &it);
|
||||
gtk_list_store_set(remote_store, &it, C_NAME, f[1], C_TIME, when, C_TYPE, kind_name(kind), C_SIZE, size, C_PATH, f[4], C_KIND, kind, -1);
|
||||
}
|
||||
g_strfreev(f);
|
||||
}
|
||||
g_strfreev(lines); g_free(l->path); g_free(l->rows); g_free(l);
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
/* rows: "kind\tname\tsize\tmodified\tpath\n" */
|
||||
void uu_files_ui_set_remote(const char *path, const char *rows) {
|
||||
struct listing *l = g_new0(struct listing, 1); l->path = g_strdup(path); l->rows = g_strdup(rows); g_idle_add(remote_idle, l);
|
||||
}
|
||||
struct task { int id, done; char *name, *status, *size, *from, *to; };
|
||||
static gboolean task_idle(gpointer d) {
|
||||
struct task *t = d; GtkTreeIter it; gboolean ok = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(task_store), &it), found = FALSE;
|
||||
while (ok) { int id; gtk_tree_model_get(GTK_TREE_MODEL(task_store), &it, T_ID, &id, -1); if (id == t->id) { found = TRUE; break; } ok = gtk_tree_model_iter_next(GTK_TREE_MODEL(task_store), &it); }
|
||||
if (!found) { gtk_list_store_append(task_store, &it); gtk_list_store_set(task_store, &it, T_ID, t->id, T_NAME, t->name, -1); }
|
||||
gtk_list_store_set(task_store, &it, T_STATUS, t->status, T_SIZE, t->size, T_FROM, t->from, T_TO, t->to, T_DONE, t->done, -1);
|
||||
g_free(t->name); g_free(t->status); g_free(t->size); g_free(t->from); g_free(t->to); g_free(t);
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
/* total == 0 means unknown size; done: 0 running/queued, 1 finished (success), 2 finished (failed/canceled). */
|
||||
void uu_files_ui_task(int id, const char *name, const char *status, unsigned long long transferred, unsigned long long total, const char *from, const char *to, int done) {
|
||||
struct task *t = g_new0(struct task, 1); char a[32], b[32];
|
||||
t->id = id; t->done = done;
|
||||
format_size(transferred, 4, a, sizeof a); format_size(total, 4, b, sizeof b);
|
||||
t->name = g_strdup(name); t->status = g_strdup(status); t->from = g_strdup(from); t->to = g_strdup(to);
|
||||
t->size = total ? g_strdup_printf("%s / %s", a, b) : g_strdup(transferred ? a : "--");
|
||||
g_idle_add(task_idle, t);
|
||||
}
|
||||
static gboolean refresh_local_idle(gpointer d) { (void)d; load_local(local_dir); return G_SOURCE_REMOVE; }
|
||||
void uu_files_ui_refresh_local(void) { g_idle_add(refresh_local_idle, NULL); }
|
||||
|
||||
/* ---------------- port mapping ---------------- */
|
||||
enum { P_ID, P_NAME, P_LOCAL, P_TARGET, P_STATUS, P_N };
|
||||
static GtkListStore *rule_store;
|
||||
static GtkWidget *rule_stack;
|
||||
static void on_add_rule(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d;
|
||||
GtkWidget *dlg = gtk_dialog_new_with_buttons("添加映射规则", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "保存后立即启用", GTK_RESPONSE_OK, NULL);
|
||||
GtkWidget *grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 12); gtk_grid_set_column_spacing(GTK_GRID(grid), 24);
|
||||
gtk_container_set_border_width(GTK_CONTAINER(grid), 20);
|
||||
const char *labels[] = {"名称", "本地端口", "目标地址", "目标端口"}, *hints[] = {"名称", "请输入端口", "", "请输入端口"};
|
||||
GtkWidget *entries[4];
|
||||
for (int i = 0; i < 4; i++) {
|
||||
entries[i] = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entries[i]), hints[i]); gtk_widget_set_hexpand(entries[i], TRUE);
|
||||
gtk_grid_attach(GTK_GRID(grid), label(labels[i], NULL), 0, i, 1, 1); gtk_grid_attach(GTK_GRID(grid), entries[i], 1, i, 1, 1);
|
||||
}
|
||||
gtk_entry_set_text(GTK_ENTRY(entries[2]), "127.0.0.1");
|
||||
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), grid, TRUE, TRUE, 0);
|
||||
gtk_window_set_default_size(GTK_WINDOW(dlg), 480, -1); gtk_widget_show_all(dlg);
|
||||
while (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
|
||||
const char *name = gtk_entry_get_text(GTK_ENTRY(entries[0])), *host = gtk_entry_get_text(GTK_ENTRY(entries[2]));
|
||||
char *end; long local = strtol(gtk_entry_get_text(GTK_ENTRY(entries[1])), &end, 10); int bad_local = *end || local < 0 || local > 65535;
|
||||
long port = strtol(gtk_entry_get_text(GTK_ENTRY(entries[3])), &end, 10); int bad_port = *end || port < 1 || port > 65535;
|
||||
if (!*name || strchr(name, '\t') || !*host || strchr(host, '\t') || bad_local || bad_port) { show_toast("请填写名称、有效端口和目标地址"); continue; }
|
||||
char cmd[1024]; snprintf(cmd, sizeof cmd, "add\t%s\t%ld\t%s\t%ld", name, local, host, port); push(cmd);
|
||||
break;
|
||||
}
|
||||
gtk_widget_destroy(dlg);
|
||||
}
|
||||
static void on_remove_rule(GtkButton *b, gpointer view) {
|
||||
(void)b; GtkTreeModel *m; GtkTreeIter it;
|
||||
if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(view), &m, &it)) { show_toast("请先选择一条规则"); return; }
|
||||
int id; gtk_tree_model_get(m, &it, P_ID, &id, -1); char cmd[64]; snprintf(cmd, sizeof cmd, "remove\t%d", id); push(cmd);
|
||||
}
|
||||
static void build_portmap(void) {
|
||||
GtkWidget *content; frame("端口映射", &content);
|
||||
gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
|
||||
GtkWidget *head = hbox(12), *add = button("添加规则", "primary"), *del = button("删除", NULL);
|
||||
GtkWidget *dot = label("● 已连接", "online");
|
||||
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), dot, FALSE, FALSE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(head), add, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), del, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
|
||||
rule_store = gtk_list_store_new(P_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
|
||||
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rule_store));
|
||||
add_column(view, "名称", P_NAME, 1); add_column(view, "本地地址", P_LOCAL, 0); add_column(view, "目标地址", P_TARGET, 1); add_column(view, "状态", P_STATUS, 0);
|
||||
rule_stack = gtk_stack_new();
|
||||
GtkWidget *empty = label("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
|
||||
gtk_stack_add_named(GTK_STACK(rule_stack), empty, "empty");
|
||||
gtk_stack_add_named(GTK_STACK(rule_stack), scrolled(view, 360), "list");
|
||||
GtkWidget *card = vbox(0); add_class(card, "card"); gtk_box_pack_start(GTK_BOX(card), rule_stack, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(content), card, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(content), label("本地端口只监听 127.0.0.1;本地端口填 0 时自动分配。", "empty"), FALSE, FALSE, 0);
|
||||
g_signal_connect(add, "clicked", G_CALLBACK(on_add_rule), NULL);
|
||||
g_signal_connect(del, "clicked", G_CALLBACK(on_remove_rule), view);
|
||||
}
|
||||
static gboolean rules_idle(gpointer d) {
|
||||
char *rows = d; gtk_list_store_clear(rule_store); int n = 0;
|
||||
char **lines = g_strsplit(rows, "\n", -1);
|
||||
for (char **line = lines; *line; line++) {
|
||||
char **f = g_strsplit(*line, "\t", 5);
|
||||
if (g_strv_length(f) == 5) { GtkTreeIter it; gtk_list_store_append(rule_store, &it);
|
||||
gtk_list_store_set(rule_store, &it, P_ID, atoi(f[0]), P_NAME, f[1], P_LOCAL, f[2], P_TARGET, f[3], P_STATUS, f[4], -1); n++; }
|
||||
g_strfreev(f);
|
||||
}
|
||||
g_strfreev(lines); g_free(rows);
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(rule_stack), n ? "list" : "empty");
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
/* rows: "id\tname\tlocal\ttarget\tstatus\n" */
|
||||
void uu_portmap_ui_set_rules(const char *rows) { g_idle_add(rules_idle, g_strdup(rows)); }
|
||||
|
||||
/* ---------------- terminal sessions ---------------- */
|
||||
enum { S_ID, S_SHELL, S_TIME, S_STATE, S_N };
|
||||
static GtkListStore *session_store;
|
||||
static GtkWidget *session_view, *session_stack, *session_dot, *session_create, *session_kill;
|
||||
static guint selected_session(void) {
|
||||
GtkTreeModel *m; GtkTreeIter it; guint id = 0;
|
||||
if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(session_view)), &m, &it)) gtk_tree_model_get(m, &it, S_ID, &id, -1);
|
||||
return id;
|
||||
}
|
||||
static void on_create_session(GtkButton *b, gpointer d) { (void)b; (void)d; push("create"); }
|
||||
static void on_open_session(GtkTreeView *v, GtkTreePath *path, GtkTreeViewColumn *col, gpointer d) {
|
||||
(void)col; (void)d; GtkTreeIter it; guint id;
|
||||
if (!gtk_widget_get_sensitive(GTK_WIDGET(v)) || !gtk_tree_model_get_iter(GTK_TREE_MODEL(session_store), &it, path)) return;
|
||||
gtk_tree_model_get(GTK_TREE_MODEL(session_store), &it, S_ID, &id, -1);
|
||||
char cmd[64]; snprintf(cmd, sizeof cmd, "open\t%u", id); push(cmd);
|
||||
}
|
||||
static void on_kill_session(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d; guint id = selected_session();
|
||||
if (!id) { show_toast("请先选择一个会话"); return; }
|
||||
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
|
||||
GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定结束会话 %u?", id);
|
||||
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dlg), "会话内正在运行的程序将被终止。");
|
||||
gtk_dialog_add_buttons(GTK_DIALOG(dlg), "取消", GTK_RESPONSE_CANCEL, "结束会话", GTK_RESPONSE_OK, NULL);
|
||||
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_CANCEL);
|
||||
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { char cmd[64]; snprintf(cmd, sizeof cmd, "kill\t%u", id); push(cmd); }
|
||||
gtk_widget_destroy(dlg);
|
||||
}
|
||||
static void build_terminal(void) {
|
||||
GtkWidget *content; frame("终端远控", &content); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
|
||||
GtkWidget *head = hbox(12); session_dot = label("● 正在读取会话", "online");
|
||||
session_create = button("创建会话", "primary"); session_kill = button("结束会话", NULL);
|
||||
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(head), session_dot, FALSE, FALSE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(head), session_create, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), session_kill, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
|
||||
session_store = gtk_list_store_new(S_N, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
|
||||
session_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(session_store));
|
||||
add_column(session_view, "会话 ID", S_ID, 0); add_column(session_view, "Shell", S_SHELL, 1);
|
||||
add_column(session_view, "创建时间", S_TIME, 0); add_column(session_view, "状态", S_STATE, 0);
|
||||
session_stack = gtk_stack_new();
|
||||
GtkWidget *empty = label("当前无正在运行的终端会话", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
|
||||
gtk_stack_add_named(GTK_STACK(session_stack), empty, "empty");
|
||||
gtk_stack_add_named(GTK_STACK(session_stack), label("正在读取会话…", "empty"), "loading");
|
||||
gtk_stack_add_named(GTK_STACK(session_stack), label("连接已断开,请关闭窗口后重试", "empty"), "offline");
|
||||
gtk_stack_add_named(GTK_STACK(session_stack), scrolled(session_view, 360), "list");
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), "loading");
|
||||
gtk_box_pack_start(GTK_BOX(content), session_stack, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(content), label("双击接回会话;创建会话将在本机终端程序中打开。", "empty"), FALSE, FALSE, 0);
|
||||
gtk_widget_set_sensitive(session_create, FALSE); gtk_widget_set_sensitive(session_kill, FALSE);
|
||||
g_signal_connect(session_create, "clicked", G_CALLBACK(on_create_session), NULL);
|
||||
g_signal_connect(session_kill, "clicked", G_CALLBACK(on_kill_session), NULL);
|
||||
g_signal_connect(session_view, "row-activated", G_CALLBACK(on_open_session), NULL);
|
||||
}
|
||||
struct sessions { char *rows; int connected; };
|
||||
static gboolean sessions_idle(gpointer d) {
|
||||
struct sessions *s = d;
|
||||
if (atomic_load(&closed)) { g_free(s->rows); g_free(s); return G_SOURCE_REMOVE; }
|
||||
guint selected = selected_session(); gtk_list_store_clear(session_store); int n = 0;
|
||||
char **lines = g_strsplit(s->rows, "\n", -1);
|
||||
for (char **line = lines; *line; line++) {
|
||||
char **f = g_strsplit(*line, "\t", 4);
|
||||
if (g_strv_length(f) == 4) {
|
||||
guint id = (guint)g_ascii_strtoull(f[0], NULL, 10); GtkTreeIter it; char date[64] = "--";
|
||||
gint64 ms = g_ascii_strtoll(f[2], NULL, 10);
|
||||
GDateTime *time = ms > 0 ? g_date_time_new_from_unix_local(ms / 1000) : NULL;
|
||||
if (time) { char *text = g_date_time_format(time, "%Y-%m-%d %H:%M:%S"); g_strlcpy(date, text, sizeof date); g_free(text); g_date_time_unref(time); }
|
||||
gtk_list_store_append(session_store, &it);
|
||||
gtk_list_store_set(session_store, &it, S_ID, id, S_SHELL, f[1], S_TIME, date, S_STATE, f[3], -1); n++;
|
||||
if (id == selected) gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(session_view)), &it);
|
||||
}
|
||||
g_strfreev(f);
|
||||
}
|
||||
g_strfreev(lines);
|
||||
gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? "● 已连接" : "● 已断开");
|
||||
gtk_widget_set_sensitive(session_create, s->connected); gtk_widget_set_sensitive(session_kill, s->connected);
|
||||
gtk_widget_set_sensitive(session_view, s->connected);
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), s->connected ? (n ? "list" : "empty") : "offline");
|
||||
g_free(s->rows); g_free(s); return G_SOURCE_REMOVE;
|
||||
}
|
||||
/* rows: "id\tshell\tcreated_at_ms\tstate\n"; copied before returning to Rust. */
|
||||
void uu_terminal_ui_set(const char *rows, int connected) {
|
||||
struct sessions *s = g_new0(struct sessions, 1); s->rows = g_strdup(rows); s->connected = connected; g_idle_add(sessions_idle, s);
|
||||
}
|
||||
|
||||
/* ---------------- startup ---------------- */
|
||||
static char tool_kind[16];
|
||||
static gboolean show_window(gpointer d) {
|
||||
(void)d;
|
||||
if (!window) {
|
||||
if (!strcmp(tool_kind, "files")) build_files(); else if (!strcmp(tool_kind, "terminal")) build_terminal(); else build_portmap();
|
||||
}
|
||||
atomic_store(&closed, 0); gtk_widget_show_all(window); gtk_window_present(GTK_WINDOW(window));
|
||||
pthread_mutex_lock(&init_lock); init_state = 1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
static void *ui_thread(void *d) {
|
||||
(void)d;
|
||||
if (!gtk_init_check(NULL, NULL)) { pthread_mutex_lock(&init_lock); init_state = -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); return NULL; }
|
||||
// Light palette in CSS; keep a dark system theme from making unstyled text white on white (#43).
|
||||
g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
|
||||
show_window(NULL); gtk_main(); return NULL;
|
||||
}
|
||||
/* Hidden windows retain their widgets so queued idle callbacks stay valid. */
|
||||
int uu_tools_ui_start(const char *kind, const char *name) {
|
||||
static int started;
|
||||
pthread_mutex_lock(&init_lock); if (init_state < 0) { pthread_mutex_unlock(&init_lock); return -1; } init_state = 0;
|
||||
snprintf(tool_kind, sizeof tool_kind, "%s", kind); snprintf(remote_name, sizeof remote_name, "%s", name);
|
||||
pthread_mutex_lock(&q_lock); q_head = q_len = 0; pthread_mutex_unlock(&q_lock);
|
||||
if (!started) {
|
||||
pthread_t t; if (pthread_create(&t, NULL, ui_thread, NULL) != 0) { pthread_mutex_unlock(&init_lock); return -1; }
|
||||
pthread_detach(t); started = 1;
|
||||
} else g_idle_add(show_window, NULL);
|
||||
while (!init_state) pthread_cond_wait(&init_cond, &init_lock);
|
||||
int s = init_state; pthread_mutex_unlock(&init_lock); return s == 1 ? 0 : -1;
|
||||
}
|
||||
static gboolean hide_window(gpointer d) { (void)d; if (window) gtk_widget_hide(window); atomic_store(&closed, 1); return G_SOURCE_REMOVE; }
|
||||
void uu_tools_ui_hide(void) { g_idle_add(hide_window, NULL); }
|
||||
void uu_tools_ui_present(void) { pthread_mutex_lock(&init_lock); if (init_state == 1) g_idle_add(show_window, NULL); pthread_mutex_unlock(&init_lock); }
|
||||
@@ -0,0 +1,731 @@
|
||||
// GTK3 launcher window for the experimental native viewer (`uuremote-viewer ui`). Layout follows the
|
||||
// official client's screens (see analysis notes: sidebar, device page, all devices, assistance,
|
||||
// favorites, settings, QR sign-in, sign-out confirmation) without any NetEase assets. GTK runs on
|
||||
// its own thread; Rust pushes state through g_idle_add and polls user commands. Account data is
|
||||
// shown only in this local window and never logged.
|
||||
#include <gtk/gtk.h>
|
||||
#include <pthread.h>
|
||||
#include <stdatomic.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
static const char *CSS =
|
||||
"window { background-color: #ffffff; }\n"
|
||||
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
|
||||
".sidebar { background-color: #e9e9ec; }\n"
|
||||
".section { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
|
||||
".sidebar list, .sidebar row { background-color: transparent; }\n"
|
||||
".sidebar row { border-radius: 8px; margin: 1px 10px; padding: 8px 10px; }\n"
|
||||
".sidebar row:selected { background-color: #d4d4d9; color: #1d1d1f; }\n"
|
||||
".devname { font-size: 15px; color: #1d1d1f; }\n"
|
||||
".offline { color: #9ca3af; }\n"
|
||||
".dot { color: #22c55e; font-size: 10px; }\n"
|
||||
".dot.off { color: transparent; }\n"
|
||||
".icon { background-color: #2f7bff; color: #ffffff; border-radius: 6px; font-size: 11px; font-weight: 700; padding: 2px 5px; }\n"
|
||||
".icon.off { background-color: #c4c7cf; }\n"
|
||||
".tag { background-color: #e8f0ff; color: #2f6bff; border-radius: 4px; font-size: 12px; padding: 1px 6px; }\n"
|
||||
".title { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
|
||||
".header { border-bottom: 1px solid #e5e7eb; padding: 12px 22px; background-color: #f7f7f8; }\n"
|
||||
".badge { background-color: #1d1d1f; color: #ffffff; border-radius: 12px; padding: 3px 12px; font-size: 13px; }\n"
|
||||
".badge.off { background-color: #9ca3af; }\n"
|
||||
".hbtn { background-image: none; background-color: transparent; border: none; font-size: 17px; color: #4b5563; padding: 4px 10px; }\n"
|
||||
".preview { background-image: linear-gradient(135deg, #a8c0ff 0%, #e2c2f2 50%, #f6c8a8 100%); border-radius: 12px 12px 0 0; }\n"
|
||||
".enter { background-image: none; background-color: rgba(0,0,0,0.18); color: #ffffff; border: none; font-size: 19px; padding: 8px 20px; border-radius: 8px; }\n"
|
||||
".toolbar { border: 1px solid #e5e7eb; border-top: none; border-radius: 0 0 12px 12px; padding: 4px; }\n"
|
||||
".tool { background-image: none; background-color: transparent; border: none; font-size: 15px; color: #374151; padding: 10px; }\n"
|
||||
".dashed { border: 1px dashed #d1d5db; border-radius: 12px; padding: 36px; }\n"
|
||||
".round { background-image: none; background-color: #f3f4f6; border: none; border-radius: 40px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
|
||||
".card { background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
|
||||
".cardbtn { background-image: none; background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 12px 16px; }\n"
|
||||
".banner { background-color: #f7f8fa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
|
||||
".group { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
|
||||
".h2 { font-size: 19px; font-weight: 700; color: #1d1d1f; }\n"
|
||||
".big { font-size: 30px; font-weight: 800; color: #111111; }\n"
|
||||
".hint { font-size: 14px; color: #6b7280; }\n"
|
||||
".primary { background-image: none; background-color: #3b82f6; color: #ffffff; border: none; border-radius: 8px; font-size: 16px; padding: 8px 26px; }\n"
|
||||
".secondary { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db; border-radius: 8px; padding: 6px 16px; }\n"
|
||||
".qrbox { background-color: #ffffff; border-radius: 12px; border: 1px solid #e5e7eb; padding: 14px; }\n"
|
||||
".status { font-size: 13px; color: #2f6bff; }\n"
|
||||
".toast { background-color: #ffffff; border: 1px solid #e5e7eb; border-radius: 10px; padding: 10px 18px; font-size: 15px; }\n";
|
||||
|
||||
typedef struct { char id[64]; char name[128]; int platform, online, current; } Device;
|
||||
static Device devices[64];
|
||||
static int device_count;
|
||||
static char queue[16][200];
|
||||
static int q_head, q_len;
|
||||
static pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_mutex_t d_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static atomic_int closed;
|
||||
static pthread_t ui_thread;
|
||||
static int ui_started, init_state;
|
||||
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
|
||||
|
||||
static GtkWidget *assist_list;
|
||||
static GtkWidget *window, *stack, *title_label, *badge, *more_button, *device_list, *my_section, *all_box,
|
||||
*qr_image, *status_label, *toast, *banner, *fav_stack, *settings_window;
|
||||
static int logged_in, selected = -1, banner_closed;
|
||||
static char qr_path[512], status_text[256], user_text[128];
|
||||
|
||||
static int push(const char *cmd) {
|
||||
pthread_mutex_lock(&q_lock);
|
||||
int accepted = q_len < 16;
|
||||
if (accepted) { snprintf(queue[(q_head + q_len) % 16], sizeof queue[0], "%s", cmd); q_len++; }
|
||||
pthread_mutex_unlock(&q_lock);
|
||||
return accepted;
|
||||
}
|
||||
static void add_class(GtkWidget *w, const char *cls) { gtk_style_context_add_class(gtk_widget_get_style_context(w), cls); }
|
||||
static GtkWidget *label(const char *text, const char *cls) {
|
||||
GtkWidget *l = gtk_label_new(text);
|
||||
if (cls) add_class(l, cls);
|
||||
gtk_label_set_xalign(GTK_LABEL(l), 0);
|
||||
gtk_label_set_line_wrap(GTK_LABEL(l), TRUE);
|
||||
return l;
|
||||
}
|
||||
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
|
||||
static GtkWidget *hbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, spacing); }
|
||||
static GtkWidget *vbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing); }
|
||||
static GtkWidget *platform_icon(int platform, int online) {
|
||||
GtkWidget *i = gtk_label_new(platform == 4 ? "Mac" : platform == 1 ? "Win" : "PC");
|
||||
add_class(i, "icon"); if (!online) add_class(i, "off");
|
||||
return i;
|
||||
}
|
||||
static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; }
|
||||
static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); }
|
||||
static void unsupported(GtkButton *b, gpointer what) { (void)b; char t[128]; snprintf(t, sizeof t, "%s:暂未支持", (const char *)what); show_toast(t); }
|
||||
|
||||
static void connect_kind(const char *kind) {
|
||||
if (selected < 0) return;
|
||||
char cmd[200];
|
||||
pthread_mutex_lock(&d_lock);
|
||||
snprintf(cmd, sizeof cmd, "connect\t%s\t%s", devices[selected].id, kind);
|
||||
pthread_mutex_unlock(&d_lock);
|
||||
push(cmd);
|
||||
if (!strcmp(kind, "desktop") || !strcmp(kind, "watch")) show_toast("正在连接…");
|
||||
}
|
||||
static void on_tool(GtkButton *b, gpointer kind);
|
||||
static void more_item(GtkButton *b, gpointer kind) {
|
||||
GtkWidget *dialog = gtk_widget_get_toplevel(GTK_WIDGET(b));
|
||||
const char *k = kind;
|
||||
if (!strcmp(k, "reboot") || !strcmp(k, "shutdown")) {
|
||||
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
|
||||
!strcmp(k, "reboot") ? "确定要重启被控电脑吗?" : "确定要关闭被控电脑吗?");
|
||||
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "远程会话会断开。");
|
||||
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "确认", GTK_RESPONSE_OK, NULL);
|
||||
int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d);
|
||||
if (ok) { connect_kind(k); show_toast("正在发送电源指令…"); }
|
||||
return;
|
||||
}
|
||||
if (!strcmp(k, "unbind")) {
|
||||
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
|
||||
"确定要从账号中删除该设备吗?");
|
||||
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "删除后需要在该设备上重新登录才能再次远控。");
|
||||
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "删除", GTK_RESPONSE_OK, NULL);
|
||||
int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d);
|
||||
if (ok) { gtk_widget_destroy(dialog); connect_kind(k); show_toast("正在删除设备…"); }
|
||||
return;
|
||||
}
|
||||
gtk_widget_destroy(dialog);
|
||||
on_tool(NULL, kind);
|
||||
}
|
||||
static void open_more(void) {
|
||||
GtkWidget *dialog = gtk_dialog_new_with_buttons("更多工具", GTK_WINDOW(window), GTK_DIALOG_MODAL, NULL, NULL);
|
||||
gtk_window_set_default_size(GTK_WINDOW(dialog), 520, -1);
|
||||
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10);
|
||||
gtk_container_set_border_width(GTK_CONTAINER(box), 22);
|
||||
gtk_box_pack_start(GTK_BOX(box), label("更多工具", "h2"), FALSE, FALSE, 6);
|
||||
const char *names[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "⏻ 远程开机", "↻ 重启", "⏻ 关机", "🗑 删除设备"};
|
||||
const char *kinds[] = {"file", "watch", "terminal", "portmap", "wol", "reboot", "shutdown", "unbind"};
|
||||
for (int i = 0; i < 8; i++) {
|
||||
GtkWidget *b = gtk_button_new(), *line = hbox(10); add_class(b, "cardbtn");
|
||||
gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(b), line);
|
||||
if (i == 4) gtk_widget_set_sensitive(b, FALSE); // 远程开机 is greyed for devices without Wake-on-LAN
|
||||
else g_signal_connect(b, "clicked", G_CALLBACK(more_item), (gpointer)kinds[i]);
|
||||
gtk_box_pack_start(GTK_BOX(box), b, FALSE, FALSE, 0);
|
||||
}
|
||||
GtkWidget *foot = hbox(10), *order = button("调整顺序", "secondary"), *close = button("关闭", "secondary");
|
||||
g_signal_connect(order, "clicked", G_CALLBACK(unsupported), "调整顺序");
|
||||
g_signal_connect_swapped(close, "clicked", G_CALLBACK(gtk_widget_destroy), dialog);
|
||||
gtk_box_pack_start(GTK_BOX(foot), order, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(foot), close, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(box), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 8);
|
||||
gtk_box_pack_start(GTK_BOX(box), foot, FALSE, FALSE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(area), box);
|
||||
gtk_widget_show_all(dialog);
|
||||
}
|
||||
static void on_tool(GtkButton *b, gpointer kind) {
|
||||
(void)b;
|
||||
if (!strcmp(kind, "more")) open_more();
|
||||
else if (!strcmp(kind, "wol") || !strcmp(kind, "reboot") || !strcmp(kind, "shutdown"))
|
||||
unsupported(NULL, (gpointer)(!strcmp(kind, "wol") ? "远程开机" : !strcmp(kind, "reboot") ? "重启" : "关机"));
|
||||
else connect_kind(kind);
|
||||
}
|
||||
static void on_login(GtkButton *b, gpointer d) { (void)b; (void)d; push("login"); gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); gtk_label_set_text(GTK_LABEL(title_label), "登录"); }
|
||||
|
||||
static void set_header(const char *title, int device_page) {
|
||||
gtk_label_set_text(GTK_LABEL(title_label), title);
|
||||
gtk_widget_set_visible(badge, device_page); gtk_widget_set_visible(more_button, device_page);
|
||||
}
|
||||
static void show_page(const char *name, const char *title) {
|
||||
int need_login = strcmp(name, "assist") && strcmp(name, "login");
|
||||
if (!logged_in && need_login) { set_header("全部设备", 0); gtk_stack_set_visible_child_name(GTK_STACK(stack), "welcome"); return; }
|
||||
set_header(title, 0);
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(stack), name);
|
||||
}
|
||||
static void show_device(int index) {
|
||||
pthread_mutex_lock(&d_lock);
|
||||
if (index < 0 || index >= device_count) { pthread_mutex_unlock(&d_lock); return; }
|
||||
selected = index;
|
||||
char name[128]; snprintf(name, sizeof name, "%s", devices[index].name);
|
||||
int online = devices[index].online;
|
||||
pthread_mutex_unlock(&d_lock);
|
||||
set_header(name, 1);
|
||||
gtk_label_set_markup(GTK_LABEL(badge), online ? "<span foreground='#22c55e'>●</span> 在线" : "离线");
|
||||
GtkStyleContext *ctx = gtk_widget_get_style_context(badge);
|
||||
if (online) gtk_style_context_remove_class(ctx, "off"); else gtk_style_context_add_class(ctx, "off");
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(stack), "device");
|
||||
}
|
||||
static void on_row(GtkListBox *box, GtkListBoxRow *row, gpointer d) {
|
||||
(void)d;
|
||||
if (!row) return;
|
||||
// The two sidebar lists act as one selection.
|
||||
gtk_list_box_unselect_all(GTK_LIST_BOX(box == GTK_LIST_BOX(device_list) ? assist_list : device_list));
|
||||
const char *kind = g_object_get_data(G_OBJECT(row), "kind");
|
||||
if (!kind) { show_device(GPOINTER_TO_INT(g_object_get_data(G_OBJECT(row), "index"))); return; }
|
||||
if (!strcmp(kind, "all")) show_page("all", "全部设备");
|
||||
else if (!strcmp(kind, "assist")) show_page("assist", "远程协助");
|
||||
else if (!strcmp(kind, "favorite")) show_page("favorite", "收藏设备");
|
||||
}
|
||||
static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTER_TO_INT(index)); }
|
||||
|
||||
static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) {
|
||||
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(10);
|
||||
gtk_box_pack_start(GTK_BOX(line), label(icon, "devname"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(line), label(text, "devname"), TRUE, TRUE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(row), line);
|
||||
g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free);
|
||||
return row;
|
||||
}
|
||||
static void clear(GtkWidget *container) {
|
||||
GList *children = gtk_container_get_children(GTK_CONTAINER(container));
|
||||
for (GList *c = children; c; c = c->next) gtk_widget_destroy(c->data);
|
||||
g_list_free(children);
|
||||
}
|
||||
|
||||
// ---- device info dialog (设备信息) ----
|
||||
static void on_info(GtkButton *b, gpointer index) {
|
||||
(void)b;
|
||||
int i = GPOINTER_TO_INT(index);
|
||||
char name[128] = "";
|
||||
pthread_mutex_lock(&d_lock); if (i >= 0 && i < device_count) snprintf(name, sizeof name, "%s", devices[i].name); pthread_mutex_unlock(&d_lock);
|
||||
GtkWidget *dialog = gtk_dialog_new_with_buttons("设备信息", GTK_WINDOW(window), GTK_DIALOG_MODAL, "完成", GTK_RESPONSE_OK, NULL);
|
||||
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(12);
|
||||
gtk_container_set_border_width(GTK_CONTAINER(box), 20);
|
||||
GtkWidget *c1 = vbox(8); add_class(c1, "card");
|
||||
GtkWidget *r = hbox(8); gtk_box_pack_start(GTK_BOX(r), label("名称", "devname"), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(r), label(name, "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(c1), r, FALSE, FALSE, 0);
|
||||
GtkWidget *rename = button("重命名", "secondary"); gtk_widget_set_halign(rename, GTK_ALIGN_END);
|
||||
g_signal_connect(rename, "clicked", G_CALLBACK(unsupported), "重命名");
|
||||
gtk_box_pack_start(GTK_BOX(c1), rename, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(box), c1, FALSE, FALSE, 0);
|
||||
GtkWidget *c2 = vbox(10); add_class(c2, "card");
|
||||
const char *rows[] = {"处理器", "网卡", "总内存", "系统版本", "显卡"};
|
||||
for (int k = 0; k < 5; k++) {
|
||||
GtkWidget *line = hbox(8);
|
||||
gtk_box_pack_start(GTK_BOX(line), label(rows[k], "devname"), TRUE, TRUE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(line), label("—", "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(c2), line, FALSE, FALSE, 0);
|
||||
}
|
||||
gtk_box_pack_start(GTK_BOX(box), c2, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(box), label("硬件信息暂未获取。", "hint"), FALSE, FALSE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(area), box);
|
||||
gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog);
|
||||
}
|
||||
static void on_more(GtkButton *b, gpointer d) { (void)b; (void)d; on_info(NULL, GINT_TO_POINTER(selected)); }
|
||||
|
||||
static gboolean apply_devices(gpointer d) {
|
||||
(void)d;
|
||||
clear(device_list); clear(all_box);
|
||||
pthread_mutex_lock(&d_lock);
|
||||
if (!banner_closed) gtk_widget_show_all(banner);
|
||||
char group[64]; snprintf(group, sizeof group, "⌄ 电脑 %d", device_count);
|
||||
gtk_box_pack_start(GTK_BOX(all_box), label(group, "group"), FALSE, FALSE, 8);
|
||||
for (int i = 0; i < device_count; i++) {
|
||||
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(8);
|
||||
GtkWidget *dot = gtk_label_new("●"); add_class(dot, "dot"); if (!devices[i].online) add_class(dot, "off");
|
||||
GtkWidget *name = label(devices[i].name, "devname"); if (!devices[i].online) add_class(name, "offline");
|
||||
gtk_label_set_line_wrap(GTK_LABEL(name), FALSE); gtk_label_set_ellipsize(GTK_LABEL(name), PANGO_ELLIPSIZE_END);
|
||||
gtk_box_pack_start(GTK_BOX(line), dot, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(line), platform_icon(devices[i].platform, devices[i].online), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(line), name, TRUE, TRUE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(row), line);
|
||||
g_object_set_data(G_OBJECT(row), "index", GINT_TO_POINTER(i));
|
||||
if (!devices[i].current) gtk_list_box_insert(GTK_LIST_BOX(device_list), row, -1); else gtk_widget_destroy(row);
|
||||
GtkWidget *card = hbox(12); add_class(card, "card");
|
||||
gtk_box_pack_start(GTK_BOX(card), platform_icon(devices[i].platform, 1), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(card), label(devices[i].name, "devname"), FALSE, FALSE, 0);
|
||||
if (devices[i].current) gtk_box_pack_start(GTK_BOX(card), label("本机", "tag"), FALSE, FALSE, 0);
|
||||
GtkWidget *open = button("›", "hbtn"), *info = button("ⓘ", "hbtn");
|
||||
g_signal_connect(info, "clicked", G_CALLBACK(on_info), GINT_TO_POINTER(i));
|
||||
if (!devices[i].current) { g_signal_connect(open, "clicked", G_CALLBACK(on_card), GINT_TO_POINTER(i)); gtk_box_pack_end(GTK_BOX(card), open, FALSE, FALSE, 0); }
|
||||
else gtk_widget_destroy(open);
|
||||
gtk_box_pack_end(GTK_BOX(card), info, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4);
|
||||
}
|
||||
pthread_mutex_unlock(&d_lock);
|
||||
gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("◼", "全部设备", "all"), -1);
|
||||
gtk_widget_show_all(device_list); gtk_widget_show_all(all_box);
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
static gboolean apply_login(gpointer d) {
|
||||
(void)d;
|
||||
gtk_label_set_text(GTK_LABEL(status_label), status_text);
|
||||
if (qr_path[0]) {
|
||||
GdkPixbuf *pix = gdk_pixbuf_new_from_file_at_size(qr_path, 240, 240, NULL);
|
||||
if (pix) { gtk_image_set_from_pixbuf(GTK_IMAGE(qr_image), pix); g_object_unref(pix); }
|
||||
} else gtk_image_clear(GTK_IMAGE(qr_image));
|
||||
gtk_widget_set_visible(my_section, logged_in);
|
||||
const char *page = gtk_stack_get_visible_child_name(GTK_STACK(stack));
|
||||
if (logged_in && (!strcmp(page, "login") || !strcmp(page, "welcome"))) show_page("all", "全部设备");
|
||||
if (!logged_in && strcmp(page, "login") && strcmp(page, "assist")) show_page("welcome", "全部设备");
|
||||
if (!logged_in && qr_path[0]) { gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); set_header("登录", 0); }
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
|
||||
// ---- pages ----
|
||||
static GtkWidget *build_welcome(void) {
|
||||
GtkWidget *page = vbox(22); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER);
|
||||
GtkWidget *art = gtk_event_box_new(); add_class(art, "preview"); gtk_widget_set_size_request(art, 520, 300);
|
||||
gtk_box_pack_start(GTK_BOX(page), art, FALSE, FALSE, 0);
|
||||
GtkWidget *t = label("随时访问个人设备,可用于办公、游戏、文件传输。", "h2"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
|
||||
gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0);
|
||||
GtkWidget *b = button("立即登录", "primary"); gtk_widget_set_halign(b, GTK_ALIGN_CENTER);
|
||||
g_signal_connect(b, "clicked", G_CALLBACK(on_login), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(page), b, FALSE, FALSE, 0);
|
||||
return page;
|
||||
}
|
||||
static GtkWidget *build_login(void) {
|
||||
GtkWidget *page = vbox(16); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER);
|
||||
GtkWidget *brand = label("UU 远程 Linux 控制端(非官方)", "h2"); gtk_widget_set_halign(brand, GTK_ALIGN_CENTER);
|
||||
GtkWidget *t = label("扫码登录", "group"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
|
||||
gtk_box_pack_start(GTK_BOX(page), brand, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0);
|
||||
GtkWidget *box = vbox(0); add_class(box, "qrbox"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER);
|
||||
qr_image = gtk_image_new(); gtk_widget_set_size_request(qr_image, 240, 240);
|
||||
gtk_container_add(GTK_CONTAINER(box), qr_image);
|
||||
gtk_box_pack_start(GTK_BOX(page), box, FALSE, FALSE, 0);
|
||||
GtkWidget *h = label("请使用网易 UU 远程 App 扫一扫\n可快速登录", "hint"); gtk_label_set_justify(GTK_LABEL(h), GTK_JUSTIFY_CENTER); gtk_widget_set_halign(h, GTK_ALIGN_CENTER);
|
||||
gtk_box_pack_start(GTK_BOX(page), h, FALSE, FALSE, 0);
|
||||
status_label = label("", "status"); gtk_widget_set_halign(status_label, GTK_ALIGN_CENTER);
|
||||
gtk_box_pack_start(GTK_BOX(page), status_label, FALSE, FALSE, 0);
|
||||
GtkWidget *again = button("刷新二维码", "secondary"); gtk_widget_set_halign(again, GTK_ALIGN_CENTER);
|
||||
g_signal_connect(again, "clicked", G_CALLBACK(on_login), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(page), again, FALSE, FALSE, 0);
|
||||
return page;
|
||||
}
|
||||
static GtkWidget *build_device(void) {
|
||||
GtkWidget *page = vbox(0); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
|
||||
GtkWidget *preview = gtk_overlay_new(), *bg = gtk_event_box_new(); add_class(bg, "preview"); gtk_widget_set_size_request(bg, -1, 320);
|
||||
gtk_container_add(GTK_CONTAINER(preview), bg);
|
||||
GtkWidget *enter = button("进入桌面 →", "enter");
|
||||
gtk_widget_set_halign(enter, GTK_ALIGN_CENTER); gtk_widget_set_valign(enter, GTK_ALIGN_END); gtk_widget_set_margin_bottom(enter, 26);
|
||||
g_signal_connect(enter, "clicked", G_CALLBACK(on_tool), "desktop");
|
||||
gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter);
|
||||
gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0);
|
||||
GtkWidget *tools = hbox(0); add_class(tools, "toolbar");
|
||||
const char *names[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "▦"}, *kinds[] = {"file", "watch", "terminal", "portmap", "more"};
|
||||
for (int i = 0; i < 5; i++) {
|
||||
GtkWidget *b = button(names[i], "tool");
|
||||
g_signal_connect(b, "clicked", G_CALLBACK(on_tool), (gpointer)kinds[i]);
|
||||
gtk_box_pack_start(GTK_BOX(tools), b, i < 4, TRUE, 0);
|
||||
if (i < 4) gtk_box_pack_start(GTK_BOX(tools), gtk_separator_new(GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
|
||||
}
|
||||
gtk_box_pack_start(GTK_BOX(page), tools, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(page), label("快速启动", "h2"), FALSE, FALSE, 22);
|
||||
GtkWidget *quick = vbox(10); add_class(quick, "dashed");
|
||||
GtkWidget *add = button("+", "round"); gtk_widget_set_halign(add, GTK_ALIGN_CENTER);
|
||||
g_signal_connect(add, "clicked", G_CALLBACK(unsupported), "快速启动");
|
||||
GtkWidget *al = label("添加", "hint"); gtk_widget_set_halign(al, GTK_ALIGN_CENTER);
|
||||
gtk_box_pack_start(GTK_BOX(quick), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(quick), al, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(page), quick, FALSE, FALSE, 0);
|
||||
return page;
|
||||
}
|
||||
static void close_banner(GtkButton *b, gpointer d) { (void)b; (void)d; banner_closed = 1; gtk_widget_hide(banner); }
|
||||
static GtkWidget *build_all(void) {
|
||||
GtkWidget *page = vbox(8); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
|
||||
banner = hbox(10); add_class(banner, "banner");
|
||||
GtkWidget *text = vbox(4);
|
||||
gtk_box_pack_start(GTK_BOX(text), label("ⓘ 添加你的其他设备", "group"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(text), label("在其他电脑上安装 UU 远程官方客户端或本项目主机端,登录同一账号后即可在这里远程访问。", "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(banner), text, TRUE, TRUE, 0);
|
||||
GtkWidget *x = button("×", "hbtn"); gtk_widget_set_valign(x, GTK_ALIGN_START);
|
||||
g_signal_connect(x, "clicked", G_CALLBACK(close_banner), NULL);
|
||||
gtk_box_pack_end(GTK_BOX(banner), x, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(page), banner, FALSE, FALSE, 0);
|
||||
all_box = vbox(4);
|
||||
gtk_box_pack_start(GTK_BOX(page), all_box, FALSE, FALSE, 8);
|
||||
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scroll), page);
|
||||
return scroll;
|
||||
}
|
||||
static void on_assist_connect(GtkButton *b, gpointer entry) {
|
||||
(void)b;
|
||||
const char *id = gtk_entry_get_text(GTK_ENTRY(entry));
|
||||
if (!id[0]) { show_toast("请输入伙伴的设备 ID"); return; }
|
||||
GtkWidget *code_entry = g_object_get_data(G_OBJECT(entry), "assist-code");
|
||||
const char *code = gtk_entry_get_text(GTK_ENTRY(code_entry));
|
||||
if (!code[0]) { show_toast("请输入伙伴的设备验证码"); return; }
|
||||
if (strpbrk(id, "\t\r\n") || strpbrk(code, "\t\r\n")) { show_toast("设备 ID 和验证码不能包含换行或制表符"); return; }
|
||||
char cmd[200];
|
||||
int n = snprintf(cmd, sizeof cmd, "assist\t%s\t%s", id, code);
|
||||
if (n < 0 || (size_t)n >= sizeof cmd) { show_toast("设备 ID 或验证码过长"); return; }
|
||||
int accepted = push(cmd);
|
||||
memset(cmd, 0, sizeof cmd);
|
||||
if (!accepted) { show_toast("连接请求过多,请稍后重试"); return; }
|
||||
gtk_entry_set_text(GTK_ENTRY(code_entry), "");
|
||||
show_toast("正在连接…");
|
||||
}
|
||||
static GtkWidget *build_assist(void) {
|
||||
GtkWidget *page = vbox(20); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
|
||||
GtkWidget *mine = vbox(14); add_class(mine, "card");
|
||||
GtkWidget *top = hbox(10); gtk_box_pack_start(GTK_BOX(top), label("本设备", "h2"), TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(top), label("允许他人远程协助", "devname"), FALSE, FALSE, 0);
|
||||
GtkWidget *sw = gtk_switch_new(); gtk_widget_set_sensitive(sw, FALSE); gtk_box_pack_start(GTK_BOX(top), sw, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(mine), top, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(mine), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
|
||||
GtkWidget *grid = hbox(40), *c1 = vbox(6), *c2 = vbox(6);
|
||||
gtk_box_pack_start(GTK_BOX(c1), label("本设备 ID", "devname"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(c1), label("— — —", "big"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(c2), label("验证方式:仅使用临时验证码", "devname"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(c2), label("—", "big"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(c2), label("每次远控结束刷新", "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(grid), c1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(grid), c2, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(mine), grid, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(mine), label("本机被协助由 uuremote-server 主机端提供(uuremote-server assist)。", "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(page), mine, FALSE, FALSE, 0);
|
||||
GtkWidget *peer = vbox(12); add_class(peer, "card");
|
||||
gtk_box_pack_start(GTK_BOX(peer), label("远控伙伴设备", "h2"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(peer), label("通过其他设备的【设备 ID】及【设备验证码】启动远程控制", "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(peer), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(peer), label("伙伴的设备 ID", "devname"), FALSE, FALSE, 0);
|
||||
GtkWidget *row = hbox(20), *entry = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entry), "请输入设备 ID"); gtk_widget_set_size_request(entry, 320, -1);
|
||||
GtkWidget *code = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(code), "请输入设备验证码");
|
||||
gtk_entry_set_visibility(GTK_ENTRY(code), FALSE);
|
||||
gtk_entry_set_input_purpose(GTK_ENTRY(code), GTK_INPUT_PURPOSE_PASSWORD);
|
||||
gtk_entry_set_max_length(GTK_ENTRY(entry), 64); gtk_entry_set_max_length(GTK_ENTRY(code), 64);
|
||||
g_object_set_data(G_OBJECT(entry), "assist-code", code);
|
||||
g_signal_connect(code, "activate", G_CALLBACK(on_assist_connect), entry);
|
||||
GtkWidget *go = button("连接", "primary"); g_signal_connect(go, "clicked", G_CALLBACK(on_assist_connect), entry);
|
||||
gtk_box_pack_start(GTK_BOX(row), entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), code, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), go, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(peer), row, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(page), peer, FALSE, FALSE, 0);
|
||||
return page;
|
||||
}
|
||||
static void on_add_favorite(GtkButton *b, gpointer d) {
|
||||
(void)b; (void)d;
|
||||
GtkWidget *dialog = gtk_dialog_new_with_buttons("添加收藏设备", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "添加", GTK_RESPONSE_OK, NULL);
|
||||
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *card = vbox(12); add_class(card, "card");
|
||||
gtk_container_set_border_width(GTK_CONTAINER(area), 16);
|
||||
const char *names[] = {"伙伴的设备 ID", "设备验证码(可选)", "备注名称(可选)"}, *hints[] = {"请输入设备 ID", "请输入设备验证码", "请输入名称"};
|
||||
GtkWidget *first = NULL;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
GtkWidget *line = hbox(20), *e = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(e), hints[i]); gtk_widget_set_size_request(e, 280, -1);
|
||||
if (!first) first = e;
|
||||
gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(line), e, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(card), line, FALSE, FALSE, 0);
|
||||
}
|
||||
gtk_container_add(GTK_CONTAINER(area), card);
|
||||
gtk_widget_show_all(dialog);
|
||||
int response = gtk_dialog_run(GTK_DIALOG(dialog));
|
||||
int has_id = first && gtk_entry_get_text(GTK_ENTRY(first))[0];
|
||||
gtk_widget_destroy(dialog);
|
||||
if (response == GTK_RESPONSE_OK) show_toast(has_id ? "收藏设备:暂未支持" : "请输入伙伴的设备 ID");
|
||||
}
|
||||
static GtkWidget *build_favorite(void) {
|
||||
GtkWidget *page = vbox(10); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
|
||||
GtkWidget *add = button("添加收藏设备", "secondary"); gtk_widget_set_halign(add, GTK_ALIGN_END);
|
||||
g_signal_connect(add, "clicked", G_CALLBACK(on_add_favorite), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(page), add, FALSE, FALSE, 0);
|
||||
fav_stack = gtk_stack_new();
|
||||
GtkWidget *empty = vbox(10); gtk_widget_set_valign(empty, GTK_ALIGN_CENTER);
|
||||
GtkWidget *box = label("📦", "big"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER);
|
||||
GtkWidget *t = label("暂无收藏", "devname"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
|
||||
gtk_box_pack_start(GTK_BOX(empty), box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(empty), t, FALSE, FALSE, 0);
|
||||
gtk_stack_add_named(GTK_STACK(fav_stack), empty, "empty");
|
||||
gtk_box_pack_start(GTK_BOX(page), fav_stack, TRUE, TRUE, 0);
|
||||
return page;
|
||||
}
|
||||
|
||||
// ---- settings window (常规 / 安全 / 键盘 / 网络) ----
|
||||
static GtkWidget *setting_row(const char *title, const char *detail, GtkWidget *control) {
|
||||
GtkWidget *row = hbox(12), *text = vbox(2);
|
||||
gtk_box_pack_start(GTK_BOX(text), label(title, "devname"), FALSE, FALSE, 0);
|
||||
if (detail) gtk_box_pack_start(GTK_BOX(text), label(detail, "hint"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(row), text, TRUE, TRUE, 0);
|
||||
if (control) { gtk_widget_set_valign(control, GTK_ALIGN_CENTER); gtk_box_pack_end(GTK_BOX(row), control, FALSE, FALSE, 0); }
|
||||
return row;
|
||||
}
|
||||
static GtkWidget *combo(const char *const *items, int n) {
|
||||
GtkWidget *c = gtk_combo_box_text_new();
|
||||
for (int i = 0; i < n; i++) gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(c), items[i]);
|
||||
gtk_combo_box_set_active(GTK_COMBO_BOX(c), 0);
|
||||
return c;
|
||||
}
|
||||
static GtkWidget *settings_card(GtkWidget **rows, int n) {
|
||||
GtkWidget *card = vbox(10); add_class(card, "card");
|
||||
for (int i = 0; i < n; i++) { if (i) gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), rows[i], FALSE, FALSE, 0); }
|
||||
return card;
|
||||
}
|
||||
static GtkWidget *settings_page(void) { GtkWidget *p = vbox(14); gtk_container_set_border_width(GTK_CONTAINER(p), 22); return p; }
|
||||
static GtkWidget *edit_button(const char *what) { GtkWidget *b = button("编辑", "secondary"); g_signal_connect(b, "clicked", G_CALLBACK(unsupported), (gpointer)what); return b; }
|
||||
static gboolean settings_hidden(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); return TRUE; }
|
||||
static gboolean settings_key(GtkWidget *w, GdkEventKey *e, gpointer d) { (void)d; if (e->keyval == GDK_KEY_Escape) { gtk_widget_hide(w); return TRUE; } return FALSE; }
|
||||
// Compositors such as Hyprland draw no title bar, so windows carry their own (with a close button).
|
||||
static void own_titlebar(GtkWidget *w, const char *title) {
|
||||
GtkWidget *bar = gtk_header_bar_new();
|
||||
gtk_header_bar_set_title(GTK_HEADER_BAR(bar), title);
|
||||
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
|
||||
gtk_window_set_titlebar(GTK_WINDOW(w), bar);
|
||||
}
|
||||
static void open_settings(void) {
|
||||
if (settings_window) { gtk_window_present(GTK_WINDOW(settings_window)); return; }
|
||||
settings_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(settings_window), "设置");
|
||||
gtk_window_set_transient_for(GTK_WINDOW(settings_window), GTK_WINDOW(window));
|
||||
gtk_window_set_default_size(GTK_WINDOW(settings_window), 680, 600);
|
||||
g_signal_connect(settings_window, "delete-event", G_CALLBACK(settings_hidden), NULL);
|
||||
g_signal_connect(settings_window, "key-press-event", G_CALLBACK(settings_key), NULL);
|
||||
own_titlebar(settings_window, "设置");
|
||||
GtkWidget *root = vbox(0), *tabs = gtk_stack_new(), *switcher = gtk_stack_switcher_new();
|
||||
gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(switcher), GTK_STACK(tabs));
|
||||
gtk_widget_set_halign(switcher, GTK_ALIGN_CENTER); gtk_widget_set_margin_top(switcher, 10); gtk_widget_set_margin_bottom(switcher, 6);
|
||||
gtk_box_pack_start(GTK_BOX(root), switcher, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(root), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
|
||||
// 常规
|
||||
GtkWidget *general = settings_page();
|
||||
const char *wake[] = {"永不", "接通电源时", "始终"}, *close_opts[] = {"最小化", "退出程序"};
|
||||
GtkWidget *g1[] = { setting_row("开机自启动", NULL, gtk_switch_new()),
|
||||
setting_row("保持唤醒状态", "防止电脑进入睡眠状态,导致无法远程访问。", combo(wake, 3)),
|
||||
setting_row("关闭窗口时", NULL, combo(close_opts, 2)) };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g1, 3), FALSE, FALSE, 0);
|
||||
GtkWidget *path = hbox(8); GtkWidget *change = button("修改路径", "secondary"), *open = button("打开文件夹", "secondary");
|
||||
g_signal_connect(change, "clicked", G_CALLBACK(unsupported), "修改路径"); g_signal_connect(open, "clicked", G_CALLBACK(unsupported), "打开文件夹");
|
||||
gtk_box_pack_end(GTK_BOX(path), open, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(path), change, FALSE, FALSE, 0);
|
||||
GtkWidget *g2[] = { setting_row("传输文件存储路径", "~/Downloads", path) };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g2, 1), FALSE, FALSE, 0);
|
||||
GtkWidget *real = button("在手机 App 中查看", "secondary"); gtk_widget_set_sensitive(real, FALSE);
|
||||
GtkWidget *g3[] = { setting_row("实名认证", NULL, real) };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g3, 1), FALSE, FALSE, 0);
|
||||
gtk_stack_add_titled(GTK_STACK(tabs), general, "general", "⚙ 常规");
|
||||
// 安全
|
||||
GtkWidget *security = settings_page();
|
||||
const char *verify[] = {"仅使用临时验证码", "仅使用自定义验证码", "临时与自定义验证码"};
|
||||
GtkWidget *s1[] = { setting_row("允许同账号控制本设备", NULL, gtk_switch_new()), setting_row("允许他人远程协助", NULL, gtk_switch_new()) };
|
||||
GtkWidget *s2[] = { setting_row("远程协助连接本设备的验证方式", NULL, combo(verify, 3)) };
|
||||
GtkWidget *s3[] = { setting_row("客户端锁定", "防止客户端设置被修改,保障数据与使用安全。", gtk_switch_new()) };
|
||||
gtk_box_pack_start(GTK_BOX(security), settings_card(s1, 2), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(security), settings_card(s2, 1), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(security), settings_card(s3, 1), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(security), label("本机被控相关设置由 uuremote-server 主机端提供。", "hint"), FALSE, FALSE, 0);
|
||||
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", "🔒 安全");
|
||||
// 键盘
|
||||
GtkWidget *keys = settings_page();
|
||||
gtk_box_pack_start(GTK_BOX(keys), label("仅控制端响应的快捷键", "h2"), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(keys), label("远控时按下以下快捷键,仅在控制端本地响应,不会发送到被控端。", "hint"), FALSE, FALSE, 0);
|
||||
GtkWidget *addk = button("添加控制端快捷键", "secondary"); g_signal_connect(addk, "clicked", G_CALLBACK(unsupported), "添加快捷键");
|
||||
GtkWidget *k1[] = { setting_row("当前暂无设置", NULL, NULL), setting_row("", NULL, addk) };
|
||||
gtk_box_pack_start(GTK_BOX(keys), settings_card(k1, 2), FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(keys), label("功能快捷键", "h2"), FALSE, FALSE, 6);
|
||||
gtk_box_pack_start(GTK_BOX(keys), label("按下以下快捷键时,仅在本地触发对应功能,不会发送到被控端。", "hint"), FALSE, FALSE, 0);
|
||||
const char *fns[] = {"使用被控端鼠标/解锁鼠标", "被控时解除防窥模式", "切换上一个屏幕", "切换下一个屏幕", "显示/隐藏悬浮球", "静音/取消静音", "老板键(隐藏/显示所有客户端窗口)", "发送 Ctrl+Alt+Delete 组合键"};
|
||||
GtkWidget *k2[8];
|
||||
for (int i = 0; i < 8; i++) k2[i] = setting_row(fns[i], NULL, edit_button(fns[i]));
|
||||
gtk_box_pack_start(GTK_BOX(keys), settings_card(k2, 8), FALSE, FALSE, 0);
|
||||
GtkWidget *kscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(kscroll), keys);
|
||||
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", "⌨ 键盘");
|
||||
// 网络
|
||||
GtkWidget *network = settings_page();
|
||||
const char *proxy[] = {"使用系统环境代理", "不使用代理"};
|
||||
GtkWidget *n1[] = { setting_row("代理设置", NULL, combo(proxy, 2)) };
|
||||
gtk_box_pack_start(GTK_BOX(network), settings_card(n1, 1), FALSE, FALSE, 0);
|
||||
gtk_stack_add_titled(GTK_STACK(tabs), network, "network", "🌐 网络");
|
||||
gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(settings_window), root);
|
||||
gtk_widget_show_all(settings_window);
|
||||
}
|
||||
static void confirm_logout(void) {
|
||||
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定要退出登录吗?");
|
||||
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "退出登录会中断正在进行中的连接,你的设备也将从本账户删除。请谨慎操作!");
|
||||
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "确认", GTK_RESPONSE_OK, NULL);
|
||||
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) push("logout");
|
||||
gtk_widget_destroy(d);
|
||||
}
|
||||
static void on_menu(GtkMenuItem *item, gpointer what) {
|
||||
(void)item;
|
||||
if (!strcmp(what, "settings")) open_settings();
|
||||
else if (!strcmp(what, "logout")) { if (logged_in) confirm_logout(); }
|
||||
else if (!strcmp(what, "refresh")) push("refresh");
|
||||
else if (!strcmp(what, "quit")) { atomic_store(&closed, 1); push("quit"); gtk_main_quit(); }
|
||||
}
|
||||
static void popup(GtkButton *b, gpointer kind) {
|
||||
GtkWidget *menu = gtk_menu_new();
|
||||
if (!strcmp(kind, "account")) {
|
||||
GtkWidget *who = gtk_menu_item_new_with_label(logged_in ? (user_text[0] ? user_text : "已登录") : "未登录"); gtk_widget_set_sensitive(who, FALSE);
|
||||
gtk_menu_shell_append(GTK_MENU_SHELL(menu), who);
|
||||
GtkWidget *out = gtk_menu_item_new_with_label("退出登录"); g_signal_connect(out, "activate", G_CALLBACK(on_menu), "logout");
|
||||
gtk_widget_set_sensitive(out, logged_in); gtk_menu_shell_append(GTK_MENU_SHELL(menu), out);
|
||||
} else if (!strcmp(kind, "notice")) {
|
||||
GtkWidget *none = gtk_menu_item_new_with_label("暂无通知"); gtk_widget_set_sensitive(none, FALSE);
|
||||
gtk_menu_shell_append(GTK_MENU_SHELL(menu), none);
|
||||
} else {
|
||||
const char *labels[] = {"刷新设备列表", "设置", "退出程序"}, *whats[] = {"refresh", "settings", "quit"};
|
||||
for (int i = 0; i < 3; i++) { GtkWidget *it = gtk_menu_item_new_with_label(labels[i]); g_signal_connect(it, "activate", G_CALLBACK(on_menu), (gpointer)whats[i]); gtk_menu_shell_append(GTK_MENU_SHELL(menu), it); }
|
||||
}
|
||||
gtk_widget_show_all(menu);
|
||||
gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(b), GDK_GRAVITY_SOUTH_EAST, GDK_GRAVITY_NORTH_EAST, NULL);
|
||||
}
|
||||
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)w; (void)e; (void)d; atomic_store(&closed, 1); push("quit"); gtk_main_quit(); return FALSE; }
|
||||
|
||||
static void *run(void *arg) {
|
||||
(void)arg;
|
||||
int ok = gtk_init_check(NULL, NULL);
|
||||
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
|
||||
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
|
||||
if (ok) {
|
||||
GtkCssProvider *css = gtk_css_provider_new();
|
||||
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
|
||||
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 控制端(非官方)");
|
||||
gtk_window_set_default_size(GTK_WINDOW(window), 1180, 780);
|
||||
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
|
||||
own_titlebar(window, "UU 远程 Linux 控制端(非官方)");
|
||||
GtkWidget *root = hbox(0);
|
||||
// Sidebar
|
||||
GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1);
|
||||
my_section = vbox(0);
|
||||
GtkWidget *mh = hbox(8); gtk_widget_set_margin_start(mh, 18); gtk_widget_set_margin_top(mh, 22); gtk_widget_set_margin_bottom(mh, 6);
|
||||
gtk_box_pack_start(GTK_BOX(mh), label("⧉ 我的设备", "section"), TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(my_section), mh, FALSE, FALSE, 0);
|
||||
device_list = gtk_list_box_new(); g_signal_connect(device_list, "row-activated", G_CALLBACK(on_row), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(my_section), device_list, FALSE, FALSE, 0);
|
||||
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
||||
GtkWidget *side_inner = vbox(0); gtk_box_pack_start(GTK_BOX(side_inner), my_section, FALSE, FALSE, 0);
|
||||
GtkWidget *welcome_nav = gtk_list_box_new(); g_signal_connect(welcome_nav, "row-activated", G_CALLBACK(on_row), NULL);
|
||||
GtkWidget *ah = label("⧉ 远程协助", "section"); gtk_widget_set_margin_start(ah, 18); gtk_widget_set_margin_top(ah, 16); gtk_widget_set_margin_bottom(ah, 6);
|
||||
gtk_box_pack_start(GTK_BOX(side_inner), ah, FALSE, FALSE, 0);
|
||||
GtkWidget *assist = assist_list = gtk_list_box_new(); g_signal_connect(assist, "row-activated", G_CALLBACK(on_row), NULL);
|
||||
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("◧", "开始协助", "assist"), -1);
|
||||
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("★", "收藏设备", "favorite"), -1);
|
||||
gtk_box_pack_start(GTK_BOX(side_inner), assist, FALSE, FALSE, 0);
|
||||
gtk_list_box_unselect_all(GTK_LIST_BOX(assist));
|
||||
(void)welcome_nav;
|
||||
gtk_container_add(GTK_CONTAINER(scroll), side_inner);
|
||||
gtk_box_pack_start(GTK_BOX(side), scroll, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(root), side, FALSE, FALSE, 0);
|
||||
// Main area
|
||||
GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header");
|
||||
badge = gtk_label_new(""); add_class(badge, "badge");
|
||||
title_label = label("全部设备", "title");
|
||||
more_button = button("⋮", "hbtn"); g_signal_connect(more_button, "clicked", G_CALLBACK(on_more), NULL);
|
||||
gtk_box_pack_start(GTK_BOX(header), badge, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(header), title_label, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(header), more_button, FALSE, FALSE, 0);
|
||||
const char *icons[] = {"☰", "◉", "🔔"}, *kinds[] = {"menu", "account", "notice"};
|
||||
for (int i = 0; i < 3; i++) { GtkWidget *b = button(icons[i], "hbtn"); g_signal_connect(b, "clicked", G_CALLBACK(popup), (gpointer)kinds[i]); gtk_box_pack_end(GTK_BOX(header), b, FALSE, FALSE, 0); }
|
||||
gtk_box_pack_start(GTK_BOX(main), header, FALSE, FALSE, 0);
|
||||
GtkWidget *overlay = gtk_overlay_new();
|
||||
stack = gtk_stack_new();
|
||||
gtk_stack_add_named(GTK_STACK(stack), build_welcome(), "welcome");
|
||||
gtk_stack_add_named(GTK_STACK(stack), build_login(), "login");
|
||||
gtk_stack_add_named(GTK_STACK(stack), build_device(), "device");
|
||||
gtk_stack_add_named(GTK_STACK(stack), build_all(), "all");
|
||||
gtk_stack_add_named(GTK_STACK(stack), build_assist(), "assist");
|
||||
gtk_stack_add_named(GTK_STACK(stack), build_favorite(), "favorite");
|
||||
gtk_container_add(GTK_CONTAINER(overlay), stack);
|
||||
toast = gtk_label_new(""); add_class(toast, "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_START); gtk_widget_set_margin_top(toast, 30);
|
||||
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), toast);
|
||||
gtk_box_pack_start(GTK_BOX(main), overlay, TRUE, TRUE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(root), main, TRUE, TRUE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(window), root);
|
||||
gtk_widget_show_all(window);
|
||||
gtk_widget_hide(badge); gtk_widget_hide(more_button); gtk_widget_hide(toast); gtk_widget_hide(my_section);
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(stack), "welcome");
|
||||
}
|
||||
pthread_mutex_lock(&init_lock); init_state = ok ? 1 : -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
|
||||
if (ok) gtk_main();
|
||||
atomic_store(&closed, 1);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int uu_viewer_ui_start(void) {
|
||||
if (ui_started) return init_state == 1 ? 0 : -1;
|
||||
ui_started = 1;
|
||||
if (pthread_create(&ui_thread, NULL, run, NULL)) return -1;
|
||||
pthread_mutex_lock(&init_lock); while (!init_state) pthread_cond_wait(&init_cond, &init_lock); pthread_mutex_unlock(&init_lock);
|
||||
return init_state == 1 ? 0 : -1;
|
||||
}
|
||||
/// Lines of "id\tname\tplatform\tonline\tcurrent".
|
||||
void uu_viewer_ui_set_devices(const char *tsv) {
|
||||
pthread_mutex_lock(&d_lock);
|
||||
/* A refresh (every 30 s) must keep the open device page usable: re-select by id, not reset. */
|
||||
char keep[sizeof devices[0].id] = "";
|
||||
if (selected >= 0 && selected < device_count) snprintf(keep, sizeof keep, "%s", devices[selected].id);
|
||||
device_count = 0;
|
||||
char *copy = strdup(tsv ? tsv : ""), *save = NULL;
|
||||
for (char *line = strtok_r(copy, "\n", &save); line && device_count < 64; line = strtok_r(NULL, "\n", &save)) {
|
||||
char *f[5] = {0}, *s2 = NULL; int n = 0;
|
||||
for (char *p = strtok_r(line, "\t", &s2); p && n < 5; p = strtok_r(NULL, "\t", &s2)) f[n++] = p;
|
||||
if (n < 5) continue;
|
||||
Device *d = &devices[device_count++];
|
||||
snprintf(d->id, sizeof d->id, "%s", f[0]); snprintf(d->name, sizeof d->name, "%s", f[1]);
|
||||
d->platform = atoi(f[2]); d->online = atoi(f[3]); d->current = atoi(f[4]);
|
||||
}
|
||||
free(copy);
|
||||
selected = -1;
|
||||
for (int i = 0; keep[0] && i < device_count; i++) if (!strcmp(devices[i].id, keep)) { selected = i; break; }
|
||||
pthread_mutex_unlock(&d_lock);
|
||||
if (init_state == 1) g_idle_add(apply_devices, NULL);
|
||||
}
|
||||
void uu_viewer_ui_set_login(int signed_in, const char *qr_png, const char *status, const char *user) {
|
||||
logged_in = signed_in;
|
||||
snprintf(qr_path, sizeof qr_path, "%s", qr_png ? qr_png : "");
|
||||
snprintf(status_text, sizeof status_text, "%s", status ? status : "");
|
||||
snprintf(user_text, sizeof user_text, "%s", user ? user : "");
|
||||
if (init_state == 1) g_idle_add(apply_login, NULL);
|
||||
}
|
||||
int uu_viewer_ui_take_command(char *out, size_t len) {
|
||||
pthread_mutex_lock(&q_lock);
|
||||
int has = q_len > 0;
|
||||
if (has) { snprintf(out, len, "%s", queue[q_head]); memset(queue[q_head], 0, sizeof queue[q_head]); q_head = (q_head + 1) % 16; q_len--; }
|
||||
pthread_mutex_unlock(&q_lock);
|
||||
return has;
|
||||
}
|
||||
int uu_viewer_ui_closed(void) { return atomic_load(&closed); }
|
||||
static char toast_text[256];
|
||||
static gboolean apply_toast(gpointer d) { (void)d; show_toast(toast_text); return G_SOURCE_REMOVE; }
|
||||
void uu_viewer_ui_toast(const char *text) {
|
||||
snprintf(toast_text, sizeof toast_text, "%s", text ? text : "");
|
||||
if (init_state == 1) g_idle_add(apply_toast, NULL);
|
||||
}
|
||||
|
||||
static int replace_result;
|
||||
static gboolean confirm_replace(gpointer d) {
|
||||
(void)d;
|
||||
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
|
||||
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "打开后将断开当前与该设备的连接,继续吗?");
|
||||
gtk_dialog_add_buttons(GTK_DIALOG(dialog), "取消", GTK_RESPONSE_CANCEL, "继续", GTK_RESPONSE_OK, NULL);
|
||||
int accepted = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK;
|
||||
gtk_widget_destroy(dialog);
|
||||
pthread_mutex_lock(&init_lock); replace_result = accepted; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
int uu_viewer_ui_confirm_replace(void) {
|
||||
pthread_mutex_lock(&init_lock); replace_result = -1; g_idle_add(confirm_replace, NULL);
|
||||
while (replace_result < 0 && !atomic_load(&closed)) {
|
||||
struct timespec until; clock_gettime(CLOCK_REALTIME, &until); until.tv_sec++;
|
||||
pthread_cond_timedwait(&init_cond, &init_lock, &until);
|
||||
}
|
||||
int result = replace_result; pthread_mutex_unlock(&init_lock); return result;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
新增实验性 Linux 控制端 `uuremote-viewer`。/ Experimental Linux viewer `uuremote-viewer`.
|
||||
|
||||
### 新增 / Added
|
||||
- **🧪 原生控制端 `uuremote-viewer`**(#36):在 Linux 上用 UU 账号连接并控制其他设备——官方 Windows / Mac 被控端或本项目的 Linux 主机,
|
||||
也可凭对方的设备 ID 和验证码发起远程协助。包含启动窗口(设备列表)、桌面窗口(H.264 画面、键鼠、声音、文本剪贴板、只看模式)、
|
||||
文件传输、终端与终端会话列表、端口映射(只监听 127.0.0.1)、重启/关机。与主机 `uuremote-server` 相互独立,**主机行为不变**。
|
||||
- 使用:`uuremote-viewer login` 扫码登录,`uuremote-viewer ui` 打开启动窗口;命令行用法见 `uuremote-viewer --help` 和 README。
|
||||
- 运行依赖:GTK3、SDL2(Ubuntu/Debian `libsdl2-2.0-0`)、`ffmpeg` 命令;剪贴板需 `xclip`/`xsel` 或 `wl-clipboard`。
|
||||
- 与主机共用 `~/.config/uuremote/config.json`(`UU_CONFIG` 可另指定),因此不能用同一身份连接本机上的主机。
|
||||
- **已实测**:官方 Windows 被控端(画面、键鼠、文件列表与下载)、官方 Mac 被控端(画面)、本项目主机(画面、键鼠、文件、
|
||||
端口映射、终端;剪贴板、声音和远程协助在虚拟机中)。
|
||||
- ⚠️ **未实测**:重启/关机、终端会话列表的新建与接回、Wayland 下的窗口与剪贴板、多显示器;只解码 H.264 4:2:0。
|
||||
这是实验性功能,欢迎反馈问题。
|
||||
An experimental viewer/controller for UU Remote hosts; the host build and behaviour are unchanged. See the README for usage,
|
||||
dependencies and the tested scope (reboot/shutdown, terminal session list and Wayland are not tested live).
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.2.0-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,20 @@
|
||||
控制端补测:重启/关机、终端会话列表、Wayland;主机远程关机不再等待授权弹窗。/ Viewer power, terminal list and Wayland tested; host power actions never wait for a polkit prompt.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **远程重启/关机不再卡在授权弹窗**:被控端用户没有 polkit 权限时(例如本机没有活动的图形会话),`systemctl reboot/poweroff`
|
||||
会一直等待,并可能在被控端屏幕上弹出密码框。现在加了 `--no-ask-password`,没有权限时直接失败并在日志记录 `ok=false`。
|
||||
正常情况下(本机有活动的图形会话)行为不变。
|
||||
Reboot/shutdown no longer wait for a polkit authentication dialog on the host; without permission they fail and are logged.
|
||||
|
||||
### 控制端实测补充 / Viewer testing
|
||||
在虚拟机中用第二个主机身份实测通过(`uuremote-viewer` 连接本项目主机):
|
||||
- 远程**重启**、**关机**,以及关机后重新开机上线。
|
||||
- 终端会话列表:新建、双击接回(重放历史输出、原 shell 环境保留)、确认后结束会话。
|
||||
- Wayland(Hyprland)下的桌面窗口与剪贴板(`wl-copy`/`wl-paste`,双向)。
|
||||
⚠️ 仍未实测:GNOME/KDE Wayland 下的窗口与剪贴板、H.265 与 4:4:4(只解码 H.264 4:2:0)、多显示器。
|
||||
Tested in a VM: reboot, shutdown and power-on, terminal session list, Wayland (Hyprland) window and clipboard.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.2.1-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,30 @@
|
||||
控制端:支持 H.265 / 4:4:4,可对官方 Windows 被控端上传、端口映射和终端。/ Viewer: H.265 / 4:4:4, and upload, port mapping and terminal with the official Windows host.
|
||||
|
||||
### 控制端新增 / Viewer — added
|
||||
- **H.265 与 4:4:4 真彩**:桌面同时提供 H.264 / H.265,由被控端选择;`UU_VIEWER_CHROMA=444` 请求真彩,`UU_VIEWER_CODEC=h264` 只用 H.264。
|
||||
已在虚拟机中对本项目主机实测(libx265 4:2:0 与 4:4:4、强制 H.264 均 0 解码错误);⚠️ 官方被控端的 H.265 / 4:4:4 未实测。
|
||||
H.265 and 4:4:4 true color (tested against this project's host in a VM; not yet with official hosts).
|
||||
|
||||
### 控制端修复 / Viewer — fixed(均为实测发现并验证 / found and verified live)
|
||||
- **官方 Windows 被控端上传文件**:之前上传会被拒绝(错误码 2)。现在按官方客户端的格式发送(Windows 路径、修改时间、压缩文件列表),
|
||||
64 KiB 与 1 MiB 文件上传后再下载回来 sha256 一致。下载也不再拒绝大于 32 KiB 的数据块(错误码 3)。
|
||||
- **官方 Windows 被控端端口映射**:之前每个连接都超时;现在可正常转发(经被控端访问 HTTP 返回 200)。
|
||||
- **官方 Windows 被控端终端**:之前连上后没有任何输出;现在可打开 PowerShell 并交互。
|
||||
- **启动窗口**:设备列表每 30 秒刷新后,已打开的设备页按钮全部失效的问题;「断开当前连接」确认框改为中文按钮。
|
||||
- **连接官方 Mac 被控端时键盘错位**(#39,感谢 @wanglz111,#40):按 1 出空格、Backspace 出 c。Mac 目标改用 macOS 原生键码
|
||||
(按物理位置转发,PC 的 Win 键对应 Command),Windows 与本项目主机仍用 Windows VK;无法确定目标平台时拒绝控制而不是乱发键码。
|
||||
贡献者已在官方 Mac 被控端实机确认;⚠️ ISO/JIS 键盘、媒体键与 Mac 远程协助未验收。
|
||||
- **FFmpeg 4.4 下没有画面**(#40):v0.2.0 / v0.2.1 的控制端解码参数 `-fps_mode` 不被 FFmpeg 4.4(如 Ubuntu 22.04 自带版本)识别,
|
||||
解码进程直接退出。现改用新旧版本都支持的参数。
|
||||
- 对本项目主机的上传、端口映射、终端新建/接回均已回归验证。
|
||||
- Upload, port mapping and terminal now work with the official Windows host; launcher device page stays usable after list refreshes.
|
||||
|
||||
### 已知问题 / Known issues
|
||||
- 控制端 → 官方 Windows 被控端的剪贴板:被控端确认收到文本,但未出现在其桌面剪贴板中,仍在排查(被控端 → 控制端正常)。
|
||||
- GNOME Wayland 下控制端剪贴板不可用,且轮询会让 Dock 图标跳动(#37,修复中);窗口本身正常。KDE、Hyprland 正常。
|
||||
- Viewer → Windows host clipboard is acknowledged but not applied yet; GNOME clipboard (#37).
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.2.2-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,20 @@
|
||||
控制端:GNOME Wayland 下剪贴板不再让 Dock 图标跳动。/ Viewer: clipboard no longer makes GNOME Wayland Dock icons jump.
|
||||
|
||||
### 控制端修复 / Viewer — fixed
|
||||
- **GNOME Wayland 剪贴板与 Dock 跳动**(#37,感谢 @wanglz111,#41):之前每 500 ms 调用一次 `wl-paste`,在缺少 data-control 的 GNOME 上
|
||||
每次都会创建临时窗口,导致 Dock 图标持续跳动。现在桌面窗口直接通过 SDL 读写文本剪贴板,不再需要 `wl-clipboard` / `xclip`。
|
||||
只在桌面窗口获得焦点时同步,仍保留 30 KiB 上限、`UU_VIEWER_CLIPBOARD=0` 关闭开关和原有协议。
|
||||
早期版本已由报告者在 GNOME Wayland 实机确认 Dock 不再跳动;⚠️ 最终的焦点门控版本只有自动化测试,尚未重新实机验收。
|
||||
Clipboard now goes through the existing SDL window (focused only). An earlier revision was confirmed live by the reporter;
|
||||
the final focus-gated revision is covered by automated tests only.
|
||||
|
||||
### 已知问题 / Known issues
|
||||
- 剪贴板只在控制端窗口获得焦点时同步;窗口在后台时收到的被控端剪贴板变化不会写入本机。
|
||||
- 剪贴板内容提供方响应很慢时,可能短暂卡住控制端窗口(SDL2 同步读取)。
|
||||
- 控制端 → 官方 Windows 被控端的剪贴板:被控端确认收到文本,但未出现在其桌面剪贴板中,仍在排查;与官方 Mac 被控端的双向剪贴板未验证。
|
||||
- Clipboard syncs only while the viewer window is focused; viewer → official Windows host clipboard is still unresolved.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.2.3-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。主机端与 v0.2.2 相同。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,22 @@
|
||||
控制端:修复 FFmpeg 9 下没有画面;新增「删除设备」。/ Viewer: fix no video with FFmpeg 9; add device removal.
|
||||
|
||||
### 控制端修复 / Viewer — fixed
|
||||
- **FFmpeg 9 下桌面没有画面**(v0.2.2、v0.2.3 的回归):为兼容 FFmpeg 4.4 改用的 `-vsync 0` 已被 FFmpeg 9 删除,解码进程一启动就退出,
|
||||
所有帧都解码失败。现在启动时探测当前 ffmpeg 支持的参数:新版本用 `-fps_mode passthrough`,旧版本(如 Ubuntu 22.04 的 4.4)用 `-vsync 0`。
|
||||
已在 FFmpeg 9.0.2 上连接官方 Mac 被控端实测:0 解码错误。
|
||||
Fixed: with FFmpeg 9 every frame failed to decode (`-vsync` was removed). Verified against the official Mac host on FFmpeg 9.0.2.
|
||||
|
||||
### 控制端新增 / Viewer — added
|
||||
- **删除设备**:启动窗口「更多工具 → 删除设备」(带确认),或命令行 `uuremote-viewer unbind DEVICE`,把设备从账号中移除,
|
||||
与官方客户端的「删除设备」相同。命令行方式已对一台测试设备实测删除成功;⚠️ 启动窗口里的按钮尚未实机点击验收;
|
||||
分享给你的设备(`--shared`)只有字符串依据,未实测。
|
||||
Remove a device from the account (CLI verified live on a test device; launcher button and `--shared` not yet verified).
|
||||
|
||||
### 已知问题 / Known issues
|
||||
- 剪贴板只在控制端窗口获得焦点时同步;控制端 → 官方 Windows 被控端的剪贴板仍在排查。
|
||||
- Clipboard syncs only while the viewer window is focused; viewer → official Windows host clipboard is still unresolved.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.2.4-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。主机端与 v0.2.3 相同。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,21 @@
|
||||
窗口颜色修复;控制端可接收官方 Mac 被控端的剪贴板。/ Window colors fixed; viewer receives the official Mac host's clipboard.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **深色系统主题下窗口文字看不见**(#43):协助窗口、控制端启动窗口和工具窗口使用固定浅色背景,但部分文字跟随系统深色主题变成了白色。
|
||||
现在这些窗口固定使用浅色主题。已在虚拟机中设置深色偏好后截图确认。
|
||||
GTK windows now stay on the light theme, so text is readable under dark system themes.
|
||||
- **控制端 ↔ 官方 Mac 被控端剪贴板**:Mac 被控端以 `public.utf8-plain-text`(UTF-8)提供文本,而不是 Windows 的 `CF_UNICODETEXT`,
|
||||
之前控制端不会请求,剪贴板始终不同步。现在两种格式都支持;主机端发给官方客户端的格式不变。
|
||||
Mac → 控制端已实机验证;⚠️ 控制端 → Mac 尚未验证。
|
||||
The viewer now handles the Mac host's UTF-8 text format (Mac → viewer verified live; viewer → Mac not yet verified).
|
||||
|
||||
### 已验证 / Verified with the official Mac host(FFmpeg 9.0.2)
|
||||
- 画面 0 解码错误,键盘输入正确,文件上传/下载/列目录 sha256 一致。
|
||||
|
||||
### 已知问题 / Known issues
|
||||
- 剪贴板只在控制端窗口获得焦点时同步;控制端 → 官方 Windows 被控端的剪贴板仍在排查。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.2.5-x86_64-linux.tar.gz`:主机 `uuremote-server`(X11 版)与控制端 `uuremote-viewer`(x86_64,glibc ≥ 2.35;控制端需 SDL2、GTK3、ffmpeg),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
+73
-12
@@ -5,11 +5,37 @@ use crate::protocol::{decode_wire,WireValue};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
const UNICODE_TEXT:u64=13;
|
||||
/// The official Mac host offers its pasteboard text as format id 0 named `public.utf8-plain-text` (observed live).
|
||||
const MAC_TEXT:&str="public.utf8-plain-text";
|
||||
#[derive(Clone,Copy,PartialEq,Eq,Debug)]
|
||||
enum TextFormat {Windows,Mac}
|
||||
impl TextFormat {
|
||||
fn of(format:&[u8])->Option<Self>{
|
||||
if number(format,1)==Ok(UNICODE_TEXT){return Some(Self::Windows)}
|
||||
let named=|n|text_field(format,n).is_ok_and(|s|s==MAC_TEXT);
|
||||
(named(2)||named(3)).then_some(Self::Mac)
|
||||
}
|
||||
fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}}
|
||||
fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}}
|
||||
fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}}
|
||||
fn decode(self,data:&[u8])->Result<String,&'static str>{
|
||||
match self{
|
||||
Self::Windows=>decode_windows(data),
|
||||
Self::Mac=>{
|
||||
let data=data.strip_suffix(&[0]).unwrap_or(data);
|
||||
if data.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}
|
||||
let text=std::str::from_utf8(data).map_err(|_|"invalid UTF-8 clipboard text")?;
|
||||
if text.contains('\0'){return Err("embedded NUL in clipboard text");}
|
||||
Ok(text.to_owned())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const BLOCK_BYTES:usize=0x20000;
|
||||
const MAX_BYTES:usize=MAX_TEXT*2+2;
|
||||
pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>}
|
||||
impl Default for ResultMessages {fn default()->Self{Self{messages:Vec::new(),text:None}}}
|
||||
struct Pending {key:String, count:Option<usize>, blocks:BTreeMap<usize,Vec<u8>>}
|
||||
struct Pending {key:String, format:TextFormat, count:Option<usize>, blocks:BTreeMap<usize,Vec<u8>>}
|
||||
#[derive(Default)]
|
||||
pub struct State {local:Option<String>, pending:Option<Pending>}
|
||||
pub fn format_ids(rpc:&[u8])->Vec<u64>{
|
||||
@@ -62,12 +88,15 @@ fn decode_windows(data:&[u8])->Result<String,&'static str>{
|
||||
if text.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}Ok(text)
|
||||
}
|
||||
impl State{
|
||||
pub fn offer(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{
|
||||
pub fn offer(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{self.offer_formats(id,text,&[TextFormat::Windows])}
|
||||
/// Viewer offers: Windows hosts pick CF_UNICODETEXT, the official Mac host its UTF-8 type.
|
||||
pub fn offer_any_host(&mut self,id:u64,text:String)->Result<Vec<u8>,&'static str>{self.offer_formats(id,text,&[TextFormat::Windows,TextFormat::Mac])}
|
||||
fn offer_formats(&mut self,id:u64,text:String,formats:&[TextFormat])->Result<Vec<u8>,&'static str>{
|
||||
if text.len()>MAX_TEXT{return Err("clipboard text exceeds limit");}
|
||||
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
|
||||
self.local=Some(text);
|
||||
let mut format=Vec::new();int(1,UNICODE_TEXT,&mut format);string(2,"CF_UNICODETEXT",&mut format);
|
||||
let mut list=Vec::new();nested(1,&format,&mut list);
|
||||
let mut list=Vec::new();
|
||||
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.name(),&mut format);nested(1,&format,&mut list);}
|
||||
Ok(request(id,1,&list))
|
||||
}
|
||||
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
|
||||
@@ -78,22 +107,30 @@ impl State{
|
||||
if let Some(list)=bytes(clip,1)?{
|
||||
out.messages.push((22,response(h,1,&[])));
|
||||
let fields=decode_wire(list).map_err(|_|"invalid clipboard format list")?;
|
||||
let supports_text=fields.iter().filter(|f|f.number==1).any(|f|match f.value{WireValue::Bytes(format)=>number(format,1)==Ok(UNICODE_TEXT),_=>false});
|
||||
let offered:Vec<TextFormat>=fields.iter().filter(|f|f.number==1).filter_map(|f|match f.value{WireValue::Bytes(format)=>TextFormat::of(format),_=>None}).collect();
|
||||
let chosen=if offered.contains(&TextFormat::Windows){Some(TextFormat::Windows)}else{offered.first().copied()};
|
||||
let supports_text=chosen.is_some();
|
||||
self.pending=None;
|
||||
if supports_text{
|
||||
if !supports_text{
|
||||
// Format ids/names only (never data), to learn non-Windows peers' text formats.
|
||||
let formats:Vec<(u64,String)>=fields.iter().filter(|f|f.number==1).filter_map(|f|match f.value{WireValue::Bytes(format)=>Some(format),_=>None})
|
||||
.take(8).map(|format|(number(format,1).unwrap_or(u64::MAX),decode_wire(format).ok().and_then(|x|x.into_iter().find_map(|y|match (y.number,y.value){(n,WireValue::Bytes(s)) if n!=1=>std::str::from_utf8(s).ok().map(|s|s.chars().take(48).collect()),_=>None})).unwrap_or_default())).collect();
|
||||
log::info!("Clipboard offer without a supported text format: formats={formats:?}");
|
||||
}
|
||||
if let Some(format)=chosen{
|
||||
let id=next();
|
||||
let epoch=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() as u32;
|
||||
let key=format!("{epoch:08x}-0000-4000-8000-{:012x}",id & 0xffffffffffff);
|
||||
let mut ask=Vec::new();int(1,UNICODE_TEXT,&mut ask);string(2,&key,&mut ask);string(3,"CF_UNICODETEXT",&mut ask);
|
||||
self.pending=Some(Pending{key,count:None,blocks:BTreeMap::new()});
|
||||
let mut ask=Vec::new();int(1,format.id(),&mut ask);string(2,&key,&mut ask);string(3,format.name(),&mut ask);
|
||||
self.pending=Some(Pending{key,format,count:None,blocks:BTreeMap::new()});
|
||||
out.messages.push((21,request(id,2,&ask)));
|
||||
}
|
||||
}else if let Some(ask)=bytes(clip,2)?{
|
||||
let key=text_field(ask,2)?;
|
||||
if key.len()>256||key.is_empty(){return Err("invalid clipboard block key");}
|
||||
let available=number(ask,1)?==UNICODE_TEXT&&self.local.is_some();
|
||||
let mut confirm=Vec::new();int(1,if available{1}else{2},&mut confirm);string(2,key,&mut confirm);
|
||||
let data=if available{Some(encode_windows(self.local.as_ref().unwrap()))}else{None};
|
||||
let format=if number(ask,1)?==UNICODE_TEXT{Some(TextFormat::Windows)}else if text_field(ask,3).is_ok_and(|s|s==MAC_TEXT){Some(TextFormat::Mac)}else{None};
|
||||
let data=format.zip(self.local.as_ref()).map(|(format,text)|format.encode(text));
|
||||
let mut confirm=Vec::new();int(1,if data.is_some(){1}else{2},&mut confirm);string(2,key,&mut confirm);
|
||||
if let Some(data)=&data{int(3,data.chunks(BLOCK_BYTES).len() as u64,&mut confirm);}
|
||||
out.messages.push((22,response(h,2,&confirm)));
|
||||
if let Some(data)=data{
|
||||
@@ -144,13 +181,37 @@ impl State{
|
||||
else if (1..=count).all(|i|pending.blocks.contains_key(&i)){1}
|
||||
else{return Ok(None);};
|
||||
let data:Vec<u8>=(first..first+count).flat_map(|i|pending.blocks[&i].iter().copied()).collect();
|
||||
self.pending=None;decode_windows(&data).map(Some)
|
||||
let format=pending.format;self.pending=None;format.decode(&data).map(Some)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests{
|
||||
use super::*;
|
||||
#[test] fn mac_utf8_text_round_trips_both_directions(){
|
||||
// Mac host offer: format list {1 id 0, 2 "public.utf8-plain-text"} (observed live).
|
||||
let mut mac=Vec::new();int(1,0,&mut mac);string(2,MAC_TEXT,&mut mac);
|
||||
let mut list=Vec::new();nested(1,&mac,&mut list);
|
||||
let mut viewer=State::default();let mut id=200;let mut next=||{id+=1;id};
|
||||
let asked=viewer.request(&request(7,1,&list),&mut next).unwrap();
|
||||
assert_eq!(asked.messages.len(),2);
|
||||
let ask_rpc=&asked.messages[1].1;let clip=bytes(ask_rpc,9).unwrap().unwrap();let ask=bytes(clip,2).unwrap().unwrap();
|
||||
assert_eq!(number(ask,1),Ok(0));assert_eq!(text_field(ask,3),Ok(MAC_TEXT));
|
||||
let key=text_field(ask,2).unwrap().to_owned();
|
||||
let mut confirm=Vec::new();int(1,1,&mut confirm);string(2,&key,&mut confirm);int(3,1,&mut confirm);
|
||||
assert_eq!(viewer.response(&response(header(ask_rpc).unwrap(),2,&confirm)).unwrap(),None);
|
||||
let mut block=Vec::new();string(1,&key,&mut block);int(2,0,&mut block);nested(3,"中文 text\n".as_bytes(),&mut block);
|
||||
assert_eq!(viewer.request(&request(8,3,&block),&mut next).unwrap().text.as_deref(),Some("中文 text\n"));
|
||||
// Viewer offer lists both formats; a Mac-style ask gets UTF-8 bytes back.
|
||||
let offer=viewer.offer_any_host(9,"hi".into()).unwrap();
|
||||
assert_eq!(format_ids(&offer),vec![13,0]);
|
||||
let mut ask=Vec::new();int(1,0,&mut ask);string(2,"k",&mut ask);string(3,MAC_TEXT,&mut ask);
|
||||
let out=viewer.request(&request(10,2,&ask),&mut next).unwrap();
|
||||
let data=bytes(bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap(),3).unwrap().unwrap();
|
||||
assert_eq!(data,b"hi");
|
||||
// Host-side offers are unchanged: CF_UNICODETEXT only.
|
||||
assert_eq!(format_ids(&State::default().offer(1,"hi".into()).unwrap()),vec![13]);
|
||||
}
|
||||
#[test]
|
||||
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
|
||||
let text="UU-test-中文🙂\n".repeat(900);
|
||||
|
||||
@@ -61,6 +61,8 @@ fn save(settings: &Settings) {
|
||||
#[derive(Default)]
|
||||
pub struct PeerActions { started: AtomicBool }
|
||||
|
||||
/// Power actions pass --no-ask-password: without polkit permission (e.g. no active local session) systemctl
|
||||
/// would otherwise wait for an authentication dialog on the controlled screen; fail and log instead.
|
||||
fn quiet(program: &str, args: &[&str]) -> bool {
|
||||
Command::new(program).args(args).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
|
||||
.status().map(|s| s.success()).unwrap_or(false)
|
||||
@@ -135,8 +137,8 @@ impl PeerActions {
|
||||
let ok = detached("gnome-system-monitor", &[]) || detached("plasma-systemmonitor", &[]) || detached("xfce4-taskmanager", &[]);
|
||||
log::info!("System action show_taskmgr: ok={}", ok); return false
|
||||
}
|
||||
REBOOT_SYSTEM => { log::warn!("System action reboot_system requested by viewer"); log::info!("reboot ok={}", quiet("systemctl", &["reboot"])); return false }
|
||||
SHUTDOWN_SYSTEM => { log::warn!("System action shutdown_system requested by viewer"); log::info!("poweroff ok={}", quiet("systemctl", &["poweroff"])); return false }
|
||||
REBOOT_SYSTEM => { log::warn!("System action reboot_system requested by viewer"); log::info!("reboot ok={}", quiet("systemctl", &["--no-ask-password", "reboot"])); return false }
|
||||
SHUTDOWN_SYSTEM => { log::warn!("System action shutdown_system requested by viewer"); log::info!("poweroff ok={}", quiet("systemctl", &["--no-ask-password", "poweroff"])); return false }
|
||||
_ => {}
|
||||
}
|
||||
let mut state = state().lock().unwrap();
|
||||
|
||||
@@ -0,0 +1,459 @@
|
||||
use crate::auth::UUAuthClient;
|
||||
use serde::Deserialize;
|
||||
use serde_json::{json, Value};
|
||||
use std::time::Duration;
|
||||
|
||||
// No Debug: room/report tokens and signaling URLs are credentials.
|
||||
#[derive(Deserialize)]
|
||||
pub struct JoinData {
|
||||
#[serde(default)] pub token: String,
|
||||
#[serde(default)] pub signaling_list: Vec<String>,
|
||||
#[serde(default)] pub ws_connect_timeout_ms: i32,
|
||||
pub report_token: String,
|
||||
pub report_url: String,
|
||||
#[serde(default)] pub report_server_address: String,
|
||||
#[serde(default)] pub streamer_retry_delta_ms: i32,
|
||||
#[serde(default)] pub international_connect: bool,
|
||||
#[serde(default)] pub publisher_platform: Option<i32>,
|
||||
}
|
||||
fn device_platform(data:&Value,device:&str)->Option<i64>{
|
||||
["my_binded_devices","others_shared_devices"].into_iter()
|
||||
.filter_map(|key|data.get(key).and_then(Value::as_array)).flatten()
|
||||
.find(|d|d.get("device_id").and_then(Value::as_str)==Some(device))
|
||||
.and_then(|d|d.get("platform")).and_then(Value::as_i64)
|
||||
}
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum Error { AuthenticationExpired, Api(i32, String), InvalidResponse, Transport, MissingRoom, InvalidDevice, InvalidAssist, UnknownKeyboardPlatform }
|
||||
impl std::fmt::Display for Error {
|
||||
// The server's short message is user-facing (e.g. 2002 「被控端正在被远控中,无法发起连接」).
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Error::Api(code, msg) if !msg.is_empty() => write!(f, "{msg} (code {code})"),
|
||||
Error::AuthenticationExpired => write!(f, "登录已过期,请重新登录"),
|
||||
Error::Transport => write!(f, "网络连接失败"),
|
||||
Error::InvalidAssist => write!(f, "请输入对方的设备 ID 和有效验证码"),
|
||||
Error::InvalidResponse => write!(f, "服务器响应格式无效"),
|
||||
Error::MissingRoom => write!(f, "服务器未返回可用的房间或信令信息"),
|
||||
Error::UnknownKeyboardPlatform => write!(f, "无法确定目标键盘平台,不能启用控制"),
|
||||
Error::Api(code, _) => write!(f, "连接请求失败(错误码 {code})"),
|
||||
_ => write!(f, "viewer API: {self:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Mirrors Windows 0x140b77cd0 / 0x140b7a6d0, not host RoomData.
|
||||
/// Treat the caller's device string as one opaque path segment, never a URL/query.
|
||||
fn path_segment(device: &str) -> Result<String, Error> {
|
||||
if device.is_empty() || device=="." || device==".." { return Err(Error::InvalidDevice); }
|
||||
Ok(device.bytes().map(|b|if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {(b as char).to_string()}else{format!("%{b:02X}")}).collect())
|
||||
}
|
||||
fn parse_ack(status: u16, body: Value) -> Result<(), Error> {
|
||||
let code = body.get("code").and_then(Value::as_i64).unwrap_or(-1);
|
||||
if code == 1120 { return Err(Error::AuthenticationExpired); }
|
||||
if status == 200 && code == 0 { return Ok(()); }
|
||||
let msg = body.get("msg").and_then(Value::as_str).unwrap_or("").chars().take(120).collect();
|
||||
Err(Error::Api(i32::try_from(code).unwrap_or(-1), msg))
|
||||
}
|
||||
pub fn parse_join(status: u16, value: Value) -> Result<JoinData, Error> {
|
||||
let code = value.get("code").and_then(Value::as_i64).and_then(|v| i32::try_from(v).ok()).ok_or(Error::InvalidResponse)?;
|
||||
let msg = value.get("msg").and_then(Value::as_str).ok_or(Error::InvalidResponse)?.chars().take(120).collect::<String>();
|
||||
if code == 1120 { return Err(Error::AuthenticationExpired); }
|
||||
let code = if code == 0 && status != 200 { i32::from(status) } else { code };
|
||||
// Error responses carry an empty data object (observed: 400 / 2002 with data {}); report the code.
|
||||
if code != 0 { return Err(Error::Api(code, msg)); }
|
||||
let data = match value.get("data") {
|
||||
Some(Value::Object(o)) => Some(serde_json::from_value::<JoinData>(Value::Object(o.clone())).map_err(|_| Error::InvalidResponse)?),
|
||||
_ => None,
|
||||
};
|
||||
data.ok_or(Error::MissingRoom)
|
||||
}
|
||||
fn parse_share(status: u16, mut body: Value, secrets: &[&str]) -> Result<JoinData, Error> {
|
||||
if let Some(Value::String(msg)) = body.get_mut("msg") {
|
||||
// A server error must not echo credentials to stderr or the launcher.
|
||||
for secret in secrets {
|
||||
if !secret.is_empty() { *msg = msg.replace(secret, "[已隐藏]"); }
|
||||
}
|
||||
*msg = msg.chars().filter(|c| !c.is_control()).collect();
|
||||
}
|
||||
let room = parse_join(status, body)?;
|
||||
if room.token.is_empty() || room.signaling_list.is_empty() { return Err(Error::MissingRoom); }
|
||||
Ok(room)
|
||||
}
|
||||
pub fn retry_delay(error: &Error, retries: usize, enabled: bool) -> Option<Duration> {
|
||||
match error {
|
||||
Error::Api(code, _) if enabled && retries < 5 && ![-1, 2002, 2006, 2007, 4042].contains(code) => Some(Duration::from_millis(3000)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Api {
|
||||
signer: UUAuthClient,
|
||||
http: reqwest::Client,
|
||||
base: String,
|
||||
}
|
||||
impl Api {
|
||||
pub fn new(signer: UUAuthClient, base: &str) -> Self {
|
||||
Self { signer, base: base.trim_end_matches('/').into(), http: reqwest::Client::builder().timeout(Duration::from_secs(12)).build().unwrap() }
|
||||
}
|
||||
pub async fn join_share(&self, connect_id: &str, connect_code: &str) -> Result<JoinData, Error> {
|
||||
if connect_id.trim().is_empty() || connect_code.trim().is_empty() || connect_id.chars().chain(connect_code.chars()).any(char::is_control) { return Err(Error::InvalidAssist); }
|
||||
// Win LiteInner 0x140b6db90 sends plaintext connect_code; Mac uses the v1 path.
|
||||
let text = json!({"connect_id":connect_id,"connect_code":connect_code}).to_string();
|
||||
for version in [2, 1] {
|
||||
let path = format!("/api/v{version}/room/join/share/by_code");
|
||||
let response = self.http.post(format!("{}{path}", self.base))
|
||||
.headers(self.signer.build_headers("POST", &path, &text)).body(text.clone())
|
||||
.send().await.map_err(|_| Error::Transport)?;
|
||||
let status = response.status().as_u16();
|
||||
log::info!("Assist join response: status={status}");
|
||||
// A missing endpoint may return HTML; inspect HTTP status before decoding JSON.
|
||||
if version == 2 && matches!(status, 404 | 405) { continue; }
|
||||
let body = response.json().await.map_err(|_| Error::InvalidResponse)?;
|
||||
return parse_share(status, body, &[connect_code, &self.signer.creds.token, &self.signer.creds.csrf]);
|
||||
}
|
||||
unreachable!()
|
||||
}
|
||||
async fn request(&self, method: reqwest::Method, path: &str, body: Option<Value>) -> Result<(u16, Value), Error> {
|
||||
let text = body.map(|v| v.to_string()).unwrap_or_default();
|
||||
let response = self.http.request(method.clone(), format!("{}{path}", self.base))
|
||||
.headers(self.signer.build_headers(method.as_str(), path, &text)).body(text)
|
||||
.send().await.map_err(|_| Error::Transport)?;
|
||||
let status = response.status().as_u16();
|
||||
Ok((status, response.json().await.map_err(|_| Error::InvalidResponse)?))
|
||||
}
|
||||
pub async fn join(&self, device: &str, force_join: bool, retry: bool) -> Result<JoinData, Error> {
|
||||
let path = format!("/api/v1/room/join/by_device/{}", path_segment(device)?);
|
||||
let mut retries = 0;
|
||||
loop {
|
||||
let result = match self.request(reqwest::Method::POST, &path, Some(json!({"force_join":force_join}))).await {
|
||||
Ok((status, body)) => {
|
||||
// Structure only (codes and key names), never the room token or URLs.
|
||||
let shape = crate::protocol::json_shape(&body, 3);
|
||||
let server_msg = body.get("msg").and_then(Value::as_str).map(|m| m.chars().take(120).collect::<String>());
|
||||
let parsed = parse_join(status, body);
|
||||
if parsed.is_err() {
|
||||
// UU_VIEWER_DEBUG=1 adds the server's short error message (like UU_ASSIST_DEBUG on the host).
|
||||
let msg = std::env::var("UU_VIEWER_DEBUG").is_ok_and(|v| v == "1").then_some(server_msg).flatten();
|
||||
log::warn!("Join response: status={status} shape={shape} msg={msg:?}");
|
||||
}
|
||||
parsed
|
||||
}
|
||||
Err(e) => Err(e),
|
||||
};
|
||||
match result {
|
||||
Ok(data) => {
|
||||
if data.token.is_empty() || data.signaling_list.is_empty() { return Err(Error::MissingRoom); }
|
||||
return Ok(data);
|
||||
}
|
||||
Err(error) => match retry_delay(&error, retries, retry) {
|
||||
Some(delay) => { tokio::time::sleep(delay).await; retries += 1; }
|
||||
None => return Err(error),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Remove a device from the account (official 「删除设备」). Paths from the Windows host strings
|
||||
/// `/api/v1/device/%s/unbind` and `/api/v1/device/share/%s/unbind` (own vs. shared-with-me device).
|
||||
/// POST verified live against an own device; the shared-device path is from strings only.
|
||||
pub async fn unbind(&self, device: &str, shared: bool) -> Result<(), Error> {
|
||||
let segment = path_segment(device)?;
|
||||
let path = if shared { format!("/api/v1/device/share/{segment}/unbind") } else { format!("/api/v1/device/{segment}/unbind") };
|
||||
let (status, body) = self.request(reqwest::Method::POST, &path, None).await?;
|
||||
parse_ack(status, body)
|
||||
}
|
||||
/// Structure-only probe of the device list (status, JSON keys/types/lengths, never values).
|
||||
pub async fn devices_shape(&self, method: reqwest::Method) -> Result<String, Error> {
|
||||
let path = "/api/v1/device/list";
|
||||
let response = self.http.request(method.clone(), format!("{}{path}", self.base))
|
||||
.headers(self.signer.build_headers(method.as_str(), path, "")).send().await.map_err(|_| Error::Transport)?;
|
||||
let status = response.status().as_u16();
|
||||
let bytes = response.bytes().await.map_err(|_| Error::InvalidResponse)?;
|
||||
Ok(match serde_json::from_slice::<Value>(&bytes) {
|
||||
Ok(v) => format!("status={status} shape={}", crate::protocol::json_shape(&v, 7)),
|
||||
Err(_) => format!("status={status} non_json_bytes={}", bytes.len()),
|
||||
})
|
||||
}
|
||||
/// GET /api/v1/device/list → data {current_device, my_binded_devices[], others_shared_devices[]} (observed live).
|
||||
pub async fn device_list(&self) -> Result<Value, Error> {
|
||||
let (status, body) = self.request(reqwest::Method::GET, "/api/v1/device/list", None).await?;
|
||||
if body.get("code").and_then(Value::as_i64) == Some(1120) { return Err(Error::AuthenticationExpired); }
|
||||
if status != 200 || body.get("code").and_then(Value::as_i64) != Some(0) { return Err(Error::InvalidResponse); }
|
||||
body.get("data").cloned().ok_or(Error::InvalidResponse)
|
||||
}
|
||||
pub async fn target_is_mac(&self,room:&JoinData,device:Option<&str>)->Result<bool,Error>{
|
||||
let platform=match room.publisher_platform {
|
||||
Some(platform)=>Some(i64::from(platform)),
|
||||
None=>match device {
|
||||
Some(device)=>device_platform(&self.device_list().await?,device),
|
||||
None=>None,
|
||||
},
|
||||
};
|
||||
// Observed device/share platforms: 1 = Windows (also our Linux host), 4 = Mac.
|
||||
match platform {
|
||||
Some(1)=>Ok(false),
|
||||
Some(4)=>Ok(true),
|
||||
_=>Err(Error::UnknownKeyboardPlatform),
|
||||
}
|
||||
}
|
||||
/// Method and wire-key mapping remain unverified. Caller must select both explicitly.
|
||||
pub async fn devices(&self, method: reqwest::Method, array_pointer: &str) -> Result<Vec<Value>, Error> {
|
||||
let (status, body) = self.request(method, "/api/v1/device/list", None).await?;
|
||||
if body.get("code").and_then(Value::as_i64) == Some(1120) { return Err(Error::AuthenticationExpired); }
|
||||
if status != 200 || body.get("code").and_then(Value::as_i64) != Some(0) { return Err(Error::InvalidResponse); }
|
||||
body.pointer(array_pointer).and_then(Value::as_array).cloned().ok_or(Error::InvalidResponse)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test] fn unbind_ack_and_device_segment(){
|
||||
use super::*;
|
||||
assert_eq!(parse_ack(200,json!({"code":0,"msg":"ok"})),Ok(()));
|
||||
assert_eq!(parse_ack(422,json!({"code":1120})),Err(Error::AuthenticationExpired));
|
||||
assert_eq!(parse_ack(200,json!({"code":5003,"msg":"no such device"})),Err(Error::Api(5003,"no such device".into())));
|
||||
assert_eq!(parse_ack(404,json!({})),Err(Error::Api(-1,String::new())));
|
||||
assert_eq!(path_segment("a/b?c").unwrap(),"a%2Fb%3Fc");
|
||||
for bad in ["",".",".."]{assert_eq!(path_segment(bad),Err(Error::InvalidDevice));}
|
||||
}
|
||||
use super::*;
|
||||
#[test]
|
||||
fn target_platform_matches_only_the_selected_device(){
|
||||
let data=json!({"my_binded_devices":[{"device_id":"windows","platform":1},{"device_id":"mac","platform":4}],
|
||||
"others_shared_devices":[{"device_id":"shared-mac","platform":4}]});
|
||||
assert_eq!(device_platform(&data,"windows"),Some(1));
|
||||
assert_eq!(device_platform(&data,"mac"),Some(4));
|
||||
assert_eq!(device_platform(&data,"shared-mac"),Some(4));
|
||||
assert_eq!(device_platform(&data,"missing"),None);
|
||||
assert_eq!(device_platform(&json!({}),"mac"),None);
|
||||
}
|
||||
#[test]
|
||||
fn assistance_response_validation_and_safe_user_errors() {
|
||||
let mut fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
|
||||
fixture["data"]["publisher_device_id"]=json!("synthetic-publisher");
|
||||
fixture["data"]["share_id"]=json!("synthetic-share");
|
||||
assert!(!parse_share(200,fixture.clone(),&[]).unwrap().token.is_empty());
|
||||
for key in ["token","signaling_list"] {
|
||||
let mut v=fixture.clone();v["data"].as_object_mut().unwrap().remove(key);
|
||||
assert_eq!(parse_share(200,v,&[]).err().unwrap(),Error::MissingRoom);
|
||||
}
|
||||
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
|
||||
assert_eq!(parse_share(422,json!({"code":9876,"msg":msg}),&[]).err().unwrap().to_string(),format!("{msg} (code 9876)"));
|
||||
}
|
||||
assert_eq!(parse_share(422,json!({"code":9876,"msg":"fixture-code\nfixture-token"}),&["fixture-code","fixture-token",""]).err().unwrap(),Error::Api(9876,"[已隐藏][已隐藏]".into()));
|
||||
assert_eq!(parse_share(422,json!({"code":1120,"msg":"expired"}),&[]).err().unwrap(),Error::AuthenticationExpired);
|
||||
assert_eq!(parse_share(200,json!({"code":0,"msg":"","data":{}}),&[]).err().unwrap(),Error::InvalidResponse);
|
||||
}
|
||||
#[test]
|
||||
fn join_schema_defaults_required_types_and_error_policy() {
|
||||
let fixture: Value = serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
|
||||
let data = parse_join(200, fixture.clone()).unwrap();
|
||||
assert_eq!(data.signaling_list.len(), 1);
|
||||
assert_eq!(data.publisher_platform,None);
|
||||
let mut empty=fixture.clone();empty["data"]["publisher_platform"]=Value::Null;
|
||||
assert_eq!(parse_join(200,empty).unwrap().publisher_platform,None);
|
||||
let mut mac=fixture.clone();mac["data"]["publisher_platform"]=json!(4);
|
||||
assert_eq!(parse_join(200,mac).unwrap().publisher_platform,Some(4));
|
||||
for key in ["report_token", "report_url"] {
|
||||
let mut v = fixture.clone(); v["data"].as_object_mut().unwrap().remove(key);
|
||||
assert!(matches!(parse_join(200,v), Err(Error::InvalidResponse)));
|
||||
let mut v = fixture.clone(); v["data"][key] = Value::Null;
|
||||
assert!(matches!(parse_join(200,v), Err(Error::InvalidResponse)));
|
||||
}
|
||||
let v = json!({"code":0,"msg":"","data":{"report_token":"","report_url":""}});
|
||||
let d = parse_join(200,v).unwrap();
|
||||
assert!(d.token.is_empty() && d.signaling_list.is_empty() && !d.international_connect);
|
||||
assert_eq!(d.ws_connect_timeout_ms,0); assert_eq!(d.streamer_retry_delta_ms,0);
|
||||
assert!(matches!(parse_join(503,fixture),Err(Error::Api(503, _))));
|
||||
for data in [Value::Null,json!([]),json!("ignored")] {
|
||||
assert!(matches!(parse_join(422,json!({"code":1120,"msg":"","data":data})),Err(Error::AuthenticationExpired)));
|
||||
}
|
||||
for code in [-1,2002,2006,2007,4042] { assert_eq!(retry_delay(&Error::Api(code,String::new()),0,true),None); }
|
||||
for retries in 0..5 { assert_eq!(retry_delay(&Error::Api(5000,String::new()),retries,true),Some(Duration::from_millis(3000))); }
|
||||
assert_eq!(retry_delay(&Error::Api(5000,String::new()),5,true),None);
|
||||
assert_eq!(retry_delay(&Error::Api(5000,String::new()),0,false),None);
|
||||
for error in [Error::Transport,Error::InvalidResponse,Error::AuthenticationExpired] { assert_eq!(retry_delay(&error,0,true),None); }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod http_tests {
|
||||
use super::*;
|
||||
use crate::auth::Credentials;
|
||||
use tokio::{io::{AsyncReadExt,AsyncWriteExt},net::TcpListener};
|
||||
pub async fn server(replies:Vec<(u16,Value)>)->(String,tokio::task::JoinHandle<Vec<String>>) {
|
||||
server_raw(replies.into_iter().map(|(status,body)|(status,body.to_string())).collect()).await
|
||||
}
|
||||
async fn server_raw(replies:Vec<(u16,String)>)->(String,tokio::task::JoinHandle<Vec<String>>) {
|
||||
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();
|
||||
let url=format!("http://{}",listener.local_addr().unwrap());
|
||||
let job=tokio::spawn(async move {
|
||||
let mut requests=Vec::new();
|
||||
for (status,body) in replies {
|
||||
let(mut stream,_)=listener.accept().await.unwrap();let mut request=Vec::new();let mut buf=[0;1024];
|
||||
loop {
|
||||
let n=stream.read(&mut buf).await.unwrap();assert_ne!(n,0);request.extend_from_slice(&buf[..n]);
|
||||
if let Some(end)=request.windows(4).position(|w|w==b"\r\n\r\n") {
|
||||
let headers=String::from_utf8_lossy(&request[..end]);
|
||||
let length=headers.lines().find_map(|l|l.to_lowercase().strip_prefix("content-length:").map(str::trim).and_then(|s|s.parse::<usize>().ok())).unwrap_or(0);
|
||||
if request.len()>=end+4+length {break}
|
||||
}
|
||||
}
|
||||
requests.push(String::from_utf8(request).unwrap());
|
||||
let reply=format!("HTTP/1.1 {status} Mock\r\nContent-Type: application/json\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{body}",body.len());
|
||||
stream.write_all(reply.as_bytes()).await.unwrap();
|
||||
}
|
||||
requests
|
||||
});
|
||||
(url,job)
|
||||
}
|
||||
fn signer()->UUAuthClient {UUAuthClient::new(Credentials{token:"synthetic-auth".into(),sign_key:"synthetic-key".into(),..Default::default()})}
|
||||
fn room(platform:Option<i32>)->JoinData {
|
||||
let mut room=parse_join(200,serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap()).unwrap();
|
||||
room.publisher_platform=platform;room
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn keyboard_platform_uses_room_metadata_without_device_lookup(){
|
||||
let api=Api::new(signer(),"http://127.0.0.1:1");
|
||||
for device in [None,Some("synthetic-device")] {
|
||||
assert_eq!(api.target_is_mac(&room(Some(1)),device).await,Ok(false));
|
||||
assert_eq!(api.target_is_mac(&room(Some(4)),device).await,Ok(true));
|
||||
for platform in [0,-1,2,3,5,999,i32::MIN,i32::MAX] {
|
||||
assert_eq!(api.target_is_mac(&room(Some(platform)),device).await,Err(Error::UnknownKeyboardPlatform));
|
||||
}
|
||||
}
|
||||
assert_eq!(api.target_is_mac(&room(None),None).await,Err(Error::UnknownKeyboardPlatform));
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn keyboard_platform_looks_up_only_the_selected_account_device(){
|
||||
for list in ["my_binded_devices","others_shared_devices"] {
|
||||
for (platform,mac) in [(1,false),(4,true)] {
|
||||
let data=json!({list:[{"device_id":"unrelated","platform":4},
|
||||
{"device_id":"synthetic-device","platform":platform}]});
|
||||
let(url,job)=server(vec![(200,json!({"code":0,"data":data}))]).await;
|
||||
assert_eq!(Api::new(signer(),&url).target_is_mac(&room(None),Some("synthetic-device")).await,Ok(mac));
|
||||
let requests=job.await.unwrap();assert_eq!(requests.len(),1);
|
||||
assert!(requests[0].starts_with("GET /api/v1/device/list "));
|
||||
}
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn keyboard_platform_rejects_unknown_or_malformed_device_metadata(){
|
||||
let mut devices=vec![json!({"device_id":"unrelated","platform":4}),json!({"device_id":"synthetic-device"})];
|
||||
for platform in [json!(0),json!(-1),json!(999),json!("4"),json!(true),json!(4.5),json!(null),json!(u64::MAX)] {
|
||||
devices.push(json!({"device_id":"synthetic-device","platform":platform}));
|
||||
}
|
||||
for device in devices {
|
||||
let data=json!({"my_binded_devices":[device]});
|
||||
let(url,job)=server(vec![(200,json!({"code":0,"data":data}))]).await;
|
||||
assert_eq!(Api::new(signer(),&url).target_is_mac(&room(None),Some("synthetic-device")).await,Err(Error::UnknownKeyboardPlatform));
|
||||
assert_eq!(job.await.unwrap().len(),1);
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn keyboard_platform_propagates_device_lookup_failures(){
|
||||
for (status,body,error) in [
|
||||
(422,json!({"code":1120}),Error::AuthenticationExpired),
|
||||
(503,json!({"code":5000}),Error::InvalidResponse),
|
||||
(200,json!({"code":0}),Error::InvalidResponse),
|
||||
] {
|
||||
let(url,job)=server(vec![(status,body)]).await;
|
||||
assert_eq!(Api::new(signer(),&url).target_is_mac(&room(None),Some("synthetic-device")).await,Err(error));
|
||||
assert_eq!(job.await.unwrap().len(),1);
|
||||
}
|
||||
let api=Api::new(signer(),"http://127.0.0.1:1");
|
||||
assert_eq!(api.target_is_mac(&room(None),Some("synthetic-device")).await,Err(Error::Transport));
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn signed_join_and_explicit_device_list_use_only_loopback_http() {
|
||||
let fixture=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
|
||||
let(url,job)=server(vec![(200,json!({"code":0,"data":{"synthetic_devices":[{"id":"synthetic-device","name":"fixture"}]}})),(200,fixture)]).await;
|
||||
let api=Api::new(signer(),&url);
|
||||
let devices=api.devices(reqwest::Method::GET,"/data/synthetic_devices").await.unwrap();assert_eq!(devices.len(),1);
|
||||
assert!(api.join("",true,true).await.is_err());
|
||||
api.join("synthetic-device",true,true).await.unwrap();
|
||||
let requests=job.await.unwrap();assert!(requests[0].starts_with("GET /api/v1/device/list "));
|
||||
assert!(requests[1].starts_with("POST /api/v1/room/join/by_device/synthetic-device "));
|
||||
assert!(requests[1].to_lowercase().contains("x-param-sign:"));
|
||||
assert_eq!(requests[1].split("\r\n\r\n").nth(1).unwrap(),r#"{"force_join":true}"#);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn assistance_uses_signed_json_and_only_http_endpoint_fallback() {
|
||||
let mut fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
|
||||
// Extra share identity fields do not change the existing room parser.
|
||||
fixture["data"]["share_id"]=json!("synthetic-share");
|
||||
fixture["data"]["publisher_device_id"]=json!("synthetic-publisher");
|
||||
fixture["data"]["publisher_platform"]=json!(1);
|
||||
for status in [200,404,405] {
|
||||
let replies=if status==200 {vec![(200,fixture.to_string())]} else {vec![(status,"<html>endpoint unavailable</html>".into()),(200,fixture.to_string())]};
|
||||
let(url,job)=server_raw(replies).await;
|
||||
let room=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.unwrap();
|
||||
assert!(!room.token.is_empty());assert_eq!(room.signaling_list.len(),1);
|
||||
let requests=job.await.unwrap();assert_eq!(requests.len(),if status==200{1}else{2});
|
||||
for (i,request) in requests.iter().enumerate() {
|
||||
let version=if i==0{2}else{1};
|
||||
assert!(request.starts_with(&format!("POST /api/v{version}/room/join/share/by_code ")));
|
||||
let(headers,body)=request.split_once("\r\n\r\n").unwrap();
|
||||
assert!(!headers.contains("synthetic-code"));
|
||||
assert!(headers.to_lowercase().contains("x-param-sign:"));
|
||||
assert!(headers.to_lowercase().contains("content-type: application/json"));
|
||||
assert_eq!(serde_json::from_str::<Value>(body).unwrap(),json!({"connect_id":"synthetic-id","connect_code":"synthetic-code"}));
|
||||
}
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn assistance_reports_actual_errors_without_retrying_or_echoing_secrets() {
|
||||
for msg in ["验证码错误","对方未开启协助","无法对同账号的设备发起远程协助"] {
|
||||
let(url,job)=server(vec![(422,json!({"code":9876,"msg":msg}))]).await;
|
||||
let error=Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap();
|
||||
assert_eq!(error.to_string(),format!("{msg} (code 9876)"));assert_eq!(job.await.unwrap().len(),1);
|
||||
}
|
||||
for (status,body,expected) in [
|
||||
(200,json!({"code":405,"msg":"业务拒绝"}),Error::Api(405,"业务拒绝".into())),
|
||||
(500,json!({"code":5000,"msg":"服务忙"}),Error::Api(5000,"服务忙".into())),
|
||||
(422,json!({"code":1120,"msg":""}),Error::AuthenticationExpired),
|
||||
(200,json!({"code":0,"msg":"","data":{"report_url":"","report_token":""}}),Error::MissingRoom),
|
||||
(200,json!({"code":0,"msg":"","data":{}}),Error::InvalidResponse),
|
||||
(422,json!({"code":9876,"msg":"synthetic-code synthetic-auth"}),Error::Api(9876,"[已隐藏] [已隐藏]".into())),
|
||||
] {
|
||||
let(url,job)=server(vec![(status,body)]).await;
|
||||
assert_eq!(Api::new(signer(),&url).join_share("synthetic-id","synthetic-code").await.err().unwrap(),expected);
|
||||
assert_eq!(job.await.unwrap().len(),1);
|
||||
}
|
||||
let api=Api::new(signer(),"http://127.0.0.1:1");
|
||||
for (id,code) in [("","fixture"),("id",""),("id","a\nb")] {assert_eq!(api.join_share(id,code).await.err().unwrap(),Error::InvalidAssist);}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn retry_stops_after_five_delays_and_terminal_errors_stop_immediately() {
|
||||
let(url,job)=server(vec![(503,json!({"code":5000,"msg":"fixture"}));6]).await;
|
||||
let start=tokio::time::Instant::now();
|
||||
assert!(matches!(Api::new(signer(),&url).join("synthetic-device",false,true).await,Err(Error::Api(5000, _))));
|
||||
assert!(start.elapsed()>=Duration::from_secs(15));assert_eq!(job.await.unwrap().len(),6);
|
||||
for code in [-1,1120,2002,2006,2007,4042] {
|
||||
let(url,job)=server(vec![(422,json!({"code":code,"msg":"fixture"}))]).await;
|
||||
let error=Api::new(signer(),&url).join("synthetic-device",false,true).await.err().unwrap();
|
||||
if code==1120 {assert_eq!(error,Error::AuthenticationExpired)} else {assert!(matches!(error,Error::Api(c,_) if c==code))}
|
||||
assert_eq!(job.await.unwrap().len(),1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod strict_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn rejects_wrong_json_types_and_missing_envelope_members() {
|
||||
let fixture:Value=serde_json::from_str(include_str!("../../tests/fixtures/viewer/join.json")).unwrap();
|
||||
for (key,bad) in [("token",json!(false)),("signaling_list",json!([7])),("ws_connect_timeout_ms",json!(2147483648u64)),("streamer_retry_delta_ms",json!(null)),("international_connect",json!(1)),("report_token",json!(null)),("report_url",json!(7)),("report_server_address",json!([]))] {
|
||||
let mut v=fixture.clone();v["data"][key]=bad;assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
|
||||
}
|
||||
for platform in [json!("4"),json!(true),json!(4.5),json!(2147483648u64),json!(-2147483649i64)] {
|
||||
let mut v=fixture.clone();v["data"]["publisher_platform"]=platform;
|
||||
assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
|
||||
}
|
||||
for key in ["code","msg"] {
|
||||
let mut v=fixture.clone();v.as_object_mut().unwrap().remove(key);assert!(matches!(parse_join(200,v),Err(Error::InvalidResponse)));
|
||||
}
|
||||
assert!(matches!(parse_join(200,json!({"code":0,"msg":"","data":{}})),Err(Error::InvalidResponse)));
|
||||
assert!(matches!(parse_join(200,json!({"code":2147483648u64,"msg":""})),Err(Error::InvalidResponse)));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
//! Assistance secrets travel only through memory and the child's stdin pipe.
|
||||
use std::{io::BufRead,path::Path,process::Stdio};
|
||||
use tokio::{io::AsyncWriteExt,process::{Child,Command}};
|
||||
|
||||
pub fn read_code(input: impl BufRead) -> Result<String,String> {
|
||||
let mut code=String::new();
|
||||
input.take(1025).read_line(&mut code).map_err(|_|"无法从 stdin 读取验证码")?;
|
||||
if code.len()>1024 {return Err("验证码过长".into())}
|
||||
if code.ends_with('\n') {code.pop();if code.ends_with('\r'){code.pop();}}
|
||||
if code.trim().is_empty() || code.chars().any(char::is_control) {return Err("请输入有效验证码".into())}
|
||||
Ok(code)
|
||||
}
|
||||
pub fn command(exe:&Path,id:&str)->Command {
|
||||
let mut command=Command::new(exe);
|
||||
command.args(["assist",id]).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::piped()).kill_on_drop(true);
|
||||
command
|
||||
}
|
||||
pub async fn send_code(child:&mut Child,code:&str)->Result<(),String> {
|
||||
let result=async {
|
||||
let mut stdin=child.stdin.take().ok_or("无法打开会话输入管道")?;
|
||||
stdin.write_all(code.as_bytes()).await.map_err(|_|"无法向会话传递验证码")?;
|
||||
stdin.write_all(b"\n").await.map_err(|_|"无法向会话传递验证码")?;
|
||||
stdin.shutdown().await.map_err(|_|"无法关闭会话输入管道")
|
||||
}.await;
|
||||
if result.is_err() {let _=child.kill().await;}
|
||||
result.map_err(str::to_owned)
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[test] fn stdin_reads_one_line_without_changing_code() {
|
||||
assert_eq!(read_code(&b"a b\r\nignored\n"[..]).unwrap(),"a b");
|
||||
assert_eq!(read_code(&b"fixture"[..]).unwrap(),"fixture");
|
||||
for input in ["","\n"," \r\n","a\tb\n","a\0b\n",&"x".repeat(1025)] {assert!(read_code(input.as_bytes()).is_err());}
|
||||
}
|
||||
#[tokio::test] async fn launcher_passes_only_id_in_arguments_and_closes_stdin() {
|
||||
let command=command(Path::new("/bin/sh"),"synthetic-id");
|
||||
assert_eq!(command.as_std().get_args().collect::<Vec<_>>(),["assist","synthetic-id"]);
|
||||
// Local process mock: echo the pipe after EOF, without files or credentials.
|
||||
let mut child=Command::new("/bin/sh").args(["-c","cat"]).stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().unwrap();
|
||||
send_code(&mut child,"synthetic-code").await.unwrap();
|
||||
let output=child.wait_with_output().await.unwrap();
|
||||
assert!(output.status.success());assert_eq!(output.stdout,b"synthetic-code\n");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
use super::media::Latest;
|
||||
|
||||
const PACKETS:usize=12;
|
||||
const MAX_PACKET:usize=8192;
|
||||
#[derive(Clone)]
|
||||
pub struct Packet { seq:u16, data:Vec<u8> }
|
||||
#[derive(Clone)]
|
||||
pub struct Audio { packets:Latest<Packet>, enabled:bool }
|
||||
impl Default for Audio {
|
||||
fn default()->Self {Self{packets:Latest::new(PACKETS),enabled:std::env::var("UU_VIEWER_AUDIO").map_or(true,|v|v!="0")}}
|
||||
}
|
||||
impl Audio {
|
||||
#[cfg(test)] pub fn pop(&self)->Option<Vec<u8>> {self.packets.pop().map(|p|p.data)}
|
||||
pub fn push(&self,seq:u16,data:&[u8]) {
|
||||
if self.enabled && data.len()<=MAX_PACKET && samples(data).is_some() {self.packets.push(Packet{seq,data:data.to_vec()});}
|
||||
}
|
||||
}
|
||||
fn samples(data:&[u8])->Option<u64> {
|
||||
let toc=*data.first()?;
|
||||
let frame=if toc&0x80!=0 {120u64<<(toc>>3&3)} else if toc&0x60==0x60 {if toc&8!=0 {960}else{480}} else {match toc>>3&3 {3=>2880,n=>480u64<<n}};
|
||||
let count=match toc&3 {0=>1,1|2=>2,_=>u64::from(*data.get(1)?&63)};
|
||||
let total=frame*count;(count>0 && total<=5760).then_some(total)
|
||||
}
|
||||
|
||||
// One complete packet per page; zero pre-skip because RTP has no encoder pre-skip header.
|
||||
#[derive(Default)]
|
||||
struct Ogg { sequence:u32, granule:u64, last:Option<u16> }
|
||||
impl Ogg {
|
||||
fn page(&mut self,payload:&[u8],flags:u8)->Vec<u8> {
|
||||
let mut page=b"OggS\0".to_vec();page.push(flags);page.extend(self.granule.to_le_bytes());
|
||||
page.extend(1u32.to_le_bytes());page.extend(self.sequence.to_le_bytes());self.sequence=self.sequence.wrapping_add(1);
|
||||
page.extend([0;4]);page.push((payload.len()/255+1) as u8);
|
||||
page.extend(std::iter::repeat(255).take(payload.len()/255));page.push((payload.len()%255) as u8);page.extend(payload);
|
||||
let mut crc=0u32;
|
||||
for byte in &page {crc^=u32::from(*byte)<<24;for _ in 0..8 {crc=if crc&0x80000000!=0 {(crc<<1)^0x04c11db7}else{crc<<1};}}
|
||||
page[22..26].copy_from_slice(&crc.to_le_bytes());page
|
||||
}
|
||||
fn headers(&mut self)->Vec<u8> {
|
||||
let mut head=b"OpusHead\x01\x02\0\0".to_vec();head.extend(48000u32.to_le_bytes());head.extend([0,0,0]);
|
||||
let mut out=self.page(&head,2);let mut tags=b"OpusTags".to_vec();tags.extend([0;8]);out.extend(self.page(&tags,0));out
|
||||
}
|
||||
fn packet(&mut self,packet:Packet)->Option<Vec<u8>> {
|
||||
if self.last.is_some_and(|last|{let delta=packet.seq.wrapping_sub(last);delta==0 || delta>=0x8000}) {return None}
|
||||
self.granule+=samples(&packet.data)?;self.last=Some(packet.seq);Some(self.page(&packet.data,0))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
mod playback {
|
||||
use super::*;
|
||||
use tokio::{io::{AsyncReadExt,AsyncWriteExt},process::{Child,Command},task::JoinHandle};
|
||||
use std::{process::Stdio,time::Duration};
|
||||
const PCM_SAMPLES:usize=1920;
|
||||
const PCM_BYTES:usize=PCM_SAMPLES*2;
|
||||
const SDL_BYTES:u32=48000*2*2/10;
|
||||
struct Decoder { child:Option<Child>, tasks:Vec<JoinHandle<()>>, pcm:Latest<Vec<i16>> }
|
||||
impl Decoder {
|
||||
fn new(audio:Audio)->Result<Self,String> {
|
||||
let mut child=Command::new(std::env::var_os("UU_VIEWER_FFMPEG").unwrap_or_else(||"ffmpeg".into()))
|
||||
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
|
||||
"-f","ogg","-i","pipe:0","-vn","-ac","2","-ar","48000","-c:a","pcm_s16le","-f","s16le","-flush_packets","1","pipe:1"])
|
||||
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|"Audio decoder start failed")?;
|
||||
let mut input=child.stdin.take().ok_or("Audio decoder stdin missing")?;
|
||||
let mut output=child.stdout.take().ok_or("Audio decoder stdout missing")?;
|
||||
let pcm=Latest::new(PACKETS);let decoded=pcm.clone();
|
||||
let writer=tokio::spawn(async move {
|
||||
let mut ogg=Ogg::default();
|
||||
let result:std::io::Result<()>=async {
|
||||
input.write_all(&ogg.headers()).await?;
|
||||
let mut tick=tokio::time::interval(Duration::from_millis(4));
|
||||
loop {
|
||||
tick.tick().await;
|
||||
while let Some(packet)=audio.packets.pop() {if let Some(page)=ogg.packet(packet) {
|
||||
tokio::time::timeout(Duration::from_secs(1),input.write_all(&page)).await??;
|
||||
}}
|
||||
}
|
||||
}.await;
|
||||
if result.is_err() {log::warn!("Viewer audio decoder input stopped");}
|
||||
});
|
||||
let reader=tokio::spawn(async move {
|
||||
let mut bytes=[0u8;PCM_BYTES];
|
||||
while output.read_exact(&mut bytes).await.is_ok() {
|
||||
decoded.push(bytes.chunks_exact(2).map(|b|i16::from_le_bytes([b[0],b[1]])).collect());
|
||||
}
|
||||
});
|
||||
Ok(Self{child:Some(child),tasks:vec![writer,reader],pcm})
|
||||
}
|
||||
fn alive(&mut self)->bool {self.child.as_mut().is_some_and(|child|matches!(child.try_wait(),Ok(None))) && self.tasks.iter().all(|t|!t.is_finished())}
|
||||
}
|
||||
impl Drop for Decoder {
|
||||
fn drop(&mut self) {
|
||||
for task in &self.tasks {task.abort();}
|
||||
if let Some(mut child)=self.child.take() {let _=child.start_kill();tokio::spawn(async move {let _=child.wait().await;});}
|
||||
}
|
||||
}
|
||||
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder }
|
||||
impl Playback {
|
||||
pub fn new(sdl:&sdl2::Sdl,audio:Audio)->Option<Self> {
|
||||
if !audio.enabled {return None}
|
||||
let result=(|| {
|
||||
let subsystem=sdl.audio()?;
|
||||
let queue=subsystem.open_queue::<i16,_>(None,&sdl2::audio::AudioSpecDesired{freq:Some(48000),channels:Some(2),samples:Some(960)})?;
|
||||
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder})
|
||||
})();
|
||||
match result {Ok(p)=>Some(p),Err(_)=>{log::warn!("Viewer audio playback unavailable");None}}
|
||||
}
|
||||
pub fn pump(&mut self)->Result<(),String> {
|
||||
if !self.decoder.alive() {return Err("Audio decoder stopped".into())}
|
||||
while let Some(samples)=self.decoder.pcm.pop() {
|
||||
if self.queue.size()+samples.len() as u32*2>SDL_BYTES {self.queue.clear();}
|
||||
self.queue.queue_audio(&samples).map_err(|_|"Audio queue failed")?;
|
||||
}Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[tokio::test] async fn sdl_dummy_queue_is_bounded_and_audio_can_be_disabled() {
|
||||
if std::env::var_os("UU_VIEWER_AUDIO_TEST_CHILD").is_none() {
|
||||
let output=std::process::Command::new(std::env::current_exe().unwrap()).args(["--exact","viewer::audio::playback::tests::sdl_dummy_queue_is_bounded_and_audio_can_be_disabled","--test-threads=1"])
|
||||
.env("SDL_AUDIODRIVER","dummy").env("UU_VIEWER_AUDIO_TEST_CHILD","1").output().unwrap();
|
||||
assert!(output.status.success(),"{}",String::from_utf8_lossy(&output.stdout));return
|
||||
}
|
||||
let sdl=sdl2::init().unwrap();
|
||||
assert!(Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:false}).is_none());
|
||||
let mut playback=Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:true}).unwrap();playback.queue.pause();
|
||||
for value in 0..100 {playback.decoder.pcm.push(vec![value;PCM_SAMPLES]);}
|
||||
playback.pump().unwrap();assert!(playback.queue.size()>0 && playback.queue.size()<=SDL_BYTES);
|
||||
assert!(playback.decoder.pcm.pop().is_none());
|
||||
}
|
||||
#[tokio::test] async fn ffmpeg_streams_pcm_before_eof_and_is_reaped() {
|
||||
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};let mut decoder=Decoder::new(audio.clone()).unwrap();
|
||||
let id=decoder.child.as_ref().unwrap().id().unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(5),async {
|
||||
for seq in 0..250 {audio.push(seq,&[0xf8,0xff,0xfe]);tokio::time::sleep(Duration::from_millis(8)).await;
|
||||
if let Some(pcm)=decoder.pcm.pop() {assert_eq!(pcm.len(),PCM_SAMPLES);assert!(decoder.alive());return}
|
||||
}panic!("No PCM before EOF");
|
||||
}).await.unwrap();
|
||||
drop(decoder);
|
||||
tokio::time::timeout(Duration::from_secs(2),async {while unsafe{libc::kill(id as i32,0)}==0 {tokio::time::sleep(Duration::from_millis(10)).await;}}).await.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")] pub use playback::Playback;
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[test] fn duration_bounds_and_latest_packets() {
|
||||
assert_eq!(samples(&[0xf8,0xff,0xfe]),Some(960));assert_eq!(samples(&[0x98]),Some(960));
|
||||
assert_eq!(samples(&[0x18]),Some(2880));assert_eq!(samples(&[0x83,48]),Some(5760));
|
||||
assert_eq!(samples(&[0x83,49]),None);assert_eq!(samples(&[3,0]),None);assert_eq!(samples(&[]),None);
|
||||
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};
|
||||
for seq in 0..1000 {audio.push(seq,&[0xf8,0xff,0xfe]);}
|
||||
audio.push(1000,&vec![0;MAX_PACKET+1]);audio.push(1000,&[]);
|
||||
for seq in 988..1000 {assert_eq!(audio.packets.pop().unwrap().seq,seq);}assert!(audio.packets.pop().is_none());
|
||||
let disabled=Audio{enabled:false,..audio};disabled.push(0,&[0xf8,0xff,0xfe]);assert!(disabled.packets.pop().is_none());
|
||||
}
|
||||
#[test] fn ogg_headers_crc_lacing_and_sequence_wrap() {
|
||||
let mut ogg=Ogg::default();let headers=ogg.headers();assert_eq!(&headers[..4],b"OggS");assert_eq!(&headers[28..36],b"OpusHead");
|
||||
let page=ogg.page(&vec![0;255],0);assert_eq!(&page[27..29],&[255,0]);
|
||||
let mut stream=headers;stream.extend(&page);
|
||||
let (mut reader,head)=webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream.clone()),true).unwrap();
|
||||
assert_eq!(head.channels,2);assert_eq!(head.sample_rate,48000);
|
||||
assert!(reader.parse_next_page().unwrap().0.starts_with(b"OpusTags"));
|
||||
assert_eq!(reader.parse_next_page().unwrap().0.len(),255);
|
||||
stream[28]^=1;assert!(webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream),true).is_err());
|
||||
let packet=|seq|Packet{seq,data:vec![0xf8,0xff,0xfe]};
|
||||
assert!(ogg.packet(packet(65535)).is_some());assert!(ogg.packet(packet(0)).is_some());
|
||||
assert!(ogg.packet(packet(0)).is_none());assert!(ogg.packet(packet(65534)).is_none());assert_eq!(ogg.granule,1920);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,381 @@
|
||||
//! Session-scoped text clipboard. Payloads never enter logs or process arguments.
|
||||
use super::{rtc::Observed,wire};
|
||||
use crate::{clipboard_protocol as text,clipboard_rich as rich,protocol::{decode_wire,WireValue}};
|
||||
use std::{path::PathBuf,process::Stdio,sync::{Arc,atomic::{AtomicBool,Ordering}},time::Duration};
|
||||
use tokio::{io::{AsyncReadExt,AsyncWriteExt},sync::mpsc};
|
||||
use webrtc::data_channel::RTCDataChannel;
|
||||
|
||||
// Same limit as src/clipboard.rs; shared host codecs enforce it on both wire formats.
|
||||
pub const MAX_TEXT:usize=30*1024;
|
||||
pub const CHANNEL:usize=1; // TEXT_DATA_CHANNEL; native host clipboard state is scoped to this channel.
|
||||
const POLL:Duration=Duration::from_millis(500);
|
||||
static WARNED:AtomicBool=AtomicBool::new(false);
|
||||
fn warn(){if !WARNED.swap(true,Ordering::Relaxed){log::warn!("Viewer text clipboard unavailable; synchronization disabled");}}
|
||||
#[derive(Clone)]
|
||||
struct CommandBackend {read:PathBuf,read_args:Vec<&'static str>,write:PathBuf,write_args:Vec<&'static str>}
|
||||
#[derive(Clone)]
|
||||
enum Backend {
|
||||
Command(CommandBackend),
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
Sdl(mpsc::Sender<ClipboardRequest>),
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
pub enum ClipboardRequest {
|
||||
Read(tokio::sync::oneshot::Sender<Result<Option<String>,()>>),
|
||||
// false means the unfocused window skipped the write.
|
||||
Write(String,tokio::sync::oneshot::Sender<Result<bool,()>>),
|
||||
}
|
||||
fn executable(name:&str)->Option<PathBuf>{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
std::env::var_os("PATH").and_then(|p|std::env::split_paths(&p).map(|d|d.join(name))
|
||||
.find(|p|std::fs::metadata(p).is_ok_and(|m|m.is_file() && m.permissions().mode()&0o111!=0)))
|
||||
}
|
||||
impl Backend {
|
||||
fn detect()->Option<Self>{
|
||||
if std::env::var("UU_VIEWER_CLIPBOARD").as_deref()==Ok("0"){return None}
|
||||
// Unit sessions must never inspect or change the developer's real clipboard.
|
||||
if !cfg!(target_os="linux") || cfg!(test){return None}
|
||||
let selected=CommandBackend::select(std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty()),executable).map(Self::Command);
|
||||
if selected.is_none(){warn();}selected
|
||||
}
|
||||
async fn read(&self)->Result<Option<String>,()>{
|
||||
match self {
|
||||
Self::Command(backend)=>backend.read().await,
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
Self::Sdl(tx)=>{
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tokio::time::timeout(Duration::from_secs(2),async {
|
||||
tx.send(ClipboardRequest::Read(reply)).await.map_err(|_|())?;
|
||||
rx.await.map_err(|_|())?
|
||||
}).await.map_err(|_|())?
|
||||
}
|
||||
}
|
||||
}
|
||||
async fn write(&self,value:&str)->Result<bool,()>{
|
||||
if value.len()>MAX_TEXT || value.contains('\0'){return Err(())}
|
||||
match self {
|
||||
Self::Command(backend)=>backend.write(value).await.map(|()|true),
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
Self::Sdl(tx)=>{
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tokio::time::timeout(Duration::from_secs(2),async {
|
||||
tx.send(ClipboardRequest::Write(value.into(),reply)).await.map_err(|_|())?;
|
||||
rx.await.map_err(|_|())?
|
||||
}).await.map_err(|_|())?
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl CommandBackend {
|
||||
fn select(wayland:bool,find:impl Fn(&str)->Option<PathBuf>)->Option<Self>{
|
||||
let selected=if wayland{
|
||||
find("wl-paste").zip(find("wl-copy")).map(|(read,write)|Self{read,write,read_args:vec!["--no-newline","--type","text"],write_args:vec!["--type","text/plain;charset=utf-8"]})
|
||||
}else{None};
|
||||
selected.or_else(||find("xclip").map(|p|Self{read:p.clone(),write:p,read_args:vec!["-selection","clipboard","-out"],write_args:vec!["-selection","clipboard","-in"]}))
|
||||
.or_else(||find("xsel").map(|p|Self{read:p.clone(),write:p,read_args:vec!["--clipboard","--output"],write_args:vec!["--clipboard","--input"]}))
|
||||
}
|
||||
async fn read(&self)->Result<Option<String>,()>{
|
||||
let mut child=tokio::process::Command::new(&self.read).args(&self.read_args).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
|
||||
let operation=async{
|
||||
let mut data=Vec::new();child.stdout.take().ok_or(())?.take((MAX_TEXT+1) as u64).read_to_end(&mut data).await.map_err(|_|())?;
|
||||
if data.len()>MAX_TEXT {let _=child.kill().await;return Ok(None)}
|
||||
// No text selection (including an image-only selection) is not a fatal backend failure.
|
||||
if !child.wait().await.map_err(|_|())?.success(){return Ok(None)}
|
||||
Ok(String::from_utf8(data).ok())
|
||||
};
|
||||
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
|
||||
}
|
||||
async fn write(&self,value:&str)->Result<(),()>{
|
||||
let mut child=tokio::process::Command::new(&self.write).args(&self.write_args).stdin(Stdio::piped()).stdout(Stdio::null()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|())?;
|
||||
let operation=async{
|
||||
let mut stdin=child.stdin.take().ok_or(())?;stdin.write_all(value.as_bytes()).await.map_err(|_|())?;drop(stdin);
|
||||
if child.wait().await.map_err(|_|())?.success(){Ok(())}else{Err(())}
|
||||
};
|
||||
tokio::time::timeout(Duration::from_secs(2),operation).await.map_err(|_|())?
|
||||
}
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct SyncState {last:Option<String>,assembly:text::Assembly,rich:rich::State,seq:u64}
|
||||
impl SyncState {
|
||||
async fn apply(&mut self,backend:&Backend,value:String)->Result<(),()>{
|
||||
if backend.write(&value).await? {
|
||||
log::info!("Viewer remote clipboard applied: bytes={}",value.len());
|
||||
self.last=Some(value);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn next(&mut self)->u64{self.seq=self.seq.wrapping_add(1).max(100);self.seq}
|
||||
/// Two requests per change: the rich format-list offer (this project's host asks for the data) and
|
||||
/// RpcRequest case 10 ClipboardTextChangeRequest carrying the text, which the official Windows host applies
|
||||
/// (handle_text_change_request -> notifyReceiveText); it only acknowledges the rich offer. Each host
|
||||
/// ignores the other form.
|
||||
fn local(&mut self,value:String)->Result<Option<Vec<Vec<u8>>>,&'static str>{
|
||||
if self.last.as_ref()==Some(&value){return Ok(None)}
|
||||
let id=self.next();let payload=self.rich.offer_any_host(id,value.clone())?;
|
||||
let rich=wire::envelope(self.next(),21,&payload);
|
||||
let text=wire::envelope(self.next(),21,&crate::clipboard_protocol::text_request(self.next(),&value));
|
||||
self.last=Some(value);Ok(Some(vec![rich,text]))
|
||||
}
|
||||
fn receive(&mut self,data:&[u8])->Result<(Vec<Vec<u8>>,Option<String>),&'static str>{
|
||||
if data.len()>MAX_TEXT*2+1024{return Err("clipboard message exceeds limit")}
|
||||
let fields=decode_wire(data).map_err(|_|"invalid clipboard envelope")?;
|
||||
let mut replies=Vec::new();let mut value=None;
|
||||
for field in fields {
|
||||
let WireValue::Bytes(payload)=field.value else{continue};
|
||||
match field.number {
|
||||
17=>if let Some(text)=self.assembly.accept(payload)?{value=Some(text)},
|
||||
21=>{
|
||||
let seq=&mut self.seq;
|
||||
let result=self.rich.request(payload,&mut ||{*seq=seq.wrapping_add(1).max(100);*seq})?;
|
||||
if result.text.is_some(){value=result.text;}
|
||||
for (kind,body) in result.messages {replies.push(wire::envelope(self.next(),kind,&body));}
|
||||
if let Some((header,text))=text::read_text_request(payload)?{
|
||||
value=Some(text);replies.push(wire::envelope(self.next(),22,&text::text_response(&header)));
|
||||
}
|
||||
},
|
||||
22=>{
|
||||
// TextChangeResponse (case 6 {1 err}, CB_SUCCEEDED=1) answers our case 10 request: status only.
|
||||
if let Some(status)=decode_wire(payload).ok().and_then(|f|f.into_iter().find_map(|x|match (x.number,x.value){(6,WireValue::Bytes(b))=>Some(b.to_vec()),_=>None})){
|
||||
let err=decode_wire(&status).ok().and_then(|f|f.into_iter().find_map(|x|match (x.number,x.value){(1,WireValue::Varint(v))=>Some(v),_=>None})).unwrap_or(0);
|
||||
log::info!("Viewer clipboard text change acknowledged: err={err}");
|
||||
}
|
||||
if let Some(text)=self.rich.response(payload)?{value=Some(text)}
|
||||
},
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
if value.as_ref().is_some_and(|text|text.contains('\0')){return Err("clipboard text contains NUL")}
|
||||
Ok((replies,value))
|
||||
}
|
||||
}
|
||||
async fn send(channel:&RTCDataChannel,message:Vec<u8>)->Result<(),()>{
|
||||
tokio::time::timeout(Duration::from_secs(2),channel.send(&bytes::Bytes::from(message))).await.map_err(|_|())?.map_err(|_|())?;Ok(())
|
||||
}
|
||||
pub struct Bridge {backend:Option<Backend>,pub enabled:bool,tx:Option<mpsc::Sender<Vec<u8>>>,task:Option<tokio::task::JoinHandle<()>>}
|
||||
impl Bridge {
|
||||
pub fn new(desktop:bool)->Self{
|
||||
let backend=if desktop{Backend::detect()}else{None};let enabled=backend.is_some();
|
||||
Self{backend,enabled,tx:None,task:None}
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
pub fn sdl(tx:mpsc::Sender<ClipboardRequest>)->Self{
|
||||
let backend=(std::env::var("UU_VIEWER_CLIPBOARD").as_deref()!=Ok("0")).then_some(Backend::Sdl(tx));
|
||||
Self{enabled:backend.is_some(),backend,tx:None,task:None}
|
||||
}
|
||||
pub fn start(&mut self,channel:&Arc<RTCDataChannel>,control:&Arc<RTCDataChannel>,observed:Arc<Observed>){
|
||||
let Some(backend)=self.backend.take() else{return};
|
||||
let (tx,mut rx)=mpsc::channel::<Vec<u8>>(16);self.tx=Some(tx);
|
||||
let channel=Arc::downgrade(channel);let control=Arc::downgrade(control);
|
||||
self.task=Some(tokio::spawn(async move{
|
||||
let mut state=SyncState::default();let mut tick=tokio::time::interval(POLL);
|
||||
let mut retries=0;let mut last_probe=std::time::Instant::now();
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
loop {
|
||||
let Some(channel)=channel.upgrade() else{break};
|
||||
tokio::select!{
|
||||
data=rx.recv()=>{
|
||||
let Some(data)=data else{break};
|
||||
if !observed.clipboard_supported.load(Ordering::Acquire){continue}
|
||||
match state.receive(&data){
|
||||
Ok((replies,value))=>{
|
||||
if let Some(value)=value {
|
||||
// Update only after the write succeeds; the next poll cannot echo it.
|
||||
if state.apply(&backend,value).await.is_err(){warn();break}
|
||||
}
|
||||
let mut failed=false;for reply in replies{if send(&channel,reply).await.is_err(){failed=true;break}}
|
||||
if failed{break}
|
||||
},
|
||||
Err(_)=>log::warn!("Viewer clipboard message rejected"),
|
||||
}
|
||||
},
|
||||
_=tick.tick()=>{
|
||||
if observed.echo_received.load(Ordering::Acquire) && !observed.control_open.load(Ordering::Acquire){break}
|
||||
if !observed.echo_received.load(Ordering::Acquire){continue}
|
||||
if !observed.clipboard_supported.load(Ordering::Acquire){
|
||||
// Host TEXT-channel initialization may finish after the initial CONTROL echo.
|
||||
if retries<5 && last_probe.elapsed()>=Duration::from_secs(1){
|
||||
retries+=1;last_probe=std::time::Instant::now();
|
||||
let Some(control)=control.upgrade() else{break};
|
||||
if send(&control,wire::echo_request_with_clipboard(1,true)).await.is_err(){break}
|
||||
}
|
||||
continue
|
||||
}
|
||||
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open{continue}
|
||||
match backend.read().await {
|
||||
Ok(Some(value))=>{let length=value.len();match state.local(value){
|
||||
Ok(Some(messages))=>{let mut failed=false;for m in messages{if send(&channel,m).await.is_err(){failed=true;break}}if failed{break}log::info!("Viewer local clipboard offered: bytes={length}");},
|
||||
Ok(None)=>{},Err(_)=>{},
|
||||
}},
|
||||
Ok(None)=>{},Err(())=>{warn();break},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}));
|
||||
}
|
||||
pub fn sender(&self)->Option<mpsc::Sender<Vec<u8>>>{self.tx.clone()}
|
||||
pub fn stop(&self){if let Some(task)=&self.task{task.abort();}}
|
||||
}
|
||||
impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
#[tokio::test] async fn sdl_backend_requests_and_invalid_text(){
|
||||
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
|
||||
let ui=tokio::spawn(async move{
|
||||
let Some(ClipboardRequest::Write(text,reply))=rx.recv().await else{panic!()};
|
||||
assert_eq!(text,"text\n");reply.send(Ok(true)).unwrap();
|
||||
let Some(ClipboardRequest::Read(reply))=rx.recv().await else{panic!()};
|
||||
reply.send(Ok(Some("text\n".into()))).unwrap();
|
||||
});
|
||||
assert!(backend.write("nul\0text").await.is_err());
|
||||
assert!(backend.write(&"a".repeat(MAX_TEXT+1)).await.is_err());
|
||||
backend.write("text\n").await.unwrap();assert_eq!(backend.read().await.unwrap().as_deref(),Some("text\n"));
|
||||
ui.await.unwrap();assert!(backend.read().await.is_err());
|
||||
}
|
||||
#[test] fn backend_priority_requires_a_complete_wayland_pair_and_falls_back(){
|
||||
let select=|wayland,names:&[&str]|CommandBackend::select(wayland,|n|names.contains(&n).then(||PathBuf::from(n)));
|
||||
let all=["wl-copy","wl-paste","xclip","xsel"];
|
||||
assert_eq!(select(true,&all).unwrap().write,PathBuf::from("wl-copy"));
|
||||
assert_eq!(select(false,&all).unwrap().write,PathBuf::from("xclip"));
|
||||
assert_eq!(select(true,&["wl-copy","xclip","xsel"]).unwrap().write,PathBuf::from("xclip"));
|
||||
assert_eq!(select(true,&["xsel"]).unwrap().write,PathBuf::from("xsel"));
|
||||
assert!(select(true,&[]).is_none());
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
#[tokio::test] async fn unfocused_write_does_not_mark_remote_text_as_applied(){
|
||||
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
|
||||
let ui=tokio::spawn(async move{
|
||||
let Some(ClipboardRequest::Write(_,reply))=rx.recv().await else{panic!()};
|
||||
reply.send(Ok(false)).unwrap();
|
||||
});
|
||||
let mut state=SyncState::default();state.last=Some("local".into());
|
||||
state.apply(&backend,"remote".into()).await.unwrap();
|
||||
assert_eq!(state.last.as_deref(),Some("local"));ui.await.unwrap();
|
||||
}
|
||||
#[test] fn limits_match_host_and_unchanged_or_remote_text_is_not_reoffered(){
|
||||
assert!(include_str!("../clipboard.rs").contains("pub const MAX_TEXT: usize = 30 * 1024;"));
|
||||
assert!(POLL>=Duration::from_millis(500));
|
||||
let mut state=SyncState::default();
|
||||
assert!(state.local("中文🙂\n".into()).unwrap().is_some());
|
||||
assert!(state.local("中文🙂\n".into()).unwrap().is_none());
|
||||
state.last=Some("remote".into());
|
||||
assert!(state.local("remote".into()).unwrap().is_none());
|
||||
assert!(state.local(String::new()).unwrap().is_some());
|
||||
assert!(state.local(String::new()).unwrap().is_none());
|
||||
assert!(state.local("a".repeat(MAX_TEXT+1)).is_err());
|
||||
}
|
||||
#[test] fn message17_fragments_and_mobile_rpc_keep_unicode_and_request_id(){
|
||||
let mut state=SyncState::default();let value="中文🙂\n".repeat(2200);
|
||||
let parts=text::chunks(&value).unwrap();
|
||||
for (i,part) in parts.iter().enumerate(){
|
||||
let (replies,received)=state.receive(&wire::envelope(1,17,&text::encode(3,part,i+1<parts.len()))).unwrap();
|
||||
assert!(replies.is_empty());
|
||||
assert_eq!(received,if i+1==parts.len(){Some(value.clone())}else{None});
|
||||
}
|
||||
let (replies,received)=state.receive(&wire::envelope(2,21,&text::text_request(73,"mobile"))).unwrap();
|
||||
assert_eq!(received.as_deref(),Some("mobile"));assert_eq!(replies.len(),1);
|
||||
let fields=decode_wire(&replies[0]).unwrap();
|
||||
assert!(fields.iter().any(|f|f.number==22));
|
||||
let WireValue::Bytes(response)=fields.iter().find(|f|f.number==22).unwrap().value else{panic!()};
|
||||
let WireValue::Bytes(header)=decode_wire(response).unwrap().into_iter().find(|f|f.number==1).unwrap().value else{panic!()};
|
||||
assert_eq!(decode_wire(header).unwrap()[0].value,WireValue::Varint(73));
|
||||
assert!(state.receive(&wire::envelope(1,17,&[18,1,255])).is_err());
|
||||
assert!(state.receive(&wire::envelope(1,17,&text::encode(1,&"a".repeat(MAX_TEXT+1),false))).is_err());
|
||||
}
|
||||
#[test] fn rejected_nul_does_not_stop_later_valid_updates(){
|
||||
let mut state=SyncState::default();
|
||||
for kind in [17,21]{
|
||||
let payload=if kind==17{text::encode(1,"nul\0text",false)}else{text::text_request(73,"nul\0text")};
|
||||
assert!(state.receive(&wire::envelope(1,kind,&payload)).is_err());
|
||||
let(_,value)=state.receive(&wire::envelope(2,17,&text::encode(2,"valid",false))).unwrap();
|
||||
assert_eq!(value.as_deref(),Some("valid"));
|
||||
}
|
||||
}
|
||||
// Match webrtc.rs: CONTROL and TEXT have separate rich States, and only TEXT has a desktop sink.
|
||||
fn native_host_exchange(outbound:usize,reverse:bool)->(Option<String>,bool){
|
||||
let mut viewer=SyncState::default();let mut host=[rich::State::default(),rich::State::default()];let mut id=1000;
|
||||
let value="clipboard-中文🙂\n".to_owned();
|
||||
let offer=if reverse{wire::envelope(1,21,&host[1].offer(1,value.clone()).unwrap())}else{viewer.local(value.clone()).unwrap().unwrap().remove(0)};
|
||||
let mut queue=std::collections::VecDeque::from([(reverse,if reverse{1}else{outbound},offer)]);
|
||||
let mut received=None;let mut unavailable=false;let mut steps=0;
|
||||
while let Some((to_viewer,channel,packet))=queue.pop_front(){
|
||||
steps+=1;assert!(steps<20);
|
||||
if to_viewer {
|
||||
// Capture DataConfirm status without reading or logging text.
|
||||
for field in decode_wire(&packet).unwrap(){
|
||||
if let (22,WireValue::Bytes(body))=(field.number,field.value){
|
||||
if let Some(clip)=super::super::tools::blob(body,5){
|
||||
if let Some(confirm)=super::super::tools::blob(clip,2){unavailable|=super::super::tools::uint(confirm,1)==2;}
|
||||
}
|
||||
}
|
||||
}
|
||||
let (replies,text)=viewer.receive(&packet).unwrap();if text.is_some(){received=text;}
|
||||
queue.extend(replies.into_iter().map(|p|(false,outbound,p)));
|
||||
}else{
|
||||
for field in decode_wire(&packet).unwrap(){let WireValue::Bytes(body)=field.value else{continue};
|
||||
if field.number==21 {let result=host[channel].request(body,&mut ||{id+=1;id}).unwrap();
|
||||
if channel==1 && result.text.is_some(){received=result.text;}
|
||||
queue.extend(result.messages.into_iter().map(|(kind,body)|(true,channel,wire::envelope(1,kind,&body))));
|
||||
}else if field.number==22 {let text=host[channel].response(body).unwrap();if channel==1 && text.is_some(){received=text;}}
|
||||
}
|
||||
}
|
||||
}
|
||||
if reverse && received.is_some(){viewer.last=Some(value.clone());assert!(viewer.local(value).unwrap().is_none());}
|
||||
(received,unavailable)
|
||||
}
|
||||
#[test] fn local_change_also_sends_windows_text_change_request(){
|
||||
let mut viewer=SyncState::default();
|
||||
let messages=viewer.local("windows 中文".into()).unwrap().unwrap();assert_eq!(messages.len(),2);
|
||||
let rpc=decode_wire(&messages[1]).unwrap().into_iter().find_map(|f|match (f.number,f.value){(21,WireValue::Bytes(b))=>Some(b.to_vec()),_=>None}).unwrap();
|
||||
let (_,text)=crate::clipboard_protocol::read_text_request(&rpc).unwrap().unwrap();assert_eq!(text,"windows 中文");
|
||||
}
|
||||
#[test] fn control_clipboard_reproduces_native_host_failures(){
|
||||
assert_eq!(native_host_exchange(0,false),(None,false)); // Complete transfer, no CONTROL desktop sink.
|
||||
assert_eq!(native_host_exchange(0,true),(None,true)); // TEXT offer, empty CONTROL provider.
|
||||
}
|
||||
#[test] fn text_clipboard_negotiates_both_directions_with_native_host(){
|
||||
assert_eq!(wire::CHANNELS[CHANNEL],"TEXT_DATA_CHANNEL");
|
||||
for reverse in [false,true]{
|
||||
let (received,unavailable)=native_host_exchange(CHANNEL,reverse);
|
||||
assert_eq!(received.as_deref(),Some("clipboard-中文🙂\n"));assert!(!unavailable);
|
||||
}
|
||||
}
|
||||
#[test] fn clipboard_capability_is_version3_and_can_be_disabled(){
|
||||
assert!(wire::echo_clipboard_supported(&wire::echo_request_with_clipboard(1,true)));
|
||||
assert!(!wire::echo_clipboard_supported(&wire::echo_request_with_clipboard(1,false)));
|
||||
assert!(wire::echo_matches(&wire::echo_response_with_clipboard(2,1,true),1));
|
||||
assert!(!wire::echo_matches(&wire::echo_response_with_clipboard(2,7,true),1));
|
||||
assert!(!Bridge::new(false).enabled);assert!(!Bridge::new(true).enabled);
|
||||
let mut shape:wire::Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap();
|
||||
shape.feature_flag=vec![[8,99]];
|
||||
let options=shape.connect_options("synthetic-device",false).unwrap();
|
||||
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
|
||||
assert!(!decode_wire(flags).unwrap().iter().any(|f|f.number==8));
|
||||
let options=shape.connect_options("synthetic-device",true).unwrap();
|
||||
let WireValue::Bytes(flags)=decode_wire(&options).unwrap().into_iter().find(|f|f.number==11).unwrap().value else{panic!()};
|
||||
assert!(decode_wire(flags).unwrap().iter().any(|f|f.number==8 && f.value==WireValue::Varint(3)));
|
||||
}
|
||||
#[tokio::test] async fn backend_uses_stdin_preserves_text_and_bounds_reads(){
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let root=std::env::temp_dir().join(format!("uu-clipboard-mock-{}",wire::uuid()));std::fs::create_dir(&root).unwrap();
|
||||
let script=root.join("mock");
|
||||
std::fs::write(&script,b"#!/bin/sh\ncd -- \"${0%/*}\" || exit 1\ncase \"$1\" in read) cat data;; write) cat > data;; esac\n").unwrap();
|
||||
std::fs::set_permissions(&script,std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
let command=CommandBackend{read:script.clone(),write:script,read_args:vec!["read"],write_args:vec!["write"]};
|
||||
let backend=Backend::Command(command.clone());
|
||||
let mut state=SyncState::default();
|
||||
for value in ["中文🙂\n", "", "literal $(echo secret) `echo secret`"]{
|
||||
state.apply(&backend,value.into()).await.unwrap();
|
||||
let read=backend.read().await.unwrap().unwrap();assert_eq!(read,value);
|
||||
assert!(state.local(read).unwrap().is_none());
|
||||
}
|
||||
let broken=Backend::Command(CommandBackend{write:root.join("missing"),..command});
|
||||
let previous=state.last.clone();assert!(state.apply(&broken,"failed".into()).await.is_err());assert_eq!(state.last,previous);
|
||||
std::fs::write(root.join("data"),vec![b'a';MAX_TEXT+1]).unwrap();assert!(backend.read().await.unwrap().is_none());
|
||||
std::fs::write(root.join("data"),[255]).unwrap();assert!(backend.read().await.unwrap().is_none());
|
||||
assert!(backend.write(&"a".repeat(MAX_TEXT+1)).await.is_err());
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
//! Uses the same optional FFmpeg dependency as the host inproc-av feature.
|
||||
use super::desktop::{Decoder,Frame};
|
||||
use ffmpeg_next as av;
|
||||
use super::media::Codec;
|
||||
pub struct Ffmpeg { decoder:av::decoder::Video, codec:Codec }
|
||||
impl Ffmpeg {
|
||||
pub fn new()->Result<Self,String> {
|
||||
Self::with_codec(Codec::H264)
|
||||
}
|
||||
fn with_codec(kind:Codec)->Result<Self,String>{
|
||||
av::init().map_err(|_|"FFmpeg initialization failed")?;
|
||||
// Library diagnostics can contain bitstream data; suppress them globally in this viewer process.
|
||||
av::log::set_level(av::log::Level::Quiet);
|
||||
let codec=av::decoder::find(match kind {Codec::H264=>av::codec::Id::H264,Codec::H265=>av::codec::Id::HEVC}).ok_or("Video decoder unavailable")?;
|
||||
let decoder=av::codec::context::Context::new().decoder().open_as(codec).and_then(|d|d.video()).map_err(|_|"Video decoder initialization failed")?;
|
||||
Ok(Self{decoder,codec:kind})
|
||||
}
|
||||
}
|
||||
impl Decoder for Ffmpeg {
|
||||
fn set_codec(&mut self,codec:Codec)->Result<(),String>{
|
||||
if self.codec!=codec {*self=Self::with_codec(codec)?;}Ok(())
|
||||
}
|
||||
fn reset(&mut self){self.decoder.flush();}
|
||||
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String>{
|
||||
self.decoder.send_packet(&av::Packet::copy(au)).map_err(|_|"Video packet rejected")?;
|
||||
let mut frames=Vec::new();let mut decoded=av::frame::Video::empty();
|
||||
loop {
|
||||
match self.decoder.receive_frame(&mut decoded) {
|
||||
Ok(())=>{},
|
||||
Err(av::Error::Other{errno}) if errno==libc::EAGAIN=>break,
|
||||
Err(_)=>return Err("Video decode failed".into()),
|
||||
}
|
||||
if decoded.is_corrupt(){return Err("Corrupt video frame".into())}
|
||||
let (w,h)=(decoded.width(),decoded.height());
|
||||
if w==0 || h==0 || w>8192 || h>8192 {return Err("Decoded dimensions exceed limit".into())}
|
||||
let mut scaler=av::software::scaling::context::Context::get(decoded.format(),w,h,av::format::Pixel::RGB24,w,h,av::software::scaling::flag::Flags::BILINEAR).map_err(|_|"Frame conversion unavailable")?;
|
||||
let mut rgb=av::frame::Video::empty();scaler.run(&decoded,&mut rgb).map_err(|_|"Frame conversion failed")?;
|
||||
let mut data=Vec::with_capacity(w as usize*h as usize*3);
|
||||
for row in 0..h as usize {let start=row*rgb.stride(0);data.extend_from_slice(&rgb.data(0)[start..start+w as usize*3]);}
|
||||
frames.push(Frame{width:w,height:h,rgb:data});
|
||||
} Ok(frames)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
//! H.264/H.265 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
|
||||
//! Needs only the ffmpeg CLI, not FFmpeg development libraries.
|
||||
//! Output is scaled into a fixed letterboxed size so every frame has a known byte length.
|
||||
use super::desktop::{Decoder,Frame};
|
||||
use super::media::Codec;
|
||||
use std::io::{Read,Write};
|
||||
use std::process::{Child,ChildStdin,Command,Stdio};
|
||||
use std::sync::mpsc::{Receiver,TryRecvError};
|
||||
|
||||
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32 }
|
||||
|
||||
impl Cli {
|
||||
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
|
||||
pub fn new()->Result<Self,String> {
|
||||
let (width,height)=std::env::var("UU_VIEWER_SIZE").ok()
|
||||
.and_then(|v|{let (w,h)=v.split_once('x')?;Some((w.parse().ok()?,h.parse().ok()?))})
|
||||
.filter(|&(w,h):&(u32,u32)|(16..=8192).contains(&w)&&(16..=8192).contains(&h)&&w%2==0&&h%2==0)
|
||||
.unwrap_or((1920,1080));
|
||||
Self::with_codec(Codec::H264,width,height)
|
||||
}
|
||||
fn with_codec(codec:Codec,width:u32,height:u32)->Result<Self,String> {
|
||||
let ffmpeg=std::env::var("UU_VIEWER_FFMPEG").unwrap_or_else(|_|"ffmpeg".into());
|
||||
let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2");
|
||||
let passthrough=passthrough_args(&ffmpeg);
|
||||
let mut child=Command::new(&ffmpeg)
|
||||
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
|
||||
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an","-vf",&filter,
|
||||
"-pix_fmt","rgb24",
|
||||
// Raw H.264/H.265 carries no timestamps; constant-rate output dropped almost every frame of
|
||||
// the official Mac host's stream (270 → 2). Pass frames through unchanged.
|
||||
passthrough.0,passthrough.1,"-f","rawvideo","pipe:1"])
|
||||
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null())
|
||||
.spawn().map_err(|e|format!("Start ffmpeg decoder: {e}"))?;
|
||||
let input=child.stdin.take().ok_or("ffmpeg stdin missing")?;
|
||||
let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?;
|
||||
let size=width as usize*height as usize*3;
|
||||
// Bounded: a slow window drops decoded frames instead of growing memory.
|
||||
let (tx,frames)=std::sync::mpsc::sync_channel(2);
|
||||
std::thread::Builder::new().name("uu-viewer-decode".into()).spawn(move||{
|
||||
loop {
|
||||
let mut frame=vec![0;size];
|
||||
if output.read_exact(&mut frame).is_err() {break;}
|
||||
match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
|
||||
}
|
||||
}).map_err(|e|format!("Decoder reader: {e}"))?;
|
||||
Ok(Self{child,input:Some(input),codec,frames,width,height})
|
||||
}
|
||||
}
|
||||
|
||||
/// FFmpeg ≥ 5.1 has `-fps_mode`; FFmpeg 8+ removed `-vsync`, and Ubuntu 22.04's 4.4 lacks `-fps_mode`.
|
||||
/// Probe once per binary with a one-frame null run instead of parsing version strings.
|
||||
fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) {
|
||||
static CACHE:std::sync::Mutex<Vec<(String,bool)>>=std::sync::Mutex::new(Vec::new());
|
||||
let mut cache=CACHE.lock().unwrap_or_else(|e|e.into_inner());
|
||||
let fps_mode=match cache.iter().find(|(name,_)|name==ffmpeg) {
|
||||
Some(&(_,known))=>known,
|
||||
None=>{
|
||||
let ok=Command::new(ffmpeg).args(["-hide_banner","-loglevel","quiet","-nostdin","-f","lavfi","-i","color=s=16x16:d=0.04",
|
||||
"-fps_mode","passthrough","-f","null","-"]).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())
|
||||
.status().is_ok_and(|s|s.success());
|
||||
cache.push((ffmpeg.into(),ok));ok
|
||||
}
|
||||
};
|
||||
if fps_mode {("-fps_mode","passthrough")} else {("-vsync","0")}
|
||||
}
|
||||
|
||||
impl Decoder for Cli {
|
||||
fn set_codec(&mut self,codec:Codec)->Result<(),String>{
|
||||
if self.codec!=codec {*self=Self::with_codec(codec,self.width,self.height)?;}Ok(())
|
||||
}
|
||||
fn reset(&mut self) {}
|
||||
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String> {
|
||||
let input=self.input.as_mut().ok_or("ffmpeg input closed")?;
|
||||
input.write_all(au).and_then(|_|input.flush()).map_err(|_|"ffmpeg decoder exited")?;
|
||||
let mut out=Vec::new();
|
||||
loop {
|
||||
match self.frames.try_recv() {
|
||||
Ok(rgb)=>out.push(Frame{width:self.width,height:self.height,rgb}),
|
||||
Err(TryRecvError::Empty)=>break,
|
||||
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.child.wait(); } }
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
// Six synthetic red IDRs per fixture; no captured desktop or external encoder dependency.
|
||||
#[cfg(unix)] #[test] fn passthrough_follows_ffmpeg_option_support(){
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let dir=std::env::temp_dir().join(format!("uu-ffprobe-{}",std::process::id()));std::fs::create_dir_all(&dir).unwrap();
|
||||
for (name,script,expected) in [("new","exit 0",("-fps_mode","passthrough")),("old","case \"$*\" in *-fps_mode*) exit 1;; esac",("-vsync","0"))]{
|
||||
let path=dir.join(name);std::fs::write(&path,format!("#!/bin/sh\n{script}\n")).unwrap();
|
||||
std::fs::set_permissions(&path,std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
assert_eq!(super::passthrough_args(path.to_str().unwrap()),expected);
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
#[test] fn ffmpeg_decodes_h264_and_hevc_420_and_444_to_rgb24(){
|
||||
match Command::new("ffmpeg").arg("-version").stdout(Stdio::null()).stderr(Stdio::null()).status(){
|
||||
Err(e) if e.kind()==std::io::ErrorKind::NotFound=>{eprintln!("skip: ffmpeg is not on PATH");return},
|
||||
result=>assert!(result.expect("ffmpeg availability").success()),
|
||||
}
|
||||
let mut cli=Cli::with_codec(Codec::H265,32,32).unwrap();
|
||||
for (codec,data) in [
|
||||
(Codec::H264,&include_bytes!("../../tests/fixtures/viewer/red-420.h264")[..]),
|
||||
(Codec::H265,&include_bytes!("../../tests/fixtures/viewer/red-420.hevc")[..]),
|
||||
(Codec::H264,&include_bytes!("../../tests/fixtures/viewer/red-444.h264")[..]),
|
||||
(Codec::H265,&include_bytes!("../../tests/fixtures/viewer/red-444.hevc")[..]),
|
||||
] {
|
||||
cli.set_codec(codec).unwrap();
|
||||
// Exercise the same streaming process and RGB conversion as SDL, then drain at EOF.
|
||||
let mut frames=cli.decode(data).unwrap();drop(cli.input.take());
|
||||
loop {match cli.frames.recv_timeout(std::time::Duration::from_secs(5)) {
|
||||
Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb}),
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break,
|
||||
Err(e)=>panic!("{codec:?} decoder did not finish: {e}"),
|
||||
}}
|
||||
let status=cli.child.wait().unwrap();
|
||||
assert!(status.success(),"{codec:?}: ffmpeg exited with {status}");
|
||||
assert!(!frames.is_empty(),"{codec:?}: no RGB frames");
|
||||
for frame in frames {
|
||||
assert_eq!(frame.rgb.len(),32*32*3);
|
||||
assert!(frame.rgb.chunks_exact(3).all(|p|p[0]>220 && p[1]<30 && p[2]<30),"{codec:?}: RGB conversion");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
use super::media::Latest;
|
||||
use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
|
||||
#[derive(Clone)]
|
||||
pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<AtomicBool>, pub reset:Arc<AtomicBool>, pub ssrc:Arc<AtomicU32> }
|
||||
impl Default for Desktop {
|
||||
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
|
||||
}
|
||||
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8> }
|
||||
pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); }
|
||||
pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
|
||||
/// Counts only (access units, presented frames, decode errors) for the periodic stats line.
|
||||
pub static STATS:[std::sync::atomic::AtomicU64;3]=[std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0)];
|
||||
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Result<(),String> {
|
||||
STATS[0].fetch_add(1,Ordering::Relaxed);
|
||||
// Local diagnostic: UU_VIEWER_DUMP_H264=path appends the first 300 access units (owner's own stream).
|
||||
if codec==super::media::Codec::H264 && STATS[0].load(Ordering::Relaxed)<=300 { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_H264") {
|
||||
use std::io::Write; if let Ok(mut f)=std::fs::OpenOptions::new().create(true).append(true).open(path){let _=f.write_all(au);}
|
||||
}}
|
||||
match decoder.decode(au) {
|
||||
Ok(frames)=>{for frame in frames {
|
||||
sink.present(&frame)?;
|
||||
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
|
||||
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
|
||||
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
|
||||
}}
|
||||
}Ok(())},
|
||||
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Ok(())},
|
||||
}
|
||||
}
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3]}])}} fn reset(&mut self){self.0=false;}}
|
||||
struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}}
|
||||
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
//! SDL scancodes are USB HID usages; translate physical keys, not typed text.
|
||||
use serde_json::{json, Value};
|
||||
use std::collections::{BTreeMap,BTreeSet};
|
||||
pub fn windows_vk(scan: i32) -> Option<i32> {
|
||||
Some(match scan {
|
||||
4..=29 => 0x41 + scan - 4, 30..=38 => 0x31 + scan - 30, 39 => 0x30,
|
||||
40=>0x0d,41=>0x1b,42=>8,43=>9,44=>0x20,
|
||||
45=>0xbd,46=>0xbb,47=>0xdb,48=>0xdd,49=>0xdc,51=>0xba,52=>0xde,53=>0xc0,54=>0xbc,55=>0xbe,56=>0xbf,
|
||||
57=>0x14,58..=69=>0x70+scan-58,70=>0x2c,71=>0x91,72=>0x13,
|
||||
73=>0x2d,74=>0x24,75=>0x21,76=>0x2e,77=>0x23,78=>0x22,
|
||||
79=>0x27,80=>0x25,81=>0x28,82=>0x26,83=>0x90,
|
||||
84=>0x6f,85=>0x6a,86=>0x6d,87=>0x6b,88=>0x0d,
|
||||
89..=97=>0x61+scan-89,98=>0x60,99=>0x6e,101=>0x5d,
|
||||
104..=115=>0x7c+scan-104,
|
||||
224=>0xa2,225=>0xa0,226=>0xa4,227=>0x5b,228=>0xa3,229=>0xa1,230=>0xa5,231=>0x5c,
|
||||
_=>return None,
|
||||
})
|
||||
}
|
||||
pub fn mac_keycode(scan:i32)->Option<i32>{
|
||||
// Inverted SDL Darwin table (release-2.32.10/src/events/scancodes_darwin.h).
|
||||
// Live Mac host evidence: Windows VK 49 becomes Space, and VK 8 becomes C.
|
||||
Some(match scan{
|
||||
4=>0,22=>1,7=>2,9=>3,11=>4,10=>5,29=>6,27=>7,6=>8,25=>9,100=>10,5=>11,
|
||||
20=>12,26=>13,8=>14,21=>15,28=>16,23=>17,30=>18,31=>19,32=>20,33=>21,
|
||||
35=>22,34=>23,46=>24,38=>25,36=>26,45=>27,37=>28,39=>29,48=>30,18=>31,
|
||||
24=>32,47=>33,12=>34,19=>35,40=>36,15=>37,13=>38,52=>39,14=>40,51=>41,
|
||||
49=>42,54=>43,56=>44,17=>45,16=>46,55=>47,43=>48,44=>49,53=>50,42=>51,
|
||||
41=>53,231=>54,227=>55,225=>56,57=>57,226=>58,224=>59,229=>60,230=>61,228=>62,
|
||||
108=>64,99=>65,85=>67,87=>69,83=>71,84=>75,88=>76,86=>78,109=>79,110=>80,
|
||||
103=>81,98=>82,89=>83,90=>84,91=>85,92=>86,93=>87,94=>88,95=>89,96=>91,97=>92,
|
||||
62=>96,63=>97,64=>98,60=>99,65=>100,66=>101,68=>103,104=>105,107=>106,105=>107,
|
||||
70=>105,71=>107,72=>113,
|
||||
67=>109,101=>110,69=>111,106=>113,73=>114,74=>115,75=>116,76=>117,61=>118,
|
||||
77=>119,59=>120,78=>121,58=>122,80=>123,79=>124,81=>125,82=>126,
|
||||
_=>return None,
|
||||
})
|
||||
}
|
||||
#[derive(Clone,Copy,Debug,PartialEq)]
|
||||
pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 }
|
||||
impl Viewport {
|
||||
pub fn fit(window:(u32,u32), frame:(u32,u32))->Self {
|
||||
let scale=(window.0 as f64 / frame.0.max(1) as f64).min(window.1 as f64 / frame.1.max(1) as f64);
|
||||
let (w,h)=(frame.0 as f64*scale,frame.1 as f64*scale);
|
||||
Self{x:(window.0 as f64-w)/2.,y:(window.1 as f64-h)/2.,width:w,height:h}
|
||||
}
|
||||
pub fn motion(self,x:f64,y:f64)->Option<Value> {
|
||||
if self.width<=0. || self.height<=0. || !x.is_finite() || !y.is_finite() {return None}
|
||||
Some(json!({"action":"mouse_move_absolute","abs_x":((x-self.x)/self.width).clamp(0.,1.),"abs_y":((y-self.y)/self.height).clamp(0.,1.)}))
|
||||
}
|
||||
}
|
||||
#[derive(Default)]
|
||||
pub struct Input { view_only:bool, mac:bool, keys:BTreeMap<i32,i32>, buttons:BTreeSet<i32> }
|
||||
pub fn view_only(argument:Option<&str>,environment:Option<&str>)->Result<bool,String> {
|
||||
match argument {None=>Ok(environment==Some("1")),Some("--view-only")=>Ok(true),_=>Err("Expected --view-only".into())}
|
||||
}
|
||||
impl Input {
|
||||
pub fn new(view_only:bool)->Self {Self{view_only,..Default::default()}}
|
||||
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
|
||||
pub fn enabled(&self)->bool {!self.view_only}
|
||||
pub fn key(&mut self,scan:i32,down:bool)->Option<Value> {
|
||||
if self.view_only {return None}
|
||||
let vk=if self.mac{mac_keycode(scan)}else{windows_vk(scan)}?;
|
||||
let changed=if down {
|
||||
if self.keys.contains_key(&scan) {return None}
|
||||
let already=self.keys.values().any(|v|*v==vk);self.keys.insert(scan,vk);!already
|
||||
}else{
|
||||
if self.keys.remove(&scan).is_none(){return None}
|
||||
!self.keys.values().any(|v|*v==vk)
|
||||
};
|
||||
changed.then(||json!({"action":if down{"kbd_press"}else{"kbd_release"},"key":vk}))
|
||||
}
|
||||
pub fn button(&mut self,button:i32,down:bool)->Option<Value> {
|
||||
if self.view_only {return None}
|
||||
if !matches!(button,1|2|4) {return None}
|
||||
let changed=if down{self.buttons.insert(button)}else{self.buttons.remove(&button)};
|
||||
changed.then(||json!({"action":if down{"mouse_press"}else{"mouse_release"},"button":button}))
|
||||
}
|
||||
pub fn release_all(&mut self)->Vec<Value> {
|
||||
let mut out=Vec::new();
|
||||
for key in std::mem::take(&mut self.keys).into_values().collect::<BTreeSet<_>>() {out.push(json!({"action":"kbd_release","key":key}));}
|
||||
for button in std::mem::take(&mut self.buttons) {out.push(json!({"action":"mouse_release","button":button}));}
|
||||
out
|
||||
}
|
||||
pub fn heartbeat()->Value {json!({"heartbeat":"kbd_heartbeat"})}
|
||||
}
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[test] fn mac_target_uses_native_codes_and_releases_same_keys(){
|
||||
let mut input=Input::default();input.set_mac(true);
|
||||
for (scan,code) in [(30,18),(39,29),(42,51),(44,49),(6,8),(4,0),(40,36),(43,48),
|
||||
(80,123),(79,124),(81,125),(82,126),(224,59),(225,56),(226,58),(227,55)]{
|
||||
assert_eq!(input.key(scan,true).unwrap()["key"],code);
|
||||
assert_eq!(input.key(scan,false).unwrap()["key"],code);
|
||||
}
|
||||
input.set_mac(false);assert_eq!(input.key(30,true).unwrap()["key"],49);
|
||||
}
|
||||
#[test] fn mac_focus_release_keeps_zero_keycode_and_modifiers(){
|
||||
let mut input=Input::default();input.set_mac(true);
|
||||
assert!(input.key(4,true).is_some());assert!(input.key(4,true).is_none());
|
||||
input.key(225,true);input.key(227,true);
|
||||
let release=input.release_all();
|
||||
assert_eq!(release,vec![json!({"action":"kbd_release","key":0}),
|
||||
json!({"action":"kbd_release","key":55}),json!({"action":"kbd_release","key":56})]);
|
||||
assert!(input.release_all().is_empty());assert!(input.key(4,false).is_none());
|
||||
let mut watch=Input::new(true);watch.set_mac(true);assert!(watch.key(4,true).is_none());
|
||||
}
|
||||
#[test] fn mac_function_key_aliases_release_after_last_keyup(){
|
||||
for (pc,function,code) in [(70,104,105),(71,105,107),(72,106,113)]{
|
||||
let mut input=Input::default();input.set_mac(true);
|
||||
assert_eq!(input.key(pc,true).unwrap()["key"],code);
|
||||
assert!(input.key(function,true).is_none());assert!(input.key(pc,false).is_none());
|
||||
assert_eq!(input.key(function,false).unwrap()["key"],code);
|
||||
}
|
||||
}
|
||||
#[test] fn watch_switch_is_explicit_and_validated(){
|
||||
assert!(!view_only(None,None).unwrap());assert!(!view_only(None,Some("0")).unwrap());
|
||||
assert!(view_only(None,Some("1")).unwrap());assert!(view_only(Some("--view-only"),Some("0")).unwrap());
|
||||
assert!(view_only(Some("invalid"),None).is_err());
|
||||
}
|
||||
#[test] fn mappings_encoding_and_focus() {
|
||||
for (scan,vk) in [(4,65),(29,90),(39,48),(58,112),(80,37),(224,162),(230,165),(52,222)] {assert_eq!(windows_vk(scan),Some(vk));}
|
||||
assert_eq!(windows_vk(100),None);
|
||||
let mut i=Input::default();assert_eq!(i.key(4,true).unwrap(),json!({"action":"kbd_press","key":65}));assert!(i.key(4,true).is_none());
|
||||
i.key(225,true);i.button(2,true);let release=i.release_all();assert_eq!(release.len(),3);
|
||||
assert!(release.iter().all(|v|v["action"].as_str().unwrap().ends_with("release")));
|
||||
assert!(i.release_all().is_empty());
|
||||
assert_eq!(Input::heartbeat(),json!({"heartbeat":"kbd_heartbeat"}));
|
||||
}
|
||||
#[test] fn aliased_physical_keys_release_only_after_last_keyup() {
|
||||
let mut i=Input::default();assert!(i.key(40,true).is_some());assert!(i.key(88,true).is_none());
|
||||
assert!(i.key(40,false).is_none());assert_eq!(i.key(88,false).unwrap(),json!({"action":"kbd_release","key":13}));
|
||||
assert!(i.button(3,true).is_none());assert_eq!(i.button(4,true).unwrap()["button"],4);
|
||||
}
|
||||
#[test] fn letterbox() {
|
||||
let v=Viewport::fit((1000,1000),(1920,1080));
|
||||
assert_eq!(v.motion(500.,500.).unwrap()["abs_y"],0.5);
|
||||
assert_eq!(v.motion(-10.,0.).unwrap()["abs_y"],0.0);
|
||||
assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0);
|
||||
assert!(v.motion(f64::NAN,0.).is_none());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
//! Bounded RFC 6184 / RFC 7798 non-interleaved receivers (no DONL). No media contents in logs.
|
||||
use std::{collections::VecDeque, sync::{Arc, Mutex}};
|
||||
use std::time::{Duration,Instant};
|
||||
#[derive(Clone,Copy,Debug,Default,PartialEq,Eq)]
|
||||
pub enum Codec { #[default] H264, H265 }
|
||||
impl Codec {
|
||||
pub fn from_mime(mime:&str)->Option<Self> {
|
||||
if mime.eq_ignore_ascii_case("video/H264"){Some(Self::H264)}
|
||||
else if mime.eq_ignore_ascii_case("video/H265"){Some(Self::H265)}else{None}
|
||||
}
|
||||
pub fn demuxer(self)->&'static str {match self {Self::H264=>"h264",Self::H265=>"hevc"}}
|
||||
}
|
||||
pub struct AccessUnit {pub codec:Codec,pub data:Vec<u8>}
|
||||
const MAX_AU: usize = 8 * 1024 * 1024;
|
||||
#[derive(Clone)]
|
||||
pub struct Packet { pub seq: u16, pub timestamp: u32, pub marker: bool, pub payload: Vec<u8> }
|
||||
#[derive(Default)]
|
||||
pub struct Output { pub units: Vec<Vec<u8>>, pub pli: bool }
|
||||
pub struct Receiver {
|
||||
codec: Codec,
|
||||
next: Option<u16>, pending: Vec<Packet>, timestamp: Option<u32>,
|
||||
au: Vec<u8>, fragment: Option<u16>, damaged: bool, gap_since:Option<Instant>, last_packet:Instant,
|
||||
}
|
||||
impl Default for Receiver {
|
||||
fn default() -> Self { Self { codec: Codec::H264, next: None, pending: Vec::new(), timestamp: None, au: Vec::new(), fragment: None, damaged: false, gap_since:None,last_packet:Instant::now() } }
|
||||
}
|
||||
impl Receiver {
|
||||
pub fn new(codec:Codec)->Self {Self{codec,..Self::default()}}
|
||||
pub fn codec(&self)->Codec {self.codec}
|
||||
pub fn push(&mut self, p: Packet) -> Output {
|
||||
if p.payload.len()>65536 {return Output{units:Vec::new(),pli:true}}
|
||||
let next = *self.next.get_or_insert(p.seq);
|
||||
if p.seq.wrapping_sub(next) >= 32768 || self.pending.iter().any(|q| q.seq == p.seq) { return Output::default() }
|
||||
self.last_packet=Instant::now();
|
||||
self.pending.push(p);
|
||||
let mut out = Output::default();
|
||||
self.drain(&mut out);
|
||||
if self.pending.len() >= 32 { self.skip_gap(&mut out); }
|
||||
if self.pending.is_empty(){self.gap_since=None;}else{self.gap_since.get_or_insert(Instant::now());}
|
||||
out
|
||||
}
|
||||
// A timer bounds latency even if the missing packet is the last packet sent.
|
||||
pub fn expire(&mut self) -> Output {
|
||||
self.expire_at(Instant::now())
|
||||
}
|
||||
fn expire_at(&mut self,now:Instant)->Output {
|
||||
let mut out=Output::default();
|
||||
if self.gap_since.is_some_and(|since|now.duration_since(since)>=Duration::from_millis(40)) && !self.pending.is_empty() {
|
||||
self.skip_gap(&mut out);self.gap_since=if self.pending.is_empty(){None}else{Some(now)};
|
||||
}
|
||||
if !self.au.is_empty() && now.duration_since(self.last_packet)>=Duration::from_millis(200) {
|
||||
self.au.clear();self.fragment=None;self.damaged=true;out.pli=true;
|
||||
}
|
||||
out
|
||||
}
|
||||
fn skip_gap(&mut self, out: &mut Output) {
|
||||
let next = self.next.unwrap();
|
||||
self.next = self.pending.iter().min_by_key(|p| p.seq.wrapping_sub(next)).map(|p| p.seq);
|
||||
self.au.clear(); self.fragment = None; self.damaged = true; out.pli = true;
|
||||
self.drain(out);
|
||||
}
|
||||
fn drain(&mut self, out: &mut Output) {
|
||||
while let Some(i) = self.pending.iter().position(|p| Some(p.seq) == self.next) {
|
||||
let p = self.pending.remove(i); self.next = Some(p.seq.wrapping_add(1));
|
||||
if self.timestamp != Some(p.timestamp) {
|
||||
// A timestamp transition without marker is an incomplete AU.
|
||||
if !self.au.is_empty() || self.fragment.is_some() { out.pli = true; }
|
||||
self.au.clear(); self.fragment = None; self.damaged = false; self.timestamp = Some(p.timestamp);
|
||||
}
|
||||
if !self.damaged && self.nal(&p.payload).is_err() { self.damaged = true; self.au.clear(); self.fragment = None; out.pli = true; }
|
||||
if p.marker {
|
||||
if self.fragment.is_some() { out.pli = true; self.damaged = true; }
|
||||
if !self.damaged && !self.au.is_empty() { out.units.push(std::mem::take(&mut self.au)); }
|
||||
self.au.clear(); self.fragment = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
fn append(&mut self, bytes: &[u8]) -> Result<(), ()> {
|
||||
if self.au.len() + bytes.len() > MAX_AU { return Err(()) }
|
||||
self.au.extend_from_slice(bytes); Ok(())
|
||||
}
|
||||
fn nal(&mut self, p: &[u8]) -> Result<(), ()> {
|
||||
if self.codec==Codec::H265 {return self.hevc(p)}
|
||||
let h = *p.first().ok_or(())?;
|
||||
if h & 0x80 != 0 { return Err(()) }
|
||||
match h & 31 {
|
||||
1..=23 if self.fragment.is_none() => { self.append(&[0,0,0,1])?; self.append(p) }
|
||||
24 if self.fragment.is_none() => {
|
||||
let mut rest = &p[1..]; if rest.is_empty() { return Err(()) }
|
||||
while !rest.is_empty() {
|
||||
if rest.len() < 2 { return Err(()) }
|
||||
let n = u16::from_be_bytes([rest[0], rest[1]]) as usize; rest = &rest[2..];
|
||||
if n == 0 || rest.len() < n || rest[0] & 0x80 != 0 || !(1..=23).contains(&(rest[0] & 31)) { return Err(()) }
|
||||
self.append(&[0,0,0,1])?; self.append(&rest[..n])?; rest = &rest[n..];
|
||||
} Ok(())
|
||||
}
|
||||
28 if p.len() > 2 => {
|
||||
let f = p[1]; let kind = f & 31; let start = f & 128 != 0; let end = f & 64 != 0;
|
||||
if f & 32 != 0 || kind == 0 || kind > 23 || (start && end) { return Err(()) }
|
||||
let header = (h & 0xe0) | kind;
|
||||
if start {
|
||||
if self.fragment.is_some() { return Err(()) }
|
||||
self.append(&[0,0,0,1,header])?; self.fragment = Some(u16::from(header));
|
||||
} else if self.fragment != Some(u16::from(header)) { return Err(()) }
|
||||
self.append(&p[2..])?;
|
||||
if end { self.fragment = None; } Ok(())
|
||||
}
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
fn hevc_header(p:&[u8])->Result<u16,()> {
|
||||
if p.len()<2 || p[0]&0x80!=0 || p[1]&7==0 {return Err(())}
|
||||
Ok(u16::from_be_bytes([p[0],p[1]]))
|
||||
}
|
||||
fn hevc(&mut self,p:&[u8])->Result<(),()> {
|
||||
Self::hevc_header(p)?;
|
||||
match (p[0]>>1)&63 {
|
||||
0..=47 if self.fragment.is_none()=>{self.append(&[0,0,0,1])?;self.append(p)},
|
||||
48 if self.fragment.is_none()=>{
|
||||
let mut rest=&p[2..];if rest.is_empty(){return Err(())}
|
||||
while !rest.is_empty() {
|
||||
if rest.len()<2 {return Err(())}
|
||||
let n=u16::from_be_bytes([rest[0],rest[1]]) as usize;rest=&rest[2..];
|
||||
if n<2 || rest.len()<n {return Err(())}
|
||||
Self::hevc_header(&rest[..n])?;
|
||||
if (rest[0]>>1)&63>=48 {return Err(())}
|
||||
self.append(&[0,0,0,1])?;self.append(&rest[..n])?;rest=&rest[n..];
|
||||
}Ok(())
|
||||
},
|
||||
49 if p.len()>3=>{
|
||||
let f=p[2];let kind=f&63;let start=f&128!=0;let end=f&64!=0;
|
||||
if kind>=48 || (start&&end){return Err(())}
|
||||
// RFC 7798 4.4.3: preserve LayerId and TID, replacing only FU's NAL type.
|
||||
let header=[(p[0]&0x81)|(kind<<1),p[1]];let key=u16::from_be_bytes(header);
|
||||
if start {
|
||||
if self.fragment.is_some(){return Err(())}
|
||||
self.append(&[0,0,0,1])?;self.append(&header)?;self.fragment=Some(key);
|
||||
}else if self.fragment!=Some(key){return Err(())}
|
||||
self.append(&p[3..])?;if end{self.fragment=None;}Ok(())
|
||||
},
|
||||
_=>Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Drop the oldest item on overflow; never block the RTP reader on a decoder/UI.
|
||||
pub struct Latest<T>(Arc<Mutex<VecDeque<T>>>, usize);
|
||||
impl<T> Clone for Latest<T> { fn clone(&self) -> Self { Self(self.0.clone(), self.1) } }
|
||||
impl<T> Latest<T> {
|
||||
pub fn new(capacity: usize) -> Self { assert!(capacity > 0); Self(Arc::new(Mutex::new(VecDeque::new())), capacity) }
|
||||
pub fn push(&self, value: T) -> bool { let mut q = self.0.lock().unwrap(); let dropped = q.len() == self.1; if dropped { q.pop_front(); } q.push_back(value); dropped }
|
||||
pub fn pop(&self) -> Option<T> { self.0.lock().unwrap().pop_front() }
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn p(seq:u16, ts:u32, marker:bool, payload:&[u8])->Packet { Packet{seq,timestamp:ts,marker,payload:payload.into()} }
|
||||
#[test] fn single_stap_and_boundary() {
|
||||
let mut r=Receiver::default();
|
||||
assert!(r.push(p(1,1,false,&[0x67,1])).units.is_empty());
|
||||
assert_eq!(r.push(p(2,1,true,&[24,0,2,0x68,2,0,2,0x65,3])).units[0],vec![0,0,0,1,0x67,1,0,0,0,1,0x68,2,0,0,0,1,0x65,3]);
|
||||
r.push(p(3,2,false,&[0x61,1]));
|
||||
let o=r.push(p(4,3,true,&[0x65,4])); assert!(o.pli); assert_eq!(o.units.len(),1);
|
||||
}
|
||||
#[test] fn fu_reorder_wrap_duplicate_and_loss() {
|
||||
let mut r=Receiver::default(); r.push(p(65535,1,false,&[0x7c,0x85,1]));
|
||||
assert!(r.push(p(1,1,true,&[0x7c,0x45,3])).units.is_empty());
|
||||
let o=r.push(p(0,1,false,&[0x7c,5,2])); assert_eq!(o.units[0],vec![0,0,0,1,0x65,1,2,3]);
|
||||
assert!(r.push(p(0,1,false,&[0x61])).units.is_empty());
|
||||
r.push(p(2,2,false,&[0x7c,0x85,1]));r.push(p(4,2,true,&[0x7c,0x45,3]));
|
||||
let o=r.expire_at(Instant::now()+Duration::from_millis(50));assert!(o.pli);assert!(o.units.is_empty());
|
||||
assert_eq!(r.push(p(5,3,true,&[0x65])).units.len(),1);
|
||||
}
|
||||
#[test] fn missing_tail_and_reorder_window_are_bounded() {
|
||||
let mut r=Receiver::default();r.push(p(0,1,false,&[0x7c,0x85,1]));
|
||||
assert!(!r.expire().pli);assert!(r.expire_at(Instant::now()+Duration::from_millis(201)).pli);
|
||||
let mut pli=false;for seq in 2..34{pli|=r.push(p(seq,seq as u32,true,&[0x65])).pli;}
|
||||
assert!(pli);assert!(r.pending.len()<32);
|
||||
}
|
||||
#[test] fn malformed_and_bounded() {
|
||||
for bytes in [vec![],vec![24,0,4,0x65],vec![0x7c,0xc5,1],vec![0xff]] {
|
||||
assert!(Receiver::default().push(p(1,1,true,&bytes)).pli);
|
||||
}
|
||||
let q=Latest::new(2);assert!(!q.push(1));q.push(2);assert!(q.push(3));assert_eq!(q.pop(),Some(2));assert_eq!(q.pop(),Some(3));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)] mod hevc_tests {
|
||||
use super::*;
|
||||
fn packet(seq:u16,ts:u32,marker:bool,payload:Vec<u8>)->Packet {Packet{seq,timestamp:ts,marker,payload}}
|
||||
fn sample()->Vec<u8>{
|
||||
let mut au=vec![0,0,0,1,64,1,9,0,0,0,1,66,1,8,0,0,0,1,68,1,7,0,0,0,1,0x27,0x2b];
|
||||
au.extend((0..2501).map(|i|(i%251+1)as u8));au
|
||||
}
|
||||
#[test] fn host_payloader_round_trip_single_fu_and_reorder(){
|
||||
for mtu in [4,5,7,1190,9000] {
|
||||
let au=sample();let payloads=crate::hevc::payload(mtu,&au).unwrap();let n=payloads.len();
|
||||
let mut packets:Vec<_>=payloads.into_iter().enumerate().map(|(i,b)|packet(65534u16.wrapping_add(i as u16),10,i+1==n,b.to_vec())).collect();
|
||||
// Start at the first sequence, then reorder adjacent packets across wraparound.
|
||||
for i in (1..n.saturating_sub(1)).step_by(2){packets.swap(i,i+1);}
|
||||
let mut r=Receiver::new(Codec::H265);let mut units=Vec::new();
|
||||
for p in packets {let o=r.push(p);assert!(!o.pli);units.extend(o.units);}
|
||||
assert_eq!(units,vec![au]);
|
||||
}
|
||||
}
|
||||
#[test] fn aggregation_and_malformed_packets(){
|
||||
let ap=vec![96,1,0,3,64,1,9,0,3,38,1,7];
|
||||
let mut r=Receiver::new(Codec::H265);
|
||||
assert_eq!(r.push(packet(0,0,true,ap)).units,vec![vec![0,0,0,1,64,1,9,0,0,0,1,38,1,7]]);
|
||||
for payload in [vec![],vec![64],vec![128,1],vec![64,0],vec![96,1],vec![96,1,0,4,38,1,7],
|
||||
vec![96,1,0,2,96,1],vec![98,1,0xc1,3],vec![98,1,0x41,3],vec![98,1,0xb0,3],vec![100,1,7]] {
|
||||
let o=Receiver::new(Codec::H265).push(packet(1,1,true,payload));assert!(o.pli);assert!(o.units.is_empty());
|
||||
}
|
||||
}
|
||||
#[test] fn loss_duplicates_incomplete_tail_and_header_mismatch(){
|
||||
let payloads=crate::hevc::payload(1190,&sample()).unwrap();
|
||||
let mut r=Receiver::new(Codec::H265);
|
||||
// Parameter sets followed by a fragmented IDR; lose its middle fragment.
|
||||
for (i,p) in payloads.iter().enumerate().take(4){r.push(packet(i as u16,1,false,p.to_vec()));}
|
||||
let tail=packet(5,1,true,payloads[5].to_vec());
|
||||
assert!(r.push(tail.clone()).units.is_empty());assert!(r.push(tail).units.is_empty());
|
||||
let o=r.expire_at(Instant::now()+Duration::from_millis(50));assert!(o.pli);assert!(o.units.is_empty());
|
||||
assert_eq!(r.push(packet(6,2,true,vec![38,1,9])).units.len(),1);
|
||||
r.push(packet(7,3,false,vec![98,1,0x93,7]));
|
||||
assert!(r.expire_at(Instant::now()+Duration::from_millis(201)).pli);
|
||||
let mut r=Receiver::new(Codec::H265);r.push(packet(0,0,false,vec![98,1,0x93,7]));
|
||||
let o=r.push(packet(1,0,true,vec![98,2,0x53,8]));assert!(o.pli);assert!(o.units.is_empty());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
//! Opt-in controller session; independent of the host room and peer lifecycle.
|
||||
pub mod api;
|
||||
pub mod assist;
|
||||
pub mod wire;
|
||||
pub mod signal;
|
||||
pub mod rtc;
|
||||
pub mod session;
|
||||
#[cfg(test)] mod tests;
|
||||
|
||||
pub mod media;
|
||||
pub mod audio;
|
||||
pub mod input;
|
||||
pub mod desktop;
|
||||
#[cfg(feature="viewer-ffmpeg")] pub mod decoder;
|
||||
#[cfg(any(test,feature="viewer-sdl"))] pub mod decoder_cli;
|
||||
#[cfg(uu_gtk)] pub mod ui;
|
||||
#[cfg(uu_gtk)] pub mod tools_ui;
|
||||
#[cfg(feature="viewer-sdl")] pub mod sdl;
|
||||
|
||||
pub mod tools;
|
||||
|
||||
pub mod clipboard;
|
||||
pub mod power;
|
||||
|
||||
fn device_label(name:Option<&str>)->&str{
|
||||
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod device_label_tests {
|
||||
#[test]
|
||||
fn device_name_or_fallback(){
|
||||
assert_eq!(super::device_label(Some("测试电脑")),"测试电脑");
|
||||
assert_eq!(super::device_label(None),"远端设备");
|
||||
assert_eq!(super::device_label(Some("")),"远端设备");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
//! SimpleAction numbers are from src/system_actions.rs (REBOOT_SYSTEM / SHUTDOWN_SYSTEM).
|
||||
use super::{session::Session,wire};
|
||||
use std::{sync::atomic::Ordering,time::Duration};
|
||||
#[derive(Clone,Copy,Debug,PartialEq)]
|
||||
pub enum Action {Reboot,Shutdown}
|
||||
impl Action {
|
||||
pub fn parse(value:&str)->Result<Self,String>{match value{"reboot"=>Ok(Self::Reboot),"shutdown"=>Ok(Self::Shutdown),_=>Err("Power action must be reboot or shutdown".into())}}
|
||||
pub fn message(self,seq:u64)->Vec<u8>{
|
||||
let mut action=Vec::new();wire::int(1,match self{Self::Reboot=>9,Self::Shutdown=>12},&mut action);
|
||||
wire::envelope(seq,3,&action)
|
||||
}
|
||||
}
|
||||
pub async fn run(session:&mut Session,action:Action)->Result<(),String>{
|
||||
let channel=session.peer.channels[0].clone();
|
||||
let ready=async{
|
||||
loop {
|
||||
if session.peer.observed.control_open.load(Ordering::Acquire) && session.peer.observed.echo_received.load(Ordering::Acquire){return Ok::<_,String>(())}
|
||||
tokio::select!{r=session.step()=>r?,_=tokio::time::sleep(Duration::from_millis(20))=>{}}
|
||||
}
|
||||
};
|
||||
let send=async move {
|
||||
tokio::time::timeout(Duration::from_secs(5),channel.send(&bytes::Bytes::from(action.message(2))))
|
||||
.await.map_err(|_|"Power command send timed out")?.map_err(|_|"Power command send failed")?;
|
||||
// Drain SCTP locally before closing; this is not a remote execution acknowledgement.
|
||||
let drain=async{while channel.buffered_amount().await>0 {tokio::time::sleep(Duration::from_millis(20)).await;}};
|
||||
tokio::time::timeout(Duration::from_secs(2),drain).await.map_err(|_|"Power command drain timed out")?;
|
||||
tokio::time::sleep(Duration::from_millis(200)).await;Ok(())
|
||||
};
|
||||
after_echo(ready,send,Duration::from_secs(30)).await
|
||||
}
|
||||
async fn after_echo(ready:impl std::future::Future<Output=Result<(),String>>,send:impl std::future::Future<Output=Result<(),String>>,timeout:Duration)->Result<(),String>{
|
||||
tokio::time::timeout(timeout,ready).await.map_err(|_|"CONTROL echo timed out")??;
|
||||
send.await
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
use crate::protocol::{decode_wire,WireValue};
|
||||
#[test] fn only_host_evidenced_actions_are_encoded(){
|
||||
for (name,number) in [("reboot",9),("shutdown",12)]{
|
||||
let bytes=Action::parse(name).unwrap().message(2);let fields=decode_wire(&bytes).unwrap();
|
||||
let WireValue::Bytes(body)=fields.iter().find(|f|f.number==3).unwrap().value else{panic!()};
|
||||
assert_eq!(decode_wire(body).unwrap()[0].value,WireValue::Varint(number));
|
||||
let host=include_str!("../system_actions.rs");
|
||||
assert!(host.contains(&format!("pub const {}_SYSTEM: u64 = {number};",name.to_uppercase())));
|
||||
}
|
||||
for value in ["logout","wol","9",""]{assert!(Action::parse(value).is_err());}
|
||||
}
|
||||
#[tokio::test] async fn waits_for_echo_and_sends_once_without_retrying_failure(){
|
||||
use std::sync::{Arc,atomic::AtomicUsize};
|
||||
for fail in [false,true]{
|
||||
let calls=Arc::new(AtomicUsize::new(0));let recorded=calls.clone();
|
||||
let(tx,rx)=tokio::sync::oneshot::channel();
|
||||
let operation=tokio::spawn(after_echo(async{rx.await.map_err(|_|"closed".into())},async move{
|
||||
recorded.fetch_add(1,Ordering::Relaxed);if fail{Err("send failed".into())}else{Ok(())}
|
||||
},Duration::from_secs(1)));
|
||||
tokio::task::yield_now().await;assert_eq!(calls.load(Ordering::Relaxed),0);
|
||||
tx.send(()).unwrap();assert_eq!(operation.await.unwrap().is_err(),fail);
|
||||
assert_eq!(calls.load(Ordering::Relaxed),1);
|
||||
}
|
||||
}
|
||||
#[tokio::test] async fn failed_or_missing_echo_never_sends(){
|
||||
for failed in [false,true]{
|
||||
let called=std::sync::atomic::AtomicBool::new(false);
|
||||
let result=after_echo(async{if failed{return Err("connection closed".into())}std::future::pending().await},async{called.store(true,Ordering::Relaxed);Ok(())},Duration::from_millis(5)).await;
|
||||
assert!(result.is_err());assert!(!called.load(Ordering::Relaxed));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,350 @@
|
||||
use super::wire::{self, Shape, CHANNELS};
|
||||
use serde_json::{json, Value};
|
||||
use std::sync::{Arc,atomic::{AtomicBool,AtomicU32,AtomicU64,Ordering}};
|
||||
use tokio::sync::mpsc;
|
||||
use webrtc::{api::{APIBuilder,media_engine::MediaEngine,setting_engine::SettingEngine}, peer_connection::{RTCPeerConnection,configuration::RTCConfiguration,sdp::session_description::RTCSessionDescription,policy::ice_transport_policy::RTCIceTransportPolicy}, ice_transport::{ice_server::RTCIceServer,ice_candidate::RTCIceCandidateInit}, data_channel::{RTCDataChannel,data_channel_init::RTCDataChannelInit}, rtp_transceiver::{rtp_codec::RTPCodecType,rtp_transceiver_direction::RTCRtpTransceiverDirection,RTCRtpTransceiverInit}};
|
||||
|
||||
pub fn configuration(result:&Value)->Result<RTCConfiguration,String> {
|
||||
let list=result.get("iceServers").and_then(Value::as_array).ok_or("Control acknowledgement missing iceServers")?;
|
||||
let mut servers=Vec::new();
|
||||
for server in list {
|
||||
let urls=match server.get("urls") {
|
||||
Some(Value::String(s))=>vec![s.clone()],
|
||||
Some(Value::Array(a))=>a.iter().map(|v|v.as_str().map(str::to_owned).ok_or("Invalid ICE URL")).collect::<Result<Vec<_>,_>>()?,
|
||||
_=>return Err("Invalid ICE URLs".into()),
|
||||
};
|
||||
if urls.is_empty() || urls.iter().any(|u| !["stun:","stuns:","turn:","turns:"].iter().any(|p|u.starts_with(p))) {return Err("Invalid ICE URL scheme".into())}
|
||||
let string=|key|match server.get(key) {Some(Value::String(s))=>Ok(s.clone()),None=>Ok(String::new()),_=>Err("Invalid ICE authentication")};
|
||||
// webrtc-rs rejects TURN unless the credential type is Password (as in the host's session_ice.rs).
|
||||
servers.push(RTCIceServer { urls,username:string("username")?,credential:string("credential")?,
|
||||
credential_type:webrtc::ice_transport::ice_credential_type::RTCIceCredentialType::Password });
|
||||
}
|
||||
let relay=match result.get("force_relay") {None=>false,Some(Value::Bool(b))=>*b,_=>return Err("Invalid relay policy".into())};
|
||||
if relay && !servers.iter().any(|s|s.urls.iter().any(|u|u.starts_with("turn:")||u.starts_with("turns:"))) {return Err("Relay-only session without TURN".into())}
|
||||
// An empty cloud list means host candidates only. Never invent public STUN.
|
||||
Ok(RTCConfiguration{ice_servers:servers,ice_transport_policy:if relay{RTCIceTransportPolicy::Relay}else{RTCIceTransportPolicy::All},..Default::default()})
|
||||
}
|
||||
#[derive(Clone,Copy)]
|
||||
pub enum ReadyPolicy { EchoOnly, Explicit }
|
||||
#[derive(Default)]
|
||||
pub struct Observed {
|
||||
pub control_open:AtomicBool,
|
||||
pub echo_received:AtomicBool,
|
||||
pub clipboard_supported:AtomicBool,
|
||||
pub control_messages:AtomicU64,
|
||||
pub other_messages:AtomicU64,
|
||||
pub media_packets:AtomicU64,
|
||||
pub encoder_codecs:AtomicU32,
|
||||
pub chroma:AtomicU32,
|
||||
}
|
||||
pub struct Peer {
|
||||
clipboard:super::clipboard::Bridge,
|
||||
pub tools:super::tools::Inbox,
|
||||
pub pc:Arc<RTCPeerConnection>,
|
||||
pub channels:Vec<Arc<RTCDataChannel>>,
|
||||
pub observed:Arc<Observed>,
|
||||
pub desktop:super::desktop::Desktop,
|
||||
pub audio:super::audio::Audio,
|
||||
answered:bool,
|
||||
early:Vec<RTCIceCandidateInit>,
|
||||
app_id:String,
|
||||
ice_id:String,
|
||||
remote_client:String,
|
||||
}
|
||||
fn media_engine(shape:&Shape)->Result<MediaEngine,String>{
|
||||
use webrtc::rtp_transceiver::rtp_codec::{RTCRtpCodecParameters,RTCRtpCodecCapability};
|
||||
let mut engine=MediaEngine::default();
|
||||
let mut codecs=vec![(RTPCodecType::Video,"video/H264",90000,0,"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",102),
|
||||
(RTPCodecType::Audio,"audio/opus",48000,2,"minptime=10;useinbandfec=1",111)];
|
||||
// RFC 7798 single-layer non-interleaved mode: no sprop-max-don-diff, hence no DONL.
|
||||
if shape.decoders.iter().any(|d|d.codec==2){codecs.insert(0,(RTPCodecType::Video,"video/H265",90000,0,"",104));}
|
||||
for (kind,mime,rate,channels,fmtp,payload) in codecs {
|
||||
engine.register_codec(RTCRtpCodecParameters{capability:RTCRtpCodecCapability{mime_type:mime.into(),clock_rate:rate,channels,sdp_fmtp_line:fmtp.into(),..Default::default()},payload_type:payload,..Default::default()},kind).map_err(|_|"Codec initialization failed")?;
|
||||
}Ok(engine)
|
||||
}
|
||||
impl Peer {
|
||||
pub async fn new(config:RTCConfiguration, shape:&Shape, app_id:&str, ice_id:&str, remote_client:&str, outbound:mpsc::Sender<Value>, settings:SettingEngine, mut clipboard:super::clipboard::Bridge)->Result<Self,String> {
|
||||
shape.validate_session()?;
|
||||
let mut engine=media_engine(shape)?;
|
||||
// UU RTP metadata the official Mac viewer offers (src/rtp_metadata.rs on the host side).
|
||||
for uri in ["http://www.webrtc.org/experiments/rtp-hdrext/video-capture-index","http://www.webrtc.org/experiments/rtp-hdrext/video-frame-is-new-frame"] {
|
||||
engine.register_header_extension(webrtc::rtp_transceiver::rtp_codec::RTCRtpHeaderExtensionCapability{uri:uri.into()},RTPCodecType::Video,None).map_err(|_|"RTP header extension registration failed")?;
|
||||
}
|
||||
let registry=webrtc::api::interceptor_registry::register_default_interceptors(webrtc::interceptor::registry::Registry::new(),&mut engine).map_err(|_|"RTP interceptor initialization failed")?;
|
||||
let api=APIBuilder::new().with_media_engine(engine).with_setting_engine(settings).with_interceptor_registry(registry).build();
|
||||
let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?);
|
||||
let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None));
|
||||
let inbox=tools.clone();
|
||||
pc.on_peer_connection_state_change(Box::new(move |state|{
|
||||
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
|
||||
log::info!("Viewer peer connection state: {state}");
|
||||
if matches!(state,RTCPeerConnectionState::Failed|RTCPeerConnectionState::Closed){inbox.lock().unwrap().take();}
|
||||
Box::pin(async{})
|
||||
}));
|
||||
let observed=Arc::new(Observed::default());
|
||||
let (app,ice,client)=(app_id.to_owned(),ice_id.to_owned(),remote_client.to_owned());
|
||||
let weak_pc=Arc::downgrade(&pc);
|
||||
pc.on_ice_candidate(Box::new(move |candidate| {
|
||||
let weak_pc=weak_pc.clone();let tx=outbound.clone();let(app,ice,client)=(app.clone(),ice.clone(),client.clone());
|
||||
Box::pin(async move {if let Some(candidate)=candidate {if let Ok(mut value)=candidate.to_json() {
|
||||
// Candidate callbacks can omit MID. Bind to the first actual bundled m-line.
|
||||
if let Some(pc)=weak_pc.upgrade() {
|
||||
if let Some(local)=pc.local_description().await {
|
||||
if let Some(mid)=local.sdp.lines().find_map(|line|line.strip_prefix("a=mid:")) {
|
||||
value.sdp_mid=Some(mid.trim().into());value.sdp_mline_index=Some(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let _=tx.send(json!({"client_id":client,"data":{"type":"candidate","candidate":value,"ice_id":ice,"app_control_id":app}})).await;
|
||||
}}})
|
||||
}));
|
||||
let counters=observed.clone();
|
||||
let desktop=super::desktop::Desktop::default();
|
||||
let audio=super::audio::Audio::default();let sound=audio.clone();
|
||||
let receiver=desktop.clone();let weak_pc=Arc::downgrade(&pc);
|
||||
pc.on_track(Box::new(move |track,_,_| {
|
||||
let counters=counters.clone();let desktop=receiver.clone();let audio=sound.clone();let weak_pc=weak_pc.clone();
|
||||
// The handler must return: webrtc-rs awaits it before surfacing the next track,
|
||||
// so an inline read loop on the audio track starved the video track.
|
||||
Box::pin(async move { tokio::spawn(async move {
|
||||
let video=track.kind()==RTPCodecType::Video;
|
||||
log::info!("Viewer track: kind={} mime={} payload_type={}",track.kind(),track.codec().capability.mime_type,track.payload_type());
|
||||
let opus=track.kind()==RTPCodecType::Audio && track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus");
|
||||
if video && super::media::Codec::from_mime(&track.codec().capability.mime_type).is_none() {return}
|
||||
if video {desktop.ssrc.store(track.ssrc(),Ordering::Release);}
|
||||
let mut receiver=super::media::Receiver::new(super::media::Codec::from_mime(&track.codec().capability.mime_type).unwrap_or_default());
|
||||
let mut tick=tokio::time::interval(std::time::Duration::from_millis(40));
|
||||
let mut last_pli=std::time::Instant::now()-std::time::Duration::from_secs(1);
|
||||
loop {
|
||||
let output=tokio::select! {
|
||||
packet=track.read_rtp()=>match packet {
|
||||
Ok((p,_))=>{
|
||||
counters.media_packets.fetch_add(1,Ordering::Relaxed);
|
||||
if !video {if opus {audio.push(p.header.sequence_number,&p.payload);}continue}
|
||||
// TrackRemote updates codec from the negotiated payload type on each read.
|
||||
let Some(codec)=super::media::Codec::from_mime(&track.codec().capability.mime_type) else{continue};
|
||||
if receiver.codec()!=codec {
|
||||
receiver=super::media::Receiver::new(codec);
|
||||
desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);
|
||||
}
|
||||
receiver.push(super::media::Packet{seq:p.header.sequence_number,timestamp:p.header.timestamp,marker:p.header.marker,payload:p.payload.to_vec()})
|
||||
},
|
||||
Err(_)=>break,
|
||||
},
|
||||
_=tick.tick()=>{if !video {continue} receiver.expire()},
|
||||
};
|
||||
if output.pli {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}
|
||||
for au in output.units {if desktop.units.push(super::media::AccessUnit{codec:receiver.codec(),data:au}) {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}}
|
||||
if desktop.pli.load(Ordering::Acquire) && last_pli.elapsed()>=std::time::Duration::from_millis(250) {
|
||||
desktop.pli.swap(false,Ordering::AcqRel);
|
||||
if let Some(pc)=weak_pc.upgrade() {
|
||||
use webrtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication;
|
||||
let _=pc.write_rtcp(&[Box::new(PictureLossIndication{sender_ssrc:0,media_ssrc:track.ssrc()})]).await;
|
||||
} else {break}
|
||||
last_pli=std::time::Instant::now();
|
||||
}
|
||||
}
|
||||
}); })
|
||||
}));
|
||||
let result=async {
|
||||
if shape.capture_type==1 {
|
||||
// The official Mac viewer offers five recvonly video sections (observed live).
|
||||
let videos=std::env::var("UU_VIEWER_VIDEO_SECTIONS").ok().and_then(|v|v.parse::<usize>().ok()).filter(|n|(1..=8).contains(n)).unwrap_or(1);
|
||||
for kind in std::iter::repeat(RTPCodecType::Video).take(videos).chain([RTPCodecType::Audio]) {
|
||||
pc.add_transceiver_from_kind(kind,Some(RTCRtpTransceiverInit{direction:RTCRtpTransceiverDirection::Recvonly,send_encodings:vec![]})).await.map_err(|_|"Media transceiver failed")?;
|
||||
}
|
||||
}
|
||||
let mut channels=Vec::new();
|
||||
let clipboard_enabled=clipboard.enabled;
|
||||
// Diagnostic: hosts may open their own channels; log the label and message count only.
|
||||
pc.on_data_channel(Box::new(|channel|Box::pin(async move {
|
||||
let label=channel.label().to_owned();log::info!("Viewer remote data channel opened: label={label}");
|
||||
let count=Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
channel.on_message(Box::new(move |m|{let n=count.fetch_add(1,Ordering::Relaxed);if n<8 {log::info!("Viewer remote channel message: label={label} bytes={} fields={:?}",m.data.len(),crate::protocol::decode_wire(&m.data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}Box::pin(async{})}));
|
||||
})));
|
||||
for label in CHANNELS {
|
||||
channels.push(pc.create_data_channel(label,Some(RTCDataChannelInit{ordered:Some(true),..Default::default()})).await.map_err(|_|"Data channel creation failed")?);
|
||||
}
|
||||
// Native host TEXT offers are RPC 21/case 9; CONTROL replies hit a separate empty State.
|
||||
// Keep clipboard offers/replies on TEXT, where the host desktop bridge lives.
|
||||
clipboard.start(&channels[super::clipboard::CHANNEL],&channels[0],observed.clone());
|
||||
for (index,channel) in channels.iter().enumerate() {
|
||||
if index==0 {
|
||||
let weak=Arc::downgrade(&channel);let state=observed.clone();
|
||||
let chroma444=shape.capture_type==1 && std::env::var("UU_VIEWER_CHROMA").is_ok_and(|v|v=="444");
|
||||
channel.on_open(Box::new(move ||Box::pin(async move {
|
||||
state.control_open.store(true,Ordering::Release);
|
||||
if let Some(channel)=weak.upgrade(){
|
||||
let _=channel.send(&bytes::Bytes::from(wire::echo_request_with_clipboard(1,clipboard_enabled))).await;
|
||||
if chroma444 {let _=channel.send(&bytes::Bytes::from(wire::request_chroma444())).await;}
|
||||
}
|
||||
})));
|
||||
}
|
||||
let closed=tools.clone();let state=observed.clone();
|
||||
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();Box::pin(async move {
|
||||
if index==0 {state.control_open.store(false,Ordering::Release);}
|
||||
if [0,3,4].contains(&index){closed.lock().unwrap().take();}
|
||||
})}));
|
||||
let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender();
|
||||
let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()};
|
||||
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();Box::pin(async move {
|
||||
if index==0 {
|
||||
let (codecs,chroma)=wire::media_control(&message.data);
|
||||
if let Some(codecs)=codecs {state.encoder_codecs.store(codecs,Ordering::Release);}
|
||||
if let Some(chroma)=chroma {
|
||||
if state.chroma.swap(chroma,Ordering::AcqRel)!=chroma {log::info!("Viewer capture sync: chroma={chroma}");}
|
||||
}
|
||||
let count=state.control_messages.fetch_add(1,Ordering::Relaxed);
|
||||
if wire::echo_matches(&message.data,1) {let supported=wire::echo_clipboard_supported(&message.data);
|
||||
if state.clipboard_supported.swap(supported,Ordering::AcqRel)!=supported || !state.echo_received.load(Ordering::Acquire) {log::info!("Viewer echo: clipboard_supported={supported}");}state.echo_received.store(true,Ordering::Release);}
|
||||
if let Some(request)=wire::echo_request_seq(&message.data) {
|
||||
if let Some(control)=control_for_echo.upgrade() {let _=control.send(&bytes::Bytes::from(wire::echo_response_with_clipboard(1_000_000+request,request,clipboard_enabled))).await;}
|
||||
}
|
||||
// Observe only protobuf field numbers; never print channel payloads.
|
||||
if count<32 {if let Ok(fields)=crate::protocol::decode_wire(&message.data) {let action=fields.iter().find_map(|f|match(f.number,&f.value){(3,crate::protocol::WireValue::Bytes(b))=>Some(super::tools::uint(b,1)),_=>None});
|
||||
log::info!("Viewer CONTROL fields={:?} simple_action={:?}",fields.iter().take(32).map(|f|f.number).collect::<Vec<_>>(),action);}}
|
||||
}
|
||||
if [0,1].contains(&index) && message.data.len()<=super::clipboard::MAX_TEXT*2+1024 {
|
||||
if let Some(tx)=clipboard_tx {
|
||||
if crate::protocol::decode_wire(&message.data).is_ok_and(|f|f.iter().any(|f|[17,21,22].contains(&f.number))){let _=tx.try_send(message.data.to_vec());}
|
||||
}
|
||||
}
|
||||
// Tools need FILE/BINARY traffic and CONTROL RPC replies (Message 22) only. Official
|
||||
// hosts stream many other CONTROL messages; a full queue drops that message instead of
|
||||
// detaching the tool, which previously lost every later reply.
|
||||
if index!=0 {let n=state.other_messages.fetch_add(1,Ordering::Relaxed);if n<8 {
|
||||
// Shape only: protobuf field numbers or JSON keys, never values.
|
||||
let shape=match serde_json::from_slice::<serde_json::Value>(&message.data){Ok(serde_json::Value::Object(o))=>format!("json{:?}",o.keys().collect::<Vec<_>>()),
|
||||
_=>format!("pb{:?}",crate::protocol::decode_wire(&message.data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default())};
|
||||
let inner=crate::protocol::decode_wire(&message.data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{crate::protocol::WireValue::Bytes(b) if x.number>2=>Some((x.number,crate::protocol::decode_wire(b).map(|g|g.iter().map(|y|y.number).collect::<Vec<_>>()).unwrap_or_default())),_=>None}));
|
||||
log::info!("Viewer channel message: index={index} bytes={} shape={shape} inner={inner:?}",message.data.len());}}
|
||||
// The official Windows host answers file RPCs (Message 21/22) on TEXT_DATA_CHANNEL (observed
|
||||
// on SHARE: a 320-byte Message 22 on index 1); our host uses FILE. Treat both as the file channel.
|
||||
let has=|n:&[u32]|crate::protocol::decode_wire(&message.data).is_ok_and(|f|f.iter().any(|x|n.contains(&x.number)));
|
||||
let route=if index==1 && has(&[21,22,27]) {3} else {index};
|
||||
// CONTROL carries host-initiated file RPCs (Message 21 with ftp case 8) during downloads too.
|
||||
let route=if index==0 && crate::protocol::decode_wire(&message.data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{crate::protocol::WireValue::Bytes(b) if x.number==21=>Some(super::tools::blob(b,8).is_some()),_=>None}))==Some(true) {3} else {route};
|
||||
let wanted=index==3 || index==4 || route==3 || (index==0 && has(&[22]));
|
||||
let sender=inbox.lock().unwrap().clone();
|
||||
if let (true,Some(sender))=(wanted,sender) {
|
||||
if let Err(tokio::sync::mpsc::error::TrySendError::Closed(_))=sender.try_send((route,message.data.to_vec())) {
|
||||
let mut slot=inbox.lock().unwrap();if slot.as_ref().is_some_and(|s|s.same_channel(&sender)){slot.take();}
|
||||
}
|
||||
}
|
||||
})}));
|
||||
}
|
||||
Ok::<_,String>((channels,tools,clipboard))
|
||||
}.await;
|
||||
match result {
|
||||
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
|
||||
Err(e)=>{let _=pc.close().await;Err(e)},
|
||||
}
|
||||
}
|
||||
pub async fn offer(&self)->Result<Value,String> {
|
||||
let offer=self.pc.create_offer(None).await.map_err(|_|"Create offer failed")?;
|
||||
let mut sdp=offer.sdp.clone();self.pc.set_local_description(offer).await.map_err(|_|"Set local offer failed")?;
|
||||
// The official Mac viewer's offer carries a bare session-level a=x-uuremote-quic. Only the sent
|
||||
// copy is changed: webrtc-rs rejects a modified local description.
|
||||
if !sdp.contains("a=x-uuremote-quic") { if let Some(i)=sdp.find("a=group:BUNDLE") { sdp.insert_str(i,"a=x-uuremote-quic\r\n"); } }
|
||||
// webrtc-rs omits a=max-message-size, so the host assumes 64 KB and drops larger replies (a 5600-entry
|
||||
// directory listing compresses to ~73 KB). Advertise libwebrtc's 256 KB like the host does; the
|
||||
// vendored data channel already accepts messages of that size.
|
||||
sdp=with_max_message_size(&sdp);
|
||||
// Local diagnostic: UU_VIEWER_DUMP_OFFER=path writes the sent offer SDP (stays on the operator's machine).
|
||||
if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_OFFER") {let _=std::fs::write(path,&sdp);}
|
||||
// ice_network_type=3 as sent by the official Mac viewer (observed on our host's SOAC shape log).
|
||||
Ok(json!({"client_id":self.remote_client,"data":{"type":"offer","sdp":sdp,"ice_id":self.ice_id,"app_control_id":self.app_id,"ice_network_type":3}}))
|
||||
}
|
||||
pub async fn receive(&mut self,event:&Value)->Result<(),String> {
|
||||
let body=event.get("data").unwrap_or(event);
|
||||
if !self.matches_route(event) {return Ok(())}
|
||||
match body.get("type").and_then(Value::as_str) {
|
||||
Some("answer")=> {
|
||||
if self.answered {return Ok(())}
|
||||
let sdp=answer_sdp(body)?;
|
||||
let answer=RTCSessionDescription::answer(sdp).map_err(|_|"Invalid answer")?;
|
||||
self.pc.set_remote_description(answer).await.map_err(|_|"Set remote answer failed")?;
|
||||
self.answered=true;
|
||||
for c in self.early.drain(..) {self.pc.add_ice_candidate(c).await.map_err(|_|"Queued ICE candidate failed")?;}
|
||||
}
|
||||
Some("candidate")=> {
|
||||
let value=body.get("candidate").ok_or("Missing candidate")?;
|
||||
let candidate=if let Some(s)=value.as_str() {
|
||||
RTCIceCandidateInit {candidate:s.into(),sdp_mid:body.get("sdp_mid").and_then(Value::as_str).map(str::to_owned),sdp_mline_index:body.get("sdp_mline_index").and_then(Value::as_u64).and_then(|v|u16::try_from(v).ok()),..Default::default()}
|
||||
} else {serde_json::from_value(value.clone()).map_err(|_|"Invalid candidate")?};
|
||||
if self.answered {self.pc.add_ice_candidate(candidate).await.map_err(|_|"ICE candidate failed")?;}
|
||||
else {if self.early.len()>=256{return Err("Too many early ICE candidates".into())}self.early.push(candidate);}
|
||||
}
|
||||
_=>{},
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn matches_route(&self,event:&Value)->bool {
|
||||
let body=event.get("data").unwrap_or(event);
|
||||
!body.get("ice_id").is_some_and(|v|v.as_str()!=Some(self.ice_id.as_str()))
|
||||
&& !body.get("app_control_id").is_some_and(|v|v.as_str()!=Some(self.app_id.as_str()))
|
||||
&& !event.get("client_id").is_some_and(|v|v.as_str()!=Some(self.remote_client.as_str()))
|
||||
}
|
||||
pub fn ready(&self,policy:ReadyPolicy,explicit:bool)->bool {
|
||||
self.observed.echo_received.load(Ordering::Acquire) && match policy {ReadyPolicy::EchoOnly=>true,ReadyPolicy::Explicit=>explicit}
|
||||
}
|
||||
pub async fn send_input(&self,value:&Value)->Result<(),String> {
|
||||
let channel=&self.channels[0];
|
||||
if channel.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {return Err("CONTROL is not open".into())}
|
||||
channel.send(&bytes::Bytes::from(value.to_string())).await.map_err(|_|"CONTROL input send failed")?;Ok(())
|
||||
}
|
||||
pub async fn close(&self) {self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
|
||||
}
|
||||
fn answer_sdp(body:&Value)->Result<String,String> {
|
||||
if let Some(s)=body.get("sdp").and_then(Value::as_str) {if s.len()<=1024*1024{return Ok(s.into())}}
|
||||
if let Some(s)=body.get("gzip_sdp").and_then(Value::as_str) {
|
||||
use base64::Engine;use std::io::Read;
|
||||
if s.len()>2*1024*1024 {return Err("Compressed answer too large".into())}
|
||||
let data=base64::engine::general_purpose::STANDARD.decode(s).map_err(|_|"Invalid compressed answer")?;
|
||||
let mut output=String::new();flate2::read::GzDecoder::new(data.as_slice()).take(1024*1024+1).read_to_string(&mut output).map_err(|_|"Invalid compressed answer")?;
|
||||
if output.len()<=1024*1024 {return Ok(output)}
|
||||
}
|
||||
Err("Answer missing or too large".into())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn compressed_answers_are_supported_and_bounded() {
|
||||
use base64::Engine;use std::io::Write;
|
||||
let mut encoder=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());
|
||||
encoder.write_all(b"synthetic-sdp").unwrap();
|
||||
let encoded=base64::engine::general_purpose::STANDARD.encode(encoder.finish().unwrap());
|
||||
assert_eq!(answer_sdp(&json!({"gzip_sdp":encoded})).unwrap(),"synthetic-sdp");
|
||||
assert!(answer_sdp(&json!({"gzip_sdp":"invalid!"})).is_err());
|
||||
assert!(answer_sdp(&json!({"sdp":"x".repeat(1024*1024+1)})).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
/// Adds `a=max-message-size:262144` after `a=sctp-port` when missing (sent copy only).
|
||||
pub fn with_max_message_size(sdp:&str)->String{
|
||||
if sdp.contains("a=max-message-size:"){return sdp.to_owned()}
|
||||
let eol=if sdp.contains("\r\n"){"\r\n"}else{"\n"};
|
||||
let mut out=String::with_capacity(sdp.len()+32);
|
||||
for line in sdp.split_inclusive('\n'){out.push_str(line);if line.trim_end().starts_with("a=sctp-port:"){out.push_str("a=max-message-size:262144");out.push_str(eol);}}
|
||||
out
|
||||
}
|
||||
#[cfg(test)] #[test] fn offer_advertises_max_message_size(){
|
||||
assert_eq!(with_max_message_size("m=application 9\r\na=sctp-port:5000\r\na=mid:0\r\n"),"m=application 9\r\na=sctp-port:5000\r\na=max-message-size:262144\r\na=mid:0\r\n");
|
||||
assert_eq!(with_max_message_size("a=max-message-size:1\r\n"),"a=max-message-size:1\r\n");
|
||||
}
|
||||
|
||||
#[cfg(test)] #[tokio::test] async fn offers_both_codecs_or_h264_only(){
|
||||
for force in [false,true] {
|
||||
let shape:Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap();
|
||||
let shape=shape.video_preferences(force);
|
||||
let api=APIBuilder::new().with_media_engine(media_engine(&shape).unwrap()).build();
|
||||
let pc=api.new_peer_connection(RTCConfiguration::default()).await.unwrap();
|
||||
pc.add_transceiver_from_kind(RTPCodecType::Video,Some(RTCRtpTransceiverInit{direction:RTCRtpTransceiverDirection::Recvonly,send_encodings:vec![]})).await.unwrap();
|
||||
let offer=pc.create_offer(None).await.unwrap();
|
||||
assert!(offer.sdp.contains("a=rtpmap:102 H264/90000"));
|
||||
assert_eq!(offer.sdp.contains("a=rtpmap:104 H265/90000"),!force);
|
||||
assert!(!offer.sdp.contains("sprop-max-don-diff"));pc.close().await.unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,248 @@
|
||||
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
|
||||
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
|
||||
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
|
||||
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest> }
|
||||
impl Window {
|
||||
pub fn new()->Result<Self,String>{
|
||||
let sdl=sdl2::init()?;let video=sdl.video()?;
|
||||
let window=video.window("Native viewer (experimental)",1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
|
||||
let canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
|
||||
let events=sdl.event_pump()?;let clipboard=video.clipboard();
|
||||
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16);
|
||||
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests})
|
||||
}
|
||||
pub fn clipboard_bridge(&self)->super::clipboard::Bridge{super::clipboard::Bridge::sdl(self.clipboard_tx.clone())}
|
||||
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
|
||||
fn viewport(&self)->Viewport {Viewport::fit(self.canvas.window().size(),self.frame)}
|
||||
fn poll_clipboard(&mut self){
|
||||
// Use the existing SDL window; wl-paste creates a transient toplevel on GNOME every poll.
|
||||
while let Ok(request)=self.clipboard_requests.try_recv(){
|
||||
use super::clipboard::ClipboardRequest;
|
||||
match request {
|
||||
ClipboardRequest::Read(reply)=>{
|
||||
if self.clipboard_dirty {log::debug!("Viewer clipboard read: focused={} has_text={}",self.focused,self.clipboard.has_clipboard_text());}
|
||||
let result=if self.focused && std::mem::take(&mut self.clipboard_dirty) && self.clipboard.has_clipboard_text(){read_clipboard()}else{Ok(None)};
|
||||
let _=reply.send(result);
|
||||
},
|
||||
ClipboardRequest::Write(text,reply)=>{
|
||||
let result=if self.focused {
|
||||
self.clipboard_dirty=true;
|
||||
self.clipboard.set_clipboard_text(&text).map(|()|true).map_err(|_|())
|
||||
}else{Ok(false)};
|
||||
let _=reply.send(result);
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn poll(&mut self,input:&mut Input)->(bool,Vec<serde_json::Value>){
|
||||
let viewport=self.viewport();
|
||||
let dirty=&mut self.clipboard_dirty;
|
||||
let events=self.events.poll_iter().inspect(|event|{
|
||||
if matches!(event,Event::ClipboardUpdate{..}|Event::Window{win_event:WindowEvent::FocusGained,..}){*dirty=true;}
|
||||
});
|
||||
translate_actions(events,input,viewport,&mut self.focused,&mut self.files)
|
||||
}
|
||||
}
|
||||
fn clipboard_text(bytes:&[u8])->Option<String>{
|
||||
if bytes.len()>super::clipboard::MAX_TEXT{return None}
|
||||
std::str::from_utf8(bytes).ok().map(str::to_owned)
|
||||
}
|
||||
fn read_clipboard()->Result<Option<String>,()>{
|
||||
// SDL2 0.37's String wrapper panics on invalid UTF-8; validate native bytes before copying.
|
||||
// SDL still acquires the selection synchronously; the bridge timeout cannot interrupt it.
|
||||
unsafe{
|
||||
let data=sdl2::sys::SDL_GetClipboardText();
|
||||
if data.is_null(){return Err(())}
|
||||
let length=libc::strnlen(data,super::clipboard::MAX_TEXT+1);
|
||||
let text=clipboard_text(std::slice::from_raw_parts(data.cast::<u8>(),length));
|
||||
sdl2::sys::SDL_free(data.cast());Ok(text)
|
||||
}
|
||||
}
|
||||
fn translate(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool)->(bool,Vec<serde_json::Value>){
|
||||
translate_actions(events,input,viewport,focused,&mut false)
|
||||
}
|
||||
fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewport:Viewport,focused:&mut bool,files:&mut bool)->(bool,Vec<serde_json::Value>){
|
||||
let mut messages=Vec::new();let mut quit=false;
|
||||
for event in events{
|
||||
let message=match event {
|
||||
Event::Quit{..}|Event::Window{win_event:WindowEvent::Close,..}=>{quit=true;messages.extend(input.release_all());None},
|
||||
Event::Window{win_event:WindowEvent::FocusLost,..}=>{*focused=false;messages.extend(input.release_all());None},
|
||||
Event::Window{win_event:WindowEvent::FocusGained,..}=>{*focused=true;None},
|
||||
Event::KeyDown{scancode:Some(sdl2::keyboard::Scancode::F),keymod,repeat,..}
|
||||
if *focused && keymod.intersects(sdl2::keyboard::Mod::LCTRLMOD|sdl2::keyboard::Mod::RCTRLMOD)
|
||||
&& keymod.intersects(sdl2::keyboard::Mod::LALTMOD|sdl2::keyboard::Mod::RALTMOD)=>{
|
||||
if !repeat{*files=true;messages.extend(input.release_all());}None
|
||||
},
|
||||
_ if !*focused || !input.enabled()=>None,
|
||||
Event::KeyDown{scancode:Some(s),repeat:false,..}=>input.key(s as i32,true),
|
||||
Event::KeyUp{scancode:Some(s),..}=>input.key(s as i32,false),
|
||||
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64),
|
||||
Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
|
||||
Event::MouseButtonUp{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,false)),
|
||||
_=>None,
|
||||
};if let Some(m)=message{messages.push(m);}
|
||||
} (quit,messages)
|
||||
}
|
||||
|
||||
fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}}
|
||||
impl FrameSink for Window {
|
||||
fn present(&mut self,frame:&Frame)->Result<(),String>{
|
||||
self.frame=(frame.width,frame.height);let v=self.viewport();let creator=self.canvas.texture_creator();
|
||||
let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?;
|
||||
texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?;
|
||||
self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();
|
||||
self.canvas.copy(&texture,None,Some(Rect::new(v.x as i32,v.y as i32,v.width as u32,v.height as u32)))?;self.canvas.present();Ok(())
|
||||
}
|
||||
}
|
||||
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool)->Result<(),String>{
|
||||
#[cfg(uu_gtk)]
|
||||
let mut files:Option<tokio::task::JoinHandle<Result<(),String>>>=None;
|
||||
let(tx,mut commands)=tokio::sync::mpsc::channel(8);
|
||||
if std::env::var("UU_VIEWER_COMMANDS").as_deref()==Ok("1") {
|
||||
std::thread::spawn(move||{
|
||||
use std::io::Read;
|
||||
let mut input=std::io::stdin().lock();let mut line=Vec::new();let mut byte=[0];
|
||||
while input.read(&mut byte).ok()==Some(1){
|
||||
if byte[0]==b'\n'{if line==b"files" && tx.blocking_send(()).is_err(){break}line.clear();}
|
||||
else if line.len()<32{line.push(byte[0]);}else{break}
|
||||
}
|
||||
});
|
||||
}else{drop(tx);}
|
||||
let mut command_open=true;let mut requested=false;
|
||||
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
|
||||
let mut audio=super::audio::Playback::new(&window._sdl,session.peer.audio.clone());
|
||||
let mut input=Input::new(view_only);input.set_mac(window.mac);let mut tick=tokio::time::interval(std::time::Duration::from_millis(8));
|
||||
let mut heartbeat=tokio::time::interval(std::time::Duration::from_secs(1));
|
||||
let deadline=tokio::time::sleep(std::time::Duration::from_secs(30));tokio::pin!(deadline);
|
||||
let result=async {
|
||||
loop {tokio::select!{
|
||||
command=commands.recv(),if command_open=>{if command.is_some(){requested=true}else{command_open=false}},
|
||||
_=terminate.recv()=>return Ok(()),
|
||||
_=tokio::signal::ctrl_c()=>return Ok(()),
|
||||
result=session.step()=>result?,
|
||||
_=&mut deadline,if !session.peer.observed.echo_received.load(std::sync::atomic::Ordering::Acquire)=>return Err("CONTROL echo timed out".into()),
|
||||
_=heartbeat.tick()=>{
|
||||
if input.enabled() && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){session.peer.send_input(&Input::heartbeat()).await?;}
|
||||
let o=&session.peer.observed;let s=&super::desktop::STATS;let r=std::sync::atomic::Ordering::Relaxed;
|
||||
log::info!("Viewer desktop stats: control_open={} echo={} media_packets={} access_units={} presented={} decode_errors={}",
|
||||
o.control_open.load(r),o.echo_received.load(r),o.media_packets.load(r),s[0].load(r),s[1].load(r),s[2].load(r));
|
||||
},
|
||||
_=tick.tick()=>{
|
||||
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
|
||||
let (quit,messages)=window.poll(&mut input);
|
||||
window.poll_clipboard();
|
||||
requested|=std::mem::take(&mut window.files);
|
||||
#[cfg(uu_gtk)] {
|
||||
if files.as_ref().is_some_and(|f|f.is_finished()){
|
||||
if let Some(f)=files.take(){let _=f.await;}session.peer.tools.lock().unwrap().take();
|
||||
}
|
||||
if requested && !(files.is_some() && super::tools_ui::closed()) && session.peer.channels[super::tools::FILE].ready_state()==webrtc::data_channel::data_channel_state::RTCDataChannelState::Open {
|
||||
if files.is_some(){super::tools_ui::present();}
|
||||
else {let(io,rx)=super::tools::attach(&session.peer)?;
|
||||
let name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
|
||||
files=Some(tokio::spawn(async move{super::tools_ui::files(io,rx,&name).await}));}
|
||||
requested=false;
|
||||
}
|
||||
}
|
||||
#[cfg(not(uu_gtk))] {if requested{log::warn!("File window requires GTK3");requested=false;}}
|
||||
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
|
||||
else {input.release_all();}
|
||||
if quit{return Ok(())}
|
||||
// At most one AU per iteration keeps local event polling responsive.
|
||||
if let Some(au)=session.peer.desktop.units.pop(){
|
||||
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();}
|
||||
decoder.set_codec(au.codec)?;
|
||||
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;}
|
||||
}
|
||||
}}
|
||||
}.await;
|
||||
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
|
||||
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[tokio::test] async fn clipboard_requests_use_existing_window(){
|
||||
if std::env::var_os("UU_VIEWER_CLIPBOARD_TEST_CHILD").is_none(){
|
||||
let output=std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args(["--exact","viewer::sdl::tests::clipboard_requests_use_existing_window","--test-threads=1"])
|
||||
.env("SDL_VIDEODRIVER","dummy").env("UU_VIEWER_CLIPBOARD_TEST_CHILD","1").output().unwrap();
|
||||
assert!(output.status.success(),"{}{}",String::from_utf8_lossy(&output.stdout),String::from_utf8_lossy(&output.stderr));return
|
||||
}
|
||||
let mut window=Window::new().unwrap();
|
||||
let tx=window.clipboard_tx.clone();
|
||||
use super::super::clipboard::ClipboardRequest;
|
||||
for text in ["clipboard text\n",""]{
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Write(text.into(),reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(true));
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok((!text.is_empty()).then(||text.to_owned())));
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));
|
||||
}
|
||||
window.focused=false;window.clipboard_dirty=true;
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));assert!(window.clipboard_dirty);
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Write("background".into(),reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(false));
|
||||
window.focused=true;
|
||||
let(reply,rx)=tokio::sync::oneshot::channel();
|
||||
tx.send(ClipboardRequest::Read(reply)).await.unwrap();
|
||||
window.poll_clipboard();assert_eq!(rx.await.unwrap(),Ok(None));
|
||||
window.clipboard_dirty=false;
|
||||
window._sdl.event().unwrap().push_event(Event::Window{timestamp:0,window_id:window.canvas.window().id(),win_event:WindowEvent::FocusGained}).unwrap();
|
||||
window.poll(&mut Input::new(true));assert!(window.clipboard_dirty);
|
||||
let bridge=window.clipboard_bridge();assert!(bridge.enabled);
|
||||
drop(window);
|
||||
assert!(tx.is_closed());drop(bridge);
|
||||
let window=Window::new().unwrap();assert!(window.clipboard_bridge().enabled);
|
||||
}
|
||||
#[test] fn clipboard_text_rejects_invalid_or_large_data_and_keeps_empty_text(){
|
||||
assert_eq!(clipboard_text(b""),Some(String::new()));
|
||||
assert_eq!(clipboard_text(b"text\n"),Some("text\n".into()));
|
||||
assert_eq!(clipboard_text(&[255]),None);
|
||||
assert_eq!(clipboard_text(&vec![b'a';super::super::clipboard::MAX_TEXT+1]),None);
|
||||
}
|
||||
#[test] fn file_shortcut_is_local_in_control_and_watch_modes(){
|
||||
use sdl2::keyboard::{Scancode as S,Mod as M};
|
||||
for watch in [false,true]{
|
||||
let mut input=Input::new(watch);let mut focused=true;let mut files=false;
|
||||
input.key(S::LCtrl as i32,true);input.key(S::LAlt as i32,true);
|
||||
let key=|repeat|Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(S::F),keymod:M::LCTRLMOD|M::LALTMOD,repeat};
|
||||
let (_,out)=translate_actions([key(false),key(true),Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(S::F),keymod:M::NOMOD,repeat:false}],
|
||||
&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused,&mut files);
|
||||
assert!(files);assert!(out.iter().all(|v|v["action"]=="kbd_release"));
|
||||
assert!(input.release_all().is_empty());
|
||||
}
|
||||
}
|
||||
#[test] fn watch_events_never_emit_input_and_still_close(){
|
||||
let mut input=Input::new(true);let mut focused=true;
|
||||
assert!(input.key(4,true).is_none());assert!(input.button(1,true).is_none());assert!(!input.enabled());
|
||||
let events=[
|
||||
Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false},
|
||||
Event::MouseMotion{timestamp:0,window_id:1,which:0,mousestate:sdl2::mouse::MouseState::from_sdl_state(0),x:12,y:34,xrel:1,yrel:1},
|
||||
Event::MouseButtonDown{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:12,y:34},
|
||||
Event::MouseButtonUp{timestamp:0,window_id:1,which:0,mouse_btn:MouseButton::Left,clicks:1,x:12,y:34},
|
||||
Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false},
|
||||
Event::Window{timestamp:0,window_id:1,win_event:WindowEvent::FocusLost},
|
||||
Event::Window{timestamp:0,window_id:1,win_event:WindowEvent::FocusGained},Event::Quit{timestamp:0}];
|
||||
let (quit,out)=translate(events,&mut input,Viewport::fit((800,600),(1920,1080)),&mut focused);
|
||||
assert!(quit);assert!(out.is_empty());assert!(input.release_all().is_empty());
|
||||
}
|
||||
#[test] fn focus_event_releases_and_suppresses_input_until_focus_returns(){
|
||||
let mut input=Input::default();input.key(4,true);input.button(1,true);let mut focused=true;
|
||||
let focus=|win_event|Event::Window{timestamp:0,window_id:1,win_event};
|
||||
let key=Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(sdl2::keyboard::Scancode::A),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false};
|
||||
let v=Viewport::fit((800,600),(1920,1080));
|
||||
let (quit,out)=translate([focus(WindowEvent::FocusLost),key.clone()],&mut input,v,&mut focused);
|
||||
assert!(!quit);assert_eq!(out.len(),2);assert!(input.release_all().is_empty());assert!(!focused);
|
||||
let (_,out)=translate([focus(WindowEvent::FocusGained),key,Event::Quit{timestamp:0}],&mut input,v,&mut focused);
|
||||
assert_eq!(out.len(),2);assert_eq!(out[0]["action"],"kbd_press");assert_eq!(out[1]["action"],"kbd_release");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
use super::{api::JoinData,wire::{self,Shape},signal::Signal,rtc::{self,Peer,ReadyPolicy}};
|
||||
use serde_json::Value;
|
||||
use std::{sync::atomic::Ordering,time::Duration};
|
||||
use tokio::sync::mpsc;
|
||||
use webrtc::api::setting_engine::SettingEngine;
|
||||
|
||||
pub struct Options {pub timeout:Duration,pub legacy_prefix:bool,pub ready_policy:ReadyPolicy,pub clipboard:super::clipboard::Bridge}
|
||||
pub struct Session {pub peer:Peer,signal:Signal,candidates:mpsc::Receiver<Value>,policy:ReadyPolicy}
|
||||
impl Session {
|
||||
pub async fn open(room:&JoinData,shape:&Shape,device:&str,client:&str,options:Options,settings:SettingEngine)->Result<Self,String> {
|
||||
shape.validate_session()?;
|
||||
let shape=shape.video_preferences(std::env::var("UU_VIEWER_CODEC").is_ok_and(|v|v.eq_ignore_ascii_case("h264")));
|
||||
shape.validate_session()?;
|
||||
let app=wire::uuid();let ice=hex::encode(rand::random::<[u8;16]>());
|
||||
let timeout=if room.ws_connect_timeout_ms>0 {Duration::from_millis(room.ws_connect_timeout_ms as u64)}else{options.timeout};
|
||||
let mut signal=Signal::connect(&room.signaling_list,&room.token,timeout,options.legacy_prefix).await?;
|
||||
let result=async {
|
||||
let result=signal.control(shape.control(client,&app,&ice)?,shape.connect_options(device,options.clipboard.enabled)?,options.timeout).await?;
|
||||
// Key names per ICE entry and URL scheme only (no values) to see where TURN credentials live.
|
||||
if let Some(list)=result.get("iceServers").and_then(Value::as_array) {
|
||||
let summary:Vec<String>=list.iter().map(|s|{
|
||||
let scheme=s.get("urls").and_then(|u|u.as_str().map(str::to_owned).or_else(||u.get(0).and_then(Value::as_str).map(str::to_owned))).unwrap_or_default();
|
||||
let keys:Vec<&str>=s.as_object().map(|o|o.keys().map(String::as_str).collect()).unwrap_or_default();
|
||||
format!("{}:{:?}",scheme.split(':').next().unwrap_or(""),keys)}).collect();
|
||||
log::info!("Control ack ICE entries: {:?}",summary);
|
||||
}
|
||||
// Structure and relations only; never the ids or ICE credentials.
|
||||
log::info!("Control ack shape={} app_control_id_matches={:?} ice_id_matches={:?}",crate::protocol::json_shape(&result,5),
|
||||
result.get("app_control_id").map(|v|v.as_str()==Some(app.as_str())),result.get("ice_id").map(|v|v.as_str()==Some(ice.as_str())));
|
||||
if result.get("app_control_id").is_some_and(|v|v.as_str()!=Some(app.as_str())) {return Err("Control acknowledgement belongs to another session".into())}
|
||||
// Observed live: the cloud assigns the session ice_id in this ack rather than echoing ours.
|
||||
let ice=result.get("ice_id").and_then(Value::as_str).filter(|s|!s.is_empty()&&s.len()<=128).map(str::to_owned).unwrap_or(ice);
|
||||
let remote=result.get("client_id").and_then(Value::as_str).filter(|s|!s.is_empty()).ok_or("Control acknowledgement missing peer route")?;
|
||||
let config=rtc::configuration(&result)?;
|
||||
let(tx,rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(config,&shape,&app,&ice,remote,tx,settings,options.clipboard).await?;
|
||||
// The official host drops an offer whose ice_id is not yet in its connection table
|
||||
// (libstreamer 0xc3080); give it time to process be-controlled first.
|
||||
let delay=std::env::var("UU_VIEWER_OFFER_DELAY_MS").ok().and_then(|v|v.parse().ok()).unwrap_or(0u64).min(10_000);
|
||||
tokio::time::sleep(Duration::from_millis(delay)).await;
|
||||
match peer.offer().await {
|
||||
Ok(offer)=>match signal.soac(offer).await {Ok(())=>Ok((peer,rx)),Err(e)=>{peer.close().await;Err(e)}},
|
||||
Err(e)=>{peer.close().await;Err(e)},
|
||||
}
|
||||
}.await;
|
||||
match result {
|
||||
Ok((peer,candidates))=>Ok(Self{peer,signal,candidates,policy:options.ready_policy}),
|
||||
Err(e)=>{signal.close().await;Err(e)},
|
||||
}
|
||||
}
|
||||
pub async fn step(&mut self)->Result<(),String> {
|
||||
tokio::select! {
|
||||
candidate=self.candidates.recv()=>if let Some(candidate)=candidate {self.signal.soac(candidate).await?},
|
||||
event=self.signal.event()=> {
|
||||
let event=event?;
|
||||
// Event name and SOAC type only.
|
||||
log::info!("Viewer signaling event: name={} soac_type={}",event.get(0).and_then(Value::as_str).unwrap_or("-"),
|
||||
event.get(1).and_then(|b|b.get("type").or_else(||b.get("data").and_then(|d|d.get("type")))).and_then(Value::as_str).unwrap_or("-"));
|
||||
match event.get(0).and_then(Value::as_str) {
|
||||
Some("soac")=>if let Some(body)=event.get(1) {self.peer.receive(body).await?},
|
||||
Some("released"|"left"|"leave")=> {
|
||||
// An event for another peer must not tear down this session.
|
||||
if self.peer.matches_route(event.get(1).unwrap_or(&Value::Null)) {return Err("Remote session released".into())}
|
||||
}
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub async fn run(&mut self)->Result<(),String> {
|
||||
let mut interval=tokio::time::interval(Duration::from_secs(1));
|
||||
let mut reported=(false,false,false);
|
||||
let deadline=tokio::time::sleep(Duration::from_secs(30));tokio::pin!(deadline);
|
||||
loop {
|
||||
tokio::select! {
|
||||
_=tokio::signal::ctrl_c()=>return Ok(()),
|
||||
result=self.step()=>result?,
|
||||
_=&mut deadline,if !self.peer.observed.echo_received.load(Ordering::Acquire)=>return Err("CONTROL echo timed out".into()),
|
||||
_=interval.tick()=> {
|
||||
if self.peer.observed.control_open.load(Ordering::Acquire) {self.peer.send_input(&super::input::Input::heartbeat()).await?;}
|
||||
let state=(self.peer.observed.control_open.load(Ordering::Acquire),self.peer.observed.echo_received.load(Ordering::Acquire),self.peer.ready(self.policy,false));
|
||||
if state!=reported {log::info!("Viewer session: control_open={} echo_received={} configured_ready={} control_messages={} media_packets={}",state.0,state.1,state.2,self.peer.observed.control_messages.load(Ordering::Relaxed),self.peer.observed.media_packets.load(Ordering::Relaxed));reported=state;}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pub async fn close(&mut self) {self.peer.close().await;self.signal.close().await;}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
//! Framing/ack evidence: internal viewer-evidence-20261016.md section 3.
|
||||
//! Raw Engine.IO4 attachments and legacy SDK 0x04 framing are explicit alternatives.
|
||||
use base64::Engine as _;
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
use serde_json::Value;
|
||||
use tokio::net::TcpStream;
|
||||
use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
|
||||
use tokio_tungstenite::tungstenite::{client::IntoClientRequest, Message};
|
||||
use std::{collections::VecDeque,time::Duration};
|
||||
|
||||
pub struct Signal {
|
||||
ws: WebSocketStream<MaybeTlsStream<TcpStream>>,
|
||||
next_ack:u64,
|
||||
pending:VecDeque<Value>,
|
||||
legacy_prefix:bool,
|
||||
}
|
||||
impl Signal {
|
||||
pub async fn connect(urls:&[String], token:&str, timeout:Duration, legacy_prefix:bool)->Result<Self,String> {
|
||||
for url in urls {
|
||||
if let Ok(Ok(signal))=tokio::time::timeout(timeout,Self::one(url,token,legacy_prefix)).await {return Ok(signal)}
|
||||
}
|
||||
Err("Signaling connection failed (details omitted)".into())
|
||||
}
|
||||
async fn one(url:&str,token:&str,legacy_prefix:bool)->Result<Self,String> {
|
||||
let mut request=format!("{}/socket.io/?transport=websocket&EIO=4",url.trim_end_matches('/')).into_client_request().map_err(|_|"Invalid signaling endpoint")?;
|
||||
request.headers_mut().insert("X-NRD-AUTH",token.parse().map_err(|_|"Invalid room authentication header")?);
|
||||
let (ws,_)=connect_async(request).await.map_err(|_|"Signaling transport failed")?;
|
||||
let mut s=Self{ws,next_ack:10,pending:VecDeque::new(),legacy_prefix};
|
||||
let mut opened=false;
|
||||
loop {
|
||||
match s.ws.next().await {
|
||||
Some(Ok(Message::Text(t))) if t.starts_with('0') && !opened => {
|
||||
serde_json::from_str::<Value>(&t[1..]).map_err(|_|"Invalid Engine.IO open")?;
|
||||
opened=true;s.send(Message::Text("40".into())).await?;
|
||||
}
|
||||
Some(Ok(Message::Text(t))) if t.starts_with("40") && opened =>return Ok(s),
|
||||
Some(Ok(Message::Text(t))) if t.starts_with('2')=>s.send(Message::Text(format!("3{}",&t[1..]))).await?,
|
||||
Some(Ok(Message::Ping(b)))=>s.send(Message::Pong(b)).await?,
|
||||
_=>return Err("Signaling handshake failed".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
async fn send(&mut self,message:Message)->Result<(),String> {self.ws.send(message).await.map_err(|_|"Signaling send failed".into())}
|
||||
pub async fn control(&mut self, header:Value, app_data:Vec<u8>, timeout:Duration)->Result<Value,String> {
|
||||
self.next_ack+=1;let id=self.next_ack;
|
||||
self.send(Message::Text(format!("451-{id}{}",serde_json::json!(["control",header])))).await?;
|
||||
let mut attachment=Vec::new();if self.legacy_prefix {attachment.push(4)} attachment.extend(app_data);
|
||||
self.send(Message::Binary(attachment)).await?;
|
||||
tokio::time::timeout(timeout,async {
|
||||
loop {
|
||||
match self.packet().await? {
|
||||
Packet::Ack(ack,value) if ack==id=> {
|
||||
let a=value.as_array().ok_or("Invalid control acknowledgement")?;
|
||||
if a.len()!=2 || a[0].as_str()!=Some("success") || !a[1].is_object() {return Err("Control refused or malformed acknowledgement".into())}
|
||||
return Ok(a[1].clone());
|
||||
}
|
||||
Packet::Event(value)=> {
|
||||
if self.pending.len()>=64 {return Err("Too many pre-control signaling events".into())}
|
||||
self.pending.push_back(value);
|
||||
}
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
}).await.map_err(|_|"Control acknowledgement timed out")?
|
||||
}
|
||||
async fn packet(&mut self)->Result<Packet,String> {
|
||||
loop {
|
||||
match self.ws.next().await {
|
||||
Some(Ok(Message::Text(t))) if t.starts_with('2')=>self.send(Message::Text(format!("3{}",&t[1..]))).await?,
|
||||
Some(Ok(Message::Ping(b)))=>self.send(Message::Pong(b)).await?,
|
||||
Some(Ok(Message::Text(t))) if t.starts_with("43")=> {
|
||||
let begin=t.find('[').ok_or("Malformed signaling acknowledgement")?;
|
||||
let id=t[2..begin].parse().map_err(|_|"Malformed signaling acknowledgement id")?;
|
||||
let value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed signaling acknowledgement body")?;
|
||||
return Ok(Packet::Ack(id,value))
|
||||
}
|
||||
Some(Ok(Message::Text(t))) if t.starts_with("42")=> {
|
||||
let begin=t.find('[').ok_or("Malformed signaling event")?;
|
||||
let value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed signaling event body")?;
|
||||
return Ok(Packet::Event(value))
|
||||
}
|
||||
// Socket.IO binary event (45N-[...] / 46N-[...] ack) followed by N attachment frames.
|
||||
// The official host sends its answer this way (binary gzip_sdp); attachments are
|
||||
// substituted as base64 strings so the existing gzip_sdp decoder applies.
|
||||
Some(Ok(Message::Text(t))) if t.starts_with("45") || t.starts_with("46")=> {
|
||||
let dash=t.find('-').ok_or("Malformed binary signaling packet")?;
|
||||
let count:usize=t[2..dash].parse().map_err(|_|"Malformed binary attachment count")?;
|
||||
if count>8 {return Err("Too many signaling attachments".into())}
|
||||
let begin=t.find('[').ok_or("Malformed binary signaling packet")?;
|
||||
let mut value:serde_json::Value=serde_json::from_str(&t[begin..]).map_err(|_|"Malformed binary signaling body")?;
|
||||
let mut attachments=Vec::with_capacity(count);
|
||||
while attachments.len()<count {
|
||||
match self.ws.next().await {
|
||||
Some(Ok(Message::Binary(mut b)))=>{
|
||||
if b.len()>2 && b[0]==4 && b[1]==0x1f {b.remove(0);}
|
||||
if b.len()>4*1024*1024 {return Err("Signaling attachment too large".into())}
|
||||
attachments.push(base64::engine::general_purpose::STANDARD.encode(&b));
|
||||
}
|
||||
Some(Ok(Message::Text(t))) if t.starts_with('2')=>self.send(Message::Text(format!("3{}",&t[1..]))).await?,
|
||||
Some(Ok(_))=>{},
|
||||
_=>return Err("Signaling disconnected".into()),
|
||||
}
|
||||
}
|
||||
fn fill(v:&mut serde_json::Value,a:&[String]) {
|
||||
match v {
|
||||
serde_json::Value::Object(o) if o.get("_placeholder")==Some(&serde_json::Value::Bool(true))=>{
|
||||
if let Some(s)=o.get("num").and_then(|n|n.as_u64()).and_then(|n|a.get(n as usize)) {*v=serde_json::Value::String(s.clone());}
|
||||
}
|
||||
serde_json::Value::Object(o)=>for x in o.values_mut(){fill(x,a)},
|
||||
serde_json::Value::Array(l)=>for x in l{fill(x,a)},
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
fill(&mut value,&attachments);
|
||||
log::info!("Viewer binary signaling event: name={} attachments={}",value.get(0).and_then(|v|v.as_str()).unwrap_or("-"),count);
|
||||
if t.starts_with("46") {
|
||||
let id=t[dash+1..begin].parse().map_err(|_|"Malformed binary acknowledgement id")?;
|
||||
return Ok(Packet::Ack(id,value))
|
||||
}
|
||||
return Ok(Packet::Event(value))
|
||||
}
|
||||
Some(Ok(Message::Text(t))) if t=="41" || t=="1"=>return Err("Signaling room closed".into()),
|
||||
Some(Ok(Message::Close(_)))|None|Some(Err(_))=>return Err("Signaling disconnected".into()),
|
||||
// Type, short prefix and length only, to see what else the room delivers.
|
||||
Some(Ok(Message::Text(t)))=>log::info!("Viewer signaling frame ignored: text prefix={} bytes={}",t.chars().take(3).collect::<String>(),t.len()),
|
||||
Some(Ok(Message::Binary(b)))=>log::info!("Viewer signaling frame ignored: binary bytes={}",b.len()),
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
}
|
||||
pub async fn event(&mut self)->Result<Value,String> {
|
||||
if let Some(v)=self.pending.pop_front(){return Ok(v)}
|
||||
loop {if let Packet::Event(v)=self.packet().await?{return Ok(v)}}
|
||||
}
|
||||
pub async fn soac(&mut self, value:Value)->Result<(),String> {self.send(Message::Text(format!("42{}",serde_json::json!(["soac",value])))).await}
|
||||
pub async fn close(&mut self) {let _=self.ws.close(None).await;}
|
||||
}
|
||||
enum Packet { Ack(u64,Value), Event(Value) }
|
||||
@@ -0,0 +1,341 @@
|
||||
use super::{api::JoinData,session::{Session,Options},signal::Signal,rtc::{self,Peer,ReadyPolicy},wire::{self,Shape}};
|
||||
use serde_json::{json,Value};
|
||||
use std::{sync::{Arc,atomic::{AtomicUsize,Ordering}},time::Duration};
|
||||
use tokio::{net::TcpListener,sync::{Mutex,mpsc}};
|
||||
use futures_util::{SinkExt,StreamExt};
|
||||
use tokio_tungstenite::{accept_async,tungstenite::Message};
|
||||
use webrtc::{api::{APIBuilder,media_engine::MediaEngine,setting_engine::SettingEngine},peer_connection::{configuration::RTCConfiguration,sdp::session_description::RTCSessionDescription},util::vnet::{net::{Net,NetConfig},router::{Router,RouterConfig}}};
|
||||
|
||||
async fn virtual_network()->(SettingEngine,SettingEngine,Arc<Mutex<Router>>) {
|
||||
// RFC 5737 documentation addresses live only inside webrtc's in-memory network.
|
||||
let router=Arc::new(Mutex::new(Router::new(RouterConfig{cidr:"192.0.2.0/24".into(),..Default::default()}).unwrap()));
|
||||
let mut settings=Vec::new();
|
||||
for address in ["192.0.2.10","192.0.2.11"] {
|
||||
let net=Arc::new(Net::new(Some(NetConfig{static_ips:vec![address.into()],..Default::default()})));
|
||||
let nic=net.get_nic().unwrap();router.lock().await.add_net(nic.clone()).await.unwrap();
|
||||
nic.lock().await.set_router(router.clone()).await.unwrap();
|
||||
let mut setting=SettingEngine::default();setting.set_vnet(Some(net));
|
||||
setting.set_network_types(vec![webrtc::ice::network_type::NetworkType::Udp4]);
|
||||
settings.push(setting);
|
||||
}
|
||||
router.lock().await.start().await.unwrap();
|
||||
let b=settings.pop().unwrap();(settings.pop().unwrap(),b,router)
|
||||
}
|
||||
fn shape()->Shape {serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap()}
|
||||
|
||||
#[test]
|
||||
fn ice_configuration_preserves_credentials_without_public_fallback() {
|
||||
let result=json!({"iceServers":[{"urls":"turn:relay.example.invalid:3478","username":"synthetic-user","credential":"synthetic-pass"}],"force_relay":true});
|
||||
let config=rtc::configuration(&result).unwrap();assert_eq!(config.ice_servers.len(),1);
|
||||
assert_eq!(config.ice_servers[0].credential,"synthetic-pass");
|
||||
assert_eq!(config.ice_transport_policy,webrtc::peer_connection::policy::ice_transport_policy::RTCIceTransportPolicy::Relay);
|
||||
assert!(rtc::configuration(&json!({"iceServers":[]})).unwrap().ice_servers.is_empty());
|
||||
for result in [json!({}),json!({"iceServers":[],"force_relay":true}),json!({"iceServers":[{"urls":"https://invalid.example"}]}),json!({"iceServers":[{"urls":[7]}]})] {assert!(rtc::configuration(&result).is_err());}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn websocket_control_ack_framing_heartbeat_failure_and_timeout() {
|
||||
for legacy in [false,true] {
|
||||
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();
|
||||
let url=format!("ws://{}",listener.local_addr().unwrap());
|
||||
let server=tokio::spawn(async move {
|
||||
let(stream,_)=listener.accept().await.unwrap();let mut ws=accept_async(stream).await.unwrap();
|
||||
ws.send(Message::Text("0{}".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("40".into()));
|
||||
ws.send(Message::Text("40{}".into())).await.unwrap();
|
||||
let Message::Text(t)=ws.next().await.unwrap().unwrap() else{panic!()};assert!(t.starts_with("451-11["));
|
||||
let Message::Binary(b)=ws.next().await.unwrap().unwrap() else{panic!()};assert_eq!(b,if legacy{vec![4,8,1]}else{vec![8,1]});
|
||||
ws.send(Message::Text("2fixture".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("3fixture".into()));
|
||||
ws.send(Message::Text("43999[\"success\",{}]".into())).await.unwrap();
|
||||
ws.send(Message::Text("4311[\"fail\",{}]".into())).await.unwrap();
|
||||
});
|
||||
let mut signal=Signal::connect(&["invalid endpoint".into(),url],"synthetic-ticket",Duration::from_millis(100),legacy).await.unwrap();
|
||||
assert!(signal.control(json!({}),vec![8,1],Duration::from_secs(2)).await.unwrap_err().contains("refused"));signal.close().await;server.await.unwrap();
|
||||
}
|
||||
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();let url=format!("ws://{}",listener.local_addr().unwrap());
|
||||
let job=tokio::spawn(async move {
|
||||
let(s,_)=listener.accept().await.unwrap();let mut ws=accept_async(s).await.unwrap();ws.send(Message::Text("0{}".into())).await.unwrap();let _=ws.next().await;
|
||||
ws.send(Message::Text("40{}".into())).await.unwrap();while ws.next().await.is_some(){}
|
||||
});
|
||||
let mut signal=Signal::connect(&[url],"synthetic-ticket",Duration::from_secs(2),false).await.unwrap();
|
||||
assert!(signal.control(json!({}),vec![],Duration::from_millis(20)).await.unwrap_err().contains("timed out"));signal.close().await;job.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn complete_session_uses_loopback_signaling_and_virtual_rtc_through_echo() {
|
||||
tokio::time::timeout(Duration::from_secs(20),async {
|
||||
let(viewer_settings,host_settings,router)=virtual_network().await;
|
||||
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
|
||||
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter};
|
||||
let track=Arc::new(TrackLocalStaticRTP::new(webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"synthetic-video".into(),"synthetic-stream".into()));
|
||||
let sender=host.add_track(track.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
|
||||
let (input_tx,mut input_rx)=mpsc::channel(8);
|
||||
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
|
||||
host.on_data_channel(Box::new(move |channel| {
|
||||
let count=count.clone();let input_tx=input_tx.clone();Box::pin(async move {
|
||||
assert!(wire::CHANNELS.contains(&channel.label()));assert!(channel.ordered());assert!(!channel.negotiated());
|
||||
let c=count.clone();channel.on_open(Box::new(move ||Box::pin(async move{c.fetch_add(1,Ordering::Relaxed);} )));
|
||||
if channel.label()==wire::CHANNELS[0] {
|
||||
let weak=Arc::downgrade(&channel);
|
||||
channel.on_message(Box::new(move |message| {let weak=weak.clone();let input_tx=input_tx.clone();Box::pin(async move {
|
||||
if message.data.first()==Some(&b'{') {input_tx.send(serde_json::from_slice::<Value>(&message.data).unwrap()).await.unwrap();return}
|
||||
for (action,number) in [(super::power::Action::Reboot,9),(super::power::Action::Shutdown,12)] {
|
||||
if message.data.as_ref()==action.message(2).as_slice(){input_tx.send(json!({"power":number})).await.unwrap();return}
|
||||
}
|
||||
assert_eq!(&message.data[..],&wire::echo_request(1));
|
||||
let mut action=Vec::new();wire::int(1,1,&mut action);wire::bytes(2,br#"{"seq":1}"#,&mut action);
|
||||
if let Some(channel)=weak.upgrade(){channel.send(&bytes::Bytes::from(wire::envelope(100,3,&action))).await.unwrap();}
|
||||
})}));
|
||||
} else if [wire::CHANNELS[3],wire::CHANNELS[4]].contains(&channel.label()) {
|
||||
let weak=Arc::downgrade(&channel);
|
||||
channel.on_message(Box::new(move |message|{let weak=weak.clone();Box::pin(async move{
|
||||
if let Some(dc)=weak.upgrade(){dc.send(&message.data).await.unwrap();}
|
||||
})}));
|
||||
}
|
||||
})
|
||||
}));
|
||||
let(tx,mut candidates)=mpsc::channel(256);
|
||||
host.on_ice_candidate(Box::new(move |candidate| {let tx=tx.clone();Box::pin(async move {
|
||||
if let Some(candidate)=candidate {let mut c=candidate.to_json().unwrap();c.sdp_mid=Some("0".into());c.sdp_mline_index=Some(0);tx.send(c).await.unwrap();}
|
||||
})}));
|
||||
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,0)).await.unwrap();let url=format!("ws://{}",listener.local_addr().unwrap());
|
||||
let server_host=host.clone();let(done_tx,mut done_rx)=mpsc::channel::<()>(1);
|
||||
let server=tokio::spawn(async move {
|
||||
let(stream,_)=listener.accept().await.unwrap();
|
||||
let mut ws=tokio_tungstenite::accept_hdr_async(stream,|request:&tokio_tungstenite::tungstenite::handshake::server::Request,response| {
|
||||
assert_eq!(request.headers()["X-NRD-AUTH"],"synthetic-room-ticket");assert_eq!(request.uri().path(),"/socket.io/");Ok(response)
|
||||
}).await.unwrap();
|
||||
ws.send(Message::Text("0{\"sid\":\"fixture\"}".into())).await.unwrap();assert_eq!(ws.next().await.unwrap().unwrap(),Message::Text("40".into()));ws.send(Message::Text("40{}".into())).await.unwrap();
|
||||
let Message::Text(packet)=ws.next().await.unwrap().unwrap() else{panic!()};
|
||||
let begin=packet.find('[').unwrap();let ack=packet[4..begin].parse::<u64>().unwrap();let args:Value=serde_json::from_str(&packet[begin..]).unwrap();assert_eq!(args[0],"control");
|
||||
let app=args[1]["app_control_id"].clone();
|
||||
// As observed live: the viewer sends no ice_id and the cloud assigns one in the ack.
|
||||
assert!(args[1].get("ice_id").is_none()&&args[1].get("client_id").is_none()&&args[1].get("controller_platform").is_none());
|
||||
let ice=json!("synthetic-cloud-ice");
|
||||
let streamer:Value=serde_json::from_str(args[1]["streamer_data"].as_str().unwrap()).unwrap();assert_eq!(streamer["control_id"],app);
|
||||
let Message::Binary(b)=ws.next().await.unwrap().unwrap() else{panic!()};assert!(crate::protocol::decode_wire(&b).is_ok());
|
||||
// A queued foreign candidate must not be installed into this PC.
|
||||
ws.send(Message::Text(format!("42{}",json!(["soac",{"data":{"type":"candidate","ice_id":"synthetic-other-session","candidate":"invalid"}}])))).await.unwrap();
|
||||
ws.send(Message::Text(format!("43{ack}{}",json!(["success",{"iceServers":[],"client_id":"synthetic-host","app_control_id":app,"ice_id":ice}])))).await.unwrap();
|
||||
loop {
|
||||
tokio::select! {
|
||||
_=done_rx.recv()=>break,
|
||||
candidate=candidates.recv()=>if let Some(candidate)=candidate {
|
||||
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"candidate","candidate":candidate,"app_control_id":app,"ice_id":ice}}])))).await.unwrap();
|
||||
},
|
||||
message=ws.next()=> {
|
||||
let Some(Ok(Message::Text(packet)))=message else{break};
|
||||
let value:Value=serde_json::from_str(&packet[2..]).unwrap();let body=&value[1]["data"];
|
||||
match body["type"].as_str() {
|
||||
Some("offer")=> {
|
||||
let offered=body["sdp"].as_str().unwrap();
|
||||
assert!(offered.contains("H264/90000") && offered.contains("opus/48000"));
|
||||
assert!(offered.contains("H265/90000") && !offered.contains("VP8"));
|
||||
assert_eq!(offered.matches("a=recvonly").count(),2);
|
||||
server_host.set_remote_description(RTCSessionDescription::offer(offered.into()).unwrap()).await.unwrap();
|
||||
let answer=server_host.create_answer(None).await.unwrap();let sdp=answer.sdp.clone();let mut gathered=server_host.gathering_complete_promise().await;server_host.set_local_description(answer).await.unwrap();
|
||||
gathered.recv().await;
|
||||
// Force one real remote candidate to arrive before the answer.
|
||||
let candidate=candidates.recv().await.unwrap();
|
||||
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"candidate","candidate":candidate,"app_control_id":app,"ice_id":ice}}])))).await.unwrap();
|
||||
ws.send(Message::Text(format!("42{}",json!(["soac",{"client_id":"synthetic-host","data":{"type":"answer","sdp":sdp,"ice_id":ice,"app_control_id":app}}])))).await.unwrap();
|
||||
}
|
||||
Some("candidate")=>server_host.add_ice_candidate(serde_json::from_value(body["candidate"].clone()).unwrap()).await.unwrap(),
|
||||
_=>panic!("unexpected synthetic event"),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
let room:JoinData=serde_json::from_value(json!({"token":"synthetic-room-ticket","signaling_list":[url],"report_token":"synthetic-report","report_url":""})).unwrap();
|
||||
let options=Options{timeout:Duration::from_secs(3),legacy_prefix:false,ready_policy:ReadyPolicy::Explicit,clipboard:super::clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape(),"synthetic-device","synthetic-client",options,viewer_settings).await.unwrap();
|
||||
assert_eq!(session.peer.channels.len(),5);
|
||||
let(tool_io,mut tool_rx)=super::tools::attach(&session.peer).unwrap();
|
||||
assert!(super::tools::attach(&session.peer).is_err());
|
||||
loop {
|
||||
tokio::select! {_=tokio::time::sleep(Duration::from_millis(20))=>{},result=session.step()=>result.unwrap()}
|
||||
if session.peer.ready(ReadyPolicy::EchoOnly,false) && opened.load(Ordering::Relaxed)==5 {break}
|
||||
}
|
||||
assert!(!session.peer.ready(ReadyPolicy::Explicit,false));assert!(session.peer.ready(ReadyPolicy::Explicit,true));
|
||||
assert!(session.peer.observed.control_open.load(Ordering::Acquire));
|
||||
for channel in [super::tools::FILE,super::tools::BINARY] {
|
||||
let data=vec![channel as u8;32*1024];tool_io.send(channel,data.clone()).await.unwrap();
|
||||
loop{let(c,b)=tool_rx.recv().await.unwrap();if c==channel{assert_eq!(b,data);break}}
|
||||
}
|
||||
let mut input=super::input::Input::default();
|
||||
let press=input.key(4,true).unwrap();session.peer.send_input(&press).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),press);
|
||||
for release in input.release_all(){session.peer.send_input(&release).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),release);}
|
||||
let heartbeat=super::input::Input::heartbeat();session.peer.send_input(&heartbeat).await.unwrap();assert_eq!(input_rx.recv().await.unwrap(),heartbeat);
|
||||
let packet=|seq,ts,marker,payload:&[u8]|webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:ts,marker,..Default::default()},payload:bytes::Bytes::copy_from_slice(payload)};
|
||||
track.write_rtp(&packet(9,1,true,&[0x65,1])).await.unwrap();
|
||||
loop {if let Some(au)=session.peer.desktop.units.pop(){assert_eq!(au.codec,super::media::Codec::H264);assert_eq!(au.data,vec![0,0,0,1,0x65,1]);break}tokio::time::sleep(Duration::from_millis(10)).await;}
|
||||
track.write_rtp(&packet(10,2,false,&[0x7c,0x85,1])).await.unwrap();
|
||||
track.write_rtp(&packet(12,2,true,&[0x7c,0x45,3])).await.unwrap();
|
||||
loop {let (packets,_)=sender.read_rtcp().await.unwrap();if packets.iter().any(|p|p.as_any().is::<webrtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication>()){break}}
|
||||
assert!(session.peer.desktop.units.pop().is_none());
|
||||
for (action,number) in [(super::power::Action::Reboot,9),(super::power::Action::Shutdown,12)]{
|
||||
super::power::run(&mut session,action).await.unwrap();
|
||||
assert_eq!(input_rx.recv().await.unwrap(),json!({"power":number}));
|
||||
assert!(input_rx.try_recv().is_err());
|
||||
}
|
||||
done_tx.send(()).await.unwrap();server.await.unwrap();session.close().await;
|
||||
assert!(tool_rx.recv().await.is_none());
|
||||
host.close().await.unwrap();router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("offline RTC/session timed out");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn early_candidates_and_foreign_session_messages_are_scoped() {
|
||||
let(settings,_,router)=virtual_network().await;let(tx,_rx)=mpsc::channel(256);
|
||||
let mut peer=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-app","synthetic-ice","synthetic-host",tx,settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
assert!(!peer.matches_route(&json!({"ice_id":"foreign"})));
|
||||
assert!(!peer.matches_route(&json!({"app_control_id":"foreign"})));
|
||||
peer.receive(&json!({"type":"answer","ice_id":"foreign","sdp":"invalid"})).await.unwrap();
|
||||
for _ in 0..256 {peer.receive(&json!({"type":"candidate","candidate":{"candidate":""}})).await.unwrap();}
|
||||
assert!(peer.receive(&json!({"type":"candidate","candidate":{"candidate":""}})).await.is_err());
|
||||
peer.close().await;router.lock().await.stop().await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn closing_one_peer_preserves_another_peer() {
|
||||
let(a,b,router)=virtual_network().await;
|
||||
let(tx1,_rx1)=mpsc::channel(256);let(tx2,_rx2)=mpsc::channel(256);
|
||||
let first=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-first","synthetic-first-ice","synthetic-host",tx1,a,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let second=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-second","synthetic-second-ice","synthetic-host",tx2,b,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
first.close().await;
|
||||
assert_ne!(second.pc.connection_state(),webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed);
|
||||
assert_eq!(second.channels.len(),5);
|
||||
second.close().await;router.lock().await.stop().await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn opus_and_video_tracks_are_received_independently_in_memory() {
|
||||
tokio::time::timeout(Duration::from_secs(10),async {
|
||||
let(viewer_settings,host_settings,router)=virtual_network().await;
|
||||
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
|
||||
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
use webrtc::{track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter},rtp_transceiver::rtp_codec::RTCRtpCodecCapability};
|
||||
let audio=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"audio/opus".into(),clock_rate:48000,channels:2,..Default::default()},"audio".into(),"test".into()));
|
||||
let video=Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability{mime_type:"video/H264".into(),clock_rate:90000,sdp_fmtp_line:"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(),..Default::default()},"video".into(),"test".into()));
|
||||
host.add_track(audio.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();host.add_track(video.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
|
||||
let(tx,_rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
|
||||
let offer=peer.pc.local_description().await.unwrap();assert!(offer.sdp.contains("m=audio") && offer.sdp.contains("opus/48000/2"));
|
||||
host.set_remote_description(offer).await.unwrap();let answer=host.create_answer(None).await.unwrap();
|
||||
let mut gathered=host.gathering_complete_promise().await;host.set_local_description(answer).await.unwrap();gathered.recv().await;
|
||||
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
|
||||
while peer.pc.connection_state()!=webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected {tokio::time::sleep(Duration::from_millis(10)).await;}
|
||||
let mut heard=false;let mut seen=false;
|
||||
for seq in 0..200 {
|
||||
let packet=|payload:&[u8]|webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:u32::from(seq)*960,marker:true,..Default::default()},payload:bytes::Bytes::copy_from_slice(payload)};
|
||||
audio.write_rtp(&packet(&[0xf8,0xff,0xfe])).await.unwrap();video.write_rtp(&packet(&[0x65,1])).await.unwrap();
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
if let Some(data)=peer.audio.pop(){assert_eq!(data,vec![0xf8,0xff,0xfe]);heard=true;}
|
||||
if let Some(data)=peer.desktop.units.pop(){assert_eq!(data.codec,super::media::Codec::H264);assert_eq!(data.data,vec![0,0,0,1,0x65,1]);seen=true;}
|
||||
if heard && seen {break}
|
||||
}
|
||||
assert!(heard && seen);peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("in-memory media timed out");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn desktop_file_window_reattaches_without_replacing_peer(){
|
||||
tokio::time::timeout(Duration::from_secs(10),async{
|
||||
use super::tools::{self,files::Files};
|
||||
let(viewer_settings,host_settings,router)=virtual_network().await;
|
||||
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
|
||||
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
let file:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
|
||||
let(tx,mut received)=mpsc::channel(32);
|
||||
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
|
||||
host.on_data_channel(Box::new(move|channel|{let(tx,file,count)=(tx.clone(),file.clone(),count.clone());Box::pin(async move{
|
||||
count.fetch_add(1,Ordering::Relaxed);
|
||||
if channel.label()==wire::CHANNELS[tools::FILE]{*file.lock().unwrap()=Some(channel.clone());}
|
||||
if channel.label()==wire::CHANNELS[tools::CONTROL]{channel.on_message(Box::new(move|m|{
|
||||
let(tx,file)=(tx.clone(),file.clone());Box::pin(async move{
|
||||
if let Some(r)=tools::blob(&m.data,21){
|
||||
if tools::blob(r,8).and_then(|b|tools::blob(b,10)).is_some(){
|
||||
let id=tools::uint(tools::blob(r,1).unwrap(),1);
|
||||
let reply=tools::rpc(id,true,7,&tools::ints(&[(4,1)]));
|
||||
let file=file.lock().unwrap().clone().unwrap();file.send(&bytes::Bytes::from(reply)).await.unwrap();return
|
||||
}
|
||||
}
|
||||
let _=tx.send(m.data.to_vec()).await;
|
||||
})
|
||||
}));}
|
||||
})}));
|
||||
let(tx,_rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape(),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
|
||||
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
|
||||
let answer=host.create_answer(None).await.unwrap();let mut gathered=host.gathering_complete_promise().await;
|
||||
host.set_local_description(answer).await.unwrap();gathered.recv().await;
|
||||
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
|
||||
while opened.load(Ordering::Relaxed)!=5 || peer.channels.iter().any(|c|c.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open){tokio::time::sleep(Duration::from_millis(10)).await;}
|
||||
let pc=peer.pc.clone();
|
||||
for _ in 0..2{
|
||||
let(io,rx)=tools::attach(&peer).unwrap();assert!(tools::attach(&peer).is_err());
|
||||
let(f,_)=Files::new(io,rx);assert!(f.list_dir(":/").await.unwrap().is_empty());drop(f);
|
||||
peer.tools.lock().unwrap().take();
|
||||
assert!(Arc::ptr_eq(&pc,&peer.pc));
|
||||
let heartbeat=super::input::Input::heartbeat();peer.send_input(&heartbeat).await.unwrap();
|
||||
loop{if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(heartbeat.clone()){break}}
|
||||
}
|
||||
assert_eq!(opened.load(Ordering::Relaxed),5);
|
||||
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("desktop file reuse timed out");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn hevc_track_uses_negotiated_payload_type_in_memory(){
|
||||
tokio::time::timeout(Duration::from_secs(10),async {
|
||||
use super::media::Codec;
|
||||
use webrtc::{track::track_local::{track_local_static_rtp::TrackLocalStaticRTP,TrackLocal,TrackLocalWriter},
|
||||
rtp_transceiver::rtp_codec::{RTCRtpCodecCapability,RTCRtpCodecParameters,RTPCodecType}};
|
||||
let(viewer_settings,host_settings,router)=virtual_network().await;
|
||||
// The host uses a different local PT; the answer binds its track to the viewer offer.
|
||||
let mut engine=MediaEngine::default();
|
||||
let capability=RTCRtpCodecCapability{mime_type:"video/H265".into(),clock_rate:90000,..Default::default()};
|
||||
engine.register_codec(RTCRtpCodecParameters{capability:capability.clone(),payload_type:126,..Default::default()},RTPCodecType::Video).unwrap();
|
||||
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
let video=Arc::new(TrackLocalStaticRTP::new(capability,"video".into(),"test".into()));
|
||||
host.add_track(video.clone() as Arc<dyn TrackLocal+Send+Sync>).await.unwrap();
|
||||
host.on_data_channel(Box::new(|channel|Box::pin(async move {
|
||||
if channel.label()=="CONTROL_DATA_CHANNEL" {
|
||||
let weak=Arc::downgrade(&channel);
|
||||
channel.on_open(Box::new(move||Box::pin(async move {
|
||||
if let Some(channel)=weak.upgrade(){
|
||||
let mut caps=Vec::new();for codec in [1,2]{let mut cap=Vec::new();wire::int(3,codec,&mut cap);wire::bytes(1,&cap,&mut caps);}
|
||||
channel.send(&bytes::Bytes::from(wire::envelope(2,18,&caps))).await.unwrap();
|
||||
// Model a host that declines 4:4:4 and encodes 4:2:0.
|
||||
channel.send(&bytes::Bytes::from(wire::envelope(3,25,&[24,1]))).await.unwrap();
|
||||
}
|
||||
})));
|
||||
}
|
||||
})));
|
||||
let(tx,_rx)=mpsc::channel(256);
|
||||
let peer=Peer::new(RTCConfiguration::default(),&shape().video_preferences(false),"app","ice","host",tx,viewer_settings,super::clipboard::Bridge::new(false)).await.unwrap();
|
||||
let mut gathered=peer.pc.gathering_complete_promise().await;peer.offer().await.unwrap();gathered.recv().await;
|
||||
host.set_remote_description(peer.pc.local_description().await.unwrap()).await.unwrap();
|
||||
let answer=host.create_answer(None).await.unwrap();
|
||||
assert!(answer.sdp.contains("H265/90000"));assert!(!answer.sdp.contains("H264/90000"));
|
||||
let mut gathered=host.gathering_complete_promise().await;host.set_local_description(answer).await.unwrap();gathered.recv().await;
|
||||
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
|
||||
while peer.pc.connection_state()!=webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected {tokio::time::sleep(Duration::from_millis(10)).await;}
|
||||
let mut au=vec![0,0,0,1,64,1,9,0,0,0,1,38,1];au.extend(vec![7;200]);
|
||||
let payloads=crate::hevc::payload(80,&au).unwrap();let mut seq=0;let mut seen=false;
|
||||
for timestamp in 0..100 {
|
||||
for (i,payload) in payloads.iter().enumerate(){
|
||||
video.write_rtp(&webrtc::rtp::packet::Packet{header:webrtc::rtp::header::Header{version:2,sequence_number:seq,timestamp:timestamp*3000,marker:i+1==payloads.len(),..Default::default()},payload:payload.clone()}).await.unwrap();seq=seq.wrapping_add(1);
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
if let Some(unit)=peer.desktop.units.pop(){assert_eq!(unit.codec,Codec::H265);assert_eq!(unit.data,au);seen=true;}
|
||||
if seen && peer.observed.chroma.load(Ordering::Acquire)==1 {break}
|
||||
}
|
||||
assert!(seen);assert_eq!(peer.observed.encoder_codecs.load(Ordering::Acquire),3);
|
||||
assert_eq!(peer.observed.chroma.load(Ordering::Acquire),1);
|
||||
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("in-memory H265 timed out");
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
//! Command-line adapters; terminal output is intentional user output, never a log.
|
||||
use super::*;
|
||||
use std::os::fd::AsRawFd;
|
||||
use tokio::io::AsyncWriteExt;
|
||||
struct Tty {fd:i32,saved:libc::termios}
|
||||
impl Tty {
|
||||
fn raw()->Result<Self,String>{
|
||||
let fd=std::io::stdin().as_raw_fd();let mut saved=unsafe{std::mem::zeroed()};
|
||||
if unsafe{libc::tcgetattr(fd,&mut saved)}!=0{return Err("Terminal command requires a local TTY".into())}
|
||||
let mut raw=saved;unsafe{libc::cfmakeraw(&mut raw)};
|
||||
if unsafe{libc::tcsetattr(fd,libc::TCSANOW,&raw)}!=0{return Err("Cannot set terminal raw mode".into())}Ok(Self{fd,saved})
|
||||
}
|
||||
}
|
||||
impl Drop for Tty {fn drop(&mut self){unsafe{libc::tcsetattr(self.fd,libc::TCSANOW,&self.saved);}}}
|
||||
pub fn size()->(u16,u16){let mut w:libc::winsize=unsafe{std::mem::zeroed()};if unsafe{libc::ioctl(0,libc::TIOCGWINSZ as _,&mut w)}==0{(w.ws_col.max(1),w.ws_row.max(1))}else{(80,24)}}
|
||||
pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,session:Option<u32>)->Result<(),String>{
|
||||
let(t,output)=terminal::Terminal::new(io,rx);t.check_env().await?;
|
||||
let(c,r)=size();let id=match session{Some(id)=>t.attach(id,c,r).await?,None=>t.open(c,r).await?};
|
||||
let result=terminal_loop(&t,output,id).await;let _=t.close(id).await;result
|
||||
}
|
||||
#[async_trait::async_trait]
|
||||
pub trait TerminalInput:Sync {
|
||||
async fn write(&self,id:u32,data:&[u8])->Result<(),String>;
|
||||
async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>;
|
||||
}
|
||||
#[async_trait::async_trait]
|
||||
impl TerminalInput for terminal::Terminal {
|
||||
async fn write(&self,id:u32,data:&[u8])->Result<(),String>{self.write(id,data).await}
|
||||
async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>{self.resize(id,cols,rows).await}
|
||||
}
|
||||
pub async fn terminal_loop(t:&impl TerminalInput,mut output:mpsc::Receiver<terminal::Event>,id:u32)->Result<(),String>{
|
||||
async{
|
||||
let _tty=Tty::raw()?;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let input=std::fs::OpenOptions::new().read(true).custom_flags(libc::O_NONBLOCK).open("/dev/tty").map_err(|_|"Cannot open local TTY")?;
|
||||
let input=tokio::io::unix::AsyncFd::new(input).map_err(|_|"Cannot watch local TTY")?;let mut stdout=tokio::io::stdout();let mut buf=vec![0;16*1024];
|
||||
let mut resize=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::window_change()).map_err(|_|"Cannot watch terminal size")?;
|
||||
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
|
||||
loop{tokio::select!{
|
||||
_=terminate.recv()=>break,
|
||||
n=async {
|
||||
loop {let mut ready=input.readable().await?;
|
||||
match ready.try_io(|fd|std::io::Read::read(&mut fd.get_ref(),&mut buf)){Ok(n)=>break n,Err(_)=>continue}
|
||||
}
|
||||
}=>{let n=n.map_err(|_|"TTY read failed")?;if n==0{break}t.write(id,&buf[..n]).await?;},
|
||||
_=resize.recv()=>{let(c,r)=size();t.resize(id,c,r).await?;},
|
||||
e=output.recv()=>match e{
|
||||
Some(terminal::Event::Output{session,data})if session==id=>{stdout.write_all(&data).await.map_err(|_|"TTY write failed")?;stdout.flush().await.map_err(|_|"TTY flush failed")?;},
|
||||
Some(terminal::Event::Exit{session,code})if session==id=>{if code!=0{return Err(format!("Remote shell exited with code {code}"))}break},
|
||||
Some(terminal::Event::Error{..})|None=>return Err("Terminal session failed".into()),_=>{},
|
||||
}
|
||||
}}Ok(())
|
||||
}.await
|
||||
}
|
||||
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,args:&[String])->Result<(),String>{
|
||||
let(f,mut progress)=files::Files::new(io,rx);
|
||||
let reporter=tokio::spawn(async move{while let Some(p)=progress.recv().await{eprintln!("{} / {} bytes",p.transferred,p.total);}});
|
||||
let operation=async {match args.first().map(String::as_str){
|
||||
Some("ls")if args.len()==2=>match f.list_dir(&args[1]).await{Ok(entries)=>{for e in entries{println!("{}",serde_json::json!({"kind":e.kind,"name":e.name,"size":e.size,"path":e.path}));}Ok(())},Err(e)=>Err(e)},
|
||||
Some("get")if args.len()==3=>f.download(&args[1],&args[2]).await,
|
||||
Some("put")if args.len()==3=>f.upload(&args[1],&args[2]).await,
|
||||
_=>Err("files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE".into()),
|
||||
}};
|
||||
tokio::pin!(operation);
|
||||
let result=tokio::select!{r=&mut operation=>r,_=tokio::signal::ctrl_c()=>{f.cancel();operation.await}};
|
||||
reporter.abort();result
|
||||
}
|
||||
pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,local:u16,host:&str,port:u16)->Result<(),String>{
|
||||
let p=portmap::PortMap::new(io,rx);let id=p.add_rule("CLI",local,host,port).await?;
|
||||
eprintln!("Listening on 127.0.0.1:{}",p.status()[0].local_port);
|
||||
let result=tokio::select!{r=tokio::signal::ctrl_c()=>r.map_err(|_|"Cannot watch interrupt".to_owned()),_=p.closed()=>Err("Forwarding transport closed".into())};
|
||||
p.remove_rule(id).await?;result
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
//! FTP RPC cases and 1-based file indexes follow src/file_trans.rs.
|
||||
use super::*;
|
||||
use std::{collections::{BTreeMap,HashMap},io::Read,path::{Path,PathBuf},sync::atomic::{AtomicBool,AtomicU64,Ordering}};
|
||||
use tokio::{io::{AsyncReadExt,AsyncWriteExt},sync::{Mutex as AsyncMutex,Notify}};
|
||||
#[derive(Debug,Clone)]
|
||||
pub struct Entry {pub kind:u64,pub name:String,pub size:u64,pub modified:u64,pub path:String}
|
||||
#[derive(Clone,Copy,Debug)]
|
||||
pub struct Progress {pub task:u64,pub transferred:u64,pub total:u64}
|
||||
// Keep request/task ids unique when a desktop file window is reopened.
|
||||
static NEXT:AtomicU64=AtomicU64::new(100);
|
||||
pub struct Files {io:Transport,rx:AsyncMutex<mpsc::Receiver<Packet>>,next:&'static AtomicU64,canceled:AtomicBool,poisoned:AtomicBool,wake:Notify,progress:mpsc::Sender<Progress>}
|
||||
fn check(code:u64)->Result<(),String>{if code==1{Ok(())}else{Err(format!("File transfer error code {code}"))}}
|
||||
fn id(task:u64,index:u64)->Vec<u8>{nested(1,&ints(&[(1,task),(2,index)]))}
|
||||
fn all(data:&[u8],n:u32)->Result<Vec<&[u8]>,String>{Ok(decode_wire(data).map_err(|_|"Invalid file protobuf")?.into_iter().filter_map(|f|match(f.number,f.value){(k,WireValue::Bytes(b))if k==n=>Some(b),_=>None}).collect())}
|
||||
pub fn inflate(data:&[u8])->Result<Vec<u8>,String>{
|
||||
let mut out=Vec::new();flate2::read::ZlibDecoder::new(data).take(16*1024*1024+1).read_to_end(&mut out).map_err(|_|"Invalid directory compression")?;
|
||||
if out.len()>16*1024*1024{return Err("Directory expansion limit".into())}Ok(out)
|
||||
}
|
||||
/// Splits a remote target into (directory, file name). Windows hosts list paths with `\\` (C:\\Users\\...),
|
||||
/// Linux hosts with `/`; the directory keeps the host's own separator style. No directory means home.
|
||||
/// Download block limit. Our host sends 32 KiB blocks; the official Windows host sends larger ones
|
||||
/// (a 64 KiB file arrived as one block), bounded by the 256 KiB SCTP message size.
|
||||
const MAX_BLOCK:usize=256*1024;
|
||||
fn split_remote(remote:&str)->Option<(&str,&str)>{
|
||||
let cut=remote.rfind(['/','\\']);
|
||||
let (dir,name)=match cut{Some(i)=>(&remote[..i],&remote[i+1..]),None=>("",remote)};
|
||||
if name.is_empty(){return None}
|
||||
// "/x" keeps the root; "C:\\x" keeps "C:\\" (a bare drive letter is not a directory).
|
||||
let dir=match cut{None=>"~/",Some(i) if dir.is_empty()||dir.ends_with(':')=>&remote[..i+1],_=>dir};
|
||||
Some((dir,name))
|
||||
}
|
||||
fn safe(path:&str)->Result<PathBuf,String>{
|
||||
let normalized=path.replace('\\',"/");let p=Path::new(&normalized);
|
||||
if p.as_os_str().is_empty() || p.components().any(|c|!matches!(c,std::path::Component::Normal(_))) || normalized.contains(':') {return Err("Unsafe remote relative path".into())}Ok(p.to_owned())
|
||||
}
|
||||
struct Stage(PathBuf);
|
||||
impl Drop for Stage {fn drop(&mut self){let _=std::fs::remove_dir_all(&self.0);}}
|
||||
/// Download block ids start at 1 on the official Windows host and at 0 (sent out of order within a
|
||||
/// 16-block window) on ours. `next` stays unset until block 0 arrives, 16 blocks are buffered, or the
|
||||
/// file completes; the lowest buffered id is then the base.
|
||||
struct Download {file:tokio::fs::File,written:u64,next:Option<u64>,blocks:BTreeMap<u64,Vec<u8>>}
|
||||
impl Files {
|
||||
pub fn new(io:Transport,rx:mpsc::Receiver<Packet>)->(Self,mpsc::Receiver<Progress>){let(tx,progress)=mpsc::channel(64);(Self{io,rx:AsyncMutex::new(rx),next:&NEXT,canceled:AtomicBool::new(false),poisoned:AtomicBool::new(false),wake:Notify::new(),progress:tx},progress)}
|
||||
/// Cancels the active operation; subsequent operations can reuse the session.
|
||||
pub fn cancel(&self){self.canceled.store(true,Ordering::Release);self.wake.notify_waiters();}
|
||||
async fn recv(&self,rx:&mut mpsc::Receiver<Packet>)->Result<Vec<u8>,String>{loop{
|
||||
let notified=self.wake.notified();tokio::pin!(notified);notified.as_mut().enable();
|
||||
if self.canceled.load(Ordering::Acquire){return Err("File transfer canceled".into())}
|
||||
let(c,b)=tokio::select!{r=receive(rx)=>r?,_=notified=>return Err("File transfer canceled".into())};if c==FILE{return Ok(b)}
|
||||
}}
|
||||
async fn request(&self,rx:&mut mpsc::Receiver<Packet>,case:u32,body:&[u8],expected:u32)->Result<Vec<u8>,String>{
|
||||
if self.poisoned.load(Ordering::Acquire){return Err("File session requires reconnect after failed cleanup".into())}
|
||||
let rid=self.next.fetch_add(1,Ordering::Relaxed);self.io.send(CONTROL,rpc(rid,false,case,body)).await?;
|
||||
loop{let b=self.recv(rx).await?;
|
||||
// Ids and field numbers only, to match official-host replies.
|
||||
if let Some(r)=blob(&b,22){log::info!("File RPC reply: want_id={rid} got_id={} case_fields={:?}",blob(r,1).map(|h|uint(h,1)).unwrap_or(0),blob(r,4).and_then(|f|crate::protocol::decode_wire(f).ok()).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}
|
||||
else {log::info!("File channel message: fields={:?}",crate::protocol::decode_wire(&b).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default());}
|
||||
if let Some(r)=blob(&b,22){if blob(r,1).is_some_and(|h|uint(h,1)==rid){return blob(r,4).and_then(|f|blob(f,expected)).map(Vec::from).ok_or("Unexpected file response case".into())}}}
|
||||
}
|
||||
pub async fn list_dir(&self,path:&str)->Result<Vec<Entry>,String>{
|
||||
let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
|
||||
let mut body=id(self.next.fetch_add(1,Ordering::Relaxed),0);wire::bytes(2,path.as_bytes(),&mut body);
|
||||
let b=self.request(&mut rx,10,&body,7).await?;check(uint(&b,4))?;
|
||||
let expanded=blob(&b,5).map(inflate).transpose()?;
|
||||
let rows=if let Some(ref d)=expanded {all(d,1)?}else{all(&b,3)?};
|
||||
rows.into_iter().map(|r|Ok(Entry{kind:uint(r,1),name:text(r,2)?,size:uint(r,3),modified:uint(r,4),path:text(r,5)?})).collect()
|
||||
}
|
||||
pub async fn mkdir(&self,path:&str)->Result<(),String>{let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);let b=self.request(&mut rx,6,&nested(1,path.as_bytes()),5).await?;check(uint(&b,1))}
|
||||
fn report(&self,task:u64,transferred:u64,total:u64){let _=self.progress.try_send(Progress{task,transferred,total});}
|
||||
pub async fn upload(&self,local:impl AsRef<Path>,remote:&str)->Result<(),String>{
|
||||
let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
|
||||
let mut file=tokio::fs::File::open(local).await.map_err(|_|"Cannot open upload file")?;
|
||||
let meta=file.metadata().await.map_err(|_|"Cannot stat upload file")?;if !meta.is_file(){return Err("Upload requires a regular file".into())}let size=meta.len();
|
||||
let (parent,name)=split_remote(remote).ok_or("Invalid remote file name")?;safe(name)?;
|
||||
let task=self.next.fetch_add(1,Ordering::Relaxed);
|
||||
// GvPb_FileInfo {1 rel_path, 2 size, 3 modified_time (unix s)}; receive_request {.., 7 task_unique_id}.
|
||||
// The official Windows host rejects (code 2) a request without the modified time / unique id.
|
||||
let modified=meta.modified().ok().and_then(|t|t.duration_since(std::time::UNIX_EPOCH).ok()).map_or(0,|d|d.as_secs());
|
||||
let mut info=nested(1,name.as_bytes());wire::int(2,size,&mut info);wire::int(3,modified,&mut info);
|
||||
let now=std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
|
||||
let unique=format!("{:08x}-{:04x}-4{:03x}-8{:03x}-{:012x}",now.as_secs() as u32,task&0xffff,(now.subsec_nanos()>>20)&0xfff,std::process::id()&0xfff,now.as_nanos()&0xffff_ffff_ffff);
|
||||
let mut body=id(task,0);wire::bytes(2,parent.as_bytes(),&mut body);wire::bytes(3,&info,&mut body);wire::int(4,1,&mut body);
|
||||
// Official viewers with the list-compress feature send FileList{1 files} zlib-compressed in list_data (6);
|
||||
// the official Windows host only registers files from there. Keep the inline copy for older hosts.
|
||||
let mut list=Vec::new();wire::bytes(1,&info,&mut list);
|
||||
let mut z=flate2::write::ZlibEncoder::new(Vec::new(),flate2::Compression::default());
|
||||
std::io::Write::write_all(&mut z,&list).map_err(|_|"Cannot compress file list")?;
|
||||
wire::bytes(6,&z.finish().map_err(|_|"Cannot compress file list")?,&mut body);
|
||||
wire::bytes(7,unique.as_bytes(),&mut body);
|
||||
let result=async {
|
||||
let r=self.request(&mut rx,1,&body,1).await?;check(uint(&r,3))?;
|
||||
let mut ask=id(task,1);wire::int(3,size,&mut ask);let r=self.request(&mut rx,3,&ask,3).await?;check(uint(&r,3))?;
|
||||
if uint(&r,2)!=0 || uint(&r,4)!=0{return Err("Unexpected upload skip/resume".into())}
|
||||
let mut done=0;let mut block=0;let mut buf=vec![0;32*1024];
|
||||
loop{let n=file.read(&mut buf).await.map_err(|_|"Upload read failed")?;if n==0{break}
|
||||
let mut b=id(task,1);wire::int(2,block,&mut b);wire::bytes(3,&buf[..n],&mut b);
|
||||
let r=self.request(&mut rx,4,&b,4).await?;check(uint(&r,3))?;
|
||||
if uint(&r,2)!=block || uint(&r,4)!=n as u64{return Err("Invalid upload block acknowledgement".into())}
|
||||
done+=n as u64;block+=1;self.report(task,done,size);
|
||||
}
|
||||
if done!=size{return Err("Upload size changed".into())}
|
||||
let mut b=id(task,1);wire::int(2,1,&mut b);let r=self.request(&mut rx,9,&b,6).await?;check(uint(&r,2))?;self.report(task,done,size);Ok(())
|
||||
}.await;
|
||||
if result.is_err(){let mut b=id(task,1);wire::int(2,7,&mut b);let _=self.io.send(CONTROL,rpc(self.next.fetch_add(1,Ordering::Relaxed),false,9,&b)).await;}
|
||||
result
|
||||
}
|
||||
pub async fn download(&self,remote:&str,local:impl AsRef<Path>)->Result<(),String>{
|
||||
let local=local.as_ref();let mut rx=self.rx.lock().await;self.canceled.store(false,Ordering::Release);
|
||||
let task=self.next.fetch_add(1,Ordering::Relaxed);let mut b=id(task,0);wire::bytes(2,remote.as_bytes(),&mut b);
|
||||
let mut accepted=false;let mut ended=false;
|
||||
let result=async {
|
||||
let r=self.request(&mut rx,2,&b,2).await?;check(uint(&r,2))?;accepted=true;
|
||||
let expanded=blob(&r,5).map(inflate).transpose()?;
|
||||
let list=if let Some(ref e)=expanded{all(e,1)?}else{all(&r,3)?};
|
||||
let files:Vec<(PathBuf,u64)>=list.iter().map(|f|Ok((safe(&text(f,1)?)?,uint(f,2)))).collect::<Result<_,String>>()?;
|
||||
let folder=!text(&r,4)?.is_empty();if !folder && files.len()!=1{return Err("Invalid single file list".into())}
|
||||
let stage=Stage(local.with_file_name(format!(".uu-download-{}",wire::uuid())));
|
||||
tokio::fs::create_dir(&stage.0).await.map_err(|_|"Cannot create download staging directory")?;
|
||||
let mut open:HashMap<u64,Download>=HashMap::new();let mut completed=std::collections::HashSet::new();let total=files.iter().try_fold(0u64,|sum,x|sum.checked_add(x.1)).ok_or("Download size overflow")?;let mut done=0;
|
||||
loop {
|
||||
let data=self.recv(&mut rx).await?;
|
||||
let Some(rpc_body)=blob(&data,21).filter(|r|blob(r,8).is_some()) else{
|
||||
// Shape only (field numbers, size): what the host sent that is not a file RPC request.
|
||||
log::info!("Download skipped message: bytes={} fields={:?} inner={:?}",data.len(),decode_wire(&data).map(|f|f.iter().map(|x|x.number).collect::<Vec<_>>()).unwrap_or_default(),
|
||||
decode_wire(&data).ok().and_then(|f|f.into_iter().find_map(|x|match x.value{WireValue::Bytes(b) if x.number>2=>decode_wire(b).ok().map(|g|(x.number,g.iter().map(|y|y.number).collect::<Vec<_>>())),_=>None})));
|
||||
continue};
|
||||
let ftp=blob(rpc_body,8).unwrap();
|
||||
let rid=blob(rpc_body,1).map(|h|uint(h,1)).unwrap_or(0);
|
||||
let Some(f)=decode_wire(ftp).ok().and_then(|v|v.into_iter().find(|f|matches!(f.value,WireValue::Bytes(_))))else{return Err("Invalid download request".into())};
|
||||
let WireValue::Bytes(body)=f.value else{unreachable!()};let tid=blob(body,1).unwrap_or_default();if uint(tid,1)!=task{return Err("Unexpected download task".into())}let index=uint(tid,2);
|
||||
let mut reply=id(task,index);let mut code=1;
|
||||
let response=match f.number {
|
||||
3=>{
|
||||
if let Some((path,size))=index.checked_sub(1).and_then(|i|files.get(i as usize)) {
|
||||
if uint(body,3)!=*size || open.contains_key(&index)||completed.contains(&index){code=3}else{
|
||||
let path=stage.0.join(path);if let Some(p)=path.parent(){tokio::fs::create_dir_all(p).await.map_err(|_|"Cannot create download directory")?;}
|
||||
match tokio::fs::OpenOptions::new().write(true).create_new(true).open(&path).await {
|
||||
Ok(file)=>{open.insert(index,Download{file,written:0,next:None,blocks:BTreeMap::new()});},Err(_)=>code=6,
|
||||
}
|
||||
}
|
||||
}else{code=3}wire::int(3,code,&mut reply);3
|
||||
},
|
||||
4=>{
|
||||
let block=uint(body,2);let chunk=blob(body,3).unwrap_or_default();
|
||||
if let Some(d)=open.get_mut(&index){
|
||||
let expected=files[index as usize-1].1;
|
||||
if chunk.len()>MAX_BLOCK || d.next.is_some_and(|n|block<n) || d.blocks.contains_key(&block)||d.blocks.len()>=32 {code=3}else{
|
||||
d.blocks.insert(block,chunk.to_vec());
|
||||
if d.next.is_none() && (block==0 || d.blocks.len()>=16) {d.next=d.blocks.keys().next().copied();}
|
||||
while let Some(chunk)=d.next.and_then(|n|d.blocks.remove(&n)){
|
||||
if d.written+chunk.len() as u64>expected || d.file.write_all(&chunk).await.is_err(){code=6;break}
|
||||
d.written+=chunk.len() as u64;done+=chunk.len() as u64;d.next=d.next.map(|n|n+1);
|
||||
}
|
||||
}
|
||||
}else{code=3}
|
||||
wire::int(2,block,&mut reply);wire::int(3,code,&mut reply);wire::int(4,chunk.len() as u64,&mut reply);self.report(task,done,total);4
|
||||
},
|
||||
9=>{
|
||||
if index==u64::MAX {
|
||||
ended=true;check(uint(body,2))?;
|
||||
if completed.len()!=files.len() || !open.is_empty(){return Err("Incomplete download task".into())}
|
||||
if folder {tokio::fs::rename(&stage.0,local).await.map_err(|_|"Cannot finalize download directory")?;}else{tokio::fs::rename(stage.0.join(&files[0].0),local).await.map_err(|_|"Cannot finalize download file")?;}
|
||||
self.report(task,done,total);return Ok(())
|
||||
}
|
||||
if let Some(mut d)=open.remove(&index){
|
||||
if d.next.is_none(){d.next=d.blocks.keys().next().copied();}
|
||||
while let Some(chunk)=d.next.and_then(|n|d.blocks.remove(&n)){
|
||||
if d.written+chunk.len() as u64>files[index as usize-1].1 || d.file.write_all(&chunk).await.is_err(){break}
|
||||
d.written+=chunk.len() as u64;done+=chunk.len() as u64;d.next=d.next.map(|n|n+1);
|
||||
}
|
||||
if uint(body,2)!=1 || d.written!=files[index as usize-1].1 || !d.blocks.is_empty() || d.file.flush().await.is_err(){code=6}else{completed.insert(index);}
|
||||
}else{code=3}wire::int(2,code,&mut reply);6
|
||||
},_=>return Err("Unexpected download request case".into()),
|
||||
};
|
||||
// Numbers only: request case, file index, expected/declared sizes, our result code.
|
||||
if code!=1 || f.number!=4 {log::info!("Download step: case={} index={} files={} declared={} expected={} status={} code={code}",f.number,index,files.len(),uint(body,3),index.checked_sub(1).and_then(|i|files.get(i as usize)).map_or(0,|x|x.1),uint(body,2));}
|
||||
self.io.send(CONTROL,rpc(rid,true,response,&reply)).await?;
|
||||
if code!=1{return Err(format!("Download rejected with code {code}"))}
|
||||
}
|
||||
}.await;
|
||||
if result.is_err() && !ended && (accepted || self.canceled.load(Ordering::Acquire)) {
|
||||
// Reject outstanding host requests so cancellation releases its transfer window.
|
||||
let cleanup=async {
|
||||
loop {
|
||||
let Some((channel,data))=rx.recv().await else{return};if channel!=FILE{continue}
|
||||
let Some(r)=blob(&data,21)else{continue};let Some(ftp)=blob(r,8)else{continue};
|
||||
let rid=blob(r,1).map(|h|uint(h,1)).unwrap_or(0);
|
||||
for (request,response,error_field) in [(3,3,3),(4,4,3),(9,6,2)] {
|
||||
let Some(body)=blob(ftp,request)else{continue};let tid=blob(body,1).unwrap_or_default();
|
||||
if uint(tid,1)!=task{continue}
|
||||
if request==9 && uint(tid,2)==u64::MAX{return}
|
||||
let mut reply=nested(1,tid);wire::int(error_field,7,&mut reply);
|
||||
if request==4{wire::int(2,uint(body,2),&mut reply);}
|
||||
let _=self.io.send(CONTROL,rpc(rid,true,response,&reply)).await;
|
||||
}
|
||||
}
|
||||
};
|
||||
if tokio::time::timeout(Duration::from_secs(3),cleanup).await.is_err(){self.poisoned.store(true,Ordering::Release);}
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod split_tests{
|
||||
#[test] fn remote_targets_keep_the_host_separator(){
|
||||
assert_eq!(super::split_remote(r"C:\Users\Public\Downloads\a.bin"),Some((r"C:\Users\Public\Downloads","a.bin")));
|
||||
assert_eq!(super::split_remote(r"C:\a.bin"),Some((r"C:\","a.bin")));
|
||||
assert_eq!(super::split_remote("/tmp/a.bin"),Some(("/tmp","a.bin")));
|
||||
assert_eq!(super::split_remote("/a.bin"),Some(("/","a.bin")));
|
||||
assert_eq!(super::split_remote("a.bin"),Some(("~/","a.bin")));
|
||||
assert_eq!(super::split_remote("/tmp/"),None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//! Tool transports use only this peer's ordered channels; payloads are never logged.
|
||||
pub mod terminal;
|
||||
pub mod files;
|
||||
pub mod portmap;
|
||||
pub mod cli;
|
||||
pub mod terminal_ipc;
|
||||
use std::{sync::{Arc,Mutex},time::Duration};
|
||||
use tokio::sync::mpsc;
|
||||
use crate::protocol::{decode_wire,WireValue};
|
||||
use super::wire;
|
||||
pub const CONTROL:usize=0;
|
||||
pub const FILE:usize=3;
|
||||
pub const BINARY:usize=4;
|
||||
pub type Packet=(usize,Vec<u8>);
|
||||
pub type Inbox=Arc<Mutex<Option<mpsc::Sender<Packet>>>>;
|
||||
pub const TIMEOUT:Duration=Duration::from_secs(30);
|
||||
#[async_trait::async_trait]
|
||||
pub trait Send:std::marker::Send+Sync {async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String>;}
|
||||
#[derive(Clone)]
|
||||
pub struct Transport(pub Arc<dyn Send>);
|
||||
impl Transport {
|
||||
pub async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String> {
|
||||
tokio::time::timeout(TIMEOUT,self.0.send(channel,data)).await.map_err(|_|"Tool send timeout")?
|
||||
}
|
||||
}
|
||||
struct Rtc(Vec<Arc<webrtc::data_channel::RTCDataChannel>>);
|
||||
#[async_trait::async_trait]
|
||||
impl Send for Rtc {
|
||||
async fn send(&self,channel:usize,data:Vec<u8>)->Result<(),String> {
|
||||
let dc=self.0.get(channel).ok_or("Unknown tool channel")?;
|
||||
while dc.buffered_amount().await>1024*1024 {tokio::time::sleep(Duration::from_millis(5)).await;}
|
||||
dc.send(&bytes::Bytes::from(data)).await.map_err(|_|"Tool data channel send failed")?;Ok(())
|
||||
}
|
||||
}
|
||||
pub fn attach(peer:&super::rtc::Peer)->Result<(Transport,mpsc::Receiver<Packet>),String> {
|
||||
let(tx,rx)=mpsc::channel(256);
|
||||
let mut slot=peer.tools.lock().unwrap();
|
||||
if slot.is_some(){return Err("Tool transport already attached".into())}
|
||||
*slot=Some(tx);Ok((Transport(Arc::new(Rtc(peer.channels.clone()))),rx))
|
||||
}
|
||||
pub fn uint(data:&[u8],n:u32)->u64 {decode_wire(data).ok().and_then(|f|f.into_iter().find_map(|f|match(f.number,f.value){(k,WireValue::Varint(v))if k==n=>Some(v),_=>None})).unwrap_or(0)}
|
||||
pub fn blob(data:&[u8],n:u32)->Option<&[u8]> {decode_wire(data).ok()?.into_iter().find_map(|f|match(f.number,f.value){(k,WireValue::Bytes(v))if k==n=>Some(v),_=>None})}
|
||||
pub fn text(data:&[u8],n:u32)->Result<String,String> {String::from_utf8(blob(data,n).unwrap_or_default().to_vec()).map_err(|_|"Invalid UTF-8 field".into())}
|
||||
pub fn ints(fields:&[(u32,u64)])->Vec<u8>{let mut b=Vec::new();for &(n,v) in fields{wire::int(n,v,&mut b)}b}
|
||||
pub fn nested(n:u32,b:&[u8])->Vec<u8>{let mut out=Vec::new();wire::bytes(n,b,&mut out);out}
|
||||
pub fn rpc(id:u64,response:bool,case:u32,body:&[u8])->Vec<u8>{
|
||||
let mut b=nested(1,&ints(&[(1,id)]));wire::bytes(if response{4}else{8},&nested(case,body),&mut b);
|
||||
wire::envelope(id,if response{22}else{21},&b)
|
||||
}
|
||||
pub async fn receive(rx:&mut mpsc::Receiver<Packet>)->Result<Packet,String>{tokio::time::timeout(TIMEOUT,rx.recv()).await.map_err(|_|"Tool response timeout")?.ok_or("Tool transport closed".into())}
|
||||
#[cfg(test)]
|
||||
pub mod tests;
|
||||
|
||||
pub struct Abort<T>(pub tokio::task::JoinHandle<T>);
|
||||
impl<T> Drop for Abort<T>{fn drop(&mut self){self.0.abort();}}
|
||||
|
||||
pub struct Cancel(pub tokio::task::AbortHandle);
|
||||
impl Drop for Cancel{fn drop(&mut self){self.0.abort();}}
|
||||
@@ -0,0 +1,90 @@
|
||||
//! Message27/SYN JSON follows src/port_mapping.rs; TCP half-close is unsupported.
|
||||
use super::*;
|
||||
use std::{collections::HashMap,sync::atomic::{AtomicU64,Ordering}};
|
||||
use tokio::{net::{TcpListener,TcpStream},io::{AsyncReadExt,AsyncWriteExt},sync::watch};
|
||||
#[derive(Clone,Debug)]
|
||||
pub struct Status {pub id:u64,pub name:String,pub local_port:u16,pub streams:usize,pub failures:u64}
|
||||
struct Rule {status:Arc<Mutex<Status>>,stop:watch::Sender<bool>,task:tokio::task::JoinHandle<()>}
|
||||
type Routes=Arc<Mutex<HashMap<(u64,u64),mpsc::Sender<(u64,Vec<u8>)>>>>;
|
||||
pub struct PortMap {io:Transport,session:u64,next:Arc<AtomicU64>,routes:Routes,rules:Mutex<HashMap<u64,Rule>>,alive:watch::Receiver<()>,worker:tokio::task::JoinHandle<()>}
|
||||
pub fn frame(session:u64,rule:u64,stream:u64,kind:u64,payload:&[u8])->Vec<u8>{let mut b=ints(&[(1,session),(2,rule),(3,stream),(4,kind)]);wire::bytes(5,payload,&mut b);wire::envelope(0,27,&b)}
|
||||
struct Route {routes:Routes,key:(u64,u64),status:Arc<Mutex<Status>>}
|
||||
impl Drop for Route {fn drop(&mut self){self.routes.lock().unwrap().remove(&self.key);self.status.lock().unwrap().streams-=1;}}
|
||||
impl Drop for PortMap {fn drop(&mut self){self.worker.abort();for(_,r)in self.rules.lock().unwrap().drain(){let _=r.stop.send(true);}self.routes.lock().unwrap().clear();}}
|
||||
impl PortMap {
|
||||
pub fn new(io:Transport,mut rx:mpsc::Receiver<Packet>)->Self{
|
||||
// The official Windows host answers every frame with session_id 1 whatever the viewer sent (observed),
|
||||
// and this project's host echoes it; one port-mapping peer carries one session, so use 1.
|
||||
let session=1u64;let routes:Routes=Arc::new(Mutex::new(HashMap::new()));let route=routes.clone();
|
||||
let(life,alive)=watch::channel(());
|
||||
let worker=tokio::spawn(async move{
|
||||
let _life=life;
|
||||
while let Some((channel,b))=rx.recv().await {
|
||||
if channel!=FILE{continue}let Some(f)=blob(&b,27)else{continue};
|
||||
let key=(uint(f,2),uint(f,3));let sender=route.lock().unwrap().get(&key).cloned();
|
||||
// Diagnostics without payload: wire types per field and whether session/route matched.
|
||||
if uint(f,1)!=session || sender.is_none() {
|
||||
let kinds=crate::protocol::decode_wire(f).map(|x|x.iter().map(|w|(w.number,match w.value{crate::protocol::WireValue::Varint(_)=>"varint",crate::protocol::WireValue::Bytes(_)=>"bytes",_=>"fixed"})).collect::<Vec<_>>()).unwrap_or_default();
|
||||
log::warn!("Port mapping frame unmatched: fields={kinds:?} session_match={} route_match={} type={}",uint(f,1)==session,sender.is_some(),uint(f,4));
|
||||
continue;
|
||||
}
|
||||
if let Some(tx)=sender {if tx.try_send((uint(f,4),blob(f,5).unwrap_or_default().to_vec())).is_err(){route.lock().unwrap().remove(&key);}}
|
||||
}
|
||||
route.lock().unwrap().clear();
|
||||
});
|
||||
Self{io,session,next:Arc::new(AtomicU64::new(1)),routes,rules:Mutex::new(HashMap::new()),alive,worker}
|
||||
}
|
||||
pub async fn closed(&self){let mut alive=self.alive.clone();let _=alive.changed().await;}
|
||||
pub fn status(&self)->Vec<Status>{self.rules.lock().unwrap().values().map(|r|r.status.lock().unwrap().clone()).collect()}
|
||||
pub async fn add_rule(&self,name:impl Into<String>,local_port:u16,target_host:impl Into<String>,target_port:u16)->Result<u64,String>{
|
||||
if self.worker.is_finished(){return Err("Forwarding transport closed".into())}
|
||||
let host=target_host.into();if host.trim().is_empty() || target_port==0 {return Err("Invalid forwarding target".into())}
|
||||
let listener=TcpListener::bind((std::net::Ipv4Addr::LOCALHOST,local_port)).await.map_err(|_|"Cannot bind local forwarding port")?;
|
||||
let port=listener.local_addr().map_err(|_|"Cannot inspect local forwarding port")?.port();
|
||||
let id=self.next.fetch_add(1,Ordering::Relaxed);let status=Arc::new(Mutex::new(Status{id,name:name.into(),local_port:port,streams:0,failures:0}));
|
||||
let(stopper,mut stop)=watch::channel(false);let st=status.clone();let io=self.io.clone();let routes=self.routes.clone();let next=self.next.clone();let session=self.session;
|
||||
let mut disconnected=self.alive.clone();
|
||||
let task=tokio::spawn(async move {
|
||||
let mut streams=tokio::task::JoinSet::new();
|
||||
loop {tokio::select!{
|
||||
_=stop.changed()=>break,
|
||||
_=disconnected.changed()=>break,
|
||||
_=streams.join_next(),if !streams.is_empty()=>{},
|
||||
accepted=listener.accept()=>{
|
||||
let Ok((socket,_))=accepted else{break};
|
||||
if st.lock().unwrap().streams>=128 {continue}
|
||||
let stream=next.fetch_add(1,Ordering::Relaxed);let(tx,rx)=mpsc::channel(64);
|
||||
routes.lock().unwrap().insert((id,stream),tx);st.lock().unwrap().streams+=1;
|
||||
let guard=Route{routes:routes.clone(),key:(id,stream),status:st.clone()};
|
||||
let io=io.clone();let host=host.clone();let mut cancel=stop.clone();let mut transport_closed=disconnected.clone();
|
||||
streams.spawn(async move {
|
||||
let result=tokio::select!{r=forward(&io,session,id,stream,socket,rx,&host,target_port)=>r,_=cancel.changed()=>Ok(()),_=transport_closed.changed()=>Err("Forwarding transport closed".into())};
|
||||
// Reason only (fixed strings), never forwarded bytes or the target address.
|
||||
if let Err(reason)=&result{guard.status.lock().unwrap().failures+=1;log::warn!("Port mapping stream ended: {reason}");}
|
||||
let _=io.send(FILE,frame(session,id,stream,1,&[])).await;drop(guard);
|
||||
});
|
||||
}
|
||||
}}
|
||||
drop(listener);
|
||||
while streams.join_next().await.is_some(){}
|
||||
});
|
||||
self.rules.lock().unwrap().insert(id,Rule{status,stop:stopper,task});Ok(id)
|
||||
}
|
||||
pub async fn remove_rule(&self,id:u64)->Result<(),String>{
|
||||
let rule=self.rules.lock().unwrap().remove(&id).ok_or("Unknown forwarding rule")?;
|
||||
let _=rule.stop.send(true);let mut task=rule.task;
|
||||
if tokio::time::timeout(TIMEOUT+Duration::from_secs(1),&mut task).await.is_err(){task.abort();return Err("Forwarding shutdown timed out".into())}Ok(())
|
||||
}
|
||||
}
|
||||
async fn forward(io:&Transport,session:u64,rule:u64,stream:u64,mut socket:TcpStream,mut rx:mpsc::Receiver<(u64,Vec<u8>)>,host:&str,port:u16)->Result<(),String>{
|
||||
let syn=serde_json::json!({"version":1,"target_host":host,"target_port":port}).to_string();
|
||||
io.send(FILE,frame(session,rule,stream,0,syn.as_bytes())).await?;
|
||||
let ack=tokio::time::timeout(Duration::from_secs(12),rx.recv()).await.map_err(|_|"Forwarding SYN timeout")?.ok_or("Forwarding channel closed")?;
|
||||
if ack.0!=3 {return Err(format!("Forwarding SYN answered with frame type {}",ack.0))}
|
||||
if serde_json::from_slice::<serde_json::Value>(&ack.1).ok().and_then(|v|v["ok"].as_bool())!=Some(true){return Err("Forwarding target rejected".into())}
|
||||
let mut buf=vec![0;16*1024];
|
||||
loop {tokio::select!{
|
||||
r=socket.read(&mut buf)=>{let n=r.map_err(|_|"Forwarding read failed")?;if n==0{break}io.send(FILE,frame(session,rule,stream,2,&buf[..n])).await?;},
|
||||
f=rx.recv()=>match f {Some((2,b))=>if socket.write_all(&b).await.is_err(){break}/* local client hung up: a normal close */,Some((1,_))|None=>break,Some((4,_))=>{},_=>return Err("Unexpected forwarding frame".into())},
|
||||
}}let _=socket.shutdown().await;Ok(())
|
||||
}
|
||||
@@ -0,0 +1,160 @@
|
||||
//! TERM types and JSON shapes follow src/terminal.rs (including bare LIST_RESP arrays).
|
||||
use super::*;
|
||||
use std::{collections::HashMap,sync::atomic::{AtomicU32,AtomicU64,Ordering}};
|
||||
use tokio::sync::oneshot;
|
||||
use serde_json::{json,Value};
|
||||
pub const OPEN:u8=1;pub const STDIN:u8=2;pub const RESIZE:u8=3;pub const CLOSE:u8=4;
|
||||
pub const STDOUT:u8=5;pub const EXIT:u8=6;pub const ERROR:u8=8;
|
||||
pub const LIST_REQ:u8=9;pub const LIST_RESP:u8=10;pub const KILL_REQ:u8=11;pub const KILL_RESP:u8=12;pub const OPEN_RESP:u8=13;
|
||||
pub struct Frame {pub kind:u8,pub session:u32,pub payload:Vec<u8>}
|
||||
pub fn encode(kind:u8,session:u32,payload:&[u8])->Vec<u8>{
|
||||
let mut b=b"TERM\x01".to_vec();b.extend([kind,0,0]);b.extend(session.to_le_bytes());b.extend((payload.len() as u32).to_le_bytes());b.extend(payload);b
|
||||
}
|
||||
#[derive(Default)]
|
||||
pub struct Decoder {buffer:Vec<u8>}
|
||||
impl Decoder {
|
||||
pub fn push(&mut self,data:&[u8])->Result<Vec<Frame>,String>{
|
||||
if self.buffer.len()+data.len()>2*1024*1024 {return Err("Terminal buffer limit".into())}
|
||||
self.buffer.extend(data);let mut out=Vec::new();let mut at=0;
|
||||
while self.buffer.len()-at>=16 {
|
||||
let b=&self.buffer[at..];
|
||||
if &b[..5]!=b"TERM\x01" || !(1..=16).contains(&b[5]) {return Err("Invalid TERM header".into())}
|
||||
let len=u32::from_le_bytes(b[12..16].try_into().unwrap()) as usize;
|
||||
if len>1024*1024{return Err("TERM payload limit".into())}
|
||||
if b.len()<16+len {break}
|
||||
out.push(Frame{kind:b[5],session:u32::from_le_bytes(b[8..12].try_into().unwrap()),payload:b[16..16+len].to_vec()});at+=16+len;
|
||||
}
|
||||
self.buffer.drain(..at);Ok(out)
|
||||
}
|
||||
}
|
||||
#[derive(Clone)]
|
||||
pub enum Event {Output{session:u32,data:Vec<u8>},Exit{session:u32,code:i64},Error{session:u32}}
|
||||
type Pending=Arc<Mutex<HashMap<(u8,u64),oneshot::Sender<Result<Vec<u8>,String>>>>>;
|
||||
struct Request {pending:Pending,key:(u8,u64)}
|
||||
impl Drop for Request {fn drop(&mut self){self.pending.lock().unwrap().remove(&self.key);}}
|
||||
pub struct Terminal {io:Transport,pending:Pending,next:AtomicU32,rpc:AtomicU64,worker:tokio::task::JoinHandle<()>}
|
||||
impl Drop for Terminal {fn drop(&mut self){self.worker.abort();}}
|
||||
impl Terminal {
|
||||
pub fn new(io:Transport,mut rx:mpsc::Receiver<Packet>)->(Self,mpsc::Receiver<Event>){
|
||||
let pending:Pending=Arc::new(Mutex::new(HashMap::new()));let p=pending.clone();let(tx,events)=mpsc::channel(256);
|
||||
let worker=tokio::spawn(async move {
|
||||
let mut decoder=Decoder::default();
|
||||
while let Some((channel,data))=rx.recv().await {
|
||||
if channel==CONTROL {
|
||||
if let Some(r)=blob(&data,22) {if let (Some(h),Some(body))=(blob(r,1),blob(r,24)) {
|
||||
if let Some(t)=p.lock().unwrap().remove(&(24,uint(h,1))) {let _=t.send(Ok(body.to_vec()));}
|
||||
}}continue
|
||||
}
|
||||
if channel!=BINARY {continue}
|
||||
let Ok(frames)=decoder.push(&data) else {break};
|
||||
let mut overflow=false;
|
||||
for f in frames {
|
||||
let event=match f.kind {
|
||||
STDOUT=>Some(Event::Output{session:f.session,data:f.payload.clone()}),
|
||||
EXIT=>Some(Event::Exit{session:f.session,code:serde_json::from_slice::<Value>(&f.payload).ok().and_then(|v|v["exit_code"].as_i64()).unwrap_or(-1)}),
|
||||
ERROR=>Some(Event::Error{session:f.session}),_=>None,
|
||||
};
|
||||
if let Some(event)=event {if tx.try_send(event).is_err(){overflow=true;break}}
|
||||
let key=if f.kind==OPEN_RESP {(OPEN_RESP,0)}else{(f.kind,f.session as u64)};
|
||||
let payload=if f.kind==OPEN_RESP {
|
||||
// Our host puts the new session in the frame header; the official Windows host answers with header 0,
|
||||
// so only a nonzero header overrides the JSON body.
|
||||
serde_json::from_slice::<Value>(&f.payload).ok().filter(Value::is_object).map(|mut v|{if f.session!=0{v["session_id"]=json!(f.session);}v.to_string().into_bytes()}).unwrap_or(f.payload)
|
||||
}else{f.payload};
|
||||
if let Some(t)=p.lock().unwrap().remove(&key){let _=t.send(Ok(payload));}
|
||||
}
|
||||
if overflow {break}
|
||||
}
|
||||
for (_,t) in p.lock().unwrap().drain(){let _=t.send(Err("Terminal channel closed or output overflow".into()));}
|
||||
});
|
||||
(Self{io,pending,next:AtomicU32::new(1),rpc:AtomicU64::new(10),worker},events)
|
||||
}
|
||||
async fn request(&self,key:(u8,u64),channel:usize,data:Vec<u8>)->Result<Vec<u8>,String>{
|
||||
if self.worker.is_finished(){return Err("Terminal channel closed".into())}
|
||||
let(tx,rx)=oneshot::channel();{
|
||||
let mut pending=self.pending.lock().unwrap();
|
||||
if pending.contains_key(&key){return Err("Terminal request already pending".into())}pending.insert(key,tx);
|
||||
}
|
||||
let _request=Request{pending:self.pending.clone(),key};
|
||||
let result=async {self.io.send(channel,data).await?;tokio::time::timeout(TIMEOUT,rx).await.map_err(|_|"Terminal request timeout")?.map_err(|_|"Terminal closed")?}.await;
|
||||
result
|
||||
}
|
||||
pub async fn check_env(&self)->Result<(),String>{
|
||||
let id=self.rpc.fetch_add(1,Ordering::Relaxed);let mut r=nested(1,&ints(&[(1,id)]));wire::bytes(28,&[],&mut r);
|
||||
// The official Windows host's rpc_main.proto has no check_env (requests end at 25): no answer means
|
||||
// "not implemented", not "unavailable"; go on and let OPEN report availability.
|
||||
match tokio::time::timeout(std::time::Duration::from_secs(3),self.request((24,id),CONTROL,wire::envelope(id,21,&r))).await{
|
||||
Err(_)=>Ok(()),
|
||||
Ok(b)=>{let b=b?;if uint(&b,1)!=0 {return Err("Terminal environment unavailable".into())}Ok(())}
|
||||
}
|
||||
}
|
||||
pub async fn list_sessions(&self)->Result<Vec<Value>,String>{
|
||||
let id=self.next.fetch_add(1,Ordering::Relaxed);
|
||||
serde_json::from_slice(&self.request((LIST_RESP,id as u64),BINARY,encode(LIST_REQ,id,&[])).await?).map_err(|_|"Invalid terminal session list".into())
|
||||
}
|
||||
pub async fn open(&self,cols:u16,rows:u16)->Result<u32,String>{
|
||||
self.open_session(0,cols,rows).await
|
||||
}
|
||||
pub async fn attach(&self,id:u32,cols:u16,rows:u16)->Result<u32,String>{
|
||||
if id==0 || !self.list_sessions().await?.iter().any(|s|s["session_id"].as_u64()==Some(id as u64)){return Err("Terminal session no longer exists".into())}
|
||||
self.open_session(id,cols,rows).await
|
||||
}
|
||||
async fn open_session(&self,id:u32,cols:u16,rows:u16)->Result<u32,String>{
|
||||
// Host TerminalConn handles OPEN(nonzero) as reattachment. The official Windows host rejects an OPEN
|
||||
// without "option" ("terminal open: missing 'option' field", kError 1004); "none" is its plain mode.
|
||||
let b=self.request((OPEN_RESP,0),BINARY,encode(OPEN,id,json!({"cols":cols.max(1),"rows":rows.max(1),"option":"none"}).to_string().as_bytes())).await?;
|
||||
let v:Value=serde_json::from_slice(&b).map_err(|_|"Invalid terminal open response")?;
|
||||
if v["code"].as_i64()!=Some(0){return Err("Terminal open rejected".into())}
|
||||
let id=v["session_id"].as_u64().or_else(||v["session_id"].as_str().and_then(|s|s.parse().ok())).and_then(|n|u32::try_from(n).ok()).filter(|n|*n!=0);
|
||||
// The official Windows host answers {"code":0,"message"} with header 0 and keeps one terminal per
|
||||
// connection addressed as session 0 (it then prints "[terminal] resumed existing session").
|
||||
if id.is_none(){log::info!("Terminal open response without a session id: keys={:?}; using session 0",v.as_object().map(|o|o.keys().collect::<Vec<_>>()));}
|
||||
Ok(id.unwrap_or(0))
|
||||
}
|
||||
pub async fn write(&self,id:u32,data:&[u8])->Result<(),String>{for b in data.chunks(16*1024){self.io.send(BINARY,encode(STDIN,id,b)).await?}Ok(())}
|
||||
pub async fn resize(&self,id:u32,cols:u16,rows:u16)->Result<(),String>{self.io.send(BINARY,encode(RESIZE,id,json!({"cols":cols.max(1),"rows":rows.max(1)}).to_string().as_bytes())).await}
|
||||
pub async fn close(&self,id:u32)->Result<(),String>{self.io.send(BINARY,encode(CLOSE,id,&[])).await}
|
||||
pub async fn kill(&self,id:u32)->Result<(),String>{
|
||||
let b=self.request((KILL_RESP,id as u64),BINARY,encode(KILL_REQ,id,&[])).await?;
|
||||
if serde_json::from_slice::<Value>(&b).ok().and_then(|v|v["code"].as_u64())!=Some(0){return Err("Terminal kill rejected".into())}Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// The remote shell needs a real terminal emulator: `$TERMINAL`, else the first installed common one.
|
||||
/// On failure the window stays open so the error is readable.
|
||||
pub fn terminal_command(exe: &std::path::Path, id: &str, session: Option<u32>) -> Option<std::process::Command> {
|
||||
terminal_launcher(exe,"terminal",id,session)
|
||||
}
|
||||
pub fn local_terminal_command(exe:&std::path::Path,path:&std::path::Path,session:Option<u32>)->Option<std::process::Command>{
|
||||
terminal_launcher(exe,"terminal-local",path.to_str()?,session)
|
||||
}
|
||||
fn terminal_launcher(exe:&std::path::Path,mode:&str,id:&str,session:Option<u32>)->Option<std::process::Command>{
|
||||
let script = r#""$0" "$1" "$2" ${3:+"$3"} || { printf '\n终端连接失败,按回车关闭'; read _; }"#;
|
||||
let inner = ["sh", "-c", script, &exe.to_string_lossy(), mode, id].map(str::to_owned);
|
||||
let mut inner = inner.to_vec();
|
||||
if let Some(id) = session { inner.push(id.to_string()); }
|
||||
let found = |name: &str| std::env::var_os("PATH").is_some_and(|p| std::env::split_paths(&p).any(|d| d.join(name).is_file()));
|
||||
let custom = std::env::var("TERMINAL").ok().filter(|t| !t.is_empty() && found(t));
|
||||
let candidates = ["xdg-terminal-exec", "x-terminal-emulator", "kitty", "foot", "alacritty", "wezterm", "ghostty", "gnome-terminal", "konsole", "xfce4-terminal", "xterm"];
|
||||
let program = custom.or_else(|| candidates.iter().find(|c| found(c)).map(|c| c.to_string()))?;
|
||||
let prefix: &[&str] = match program.as_str() {
|
||||
"xdg-terminal-exec" | "kitty" | "foot" => &[],
|
||||
"wezterm" => &["start", "--"],
|
||||
"gnome-terminal" => &["--"],
|
||||
"xfce4-terminal" => &["-x"],
|
||||
_ => &["-e"],
|
||||
};
|
||||
let mut command = std::process::Command::new(program);
|
||||
command.args(prefix).args(inner).stdin(std::process::Stdio::null()).stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null());
|
||||
Some(command)
|
||||
}
|
||||
|
||||
/// Only known metadata is allowed across the GTK boundary; never serialize the full host object.
|
||||
pub fn session_rows(sessions:&[Value])->String{
|
||||
let mut rows:Vec<_>=sessions.iter().filter_map(|s|{
|
||||
let id=u32::try_from(s["session_id"].as_u64()?).ok().filter(|n|*n!=0)?;
|
||||
let shell=s["shell"].as_str().unwrap_or("--").chars().take(256).collect::<String>().replace(['\t','\n','\r','\0']," ");
|
||||
let state=match s["state"].as_str(){Some("running")=>"运行中",Some("detached")=>"已分离",_=>"--"};
|
||||
Some((id,format!("{id}\t{shell}\t{}\t{state}\n",s["created_at_ms"].as_u64().unwrap_or(0))))
|
||||
}).collect();rows.sort_by_key(|r|r.0);rows.into_iter().map(|r|r.1).collect()
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
//! Local TTY clients share the list process's Terminal; no cloud credentials cross IPC.
|
||||
use super::{terminal::{Terminal,Event},cli};
|
||||
use std::{path::{Path,PathBuf},sync::Arc};
|
||||
use tokio::{io::{AsyncRead,AsyncReadExt,AsyncWrite,AsyncWriteExt},net::{UnixListener,UnixStream},sync::{broadcast,mpsc,Mutex},task::JoinSet};
|
||||
use serde::{Serialize,Deserialize};
|
||||
const MAX:usize=4*1024*1024+1024;
|
||||
#[derive(Serialize,Deserialize)]
|
||||
enum Message {Open{session:Option<u32>,cols:u16,rows:u16},Ready(u32),Input(Vec<u8>),Resize(u16,u16),Output(Vec<u8>),Exit(i64),Close,Error}
|
||||
async fn read(r:&mut (impl AsyncRead+Unpin))->Result<Message,String>{
|
||||
let n=r.read_u32().await.map_err(|_|"Local terminal closed")? as usize;
|
||||
if n>MAX{return Err("Local terminal frame limit".into())}
|
||||
let mut b=vec![0;n];r.read_exact(&mut b).await.map_err(|_|"Local terminal closed")?;
|
||||
serde_json::from_slice(&b).map_err(|_|"Invalid local terminal frame".into())
|
||||
}
|
||||
async fn write(w:&mut (impl AsyncWrite+Unpin),m:&Message)->Result<(),String>{
|
||||
let b=serde_json::to_vec(m).map_err(|_|"Invalid local terminal frame")?;
|
||||
if b.len()>MAX{return Err("Local terminal frame limit".into())}
|
||||
w.write_u32(b.len() as u32).await.map_err(|_|"Local terminal closed")?;
|
||||
w.write_all(&b).await.map_err(|_|"Local terminal closed".into())
|
||||
}
|
||||
pub struct Server {dir:PathBuf,pub path:PathBuf,listener:UnixListener}
|
||||
impl Drop for Server {fn drop(&mut self){let _=std::fs::remove_file(&self.path);let _=std::fs::remove_dir(&self.dir);}}
|
||||
impl Server {
|
||||
pub fn new()->Result<Self,String>{
|
||||
use std::os::unix::fs::DirBuilderExt;
|
||||
let dir=std::env::temp_dir().join(format!("uu-tty-{}",super::super::wire::uuid()));
|
||||
std::fs::DirBuilder::new().mode(0o700).create(&dir).map_err(|_|"Cannot create private terminal directory")?;
|
||||
let path=dir.join("tty");
|
||||
match UnixListener::bind(&path){Ok(listener)=>Ok(Self{dir,path,listener}),Err(_)=>{let _=std::fs::remove_dir(dir);Err("Cannot bind local terminal socket".into())}}
|
||||
}
|
||||
pub async fn run(self,t:Arc<Terminal>,events:broadcast::Sender<Event>){
|
||||
let opening=Arc::new(Mutex::new(()));let active=Arc::new(std::sync::Mutex::new(std::collections::HashSet::new()));let mut clients=JoinSet::new();
|
||||
loop{tokio::select!{
|
||||
accepted=self.listener.accept(),if clients.len()<16=>match accepted{
|
||||
Ok((socket,_))=>{let(t,opening,active,output)=(t.clone(),opening.clone(),active.clone(),events.subscribe());clients.spawn(async move{let _=serve(socket,t,opening,active,output).await;});},
|
||||
Err(_)=>break,
|
||||
},
|
||||
_=clients.join_next(),if !clients.is_empty()=>{},
|
||||
}}
|
||||
}
|
||||
}
|
||||
type Sessions=Arc<std::sync::Mutex<std::collections::HashSet<u32>>>;
|
||||
struct Active {id:u32,sessions:Sessions}
|
||||
impl Drop for Active {fn drop(&mut self){self.sessions.lock().unwrap().remove(&self.id);}}
|
||||
async fn serve<S:AsyncRead+AsyncWrite+Unpin+Send+'static>(mut socket:S,t:Arc<Terminal>,opening:Arc<Mutex<()>>,active:Sessions,mut output:broadcast::Receiver<Event>)->Result<(),String>{
|
||||
let first=tokio::time::timeout(super::TIMEOUT,read(&mut socket)).await.map_err(|_|"Local terminal open timeout")??;
|
||||
let Message::Open{session,cols,rows}=first else{return Err("Expected local terminal open".into())};
|
||||
let id={let _guard=opening.lock().await;
|
||||
if session.is_some_and(|id|active.lock().unwrap().contains(&id)){return Err("Terminal session already attached locally".into())}
|
||||
let id=match session{Some(id)=>t.attach(id,cols,rows).await?,None=>t.open(cols,rows).await?};
|
||||
active.lock().unwrap().insert(id);id
|
||||
};
|
||||
let _active=Active{id,sessions:active};
|
||||
let result=async{
|
||||
write(&mut socket,&Message::Ready(id)).await?;
|
||||
let(mut r,mut w)=tokio::io::split(socket);let(tx,mut commands)=mpsc::channel(32);
|
||||
let _reader=super::Abort(tokio::spawn(async move{loop{
|
||||
let message=read(&mut r).await;let failed=message.is_err();
|
||||
if tx.send(message).await.is_err() || failed{break}
|
||||
}}));
|
||||
loop{tokio::select!{
|
||||
m=commands.recv()=>match m.ok_or("Local terminal closed")??{
|
||||
Message::Input(b)=>t.write(id,&b).await?,Message::Resize(c,r)=>t.resize(id,c,r).await?,Message::Close=>break,
|
||||
_=>return Err("Invalid local terminal command".into()),
|
||||
},
|
||||
e=output.recv()=>match e{
|
||||
Ok(Event::Output{session,data})if session==id=>write(&mut w,&Message::Output(data)).await?,
|
||||
Ok(Event::Exit{session,code})if session==id=>{write(&mut w,&Message::Exit(code)).await?;break},
|
||||
Ok(Event::Error{session})if session==id=>{write(&mut w,&Message::Error).await?;break},
|
||||
Err(_)=>return Err("Local terminal output closed or overflowed".into()),_=>{},
|
||||
},
|
||||
}}Ok(())
|
||||
}.await;
|
||||
let _=t.close(id).await;result
|
||||
}
|
||||
struct Input(Mutex<tokio::net::unix::OwnedWriteHalf>);
|
||||
#[async_trait::async_trait]
|
||||
impl cli::TerminalInput for Input {
|
||||
async fn write(&self,_:u32,b:&[u8])->Result<(),String>{write(&mut *self.0.lock().await,&Message::Input(b.to_vec())).await}
|
||||
async fn resize(&self,_:u32,c:u16,r:u16)->Result<(),String>{write(&mut *self.0.lock().await,&Message::Resize(c,r)).await}
|
||||
}
|
||||
pub async fn client(path:&Path,session:Option<u32>)->Result<(),String>{
|
||||
let mut socket=UnixStream::connect(path).await.map_err(|_|"Terminal list is no longer available")?;
|
||||
let(c,r)=cli::size();write(&mut socket,&Message::Open{session,cols:c,rows:r}).await?;
|
||||
let Message::Ready(id)=read(&mut socket).await? else{return Err("Local terminal open failed".into())};
|
||||
let(mut r,w)=socket.into_split();let input=Input(Mutex::new(w));let(tx,rx)=mpsc::channel(256);
|
||||
let worker=tokio::spawn(async move{loop{
|
||||
let event=match read(&mut r).await{Ok(Message::Output(data))=>Event::Output{session:id,data},Ok(Message::Exit(code))=>Event::Exit{session:id,code},_=>break};
|
||||
if tx.send(event).await.is_err(){break}
|
||||
}});
|
||||
let result=cli::terminal_loop(&input,rx,id).await;
|
||||
worker.abort();let _=worker.await;let _=write(&mut *input.0.lock().await,&Message::Close).await;result
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
struct Mock(mpsc::Sender<super::super::Packet>);
|
||||
#[async_trait::async_trait]
|
||||
impl super::super::Send for Mock {
|
||||
async fn send(&self,c:usize,b:Vec<u8>)->Result<(),String>{self.0.send((c,b)).await.map_err(|_|"Mock closed".into())}
|
||||
}
|
||||
#[tokio::test] async fn two_local_ttys_share_one_terminal_and_close_independently(){
|
||||
tokio::time::timeout(std::time::Duration::from_secs(3),async{
|
||||
use super::super::{terminal as term,BINARY};
|
||||
let(tx,mut requests)=mpsc::channel(256);let(input,rx)=mpsc::channel(256);
|
||||
let(t,mut events)=Terminal::new(super::super::Transport(Arc::new(Mock(tx))),rx);let t=Arc::new(t);
|
||||
let(output,_)=broadcast::channel(256);let sender=output.clone();
|
||||
let _relay=super::super::Abort(tokio::spawn(async move{while let Some(e)=events.recv().await{let _=sender.send(e);}}));
|
||||
let(closed,mut closes)=mpsc::channel(8);
|
||||
let _host=super::super::Abort(tokio::spawn(async move{
|
||||
let mut next=40;
|
||||
while let Some((channel,b))=requests.recv().await{
|
||||
assert_eq!(channel,BINARY);let f=term::Decoder::default().push(&b).unwrap().remove(0);
|
||||
let reply=match f.kind{
|
||||
term::OPEN=>{next+=1;term::encode(term::OPEN_RESP,next,br#"{"code":0}"#)},
|
||||
term::STDIN=>term::encode(term::STDOUT,f.session,&f.payload),
|
||||
term::CLOSE=>{closed.send(f.session).await.unwrap();continue},_=>panic!("Unexpected remote request"),
|
||||
};input.send((BINARY,reply)).await.unwrap();
|
||||
}
|
||||
}));
|
||||
let opening=Arc::new(Mutex::new(()));let active:Sessions=Default::default();let mut clients=Vec::new();let mut tasks=Vec::new();
|
||||
for _ in 0..2{
|
||||
let(mut client,server)=tokio::io::duplex(4096);
|
||||
let(t,opening,active,events)=(t.clone(),opening.clone(),active.clone(),output.subscribe());
|
||||
tasks.push(tokio::spawn(serve(server,t,opening,active,events)));
|
||||
write(&mut client,&Message::Open{session:None,cols:80,rows:24}).await.unwrap();
|
||||
let Message::Ready(id)=read(&mut client).await.unwrap()else{panic!()};clients.push((client,id));
|
||||
}
|
||||
let(mut first,id)=clients.remove(0);write(&mut first,&Message::Close).await.unwrap();
|
||||
assert_eq!(closes.recv().await.unwrap(),id);tasks.remove(0).await.unwrap().unwrap();
|
||||
let(mut second,id)=clients.remove(0);
|
||||
// Split an incoming frame while remote output is ready: the reader must retain framing.
|
||||
let b=serde_json::to_vec(&Message::Input(vec![0,255,27])).unwrap();second.write_u32(b.len() as u32).await.unwrap();second.write_all(&b[..2]).await.unwrap();
|
||||
assert!(output.send(Event::Output{session:id,data:b"synthetic".to_vec()}).is_ok());
|
||||
assert!(matches!(read(&mut second).await,Ok(Message::Output(b))if b==b"synthetic"));
|
||||
second.write_all(&b[2..]).await.unwrap();
|
||||
assert!(matches!(read(&mut second).await,Ok(Message::Output(b))if b==[0,255,27]));
|
||||
drop(second);assert_eq!(closes.recv().await.unwrap(),id);tasks.remove(0).await.unwrap().unwrap_err();
|
||||
assert!(active.lock().unwrap().is_empty());
|
||||
}).await.unwrap();
|
||||
}
|
||||
#[tokio::test] async fn framing_rejects_oversize_before_payload(){
|
||||
let(mut a,mut b)=tokio::io::duplex(64);a.write_u32(MAX as u32+1).await.unwrap();
|
||||
assert!(read(&mut b).await.err().unwrap().contains("limit"));
|
||||
}
|
||||
#[tokio::test] async fn framing_roundtrips_binary_and_detects_truncation(){
|
||||
let(mut a,mut b)=tokio::io::duplex(256);
|
||||
write(&mut a,&Message::Input(vec![0,255,27])).await.unwrap();
|
||||
assert!(matches!(read(&mut b).await,Ok(Message::Input(v))if v==[0,255,27]));
|
||||
a.write_u32(30).await.unwrap();drop(a);assert!(read(&mut b).await.is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
use super::*;
|
||||
use tokio::io::{AsyncReadExt,AsyncWriteExt};
|
||||
struct Mock(mpsc::Sender<Packet>);
|
||||
#[async_trait::async_trait]
|
||||
impl Send for Mock {async fn send(&self,c:usize,b:Vec<u8>)->Result<(),String>{self.0.send((c,b)).await.map_err(|_|"Mock closed".into())}}
|
||||
fn pair()->(Transport,mpsc::Receiver<Packet>,mpsc::Sender<Packet>,mpsc::Receiver<Packet>){let(tx,out)=mpsc::channel(256);let(input,rx)=mpsc::channel(256);(Transport(Arc::new(Mock(tx))),rx,input,out)}
|
||||
struct Temp(std::path::PathBuf);
|
||||
impl Temp {fn new()->Self{let p=std::env::temp_dir().join(format!("uu-tools-test-{}",wire::uuid()));std::fs::create_dir(&p).unwrap();Self(p)}}
|
||||
impl Drop for Temp {fn drop(&mut self){let _=std::fs::remove_dir_all(&self.0);}}
|
||||
fn host_files()->(files::Files,mpsc::Receiver<files::Progress>,tokio::task::JoinHandle<()>,tokio::task::JoinHandle<()>){
|
||||
let(io,rx,input,mut out)=pair();let(tx,mut host)=mpsc::unbounded_channel();
|
||||
let session=crate::file_trans::FileSession::new(tx,Arc::new(std::sync::atomic::AtomicU64::new(1)));
|
||||
let server=tokio::spawn(async move{while let Some((c,b))=out.recv().await{assert_eq!(c,CONTROL);assert!(session.handle(&decode_wire(&b).unwrap()));}});
|
||||
let pump=tokio::spawn(async move{while let Some(b)=host.recv().await{if input.send((FILE,b)).await.is_err(){break}}});
|
||||
let(f,p)=files::Files::new(io,rx);(f,p,server,pump)
|
||||
}
|
||||
#[test]
|
||||
fn terminal_frames_match_host_and_incremental_decoder(){
|
||||
let a=terminal::encode(terminal::OPEN,7,br#"{"cols":80,"rows":24}"#);
|
||||
assert_eq!(a,crate::terminal::encode(crate::terminal::OPEN,7,br#"{"cols":80,"rows":24}"#));
|
||||
let mut d=terminal::Decoder::default();let b=[a.clone(),terminal::encode(terminal::STDOUT,7,b"synthetic")].concat();let mut frames=Vec::new();
|
||||
for part in b.chunks(3){frames.extend(d.push(part).unwrap());}assert_eq!(frames.len(),2);assert_eq!(frames[1].payload,b"synthetic");
|
||||
assert!(terminal::Decoder::default().push(b"TERM\x02\x01\0\0\0\0\0\0\0\0\0\0").is_err());
|
||||
let mut bad=a;bad[12..16].copy_from_slice(&u32::MAX.to_le_bytes());assert!(terminal::Decoder::default().push(&bad).is_err());
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn terminal_rpc_list_open_io_and_errors(){
|
||||
let(io,rx,input,mut out)=pair();let(t,mut events)=terminal::Terminal::new(io,rx);
|
||||
let server=tokio::spawn(async move{
|
||||
let(tx,mut replies)=mpsc::unbounded_channel();let host=crate::terminal::TerminalConn::new(tx);
|
||||
while let Some((c,b))=out.recv().await{
|
||||
if c==CONTROL{let r=crate::terminal::rpc_response(&decode_wire(blob(&b,21).unwrap()).unwrap()).unwrap();input.send((CONTROL,wire::envelope(1,22,&r))).await.unwrap();continue}
|
||||
assert_eq!(c,BINARY);let f=crate::terminal::decode(&b).unwrap();
|
||||
match f.kind{
|
||||
terminal::LIST_REQ=>{host.handle(&b);input.send((BINARY,replies.recv().await.unwrap())).await.unwrap();},
|
||||
terminal::OPEN=>{let v:serde_json::Value=serde_json::from_slice(&f.payload).unwrap();assert_eq!(v["cols"],91);input.send((BINARY,terminal::encode(terminal::OPEN_RESP,37,br#"{"code":0}"#))).await.unwrap();},
|
||||
terminal::STDIN=>input.send((BINARY,terminal::encode(terminal::STDOUT,f.session,&f.payload))).await.unwrap(),
|
||||
terminal::RESIZE=>assert_eq!(serde_json::from_slice::<serde_json::Value>(&f.payload).unwrap()["rows"],40),
|
||||
terminal::KILL_REQ=>input.send((BINARY,terminal::encode(terminal::KILL_RESP,f.session,br#"{"code":1}"#))).await.unwrap(),
|
||||
terminal::CLOSE=>break,_=>panic!(),
|
||||
}
|
||||
}
|
||||
});
|
||||
t.check_env().await.unwrap();let _sessions=t.list_sessions().await.unwrap();let id=t.open(91,30).await.unwrap();
|
||||
let data=vec![42;50_000];t.write(id,&data).await.unwrap();let mut received=Vec::new();
|
||||
while received.len()<data.len(){match tokio::time::timeout(TIMEOUT,events.recv()).await.unwrap().unwrap(){terminal::Event::Output{data,..}=>{assert!(data.len()<=16*1024);received.extend(data)},_=>panic!()}}
|
||||
assert_eq!(received,data);t.resize(id,100,40).await.unwrap();assert!(t.kill(id).await.is_err());t.close(id).await.unwrap();server.await.unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn file_host_roundtrip_multiblock_empty_mkdir_and_errors(){
|
||||
let tmp=Temp::new();let(f,mut progress,server,pump)=host_files();
|
||||
let remote=tmp.0.join("remote");f.mkdir(remote.to_str().unwrap()).await.unwrap();
|
||||
let source=tmp.0.join("source");let data:Vec<u8>=(0..130_111).map(|i|(i%251)as u8).collect();std::fs::write(&source,&data).unwrap();
|
||||
let dest=remote.join("uploaded");f.upload(&source,dest.to_str().unwrap()).await.unwrap();assert_eq!(std::fs::read(&dest).unwrap(),data);
|
||||
let entries=f.list_dir(remote.to_str().unwrap()).await.unwrap();assert_eq!(entries.len(),1);assert_eq!(entries[0].size,data.len()as u64);
|
||||
let downloaded=tmp.0.join("downloaded");f.download(dest.to_str().unwrap(),&downloaded).await.unwrap();assert_eq!(std::fs::read(downloaded).unwrap(),data);
|
||||
let empty=tmp.0.join("empty");std::fs::write(&empty,[]).unwrap();f.upload(&empty,remote.join("empty").to_str().unwrap()).await.unwrap();
|
||||
let copy=tmp.0.join("empty-copy");f.download(empty.to_str().unwrap(),©).await.unwrap();assert_eq!(std::fs::metadata(copy).unwrap().len(),0);
|
||||
let folder_copy=tmp.0.join("folder-copy");f.download(remote.to_str().unwrap(),&folder_copy).await.unwrap();assert_eq!(std::fs::read(folder_copy.join("uploaded")).unwrap(),data);
|
||||
assert!(f.list_dir(tmp.0.join("missing").to_str().unwrap()).await.unwrap_err().contains("9"));
|
||||
assert!(f.download(tmp.0.join("missing").to_str().unwrap(),tmp.0.join("absent")).await.unwrap_err().contains("9"));
|
||||
assert!(progress.try_recv().is_ok());server.abort();pump.abort();
|
||||
}
|
||||
#[test]
|
||||
fn directory_expansion_and_invalid_compression(){
|
||||
use std::io::Write;let mut z=flate2::write::ZlibEncoder::new(Vec::new(),flate2::Compression::fast());z.write_all(&nested(1,b"synthetic")).unwrap();let data=z.finish().unwrap();assert_eq!(files::inflate(&data).unwrap(),nested(1,b"synthetic"));assert!(files::inflate(b"invalid").is_err());
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn files_cancel_wakes_pending_request(){
|
||||
let(io,rx,_input,mut out)=pair();let(f,_)=files::Files::new(io,rx);
|
||||
let op=f.list_dir("synthetic");tokio::pin!(op);
|
||||
tokio::select!{r=&mut op=>panic!("unexpected {r:?}"),_=out.recv()=>{}};
|
||||
f.cancel();assert!(tokio::time::timeout(Duration::from_secs(1),op).await.unwrap().unwrap_err().contains("canceled"));
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn forwarding_mock_loopback_echo_fragmentation_remove_and_reject(){
|
||||
let target=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();let port=target.local_addr().unwrap().port();
|
||||
let echo=tokio::spawn(async move{let(mut s,_)=target.accept().await.unwrap();let mut b=vec![0;4096];loop{let n=s.read(&mut b).await.unwrap();if n==0{break}s.write_all(&b[..n]).await.unwrap();}});
|
||||
let(io,rx,input,mut out)=pair();let p=portmap::PortMap::new(io,rx);
|
||||
let host=tokio::spawn(async move{
|
||||
let mut tcp:Option<tokio::net::TcpStream>=None;
|
||||
while let Some((c,b))=out.recv().await{
|
||||
assert_eq!(c,FILE);let f=blob(&b,27).unwrap();let(s,r,t)=(uint(f,1),uint(f,2),uint(f,3));
|
||||
match uint(f,4){
|
||||
0=>{let v:serde_json::Value=serde_json::from_slice(blob(f,5).unwrap()).unwrap();assert_eq!(v["version"],1);let target=v["target_port"].as_u64().unwrap()as u16;
|
||||
let connected=if target==port {tokio::net::TcpStream::connect(("127.0.0.1",target)).await.ok()}else{None};let ok=connected.is_some();tcp=connected;
|
||||
input.send((FILE,portmap::frame(s,r,t,3,if ok{br#"{"version":1,"ok":true}"#}else{br#"{"version":1,"ok":false}"#}))).await.unwrap();},
|
||||
2=>{let payload=blob(f,5).unwrap();assert!(payload.len()<=16*1024);let socket=tcp.as_mut().unwrap();socket.write_all(payload).await.unwrap();let mut b=vec![0;payload.len()];socket.read_exact(&mut b).await.unwrap();input.send((FILE,portmap::frame(s,r,t,2,&b))).await.unwrap();},
|
||||
1=>{tcp.take();},_=>panic!(),
|
||||
}
|
||||
}
|
||||
});
|
||||
let id=p.add_rule("echo",0,"127.0.0.1",port).await.unwrap();let local=p.status()[0].local_port;
|
||||
let mut socket=tokio::net::TcpStream::connect(("127.0.0.1",local)).await.unwrap();let bytes=vec![91;100_000];socket.write_all(&bytes).await.unwrap();let mut received=vec![0;bytes.len()];tokio::time::timeout(TIMEOUT,socket.read_exact(&mut received)).await.unwrap().unwrap();assert_eq!(received,bytes);
|
||||
p.remove_rule(id).await.unwrap();assert!(p.status().is_empty());assert!(tokio::net::TcpStream::connect(("127.0.0.1",local)).await.is_err());
|
||||
let id=p.add_rule("reject",0,"127.0.0.1",1).await.unwrap();let mut socket=tokio::net::TcpStream::connect(("127.0.0.1",p.status()[0].local_port)).await.unwrap();assert_eq!(tokio::time::timeout(TIMEOUT,socket.read(&mut [0])).await.unwrap().unwrap(),0);
|
||||
assert_eq!(p.status()[0].failures,1);p.remove_rule(id).await.unwrap();host.abort();echo.await.unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn file_download_reorders_blocks_and_rejects_traversal(){
|
||||
for (unsafe_name,one_based) in [(false,true),(false,false),(true,false)]{
|
||||
let tmp=Temp::new();let(io,rx,input,mut out)=pair();let(f,_)=files::Files::new(io,rx);
|
||||
let host=tokio::spawn(async move{
|
||||
let(_,b)=out.recv().await.unwrap();let r=blob(&b,21).unwrap();let rid=uint(blob(r,1).unwrap(),1);let req=blob(blob(r,8).unwrap(),2).unwrap();let task=uint(blob(req,1).unwrap(),1);
|
||||
let mut info=nested(1,if unsafe_name{b"../escape"}else{b"file"});wire::int(2,6,&mut info);
|
||||
let mut response=nested(1,&ints(&[(1,task)]));wire::int(2,1,&mut response);wire::bytes(3,&info,&mut response);
|
||||
input.send((FILE,rpc(rid,true,2,&response))).await.unwrap();
|
||||
if unsafe_name{
|
||||
// Let the client reject an ask, then close the host task normally.
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,6,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();
|
||||
let(_,reply)=out.recv().await.unwrap();assert_eq!(uint(blob(blob(blob(&reply,22).unwrap(),4).unwrap(),3).unwrap(),3),7);
|
||||
}else{
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,6,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();out.recv().await.unwrap();
|
||||
// Official Windows host numbering starts at 1 (base fixed at completion); our host sends 0-based out of order.
|
||||
let blocks:&[(u64,&[u8;2])]=if one_based {&[(1,b"ab"),(3,b"ef"),(2,b"cd")]} else {&[(2,b"ef"),(0,b"ab"),(1,b"cd")]};
|
||||
for &(block,data) in blocks {let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,block,&mut b);wire::bytes(3,data,&mut b);input.send((FILE,rpc(901+block,false,4,&b))).await.unwrap();out.recv().await.unwrap();}
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,1,&mut b);input.send((FILE,rpc(903,false,9,&b))).await.unwrap();out.recv().await.unwrap();
|
||||
}
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,u64::MAX)]));wire::int(2,1,&mut b);input.send((FILE,rpc(904,false,9,&b))).await.unwrap();
|
||||
});
|
||||
let target=tmp.0.join("received");let result=f.download("synthetic",&target).await;
|
||||
if unsafe_name{assert!(result.unwrap_err().contains("Unsafe"));assert!(!tmp.0.join("escape").exists());assert!(!target.exists());}else{result.unwrap();assert_eq!(std::fs::read(target).unwrap(),b"abcdef");}
|
||||
host.await.unwrap();
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn cancel_download_rejects_host_and_removes_staging(){
|
||||
let tmp=Temp::new();let(io,rx,input,mut out)=pair();let(f,_)=files::Files::new(io,rx);let(asked,ready)=tokio::sync::oneshot::channel();
|
||||
let host=tokio::spawn(async move{
|
||||
let(_,b)=out.recv().await.unwrap();let r=blob(&b,21).unwrap();let rid=uint(blob(r,1).unwrap(),1);let req=blob(blob(r,8).unwrap(),2).unwrap();let task=uint(blob(req,1).unwrap(),1);
|
||||
let mut info=nested(1,b"file");wire::int(2,10,&mut info);let mut b=nested(1,&ints(&[(1,task)]));wire::int(2,1,&mut b);wire::bytes(3,&info,&mut b);
|
||||
input.send((FILE,rpc(rid,true,2,&b))).await.unwrap();let _=asked.send(());
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(3,10,&mut b);input.send((FILE,rpc(900,false,3,&b))).await.unwrap();
|
||||
let(_,reply)=out.recv().await.unwrap();let code=uint(blob(blob(blob(&reply,22).unwrap(),4).unwrap(),3).unwrap(),3);
|
||||
if code==1{
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,1)]));wire::int(2,0,&mut b);wire::bytes(3,b"synthetic!",&mut b);input.send((FILE,rpc(901,false,4,&b))).await.unwrap();let(_,r)=out.recv().await.unwrap();assert_eq!(uint(blob(blob(blob(&r,22).unwrap(),4).unwrap(),4).unwrap(),3),7);
|
||||
}else{assert_eq!(code,7);}
|
||||
let mut b=nested(1,&ints(&[(1,task),(2,u64::MAX)]));wire::int(2,7,&mut b);input.send((FILE,rpc(902,false,9,&b))).await.unwrap();
|
||||
});
|
||||
let target=tmp.0.join("received");let op=f.download("synthetic",&target);tokio::pin!(op);
|
||||
tokio::select!{r=&mut op=>panic!("unexpected {r:?}"),_=ready=>{}}f.cancel();
|
||||
assert!(tokio::time::timeout(Duration::from_secs(4),op).await.unwrap().unwrap_err().contains("canceled"));host.await.unwrap();assert!(!target.exists());assert_eq!(std::fs::read_dir(&tmp.0).unwrap().count(),0);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn forwarding_transport_close_stops_listener(){
|
||||
let(io,rx,input,_out)=pair();let p=portmap::PortMap::new(io,rx);let id=p.add_rule("closed",0,"127.0.0.1",1).await.unwrap();let port=p.status()[0].local_port;
|
||||
drop(input);tokio::time::timeout(Duration::from_secs(1),p.closed()).await.unwrap();
|
||||
p.remove_rule(id).await.unwrap();assert!(tokio::net::TcpStream::connect(("127.0.0.1",port)).await.is_err());
|
||||
assert!(p.add_rule("unavailable",0,"127.0.0.1",1).await.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn terminal_metadata_is_allowlisted_and_sorted(){
|
||||
let rows=terminal::session_rows(&[
|
||||
serde_json::json!({"session_id":9,"shell":"/bin/sh\tX\nY\0","state":"detached","created_at_ms":123,"output":"PRIVATE","name":"PRIVATE"}),
|
||||
serde_json::json!({"session_id":2,"shell":"/bin/bash","state":"running"}),
|
||||
serde_json::json!({"session_id":0}),serde_json::json!({"session_id":4294967296u64}),
|
||||
]);
|
||||
assert_eq!(rows,"2\t/bin/bash\t0\t运行中\n9\t/bin/sh X Y \t123\t已分离\n");
|
||||
assert!(!rows.contains("PRIVATE"));assert!(terminal::session_rows(&[]).is_empty());
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn terminal_attach_uses_existing_id_and_rejects_absent_session(){
|
||||
let(io,rx,input,mut out)=pair();let(t,_events)=terminal::Terminal::new(io,rx);
|
||||
let host=tokio::spawn(async move{
|
||||
for id in [37,99]{
|
||||
let(c,b)=out.recv().await.unwrap();assert_eq!(c,BINARY);
|
||||
let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::LIST_REQ);
|
||||
input.send((BINARY,terminal::encode(terminal::LIST_RESP,f.session,br#"[{"session_id":37}]"#))).await.unwrap();
|
||||
if id==37{
|
||||
let(_,b)=out.recv().await.unwrap();let f=crate::terminal::decode(&b).unwrap();
|
||||
assert_eq!(f.kind,terminal::OPEN);assert_eq!(f.session,37);
|
||||
let v:serde_json::Value=serde_json::from_slice(&f.payload).unwrap();assert_eq!(v["cols"],90);assert_eq!(v["rows"],30);
|
||||
input.send((BINARY,terminal::encode(terminal::OPEN_RESP,37,br#"{"code":0}"#))).await.unwrap();
|
||||
}
|
||||
}
|
||||
assert!(out.try_recv().is_err());
|
||||
});
|
||||
assert_eq!(t.attach(37,90,30).await.unwrap(),37);
|
||||
assert!(t.attach(99,90,30).await.is_err());assert!(t.attach(0,90,30).await.is_err());host.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn terminal_kill_acknowledgement_and_empty_refresh(){
|
||||
let(io,rx,input,mut out)=pair();let(t,_events)=terminal::Terminal::new(io,rx);
|
||||
let host=tokio::spawn(async move{
|
||||
let(c,b)=out.recv().await.unwrap();assert_eq!(c,BINARY);
|
||||
let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::KILL_REQ);assert_eq!(f.session,42);
|
||||
input.send((BINARY,terminal::encode(terminal::KILL_RESP,42,br#"{"code":0}"#))).await.unwrap();
|
||||
let(_,b)=out.recv().await.unwrap();let f=crate::terminal::decode(&b).unwrap();assert_eq!(f.kind,terminal::LIST_REQ);
|
||||
input.send((BINARY,terminal::encode(terminal::LIST_RESP,f.session,b"[]"))).await.unwrap();
|
||||
});
|
||||
t.kill(42).await.unwrap();assert!(t.list_sessions().await.unwrap().is_empty());host.await.unwrap();
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
//! GTK windows for file transfer, port mapping and terminal sessions. Paths, names and
|
||||
//! ports are shown only in the local window; logs keep to the existing id/field diagnostics.
|
||||
use super::tools::{files::{Entry,Files},portmap::PortMap,Packet,Transport};
|
||||
use std::ffi::{CStr,CString};
|
||||
use std::os::raw::{c_char,c_int,c_ulonglong};
|
||||
use std::sync::{Arc,Mutex,atomic::{AtomicU64,AtomicBool,Ordering}};
|
||||
use std::time::{Duration,Instant};
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
extern "C" {
|
||||
fn uu_tools_ui_start(kind:*const c_char,name:*const c_char)->c_int;
|
||||
fn uu_tools_ui_take(out:*mut c_char,len:usize)->c_int;
|
||||
fn uu_tools_ui_closed()->c_int;
|
||||
fn uu_tools_ui_hide();
|
||||
fn uu_tools_ui_present();
|
||||
fn uu_tools_ui_toast(text:*const c_char);
|
||||
fn uu_files_ui_set_remote(path:*const c_char,rows:*const c_char);
|
||||
fn uu_files_ui_task(id:c_int,name:*const c_char,status:*const c_char,transferred:c_ulonglong,total:c_ulonglong,from:*const c_char,to:*const c_char,done:c_int);
|
||||
fn uu_files_ui_refresh_local();
|
||||
fn uu_terminal_ui_set(rows:*const c_char,connected:c_int);
|
||||
fn uu_portmap_ui_set_rules(rows:*const c_char);
|
||||
}
|
||||
fn c(text:&str)->CString{CString::new(text.replace('\0',"")).unwrap_or_default()}
|
||||
fn toast(text:&str){let t=c(text);unsafe{uu_tools_ui_toast(t.as_ptr())}}
|
||||
fn take()->Option<String>{
|
||||
let mut buf=vec![0 as c_char;4096];
|
||||
(unsafe{uu_tools_ui_take(buf.as_mut_ptr(),buf.len())}!=0).then(||unsafe{CStr::from_ptr(buf.as_ptr())}.to_string_lossy().into_owned())
|
||||
}
|
||||
pub fn hide(){unsafe{uu_tools_ui_hide()}}
|
||||
pub fn present(){unsafe{uu_tools_ui_present()}}
|
||||
pub fn closed()->bool{(unsafe{uu_tools_ui_closed()})!=0}
|
||||
fn start(kind:&str,name:&str)->Result<(),String>{
|
||||
let(k,n)=(c(kind),c(name));
|
||||
if unsafe{uu_tools_ui_start(k.as_ptr(),n.as_ptr())}!=0{return Err("Cannot open the window (GTK3 and a graphical session are required)".into())}Ok(())
|
||||
}
|
||||
/// Last path component for either separator; hosts may be Windows (`C:\x`) or Unix.
|
||||
pub fn base_name(path:&str)->&str{path.trim_end_matches(['/','\\']).rsplit(['/','\\']).next().filter(|s|!s.is_empty()).unwrap_or(path)}
|
||||
pub fn remote_join(dir:&str,name:&str)->String{
|
||||
let sep=if dir.contains('\\') && !dir.contains('/'){'\\'}else{'/'};
|
||||
if dir.ends_with(['/','\\']){format!("{dir}{name}")}else{format!("{dir}{sep}{name}")}
|
||||
}
|
||||
/// First free `name`, `name (1)`, ... in `dir` so a download never replaces a local file.
|
||||
pub fn free_local(dir:&std::path::Path,name:&str)->std::path::PathBuf{
|
||||
let(stem,ext)=match name.rfind('.'){Some(i) if i>0=>(&name[..i],&name[i..]),_=>(name,"")};
|
||||
(0..).map(|n|dir.join(if n==0{name.to_owned()}else{format!("{stem} ({n}){ext}")})).find(|p|!p.exists()).unwrap()
|
||||
}
|
||||
pub fn entry_rows(entries:&[Entry])->String{
|
||||
let clean=|s:&str|s.replace(['\t','\n','\r']," ");
|
||||
entries.iter().map(|e|format!("{}\t{}\t{}\t{}\t{}\n",e.kind,clean(&e.name),e.size,e.modified,clean(&e.path))).collect()
|
||||
}
|
||||
enum Job {List(String),Mkdir(String,String),Transfer{id:i32,upload:bool,from:String,dir:String,generation:u64}}
|
||||
struct Active {id:i32,name:String,from:String,to:String,last:Instant}
|
||||
fn task(id:i32,name:&str,status:&str,done:u64,total:u64,from:&str,to:&str,state:i32){
|
||||
let(n,s,f,t)=(c(name),c(status),c(from),c(to));
|
||||
unsafe{uu_files_ui_task(id,n.as_ptr(),s.as_ptr(),done,total,f.as_ptr(),t.as_ptr(),state)}
|
||||
}
|
||||
fn reason(error:&str)->String{if error.contains("canceled"){"已取消".into()}else{format!("失败:{error}")}}
|
||||
|
||||
pub async fn files(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
|
||||
start("files",name)?;
|
||||
let(f,mut progress)=Files::new(io,rx);let f=Arc::new(f);
|
||||
let generation=Arc::new(AtomicU64::new(0));
|
||||
let active:Arc<Mutex<Option<Active>>>=Arc::new(Mutex::new(None));
|
||||
let shown=active.clone();
|
||||
let reporter=tokio::spawn(async move{
|
||||
while let Some(p)=progress.recv().await{
|
||||
let mut guard=shown.lock().unwrap();let Some(a)=guard.as_mut() else{continue};
|
||||
if a.last.elapsed()<Duration::from_millis(200) && p.transferred<p.total{continue}a.last=Instant::now();
|
||||
let percent=if p.total>0{p.transferred*100/p.total}else{0};
|
||||
task(a.id,&a.name,&format!("传输中 {percent}%"),p.transferred,p.total,&a.from,&a.to,0);
|
||||
}
|
||||
});
|
||||
let _reporter=super::tools::Cancel(reporter.abort_handle());
|
||||
let(jobs,mut queue)=mpsc::unbounded_channel::<Job>();
|
||||
let closing=Arc::new(AtomicBool::new(false));let worker_closing=closing.clone();
|
||||
let(worker_f,worker_gen,worker_active)=(f.clone(),generation.clone(),active.clone());
|
||||
let mut worker=tokio::spawn(async move{
|
||||
let mut remote=":/".to_owned();
|
||||
while let Some(job)=queue.recv().await{if worker_closing.load(Ordering::Acquire){break}match job{
|
||||
Job::List(path)=>match worker_f.list_dir(&path).await{
|
||||
Ok(entries)=>{remote=path.clone();let(p,r)=(c(&path),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}
|
||||
Err(e)=>toast(&format!("无法读取远端目录:{e}")),
|
||||
},
|
||||
Job::Mkdir(path,parent)=>match worker_f.mkdir(&path).await{
|
||||
Ok(())=>if parent==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}},
|
||||
Err(e)=>toast(&format!("无法创建远端文件夹:{e}")),
|
||||
},
|
||||
Job::Transfer{id,upload,from,dir,generation}=>{
|
||||
let name=base_name(&from).to_owned();
|
||||
let to=if upload{remote_join(&dir,&name)}else{free_local(std::path::Path::new(&dir),&name).to_string_lossy().into_owned()};
|
||||
if generation!=worker_gen.load(Ordering::Acquire){task(id,&name,"已取消",0,0,&from,&to,2);continue}
|
||||
*worker_active.lock().unwrap()=Some(Active{id,name:name.clone(),from:from.clone(),to:to.clone(),last:Instant::now()});
|
||||
task(id,&name,"传输中",0,0,&from,&to,0);
|
||||
let result=if upload{worker_f.upload(&from,&to).await}else{worker_f.download(&from,&to).await};
|
||||
*worker_active.lock().unwrap()=None;
|
||||
match result{
|
||||
Ok(())=>{
|
||||
let size=std::fs::metadata(if upload{&from}else{&to}).map(|m|if m.is_file(){m.len()}else{0}).unwrap_or(0);
|
||||
task(id,&name,"已完成",size,size,&from,&to,1);
|
||||
if upload{if dir==remote{if let Ok(entries)=worker_f.list_dir(&remote).await{let(p,r)=(c(&remote),c(&entry_rows(&entries)));unsafe{uu_files_ui_set_remote(p.as_ptr(),r.as_ptr())}}}}
|
||||
else{unsafe{uu_files_ui_refresh_local()}}
|
||||
}
|
||||
Err(e)=>task(id,&name,&reason(&e),0,0,&from,&to,2),
|
||||
}
|
||||
}
|
||||
}}
|
||||
});
|
||||
let _worker=super::tools::Cancel(worker.abort_handle());
|
||||
let _=jobs.send(Job::List(":/".into()));
|
||||
static NEXT_TASK:std::sync::atomic::AtomicI32=std::sync::atomic::AtomicI32::new(1);
|
||||
let result=loop{
|
||||
if closed(){break Ok(())}
|
||||
if worker.is_finished(){break Err("File transfer worker stopped".into())}
|
||||
while let Some(cmd)=take(){
|
||||
let parts:Vec<&str>=cmd.split('\t').collect();
|
||||
match parts.as_slice(){
|
||||
["ls",path]=>{let _=jobs.send(Job::List((*path).into()));}
|
||||
["mkdir",path]=>{let parent=path.rfind(['/','\\']).map(|i|path[..i.max(1)].to_owned()).unwrap_or_default();let _=jobs.send(Job::Mkdir((*path).into(),parent));}
|
||||
[kind@("put"|"get"),from,dir]=>{
|
||||
let(id,upload)=(NEXT_TASK.fetch_add(1,Ordering::Relaxed),*kind=="put");
|
||||
let name=base_name(from);task(id,name,"等待中",0,0,from,dir,0);
|
||||
let _=jobs.send(Job::Transfer{id,upload,from:(*from).into(),dir:(*dir).into(),generation:generation.load(Ordering::Acquire)});
|
||||
}
|
||||
["cancel"]=>{generation.fetch_add(1,Ordering::AcqRel);f.cancel();}
|
||||
_=>{}
|
||||
}
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
};
|
||||
closing.store(true,Ordering::Release);drop(jobs);f.cancel();
|
||||
// Allow the existing transfer cancellation handshake to release the host's window.
|
||||
if tokio::time::timeout(Duration::from_secs(5),&mut worker).await.is_err(){worker.abort();let _=worker.await;}
|
||||
reporter.abort();let _=reporter.await;result
|
||||
}
|
||||
|
||||
pub async fn portmap(io:Transport,rx:mpsc::Receiver<Packet>,name:&str)->Result<(),String>{
|
||||
start("portmap",name)?;
|
||||
let p=PortMap::new(io,rx);
|
||||
let mut targets:std::collections::HashMap<u64,String>=Default::default();
|
||||
let mut last=String::from("-");
|
||||
let closed_transport=p.closed();tokio::pin!(closed_transport);
|
||||
let result=loop{
|
||||
if closed(){break Ok(())}
|
||||
while let Some(cmd)=take(){
|
||||
let parts:Vec<&str>=cmd.split('\t').collect();
|
||||
match parts.as_slice(){
|
||||
["add",rule,local,host,port]=>match(local.parse::<u16>(),port.parse::<u16>()){
|
||||
(Ok(local),Ok(port))=>match p.add_rule(*rule,local,*host,port).await{
|
||||
Ok(id)=>{targets.insert(id,format!("{host}:{port}"));}
|
||||
Err(e)=>toast(&format!("添加失败:{}",if e.contains("bind"){"本地端口已被占用".to_owned()}else{e})),
|
||||
},
|
||||
_=>toast("端口无效"),
|
||||
},
|
||||
["remove",id]=>if let Ok(id)=id.parse::<u64>(){
|
||||
if let Err(e)=p.remove_rule(id).await{toast(&format!("删除失败:{e}"))}targets.remove(&id);
|
||||
},
|
||||
_=>{}
|
||||
}
|
||||
}
|
||||
let mut status=p.status();status.sort_by_key(|s|s.id);
|
||||
let rows:String=status.iter().map(|s|format!("{}\t{}\t127.0.0.1:{}\t{}\t{}\n",s.id,s.name.replace(['\t','\n']," "),s.local_port,
|
||||
targets.get(&s.id).map(String::as_str).unwrap_or("-"),
|
||||
if s.failures>0{format!("已启用 · {} 个连接 · {} 次失败",s.streams,s.failures)}else{format!("已启用 · {} 个连接",s.streams)})).collect();
|
||||
if rows!=last{let r=c(&rows);unsafe{uu_portmap_ui_set_rules(r.as_ptr())};last=rows;}
|
||||
tokio::select!{_=&mut closed_transport=>{toast("连接已断开");tokio::time::sleep(Duration::from_secs(3)).await;break Err("Forwarding transport closed".into())},_=tokio::time::sleep(Duration::from_millis(200))=>{}}
|
||||
};
|
||||
let ids:Vec<u64>=p.status().iter().map(|s|s.id).collect();for id in ids{let _=p.remove_rule(id).await;}
|
||||
result
|
||||
}
|
||||
|
||||
// The worker serializes LIST/KILL requests; GTK commands remain responsive during network waits.
|
||||
pub async fn terminal(io:Transport,rx:mpsc::Receiver<Packet>,_device:&str,name:&str)->Result<(),String>{
|
||||
use super::tools::terminal::{Terminal,session_rows,local_terminal_command};
|
||||
let exe=std::env::current_exe().map_err(|_|"Cannot locate executable")?;
|
||||
start("terminal",name)?;
|
||||
let(t,mut events)=Terminal::new(io,rx);let t=Arc::new(t);
|
||||
let server=super::tools::terminal_ipc::Server::new()?;let path=server.path.clone();
|
||||
let(output,_)=tokio::sync::broadcast::channel(256);
|
||||
let ipc=super::tools::Abort(tokio::spawn(server.run(t.clone(),output.clone())));
|
||||
let relay=super::tools::Abort(tokio::spawn(async move{while let Some(e)=events.recv().await{let _=output.send(e);}}));
|
||||
let(jobs,mut queue)=mpsc::unbounded_channel::<u32>();
|
||||
let worker=tokio::spawn(async move{
|
||||
let operation=async{
|
||||
t.check_env().await?;
|
||||
let mut refresh=tokio::time::interval(Duration::from_secs(2));
|
||||
refresh.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
loop{tokio::select!{
|
||||
_=refresh.tick()=>{
|
||||
let rows=c(&session_rows(&t.list_sessions().await?));
|
||||
unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}
|
||||
},
|
||||
id=queue.recv()=>match id{
|
||||
Some(id)=>{if t.kill(id).await.is_err(){toast("结束会话失败,会话可能已退出")}
|
||||
let rows=c(&session_rows(&t.list_sessions().await?));unsafe{uu_terminal_ui_set(rows.as_ptr(),1)}},
|
||||
None=>return Ok::<(),String>(()),
|
||||
},
|
||||
_=tokio::time::sleep(Duration::from_millis(100)),if relay.0.is_finished()=>return Err("Terminal channel closed".into()),
|
||||
}}
|
||||
}.await;
|
||||
if operation.is_err(){unsafe{uu_terminal_ui_set(c("").as_ptr(),0)};toast("终端连接已断开,请关闭窗口后重试")}
|
||||
});
|
||||
let _worker=super::tools::Cancel(worker.abort_handle());
|
||||
let mut children:Vec<std::process::Child>=Vec::new();
|
||||
while !closed(){
|
||||
if worker.is_finished(){ipc.0.abort();}
|
||||
children.retain_mut(|child|matches!(child.try_wait(),Ok(None)));
|
||||
while let Some(cmd)=take(){
|
||||
if worker.is_finished(){toast("连接已断开");continue}
|
||||
let parts:Vec<_>=cmd.split('\t').collect();
|
||||
let session=match parts.as_slice(){
|
||||
["create"]=>None,
|
||||
["open",id]=>match id.parse::<u32>().ok().filter(|n|*n!=0){Some(id)=>Some(id),None=>continue},
|
||||
["kill",id]=>{if let Ok(id)=id.parse::<u32>(){let _=jobs.send(id);}continue},
|
||||
_=>continue,
|
||||
};
|
||||
match local_terminal_command(&exe,&path,session){
|
||||
Some(mut command)=>match command.spawn(){Ok(child)=>children.push(child),Err(_)=>toast("无法启动本机终端程序")},
|
||||
None=>toast("没有找到本机终端程序(可设置 TERMINAL 环境变量)"),
|
||||
}
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
worker.abort();let _=worker.await;
|
||||
drop(ipc);
|
||||
// Closing the list drops all local IPC clients; reap emulator launchers off-thread.
|
||||
std::thread::spawn(move||{for mut child in children{let _=child.wait();}});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[test] fn path_helpers_handle_both_separators() {
|
||||
assert_eq!(base_name("/home/u/a.txt"),"a.txt");assert_eq!(base_name("C:\\Users\\x\\"),"x");assert_eq!(base_name("/"),"/");
|
||||
assert_eq!(remote_join("/home/u","a"),"/home/u/a");assert_eq!(remote_join("/","a"),"/a");assert_eq!(remote_join("C:\\Users","a"),"C:\\Users\\a");
|
||||
let dir=std::env::temp_dir().join(format!("uu-free-{}",super::super::wire::uuid()));std::fs::create_dir(&dir).unwrap();
|
||||
std::fs::write(dir.join("a.txt"),b"").unwrap();
|
||||
assert_eq!(free_local(&dir,"a.txt"),dir.join("a (1).txt"));assert_eq!(free_local(&dir,"b"),dir.join("b"));
|
||||
std::fs::remove_file(dir.join("a.txt")).unwrap();std::fs::remove_dir(&dir).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
//! Launcher window (`uuremote-viewer ui`): QR sign-in, device list, and one child process per
|
||||
//! remote session so each SDL window is isolated. Account data never reaches the logs.
|
||||
use serde_json::Value;
|
||||
use std::ffi::{CStr, CString};
|
||||
use std::os::raw::{c_char, c_int};
|
||||
use std::time::{Duration, Instant, SystemTime};
|
||||
|
||||
extern "C" {
|
||||
fn uu_viewer_ui_start() -> c_int;
|
||||
fn uu_viewer_ui_set_devices(tsv: *const c_char);
|
||||
fn uu_viewer_ui_set_login(signed_in: c_int, qr_png: *const c_char, status: *const c_char, user: *const c_char);
|
||||
fn uu_viewer_ui_take_command(out: *mut c_char, len: usize) -> c_int;
|
||||
fn uu_viewer_ui_closed() -> c_int;
|
||||
fn uu_viewer_ui_confirm_replace() -> c_int;
|
||||
fn uu_viewer_ui_toast(text: *const c_char);
|
||||
}
|
||||
fn toast(text: &str) { let t = c(text); unsafe { uu_viewer_ui_toast(t.as_ptr()) } }
|
||||
|
||||
/// Runs one session child; on failure shows its last error line (log lines start with '[').
|
||||
fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::oneshot::Receiver<()>, success: Option<&'static str>) -> tokio::task::JoinHandle<()> {
|
||||
use tokio::io::AsyncBufReadExt;
|
||||
let stderr = child.stderr.take();
|
||||
tokio::spawn(async move {
|
||||
let mut last = String::new();
|
||||
let mut lines = stderr.map(|e| tokio::io::BufReader::new(e).lines());
|
||||
let status = loop {
|
||||
tokio::select! {
|
||||
_ = &mut cancel => {
|
||||
if let Some(id)=child.id(){unsafe{libc::kill(id as i32,libc::SIGTERM);}}
|
||||
if tokio::time::timeout(Duration::from_secs(6),child.wait()).await.is_err(){let _=child.kill().await;}return;
|
||||
}
|
||||
status = child.wait() => break status,
|
||||
line = async { match lines.as_mut() { Some(l) => l.next_line().await, None => std::future::pending().await } } => match line {
|
||||
Ok(Some(l)) => { if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
|
||||
_ => lines = None,
|
||||
},
|
||||
}
|
||||
};
|
||||
// wait() may win before the final stderr line is read.
|
||||
let _ = tokio::time::timeout(Duration::from_millis(200), async {
|
||||
if let Some(lines) = lines.as_mut() {
|
||||
while let Ok(Some(l)) = lines.next_line().await {
|
||||
if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); }
|
||||
}
|
||||
}
|
||||
}).await;
|
||||
if !status.is_ok_and(|s| s.success()) {
|
||||
let reason = match last.as_str() {
|
||||
"" => "连接已断开".to_owned(),
|
||||
"CONTROL echo timed out" => "连接超时:被控端没有响应(官方主机互通尚未完成)".to_owned(),
|
||||
"Remote session released" => "被控端结束了本次连接".to_owned(),
|
||||
other => other.to_owned(),
|
||||
};
|
||||
toast(&format!("连接失败:{reason}"));
|
||||
} else if let Some(message) = success { toast(message); }
|
||||
})
|
||||
}
|
||||
|
||||
struct Running { cancel:tokio::sync::oneshot::Sender<()>, task:tokio::task::JoinHandle<()>, input:Option<tokio::process::ChildStdin> }
|
||||
impl Running { async fn stop(self){let _=self.cancel.send(());let _=self.task.await;} }
|
||||
async fn replace(sessions:&mut std::collections::HashMap<String,Running>,id:&str)->bool{
|
||||
if sessions.get(id).is_some_and(|s|!s.task.is_finished()) && unsafe{uu_viewer_ui_confirm_replace()}!=1{return false}
|
||||
if let Some(old)=sessions.remove(id){old.stop().await;}true
|
||||
}
|
||||
|
||||
fn c(text: &str) -> CString { CString::new(text.replace('\0', "")).unwrap_or_default() }
|
||||
fn set_login(signed_in: bool, qr: &str, status: &str, user: &str) {
|
||||
let (q, s, u) = (c(qr), c(status), c(user));
|
||||
unsafe { uu_viewer_ui_set_login(signed_in as c_int, q.as_ptr(), s.as_ptr(), u.as_ptr()) }
|
||||
}
|
||||
fn take() -> Option<String> {
|
||||
let mut buf = [0 as c_char; 200];
|
||||
(unsafe { uu_viewer_ui_take_command(buf.as_mut_ptr(), buf.len()) } != 0)
|
||||
.then(|| unsafe { CStr::from_ptr(buf.as_ptr()) }.to_string_lossy().into_owned())
|
||||
}
|
||||
/// "id\tname\tplatform\tonline\tcurrent" lines; tabs and newlines in names are flattened.
|
||||
pub fn device_rows(devices: &[Value], current: Option<&str>) -> String {
|
||||
let clean = |s: &str| s.replace(['\t', '\n', '\r'], " ");
|
||||
devices.iter().filter_map(|d| {
|
||||
let id = d.get("device_id")?.as_str()?;
|
||||
let name = d.get("alias").and_then(Value::as_str).unwrap_or(id);
|
||||
let platform = d.get("platform").and_then(Value::as_i64).unwrap_or(0);
|
||||
let online = d.get("status").and_then(Value::as_str) == Some("CONNECTED");
|
||||
Some(format!("{}\t{}\t{}\t{}\t{}\n", clean(id), clean(name), platform, online as u8, (current == Some(id)) as u8))
|
||||
}).collect()
|
||||
}
|
||||
|
||||
pub async fn run(credentials: impl Fn() -> Result<crate::auth::Credentials, String>) -> Result<(), String> {
|
||||
if unsafe { uu_viewer_ui_start() } != 0 { return Err("Cannot open the window (GTK3 and a graphical session are required)".into()); }
|
||||
let exe = std::env::current_exe().map_err(|_| "Cannot locate executable")?;
|
||||
let qr = std::env::temp_dir().join(format!("uu-viewer-qr-{}.png", std::process::id()));
|
||||
let mut login: Option<tokio::process::Child> = None;
|
||||
let mut qr_seen: Option<SystemTime> = None;
|
||||
let mut next_refresh = Instant::now();
|
||||
let mut sessions:std::collections::HashMap<String,Running>=Default::default();
|
||||
let mut names: std::collections::HashMap<String, String> = Default::default();
|
||||
let refresh = |creds: &crate::auth::Credentials| {
|
||||
let api = super::api::Api::new(crate::auth::UUAuthClient::new(creds.clone()), crate::auth::BASE_URL);
|
||||
async move { api.device_list().await }
|
||||
};
|
||||
loop {
|
||||
if unsafe { uu_viewer_ui_closed() } != 0 { break; }
|
||||
sessions.retain(|_,s| !s.task.is_finished());
|
||||
if let Some(child) = login.as_mut() {
|
||||
if let Ok(meta) = std::fs::metadata(&qr) {
|
||||
if meta.modified().ok() != qr_seen { qr_seen = meta.modified().ok(); set_login(false, &qr.to_string_lossy(), "请用手机扫码并确认", ""); }
|
||||
}
|
||||
if let Ok(Some(_)) = child.try_wait() { login = None; let _ = std::fs::remove_file(&qr); next_refresh = Instant::now(); }
|
||||
} else if Instant::now() >= next_refresh {
|
||||
next_refresh = Instant::now() + Duration::from_secs(30);
|
||||
match credentials() {
|
||||
Ok(creds) => {
|
||||
set_login(true, "", "", "已登录");
|
||||
match refresh(&creds).await {
|
||||
Ok(data) => {
|
||||
let list = data.get("my_binded_devices").and_then(Value::as_array).cloned().unwrap_or_default();
|
||||
let current = data.pointer("/current_device/device_id").and_then(Value::as_str);
|
||||
names = list.iter().filter_map(|d| Some((d.get("device_id")?.as_str()?.to_owned(),
|
||||
d.get("alias").and_then(Value::as_str).unwrap_or("远端设备").to_owned()))).collect();
|
||||
let rows = c(&device_rows(&list, current)); unsafe { uu_viewer_ui_set_devices(rows.as_ptr()) }
|
||||
}
|
||||
Err(super::api::Error::AuthenticationExpired) => set_login(false, "", "登录已过期,请重新登录", ""),
|
||||
Err(_) => {}
|
||||
}
|
||||
}
|
||||
Err(_) => set_login(false, "", "尚未登录", ""),
|
||||
}
|
||||
}
|
||||
while let Some(cmd) = take() {
|
||||
let parts: Vec<&str> = cmd.split('\t').collect();
|
||||
match parts.as_slice() {
|
||||
["quit"] => break,
|
||||
["refresh"] => next_refresh = Instant::now(),
|
||||
["logout"] => {
|
||||
// Sign out locally: drop the account token, keep the device identity.
|
||||
let path = crate::config::path();
|
||||
if let Ok(mut v) = std::fs::read_to_string(&path).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).ok_or(()) {
|
||||
if let Some(o) = v.as_object_mut() { o.remove("token"); o.remove("csrf"); }
|
||||
let _ = std::fs::write(&path, v.to_string());
|
||||
}
|
||||
for (_,s) in sessions.drain() { s.stop().await; }
|
||||
unsafe { uu_viewer_ui_set_devices(c("").as_ptr()) }
|
||||
set_login(false, "", "已退出登录", "");
|
||||
next_refresh = Instant::now() + Duration::from_secs(3600);
|
||||
}
|
||||
["login"] if login.is_none() => {
|
||||
let server = exe.with_file_name("uuremote-server");
|
||||
login = tokio::process::Command::new(server).args(["login", "--no-gui"])
|
||||
.env("UU_LOGIN_QR_PNG", &qr).stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null())
|
||||
.kill_on_drop(true).spawn().ok();
|
||||
if login.is_none() { set_login(false, "", "找不到配套的 uuremote-server", ""); }
|
||||
}
|
||||
["connect", id, kind] if matches!(*kind, "desktop" | "watch") => {
|
||||
if !replace(&mut sessions,id).await{continue}
|
||||
// One process per session; "-" selects the built-in desktop connection shape.
|
||||
let mut command=tokio::process::Command::new(&exe);
|
||||
command.args(["connect", id, "false", "-", "echo", "legacy"]);
|
||||
command.env("UU_VIEWER_DEVICE_NAME", super::device_label(names.get(*id).map(String::as_str)));
|
||||
if *kind=="watch" {command.arg("--view-only");}
|
||||
match command.env("UU_VIEWER_COMMANDS","1").stdin(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
|
||||
Ok(mut child) => { let input=child.stdin.take();let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input}); }
|
||||
Err(_) => toast("连接失败:无法启动会话进程"),
|
||||
}
|
||||
}
|
||||
["assist", id, code] => {
|
||||
match super::assist::command(&exe, id).spawn() {
|
||||
Ok(mut child) => match super::assist::send_code(&mut child, code).await {
|
||||
Ok(()) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert(format!("assist:{id}"),Running{cancel,task,input:None}); }
|
||||
Err(reason) => toast(&format!("连接失败:{reason}")),
|
||||
},
|
||||
Err(_) => toast("连接失败:无法启动协助会话进程"),
|
||||
}
|
||||
}
|
||||
["connect", id, kind @ ("file" | "portmap" | "terminal")] => {
|
||||
if *kind=="file" {if let Some(s)=sessions.get_mut(*id){if let Some(input)=s.input.as_mut(){
|
||||
use tokio::io::AsyncWriteExt;
|
||||
if input.write_all(b"files\n").await.is_err(){toast("桌面会话命令发送失败,请重试")}continue
|
||||
}}}
|
||||
if !replace(&mut sessions,id).await{continue}
|
||||
let name = names.get(*id).cloned().unwrap_or_else(|| "远端设备".into());
|
||||
let tool = if *kind == "file" { "files-ui" } else if *kind == "terminal" { "terminal-ui" } else { "portmap-ui" };
|
||||
match tokio::process::Command::new(&exe).args([tool, id, &name])
|
||||
.stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
|
||||
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,None);sessions.insert((*id).into(),Running{cancel,task,input:None}); }
|
||||
Err(_) => toast("连接失败:无法启动工具进程"),
|
||||
}
|
||||
}
|
||||
["connect", id, kind @ ("reboot" | "shutdown")] => {
|
||||
if !replace(&mut sessions,id).await{continue}
|
||||
match tokio::process::Command::new(&exe).args(["power", id, kind])
|
||||
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::piped()).kill_on_drop(true).spawn() {
|
||||
Ok(child) => { let (cancel,rx)=tokio::sync::oneshot::channel();let task=watch_session(child,rx,Some("电源指令已发送,未确认远端执行结果"));sessions.insert((*id).into(),Running{cancel,task,input:None}); }
|
||||
Err(_) => toast("电源指令失败:无法启动会话进程"),
|
||||
}
|
||||
}
|
||||
["connect", id, "unbind"] => {
|
||||
if let Some(s)=sessions.remove(*id){s.stop().await;}
|
||||
let result=match credentials(){
|
||||
Ok(creds)=>super::api::Api::new(crate::auth::UUAuthClient::new(creds),crate::auth::BASE_URL).unbind(id,false).await.map_err(|e|e.to_string()),
|
||||
Err(e)=>Err(e),
|
||||
};
|
||||
match result {Ok(())=>toast("设备已从账号删除"),Err(e)=>toast(&format!("删除设备失败:{e}"))}
|
||||
next_refresh=Instant::now();
|
||||
}
|
||||
["connect", _, kind] => log::info!("Viewer UI: {kind} is not supported yet"),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||||
}
|
||||
for (_,s) in sessions {s.stop().await;}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
#[test] fn device_rows_flatten_names_and_mark_online() {
|
||||
let rows = super::device_rows(&[
|
||||
serde_json::json!({"device_id":"d1","alias":"a\tb","platform":4,"status":"CONNECTED"}),
|
||||
serde_json::json!({"device_id":"d2","platform":1,"status":"DISCONNECTED"}),
|
||||
serde_json::json!({"alias":"no id"}),
|
||||
], Some("d2"));
|
||||
assert_eq!(rows, "d1\ta b\t4\t1\t0\nd2\td2\t1\t0\t1\n");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
//! Shapes from viewer-connect-shape-20261016.md; values describe caller capabilities.
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{json, Value};
|
||||
use crate::protocol::{decode_wire, WireValue};
|
||||
|
||||
pub const CHANNELS: [&str; 5] = ["CONTROL_DATA_CHANNEL", "TEXT_DATA_CHANNEL", "STREAMER_DATA_CHANNEL", "FILE_DATA_CHANNEL", "BINARY_DATA_CHANNEL"];
|
||||
pub fn uuid() -> String {
|
||||
let mut b: [u8;16] = rand::random(); b[6] = (b[6] & 15) | 64; b[8] = (b[8] & 63) | 128;
|
||||
let s = hex::encode(b);
|
||||
format!("{}-{}-{}-{}-{}", &s[..8], &s[8..12], &s[12..16], &s[16..20], &s[20..])
|
||||
}
|
||||
pub fn varint(mut n: u64, out: &mut Vec<u8>) { while n >= 128 { out.push(n as u8 | 128); n >>= 7; } out.push(n as u8); }
|
||||
pub fn int(field: u32, value: u64, out: &mut Vec<u8>) { varint(u64::from(field) << 3,out); varint(value,out); }
|
||||
pub fn bytes(field: u32, value: &[u8], out: &mut Vec<u8>) { varint((u64::from(field)<<3)|2,out); varint(value.len() as u64,out); out.extend(value); }
|
||||
pub fn envelope(seq:u64, kind:u32, payload:&[u8]) -> Vec<u8> {
|
||||
let mut out=Vec::new(); int(1,seq,&mut out); bytes(kind,payload,&mut out); out
|
||||
}
|
||||
#[derive(Clone, Deserialize)]
|
||||
pub struct Decoder { pub fps:u32, pub codec:u32, pub width:u32, pub height:u32, pub chroma:u32 }
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct Display { pub id:u32, pub fps:u32, pub r#type:u32, pub hdr:u32 }
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct Codec { pub video_codec:u32, pub chroma_sampling:u32, pub codec_impl:u32, pub bit_depth:u32, pub width:u32, pub height:u32 }
|
||||
#[derive(Clone, Deserialize)]
|
||||
pub struct Shape {
|
||||
pub capture_type:u32,
|
||||
pub platform:u32,
|
||||
pub client_version:String,
|
||||
pub width:u32,
|
||||
pub height:u32,
|
||||
pub fps:u32,
|
||||
pub chroma:u32,
|
||||
pub decoders:Vec<Decoder>,
|
||||
pub display_modes:Vec<[u32;3]>,
|
||||
pub displays:Vec<Display>,
|
||||
pub codecs:Vec<Codec>,
|
||||
/// FeatureFlag {field: version} pairs (ConnectOptions 11). Empty by default; official hosts may
|
||||
/// require it (live: official Mac/Windows hosts did not answer an empty flag set).
|
||||
#[serde(default)]
|
||||
pub feature_flag:Vec<[u32;2]>,
|
||||
}
|
||||
impl Shape {
|
||||
pub fn validate(&self) -> Result<(),String> {
|
||||
if ![1,5,8,9].contains(&self.capture_type) || ![3,4].contains(&self.platform)
|
||||
|| self.width==0 || self.height==0 || self.fps==0 || ![1,3].contains(&self.chroma) {
|
||||
return Err("Invalid explicit viewer shape".into());
|
||||
}
|
||||
if self.decoders.iter().any(|d| ![1,2].contains(&d.codec) || ![1,3].contains(&d.chroma) || d.width==0 || d.height==0 || d.fps==0) {
|
||||
return Err("Invalid decoder capability".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn validate_session(&self)->Result<(),String> {
|
||||
self.validate()?;
|
||||
if self.codecs.iter().any(|c|![1,2].contains(&c.video_codec) || ![1,3].contains(&c.chroma_sampling))
|
||||
|| (self.capture_type==1 && self.decoders.is_empty()) {
|
||||
return Err("Sessions require supported decoder and codec capabilities".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Advertise software decoding of both 8-bit chroma formats. Keep caller size/fps limits.
|
||||
/// The explicit chroma request is sent on CONTROL, so initial capture stays 4:2:0.
|
||||
pub fn video_preferences(&self,h264_only:bool)->Self {
|
||||
let mut shape=self.clone();
|
||||
if shape.capture_type==1 {
|
||||
shape.chroma=1;
|
||||
shape.decoders.clear();
|
||||
for codec in if h264_only {&[1][..]}else{&[2,1][..]} {
|
||||
let base=self.decoders.iter().find(|d|d.codec==*codec).or_else(||self.decoders.first());
|
||||
if let Some(base)=base {for chroma in [1,3] {
|
||||
let mut d=base.clone();d.codec=*codec;d.chroma=chroma;shape.decoders.push(d);
|
||||
}}
|
||||
}
|
||||
}
|
||||
if h264_only {shape.decoders.retain(|d|d.codec==1);shape.codecs.retain(|c|c.video_codec==1);}
|
||||
shape
|
||||
}
|
||||
pub fn connect_options(&self, device:&str, clipboard:bool) -> Result<Vec<u8>,String> {
|
||||
self.validate()?;
|
||||
let mut out=Vec::new(); int(1,self.capture_type.into(),&mut out);
|
||||
if [1,8].contains(&self.capture_type) { int(2,u64::MAX,&mut out); }
|
||||
if [1,5].contains(&self.capture_type) {
|
||||
let mut params=Vec::new(); int(1,2,&mut params); int(2,4,&mut params); int(4,2,&mut params);
|
||||
let mut size=Vec::new(); int(1,self.width.into(),&mut size); int(2,self.height.into(),&mut size);
|
||||
bytes(5,&size,&mut params); bytes(6,&[],&mut params);
|
||||
if self.capture_type==1 { int(7,self.chroma.into(),&mut params); int(9,1,&mut params); int(11,self.fps.into(),&mut params); }
|
||||
bytes(3,¶ms,&mut out);
|
||||
for d in &self.decoders {
|
||||
let mut cap=Vec::new();
|
||||
for (f,v) in [(1,d.fps),(2,d.codec),(3,d.width),(4,d.height)] { int(f,v.into(),&mut cap); }
|
||||
if self.capture_type==1 { int(5,d.chroma.into(),&mut cap); }
|
||||
bytes(4,&cap,&mut out);
|
||||
}
|
||||
for mode in &self.display_modes {
|
||||
let mut value=Vec::new(); for (f,v) in mode.iter().enumerate() { int(f as u32+1,(*v).into(),&mut value); }
|
||||
bytes(6,&value,&mut out);
|
||||
}
|
||||
bytes(7,&size,&mut out);
|
||||
}
|
||||
int(8,self.platform.into(),&mut out); bytes(9,device.as_bytes(),&mut out); int(10,1,&mut out);
|
||||
if self.capture_type==1 {
|
||||
let mut flags=Vec::new(); for [field,version] in &self.feature_flag { if *field!=8 {int((*field).into(),(*version).into(),&mut flags);} }
|
||||
if clipboard{int(8,3,&mut flags);}
|
||||
bytes(11,&flags,&mut out);
|
||||
}
|
||||
if self.capture_type!=5 { bytes(12,self.client_version.as_bytes(),&mut out); }
|
||||
Ok(out)
|
||||
}
|
||||
pub fn control(&self, client:&str, id:&str, ice:&str) -> Result<Value,String> {
|
||||
self.validate()?;
|
||||
let streamer=json!({"control_id":id,"device_capability":{"display_info":self.displays,"ice_id":"","video_codec_capability":self.codecs}});
|
||||
// Official Control::SerializeSioMsg (libstreamer 0x107bf8) sends only these three keys. A
|
||||
// viewer-chosen ice_id reaches the host via be-controlled while the ack assigns another, and the
|
||||
// official host drops the offer ("drop the soac event ... not in current ice connections").
|
||||
let _=(client,ice);
|
||||
Ok(json!({"app_control_id":id,"app_data":{"_placeholder":true,"num":0},"streamer_data":streamer.to_string()}))
|
||||
}
|
||||
}
|
||||
|
||||
/// Existing viewer FeatureFlag pairs; clipboard uses the host text protocol version (3).
|
||||
/// Session encoders omit clipboard when its local backend is disabled or unavailable.
|
||||
pub const VIEWER_FEATURES:[[u32;2];8]=[[1,6],[2,2],[3,1],[4,2],[6,2],[7,2],[8,3],[9,1]];
|
||||
pub fn feature_flag(flags:&[[u32;2]]) -> Vec<u8> { let mut out=Vec::new(); for [f,v] in flags { int(*f,(*v).into(),&mut out); } out }
|
||||
pub fn echo_request(seq:u64) -> Vec<u8> {echo_request_with_clipboard(seq,false)}
|
||||
fn session_features(clipboard:bool)->Vec<u8>{
|
||||
let mut flags:Vec<_>=VIEWER_FEATURES.iter().copied().filter(|p|p[0]!=8).collect();
|
||||
if clipboard{flags.push([8,3]);}feature_flag(&flags)
|
||||
}
|
||||
pub fn echo_request_with_clipboard(seq:u64,clipboard:bool)->Vec<u8>{
|
||||
let mut action=Vec::new();int(1,0,&mut action);bytes(4,&session_features(clipboard),&mut action);envelope(seq,3,&action)
|
||||
}
|
||||
pub fn echo_clipboard_supported(data:&[u8])->bool{
|
||||
let Ok(fields)=decode_wire(data) else{return false};
|
||||
fields.iter().any(|f|match (f.number,&f.value){
|
||||
(3,WireValue::Bytes(action))=>decode_wire(action).is_ok_and(|fields|fields.iter().any(|f|match (f.number,&f.value){
|
||||
(4,WireValue::Bytes(flags))=>decode_wire(flags).is_ok_and(|flags|flags.iter().any(|f|matches!((f.number,&f.value),(8,WireValue::Varint(3..))))),_=>false,
|
||||
})),_=>false,
|
||||
})
|
||||
}
|
||||
/// Official hosts also send an echo request (SimpleAction action 0) and repeat it until answered.
|
||||
/// Returns the request's Message seq when `data` is such a request.
|
||||
pub fn echo_request_seq(data:&[u8]) -> Option<u64> {
|
||||
let fields=decode_wire(data).ok()?;
|
||||
let seq=fields.iter().find_map(|f|match (f.number,&f.value){(1,WireValue::Varint(v))=>Some(*v),_=>None})?;
|
||||
fields.iter().find_map(|f|match (f.number,&f.value) {
|
||||
// proto3 omits the default action 0, so a SimpleAction without field 1 is an echo request too.
|
||||
(3,WireValue::Bytes(action))=>decode_wire(action).ok()?.iter().find_map(|f|match (f.number,&f.value){(1,WireValue::Varint(v))=>Some(*v),_=>None}).unwrap_or(0).eq(&0).then_some(seq),
|
||||
_=>None,
|
||||
})
|
||||
}
|
||||
/// Answer like the host side does: action 1, args {"seq": request seq}, our FeatureFlag.
|
||||
pub fn echo_response(seq:u64,request_seq:u64)->Vec<u8>{echo_response_with_clipboard(seq,request_seq,false)}
|
||||
pub fn echo_response_with_clipboard(seq:u64, request_seq:u64,clipboard:bool) -> Vec<u8> {
|
||||
let mut action=Vec::new(); int(1,1,&mut action);
|
||||
bytes(2,format!("{{\"seq\":{request_seq}}}").as_bytes(),&mut action);
|
||||
bytes(4,&session_features(clipboard),&mut action); envelope(seq,3,&action)
|
||||
}
|
||||
pub fn echo_matches(data:&[u8], seq:u64) -> bool {
|
||||
let Ok(fields)=decode_wire(data) else {return false};
|
||||
fields.iter().any(|f| match (f.number,&f.value) {
|
||||
(3,WireValue::Bytes(action))=> {
|
||||
let Ok(fields)=decode_wire(action) else {return false};
|
||||
let response=fields.iter().any(|f|f.number==1 && f.value==WireValue::Varint(1));
|
||||
response && fields.iter().any(|f|match (f.number,&f.value) {
|
||||
(2,WireValue::Bytes(args))=>serde_json::from_slice::<Value>(args).ok().and_then(|v|v.get("seq").and_then(Value::as_u64))==Some(seq), _=>false,
|
||||
})
|
||||
}, _=>false,
|
||||
})
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
pub fn shape()->Shape { serde_json::from_str(include_str!("../../tests/fixtures/viewer/shape.json")).unwrap() }
|
||||
#[test]
|
||||
fn session_shape_uses_observed_field_presence_and_nested_values() {
|
||||
let mut s=shape();
|
||||
for capture in [1,5,8,9] {
|
||||
s.capture_type=capture;
|
||||
let b=s.connect_options("synthetic-device",false).unwrap(); let f=decode_wire(&b).unwrap();
|
||||
let numbers:Vec<u32>=f.iter().map(|f|f.number).collect();
|
||||
let expected=match capture {1=>vec![1,2,3,4,4,4,4,6,6,7,8,9,10,11,12],5=>vec![1,3,4,4,4,4,6,6,7,8,9,10],8=>vec![1,2,8,9,10,12],_=>vec![1,8,9,10,12]};
|
||||
assert_eq!(numbers,expected);
|
||||
for f in f.iter().filter(|f|f.number==4) {
|
||||
let WireValue::Bytes(b)=f.value else {panic!()}; let cap=decode_wire(b).unwrap();
|
||||
assert_eq!(cap.len(),if capture==1 {5}else{4});
|
||||
}
|
||||
if [1,8].contains(&capture) { assert!(f.iter().any(|f| f.number==2 && f.value==WireValue::Varint(u64::MAX))); }
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn streamer_identity_and_echo_correlation_are_separate_from_socket_ack() {
|
||||
let s=shape();let id=uuid(); let v=s.control("synthetic-client",&id,"synthetic-ice").unwrap();
|
||||
let streamer:Value=serde_json::from_str(v["streamer_data"].as_str().unwrap()).unwrap();
|
||||
assert_eq!(streamer["control_id"],v["app_control_id"]); assert_eq!(id.len(),36); assert_ne!(id,uuid()); assert_eq!(&id[14..15],"4");
|
||||
let mut action=Vec::new();int(1,1,&mut action);bytes(2,br#"{"seq":7}"#,&mut action);
|
||||
let reply=envelope(99,3,&action); assert!(echo_matches(&reply,7)); assert!(!echo_matches(&reply,99));
|
||||
assert!(!echo_matches(&echo_request(7),7)); assert!(!echo_matches(&[255],7));
|
||||
}
|
||||
}
|
||||
|
||||
/// CaptureSettingRequest field 7 = ChromaFormat 3, wrapped in RPC 21/case 2.
|
||||
pub fn request_chroma444()->Vec<u8>{
|
||||
let mut header=Vec::new();int(1,2_000_000,&mut header);
|
||||
let mut setting=Vec::new();int(7,3,&mut setting);
|
||||
let mut rpc=Vec::new();bytes(1,&header,&mut rpc);bytes(2,&setting,&mut rpc);
|
||||
envelope(2_000_000,21,&rpc)
|
||||
}
|
||||
/// Message 18 is an encoder capability LIST, not the chosen codec; RTP's negotiated PT is authoritative.
|
||||
/// Message 25 reports actual encoded chroma, which may fall back to 4:2:0.
|
||||
pub fn media_control(data:&[u8])->(Option<u32>,Option<u32>){
|
||||
let mut codecs=None;let mut chroma=None;
|
||||
if let Ok(fields)=decode_wire(data){for field in fields {
|
||||
if let WireValue::Bytes(body)=field.value {match field.number {
|
||||
18=>{if let Ok(caps)=decode_wire(body){let mut mask=0;for cap in caps {if let (1,WireValue::Bytes(cap))=(cap.number,cap.value){
|
||||
match super::tools::uint(cap,3){1=>mask|=1,2=>mask|=2,_=>{}}
|
||||
}}codecs=Some(mask);}},
|
||||
25=>{let value=super::tools::uint(body,3);if [1,3].contains(&value){chroma=Some(value as u32);}},
|
||||
_=>{},
|
||||
}}
|
||||
}}(codecs,chroma)
|
||||
}
|
||||
|
||||
#[cfg(test)] mod video_tests {
|
||||
use super::*;
|
||||
#[test] fn decoder_caps_cover_both_codecs_and_chroma_and_force_h264(){
|
||||
let original:Shape=serde_json::from_str(include_str!("../../tests/fixtures/viewer/session-shape.json")).unwrap();
|
||||
for force in [false,true] {
|
||||
let s=original.video_preferences(force);s.validate_session().unwrap();assert_eq!(s.chroma,1);
|
||||
let options=s.connect_options("synthetic-device",false).unwrap();
|
||||
let mut caps=Vec::new();
|
||||
for f in decode_wire(&options).unwrap(){if let (4,WireValue::Bytes(cap))=(f.number,f.value){
|
||||
assert_eq!(super::super::tools::uint(cap,1),30);
|
||||
assert_eq!(super::super::tools::uint(cap,3),1280);assert_eq!(super::super::tools::uint(cap,4),720);
|
||||
caps.push((super::super::tools::uint(cap,2),super::super::tools::uint(cap,5)));
|
||||
}}
|
||||
assert_eq!(caps,if force{vec![(1,1),(1,3)]}else{vec![(2,1),(2,3),(1,1),(1,3)]});
|
||||
assert!(s.video_preferences(force).connect_options("synthetic-device",false).unwrap()==options);
|
||||
}
|
||||
}
|
||||
#[test] fn chroma_request_and_actual_sync_are_independent_of_encoder_list(){
|
||||
let request=request_chroma444();let rpc=super::super::tools::blob(&request,21).unwrap();
|
||||
let setting=super::super::tools::blob(rpc,2).unwrap();assert_eq!(super::super::tools::uint(setting,7),3);
|
||||
assert_eq!(decode_wire(setting).unwrap().len(),1);
|
||||
let mut caps=Vec::new();for codec in [1,2] {let mut cap=Vec::new();int(3,codec,&mut cap);bytes(1,&cap,&mut caps);}
|
||||
let mut msg=envelope(1,18,&caps);let mut sync=Vec::new();int(3,1,&mut sync);bytes(25,&sync,&mut msg);
|
||||
assert_eq!(media_control(&msg),(Some(3),Some(1)));
|
||||
assert_eq!(media_control(&envelope(2,25,&[24,3])),(None,Some(3)));
|
||||
assert_eq!(media_control(&[255]),(None,None));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
//! Experimental controller session, built only with --features native-viewer.
|
||||
#![allow(dead_code)]
|
||||
#[path = "auth.rs"] mod auth;
|
||||
#[path = "config.rs"] mod config;
|
||||
#[path = "protocol.rs"] mod protocol;
|
||||
mod viewer;
|
||||
#[cfg(test)] #[path="hevc.rs"] mod hevc;
|
||||
use viewer::clipboard;
|
||||
#[path="clipboard_protocol.rs"] mod clipboard_protocol;
|
||||
#[path="clipboard_rich.rs"] mod clipboard_rich;
|
||||
#[cfg(test)] #[path="terminal.rs"] mod terminal;
|
||||
#[cfg(test)] #[path="file_trans.rs"] mod file_trans;
|
||||
#[cfg(test)] #[path="initialization.rs"] mod initialization;
|
||||
use viewer::{api::Api,rtc::ReadyPolicy,session::{Options,Session},wire::Shape};
|
||||
use std::time::Duration;
|
||||
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer unbind DEVICE [--shared] (从账号删除设备 / remove a device from the account)\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nVideo: UU_VIEWER_CODEC=h264 forces H.264; UU_VIEWER_CHROMA=444 requests true color (default 4:2:0).\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
|
||||
const DEFAULT_SHAPE:&str=r#"{"capture_type":1,"platform":3,"client_version":"4.42.0","width":1920,"height":1080,"fps":60,"chroma":1,
|
||||
"decoders":[{"fps":60,"codec":1,"width":3840,"height":2160,"chroma":1}],"display_modes":[[1920,1080,60]],
|
||||
"displays":[{"id":1,"fps":60,"type":0,"hdr":0}],
|
||||
"codecs":[{"video_codec":1,"chroma_sampling":1,"codec_impl":34,"bit_depth":8,"width":3840,"height":2160}],
|
||||
"feature_flag":[[1,6],[2,2],[3,1],[4,2],[6,2],[7,2],[8,3],[9,1]]}"#;
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
// Do not inherit broad RUST_LOG filters that could expose third-party wire diagnostics.
|
||||
let args:Vec<String>=std::env::args().skip(1).collect();
|
||||
// The terminal tool owns the TTY: diagnostics would interleave with the remote shell's screen.
|
||||
let level=if args.first().is_some_and(|m|matches!(m.as_str(),"terminal"|"terminal-local")){log::LevelFilter::Off}else{log::LevelFilter::Info};
|
||||
env_logger::Builder::new().filter_level(log::LevelFilter::Off).filter_module("uuremote_viewer",level).init();
|
||||
match run(&args).await {Ok(())=>{},Err(error)=>{eprintln!("{error}");std::process::exit(2)}}
|
||||
}
|
||||
async fn run(args:&[String])->Result<(),String> {
|
||||
match args.first().map(String::as_str) {
|
||||
None|Some("--help"|"help")=>{println!("{HELP}");Ok(())},
|
||||
Some("login") if args.len()==1 || (args.len()==2 && args[1]=="--no-gui")=> {
|
||||
let executable=std::env::current_exe().map_err(|_|"Cannot locate companion login binary")?.with_file_name("uuremote-server");
|
||||
login_command(&executable,&args[1..]).await
|
||||
}
|
||||
#[cfg(uu_gtk)]
|
||||
Some("ui") if args.len()==1=> viewer::ui::run(credentials).await,
|
||||
Some("devices-shape") if args.len()==2=> {
|
||||
let method=match args[1].as_str(){"GET"=>reqwest::Method::GET,"POST"=>reqwest::Method::POST,_=>return Err("Device list method must be GET or POST".into())};
|
||||
println!("{}",api()?.devices_shape(method).await.map_err(|e|e.to_string())?);
|
||||
Ok(())
|
||||
}
|
||||
Some("devices") if args.len()==5=> {
|
||||
let method=match args[1].as_str(){"GET"=>reqwest::Method::GET,"POST"=>reqwest::Method::POST,_=>return Err("Device list method must be GET or POST".into())};
|
||||
let api=api()?;
|
||||
let devices=api.devices(method,&args[2]).await.map_err(|e|e.to_string())?;
|
||||
for device in devices {
|
||||
// Deliberate UI output, restricted to selected identity/display fields.
|
||||
// Strings verbatim; numbers/booleans (platform, status flags) as their JSON text.
|
||||
let id=device.pointer(&args[3]).map(|v|v.as_str().map(str::to_owned).unwrap_or_else(||v.to_string())).unwrap_or_default();
|
||||
let name=device.pointer(&args[4]).and_then(serde_json::Value::as_str).unwrap_or("");
|
||||
println!("{}",serde_json::json!({"device":id,"name":name}));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
Some("unbind") if (args.len()==2 || (args.len()==3 && args[2]=="--shared")) && !args[1].is_empty() => {
|
||||
api()?.unbind(&args[1],args.len()==3).await.map_err(|e|format!("删除设备失败:{e}"))?;
|
||||
println!("已从账号删除设备");Ok(())
|
||||
}
|
||||
Some("power")=>power_command(args).await,
|
||||
Some("terminal-local") if args.len()==2 || args.len()==3=>{
|
||||
let session=if args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
|
||||
viewer::tools::terminal_ipc::client(std::path::Path::new(&args[1]),session).await
|
||||
},
|
||||
Some("terminal"|"files"|"portmap"|"files-ui"|"portmap-ui"|"terminal-ui")=>tool_command(args).await,
|
||||
Some("assist") if args.len()==2=> {
|
||||
let code=viewer::assist::read_code(std::io::stdin().lock())?;
|
||||
desktop_command(&["connect".into(),args[1].clone(),"false".into(),"-".into(),"echo".into(),"legacy".into()],Some(code)).await.map_err(|e|format!("协助连接失败:{e}"))
|
||||
}
|
||||
Some("connect") if args.len()==6 || args.len()==7=> desktop_command(args,None).await,
|
||||
_=>Err(HELP.into()),
|
||||
}
|
||||
}
|
||||
async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String> {
|
||||
let view_only=viewer::input::view_only(args.get(6).map(String::as_str),std::env::var("UU_VIEWER_VIEW_ONLY").ok().as_deref())?;
|
||||
let force=match args[2].as_str(){"true"=>true,"false"=>false,_=>return Err("force_join must be explicit true or false".into())};
|
||||
let policy=match args[4].as_str(){"echo"=>ReadyPolicy::EchoOnly,"manual"=>ReadyPolicy::Explicit,_=>return Err("Ready policy must be echo or manual".into())};
|
||||
let legacy=match args[5].as_str(){"raw"=>false,"legacy"=>true,_=>return Err("Attachment framing must be raw or legacy".into())};
|
||||
// "-" selects the built-in desktop shape (mirrors the official Mac viewer's observed request).
|
||||
let text=if args[3]=="-" {DEFAULT_SHAPE.to_owned()} else {std::fs::read_to_string(&args[3]).map_err(|_|"Cannot read explicit viewer shape")?};
|
||||
let shape:Shape=serde_json::from_str(&text).map_err(|_|"Invalid explicit viewer shape JSON")?;shape.validate_session()?;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let mut desktop=if shape.capture_type==1 {
|
||||
if matches!(policy,ReadyPolicy::Explicit) {return Err("Desktop manual readiness has no verified activation protocol".into())}
|
||||
// Library decoding with viewer-ffmpeg (FFmpeg 6.x headers); otherwise an ffmpeg CLI process.
|
||||
#[cfg(feature="viewer-ffmpeg")]
|
||||
let decoder:Box<dyn viewer::desktop::Decoder>=Box::new(viewer::decoder::Ffmpeg::new()?);
|
||||
#[cfg(not(feature="viewer-ffmpeg"))]
|
||||
let decoder:Box<dyn viewer::desktop::Decoder>=Box::new(viewer::decoder_cli::Cli::new()?);
|
||||
Some((viewer::sdl::Window::new()?,decoder))
|
||||
}else{None};
|
||||
let creds=credentials()?;
|
||||
let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let account_connection=code.is_none();
|
||||
let room=match code {
|
||||
Some(code)=>api.join_share(&args[1],&code).await,
|
||||
None=>api.join(&args[1],force,true).await,
|
||||
}.map_err(|e|e.to_string())?;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
if let Some((window,_))=desktop.as_mut().filter(|_|!view_only){
|
||||
let device=account_connection.then_some(args[1].as_str());
|
||||
window.set_mac(api.target_is_mac(&room,device).await.map_err(|e|e.to_string())?);
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let clipboard=desktop.as_ref().map(|(window,_)|window.clipboard_bridge()).unwrap_or_else(||clipboard::Bridge::new(false));
|
||||
#[cfg(not(feature="viewer-sdl"))]
|
||||
let clipboard=clipboard::Bridge::new(shape.capture_type==1);
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy,clipboard};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only).await}else{session.run().await};
|
||||
#[cfg(not(feature="viewer-sdl"))]
|
||||
let result=session.run().await;
|
||||
session.close().await;result
|
||||
}
|
||||
fn credentials()->Result<auth::Credentials,String> {auth::Credentials::load(config::read_fresh().map_err(|_|"Cannot read credential configuration")?.as_ref())}
|
||||
fn api()->Result<Api,String> {Ok(Api::new(auth::UUAuthClient::new(credentials()?),auth::BASE_URL))}
|
||||
|
||||
async fn login_command(executable:&std::path::Path,options:&[String])->Result<(),String> {
|
||||
let status=tokio::process::Command::new(executable).arg("login").args(options).status().await.map_err(|_|"Build sibling uuremote-server to reuse QR login")?;
|
||||
if status.success(){Ok(())}else{Err("QR login did not complete".into())}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod cli_tests {
|
||||
use super::*;
|
||||
#[tokio::test]
|
||||
async fn invalid_commands_never_fall_through_to_login_or_host_service() {
|
||||
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"],vec!["unbind"],vec!["unbind",""],vec!["unbind","device","--other"],vec!["unbind","device","--shared","extra"]] {
|
||||
assert!(run(&args.into_iter().map(str::to_owned).collect::<Vec<_>>()).await.is_err());
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn login_reuses_companion_subcommand_with_a_local_process_mock() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path=std::env::temp_dir().join(format!("uu-viewer-login-mock-{}",viewer::wire::uuid()));
|
||||
std::fs::write(&path,b"#!/bin/sh\n[ \"$#\" -eq 2 ] && [ \"$1\" = login ] && [ \"$2\" = --no-gui ]\n".as_slice()).unwrap();
|
||||
std::fs::set_permissions(&path,std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
let result=login_command(&path,&["--no-gui".into()]).await;
|
||||
std::fs::remove_file(path).unwrap();assert!(result.is_ok());
|
||||
}
|
||||
}
|
||||
|
||||
async fn tool_command(args:&[String])->Result<(),String>{
|
||||
let capture=match args[0].as_str(){"terminal" if args.len()==2 || args.len()==3=>8,"terminal-ui" if args.len()==3=>8,"files" if (args.len()==4 && args[2]=="ls") || (args.len()==5 && ["get","put"].contains(&args[2].as_str()))=>5,"portmap" if args.len()==5=>9,"files-ui" if args.len()==3=>5,"portmap-ui" if args.len()==3=>9,_=>return Err(HELP.into())};
|
||||
let terminal_session=if args[0]=="terminal" && args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
|
||||
#[cfg(not(uu_gtk))] if args[0].ends_with("-ui"){return Err("Tool windows require the GTK build".into())}
|
||||
let ports=if args[0]=="portmap"{Some((args[2].parse::<u16>().map_err(|_|"Invalid local port")?,args[4].parse::<u16>().map_err(|_|"Invalid target port")?))}else{None};
|
||||
if ports.is_some_and(|(_,port)|port==0) || (args[0]=="portmap" && args[3].trim().is_empty()){return Err("Invalid forwarding target".into())}
|
||||
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in tool shape")?;
|
||||
shape.capture_type=capture;shape.feature_flag.clear();
|
||||
if capture!=5{shape.decoders.clear();shape.display_modes.clear();shape.displays.clear();shape.codecs.clear();}
|
||||
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
|
||||
// Match the existing UI connection framing (9bb42d5); the host tolerates this prefix.
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
let result=async{
|
||||
let(io,rx)=viewer::tools::attach(&session.peer)?;
|
||||
let ready=async{
|
||||
loop{if session.peer.channels.iter().enumerate().filter(|(i,_)|[0,if capture==8{4}else{3}].contains(i)).all(|(_,c)|c.ready_state()==webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) && session.peer.observed.echo_received.load(std::sync::atomic::Ordering::Acquire){break}tokio::select!{r=session.step()=>r?,_=tokio::time::sleep(Duration::from_millis(20))=>{}}}Ok::<_,String>(())
|
||||
};
|
||||
tokio::time::timeout(Duration::from_secs(30),ready).await.map_err(|_|"Tool connection timed out")??;
|
||||
let operation=async{match args[0].as_str(){"terminal"=>viewer::tools::cli::terminal(io,rx,terminal_session).await,"files"=>viewer::tools::cli::files(io,rx,&args[2..]).await,
|
||||
#[cfg(uu_gtk)] "terminal-ui"=>viewer::tools_ui::terminal(io,rx,&args[1],&args[2]).await,
|
||||
#[cfg(uu_gtk)] "files-ui"=>viewer::tools_ui::files(io,rx,&args[2]).await,
|
||||
#[cfg(uu_gtk)] "portmap-ui"=>viewer::tools_ui::portmap(io,rx,&args[2]).await,
|
||||
"portmap"=>{let(local,port)=ports.unwrap();viewer::tools::cli::portmap(io,rx,local,&args[3],port).await}
|
||||
_=>Err("Tool windows require the GTK build".into())}};
|
||||
tokio::pin!(operation);
|
||||
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
|
||||
loop{tokio::select!{r=&mut operation=>break r,r=session.step()=>r?,_=terminate.recv()=>break Ok(()),_=tokio::signal::ctrl_c()=>break Ok(())}}
|
||||
}.await;
|
||||
session.close().await;result
|
||||
}
|
||||
|
||||
async fn power_command(args:&[String])->Result<(),String>{
|
||||
if args.len()!=3 || args[1].trim().is_empty(){return Err(HELP.into())}
|
||||
let action=viewer::power::Action::parse(&args[2])?;
|
||||
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in power shape")?;
|
||||
// File-tool peers carry CONTROL without starting desktop capture or clipboard.
|
||||
shape.capture_type=5;shape.feature_flag.clear();
|
||||
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
let room=api.join(&args[1],false,true).await.map_err(|e|e.to_string())?;
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
let result=viewer::power::run(&mut session,action).await;
|
||||
session.close().await;
|
||||
if result.is_ok(){println!("电源指令已发送;未确认远端执行结果。");}
|
||||
result
|
||||
}
|
||||
Vendored
+15
@@ -0,0 +1,15 @@
|
||||
The `red-{420,444}.{h264,hevc}` fixtures contain six synthetic 32x32 red IDRs,
|
||||
not desktop captures. Their decoded pixel formats are yuv420p and yuv444p.
|
||||
They let the CLI decoder test run without requiring encoders at test time.
|
||||
|
||||
Generated with FFmpeg (substitute `420` / `444` for `CHROMA`):
|
||||
|
||||
```sh
|
||||
ffmpeg -f lavfi -i color=c=red:s=32x32:r=10 -frames:v 6 -pix_fmt yuvCHROMAp \
|
||||
-c:v libx264 -threads 1 -preset ultrafast -tune zerolatency -g 1 \
|
||||
-f h264 red-CHROMA.h264
|
||||
ffmpeg -f lavfi -i color=c=red:s=32x32:r=10 -frames:v 6 -pix_fmt yuvCHROMAp \
|
||||
-c:v libx265 -threads 1 -preset ultrafast -tune zerolatency -g 1 \
|
||||
-x265-params pools=none:frame-threads=1:log-level=none:info=0 \
|
||||
-f hevc red-CHROMA.hevc
|
||||
```
|
||||
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"code":0,"msg":"fixture only","data":{"token":"synthetic-room-ticket","signaling_list":["ws://signaling.example.invalid"],"ws_connect_timeout_ms":1000,"report_token":"synthetic-report-ticket","report_url":"https://reports.example.invalid","report_server_address":"","streamer_retry_delta_ms":0,"international_connect":false}}
|
||||
Vendored
BIN
Binary file not shown.
Vendored
BIN
Binary file not shown.
Vendored
BIN
Binary file not shown.
Vendored
BIN
Binary file not shown.
+1
@@ -0,0 +1 @@
|
||||
{"capture_type":1,"platform":3,"client_version":"4.42.0","width":1280,"height":720,"fps":30,"chroma":1,"decoders":[{"fps":30,"codec":1,"width":1280,"height":720,"chroma":1}],"display_modes":[[1280,720,30]],"displays":[{"id":1,"fps":30,"type":0,"hdr":0}],"codecs":[]}
|
||||
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"capture_type":1,"platform":4,"client_version":"4.42.0","width":4112,"height":2580,"fps":60,"chroma":3,"decoders":[{"fps":120,"codec":2,"width":3840,"height":2160,"chroma":1},{"fps":120,"codec":2,"width":3840,"height":2160,"chroma":3},{"fps":120,"codec":1,"width":3840,"height":2160,"chroma":1},{"fps":120,"codec":1,"width":3840,"height":2160,"chroma":3}],"display_modes":[[4112,2580,120],[3840,2160,60]],"displays":[{"id":1,"fps":120,"type":0,"hdr":0}],"codecs":[{"video_codec":1,"chroma_sampling":1,"codec_impl":34,"bit_depth":8,"width":3840,"height":2160}]}
|
||||
Reference in new issue
Block a user