Compare commits

..
2 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 1b10a22c8c Release v0.2.0
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-17 15:41:51 +08:00
809ce1697d Add the experimental native viewer (uuremote-viewer) (#36)
* Add the experimental native viewer (uuremote-viewer)

A Linux viewer/controller for UU Remote hosts, built separately with
--features native-viewer,viewer-sdl; the host build and behaviour are
unchanged.

- Cloud join by device and remote assistance by share ID + code (code
  via stdin only), WebRTC offer side, SDL desktop window with ffmpeg CLI
  H.264 decoding, Opus sound, keyboard/mouse, view-only mode, text
  clipboard on TEXT_DATA_CHANNEL.
- Tools: file browser/transfer (zero- and one-based download blocks),
  terminal and terminal session list, port mapping (127.0.0.1 only),
  reboot/shutdown; tools reuse the desktop peer while one is open.
- GTK launcher with device list and tool windows.
- CI builds and tests the viewer; release tarballs include it.

Logs carry field numbers, sizes and states only.

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

* ci: install the ffmpeg CLI for the viewer audio tests

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

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-17 15:41:20 +08:00
41 changed files with 5355 additions and 9 deletions

No files matched your search

+14
View File
@@ -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:
+4 -2
View File
@@ -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"
+6 -2
View File
@@ -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
View File
@@ -2050,6 +2050,30 @@ dependencies = [
"untrusted 0.9.0",
]
[[package]]
name = "sdl2"
version = "0.37.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b498da7d14d1ad6c839729bd4ad6fc11d90a57583605f3b4df2cd709a9cd380"
dependencies = [
"bitflags 1.3.2",
"lazy_static",
"libc",
"sdl2-sys",
]
[[package]]
name = "sdl2-sys"
version = "0.37.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "951deab27af08ed9c6068b7b0d05a93c91f0a8eb16b6b816a5e73452a43521d3"
dependencies = [
"cfg-if",
"libc",
"pkg-config",
"version-compare",
]
[[package]]
name = "sdp"
version = "0.6.2"
@@ -2717,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.1.31"
version = "0.2.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
View File
@@ -1,7 +1,8 @@
[package]
name = "uu-remote-linux"
version = "0.1.31"
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"
+37 -1
View File
@@ -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.
+33 -1
View File
@@ -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 -1
View File
@@ -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() {
+494
View File
@@ -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); }
+715
View File
@@ -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;
}
+20
View File
@@ -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.**
+334
View File
@@ -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)));
}
}
+45
View File
@@ -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");
}
}
+170
View File
@@ -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);
}
}
+277
View File
@@ -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();
}
}
+36
View File
@@ -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)
}
}
+61
View File
@@ -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(); } }
+35
View File
@@ -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);}
}
+94
View File
@@ -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());
}
}
+138
View File
@@ -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));
}
}
+37
View File
@@ -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("")),"远端设备");
}
}
+70
View File
@@ -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));
}
}
}
+315
View File
@@ -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");
}
+156
View File
@@ -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");
}
}
+87
View File
@@ -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;}
}
+138
View File
@@ -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) }
+289
View File
@@ -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");
}
+73
View File
@@ -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
}
+178
View File
@@ -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
}
}
+58
View File
@@ -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();}}
+80
View File
@@ -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(())
}
+148
View File
@@ -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()
}
+152
View File
@@ -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());
}
}
+194
View File
@@ -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(),&copy).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();
}
+240
View File
@@ -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();
}
}
+217
View File
@@ -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");
}
}
+183
View File
@@ -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,&params,&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));
}
}
+177
View File
@@ -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
}
+1
View File
@@ -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
View File
@@ -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":[]}
+1
View File
@@ -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}]}