mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1b10a22c8c | ||
|
|
809ce1697d | ||
|
|
6f1dd77ab5 | ||
|
|
e5bb214f99 | ||
|
|
25edc41b9f | ||
|
|
1fa58904d7 | ||
|
|
da49e71b9d |
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, 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.29"
|
||||
version = "0.2.0"
|
||||
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.29"
|
||||
version = "0.2.0"
|
||||
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"
|
||||
|
||||
|
||||
+38
-2
@@ -74,7 +74,7 @@ real hardware, please [open an issue](../../issues) with your distribution, desk
|
||||
Wayland limits: single screen, fixed resolution. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
|
||||
permission; the permission is remembered once granted.
|
||||
|
||||
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. A previously streaming Portal capture that stays paused without a negotiated format for five seconds enters session recovery; a static desktop does not trigger this timeout. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the detection threshold, not the total recovery time. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping.
|
||||
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. On GNOME, a display-change notification enables earlier recovery when previously streaming Portal capture remains paused without a valid format for a 200 ms grace after both conditions are present. Healthy renegotiation cancels the early check; repeated notifications do not postpone the same interruption. The five-second fallback remains without a related notification. Static video and valid-format pauses do not trigger recovery. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the fallback threshold, not total recovery time. See [#35](../../pull/35) for timing measurements and validation limits. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping.
|
||||
|
||||
GNOME Portal CONTROL no longer waits for a consent dialog or the first video frame. It announces the selected desktop before reporting secure-desktop state and receiving the official viewer's “auto unlock host” request. The official Android viewer requires this desktop selection before entering its auto-unlock flow, so the notification must precede capture readiness; actual screen dimensions, codec information and capture permissions still follow their real readiness state. Enable auto unlock in the viewer and use the current Linux user's login password. The host verifies it with PAM, unlocks the existing GNOME session, requests display wake, and restores capture, input and clipboard through the shared Portal session. Initial consent or revoked permissions still require local approval. Reconnect if physical or logical dimensions change.
|
||||
|
||||
@@ -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,39 @@ 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; clipboard needs `wl-clipboard` (Wayland) or `xclip`/`xsel` (X11); 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`.
|
||||
|
||||
**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`,
|
||||
`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.
|
||||
|
||||
**Tested live** (author's setup, not full acceptance):
|
||||
| Feature | Official Windows host | Official Mac host | This project's Linux host |
|
||||
|---|---|---|---|
|
||||
| Desktop video (H.264) | ✅ | ✅ | ✅ |
|
||||
| Keyboard, mouse | ✅ | — | ✅ |
|
||||
| File list / download / upload | ✅ list, download | — | ✅ |
|
||||
| Port mapping, terminal | — | — | ✅ |
|
||||
| Clipboard (text, both ways), sound | — | — | ✅ (VM) |
|
||||
| Remote assistance (ID + code) | — | — | ✅ (VM, guest host) |
|
||||
|
||||
"—" = not tested yet. **Not tested live**: reboot/shutdown (only try on a machine you can restart), terminal session list
|
||||
create/reattach, Wayland windows and clipboard, H.265 and 4:4:4 (only H.264 4:2:0 is decoded), multiple monitors. Logs carry field
|
||||
numbers, sizes and states only, never keystrokes, clipboard or file contents, codes or credentials.
|
||||
@@ -66,7 +66,7 @@ GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/20
|
||||
|
||||
Wayland 下的限制:只支持单屏、固定分辨率;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
|
||||
|
||||
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。已开始推流的 Portal 采集若暂停且无有效协商格式持续五秒,将进入会话恢复;静态桌面不会触发该超时。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是故障判定阈值,并非总恢复时间。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。
|
||||
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。GNOME 显示配置变化后,已推流的 Portal 采集若持续「暂停且无有效格式」,会在关联通知后的 200 毫秒宽限结束后提前进入现有恢复流程;正常重协商恢复会取消提前判定,连续通知不会推迟同次异常的判定。未收到相关通知时保留五秒兜底;静态画面或有效格式下的暂停不会触发恢复。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是兜底判定阈值,并非总恢复时间。提前恢复的测量结果和验证范围见 [#35](../../pull/35)。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。
|
||||
|
||||
GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通知客户端当前选择桌面,再上报锁屏状态、接收官方客户端的「自动解锁被控端」请求。官方 Android 客户端需要桌面目标通知才会进入自动解锁流程,因此该通知不能等待采集就绪;真实屏幕尺寸、编码信息及采集权限仍按实际就绪状态上报。请在客户端启用自动解锁,使用当前 Linux 用户的登录密码;主机通过 PAM 验证后解锁当前 GNOME 会话、请求点亮屏幕,并恢复同一 Portal 会话中的画面、键鼠和剪贴板。首次授权或权限被撤销时仍需本机确认。物理或逻辑分辨率变化后需要重连。
|
||||
|
||||
@@ -94,7 +94,7 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
|
||||
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
|
||||
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
|
||||
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
|
||||
| 作为控制端(在 Linux 上控制别的电脑) | 不在本项目范围 |
|
||||
| 作为控制端(在 Linux 上控制别的电脑) | 🧪 实验性 `uuremote-viewer`,见[下文](#实验性原生控制端uuremote-viewer) |
|
||||
|
||||
## 安装
|
||||
|
||||
@@ -370,3 +370,35 @@ 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` 命令;剪贴板需要 `wl-clipboard`(Wayland)或 `xclip`/`xsel`(X11);终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
|
||||
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
|
||||
|
||||
**使用**:
|
||||
- `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`、
|
||||
`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 路径。
|
||||
|
||||
**已实测**(作者环境,非全面验收):
|
||||
| 功能 | 官方 Windows 被控端 | 官方 Mac 被控端 | 本项目 Linux 主机 |
|
||||
|---|---|---|---|
|
||||
| 桌面画面(H.264) | ✅ | ✅ | ✅ |
|
||||
| 键盘、鼠标 | ✅ | — | ✅ |
|
||||
| 文件列表 / 下载 / 上传 | ✅ 列表、下载 | — | ✅ |
|
||||
| 端口映射、终端 | — | — | ✅ |
|
||||
| 剪贴板(文本,双向)、声音 | — | — | ✅(虚拟机) |
|
||||
| 远程协助(ID + 验证码) | — | — | ✅(虚拟机,访客主机) |
|
||||
|
||||
「—」表示尚未测试。**未实测**:重启/关机(只应在可以重启的测试机上尝试)、终端会话列表的新建与接回、Wayland 下的窗口与剪贴板、
|
||||
H.265 与 4:4:4(目前只解码 H.264 4:2:0)、多显示器。日志只记录字段号、大小和状态,不记录键盘、剪贴板、文件内容、验证码或凭据。
|
||||
@@ -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() {
|
||||
|
||||
@@ -24,6 +24,9 @@
|
||||
#define REQUEST "org.freedesktop.portal.Request"
|
||||
#define SESSION "org.freedesktop.portal.Session"
|
||||
#define PORTAL_RENEGOTIATION_TIMEOUT (5 * G_TIME_SPAN_SECOND)
|
||||
#define PORTAL_DISPLAY_GRACE (200 * G_TIME_SPAN_MILLISECOND)
|
||||
#define MUTTER_DISPLAY "org.gnome.Mutter.DisplayConfig"
|
||||
#define MUTTER_DISPLAY_PATH "/org/gnome/Mutter/DisplayConfig"
|
||||
|
||||
struct uu_portal {
|
||||
GDBusConnection *bus;
|
||||
@@ -33,7 +36,7 @@ struct uu_portal {
|
||||
int dbus_started;
|
||||
char *session;
|
||||
char *restore_token;
|
||||
guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription;
|
||||
guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription;
|
||||
int clipboard_enabled, clipboard_changed;
|
||||
char *clipboard_text, *clipboard_mime;
|
||||
size_t clipboard_length;
|
||||
@@ -51,7 +54,7 @@ struct uu_portal {
|
||||
int error;
|
||||
enum pw_stream_state state;
|
||||
int format_valid, stream_started;
|
||||
gint64 interrupted_at;
|
||||
gint64 interrupted_at, display_changed_at;
|
||||
uint32_t node, width, height;
|
||||
int logical_width, logical_height;
|
||||
int absolute_stream_pixels;
|
||||
@@ -176,14 +179,31 @@ static int has_interface(struct uu_portal *p, const char *interface) {
|
||||
static void update_interruption(struct uu_portal *p) {
|
||||
if (p->stream_started && p->state == PW_STREAM_STATE_PAUSED && !p->format_valid) {
|
||||
if (!p->interrupted_at) p->interrupted_at = g_get_monotonic_time();
|
||||
} else p->interrupted_at = 0;
|
||||
} else {
|
||||
if (p->interrupted_at) p->display_changed_at = 0;
|
||||
p->interrupted_at = 0;
|
||||
}
|
||||
}
|
||||
static void monitors_changed(GDBusConnection *bus, const gchar *sender, const gchar *path,
|
||||
const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) {
|
||||
struct uu_portal *p = data;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
/* #27: measured NULL format 10-36ms after the notification, with PAUSED
|
||||
* 5-9ms before it. Preserve a correlated signal across repeated changes. */
|
||||
if (p->stream_started && (!p->display_changed_at || !p->interrupted_at ||
|
||||
p->display_changed_at < p->interrupted_at - PORTAL_DISPLAY_GRACE))
|
||||
p->display_changed_at = g_get_monotonic_time();
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
}
|
||||
static void stream_state(void *data, enum pw_stream_state old, enum pw_stream_state state, const char *message) {
|
||||
(void)old; (void)message;
|
||||
struct uu_portal *p = data;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
p->state = state;
|
||||
if (state == PW_STREAM_STATE_STREAMING) p->stream_started = 1;
|
||||
if (state == PW_STREAM_STATE_STREAMING) {
|
||||
p->stream_started = 1;
|
||||
p->display_changed_at = 0;
|
||||
}
|
||||
update_interruption(p);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (state == PW_STREAM_STATE_ERROR || state == PW_STREAM_STATE_UNCONNECTED) fail(data, 9);
|
||||
@@ -213,6 +233,7 @@ static void stream_format(void *data, uint32_t id, const struct spa_pod *param)
|
||||
p->width = info.size.width; p->height = info.size.height; p->format = info.format;
|
||||
p->frame_length = length;
|
||||
p->format_valid = 1;
|
||||
p->display_changed_at = 0;
|
||||
update_interruption(p);
|
||||
pthread_cond_broadcast(&p->changed);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
@@ -444,6 +465,9 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
g_variant_unref(results);
|
||||
if (*error) goto done;
|
||||
p->main_loop = g_main_loop_new(p->context, FALSE);
|
||||
if (p->absolute_stream_pixels)
|
||||
p->display_subscription = g_dbus_connection_signal_subscribe(p->bus, MUTTER_DISPLAY, MUTTER_DISPLAY,
|
||||
"MonitorsChanged", MUTTER_DISPLAY_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE, monitors_changed, p, NULL);
|
||||
g_main_context_pop_thread_default(p->context);
|
||||
if (pthread_create(&p->dbus_thread, NULL, run_dbus, p)) {
|
||||
*error = 3; p->cancelled = NULL; p->cancel_data = NULL;
|
||||
@@ -496,6 +520,7 @@ void uu_portal_close(struct uu_portal *p) {
|
||||
if (p->clipboard_owner_subscription) g_dbus_connection_signal_unsubscribe(p->bus,p->clipboard_owner_subscription);
|
||||
if (p->clipboard_transfer_subscription) g_dbus_connection_signal_unsubscribe(p->bus,p->clipboard_transfer_subscription);
|
||||
if (p->closed_subscription) g_dbus_connection_signal_unsubscribe(p->bus, p->closed_subscription);
|
||||
if (p->display_subscription) g_dbus_connection_signal_unsubscribe(p->bus, p->display_subscription);
|
||||
if (p->dbus_started) {
|
||||
/* A queued source also handles close racing with thread startup; an
|
||||
* immediate g_main_loop_quit before run would leave run blocking. */
|
||||
@@ -503,6 +528,8 @@ void uu_portal_close(struct uu_portal *p) {
|
||||
g_source_set_callback(quit, quit_dbus_loop, p->main_loop, NULL);
|
||||
g_source_attach(quit, p->context); g_source_unref(quit);
|
||||
g_main_context_wakeup(p->context); pthread_join(p->dbus_thread, NULL);
|
||||
} else if (p->context) {
|
||||
while (g_main_context_iteration(p->context, FALSE)) {}
|
||||
}
|
||||
if (p->pw_loop) pw_thread_loop_stop(p->pw_loop);
|
||||
if (p->stream) pw_stream_destroy(p->stream);
|
||||
@@ -531,8 +558,11 @@ int uu_portal_capture(struct uu_portal *p, uint8_t *frame, size_t length) {
|
||||
* paused, format-less renegotiation observed after a live scaling change (#25).
|
||||
* Called with the frame mutex held; recovery runs on the Rust capture worker. */
|
||||
static int stream_stalled(struct uu_portal *p) {
|
||||
return p->state == PW_STREAM_STATE_PAUSED && !p->format_valid && p->interrupted_at &&
|
||||
g_get_monotonic_time() - p->interrupted_at >= PORTAL_RENEGOTIATION_TIMEOUT;
|
||||
if (p->state != PW_STREAM_STATE_PAUSED || p->format_valid || !p->interrupted_at) return 0;
|
||||
gint64 now = g_get_monotonic_time();
|
||||
return now - p->interrupted_at >= PORTAL_RENEGOTIATION_TIMEOUT ||
|
||||
(p->display_changed_at && p->display_changed_at >= p->interrupted_at - PORTAL_DISPLAY_GRACE &&
|
||||
now - MAX(p->interrupted_at, p->display_changed_at) >= PORTAL_DISPLAY_GRACE);
|
||||
}
|
||||
int uu_portal_capture_since(struct uu_portal *p, uint8_t *frame, size_t length, uint64_t *revision) {
|
||||
if (!p || !frame) return 11;
|
||||
|
||||
@@ -0,0 +1,494 @@
|
||||
// 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; }
|
||||
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,715 @@
|
||||
// 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;
|
||||
}
|
||||
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"};
|
||||
for (int i = 0; i < 7; 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);
|
||||
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);
|
||||
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;
|
||||
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_OK_CANCEL, "打开后将断开当前与该设备的连接,继续吗?");
|
||||
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,13 @@
|
||||
修复未登录(访客)远程协助时 X11 没有画面。/ Fix missing video during guest remote assistance on X11.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **X11 访客远程协助无画面**:未登录账号、以访客身份开启远程协助时,设备初始化过程会临时打开再关闭一次屏幕采集,
|
||||
把正在使用的 X11 连接一起关掉,日志出现 `Live desktop stream stopped: X11 display wake failed`,控制端连上后一直黑屏。
|
||||
现在 X11 连接按引用计数管理,只有最后一个采集对象释放时才关闭;X11 分辨率变化后重建采集也不再有同样的隐患。
|
||||
已在虚拟机(Xvfb 虚拟桌面)上实测:访客协助加入、画面、鼠标移动/点击、键盘均正常。⚠️ 未用官方客户端在真机上复测。
|
||||
Guest assistance on X11 no longer loses the display connection; video, mouse and keyboard verified in a VM.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.30-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,18 @@
|
||||
GNOME 修改缩放后画面恢复更快。/ Faster capture recovery after GNOME display changes.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **GNOME Wayland 改缩放后黑屏/停顿时间缩短**(#27,感谢 @wanglz111,#35):以前切换缩放(如 200% ↔ 166.67%)后,Portal 采集要等
|
||||
5 秒兜底才恢复。现在监听 Mutter 的显示配置变化通知,采集持续「暂停且无有效格式」超过 200 毫秒宽限即提前进入原有恢复流程;
|
||||
正常重协商会取消提前判定,连续切换只恢复一次,5 秒兜底保留。贡献者在 Ubuntu 26.04、GNOME 50、单屏 3840×2160 上实测:
|
||||
通知到会话恢复从约 6.2 秒降到约 1.4 秒。⚠️ 200 毫秒是在该机器上测得的初始值;官方客户端侧的画面恢复耗时、多屏、
|
||||
物理分辨率变化与旋转未验收。X11 与其他桌面不受影响。
|
||||
On GNOME, Mutter `MonitorsChanged` lets a stalled Portal capture recover after a 200 ms grace instead of the 5 s fallback
|
||||
(host-side recovery about 6.2 s → 1.4 s on the contributor's 4K display).
|
||||
|
||||
### 内部 / Internal
|
||||
- CONTROL 生命周期单测改用虚拟网络,不再因本机网卡环境偶发超时。/ CONTROL lifecycle tests run on the virtual network.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.31-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -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.**
|
||||
+8
-1
@@ -108,6 +108,7 @@ impl ScreenCapture {
|
||||
if display_ptr.is_null() { return Err("Capture display name unavailable".into()); }
|
||||
let display = unsafe { std::ffi::CStr::from_ptr(display_ptr) }.to_string_lossy().into_owned();
|
||||
log::info!("Selected capture display: {}", display);
|
||||
X11_USERS.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
Ok(Self {
|
||||
backend,
|
||||
init_error:None,
|
||||
@@ -150,9 +151,15 @@ impl ScreenCapture {
|
||||
}
|
||||
}
|
||||
|
||||
/// The X11 engine keeps one process-wide display connection shared by every ScreenCapture.
|
||||
/// Only the last one may close it: a short-lived capture (device init's screen size during guest
|
||||
/// assistance, or the replaced capture after a resize) used to close it under the live stream.
|
||||
static X11_USERS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
|
||||
impl Drop for ScreenCapture {
|
||||
fn drop(&mut self) {
|
||||
if self.init_error.is_none() && self.backend==crate::desktop_backend::DesktopBackend::X11 { unsafe { x11_close() }; }
|
||||
if self.init_error.is_none() && self.backend==crate::desktop_backend::DesktopBackend::X11
|
||||
&& X11_USERS.fetch_sub(1, std::sync::atomic::Ordering::AcqRel) == 1 { unsafe { x11_close() }; }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -9,14 +9,16 @@ struct Viewer {
|
||||
pc: Arc<RTCPeerConnection>,
|
||||
channels: HashMap<String, Arc<RTCDataChannel>>,
|
||||
messages: Messages,
|
||||
router: Arc<Mutex<webrtc::util::vnet::router::Router>>,
|
||||
}
|
||||
|
||||
async fn connect(input: Arc<InputInjector>, desktop: bool,
|
||||
portal: Option<Arc<crate::desktop_session::PortalDesktop>>, labels: &[&str]) -> (WebRtcSession, Viewer) {
|
||||
let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await;
|
||||
let screen = Arc::new(ScreenCapture::unavailable("synthetic locked desktop".into()));
|
||||
let host = WebRtcSession::new(screen, input, crate::signaling::SignalingClient::disconnected(),
|
||||
desktop, crate::session_ice::SessionIce::local(), portal).await.unwrap();
|
||||
let pc = Arc::new(APIBuilder::new().build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
desktop, crate::session_ice::SessionIce::virtual_net(host_setting), portal).await.unwrap();
|
||||
let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
let (tx, messages) = mpsc::unbounded_channel();
|
||||
let mut channels = HashMap::new();
|
||||
for label in labels {
|
||||
@@ -41,7 +43,7 @@ async fn connect(input: Arc<InputInjector>, desktop: bool,
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
}).await.expect("local SCTP channels did not open");
|
||||
(host, Viewer { pc, channels, messages })
|
||||
(host, Viewer { pc, channels, messages, router })
|
||||
}
|
||||
|
||||
fn body(message: &[u8], number: u32) -> Option<&[u8]> {
|
||||
@@ -206,6 +208,9 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
|
||||
terminal_viewer.pc.close().await.unwrap();
|
||||
file_viewer.pc.close().await.unwrap();
|
||||
port_viewer.pc.close().await.unwrap();
|
||||
for router in [&viewer.router, &terminal_viewer.router, &file_viewer.router, &port_viewer.router] {
|
||||
router.lock().await.stop().await.unwrap();
|
||||
}
|
||||
echo.abort();
|
||||
drop(lock);
|
||||
}).await.expect("locked bootstrap/tool regression exceeded deadline");
|
||||
|
||||
+8
-1
@@ -7,13 +7,20 @@ use webrtc::peer_connection::{configuration::RTCConfiguration,policy::ice_transp
|
||||
pub struct SessionIce {
|
||||
servers: Vec<RTCIceServer>,
|
||||
relay_only: bool,
|
||||
#[cfg(test)]
|
||||
pub(crate) setting_engine: Option<webrtc::api::setting_engine::SettingEngine>,
|
||||
}
|
||||
|
||||
impl SessionIce {
|
||||
#[cfg(test)]
|
||||
pub fn local() -> Self {
|
||||
// A supplied empty URL list disables the public STUN defaults in local peer tests.
|
||||
Self { servers: vec![RTCIceServer::default()], relay_only: false }
|
||||
Self { servers: vec![RTCIceServer::default()], ..Default::default() }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub fn virtual_net(setting_engine: webrtc::api::setting_engine::SettingEngine) -> Self {
|
||||
Self { setting_engine: Some(setting_engine), ..Self::local() }
|
||||
}
|
||||
|
||||
pub fn from_header(header:&Value)->Self {
|
||||
|
||||
@@ -0,0 +1,334 @@
|
||||
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,
|
||||
}
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub enum Error { AuthenticationExpired, Api(i32, String), InvalidResponse, Transport, MissingRoom, InvalidDevice, InvalidAssist }
|
||||
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::Api(code, _) => write!(f, "连接请求失败(错误码 {code})"),
|
||||
_ => write!(f, "viewer API: {self:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Mirrors Windows 0x140b77cd0 / 0x140b7a6d0, not host RoomData.
|
||||
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> {
|
||||
// Treat the caller's device string as one opaque path segment, never a URL/query.
|
||||
if device.is_empty() || device=="." || device==".." { return Err(Error::InvalidDevice); }
|
||||
let encoded=device.bytes().map(|b|if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {(b as char).to_string()}else{format!("%{b:02X}")}).collect::<String>();
|
||||
let path = format!("/api/v1/room/join/by_device/{encoded}");
|
||||
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),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
/// 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)
|
||||
}
|
||||
/// 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 {
|
||||
use super::*;
|
||||
#[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);
|
||||
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()})}
|
||||
#[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 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,277 @@
|
||||
//! 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 Backend {read:PathBuf,read_args:Vec<&'static str>,write:PathBuf,write_args:Vec<&'static str>}
|
||||
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=Self::select(std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty()),executable);
|
||||
if selected.is_none(){warn();}selected
|
||||
}
|
||||
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<(),()>{
|
||||
if value.len()>MAX_TEXT{return Err(())}
|
||||
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<(),()>{
|
||||
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}
|
||||
fn local(&mut self,value:String)->Result<Option<Vec<u8>>,&'static str>{
|
||||
if self.last.as_ref()==Some(&value){return Ok(None)}
|
||||
let id=self.next();let payload=self.rich.offer(id,value.clone())?;
|
||||
self.last=Some(value);Ok(Some(wire::envelope(self.next(),21,&payload)))
|
||||
}
|
||||
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=>if let Some(text)=self.rich.response(payload)?{value=Some(text)},
|
||||
_=>{},
|
||||
}
|
||||
}
|
||||
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 fn available()->bool{Backend::detect().is_some()}
|
||||
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}
|
||||
}
|
||||
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(message))=>{if send(&channel,message).await.is_err(){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::*;
|
||||
#[test] fn backend_priority_requires_a_complete_wayland_pair_and_falls_back(){
|
||||
let select=|wayland,names:&[&str]|Backend::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());
|
||||
}
|
||||
#[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());
|
||||
}
|
||||
// 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()};
|
||||
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 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").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));
|
||||
}
|
||||
#[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 backend=Backend{read:script.clone(),write:script,read_args:vec!["read"],write_args:vec!["write"]};
|
||||
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{write:root.join("missing"),..backend.clone()};
|
||||
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,36 @@
|
||||
//! Uses the same optional FFmpeg dependency as the host inproc-av feature.
|
||||
use super::desktop::{Decoder,Frame};
|
||||
use ffmpeg_next as av;
|
||||
pub struct Ffmpeg { decoder:av::decoder::Video }
|
||||
impl Ffmpeg {
|
||||
pub fn new()->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(av::codec::Id::H264).ok_or("H264 decoder unavailable")?;
|
||||
let decoder=av::codec::context::Context::new().decoder().open_as(codec).and_then(|d|d.video()).map_err(|_|"H264 decoder initialization failed")?;
|
||||
Ok(Self{decoder})
|
||||
}
|
||||
}
|
||||
impl Decoder for Ffmpeg {
|
||||
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(|_|"H264 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("H264 decode failed".into()),
|
||||
}
|
||||
if decoded.is_corrupt(){return Err("Corrupt H264 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,61 @@
|
||||
//! H.264 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
|
||||
//! Needs only the ffmpeg CLI (any recent version), 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 std::io::{Read,Write};
|
||||
use std::process::{Child,ChildStdin,Command,Stdio};
|
||||
use std::sync::mpsc::{Receiver,TryRecvError};
|
||||
|
||||
pub struct Cli { child:Child, input:ChildStdin, 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));
|
||||
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 mut child=Command::new(ffmpeg)
|
||||
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
|
||||
"-fflags","nobuffer","-flags","low_delay","-f","h264","-i","pipe:0","-an","-vf",&filter,
|
||||
"-pix_fmt","rgb24",
|
||||
// Raw H.264 carries no timestamps; constant-rate output dropped almost every frame of
|
||||
// the official Mac host's stream (270 → 2). Pass frames through unchanged.
|
||||
"-fps_mode","passthrough","-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,frames,width,height})
|
||||
}
|
||||
}
|
||||
|
||||
impl Decoder for Cli {
|
||||
fn reset(&mut self) {}
|
||||
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String> {
|
||||
self.input.write_all(au).and_then(|_|self.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(); } }
|
||||
@@ -0,0 +1,35 @@
|
||||
use super::media::Latest;
|
||||
use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
|
||||
#[derive(Clone)]
|
||||
pub struct Desktop { pub units:Latest<Vec<u8>>, 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 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],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 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 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,&[],&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],&p).unwrap();assert_eq!(s.0,1);}
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
//! 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,
|
||||
})
|
||||
}
|
||||
#[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, 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 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=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 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,138 @@
|
||||
//! Bounded RFC 6184 packetization-mode 1 receiver. No media contents in logs.
|
||||
use std::{collections::VecDeque, sync::{Arc, Mutex}};
|
||||
use std::time::{Duration,Instant};
|
||||
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 {
|
||||
next: Option<u16>, pending: Vec<Packet>, timestamp: Option<u32>,
|
||||
au: Vec<u8>, fragment: Option<u8>, damaged: bool, gap_since:Option<Instant>, last_packet:Instant,
|
||||
}
|
||||
impl Default for Receiver {
|
||||
fn default() -> Self { Self { 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 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<(), ()> {
|
||||
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(header);
|
||||
} else if self.fragment != Some(header) { return Err(()) }
|
||||
self.append(&p[2..])?;
|
||||
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));
|
||||
}
|
||||
}
|
||||
@@ -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(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,315 @@
|
||||
use super::wire::{self, Shape, CHANNELS};
|
||||
use serde_json::{json, Value};
|
||||
use std::sync::{Arc,atomic::{AtomicBool,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 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,
|
||||
}
|
||||
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)->Result<Self,String> {
|
||||
shape.validate_session()?;
|
||||
let mut engine=MediaEngine::default();
|
||||
use webrtc::rtp_transceiver::rtp_codec::{RTCRtpCodecParameters,RTCRtpCodecCapability};
|
||||
for (kind,mime,rate,channels,fmtp,payload) in [
|
||||
(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),
|
||||
] {
|
||||
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")?;
|
||||
}
|
||||
// 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 && !track.codec().capability.mime_type.eq_ignore_ascii_case("video/H264") {return}
|
||||
if video {desktop.ssrc.store(track.ssrc(),Ordering::Release);}
|
||||
let mut receiver=super::media::Receiver::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}
|
||||
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(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 mut clipboard=super::clipboard::Bridge::new(shape.capture_type==1);
|
||||
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();
|
||||
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;}
|
||||
})));
|
||||
}
|
||||
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 count=state.control_messages.fetch_add(1,Ordering::Relaxed);
|
||||
if wire::echo_matches(&message.data,1) {state.clipboard_supported.store(wire::echo_clipboard_supported(&message.data),Ordering::Release);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");
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
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 }
|
||||
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()?;Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false})
|
||||
}
|
||||
fn viewport(&self)->Viewport {Viewport::fit(self.canvas.window().size(),self.frame)}
|
||||
pub fn poll(&mut self,input:&mut Input)->(bool,Vec<serde_json::Value>){
|
||||
let viewport=self.viewport();
|
||||
translate_actions(self.events.poll_iter(),input,viewport,&mut self.focused,&mut self.files)
|
||||
}
|
||||
}
|
||||
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);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);
|
||||
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();}
|
||||
super::desktop::display(decoder,window,&au,&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::*;
|
||||
#[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,87 @@
|
||||
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 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 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.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).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,289 @@
|
||||
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") && !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};
|
||||
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,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).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).await.unwrap();
|
||||
let second=Peer::new(RTCConfiguration::default(),&shape(),"synthetic-second","synthetic-second-ice","synthetic-host",tx2,b).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(),"app","ice","host",tx,viewer_settings).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,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).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");
|
||||
}
|
||||
@@ -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,178 @@
|
||||
//! 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)
|
||||
}
|
||||
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 remote=Path::new(remote);let name=remote.file_name().and_then(|s|s.to_str()).ok_or("Invalid remote file name")?;safe(name)?;
|
||||
let parent=remote.parent().and_then(|p|p.to_str()).filter(|p|!p.is_empty()).unwrap_or("~/");
|
||||
let task=self.next.fetch_add(1,Ordering::Relaxed);
|
||||
let mut info=nested(1,name.as_bytes());wire::int(2,size,&mut info);
|
||||
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);
|
||||
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()>32*1024 || 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
|
||||
}
|
||||
}
|
||||
@@ -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,80 @@
|
||||
//! 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{
|
||||
let session=rand::random::<u64>();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};if uint(f,1)!=session{continue}
|
||||
let key=(uint(f,2),uint(f,3));let sender=route.lock().unwrap().get(&key).cloned();
|
||||
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())};
|
||||
if result.is_err(){guard.status.lock().unwrap().failures+=1;}
|
||||
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 || 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,148 @@
|
||||
//! 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 {
|
||||
serde_json::from_slice::<Value>(&f.payload).ok().filter(Value::is_object).map(|mut v|{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);
|
||||
let b=self.request((24,id),CONTROL,wire::envelope(id,21,&r)).await?;
|
||||
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.
|
||||
let b=self.request((OPEN_RESP,0),BINARY,encode(OPEN,id,json!({"cols":cols.max(1),"rows":rows.max(1)}).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())}v["session_id"].as_u64().and_then(|n|u32::try_from(n).ok()).filter(|n|*n!=0).ok_or("Invalid terminal session id".into())
|
||||
}
|
||||
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,217 @@
|
||||
//! 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", _, 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,183 @@
|
||||
//! 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()?;
|
||||
// H264/420 receive only. streamer_data video_codec_capability is sent by the official Mac
|
||||
// viewer (8 entries observed live), so H264/420 entries are allowed there too.
|
||||
if self.decoders.iter().any(|d|d.codec!=1 || d.chroma!=1) || self.codecs.iter().any(|c|c.video_codec!=1 || c.chroma_sampling!=1)
|
||||
|| (self.capture_type==1 && (self.chroma!=1 || self.decoders.is_empty())) {
|
||||
return Err("Sessions require H264/420 decoder and codec capabilities".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn connect_options(&self, device:&str) -> 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 super::clipboard::available(){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) {
|
||||
(3,WireValue::Bytes(action))=>decode_wire(action).ok()?.iter().any(|f|f.number==1 && f.value==WireValue::Varint(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").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));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
//! 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;
|
||||
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 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]\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("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);
|
||||
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())?;
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy};
|
||||
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"]] {
|
||||
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};
|
||||
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};
|
||||
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
|
||||
}
|
||||
@@ -78,6 +78,8 @@ impl WebRtcSession {
|
||||
webrtc::interceptor::registry::Registry::new(), &mut m,
|
||||
).map_err(|e| format!("Register RTP/RTCP interceptors failed: {}", e))?;
|
||||
let mut se = webrtc::api::setting_engine::SettingEngine::default();
|
||||
#[cfg(test)]
|
||||
if let Some(setting) = &transport.setting_engine { se = setting.clone(); }
|
||||
se.set_answering_dtls_role(DTLSRole::Server)
|
||||
.map_err(|e| format!("Configure DTLS answer role failed: {}", e))?;
|
||||
se.set_ice_multicast_dns_mode(webrtc::ice::mdns::MulticastDnsMode::Disabled);
|
||||
|
||||
@@ -13,15 +13,17 @@ struct Viewer {
|
||||
pc: Arc<RTCPeerConnection>,
|
||||
channels: HashMap<String, Arc<RTCDataChannel>>,
|
||||
messages: Messages,
|
||||
router: Arc<Mutex<webrtc::util::vnet::router::Router>>,
|
||||
}
|
||||
|
||||
async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::PortalDesktop>>)
|
||||
-> (WebRtcSession, Viewer) {
|
||||
let input = Arc::new(InputInjector::without_desktop());
|
||||
let (host_setting, viewer_setting, router) = crate::test_network::virtual_network().await;
|
||||
let screen = Arc::new(ScreenCapture::unavailable("synthetic pending desktop".into()));
|
||||
let host = WebRtcSession::new(screen, input, crate::signaling::SignalingClient::disconnected(),
|
||||
desktop, crate::session_ice::SessionIce::local(), portal).await.unwrap();
|
||||
let pc = Arc::new(APIBuilder::new().build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
desktop, crate::session_ice::SessionIce::virtual_net(host_setting), portal).await.unwrap();
|
||||
let pc = Arc::new(APIBuilder::new().with_setting_engine(viewer_setting).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
let (tx, messages) = mpsc::unbounded_channel();
|
||||
let mut channels = HashMap::new();
|
||||
for label in ["CONTROL_DATA_CHANNEL"] {
|
||||
@@ -46,7 +48,7 @@ async fn connect(desktop: bool, portal: Option<Arc<crate::desktop_session::Porta
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
}).await.expect("local SCTP channels did not open");
|
||||
(host, Viewer { pc, channels, messages })
|
||||
(host, Viewer { pc, channels, messages, router })
|
||||
}
|
||||
|
||||
fn body(message: &[u8], number: u32) -> Option<&[u8]> {
|
||||
@@ -137,6 +139,7 @@ async fn ready_without_portal_session_does_not_advertise_clipboard() {
|
||||
"Echo was re-sent without an established clipboard capability");
|
||||
viewer.pc.close().await.unwrap();
|
||||
host.pc.close().await.unwrap();
|
||||
viewer.router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("clipboard capability regression exceeded deadline");
|
||||
}
|
||||
|
||||
@@ -201,6 +204,7 @@ async fn pending_portal_answers_echo_immediately_and_defers_capture_settings() {
|
||||
|
||||
viewer.pc.close().await.unwrap();
|
||||
host.pc.close().await.unwrap();
|
||||
viewer.router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("pending-Portal lifecycle regression exceeded deadline");
|
||||
}
|
||||
|
||||
@@ -220,5 +224,6 @@ async fn tool_peer_applies_capture_settings_without_a_desktop() {
|
||||
assert_eq!((varint_of(sync, 5), varint_of(sync, 6)), (Some(1280), Some(720)));
|
||||
viewer.pc.close().await.unwrap();
|
||||
host.pc.close().await.unwrap();
|
||||
viewer.router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("tool capture-setting regression exceeded deadline");
|
||||
}
|
||||
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}}
|
||||
+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}]}
|
||||
@@ -184,6 +184,148 @@ static void portal_changed_physical_format_still_fails(void) {
|
||||
assert(uu_portal_capture_since(p, pixels, sizeof(pixels), NULL) == 8);
|
||||
uu_portal_close(p);
|
||||
}
|
||||
static void display_change(struct uu_portal *p) {
|
||||
monitors_changed(NULL, NULL, NULL, NULL, NULL, NULL, p);
|
||||
}
|
||||
static struct uu_portal *streaming_portal(void) {
|
||||
struct uu_portal *p = test_portal();
|
||||
test_format(p, 2, 2);
|
||||
stream_state(p, PW_STREAM_STATE_UNCONNECTED, PW_STREAM_STATE_STREAMING, NULL);
|
||||
test_frame(p);
|
||||
return p;
|
||||
}
|
||||
static void portal_display_change_recovery(void) {
|
||||
/* Notification, PAUSED and NULL can arrive in any order. */
|
||||
const unsigned orders[][3] = {{0,1,2}, {0,2,1}, {1,0,2}, {1,2,0}, {2,0,1}, {2,1,0}};
|
||||
for (size_t order = 0; order < G_N_ELEMENTS(orders); order++) {
|
||||
test_monotonic_time = 10000000;
|
||||
struct uu_portal *p = streaming_portal();
|
||||
for (unsigned n = 0; n < 3; n++) {
|
||||
test_monotonic_time += 20 * G_TIME_SPAN_MILLISECOND;
|
||||
switch (orders[order][n]) {
|
||||
case 0: display_change(p); break;
|
||||
case 1: stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL); break;
|
||||
case 2: stream_format(p, SPA_PARAM_Format, NULL); break;
|
||||
}
|
||||
}
|
||||
gint64 deadline = MAX(p->display_changed_at, p->interrupted_at) + PORTAL_DISPLAY_GRACE;
|
||||
test_monotonic_time = deadline - 1;
|
||||
assert(uu_portal_capture_alive(p));
|
||||
test_monotonic_time++;
|
||||
assert(!uu_portal_capture_alive(p) && uu_portal_alive(p));
|
||||
p->clipboard_enabled = 1;
|
||||
assert(uu_portal_clipboard_ready(p));
|
||||
uint8_t pixels[16];
|
||||
assert(uu_portal_capture(p, pixels, sizeof(pixels)) == 9);
|
||||
uu_portal_close(p);
|
||||
}
|
||||
/* A delayed notification still accelerates an existing invalid pause. */
|
||||
test_monotonic_time = 20000000;
|
||||
struct uu_portal *p = streaming_portal();
|
||||
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
|
||||
stream_format(p, SPA_PARAM_Format, NULL);
|
||||
test_monotonic_time += G_TIME_SPAN_SECOND;
|
||||
display_change(p);
|
||||
gint64 notified_at = p->display_changed_at;
|
||||
test_monotonic_time += 100 * G_TIME_SPAN_MILLISECOND;
|
||||
display_change(p);
|
||||
assert(p->display_changed_at == notified_at); /* Repeated signals cannot postpone recovery. */
|
||||
test_monotonic_time = notified_at + PORTAL_DISPLAY_GRACE;
|
||||
assert(!uu_portal_capture_alive(p) && uu_portal_alive(p));
|
||||
uu_portal_close(p);
|
||||
}
|
||||
static void portal_display_change_healthy_and_stale(void) {
|
||||
test_monotonic_time = 30000000;
|
||||
struct uu_portal *p = test_portal();
|
||||
display_change(p);
|
||||
assert(!p->display_changed_at); /* Ignore notifications during startup. */
|
||||
uu_portal_close(p);
|
||||
|
||||
p = streaming_portal();
|
||||
display_change(p);
|
||||
test_monotonic_time += 60 * G_TIME_SPAN_SECOND;
|
||||
assert(uu_portal_capture_alive(p)); /* No new frames on a static screen is healthy. */
|
||||
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
|
||||
assert(uu_portal_capture_alive(p)); /* A valid format must not trigger recovery. */
|
||||
stream_format(p, SPA_PARAM_Format, NULL);
|
||||
gint64 invalid_at = test_monotonic_time;
|
||||
test_monotonic_time += PORTAL_DISPLAY_GRACE;
|
||||
assert(uu_portal_capture_alive(p)); /* The notification from a minute ago is unrelated. */
|
||||
test_monotonic_time = invalid_at + PORTAL_RENEGOTIATION_TIMEOUT;
|
||||
assert(!uu_portal_capture_alive(p));
|
||||
uu_portal_close(p);
|
||||
|
||||
test_monotonic_time = 100000000;
|
||||
p = streaming_portal();
|
||||
display_change(p);
|
||||
stream_state(p, PW_STREAM_STATE_STREAMING, PW_STREAM_STATE_PAUSED, NULL);
|
||||
stream_format(p, SPA_PARAM_Format, NULL);
|
||||
test_monotonic_time += PORTAL_DISPLAY_GRACE - 1;
|
||||
test_format(p, 2, 2); /* Natural renegotiation wins before the early check. */
|
||||
assert(!p->display_changed_at && !p->interrupted_at);
|
||||
test_monotonic_time += G_TIME_SPAN_SECOND;
|
||||
assert(uu_portal_capture_alive(p));
|
||||
stream_format(p, SPA_PARAM_Format, NULL);
|
||||
test_monotonic_time += PORTAL_DISPLAY_GRACE;
|
||||
assert(uu_portal_capture_alive(p)); /* Recovered signal cannot accelerate another failure. */
|
||||
display_change(p); /* A later display change correlates with the retained invalid state. */
|
||||
test_monotonic_time += PORTAL_DISPLAY_GRACE;
|
||||
assert(!uu_portal_capture_alive(p) && uu_portal_alive(p));
|
||||
/* Even after the fast deadline, recovery can still win before replacement. */
|
||||
test_format(p, 2, 2);
|
||||
assert(uu_portal_capture_alive(p) && !p->display_changed_at);
|
||||
display_change(p);
|
||||
test_format(p, 2, 2); /* Successful format without an invalid pause discards its hint. */
|
||||
assert(!p->display_changed_at);
|
||||
display_change(p);
|
||||
stream_state(p, PW_STREAM_STATE_PAUSED, PW_STREAM_STATE_STREAMING, NULL);
|
||||
assert(!p->display_changed_at);
|
||||
uu_portal_close(p);
|
||||
}
|
||||
static void portal_display_subscription_lifecycle(void) {
|
||||
GTestDBus *test_bus = g_test_dbus_new(G_TEST_DBUS_NONE);
|
||||
g_test_dbus_up(test_bus);
|
||||
GDBusConnection *bus = g_dbus_connection_new_for_address_sync(g_test_dbus_get_bus_address(test_bus),
|
||||
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
|
||||
NULL, NULL, NULL);
|
||||
assert(bus);
|
||||
const char *sender = g_dbus_connection_get_unique_name(bus);
|
||||
for (unsigned threaded = 0; threaded < 2; threaded++) {
|
||||
struct uu_portal *p = streaming_portal();
|
||||
p->bus = g_object_ref(bus);
|
||||
p->context = g_main_context_new();
|
||||
p->main_loop = g_main_loop_new(p->context, FALSE);
|
||||
g_main_context_push_thread_default(p->context);
|
||||
p->display_subscription = g_dbus_connection_signal_subscribe(bus, sender, MUTTER_DISPLAY,
|
||||
"MonitorsChanged", MUTTER_DISPLAY_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE, monitors_changed, p, NULL);
|
||||
g_main_context_pop_thread_default(p->context);
|
||||
/* A synchronous roundtrip places the match rule before the signal. */
|
||||
GVariant *reply = g_dbus_connection_call_sync(bus, "org.freedesktop.DBus", "/org/freedesktop/DBus",
|
||||
"org.freedesktop.DBus", "GetId", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
assert(reply); g_variant_unref(reply);
|
||||
assert(g_dbus_connection_emit_signal(bus, NULL, MUTTER_DISPLAY_PATH, MUTTER_DISPLAY,
|
||||
"MonitorsChanged", g_variant_new("()"), NULL));
|
||||
assert(g_dbus_connection_flush_sync(bus, NULL, NULL));
|
||||
/* The test clock is fixed; use a bounded iteration count for delivery. */
|
||||
for (unsigned attempt = 0; attempt < 1000 && !p->display_changed_at; attempt++) {
|
||||
while (g_main_context_iteration(p->context, FALSE)) {}
|
||||
if (!p->display_changed_at) g_usleep(1000);
|
||||
}
|
||||
assert(p->display_changed_at);
|
||||
if (threaded) {
|
||||
assert(!pthread_create(&p->dbus_thread, NULL, run_dbus, p));
|
||||
p->dbus_started = 1;
|
||||
}
|
||||
assert(g_dbus_connection_emit_signal(bus, NULL, MUTTER_DISPLAY_PATH, MUTTER_DISPLAY,
|
||||
"MonitorsChanged", g_variant_new("()"), NULL));
|
||||
assert(g_dbus_connection_flush_sync(bus, NULL, NULL));
|
||||
uu_portal_close(p); /* Queued signals and immediate loop shutdown must be safe. */
|
||||
}
|
||||
g_dbus_connection_close_sync(bus, NULL, NULL);
|
||||
g_object_unref(bus);
|
||||
g_test_dbus_down(test_bus);
|
||||
g_object_unref(test_bus);
|
||||
}
|
||||
|
||||
static int cancel_immediately(void *data) { return *(const int *)data; }
|
||||
struct cancel_later { int *cancelled; int polls; };
|
||||
@@ -282,6 +424,9 @@ int main(void) {
|
||||
portal_renegotiation_recovery();
|
||||
portal_renegotiation_event_order_and_healthy_states();
|
||||
portal_changed_physical_format_still_fails();
|
||||
portal_display_change_recovery();
|
||||
portal_display_change_healthy_and_stale();
|
||||
portal_display_subscription_lifecycle();
|
||||
cancellable_waits();
|
||||
clipboard_bounds();
|
||||
capture_with_optional_geometry(0);
|
||||
|
||||
Reference in new issue
Block a user