Compare commits

..
12 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 ff84aa4fd2 Support true color (H.264 4:4:4) and log viewer decoder capabilities
The viewer sends CaptureSettingRequest field 7 = 3 when 真彩 is enabled
(ff_capture_setting versions are cumulative, so our version 4 already
implies chroma sampling). Encode yuv444p with NVENC high444p / x264
high444 and report the encoded chroma in CaptureSettingSync; VAAPI and
inproc stay 4:2:0. Log ConnectOptions decoder_cap_list (numbers only).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 23:58:54 +08:00
VallierDevandClaude Opus 5.5 4df95ea271 Release v0.1.14
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 23:12:28 +08:00
cnetst be7dba4669 Fix black terminal after reconnecting with a large scrollback (#14) 2026-10-15 23:12:09 +08:00
VallierDevandClaude Opus 5.5 61dfb2edf5 Release v0.1.13
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 23:02:08 +08:00
VallierDevandClaude Opus 5.5 d4483e2bbd Tray icon (AppIndicator via dlopen, GtkStatusIcon fallback); show restarts the service
Tray menu: open main window, allow switch (synced), quit. Quit stops the
systemd user unit (found via /proc/self/cgroup) so Restart=always does not
bring it back; `uuremote-server show` starts the installed unit when the host
is not running. SIGUSR1 handler is installed before the pid file is written.
Verified on Ubuntu 24.04 GNOME (X11).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 23:02:08 +08:00
VallierDevandClaude Opus 5.5 0de74566a9 README: separate the Linux login screen limit from UU account sign-in
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:54:27 +08:00
VallierDevandClaude Opus 5.5 edee53a022 Release v0.1.12
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:50:24 +08:00
VallierDevandClaude Opus 5.5 fd3caf0d15 Mac shortcuts for macOS viewers (Cmd held back, terminal-aware)
With the viewer option 「使用 macOS 快捷键」 off, Cmd arrives as VK_LWIN
(verified: Cmd 0x5B, Option 0xA4, Ctrl 0xA2; controller_platform 4 = macOS).
For macOS controllers Cmd+C/V/A/F/X/Z become Ctrl+key, Cmd+C/V become
Ctrl+Shift+C/V in a focused terminal, Ctrl+C keeps interrupting; other
combos and Cmd alone stay Super. Verified with the official Mac viewer.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:50:24 +08:00
VallierDevandClaude Opus 5.5 ce7906510f Test: read the assist PTY banner until complete (flaky single read on CI)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:26:35 +08:00
VallierDevandClaude Opus 5.5 73462ee57f Release v0.1.11
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:22:08 +08:00
VallierDevandClaude Opus 5.5 bc683b3cef README: screenshot of the new main window (ID, code and account redacted)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:19:44 +08:00
VallierDevandClaude Opus 5.5 94039c092a Remote assistance (experimental) and unified host window
Like the official client: share a device ID + verification code; the other
person connects from 开始协助. Guest identity before sign-in, account identity
after (same share ID). One GTK window: 本设备 (allow switch, ID/code with copy,
verification modes incl. custom code, rotation schedule, copy & share) and
账号 (QR before sign-in, masked account + sign out after). Logged-in hosts keep
the window hidden; `uuremote-server show` / the desktop launcher opens it.
App icon and .desktop entry in contrib/desktop.

Protocol from the official Windows lite host; guest flow, wrong-code rejection,
rotation, switching off, sign-in/sign-out verified with the official Mac
viewer. Signed-in assistance from another account is not yet verified.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 22:17:25 +08:00
28 changed files with 2006 additions and 425 deletions

No files matched your search

+27 -2
View File
@@ -106,12 +106,14 @@ viewer does not reconnect them automatically.
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent |
| `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) |
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
| `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset: NVENC→CPU only if `/proc/driver/nvidia/version` or `/dev/nvidia0` exists, else CPU (#10) |
| `UU_FFMPEG_ROOT` | FFmpeg prefix (`bin/ffmpeg`, libs in `lib/x86_64-linux-gnu`) |
| `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) |
| `UU_LOGIN_WINDOW=0` | don't auto-open the login window |
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. The config is re-read
every 60 s.
@@ -138,7 +140,7 @@ every 60 s.
| `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal |
| `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 |
| `c_engine/login_window.c` | GTK3 login window |
| `src/assist.rs`, `c_engine/assist_window.c` | remote assistance (guest + account) and the unified GTK main window (assist + account/QR card) |
Diagnostic subcommands: `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
`desktop-probe [new.png]`, `desktop-video-probe`, `wayland-input-probe`, `clipboard-acceptance`,
@@ -162,7 +164,13 @@ started a second full host server instead, so check that a subcommand exists in
- CaptureSettingRequest: field 1 is an **fps option index** (1=30, 2=60, 3=90); the real frame rate is
field 18 `fpsCount`. Field 2 quality: 1 Fast, 2 General (高清 2M), 3 HD (超清 8M), 4 Bluray (原画 20M),
5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote).
Reply `RpcResponse{2 CaptureSettingResponse{}}` (no errors = applied) and send Message 25 CaptureSettingSync.
Field 7 `chorma_format` (ChromaFormat 1 = 4:2:0, 3 = 4:4:4) is sent when 真彩 is toggled; ff_capture_setting versions
are cumulative (3 CHROMA_SAMPLING, 4 CUSTOM_BITRATE, 5 DPI_SCALE, 6 HDR). 4:4:4 = NVENC `high444p` / x264 `high444`
with `yuv444p`; VAAPI and inproc stay 4:2:0.
Reply `RpcResponse{2 CaptureSettingResponse{}}` (no errors = applied) and send Message 25 CaptureSettingSync
(field 3 = the chroma actually encoded).
- ConnectOptions field 4 `decoder_cap_list` = DecoderCap {1 fps, 2 codec_type (1 H264, 2 H265), 3 width, 4 height,
5 chroma_format}. The Mac viewer lists H.264 and H.265, each 4:2:0 and 4:4:4, up to 3840x2160@120.
- SystemMetrics (Message 13): GeneralMetric `2 system_sound_support` is an enum, **2 = supported** (1 = not
supported); SettingMetric 1 keep_mute, 2 mute_permanent, 3 auto_lock, 5 file_transfer_save_location,
8/9/10 permission states (2 = allow).
@@ -189,6 +197,23 @@ started a second full host server instead, so check that a subcommand exists in
`/qrcode/login/status` (1 wait, 2 scanned, 4 confirmed); `/login/by_qrcode` → user token. QR expires after
~5 min with HTTP 400 code 1190 (not fatal: generate a new one).
- Remote assistance (recipient side), live-verified with the official Mac viewer; protocol from the official
Windows lite host (GameViewerLite: GameViewerServer + GameViewerLiteInner). Guest (not signed in) and account
identities use parallel endpoints:
| step | guest | signed in |
|---|---|---|
| identity | register the Windows device, then `POST /api/v1/guest/create` (422/1001 if unregistered) | account token |
| room | `POST /api/v1/guest/room/create` **before** share info (else 400/2004) | the host's own room |
| ID + code owner | `POST /api/v1/guest/share/info` → `connect_id` | `GET /api/v1/device/share/info` (POST = 405) |
| withdraw | `POST /api/v1/guest/share/cancel` | `POST /api/v1/device/share/cancel` |
Cloud pushes arrive as `bmsg_push`: `get_control_mode {control_id}` → `POST …/room/share/upload_control_mode`
`{control_id, allow_control, control_mode: by_password}` (guest v1, account v2); the viewer only asks for the code
after this. `remote_control {control_id, salt}` → `upload/sign` (guest v1) / `upload_sign` (account v2)
`{control_id, can_remote_control, sign: sha256hex(salt+code), backup_sign}`. Temporary-only: sign=temp code,
empty backup; both: backup=custom; custom-only: sign=custom. The share ID stays the same across sign-in/out.
Same-account devices cannot assist each other (viewer: 无法对同账号的设备发起远程协助). On a signed-in host never gate
the owner's offers on the assist switch; the cloud already gates assist peers.
## 8. Known pitfalls
- webrtc-rs `Sample.duration` sets the gap to the **next** frame. FFmpeg 6.1 rejects `-r` together with
Generated
+1 -1
View File
@@ -2649,7 +2649,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.1.10"
version = "0.1.15"
dependencies = [
"base64 0.22.1",
"bytes",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.1.10"
version = "0.1.15"
edition = "2021"
authors = ["uu-remote-linux contributors"]
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
+39 -5
View File
@@ -12,7 +12,7 @@
> If NetEase considers this project infringing or inappropriate, please DM me on X
> **[@ai_fengshou](https://x.com/ai_fengshou)** and I will take it down right away.
<p align="center"><img src="docs/images/login-window.png" width="560" alt="QR login window on the Linux host"></p>
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Host main window: remote assistance and account"></p>
<p align="center"><sub>The QR login window shown on first run (QR code blurred). The UI is in Chinese, like the official app.</sub></p>
<!-- Screenshot placeholder: the Linux desktop controlled from the official client. Take your own
@@ -31,10 +31,11 @@
| Feature | Notes |
|---|---|
| QR login | GTK login window (or a terminal QR code with `login --no-gui`); expired codes refresh automatically; the service opens the login window by itself when credentials are missing or expired |
| Main window and QR login | One window with "This device" (remote assistance) and "Account": a QR code before sign-in, the account and a sign-out button after; `login --no-gui` prints the QR in a terminal |
| Remote assistance (experimental) | Like the official client: share the **device ID + verification code**; the other person enters them under 开始协助 in UU Remote. Works before sign-in (guest identity) and after; see below |
| Remote desktop | H.264 video, NVENC hardware encoding on NVIDIA GPUs, libx264 otherwise; the viewer draws its local pointer, so there is no double cursor |
| Mouse / keyboard | Absolute and relative motion, clicks, wheel, keys; no spurious key repeat on high-latency links; optional uinput virtual devices on Wayland (layout independent, see below) |
| Terminal shortcuts | Mac viewers send both Cmd and Ctrl as Ctrl. In a focused terminal window Ctrl+V / Cmd+V become Ctrl+Shift+V (paste); Ctrl+C always interrupts, copy with Cmd+Shift+C (X11) |
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; "other resolutions" are scaled by the encoder, the host monitor is left untouched |
@@ -87,13 +88,13 @@ mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI
| Feature | Status |
|---|---|
| Switching between multiple monitors | In progress |
| True color (4:4:4) | Not implemented; not declared in the handshake, so the client does not enable it |
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; VAAPI and `inproc-av` stay 4:2:0 and report that to the client |
| HDR | Not implemented |
| Super screen / virtual display | Not implemented |
| Privacy screen on the host | Not implemented |
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) |
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
| Access before login (greeter / no user logged in) | The greeter cannot be controlled; without a logged-in user use headless mode or a virtual desktop (see below) |
| 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 |
@@ -180,6 +181,37 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
`uaccess` grants access only to the user sitting at the machine. `UU_INPUT_BACKEND=uinput|native` forces a backend.
X11 keeps XTest by default because it handles held keys correctly on high-latency links.
## Remote assistance and the main window (experimental)
As in the official client, this host shows a **device ID** and a **verification code**; whoever you give them to can
connect from 开始协助 (remote assistance) in UU Remote.
- **Not signed in**: the main window opens at start, offers remote assistance as a guest and shows the sign-in QR code.
Signing in switches to account mode automatically.
- **Signed in**: the host is in your device list and remote assistance keeps working (same device ID). A background
service keeps the window hidden; open it with `uuremote-server show` or the "UU Remote Linux Host" launcher.
Closing the window only hides it.
- **Tray icon**: a background host shows a tray icon with Open main window, the allow switch and Quit. GNOME needs
the AppIndicator extension (bundled on Ubuntu); Xfce / Cinnamon / KDE work as is. Quit stops `uuremote-native.service`;
the launcher starts it again.
- **Settings** (as in the official client): allow switch (off by default); verification by temporary code, custom code
(8–16 letters and digits) or either; temporary code rotation after each session / hourly / 12 h / 24 h / never;
copy buttons for the ID and the code. Stored in the 0600 config.
- The code is only shown in the local window, never logged. Without a desktop, `uuremote-server assist` shows it on the
terminal (`allow` / `deny` / `reset` / `mode …` / `refresh …` / `off`).
- **Security**: the ID and code give full control (desktop, files, terminal). Share them only with people you trust.
Optional launcher icon:
```sh
install -Dm644 contrib/desktop/uu-remote-linux.svg ~/.local/share/icons/hicolor/scalable/apps/uu-remote-linux.svg
install -Dm644 contrib/desktop/uu-remote-linux.desktop ~/.local/share/applications/uu-remote-linux.desktop
```
Verified with the official Mac viewer: guest connections, wrong-code rejection, code rotation, switching assistance off,
signing in and out. **Remote assistance while signed in has not yet been tested from a different account** (devices of
the same account cannot assist each other, an official restriction).
## Servers without a monitor
**Headless mode** (terminal, file transfer and port mapping only): add `Environment=UU_DESKTOP_BACKEND=none` to the
@@ -220,6 +252,8 @@ Common environment variables:
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset: NVENC only when an NVIDIA driver is loaded, else CPU |
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing |
| `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) |
+29 -5
View File
@@ -10,7 +10,7 @@
> 这是个人兴趣项目,**与网易无关,也不是官方客户端**。如果网易认为本项目侵权或有不妥,
> 请在推特私信我 **[@ai_fengshou](https://x.com/ai_fengshou)**,我会第一时间自行下架。
<p align="center"><img src="docs/images/login-window.png" width="560" alt="Linux 主机扫码登录窗口"></p>
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p>
<p align="center"><sub>首次运行时弹出的扫码登录窗口(二维码已打码)</sub></p>
<!-- 截图占位:在官方客户端里远控 Linux 桌面的效果图。请自行截图并去掉账号、设备名等信息后放到
@@ -27,10 +27,11 @@
| 功能 | 说明 |
|---|---|
| 扫码登录 | GTK 登录窗口(或 `login --no-gui` 终端二维码);二维码过期自动刷新;登录凭证失效时服务会自动弹出登录窗口 |
| 主窗口与扫码登录 | 一个窗口包含「本设备」(远程协助)和「账号」两部分:未登录时显示扫码二维码,登录后显示账号并可退出登录;也可用 `login --no-gui` 在终端扫码 |
| 远程协助(实验性) | 像官方客户端一样,把**设备 ID + 验证码**发给别人,对方在 UU「开始协助」里输入即可连接;登录前(访客身份)和登录后都能用,见下文 |
| 远程桌面 | H.264 视频,NVIDIA 显卡用 NVENC 硬件编码,否则用 libx264;查看端绘制本地鼠标,不会出现双光标 |
| 鼠标 / 键盘 | 绝对/相对移动、点击、滚轮、按键;修复了网络延迟导致的按键连发;Wayland 下可用 uinput 虚拟键鼠(不依赖键盘布局,见下文) |
| 终端快捷键 | Mac 控制端的 Cmd 和 Ctrl 到被控端都是 Ctrl。焦点在终端窗口时,Ctrl+V / Cmd+V 自动转成 Ctrl+Shift+V 粘贴;Ctrl+C 始终是中断,复制请用 Cmd+Shift+C(X11) |
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
| 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;「其他分辨率」由编码器缩放,不改动主机显示器 |
@@ -73,13 +74,13 @@ Wayland 下的限制:只支持单屏、固定分辨率;Hyprland 原生后端
| 功能 | 状态 |
|---|---|
| 多显示器切换 | 开发中 |
| 真彩(4:4:4) | 未实现,握手时不声明,客户端不会启用 |
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;VAAPI 和 `inproc-av` 管线仍为 4:2:0,并如实回报给客户端 |
| HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 未实现 |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| 登录前(登录界面 / 无人登录)访问 | 不支持控制登录界面;没有人登录时可以用无头模式或虚拟桌面(见下文) |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
| 作为控制端(在 Linux 上控制别的电脑) | 不在本项目范围 |
@@ -164,6 +165,27 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
`uaccess` 只把权限给当前坐在这台机器前的登录用户。`UU_INPUT_BACKEND=uinput|native` 可以强制指定后端。
X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放的按键。
## 远程协助与主窗口(实验性)
和官方客户端的「远程协助」一样:本机显示**设备 ID** 和**验证码**,把它们发给信任的人,对方在 UU 远程的「开始协助」里输入即可控制本机。
- **未登录**:启动后直接显示主窗口,用访客身份提供远程协助,同时显示扫码登录二维码。扫码登录后自动切换到账号模式。
- **已登录**:本机出现在你的设备列表里,可以直接连;远程协助也照常可用(同一设备 ID)。服务在后台运行时窗口默认隐藏,用 `uuremote-server show` 或应用菜单里的「UU 远程 Linux 主机」打开。关闭窗口只是隐藏,不会停止服务。
- **托盘图标**:后台运行时顶栏/任务栏有托盘图标,菜单里可以「打开主窗口」、切换「允许他人远程协助」、「退出」。GNOME 需要 AppIndicator 扩展(Ubuntu 自带),Xfce / Cinnamon / KDE 直接可用。从托盘退出会停止 `uuremote-native.service`,之后从应用菜单打开会重新启动服务。
- **设置**(与官方一致):「允许他人远程协助」开关(默认关闭);验证方式:仅临时验证码 / 仅自定义验证码(8–16 位,需同时包含字母和数字) / 两种都可以;临时验证码自动刷新:每次远控结束 / 每小时 / 每 12 小时 / 每 24 小时 / 不刷新;ID 和验证码旁各有「复制」按钮。设置保存在本机配置文件(0600)。
- **只在本机窗口显示**:验证码不会写进日志。没有图形界面时,单独运行 `uuremote-server assist` 会在终端显示(`allow` / `deny` / `reset` / `mode …` / `refresh …` / `off`)。
- **安全**:拿到 ID 和验证码的人可以完全控制这台电脑(桌面、文件、终端)。只发给信任的人,用完关掉开关或刷新验证码。
安装应用菜单图标(可选):
```sh
install -Dm644 contrib/desktop/uu-remote-linux.svg ~/.local/share/icons/hicolor/scalable/apps/uu-remote-linux.svg
install -Dm644 contrib/desktop/uu-remote-linux.desktop ~/.local/share/applications/uu-remote-linux.desktop
```
验证情况:访客身份下的连接、错误验证码拒绝、用完换码、关闭后不可连接、登录与退出登录的切换,已用官方 Mac 客户端实测通过。
**登录状态下的远程协助尚未用另一个账号实测**(同一账号的设备不能互相发起远程协助,这是官方限制)。
## 没有显示器的服务器
**无头模式**:只要终端、文件传输和端口映射,不需要图形界面。在服务里加 `Environment=UU_DESKTOP_BACKEND=none`,
@@ -203,6 +225,8 @@ systemctl --user restart uuremote-native.service
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。
+2 -2
View File
@@ -2,7 +2,7 @@ fn main() {
println!("cargo:rerun-if-changed=c_engine/portal_clipboard.inc");
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/login_window.c");
println!("cargo:rerun-if-changed=c_engine/assist_window.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 +36,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/login_window.c").flag_if_supported("-Wno-deprecated-declarations");
build.file("c_engine/assist_window.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() {
+644
View File
@@ -0,0 +1,644 @@
// GTK3 window for guest remote assistance (`uuremote-server assist`). Layout follows the official
// "本设备" card (allow switch, device ID, temporary code with show/hide, copy & share) without any
// NetEase assets. GTK runs on its own thread; Rust pushes state through g_idle_add and polls the
// user's commands. The code is only drawn in this local window and copied on explicit request.
#include <gtk/gtk.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
static const char *CSS =
"window { background-color: #f5f6f8; }\n"
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
".card { background-color: #ffffff; border-radius: 10px; border: 1px solid #e5e7eb; }\n"
".heading { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
".key { font-size: 14px; color: #4b5563; }\n"
".big { font-size: 32px; font-weight: 800; color: #111111; }\n"
".note { font-size: 13px; color: #9ca3af; }\n"
".hint { font-size: 13px; color: #6b7280; }\n"
".footer { font-size: 12px; color: #9ca3af; }\n"
"button.flat { padding: 4px 8px; }\n"
"button.share { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db;"
" border-radius: 6px; padding: 6px 14px; font-size: 14px; }\n"
"separator { background-color: #e5e7eb; min-height: 1px; }\n"
".user { font-size: 22px; font-weight: 700; color: #111111; }\n"
".status { font-size: 13px; color: #2f6bff; }\n"
".status.ok { color: #16a34a; }\n"
".status.error { color: #dc2626; }\n";
enum { CMD_NONE = 0, CMD_ALLOW = 1, CMD_DENY = 2, CMD_RESET = 3, CMD_STOP = 4, CMD_VERIFY = 5, CMD_REFRESH = 6, CMD_CUSTOM = 7, CMD_LOGOUT = 8, CMD_QUIT = 9 };
enum { VERIFY_TEMPORARY = 0, VERIFY_CUSTOM = 1, VERIFY_BOTH = 2 };
typedef struct { char *id; char *code; int allowed, verify, refresh, has_custom; } State;
typedef struct { int cmd; char arg[40]; } Cmd;
// Small FIFO so quick successive UI actions (e.g. set code, then mode) are all delivered.
static Cmd queue[16];
static int q_head, q_len;
static pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
static atomic_int closed;
static pthread_t ui_thread;
static int ui_started, init_state; // 0 pending, 1 ok, -1 failed
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
static GtkWidget *window, *allow_switch, *id_label, *code_label, *eye_button, *share_button, *hint_label, *verify_combo, *note_label;
static GtkWidget *refresh_items[5], *footer_label;
// Account card: QR login before sign-in, user info (+ logout) after.
static GtkWidget *assist_card, *account_card, *account_stack, *qr_stack, *qr_image, *login_status, *user_label;
static int show_assist = 1, show_account;
// Tray (host service only): AppIndicator via dlopen (no build dependency), else GtkStatusIcon.
static GtkWidget *tray_menu, *tray_allow;
static int suppress_tray;
static int cur_verify, cur_refresh, cur_has_custom;
static char current_id[64], current_code[64];
static int code_visible = 1, suppress_switch, start_hidden, close_hides;
static GtkWidget *label(const char *text, const char *cls) {
GtkWidget *l = gtk_label_new(text);
gtk_style_context_add_class(gtk_widget_get_style_context(l), cls);
gtk_widget_set_halign(l, GTK_ALIGN_START);
return l;
}
static void post_arg(int cmd, const char *arg) {
pthread_mutex_lock(&q_lock);
if (q_len < 16) {
Cmd *c = &queue[(q_head + q_len) % 16];
c->cmd = cmd; g_strlcpy(c->arg, arg ? arg : "", sizeof c->arg); q_len++;
}
pthread_mutex_unlock(&q_lock);
}
static void post(int cmd) { post_arg(cmd, NULL); }
static void post_int(int cmd, int v) { char b[8]; g_snprintf(b, sizeof b, "%d", v); post_arg(cmd, b); }
// 8-16 ASCII letters/digits including both, as the official custom code dialog requires.
static int valid_custom(const char *c) {
size_t n = strlen(c); int alpha = 0, digit = 0;
if (n < 8 || n > 16) return 0;
for (size_t i = 0; i < n; i++) {
if (g_ascii_isalpha(c[i])) alpha = 1; else if (g_ascii_isdigit(c[i])) digit = 1; else return 0;
}
return alpha && digit;
}
static void on_custom_changed(GtkEditable *e, gpointer ok) {
gtk_widget_set_sensitive(GTK_WIDGET(ok), valid_custom(gtk_entry_get_text(GTK_ENTRY(e))));
}
// Returns 1 when a new custom code was entered and posted.
static int ask_custom_code(void) {
GtkWidget *d = gtk_dialog_new_with_buttons("设置自定义验证码", GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"取消", GTK_RESPONSE_CANCEL, NULL);
GtkWidget *ok = gtk_dialog_add_button(GTK_DIALOG(d), "确定", GTK_RESPONSE_OK);
gtk_widget_set_sensitive(ok, FALSE);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(d));
gtk_container_set_border_width(GTK_CONTAINER(area), 16);
gtk_box_set_spacing(GTK_BOX(area), 8);
GtkWidget *entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), 16);
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(entry), "请输入自定义验证码");
g_signal_connect(entry, "changed", G_CALLBACK(on_custom_changed), ok);
gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(area), label("8-16 位,需同时包含字母和数字;不会自动刷新,请妥善保管", "note"), FALSE, FALSE, 0);
gtk_widget_show_all(d);
int done = 0;
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) {
const char *code = gtk_entry_get_text(GTK_ENTRY(entry));
if (valid_custom(code)) { post_arg(CMD_CUSTOM, code); done = 1; }
}
gtk_widget_destroy(d);
return done;
}
static int suppress_combo;
static void on_verify_changed(GtkComboBox *c, gpointer d) {
(void)d;
if (suppress_combo) return;
int v = gtk_combo_box_get_active(c);
if (v != VERIFY_TEMPORARY && !cur_has_custom && !ask_custom_code()) {
suppress_combo = 1; gtk_combo_box_set_active(c, cur_verify); suppress_combo = 0;
return;
}
post_int(CMD_VERIFY, v);
}
static void on_set_custom(GtkButton *b, gpointer d) { (void)b; (void)d; ask_custom_code(); }
static int suppress_refresh;
static void on_refresh_item(GtkCheckMenuItem *item, gpointer data) {
if (suppress_refresh || !gtk_check_menu_item_get_active(item)) return;
post_int(CMD_REFRESH, GPOINTER_TO_INT(data));
}
static void on_refresh_now(GtkMenuItem *i, gpointer d) { (void)i; (void)d; post(CMD_RESET); }
static const char *REFRESH_NOTES[5] = { "每次远控结束刷新", "每小时自动刷新", "每 12 小时自动刷新", "每 24 小时自动刷新", "不自动刷新" };
static void render_code(void) {
if (!code_label) return;
gtk_label_set_text(GTK_LABEL(code_label), current_code[0] ? (code_visible ? current_code : "********") : "--------");
gtk_button_set_label(GTK_BUTTON(eye_button), code_visible ? "隐藏" : "显示");
}
static void copy_text(const char *text, const char *hint) {
if (!text || !text[0]) return;
gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), text, -1);
gtk_label_set_text(GTK_LABEL(hint_label), hint);
}
// The ID is copied without the display spaces so it pastes straight into the viewer's ID field.
static void on_copy_id(GtkButton *b, gpointer d) {
(void)b; (void)d;
char digits[64]; size_t n = 0;
for (const char *p = current_id; *p && n + 1 < sizeof digits; p++) if (*p != ' ') digits[n++] = *p;
digits[n] = 0;
copy_text(digits, "已复制设备 ID");
}
static void on_copy_code(GtkButton *b, gpointer d) { (void)b; (void)d; copy_text(current_code, "已复制验证码,请只发给信任的人"); }
static void on_eye(GtkButton *b, gpointer d) { (void)b; (void)d; code_visible = !code_visible; render_code(); }
static void on_share(GtkButton *b, gpointer d) {
(void)b; (void)d;
if (!current_id[0] || !current_code[0]) return;
char *text = g_strdup_printf("UU 远程协助\n设备 ID:%s\n验证码:%s", current_id, current_code);
gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), text, -1);
g_free(text);
gtk_label_set_text(GTK_LABEL(hint_label), "已复制设备 ID 和验证码,请只发给信任的人");
}
static gboolean on_switch(GtkSwitch *s, gboolean state, gpointer d) {
(void)s; (void)d;
if (!suppress_switch) post(state ? CMD_ALLOW : CMD_DENY);
return FALSE;
}
// Host service: the close button only hides the window (assistance keeps its own on/off switch).
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) {
(void)e; (void)d;
if (!close_hides) return FALSE;
gtk_widget_hide(w);
return TRUE;
}
static void on_destroy(GtkWidget *w, gpointer d) {
(void)w; (void)d;
window = code_label = NULL;
atomic_store(&closed, 1);
post(CMD_STOP);
gtk_main_quit();
}
static gboolean draw_avatar(GtkWidget *w, cairo_t *cr, gpointer d) {
(void)w; (void)d;
double s = 64;
cairo_arc(cr, s / 2, s / 2, s / 2 - 1, 0, 2 * G_PI);
cairo_set_source_rgb(cr, 0.84, 0.90, 1.0); cairo_fill_preserve(cr);
cairo_set_source_rgb(cr, 0.36, 0.55, 1.0); cairo_set_line_width(cr, 2); cairo_stroke(cr);
cairo_save(cr);
cairo_arc(cr, s / 2, s / 2, s / 2 - 2, 0, 2 * G_PI); cairo_clip(cr);
cairo_set_source_rgb(cr, 0.27, 0.51, 1.0);
cairo_arc(cr, s / 2, s * 0.38, s * 0.16, 0, 2 * G_PI); cairo_fill(cr);
cairo_arc(cr, s / 2, s * 0.92, s * 0.32, G_PI, 2 * G_PI); cairo_fill(cr);
cairo_restore(cr);
return TRUE;
}
static void on_logout(GtkButton *b, gpointer d) {
(void)b; (void)d;
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
"退出登录后,本机将从你的设备列表中下线,远程协助会改用访客身份。确定退出吗?");
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
post(CMD_LOGOUT);
gtk_label_set_text(GTK_LABEL(user_label), "正在退出登录…");
}
gtk_widget_destroy(dlg);
}
static GtkWidget *build_account_card(void) {
GtkWidget *card = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(header), 20);
gtk_box_pack_start(GTK_BOX(header), label("账号", "heading"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
account_stack = gtk_stack_new();
gtk_stack_set_transition_type(GTK_STACK(account_stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);
gtk_stack_set_vhomogeneous(GTK_STACK(account_stack), FALSE); // user page is shorter than the QR page
// Not signed in: QR code + guidance.
GtkWidget *qr_page = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 24);
gtk_container_set_border_width(GTK_CONTAINER(qr_page), 20);
qr_stack = gtk_stack_new();
gtk_widget_set_size_request(qr_stack, 180, 180);
GtkWidget *loading = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_valign(loading, GTK_ALIGN_CENTER);
GtkWidget *spinner = gtk_spinner_new();
gtk_spinner_start(GTK_SPINNER(spinner));
gtk_box_pack_start(GTK_BOX(loading), spinner, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(loading), label("正在获取二维码…", "note"), FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(qr_stack), loading, "loading");
qr_image = gtk_image_new();
gtk_stack_add_named(GTK_STACK(qr_stack), qr_image, "qr");
gtk_box_pack_start(GTK_BOX(qr_page), qr_stack, FALSE, FALSE, 0);
GtkWidget *qr_text = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_valign(qr_text, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(qr_text), label("扫码登录", "heading"), FALSE, FALSE, 0);
GtkWidget *cap = label("请使用网易 UU 远程 App 扫一扫登录。\n登录后本机会出现在你的设备列表中,可直接远程控制;\n远程协助在登录前后都可以使用。", "hint");
gtk_label_set_xalign(GTK_LABEL(cap), 0);
gtk_box_pack_start(GTK_BOX(qr_text), cap, FALSE, FALSE, 0);
login_status = label("", "status");
gtk_label_set_line_wrap(GTK_LABEL(login_status), TRUE);
gtk_box_pack_start(GTK_BOX(qr_text), login_status, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(qr_page), qr_text, TRUE, TRUE, 0);
gtk_stack_add_named(GTK_STACK(account_stack), qr_page, "qr");
// Signed in: avatar + account name + logout.
GtkWidget *user_page = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 16);
gtk_container_set_border_width(GTK_CONTAINER(user_page), 20);
GtkWidget *avatar = gtk_drawing_area_new();
gtk_widget_set_size_request(avatar, 64, 64);
gtk_widget_set_valign(avatar, GTK_ALIGN_CENTER);
g_signal_connect(avatar, "draw", G_CALLBACK(draw_avatar), NULL);
gtk_box_pack_start(GTK_BOX(user_page), avatar, FALSE, FALSE, 0);
GtkWidget *user_text = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_set_valign(user_text, GTK_ALIGN_CENTER);
user_label = label("", "user");
gtk_box_pack_start(GTK_BOX(user_text), user_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_text), label("已登录 · 本机已出现在你的设备列表中", "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_page), user_text, TRUE, TRUE, 0);
GtkWidget *logout = gtk_button_new_with_label("退出登录");
gtk_style_context_add_class(gtk_widget_get_style_context(logout), "share");
gtk_widget_set_valign(logout, GTK_ALIGN_CENTER);
g_signal_connect(logout, "clicked", G_CALLBACK(on_logout), NULL);
gtk_box_pack_end(GTK_BOX(user_page), logout, FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(account_stack), user_page, "user");
gtk_box_pack_start(GTK_BOX(card), account_stack, FALSE, FALSE, 0);
return card;
}
static void present_window(void) { if (window) { gtk_widget_show(window); gtk_window_present(GTK_WINDOW(window)); } }
static void on_tray_open(GtkMenuItem *i, gpointer d) { (void)i; (void)d; present_window(); }
static void on_tray_allow(GtkCheckMenuItem *i, gpointer d) {
(void)d;
if (!suppress_tray) post(gtk_check_menu_item_get_active(i) ? CMD_ALLOW : CMD_DENY);
}
static void on_tray_quit(GtkMenuItem *i, gpointer d) {
(void)i; (void)d;
GtkWidget *dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
"退出后本机将下线:设备列表和远程协助都无法连接,直到再次启动。确定退出吗?");
gtk_window_set_title(GTK_WINDOW(dlg), "UU 远程 Linux 主机");
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) post(CMD_QUIT);
gtk_widget_destroy(dlg);
}
static void on_status_activate(GtkStatusIcon *i, gpointer d) { (void)i; (void)d; present_window(); }
static void on_status_menu(GtkStatusIcon *i, guint button, guint time, gpointer d) {
(void)i; (void)button; (void)time; (void)d;
gtk_menu_popup_at_pointer(GTK_MENU(tray_menu), NULL);
}
static void build_tray(void) {
tray_menu = gtk_menu_new();
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口");
g_signal_connect(open, "activate", G_CALLBACK(on_tray_open), NULL);
tray_allow = gtk_check_menu_item_new_with_label("允许他人远程协助");
g_signal_connect(tray_allow, "toggled", G_CALLBACK(on_tray_allow), NULL);
GtkWidget *quit = gtk_menu_item_new_with_label("退出");
g_signal_connect(quit, "activate", G_CALLBACK(on_tray_quit), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), open);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), tray_allow);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new());
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), quit);
gtk_widget_show_all(tray_menu);
const char *icon = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
// StatusNotifierItem (GNOME AppIndicator extension, KDE): libayatana-appindicator3 / libappindicator3.
const char *libs[] = { "libayatana-appindicator3.so.1", "libappindicator3.so.1" };
for (int i = 0; i < 2; i++) {
void *h = dlopen(libs[i], RTLD_LAZY | RTLD_LOCAL);
if (!h) continue;
void *(*ind_new)(const char *, const char *, int) = (void *(*)(const char *, const char *, int))dlsym(h, "app_indicator_new");
void (*set_status)(void *, int) = (void (*)(void *, int))dlsym(h, "app_indicator_set_status");
void (*set_menu)(void *, GtkMenu *) = (void (*)(void *, GtkMenu *))dlsym(h, "app_indicator_set_menu");
void (*set_title)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_title");
if (ind_new && set_status && set_menu) {
void *ind = ind_new("uu-remote-linux", icon, 0 /* APPLICATION_STATUS */);
if (set_title) set_title(ind, "UU 远程 Linux 主机");
set_menu(ind, GTK_MENU(tray_menu));
set_status(ind, 1 /* ACTIVE */);
return; // keep the library loaded for the indicator's lifetime
}
dlclose(h);
}
// XEmbed system tray (Xfce, Cinnamon, MATE...).
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
GtkStatusIcon *status = gtk_status_icon_new_from_icon_name(icon);
gtk_status_icon_set_tooltip_text(status, "UU 远程 Linux 主机");
gtk_status_icon_set_title(status, "UU 远程 Linux 主机");
g_signal_connect(status, "activate", G_CALLBACK(on_status_activate), NULL);
g_signal_connect(status, "popup-menu", G_CALLBACK(on_status_menu), NULL);
G_GNUC_END_IGNORE_DEPRECATIONS
}
static void build_window(void) {
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);
g_object_unref(css);
gtk_window_set_default_icon_name("uu-remote-linux"); // contrib/desktop icon, when installed
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 主机(非官方)");
gtk_window_set_default_size(GTK_WINDOW(window), 760, -1);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
g_signal_connect(window, "destroy", G_CALLBACK(on_destroy), NULL);
GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(root), 24);
gtk_container_add(GTK_CONTAINER(window), root);
GtkWidget *card = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
gtk_box_pack_start(GTK_BOX(root), card, FALSE, FALSE, 0);
assist_card = card;
// Header: 本设备 ... 允许他人远程协助 [switch]
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(header), 20);
gtk_box_pack_start(GTK_BOX(header), label("本设备", "heading"), FALSE, FALSE, 0);
allow_switch = gtk_switch_new();
gtk_widget_set_valign(allow_switch, GTK_ALIGN_CENTER);
g_signal_connect(allow_switch, "state-set", G_CALLBACK(on_switch), NULL);
gtk_box_pack_end(GTK_BOX(header), allow_switch, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), label("允许他人远程协助", "key"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
// Body: ID | code + controls
GtkWidget *body = gtk_grid_new();
gtk_container_set_border_width(GTK_CONTAINER(body), 20);
gtk_grid_set_column_spacing(GTK_GRID(body), 48);
gtk_grid_set_row_spacing(GTK_GRID(body), 6);
gtk_grid_attach(GTK_GRID(body), label("本设备 ID", "key"), 0, 0, 1, 1);
GtkWidget *id_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
id_label = label("获取中…", "big");
gtk_label_set_selectable(GTK_LABEL(id_label), TRUE);
gtk_box_pack_start(GTK_BOX(id_row), id_label, FALSE, FALSE, 0);
GtkWidget *copy_id = gtk_button_new_with_label("复制");
gtk_style_context_add_class(gtk_widget_get_style_context(copy_id), "flat");
gtk_widget_set_valign(copy_id, GTK_ALIGN_CENTER);
g_signal_connect(copy_id, "clicked", G_CALLBACK(on_copy_id), NULL);
gtk_box_pack_start(GTK_BOX(id_row), copy_id, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(body), id_row, 0, 1, 1, 1);
GtkWidget *verify_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(verify_row), label("验证方式:", "key"), FALSE, FALSE, 0);
verify_combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "仅使用临时验证码");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "仅使用自定义验证码");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "同时使用两种验证码");
gtk_combo_box_set_active(GTK_COMBO_BOX(verify_combo), 0);
g_signal_connect(verify_combo, "changed", G_CALLBACK(on_verify_changed), NULL);
gtk_box_pack_start(GTK_BOX(verify_row), verify_combo, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(body), verify_row, 1, 0, 1, 1);
GtkWidget *code_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
code_label = label("--------", "big");
gtk_box_pack_start(GTK_BOX(code_row), code_label, FALSE, FALSE, 0);
eye_button = gtk_button_new_with_label("隐藏");
gtk_style_context_add_class(gtk_widget_get_style_context(eye_button), "flat");
g_signal_connect(eye_button, "clicked", G_CALLBACK(on_eye), NULL);
// Gear menu: 立即刷新 / 自动刷新 ▸ (每次远控结束, 每小时, 每 12 小时, 每 24 小时, 关闭) / 设置自定义验证码
GtkWidget *menu = gtk_menu_new();
GtkWidget *now = gtk_menu_item_new_with_label("立即刷新");
g_signal_connect(now, "activate", G_CALLBACK(on_refresh_now), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), now);
GtkWidget *auto_item = gtk_menu_item_new_with_label("自动刷新");
GtkWidget *sub = gtk_menu_new();
const char *names[5] = { "每次远控结束", "每小时", "每 12 小时", "每 24 小时", "关闭" };
GSList *group = NULL;
for (int i = 0; i < 5; i++) {
refresh_items[i] = gtk_radio_menu_item_new_with_label(group, names[i]);
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(refresh_items[i]));
g_signal_connect(refresh_items[i], "toggled", G_CALLBACK(on_refresh_item), GINT_TO_POINTER(i));
gtk_menu_shell_append(GTK_MENU_SHELL(sub), refresh_items[i]);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(auto_item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), auto_item);
GtkWidget *custom_item = gtk_menu_item_new_with_label("设置自定义验证码…");
g_signal_connect(custom_item, "activate", G_CALLBACK(on_set_custom), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), custom_item);
gtk_widget_show_all(menu);
GtkWidget *gear = gtk_menu_button_new();
gtk_button_set_image(GTK_BUTTON(gear), gtk_image_new_from_icon_name("emblem-system-symbolic", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text(gear, "刷新设置");
gtk_menu_button_set_popup(GTK_MENU_BUTTON(gear), menu);
GtkWidget *copy_code = gtk_button_new_with_label("复制");
gtk_style_context_add_class(gtk_widget_get_style_context(copy_code), "flat");
gtk_widget_set_valign(copy_code, GTK_ALIGN_CENTER);
g_signal_connect(copy_code, "clicked", G_CALLBACK(on_copy_code), NULL);
gtk_widget_set_valign(eye_button, GTK_ALIGN_CENTER);
gtk_widget_set_valign(gear, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(code_row), copy_code, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(code_row), eye_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(code_row), gear, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(body), code_row, 1, 1, 1, 1);
note_label = label(REFRESH_NOTES[0], "note");
gtk_grid_attach(GTK_GRID(body), note_label, 1, 2, 1, 1);
share_button = gtk_button_new_with_label("复制并分享");
gtk_style_context_add_class(gtk_widget_get_style_context(share_button), "share");
gtk_widget_set_valign(share_button, GTK_ALIGN_CENTER);
g_signal_connect(share_button, "clicked", G_CALLBACK(on_share), NULL);
gtk_grid_attach(GTK_GRID(body), share_button, 2, 1, 1, 1);
gtk_box_pack_start(GTK_BOX(card), body, FALSE, FALSE, 0);
hint_label = label("", "hint");
gtk_box_pack_start(GTK_BOX(root), hint_label, FALSE, FALSE, 0);
account_card = build_account_card();
gtk_widget_set_margin_top(account_card, 6);
gtk_box_pack_start(GTK_BOX(root), account_card, FALSE, FALSE, 0);
footer_label = label("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口即停止远程协助", "footer");
gtk_box_pack_end(GTK_BOX(root), footer_label, FALSE, FALSE, 0);
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), "开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行");
render_code();
if (close_hides) build_tray();
gtk_widget_show_all(gtk_bin_get_child(GTK_BIN(window)));
gtk_widget_set_visible(assist_card, show_assist);
gtk_widget_set_visible(hint_label, show_assist);
gtk_widget_set_visible(account_card, show_account);
if (!start_hidden) gtk_widget_show(window);
}
static void *ui_main(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
if (ok) build_window();
pthread_mutex_lock(&init_lock);
init_state = ok ? 1 : -1;
pthread_cond_signal(&init_cond);
pthread_mutex_unlock(&init_lock);
if (ok) gtk_main();
else atomic_store(&closed, 1);
return NULL;
}
// Returns 0 when the window was created, -1 when no display is usable. hidden: create without
// showing (host service, opened later with uu_assist_ui_present); hide_on_close: closing hides.
static gboolean apply_sections(gpointer d) {
(void)d;
if (window) {
gtk_widget_set_visible(assist_card, show_assist); gtk_widget_set_visible(hint_label, show_assist);
gtk_widget_set_visible(account_card, show_account);
}
return G_SOURCE_REMOVE;
}
static int ui_start(int hidden, int hide_on_close);
int uu_assist_ui_start(int hidden, int hide_on_close) {
if (ui_started) { show_assist = 1; g_idle_add(apply_sections, NULL); return init_state == 1 ? 0 : -1; }
show_assist = 1;
return ui_start(hidden, hide_on_close);
}
// Reveals the account card on the shared window; standalone `login` opens it with the account card only.
int uu_login_ui_start(const char *name, const char *os, const char *cpu, const char *gpu) {
(void)name; (void)os; (void)cpu; (void)gpu;
show_account = 1;
if (ui_started) { g_idle_add(apply_sections, NULL); return init_state == 1 ? 0 : -1; }
show_assist = 0;
return ui_start(0, 0);
}
void uu_ui_show_account(void) { show_account = 1; if (ui_started && init_state == 1) g_idle_add(apply_sections, NULL); }
static int ui_start(int hidden, int hide_on_close) {
if (ui_started) return init_state == 1 ? 0 : -1;
start_hidden = hidden; close_hides = hide_on_close;
if (pthread_create(&ui_thread, NULL, ui_main, NULL) != 0) return -1;
ui_started = 1;
pthread_mutex_lock(&init_lock);
while (init_state == 0) pthread_cond_wait(&init_cond, &init_lock);
pthread_mutex_unlock(&init_lock);
if (init_state != 1) { pthread_join(ui_thread, NULL); return -1; }
return 0;
}
static gboolean apply_state(gpointer data) {
State *s = data;
if (window) {
g_strlcpy(current_id, s->id, sizeof current_id);
g_strlcpy(current_code, s->code, sizeof current_code);
gtk_label_set_text(GTK_LABEL(id_label), current_id[0] ? current_id : "获取中…");
render_code();
suppress_switch = 1;
gtk_switch_set_active(GTK_SWITCH(allow_switch), s->allowed);
suppress_switch = 0;
if (tray_allow) { suppress_tray = 1; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tray_allow), s->allowed); suppress_tray = 0; }
cur_verify = s->verify; cur_refresh = s->refresh; cur_has_custom = s->has_custom;
suppress_combo = 1; gtk_combo_box_set_active(GTK_COMBO_BOX(verify_combo), s->verify); suppress_combo = 0;
if (s->refresh >= 0 && s->refresh < 5) {
suppress_refresh = 1; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(refresh_items[s->refresh]), TRUE); suppress_refresh = 0;
}
gtk_label_set_text(GTK_LABEL(note_label), s->verify == VERIFY_CUSTOM ? "自定义验证码不会自动刷新"
: s->verify == VERIFY_BOTH ? "也可使用自定义验证码连接" : REFRESH_NOTES[s->refresh >= 0 && s->refresh < 5 ? s->refresh : 0]);
gtk_widget_set_sensitive(share_button, current_id[0] && current_code[0]);
gtk_label_set_text(GTK_LABEL(hint_label), s->allowed
? "对方在 UU 远程「开始协助」中输入设备 ID 和验证码即可连接"
: "已关闭:他人暂时无法远程协助本机,打开右上角开关后才能连接");
}
g_free(s->id); g_free(s->code); g_free(s);
return G_SOURCE_REMOVE;
}
// id is already formatted for display (e.g. "123 456 789").
void uu_assist_ui_set(const char *id, const char *code, int allowed, int verify, int refresh, int has_custom) {
if (!ui_started || init_state != 1) return;
State *s = g_new0(State, 1);
s->id = g_strdup(id ? id : ""); s->code = g_strdup(code ? code : ""); s->allowed = allowed;
s->verify = verify; s->refresh = refresh; s->has_custom = has_custom;
g_idle_add(apply_state, s);
}
// Pops the next user command (see CMD_*), copying its argument into arg.
int uu_assist_ui_take_command(char *arg, size_t len) {
int cmd = CMD_NONE;
if (arg && len) arg[0] = 0;
pthread_mutex_lock(&q_lock);
if (q_len) {
Cmd *c = &queue[q_head];
cmd = c->cmd; if (arg && len) g_strlcpy(arg, c->arg, len);
memset(c->arg, 0, sizeof c->arg); // drop the custom code copy promptly
q_head = (q_head + 1) % 16; q_len--;
}
pthread_mutex_unlock(&q_lock);
return cmd;
}
int uu_assist_ui_closed(void) { return atomic_load(&closed); }
static gboolean apply_present(gpointer data) {
(void)data;
if (window) { gtk_widget_show(window); gtk_window_present(GTK_WINDOW(window)); }
return G_SOURCE_REMOVE;
}
void uu_assist_ui_present(void) { if (ui_started && init_state == 1 && !atomic_load(&closed)) g_idle_add(apply_present, NULL); }
static gboolean apply_close(gpointer data) { (void)data; if (window) gtk_widget_destroy(window); return G_SOURCE_REMOVE; }
void uu_assist_ui_close(void) { if (ui_started && init_state == 1 && !atomic_load(&closed)) g_idle_add(apply_close, NULL); }
// ---- Account card API (QR login / signed-in user); same names as the former login window ----
typedef struct { unsigned char *rgba; int edge; } QrUpdate;
typedef struct { char *text; int kind; } StatusUpdate;
static gboolean apply_qr(gpointer data) {
QrUpdate *u = data;
if (window) {
GdkPixbuf *pb = gdk_pixbuf_new_from_data(u->rgba, GDK_COLORSPACE_RGB, TRUE, 8, u->edge, u->edge, u->edge * 4, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(pb, 180, 180, GDK_INTERP_NEAREST);
gtk_image_set_from_pixbuf(GTK_IMAGE(qr_image), scaled);
g_object_unref(scaled); g_object_unref(pb);
gtk_stack_set_visible_child_name(GTK_STACK(qr_stack), "qr");
gtk_stack_set_visible_child_name(GTK_STACK(account_stack), "qr");
}
g_free(u->rgba); g_free(u);
return G_SOURCE_REMOVE;
}
void uu_login_ui_set_qr(const unsigned char *rgba, int edge) {
if (!ui_started || init_state != 1 || atomic_load(&closed) || edge <= 0) return;
QrUpdate *u = g_new(QrUpdate, 1);
u->rgba = g_memdup2(rgba, (gsize)edge * edge * 4); u->edge = edge;
g_idle_add(apply_qr, u);
}
static gboolean apply_login_status(gpointer data) {
StatusUpdate *u = data;
if (window) {
GtkStyleContext *ctx = gtk_widget_get_style_context(login_status);
gtk_style_context_remove_class(ctx, "ok"); gtk_style_context_remove_class(ctx, "error");
if (u->kind == 1) gtk_style_context_add_class(ctx, "ok");
if (u->kind == 2) gtk_style_context_add_class(ctx, "error");
gtk_label_set_text(GTK_LABEL(login_status), u->text);
}
g_free(u->text); g_free(u);
return G_SOURCE_REMOVE;
}
void uu_login_ui_set_status(const char *text, int kind) {
if (!ui_started || init_state != 1 || atomic_load(&closed)) return;
StatusUpdate *u = g_new(StatusUpdate, 1);
u->text = g_strdup(text ? text : ""); u->kind = kind;
g_idle_add(apply_login_status, u);
}
static gboolean apply_user(gpointer data) {
if (window) {
gtk_label_set_text(GTK_LABEL(user_label), data);
gtk_stack_set_visible_child_name(GTK_STACK(account_stack), "user");
show_account = 1; apply_sections(NULL);
}
g_free(data);
return G_SOURCE_REMOVE;
}
// Signed in: show the user page with this (already masked) account name.
void uu_ui_set_user(const char *name) {
if (!ui_started || init_state != 1) return;
g_idle_add(apply_user, g_strdup(name ? name : ""));
}
void uu_login_ui_set_done(const char *text) { uu_ui_set_user(text); }
int uu_login_ui_closed(void) { return atomic_load(&closed); }
void uu_login_ui_close(void) { uu_assist_ui_close(); }
-321
View File
@@ -1,321 +0,0 @@
// GTK3 QR login window for `uuremote-server login`. The window runs its own GTK main loop on a
// dedicated thread; the Rust login flow pushes QR images and status text through g_idle_add.
// Layout follows the official login window (QR on the left), but uses no NetEase assets: the
// mark is drawn with cairo and the right column shows this host's hardware summary instead of SMS.
#include <gtk/gtk.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
static const char *CSS =
"window { background-image: linear-gradient(165deg, #d6e8ff 0%, #eaf3ff 40%, #ffffff 100%); }\n"
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
".title { font-size: 26px; font-weight: 800; color: #111111; }\n"
".subtitle { font-size: 13px; color: #6b7280; }\n"
".heading { font-size: 19px; font-weight: 700; color: #1d1d1f; }\n"
".card { background-color: #ffffff; border-radius: 10px; padding: 14px; }\n"
".caption { font-size: 14px; color: #555555; }\n"
".status { font-size: 13px; color: #2f6bff; }\n"
".status.ok { color: #16a34a; }\n"
".status.error { color: #dc2626; }\n"
".key { font-size: 13px; color: #8a8f98; }\n"
".value { font-size: 13px; color: #222222; }\n"
".note { font-size: 12px; color: #6b7280; }\n"
".done-mark { font-size: 72px; color: #16a34a; }\n"
".done-text { font-size: 17px; font-weight: 700; color: #1d1d1f; }\n"
".footer { font-size: 12px; color: #9ca3af; }\n"
"button.primary { background-image: none; background-color: #2f6bff; color: #ffffff; border: none;"
" border-radius: 6px; padding: 6px 28px; font-size: 15px; }\n"
"button.primary:hover { background-color: #1f5ae6; }\n"
"separator { background-color: #dfe5ee; min-width: 1px; }\n";
typedef struct { unsigned char *rgba; int edge; } QrUpdate;
typedef struct { char *text; int kind; } StatusUpdate;
static atomic_int closed;
static pthread_t ui_thread;
static int ui_started;
static pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
static int init_state; // 0 pending, 1 ok, -1 failed
static char *info[4];
static GtkWidget *window, *stack, *qr_image, *status_label, *done_label, *done_button;
static gboolean draw_mark(GtkWidget *w, cairo_t *cr, gpointer data) {
(void)w; (void)data;
cairo_pattern_t *g = cairo_pattern_create_linear(0, 0, 44, 44);
cairo_pattern_add_color_stop_rgb(g, 0, 0.13, 0.83, 0.93);
cairo_pattern_add_color_stop_rgb(g, 1, 0.18, 0.42, 1.0);
double r = 11, s = 44;
cairo_new_sub_path(cr);
cairo_arc(cr, s - r, r, r, -G_PI / 2, 0);
cairo_arc(cr, s - r, s - r, r, 0, G_PI / 2);
cairo_arc(cr, r, s - r, r, G_PI / 2, G_PI);
cairo_arc(cr, r, r, r, G_PI, 3 * G_PI / 2);
cairo_close_path(cr);
cairo_set_source(cr, g);
cairo_fill(cr);
cairo_pattern_destroy(g);
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_select_font_face(cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(cr, 19);
cairo_text_extents_t e;
cairo_text_extents(cr, "UU", &e);
cairo_move_to(cr, (s - e.width) / 2 - e.x_bearing, (s - e.height) / 2 - e.y_bearing);
cairo_show_text(cr, "UU");
return TRUE;
}
static GtkWidget *label(const char *text, const char *cls) {
GtkWidget *l = gtk_label_new(text);
gtk_style_context_add_class(gtk_widget_get_style_context(l), cls);
return l;
}
static void info_row(GtkGrid *grid, int row, const char *key, const char *value) {
GtkWidget *k = label(key, "key"), *v = label(value && *value ? value : "-", "value");
gtk_widget_set_halign(k, GTK_ALIGN_START);
gtk_widget_set_valign(k, GTK_ALIGN_START);
gtk_widget_set_halign(v, GTK_ALIGN_START);
gtk_label_set_xalign(GTK_LABEL(v), 0);
gtk_label_set_line_wrap(GTK_LABEL(v), TRUE);
gtk_label_set_max_width_chars(GTK_LABEL(v), 26);
gtk_grid_attach(grid, k, 0, row, 1, 1);
gtk_grid_attach(grid, v, 1, row, 1, 1);
}
static void on_destroy(GtkWidget *w, gpointer data) {
(void)w; (void)data;
atomic_store(&closed, 1);
window = NULL;
gtk_main_quit();
}
static void on_done_clicked(GtkButton *b, gpointer data) {
(void)b; (void)data;
if (window) gtk_widget_destroy(window);
}
static void build_window(void) {
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);
g_object_unref(css);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 主机 - 登录");
gtk_window_set_default_size(GTK_WINDOW(window), 720, 520);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(window, "destroy", G_CALLBACK(on_destroy), NULL);
GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width(GTK_CONTAINER(root), 24);
gtk_container_add(GTK_CONTAINER(window), root);
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_set_halign(header, GTK_ALIGN_CENTER);
GtkWidget *mark = gtk_drawing_area_new();
gtk_widget_set_size_request(mark, 44, 44);
gtk_widget_set_valign(mark, GTK_ALIGN_CENTER);
g_signal_connect(mark, "draw", G_CALLBACK(draw_mark), NULL);
GtkWidget *titles = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *title = label("UU 远程 · Linux 主机", "title");
gtk_widget_set_halign(title, GTK_ALIGN_START);
GtkWidget *subtitle = label("登录后,本机会出现在你的 UU 远程设备列表中", "subtitle");
gtk_widget_set_halign(subtitle, GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(titles), title, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(titles), subtitle, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), mark, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), titles, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(root), header, FALSE, FALSE, 4);
GtkWidget *columns = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(columns), FALSE);
gtk_widget_set_margin_top(columns, 22);
gtk_box_pack_start(GTK_BOX(root), columns, TRUE, TRUE, 0);
// Left: QR login.
GtkWidget *left = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12);
gtk_widget_set_size_request(left, 330, -1);
gtk_box_pack_start(GTK_BOX(left), label("扫码登录", "heading"), FALSE, FALSE, 0);
GtkWidget *card = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
gtk_widget_set_halign(card, GTK_ALIGN_CENTER);
gtk_widget_set_size_request(card, 252, 252);
stack = gtk_stack_new();
gtk_stack_set_transition_type(GTK_STACK(stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);
GtkWidget *loading = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_widget_set_valign(loading, GTK_ALIGN_CENTER);
GtkWidget *spinner = gtk_spinner_new();
gtk_spinner_start(GTK_SPINNER(spinner));
gtk_widget_set_size_request(spinner, 32, 32);
gtk_box_pack_start(GTK_BOX(loading), spinner, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(loading), label("正在获取二维码…", "caption"), FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(stack), loading, "loading");
qr_image = gtk_image_new();
gtk_stack_add_named(GTK_STACK(stack), qr_image, "qr");
GtkWidget *done = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_set_valign(done, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(done), label("✓", "done-mark"), FALSE, FALSE, 0);
done_label = label("登录成功", "done-text");
gtk_label_set_justify(GTK_LABEL(done_label), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap(GTK_LABEL(done_label), TRUE);
gtk_box_pack_start(GTK_BOX(done), done_label, FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(stack), done, "done");
gtk_box_pack_start(GTK_BOX(card), stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(left), card, FALSE, FALSE, 0);
GtkWidget *caption = label("请使用网易 UU 远程 App 扫一扫\n可快速登录", "caption");
gtk_label_set_justify(GTK_LABEL(caption), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(left), caption, FALSE, FALSE, 0);
status_label = label("", "status");
gtk_label_set_line_wrap(GTK_LABEL(status_label), TRUE);
gtk_label_set_justify(GTK_LABEL(status_label), GTK_JUSTIFY_CENTER);
gtk_label_set_max_width_chars(GTK_LABEL(status_label), 34);
gtk_box_pack_start(GTK_BOX(left), status_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(columns), left, TRUE, TRUE, 0);
GtkWidget *sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_widget_set_margin_top(sep, 6);
gtk_widget_set_margin_bottom(sep, 24);
gtk_box_pack_start(GTK_BOX(columns), sep, FALSE, FALSE, 0);
// Right: what will be registered.
GtkWidget *right = gtk_box_new(GTK_ORIENTATION_VERTICAL, 14);
gtk_widget_set_margin_start(right, 30);
gtk_widget_set_size_request(right, 300, -1);
GtkWidget *rh = label("本机信息", "heading");
gtk_box_pack_start(GTK_BOX(right), rh, FALSE, FALSE, 0);
GtkWidget *grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(grid), 12);
gtk_grid_set_column_spacing(GTK_GRID(grid), 16);
gtk_widget_set_margin_top(grid, 10);
const char *keys[4] = {"设备名称", "操作系统", "处理器", "显卡"};
for (int i = 0; i < 4; i++) info_row(GTK_GRID(grid), i, keys[i], info[i]);
gtk_box_pack_start(GTK_BOX(right), grid, FALSE, FALSE, 0);
GtkWidget *note = label("登录后可在 Mac / Windows / 手机上的官方 UU 远程客户端中连接本机的桌面、文件传输和终端。"
"登录信息只保存在本机配置文件中。", "note");
gtk_label_set_line_wrap(GTK_LABEL(note), TRUE);
gtk_label_set_max_width_chars(GTK_LABEL(note), 30);
gtk_label_set_xalign(GTK_LABEL(note), 0);
gtk_widget_set_margin_top(note, 10);
gtk_box_pack_start(GTK_BOX(right), note, FALSE, FALSE, 0);
done_button = gtk_button_new_with_label("完成");
gtk_style_context_add_class(gtk_widget_get_style_context(done_button), "primary");
gtk_widget_set_halign(done_button, GTK_ALIGN_START);
gtk_widget_set_no_show_all(done_button, TRUE);
g_signal_connect(done_button, "clicked", G_CALLBACK(on_done_clicked), NULL);
gtk_box_pack_end(GTK_BOX(right), done_button, FALSE, FALSE, 20);
gtk_box_pack_start(GTK_BOX(columns), right, TRUE, TRUE, 0);
GtkWidget *footer = label("开源 Linux 主机端 · 非网易官方客户端", "footer");
gtk_box_pack_end(GTK_BOX(root), footer, FALSE, FALSE, 0);
gtk_widget_show_all(window);
}
static void *ui_main(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
if (ok) build_window();
pthread_mutex_lock(&init_lock);
init_state = ok ? 1 : -1;
pthread_cond_signal(&init_cond);
pthread_mutex_unlock(&init_lock);
if (ok) gtk_main();
else atomic_store(&closed, 1);
return NULL;
}
// Returns 0 when the window is shown, -1 when no display is usable.
int uu_login_ui_start(const char *name, const char *os, const char *cpu, const char *gpu) {
if (ui_started) return init_state == 1 ? 0 : -1;
const char *src[4] = {name, os, cpu, gpu};
for (int i = 0; i < 4; i++) info[i] = g_strdup(src[i] ? src[i] : "");
if (pthread_create(&ui_thread, NULL, ui_main, NULL) != 0) return -1;
ui_started = 1;
pthread_mutex_lock(&init_lock);
while (init_state == 0) pthread_cond_wait(&init_cond, &init_lock);
pthread_mutex_unlock(&init_lock);
if (init_state != 1) { pthread_join(ui_thread, NULL); return -1; }
return 0;
}
static gboolean apply_qr(gpointer data) {
QrUpdate *u = data;
if (window) {
GdkPixbuf *pb = gdk_pixbuf_new_from_data(u->rgba, GDK_COLORSPACE_RGB, TRUE, 8, u->edge, u->edge, u->edge * 4,
(GdkPixbufDestroyNotify)g_free, NULL);
gtk_image_set_from_pixbuf(GTK_IMAGE(qr_image), pb);
g_object_unref(pb);
gtk_stack_set_visible_child_name(GTK_STACK(stack), "qr");
} else g_free(u->rgba);
g_free(u);
return G_SOURCE_REMOVE;
}
void uu_login_ui_set_qr(const unsigned char *rgba, int edge) {
if (atomic_load(&closed) || edge <= 0) return;
QrUpdate *u = g_new(QrUpdate, 1);
u->rgba = g_memdup2(rgba, (gsize)edge * edge * 4);
u->edge = edge;
g_idle_add(apply_qr, u);
}
static gboolean apply_status(gpointer data) {
StatusUpdate *u = data;
if (window) {
GtkStyleContext *ctx = gtk_widget_get_style_context(status_label);
gtk_style_context_remove_class(ctx, "ok");
gtk_style_context_remove_class(ctx, "error");
if (u->kind == 1) gtk_style_context_add_class(ctx, "ok");
if (u->kind == 2) gtk_style_context_add_class(ctx, "error");
gtk_label_set_text(GTK_LABEL(status_label), u->text);
if (u->kind == 2 && !gtk_image_get_pixbuf(GTK_IMAGE(qr_image)))
gtk_widget_hide(gtk_stack_get_child_by_name(GTK_STACK(stack), "loading"));
}
g_free(u->text);
g_free(u);
return G_SOURCE_REMOVE;
}
// kind: 0 info, 1 success, 2 error.
void uu_login_ui_set_status(const char *text, int kind) {
if (atomic_load(&closed)) return;
StatusUpdate *u = g_new(StatusUpdate, 1);
u->text = g_strdup(text ? text : "");
u->kind = kind;
g_idle_add(apply_status, u);
}
static gboolean apply_done(gpointer data) {
if (window) {
gtk_label_set_text(GTK_LABEL(done_label), data);
gtk_stack_set_visible_child_name(GTK_STACK(stack), "done");
gtk_widget_show(done_button);
gtk_widget_grab_focus(done_button);
}
g_free(data);
return G_SOURCE_REMOVE;
}
void uu_login_ui_set_done(const char *text) {
if (atomic_load(&closed)) return;
g_idle_add(apply_done, g_strdup(text ? text : ""));
}
int uu_login_ui_closed(void) { return atomic_load(&closed); }
static gboolean apply_close(gpointer data) {
(void)data;
if (window) gtk_widget_destroy(window);
return G_SOURCE_REMOVE;
}
void uu_login_ui_close(void) {
if (!ui_started) return;
if (!atomic_load(&closed)) g_idle_add(apply_close, NULL);
pthread_join(ui_thread, NULL);
ui_started = 0;
}
+13
View File
@@ -0,0 +1,13 @@
[Desktop Entry]
Type=Application
Name=UU 远程 Linux 主机
Name[en]=UU Remote Linux Host
GenericName=Remote assistance host
Comment=非官方 UU 远程被控端:远程协助与扫码登录
Comment[en]=Unofficial NetEase UU Remote host: remote assistance and QR sign-in
Exec=uuremote-server show
Icon=uu-remote-linux
Terminal=false
Categories=Network;RemoteAccess;
Keywords=remote;assist;UU;远程;协助;
StartupNotify=false
+13
View File
@@ -0,0 +1,13 @@
<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128" viewBox="0 0 128 128">
<!-- uu-remote-linux app icon (original artwork, GPL-3.0 with the project): a desktop being reached remotely. -->
<defs>
<linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
<stop offset="0" stop-color="#22d3ee"/>
<stop offset="1" stop-color="#2563eb"/>
</linearGradient>
</defs>
<rect x="4" y="4" width="120" height="120" rx="28" fill="url(#bg)"/>
<rect x="26" y="32" width="76" height="52" rx="7" fill="none" stroke="#ffffff" stroke-width="7"/>
<path d="M52 98h24M64 84v14" stroke="#ffffff" stroke-width="7" stroke-linecap="round"/>
<path d="M46 70l22-22M54 48h14v14" fill="none" stroke="#ffffff" stroke-width="7" stroke-linecap="round" stroke-linejoin="round"/>
</svg>

After

Width:  |  Height:  |  Size: 794 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 84 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 51 KiB

+27
View File
@@ -0,0 +1,27 @@
远程协助(实验性)、统一主窗口和应用图标。/ Remote assistance (experimental), a unified main window and an app icon.
<p align="center"><img src="https://raw.githubusercontent.com/VallierDev/uu-remote-linux/v0.1.11/docs/images/main-window.png" width="560" alt="main window"></p>
### 新增 / Added
- **远程协助(实验性)**:和官方客户端一样,把「设备 ID + 验证码」发给别人,对方在 UU 远程的「开始协助」里输入即可连接本机。
- **未登录也能用**(访客身份);**登录后同样可用**,设备 ID 不变。
- 「允许他人远程协助」开关(默认关闭);验证方式:仅临时验证码 / 仅自定义验证码(8–16 位字母+数字)/ 两种都可以;
临时验证码刷新:每次远控结束 / 每小时 / 每 12 小时 / 每 24 小时 / 不刷新;ID 和验证码各有「复制」按钮,另有「复制并分享」。
- 协议参照官方 Windows 精简版被控端实现。✅ 用官方 Mac 客户端实测:访客连接、错误验证码被拒绝、用完自动换码、关闭后不可连接、
登录与退出登录的切换。⚠️ **登录状态下用另一个账号发起远程协助尚未实测**(同账号设备之间不能互相协助,这是官方限制)。
- 安全:拿到 ID 和验证码的人可以完全控制这台电脑,只发给信任的人;验证码只显示在本机窗口,不写入日志。
Remote assistance like the official client (device ID + code), before and after sign-in. Verified with the official
Mac viewer except signed-in assistance from another account.
- **统一主窗口**:一个窗口包含「本设备」(远程协助)和「账号」:未登录时显示扫码二维码,登录后显示账号(手机号打码)和「退出登录」。
扫码登录或退出登录后,主机会自动切换模式。已登录的后台服务默认隐藏窗口,用 `uuremote-server show` 或应用菜单打开;关闭窗口只是隐藏。
One window with remote assistance and the account (QR before sign-in, account + sign out after).
- **应用图标和启动项**(#13):`contrib/desktop/` 里有图标和 `.desktop` 文件,安装后应用菜单里会出现「UU 远程 Linux 主机」。
App icon and desktop launcher.
### 修复 / Fixed
- 服务模式下扫码登录时,二维码(登录凭证)不再打印到标准输出(会进入系统日志)。/ The QR is no longer printed to a service's stdout.
### 下载 / Download
`uu-remote-linux-v0.1.11-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
Mac 快捷键和在 Mac 上一样用。/ Mac shortcuts work as on a Mac.
### 新增 / Added
- **Mac 快捷键**:在 Mac 远控窗口菜单里**关闭「使用 macOS 快捷键」**后:
- Cmd+C / V / A / F / X / Z 是复制、粘贴、全选、查找、剪切、撤销(Cmd+Shift+Z 等组合同样可用);
- 在终端里 Cmd+C / Cmd+V 自动变成终端的复制、粘贴(Ctrl+Shift+C / V),**Ctrl+C 始终是中断**;
- 其他 Cmd 组合键和单独按 Cmd 仍然是 Super(Windows 键)。
只对 Mac 控制端生效(按连接请求里的控制端平台判断),Windows 和手机控制端不受影响。✅ 已用官方 Mac 客户端在 X11 实机验收。
保持该选项开启时行为和以前一样(客户端会把 Cmd 当成 Ctrl 发送)。
With 「使用 macOS 快捷键」 off, Cmd shortcuts behave as on a Mac (terminal-aware copy/paste), only for macOS viewers.
### 下载 / Download
`uu-remote-linux-v0.1.12-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
托盘图标。/ Tray icon.
### 新增 / Added
- **托盘图标**:后台运行时,顶栏/任务栏会显示托盘图标,菜单里有「打开主窗口」、「允许他人远程协助」(与主窗口开关同步)和「退出」。
- GNOME 通过 AppIndicator 显示(Ubuntu 自带扩展;运行时加载 libayatana-appindicator,无需额外编译依赖);Xfce / Cinnamon / KDE 等使用系统托盘。
- 「退出」会停止 `uuremote-native.service`(不会被自动重启);之后从应用菜单「UU 远程 Linux 主机」打开,会重新启动服务并显示主窗口。
✅ Ubuntu 24.04 GNOME(X11)实机验收:图标、菜单、开关同步、退出、从应用菜单重新启动。⚠️ Xfce 等系统托盘路径尚未实机验收。
Tray icon with open / allow / quit; Quit stops the user service and the launcher restarts it. Verified on Ubuntu GNOME.
### 改进 / Improved
- `uuremote-server show`:主机没在运行时,优先启动已安装的 `uuremote-native.service`,而不是另起一个不受管理的进程。
- 修复启动时的一个时序问题:先注册窗口唤起信号再写入 PID 文件,避免过早的 `show` 意外结束主机进程。
### 下载 / Download
`uu-remote-linux-v0.1.13-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
修复手机切回终端时黑屏。/ Fixes a black terminal after returning to it on mobile.
### 修复 / Fixed
- **终端历史输出较多时,重连后黑屏**(#14,感谢 @cnetst):手机客户端切到后台再回到同一个终端时,如果之前积累的输出较多,
会整屏黑屏,连新建终端也没有输出,只能完全退出 App 重连。原因是重连时把最多 256 KB 的历史输出作为一条消息发送,
超过了 WebRTC 数据通道单条消息 64 KB 的上限,发送失败后整个终端连接卡住。现在历史输出按 16 KB 分段发送,顺序不变。
✅ 已用官方手机客户端在 3090 实机验收。
Terminal scrollback is replayed in 16 KiB chunks instead of one message over the 64 KiB SCTP limit. Verified on mobile.
### 下载 / Download
`uu-remote-linux-v0.1.14-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+20
View File
@@ -0,0 +1,20 @@
支持真彩(4:4:4)。/ True color (4:4:4) support.
### 新功能 / Added
- **真彩(4:4:4)**:在客户端画面菜单打开「真彩」后,主机改用 H.264 High 4:4:4 编码,彩色细字(红字、链接、
代码高亮)边缘不再发虚;关闭后切回 4:2:0。适用于默认的 FFmpeg 管线(NVENC 或 libx264);VAAPI 和
`--features inproc-av` 管线仍为 4:2:0,并如实告知客户端。
✅ 已用官方 Mac 客户端在 RTX 3090(NVENC)上实机验证:开关来回切换正常、画面正常解码。
When 真彩 is enabled the host encodes H.264 High 4:4:4 (default FFmpeg pipeline with NVENC or libx264); VAAPI and
inproc-av stay 4:2:0 and report it. Verified with the official Mac viewer on NVENC (toggling, decoding).
- 日志记录客户端声明的解码能力(编码类型、色度、最大分辨率、帧率,仅数字),便于排查画质问题。
The log now shows the viewer's declared decoder capabilities (numbers only).
### 说明 / Notes
- 4:4:4 码率会略高于 4:2:0;在缩放到较低分辨率时差别不明显,建议配合「跟随远端」分辨率使用。
4:4:4 costs some bitrate; the difference is hardly visible when the stream is scaled down.
### 下载 / Download
`uu-remote-linux-v0.1.15-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+536
View File
@@ -0,0 +1,536 @@
//! Opt-in guest assistance. Protocol sources: docs/validation/remote-assist-evidence.md.
//! Secret values never implement Display/Debug or enter diagnostics.
use crate::auth::{Credentials, RoomData, UUAuthClient};
use serde_json::{json, Value};
use sha2::{Digest, Sha256};
use std::io::{Read, Write};
use std::os::unix::{fs::OpenOptionsExt, io::AsRawFd};
const CREATE: &str = "/api/v1/guest/create";
const INFO: &str = "/api/v1/guest/share/info";
const CANCEL: &str = "/api/v1/guest/share/cancel";
const ROOM: &str = "/api/v1/guest/room/create";
const SIGN: &str = "/api/v1/guest/room/share/upload/sign";
const CONTROL_MODE: &str = "/api/v1/guest/room/share/upload_control_mode";
// Logged-in host: the same flow on the account identity (official Windows host NrdDevice/NrdBusinessEntry).
const ACCOUNT_INFO: &str = "/api/v1/device/share/info";
const ACCOUNT_CANCEL: &str = "/api/v1/device/share/cancel";
const ACCOUNT_SIGN: &str = "/api/v2/room/share/upload_sign";
const ACCOUNT_CONTROL_MODE: &str = "/api/v2/room/share/upload_control_mode";
const ALPHABET: &[u8] = b"ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
/// Guest mode uses its own device/config identity and never consumes an account token.
pub fn configure() -> Result<(), String> {
if ["UU_USER_ID", "UU_TOKEN", "UU_CSRF"].iter().any(|k| std::env::var_os(k).is_some_and(|v| !v.is_empty())) {
return Err("assist mode cannot use account credential environment variables".into());
}
if std::env::var_os("UU_CONFIG").is_none() {
if crate::config::read_fresh()?.as_ref().is_some_and(|v| ["token", "user_id"].iter()
.any(|k| v.get(k).and_then(Value::as_str).is_some_and(|s| !s.is_empty()))) {
return Err("account identity already configured; guest assist needs an explicit separate UU_CONFIG".into());
}
let path = crate::config::path().with_file_name("assist").join("config.json");
std::env::set_var("UU_CONFIG", path);
}
if crate::config::read_fresh()?.as_ref().is_some_and(|v| ["token", "user_id", "csrf"].iter()
.any(|k| v.get(k).and_then(Value::as_str).is_some_and(|s| !s.is_empty()))) {
return Err("assist requires a separate config without account credentials".into());
}
Ok(())
}
/// Official RecipientConfigModel.verificationType: temporary only, custom only, or both.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Verify { Temporary = 0, Custom = 1, Both = 2 }
impl Verify {
fn parse(v: &str) -> Option<Self> { match v { "temporary" => Some(Self::Temporary), "custom" => Some(Self::Custom), "both" => Some(Self::Both), _ => None } }
fn name(self) -> &'static str { match self { Self::Temporary => "temporary", Self::Custom => "custom", Self::Both => "both" } }
fn from_index(i: i64) -> Option<Self> { match i { 0 => Some(Self::Temporary), 1 => Some(Self::Custom), 2 => Some(Self::Both), _ => None } }
}
/// Official RecipientCodeRefreshType: after each session (closeConnect), hourly, 12 h, 24 h, never.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Refresh { Session = 0, Hour = 1, Hour12 = 2, Hour24 = 3, Never = 4 }
impl Refresh {
fn parse(v: &str) -> Option<Self> { match v { "session" => Some(Self::Session), "1h" => Some(Self::Hour), "12h" => Some(Self::Hour12), "24h" => Some(Self::Hour24), "never" => Some(Self::Never), _ => None } }
fn name(self) -> &'static str { match self { Self::Session => "session", Self::Hour => "1h", Self::Hour12 => "12h", Self::Hour24 => "24h", Self::Never => "never" } }
fn from_index(i: i64) -> Option<Self> { [Self::Session, Self::Hour, Self::Hour12, Self::Hour24, Self::Never].get(usize::try_from(i).ok()?).copied() }
fn period(self) -> Option<std::time::Duration> {
match self { Self::Hour => Some(3600), Self::Hour12 => Some(12 * 3600), Self::Hour24 => Some(24 * 3600), _ => None }.map(std::time::Duration::from_secs)
}
}
/// Mainland mobile numbers are shown like the official client: 186******08.
pub fn display_account(name: &str) -> String {
if name.len() == 11 && name.bytes().all(|b| b.is_ascii_digit()) { format!("{}******{}", &name[..3], &name[9..]) } else { name.to_owned() }
}
/// 8-16 ASCII letters/digits including both (official RecipientCustomCodeView rules).
fn valid_custom(code: &str) -> bool {
(8..=16).contains(&code.len()) && code.bytes().all(|b| b.is_ascii_alphanumeric())
&& code.bytes().any(|b| b.is_ascii_alphabetic()) && code.bytes().any(|b| b.is_ascii_digit())
}
pub enum Command { Allow, Deny, Reset, Stop, Verify(Verify), Refresh(Refresh), Custom(String), Logout, Quit }
#[cfg(uu_gtk)]
extern "C" {
fn uu_assist_ui_start(hidden: libc::c_int, hide_on_close: libc::c_int) -> libc::c_int;
fn uu_assist_ui_present();
fn uu_ui_set_user(name: *const libc::c_char);
fn uu_assist_ui_set(id: *const libc::c_char, code: *const libc::c_char, allowed: libc::c_int, verify: libc::c_int, refresh: libc::c_int, has_custom: libc::c_int);
fn uu_assist_ui_take_command(arg: *mut libc::c_char, len: libc::size_t) -> libc::c_int;
fn uu_assist_ui_close();
}
/// "243829726" -> "243 829 726", as the official client shows device IDs.
fn display_id(id: &str) -> String {
if id.is_empty() || !id.bytes().all(|b| b.is_ascii_digit()) { return id.to_owned(); }
id.as_bytes().chunks(3).map(|c| String::from_utf8_lossy(c).into_owned()).collect::<Vec<_>>().join(" ")
}
/// Where the ID/code are shown and commands come from: a local GTK window (c_engine/assist_window.c)
/// when a display is available, otherwise /dev/tty, which bypasses stdout/stderr, journals,
/// redirected output and the logger. Without either, refuse startup rather than disclose the code.
pub enum LocalUi { Tty(tokio::io::unix::AsyncFd<std::fs::File>), #[cfg(uu_gtk)] Window }
impl LocalUi {
/// Standalone `assist`: visible window (closing it stops assistance), else /dev/tty.
pub fn open() -> Result<Self, String> { Self::open_visible(false) }
/// `hide_on_close`: the not-logged-in host service (window stays reachable with `uuremote-server show`).
pub fn open_visible(hide_on_close: bool) -> Result<Self, String> {
#[cfg(not(uu_gtk))] let _ = hide_on_close;
#[cfg(uu_gtk)]
if std::env::var("UU_ASSIST_UI").ok().as_deref() != Some("tty") && Self::display() && unsafe { uu_assist_ui_start(0, i32::from(hide_on_close)) } == 0 {
return Ok(Self::Window);
}
let tty = std::fs::OpenOptions::new().read(true).write(true)
.custom_flags(libc::O_NONBLOCK | libc::O_NOCTTY).open("/dev/tty")
.map_err(|_| "assist requires a desktop window or a local controlling terminal; no code was printed")?;
if unsafe { libc::isatty(tty.as_raw_fd()) } != 1 { return Err("assist output is not a terminal".into()); }
Ok(Self::Tty(tokio::io::unix::AsyncFd::new(tty).map_err(|_| "assist terminal registration failed")?))
}
fn display() -> bool { std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() }
/// Host service: a hidden window opened on demand (`uuremote-server show`); closing only hides it.
/// No terminal fallback: a background service has nowhere safe to print the code.
pub fn open_service() -> Result<Self, String> {
#[cfg(uu_gtk)]
if Self::display() && unsafe { uu_assist_ui_start(1, 1) } == 0 { return Ok(Self::Window); }
Err("remote assistance needs a desktop window for the host service".into())
}
/// Account card: signed-in user (name already masked for display).
pub fn set_user(&self, name: &str) {
#[cfg(uu_gtk)]
if matches!(self, Self::Window) { let name = std::ffi::CString::new(name).unwrap_or_default(); unsafe { uu_ui_set_user(name.as_ptr()) } }
#[cfg(not(uu_gtk))] let _ = name;
}
pub fn present(&self) {
#[cfg(uu_gtk)]
if matches!(self, Self::Window) { unsafe { uu_assist_ui_present() } }
}
fn show(&self, id: &str, code: &str, allowed: bool, verify: Verify, refresh: Refresh, has_custom: bool) -> Result<(), String> {
#[cfg(not(uu_gtk))] let _ = has_custom;
match self {
Self::Tty(tty) => {
// Bound/control-character-validated server identifier; no terminal escape injection.
let mut tty = tty.get_ref();
write!(tty, "\n远程协助 / Remote assistance\n设备 ID: {}\n临时验证码: {code}\n允许他人远程协助: {allowed}\n验证方式: {} 自动刷新: {}\n仅向可信的人提供验证码。allow=允许,deny=不允许,reset=换码,mode temporary|custom|both,refresh session|1h|12h|24h|never,off=关闭并撤销\n", display_id(id), verify.name(), refresh.name())
.map_err(|_| "assist terminal display failed".into())
}
#[cfg(uu_gtk)]
Self::Window => {
let (id, code) = (std::ffi::CString::new(display_id(id)).unwrap_or_default(), std::ffi::CString::new(code).unwrap_or_default());
unsafe { uu_assist_ui_set(id.as_ptr(), code.as_ptr(), i32::from(allowed), verify as i32, refresh as i32, i32::from(has_custom)) };
Ok(())
}
}
}
pub async fn command(&self) -> Command {
match self {
Self::Tty(tty) => Self::tty_command(tty).await,
#[cfg(uu_gtk)]
Self::Window => loop {
let mut arg = [0 as libc::c_char; 40];
let cmd = unsafe { uu_assist_ui_take_command(arg.as_mut_ptr(), arg.len()) };
let text = unsafe { std::ffi::CStr::from_ptr(arg.as_ptr()) }.to_string_lossy().into_owned();
let index = text.parse::<i64>().unwrap_or(-1);
match cmd {
1 => return Command::Allow, 2 => return Command::Deny, 3 => return Command::Reset, 4 => return Command::Stop,
5 => if let Some(v) = Verify::from_index(index) { return Command::Verify(v) },
6 => if let Some(r) = Refresh::from_index(index) { return Command::Refresh(r) },
7 => return Command::Custom(text),
8 => return Command::Logout,
9 => return Command::Quit,
_ => tokio::time::sleep(std::time::Duration::from_millis(150)).await,
}
},
}
}
async fn tty_command(tty: &tokio::io::unix::AsyncFd<std::fs::File>) -> Command {
let mut line = Vec::new();
loop {
let mut ready = match tty.readable().await { Ok(v) => v, Err(_) => return Command::Stop };
let result = ready.try_io(|fd| { let mut byte = [0u8]; let mut tty = fd.get_ref(); tty.read(&mut byte).map(|n| (n, byte[0])) });
match result {
Ok(Ok((0, _))) | Ok(Err(_)) => return Command::Stop,
Ok(Ok((_, byte))) if byte == b'\n' => {
let text = String::from_utf8_lossy(&line).trim().to_owned();
let cmd = match text.split_once(' ') {
Some(("mode", v)) => Verify::parse(v).map(Command::Verify),
Some(("refresh", v)) => Refresh::parse(v).map(Command::Refresh),
_ => match text.as_str() { "allow" => Some(Command::Allow), "deny" => Some(Command::Deny), "reset" => Some(Command::Reset), "off" | "q" => Some(Command::Stop), _ => None },
};
line.clear(); if let Some(cmd) = cmd { return cmd; }
}
Ok(Ok((_, byte))) => { if line.len() < 64 { line.push(byte); } },
Err(_) => {},
}
}
}
}
impl Drop for LocalUi {
fn drop(&mut self) {
#[cfg(uu_gtk)]
if matches!(self, Self::Window) { unsafe { uu_assist_ui_close() } }
}
}
fn response(status: u16, value: &Value) -> Result<&Value, String> {
let code = value.get("code").and_then(Value::as_i64).unwrap_or(-1);
if status == 200 && code == 0 { return Ok(value.get("data").unwrap_or(&Value::Null)); }
// No server message, validation payload, headers, URLs, token or code in errors. UU_ASSIST_DEBUG=1 adds
// the server's short human-readable message (bounded) for diagnosing rejected guest calls.
let message = (std::env::var("UU_ASSIST_DEBUG").ok().as_deref() == Some("1"))
.then(|| value.get("message").or_else(|| value.get("msg")).and_then(Value::as_str)
.map(|m| m.chars().filter(|c| !c.is_control()).take(120).collect::<String>()))
.flatten().map(|m| format!(" message={m:?}")).unwrap_or_default();
Err(format!("assist API rejected request: http={status} code={code}{message}"))
}
fn text(value: &Value, key: &str) -> Result<String, String> {
value.get(key).and_then(Value::as_str).filter(|s| !s.is_empty() && s.len() <= 16384)
.map(str::to_owned).ok_or_else(|| "assist response missing required string".into())
}
fn share_id(value: &Value) -> Result<String, String> {
let id = text(value, "connect_id")?;
if id.len() > 128 || !id.bytes().all(|c| c.is_ascii_alphanumeric() || c == b'-') {
return Err("assist response invalid device identifier".into());
}
Ok(id)
}
fn generate_code() -> Result<String, String> {
let mut random = std::fs::File::open("/dev/urandom").map_err(|_| "assist random source unavailable")?;
let mut code = String::new();
// Rejection sampling avoids modulo bias (alphabet has 32 entries).
let limit = 256 / ALPHABET.len() * ALPHABET.len();
while code.len() < 8 {
let mut byte = [0u8]; random.read_exact(&mut byte).map_err(|_| "assist random source failed")?;
if (byte[0] as usize) < limit { code.push(ALPHABET[byte[0] as usize % ALPHABET.len()] as char); }
}
Ok(code)
}
fn digest(salt: &str, code: &str) -> String {
let mut hash = Sha256::new(); hash.update(salt.as_bytes()); hash.update(code.as_bytes()); hex::encode(hash.finalize())
}
/// Official: temporary-only signs the temporary code with an empty backup; both adds the custom code
/// as `backup_sign`; custom-only puts the custom code in the primary `sign`.
fn sign_body(control_id: &str, salt: &str, temporary: &str, custom: Option<&str>, verify: Verify, allow: bool) -> Value {
let (primary, backup) = match (verify, custom) {
(Verify::Custom, Some(c)) => (c, None),
(Verify::Both, Some(c)) => (temporary, Some(c)),
_ => (temporary, None),
};
json!({"can_remote_control": allow, "control_id": control_id,
"sign": digest(salt, primary), "backup_sign": backup.map(|c| digest(salt, c)).unwrap_or_default()})
}
fn challenge(value: &Value) -> Option<(&str, &str)> {
let id = value.get("control_id")?.as_str()?; let salt = value.get("salt")?.as_str()?;
(!id.is_empty() && id.len() <= 256 && !salt.is_empty() && salt.len() <= 4096).then_some((id, salt))
}
#[derive(Default)]
struct RetryBackoff(u64);
impl RetryBackoff {
fn next(&mut self) -> std::time::Duration { self.0 = (self.0 + 15).min(99); std::time::Duration::from_secs(self.0) }
}
pub struct Assist {
_lock: std::fs::File,
pub renewed: bool,
device: Credentials,
pub client: std::sync::Arc<UUAuthClient>,
ui: std::sync::Arc<LocalUi>,
code: String,
custom: Option<String>,
id: String,
pub allowed: bool,
verify: Verify,
refresh: Refresh,
code_at: std::time::Instant,
/// Logged-in host: account endpoints and the host's own room (no guest identity).
account: bool,
}
impl Assist {
pub async fn start(shutdown: &mut tokio::sync::watch::Receiver<bool>, service: bool) -> Result<Self, String> {
let ui = std::sync::Arc::new(LocalUi::open_visible(service)?);
let lock = Self::lock()?;
// guest/create rejects an unregistered device (HTTP 422 code 1001, verified live): register the
// Windows device identity first, exactly as account login does (no account involved).
let (config, device) = crate::login::prepare_device().await.map_err(|_| "assist device registration failed")?;
let (custom, verify, refresh, allowed) = Self::settings(&config)?;
let mut retry = RetryBackoff::default();
let client = loop {
if *shutdown.borrow() { return Err("assist stopped".into()); }
let result = tokio::select! {
result = Self::authenticate(&device) => result,
_ = shutdown.changed() => return Err("assist stopped".into()),
_ = ui.command() => return Err("assist stopped before guest identity was available".into()),
};
match result { Ok(client) => break client, Err(error) => {
let delay = retry.next();
// `error` carries only HTTP status / API code numbers or a fixed transport label.
log::warn!("Guest identity request failed: {error}; retry_s={}", delay.as_secs());
tokio::select! {
_ = tokio::time::sleep(delay) => {},
_ = shutdown.changed() => return Err("assist stopped".into()),
_ = ui.command() => return Err("assist stopped before guest identity was available".into()),
}
}}
};
let this = Self { _lock: lock, renewed: false, device, client: std::sync::Arc::new(client), ui, code: generate_code()?, custom, id: String::new(),
allowed, verify, refresh, code_at: std::time::Instant::now(), account: false };
// guest/share/info answers 400/2004 until a guest room exists (verified live), so the ID/code
// are published right after the first room(), which serve() requests before signaling.
Ok(this)
}
fn settings(config: &Value) -> Result<(Option<String>, Verify, Refresh, bool), String> {
let custom = config.get("assist_custom_code").and_then(Value::as_str).map(str::to_owned);
if custom.as_deref().is_some_and(|c| !valid_custom(c)) {
return Err("assist_custom_code requires 8-16 ASCII letters/digits, including both".into());
}
let setting = |key: &str| config.get(key).and_then(Value::as_str).map(str::to_owned);
let verify = setting("assist_verify").as_deref().and_then(Verify::parse).filter(|v| *v == Verify::Temporary || custom.is_some()).unwrap_or(Verify::Temporary);
let refresh = setting("assist_refresh").as_deref().and_then(Refresh::parse).unwrap_or(Refresh::Session);
// Official default is "not allowed"; the switch state persists like isAllowRecipient.
let allowed = std::env::var("UU_ASSIST_ALLOW").ok().as_deref() == Some("1")
|| config.get("assist_allow").and_then(Value::as_bool) == Some(true);
Ok((custom, verify, refresh, allowed))
}
fn lock() -> Result<std::fs::File, String> {
let lock_path = crate::config::path().with_file_name("assist.lock");
if let Some(dir) = lock_path.parent() { std::fs::create_dir_all(dir).map_err(|_| "assist config directory unavailable")?; }
let lock = std::fs::OpenOptions::new().create(true).write(true).mode(0o600).custom_flags(libc::O_NOFOLLOW).open(lock_path)
.map_err(|_| "assist lock unavailable")?;
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 { return Err("another assist host uses this config".into()); }
Ok(lock)
}
/// Remote assistance on a logged-in host, shown in the service's hidden window.
pub fn start_account(client: std::sync::Arc<UUAuthClient>, device: Credentials) -> Result<Self, String> {
let lock = Self::lock()?;
let ui = std::sync::Arc::new(LocalUi::open_service()?);
let config = crate::config::read_fresh()?.unwrap_or_else(|| json!({}));
let (custom, verify, refresh, allowed) = Self::settings(&config)?;
let this = Self { _lock: lock, renewed: false, device, client, ui, code: generate_code()?, custom, id: String::new(),
allowed, verify, refresh, code_at: std::time::Instant::now(), account: true };
this.show()?;
Ok(this)
}
pub fn is_account(&self) -> bool { self.account }
/// Logged-in host: account name for the account card (saved at login, else /api/v1/user/info).
pub async fn load_account_name(&self) {
let saved = crate::config::read_fresh().ok().flatten()
.and_then(|c| c.get("account_name").and_then(Value::as_str).map(str::to_owned)).filter(|n| !n.is_empty());
let name = match saved {
Some(name) => name,
None => match self.client.assist_get("/api/v1/user/info").await {
Ok((200, v)) => v.get("data").and_then(|d| ["nickname", "mobile", "phone"].iter()
.find_map(|k| d.get(*k).and_then(Value::as_str).filter(|s| !s.is_empty()).map(str::to_owned)))
.unwrap_or_else(|| self.device.user_id.clone()),
_ => self.device.user_id.clone(),
},
};
self.ui.set_user(&display_account(&name));
}
/// Sign out: official /api/v1/user/logout (best effort), withdraw the share, drop local credentials.
pub async fn logout(&mut self) {
let _ = self.client.assist_post("/api/v1/user/logout", None).await;
let _ = self.cancel().await;
self.save_many(&[("token", Value::Null), ("csrf", Value::Null), ("user_id", Value::Null), ("account_name", Value::Null)]);
log::info!("Signed out; restarting without an account");
}
pub fn ui(&self) -> std::sync::Arc<LocalUi> { self.ui.clone() }
fn path(&self, guest: &'static str) -> &'static str {
if !self.account { return guest; }
match guest { INFO => ACCOUNT_INFO, CANCEL => ACCOUNT_CANCEL, SIGN => ACCOUNT_SIGN, CONTROL_MODE => ACCOUNT_CONTROL_MODE, other => other }
}
/// Logged-in host: publish the share ID/code once its own room exists (same ordering as guests).
pub async fn ensure_published(&mut self) -> Result<(), String> {
if self.id.is_empty() { self.publish().await } else { Ok(()) }
}
async fn authenticate(device: &Credentials) -> Result<UUAuthClient, String> {
let client = UUAuthClient::new(device.clone());
let (status, value) = client.assist_post(CREATE, None).await?;
let data = response(status, &value)?;
Ok(UUAuthClient::new_guest(device.clone(), text(data, "guest_id")?, text(data, "token")?))
}
async fn post(&mut self, path: &'static str, body: Option<&Value>) -> Result<Value, String> {
let path = self.path(path);
let (mut status, mut value) = if path == ACCOUNT_INFO { self.client.assist_get(path).await? } else { self.client.assist_post(path, body).await? };
if self.account { return response(status, &value).map(Clone::clone); }
// Official wrapper refreshes on 1120 and retries once, rather than on a guessed TTL.
if value.get("code").and_then(Value::as_i64) == Some(crate::auth::TOKEN_INVALID) {
self.client = std::sync::Arc::new(Self::authenticate(&self.device).await?);
self.renewed = true;
(status, value) = self.client.assist_post(path, body).await?;
}
response(status, &value).map(Clone::clone)
}
async fn publish(&mut self) -> Result<(), String> {
self.id = share_id(&self.post(INFO, None).await?)?;
self.show()
}
pub async fn room(&mut self) -> Result<RoomData, String> {
let value = self.post(ROOM, None).await?;
if self.renewed || self.id.is_empty() {
if let Err(error) = self.publish().await { let _ = self.cancel().await; return Err(error); }
self.renewed = false;
}
serde_json::from_value(value).map_err(|_| "assist room response malformed".into())
}
pub async fn challenge(&mut self, value: &Value) -> Result<(), String> {
let (control, salt) = challenge(value).ok_or("assist challenge malformed")?;
self.post(SIGN, Some(&sign_body(control, salt, &self.code, self.custom.as_deref(), self.verify, self.allowed))).await?;
Ok(())
}
/// Answer the cloud's `get_control_mode` push (data {control_id}). Official Windows host
/// (GameViewerServer RemoteAssistCode::respRemoteGetControlMode -> NrdBusinessEntry::uploadControlMode)
/// posts {control_id, allow_control, control_mode: by_password|by_confirmation|password_confirmation}.
/// Only the temporary/custom code mode is implemented, so this host reports `by_password`.
pub async fn control_mode(&mut self, value: &Value) -> Result<(), String> {
let control = value.get("control_id").and_then(Value::as_str).filter(|s| !s.is_empty() && s.len() <= 256)
.ok_or("assist control mode request malformed")?;
self.post(CONTROL_MODE, Some(&json!({"control_id": control, "allow_control": self.allowed, "control_mode": "by_password"}))).await.map(|_| ())
}
/// The code the controller types: the custom code in custom-only mode, else the temporary one.
fn show(&self) -> Result<(), String> {
let code = match (self.verify, &self.custom) { (Verify::Custom, Some(c)) => c.as_str(), _ => self.code.as_str() };
self.ui.show(&self.id, code, self.allowed, self.verify, self.refresh, self.custom.is_some())
}
/// Saves one assist setting into the owner's 0600 config (custom code included, never logged).
fn save_many(&self, entries: &[(&str, Value)]) {
let mut cfg = std::fs::read(crate::config::path()).ok().and_then(|b| serde_json::from_slice::<Value>(&b).ok())
.filter(Value::is_object).unwrap_or_else(|| json!({}));
if let Some(map) = cfg.as_object_mut() { for (k, v) in entries { if v.is_null() { map.remove(*k); } else { map.insert((*k).to_owned(), v.clone()); } } }
if crate::login::write_config(&cfg).is_err() { log::warn!("Account settings could not be saved"); }
}
fn save(&self, key: &str, value: Value) {
// Re-read the file: config::file() is a startup snapshot that predates device registration,
// so writing it back would drop device_id (and earlier saves) and change the device ID.
let mut cfg = std::fs::read(crate::config::path()).ok().and_then(|b| serde_json::from_slice::<Value>(&b).ok())
.filter(Value::is_object).unwrap_or_else(|| json!({}));
cfg[key] = value;
if crate::login::write_config(&cfg).is_err() { log::warn!("Assist setting could not be saved: key={key}"); }
}
pub fn reset(&mut self) -> Result<(), String> { self.code = generate_code()?; self.code_at = std::time::Instant::now(); self.show() }
pub fn allow(&mut self) -> Result<(), String> { self.allowed = true; self.save("assist_allow", json!(true)); self.show() }
pub fn deny(&mut self) -> Result<(), String> { self.allowed = false; self.save("assist_allow", json!(false)); self.show() }
pub fn set_verify(&mut self, verify: Verify) -> Result<(), String> {
if verify != Verify::Temporary && self.custom.is_none() { return self.show(); } // UI asks for a code first
self.verify = verify; self.save("assist_verify", json!(verify.name())); self.show()
}
pub fn set_refresh(&mut self, refresh: Refresh) -> Result<(), String> {
self.refresh = refresh; self.code_at = std::time::Instant::now(); self.save("assist_refresh", json!(refresh.name())); self.show()
}
pub fn set_custom(&mut self, code: String) -> Result<(), String> {
if !valid_custom(&code) { return self.show(); }
self.custom = Some(code.clone()); self.save("assist_custom_code", json!(code));
if self.verify == Verify::Temporary { self.verify = Verify::Custom; self.save("assist_verify", json!(self.verify.name())); }
self.show()
}
/// After the last desktop session: rotate only in "每次远控结束" mode.
pub fn session_ended(&mut self) -> Result<(), String> { if self.refresh == Refresh::Session { self.reset() } else { Ok(()) } }
/// Periodic rotation for the hourly/12 h/24 h settings.
pub fn tick(&mut self) -> Result<(), String> {
match self.refresh.period() { Some(p) if self.code_at.elapsed() >= p => self.reset(), _ => Ok(()) }
}
pub fn commands(&self, shutdown: tokio::sync::watch::Sender<bool>) -> (tokio::sync::mpsc::Receiver<Command>, tokio::task::JoinHandle<()>) {
let (tx, rx) = tokio::sync::mpsc::channel(4);
let ui = self.ui.clone();
let task = tokio::spawn(async move {
loop {
let command = tokio::select! { command = ui.command() => command, _ = tx.closed() => return };
if matches!(command, Command::Stop) { let _ = shutdown.send(true); return; }
match tx.try_send(command) {
Ok(()) | Err(tokio::sync::mpsc::error::TrySendError::Full(_)) => {},
Err(tokio::sync::mpsc::error::TrySendError::Closed(_)) => return,
}
}
});
(rx, task)
}
pub async fn cancel(&mut self) -> Result<(), String> { self.post(CANCEL, None).await.map(|_| ()) }
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn local_terminal_display_and_explicit_commands() {
// Private PTY pair only, never the user's actual terminal; all values synthetic.
let pair = nix::pty::openpty(None, None).unwrap();
let slave = std::fs::File::from(pair.slave);
unsafe { libc::fcntl(slave.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK); }
let ui = LocalUi::Tty(tokio::io::unix::AsyncFd::new(slave).unwrap());
let mut master = std::fs::File::from(pair.master);
ui.show("fixture-123", "FIXTURE8", false, Verify::Temporary, Refresh::Session, false).unwrap();
// A PTY may deliver the banner in several chunks: read until complete (bounded).
let mut text = String::new();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
let complete = |t: &str| t.contains("fixture-123") && t.contains("FIXTURE8") && t.contains("false") && t.contains("off=");
while !complete(&text) && std::time::Instant::now() < deadline {
let mut bytes = [0u8; 1024];
match master.read(&mut bytes) { Ok(n) if n > 0 => text.push_str(&String::from_utf8_lossy(&bytes[..n])), _ => break }
}
assert!(complete(&text));
for (input, expected) in [(b"unknown\nallow\n".as_slice(), 0), (b"reset\n".as_slice(), 1), (b"off\n".as_slice(), 2)] {
master.write_all(input).unwrap();
let command = tokio::time::timeout(std::time::Duration::from_secs(2), ui.command()).await.unwrap();
assert!(matches!((command, expected), (Command::Allow, 0) | (Command::Reset, 1) | (Command::Stop, 2)));
}
}
#[test]
fn official_challenge_sign_and_shape() {
// Synthetic fixture, independently calculated SHA256("saltABC234XY").
let body = sign_body("fixture-control", "salt", "ABC234XY", None, Verify::Temporary, false);
assert_eq!(body.as_object().unwrap().len(), 4);
assert_eq!(body["can_remote_control"], false);
assert_eq!(body["control_id"], "fixture-control");
assert_eq!(body["sign"], "dc747ee8adb0e591f5ff4ab6cabcaf3a0ec312851580f225d4ca140766229c94");
assert_eq!(body["backup_sign"], "");
let both = sign_body("fixture", "salt", "ABC234XY", Some("test1234"), Verify::Both, true);
assert_ne!(both["sign"], both["backup_sign"]);
assert_eq!(both["can_remote_control"], true);
}
#[test]
fn rejects_missing_or_unbounded_challenges_and_terminal_injection() {
for value in [json!({}), json!({"control_id":"x", "salt":""}), json!({"control_id":12,"salt":"s"}), json!({"control_id":"x","salt":"s".repeat(4097)})] {
assert!(challenge(&value).is_none());
}
assert!(challenge(&json!({"control_id":"fixture", "salt":"fixture"})).is_some());
assert!(share_id(&json!({"connect_id":"fixture-123"})).is_ok());
for id in ["", "\u{1b}[2J", "a\nb", "x\u{7}"] { assert!(share_id(&json!({"connect_id":id})).is_err()); }
}
#[test]
fn responses_do_not_disclose_untrusted_server_errors() {
let error = response(422, &json!({"code":1120,"msg":"synthetic-secret","data":{"token":"synthetic-secret"}})).unwrap_err();
assert!(!error.contains("synthetic-secret"));
assert!(response(200, &json!({"code":0})).unwrap().is_null());
assert!(text(&Value::Null, "token").is_err());
assert_eq!(text(&json!({"guest_id":"fixture-guest"}), "guest_id").unwrap(), "fixture-guest");
}
#[test]
fn official_guest_failure_retry_schedule() {
let mut retry = RetryBackoff::default();
let actual: Vec<_> = (0..9).map(|_| retry.next().as_secs()).collect();
assert_eq!(actual, [15,30,45,60,75,90,99,99,99]);
}
#[test]
fn secure_temporary_code_format() {
for _ in 0..64 { let code = generate_code().unwrap(); assert_eq!(code.len(),8); assert!(code.bytes().all(|b| ALPHABET.contains(&b))); }
}
}
+85 -5
View File
@@ -73,7 +73,7 @@ pub struct ApiResponse<T> {
pub data: Option<T>,
}
#[derive(Debug, Clone, Deserialize)]
#[derive(Clone, Deserialize)]
pub struct RoomData {
pub signaling_server: String,
pub token: String,
@@ -81,9 +81,14 @@ pub struct RoomData {
pub ws_connect_timeout_ms: Option<u64>,
}
impl std::fmt::Debug for RoomData {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.write_str("RoomData { .. }") }
}
pub struct UUAuthClient {
pub creds: Credentials,
http: reqwest::Client,
guest_id: Option<String>,
}
impl UUAuthClient {
@@ -92,7 +97,16 @@ impl UUAuthClient {
.timeout(std::time::Duration::from_secs(12))
.build()
.unwrap();
Self { creds, http }
Self { creds, http, guest_id: None }
}
/// Explicit guest identity: never inherits account Authorization/cookies.
/// Official ApiDefaultHeaders 0x1003853ac/0x1003853f8 (see assist evidence).
pub fn new_guest(mut device: Credentials, guest_id: String, token: String) -> Self {
device.user_id.clear(); device.csrf.clear(); device.token = token;
let mut client = Self::new(device);
client.guest_id = Some(guest_id);
client
}
/// 计算网易 NRD HMAC-SHA256 签名
@@ -147,6 +161,7 @@ impl UUAuthClient {
("x-param-system-id", &self.creds.system_id), ("x-param-user-id", &self.creds.user_id)] {
if !value.is_empty() { param_map.insert(key.into(), value.clone()); }
}
if let Some(id) = &self.guest_id { param_map.insert("x-param-guest-id".into(), id.clone()); }
param_map.insert("x-param-ts".into(), ts);
let sign = self.sign_request(method, path, &param_map, body_str);
@@ -160,10 +175,12 @@ impl UUAuthClient {
);
if !self.creds.token.is_empty() {
if let Ok(v) = HeaderValue::from_str(&format!("Bearer {}", self.creds.token)) { headers.insert("Authorization", v); }
if let Ok(v) = HeaderValue::from_str(&format!("nrd_access_token={}; nrd_csrf_access_token={}", self.creds.token, self.creds.csrf)) {
headers.insert("Cookie", v);
if self.guest_id.is_none() {
if let Ok(v) = HeaderValue::from_str(&format!("nrd_access_token={}; nrd_csrf_access_token={}", self.creds.token, self.creds.csrf)) {
headers.insert("Cookie", v);
}
if let Ok(v) = HeaderValue::from_str(&self.creds.csrf) { headers.insert("X-CSRF-TOKEN", v); }
}
if let Ok(v) = HeaderValue::from_str(&self.creds.csrf) { headers.insert("X-CSRF-TOKEN", v); }
}
for (k, v) in param_map {
@@ -189,6 +206,34 @@ impl UUAuthClient {
Ok((status, value))
}
/// Guest APIs use requestPlain for empty requests; sign the actual empty body.
/// Errors intentionally exclude response text and URL (both can contain secrets).
pub async fn assist_post(&self, path: &str, body: Option<&serde_json::Value>) -> Result<(u16, serde_json::Value), String> {
self.assist_send(self.assist_request(path, body)?).await
}
/// Account share info is a GET (POST answers 405, verified live).
pub async fn assist_get(&self, path: &str) -> Result<(u16, serde_json::Value), String> {
let request = self.http.get(format!("{BASE_URL}{path}")).headers(self.build_headers("GET", path, "")).build()
.map_err(|_| "assist request construction failed")?;
self.assist_send(request).await
}
async fn assist_send(&self, request: reqwest::Request) -> Result<(u16, serde_json::Value), String> {
let response = self.http.execute(request)
.await.map_err(|_| "assist request transport failed")?;
let status = response.status().as_u16();
let bytes = response.bytes().await.map_err(|_| "assist response read failed")?;
if bytes.len() > 65536 { return Err("assist response too large".into()); }
let value = serde_json::from_slice(&bytes).map_err(|_| "assist response malformed")?;
Ok((status, value))
}
fn assist_request(&self, path: &str, body: Option<&serde_json::Value>) -> Result<reqwest::Request, String> {
let body = body.map(serde_json::to_string).transpose().map_err(|_| "assist request encoding failed")?.unwrap_or_default();
self.http.post(format!("{BASE_URL}{path}"))
.headers(self.build_headers("POST", path, &body)).body(body).build()
.map_err(|_| "assist request construction failed".into())
}
/// 向网易服务器请求创建房间,获取最新的信令服务器与鉴权 Token
pub async fn create_room(&self) -> Result<RoomData, RoomError> {
let (status, body) = self.post_json("/api/v1/room/create", &serde_json::json!({})).await.map_err(RoomError::Other)?;
@@ -231,3 +276,38 @@ mod room_lifetime_tests {
assert_eq!(room_token_lifetime("h.invalid.s",1000),None);
}
}
#[cfg(test)]
mod guest_tests {
use super::*;
#[test]
fn official_request_plain_body_and_sanitized_room_debug() {
let client = UUAuthClient::new_guest(Credentials { sign_key: "fixture-key".into(), ..Default::default() },
"fixture-guest".into(), "fixture-token".into());
let request = client.assist_request("/api/v1/guest/create", None).unwrap();
assert_eq!(request.method(), reqwest::Method::POST);
assert_eq!(request.body().unwrap().as_bytes(), Some(&b""[..]));
let other = client.assist_request("/api/v1/guest/create", Some(&serde_json::json!({}))).unwrap();
assert_eq!(other.body().unwrap().as_bytes(), Some(&b"{}"[..]));
assert_ne!(request.headers()["x-param-sign"], other.headers()["x-param-sign"]);
let room: RoomData = serde_json::from_value(serde_json::json!({"signaling_server":"wss://fixture.invalid", "token":"synthetic-room-secret"})).unwrap();
assert!(!format!("{room:?}").contains("synthetic-room-secret"));
assert!(serde_json::from_value::<RoomData>(serde_json::json!({"token":42})).is_err());
}
#[test]
fn guest_signs_guest_id_and_never_inherits_account_identity() {
let account = Credentials { user_id: "fixture-account".into(), token: "fixture-account-token".into(),
csrf: "fixture-account-csrf".into(), client_id: "fixture-client".into(),
device_id: "fixture-device".into(), sign_key: "fixture-sign-key".into(), ..Default::default() };
let client = UUAuthClient::new_guest(account, "fixture-guest".into(), "fixture-guest-token".into());
let headers = client.build_headers("POST", "/api/v1/guest/room/create", "");
assert_eq!(headers["authorization"], "Bearer fixture-guest-token");
assert_eq!(headers["x-param-guest-id"], "fixture-guest");
for key in ["x-param-user-id", "cookie", "x-csrf-token"] { assert!(!headers.contains_key(key)); }
let params: BTreeMap<String,String> = headers.iter().filter_map(|(key, value)|
key.as_str().starts_with("x-param-").then(|| (key.to_string(), value.to_str().unwrap().to_owned()))).collect();
assert_eq!(headers["x-param-sign"], client.sign_request("POST", "/api/v1/guest/room/create", &params, ""));
let mut without_guest = params; without_guest.remove("x-param-guest-id");
assert_ne!(headers["x-param-sign"], client.sign_request("POST", "/api/v1/guest/room/create", &without_guest, ""));
}
}
+37 -5
View File
@@ -19,9 +19,14 @@ pub const QUALITY_AUTO: u64 = 5;
pub const QUALITY_CUSTOM: u64 = 6;
/// FeatureFlag.ff_capture_setting we declare: fps, preset quality and custom bitrate.
/// (Chroma 4:4:4, DPI scaling and HDR are higher versions and are not implemented.)
/// Versions are cumulative (official FF_CaptureSetting enum: 3 CHROMA_SAMPLING, 4 CUSTOM_BITRATE,
/// 5 DPI_SCALE, 6 HDR), so 4 also tells the viewer we accept a chroma format (真彩).
pub const FEATURE_VERSION: u64 = 4;
/// Official GvPb_ChromaFormat values (CaptureSettingRequest field 7, CaptureSettingSync field 3).
pub const CHROMA_420: u64 = 1;
pub const CHROMA_444: u64 = 3;
const MIN_FPS: u32 = 5;
const MAX_FPS: u32 = 144;
@@ -33,10 +38,12 @@ pub struct VideoSettings {
pub custom_mbps: u32,
/// Scaled stream size (其他分辨率); None streams the native desktop size.
pub output: Option<(u32, u32)>,
/// CHROMA_420 or CHROMA_444 (真彩); 4:4:4 only when the encoder pipeline supports it.
pub chroma: u64,
}
impl Default for VideoSettings {
fn default() -> Self { Self { fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None } }
fn default() -> Self { Self { fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None, chroma: CHROMA_420 } }
}
/// Selectable smaller stream sizes with the desktop's aspect ratio (even dimensions).
@@ -95,6 +102,10 @@ fn fps_from_option(value: u64) -> Option<u64> {
/// Applies a capture-setting RPC to `settings` and returns the RpcResponse payload (Message 22),
/// or None when the RPC is not a capture/fps/quality setting.
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
apply_rpc(rpc, settings, native, crate::video::full_chroma_available())
}
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), full_chroma: bool) -> Option<Vec<u8>> {
let header = message(rpc, 1).unwrap_or(&[]);
let mut next = *settings.borrow();
if let Some(request) = message(rpc, 2) {
@@ -106,6 +117,13 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_mbps = bitrate as u32; }
// Field 7 chorma_format (sic): 3 = 4:4:4 when 真彩 is on, 1 = 4:2:0. The Sync reports what is encoded.
match number(&fields, 7) {
Some(CHROMA_444) if full_chroma => next.chroma = CHROMA_444,
Some(CHROMA_444) => { log::info!("Chroma 4:4:4 requested; this encoder pipeline only supports 4:2:0"); next.chroma = CHROMA_420; }
Some(CHROMA_420) => next.chroma = CHROMA_420,
_ => {}
}
// ChooseResolutionType 3 = follow remote (native); otherwise pixel size, else logical size.
if number(&fields, 10) == Some(3) { next.output = None; }
else if let Some((w, h)) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6))) {
@@ -129,7 +147,7 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
}
next.fps = next.fps.clamp(MIN_FPS, MAX_FPS);
settings.send_if_modified(|current| if *current != next {
log::info!("Desktop video settings: fps={} quality={} max_kbps={:?} output={:?}", next.fps, next.quality, next.max_kbps(), next.output);
log::info!("Desktop video settings: fps={} quality={} max_kbps={:?} output={:?} chroma={}", next.fps, next.quality, next.max_kbps(), next.output, next.chroma);
*current = next; true
} else { false });
let mut out = Vec::new();
@@ -156,7 +174,7 @@ pub fn sync_payload(settings: &VideoSettings, native: (u32, u32)) -> Vec<u8> {
let mut out = Vec::new();
put_varint(1, u64::from(settings.fps), &mut out);
put_varint(2, settings.quality, &mut out);
put_varint(3, 1, &mut out); // ChromaFormat_420
put_varint(3, settings.chroma, &mut out);
if settings.custom_mbps > 0 { put_varint(4, u64::from(settings.custom_mbps), &mut out); }
put_varint(5, u64::from(size.0), &mut out);
put_varint(6, u64::from(size.1), &mut out);
@@ -187,7 +205,7 @@ mod tests {
put_varint(18, 30, &mut body);
let request = rpc(77, 2, &body);
let response = handle_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(*rx.borrow(), VideoSettings { fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None });
assert_eq!(*rx.borrow(), VideoSettings { fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None, chroma: CHROMA_420 });
assert_eq!(rx.borrow().max_kbps(), Some(2_000));
let fields = decode_wire(&response).unwrap();
assert_eq!(message(&fields, 1), Some(&[8u8, 77][..]));
@@ -208,6 +226,20 @@ mod tests {
assert!(handle_rpc(&decode_wire(&rpc(3, 9, &[])).unwrap(), &tx, (1920, 1080)).is_none());
}
#[test]
fn true_color_request_selects_444_only_when_the_encoder_supports_it() {
let (tx, rx) = watch::channel(VideoSettings::default());
// Observed Mac viewer request with 真彩 on: field 7 = 3.
let request = rpc(5, 2, &[8, 2, 16, 4, 56, 3, 144, 1, 60]);
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), false).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_420);
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_444);
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_444));
apply_rpc(&decode_wire(&rpc(6, 2, &[56, 1])).unwrap(), &tx, (1920, 1080), true).unwrap();
assert_eq!(rx.borrow().chroma, CHROMA_420);
}
#[test]
fn resolution_requests_scale_below_native_only() {
let (tx, rx) = watch::channel(VideoSettings::default());
+61 -2
View File
@@ -43,8 +43,12 @@ struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collecti
/// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift.
#[derive(Default)]
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
/// Mac viewer with 「使用 macOS 快捷键」 off sends Cmd as VK_LWIN (verified: Cmd 0x5B, Option 0xA4,
/// Ctrl 0xA2). Cmd is held back until we know whether it starts a Mac shortcut.
#[derive(Default)]
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
pub struct InputInjector { serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput> }
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput> }
impl InputInjector {
pub fn new() -> Self {
@@ -55,7 +59,7 @@ impl InputInjector {
Err(e) => { log::warn!("uinput unavailable ({}); using the desktop input path. See README for the udev rule.", e.kind()); None }
}
} else { None };
Self { serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
}
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
@@ -167,8 +171,62 @@ impl InputInjector {
shift
}
/// The current desktop controller is the macOS viewer (connect header controller_platform).
pub fn set_mac_controller(&self, mac: bool) {
self.mac_controller.store(mac, std::sync::atomic::Ordering::Relaxed);
*self.cmd.lock().unwrap() = CmdState::default();
}
fn terminal_focused(&self) -> bool {
self.backend == crate::desktop_backend::DesktopBackend::X11 && std::env::var_os("DISPLAY").is_some()
&& !std::env::var("UU_TERMINAL_SHORTCUTS").is_ok_and(|v| v == "0")
&& unsafe { x11_terminal_shortcut_state() } & 1 != 0
}
/// Mac habits for a Mac viewer with 「使用 macOS 快捷键」 off: Cmd+C/V/A/F/X/Z (the keys that option
/// lists) become Ctrl+key, and in a focused terminal Cmd+C/V become Ctrl+Shift+C/V (copy/paste)
/// while Ctrl+C still interrupts. Other Cmd combos, and Cmd alone, stay Super. Returns true when handled.
fn mac_cmd(&self, key: i32, is_press: bool) -> bool {
const SUPER_L: u64 = 0xffeb; const CONTROL_L: u64 = 0xffe3; const SHIFT_L: u64 = 0xffe1;
let mut st = self.cmd.lock().unwrap();
if matches!(key, 0x5b | 0x5c) {
if is_press { st.held = true; st.pending = true; st.passthrough = false; }
else {
if st.passthrough { self.inject_key(SUPER_L, false); }
else if st.pending { self.inject_key(SUPER_L, true); self.inject_key(SUPER_L, false); }
st.held = false; st.pending = false; st.passthrough = false;
}
return true;
}
if !is_press {
let Some(shifted) = st.combos.remove(&key) else { return false };
self.key_symbol_event(key, false);
if shifted { self.inject_key(SHIFT_L, false); }
self.inject_key(CONTROL_L, false);
return true;
}
if !st.held { return false; }
// Shift/Option/Ctrl pressed with Cmd (e.g. Cmd+Shift+Z) must not decide the combo yet.
if matches!(key, 0x10..=0x12 | 0xa0..=0xa5) { return false; }
if st.combos.contains_key(&key) { self.key_symbol_event(key, true); return true; } // autorepeat
if matches!(key, 0x41 | 0x43 | 0x46 | 0x56 | 0x58 | 0x5a) && !st.passthrough {
st.pending = false;
let shifted = matches!(key, 0x43 | 0x56) && self.terminal_focused();
self.inject_key(CONTROL_L, true);
if shifted { self.inject_key(SHIFT_L, true); }
self.key_symbol_event(key, true);
st.combos.insert(key, shifted);
static NOTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if NOTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 4 { log::info!("Mac shortcut: Cmd combo sent as Ctrl{}", if shifted { "+Shift (terminal)" } else { "" }); }
return true;
}
if st.pending { self.inject_key(SUPER_L, true); st.pending = false; st.passthrough = true; }
false
}
pub fn windows_key_event(&self, key: i32, is_press: bool) {
let _serial=self.serial.lock().unwrap();
if self.mac_controller.load(std::sync::atomic::Ordering::Relaxed) && self.mac_cmd(key, is_press) { return; }
if self.terminal_shift(key, is_press) {
const SHIFT_L: u64 = 0xffe1;
if is_press {
@@ -221,6 +279,7 @@ impl InputInjector {
}
*held=HeldInput::default();
*self.shortcuts.lock().unwrap()=Shortcuts::default();
*self.cmd.lock().unwrap()=CmdState::default();
}
// Per-injector budgets cover missing bindings, locked sessions, stale handles
// and D-Bus errors. Never include keys, coordinates, text or portal tokens.
+26 -7
View File
@@ -143,7 +143,7 @@ fn qr_rgba(content: &str, scale: usize, quiet: usize) -> Result<(Vec<u8>, usize)
Ok((rgba, edge))
}
fn write_config(cfg: &Value) -> Result<std::path::PathBuf, String> {
pub(crate) fn write_config(cfg: &Value) -> Result<std::path::PathBuf, String> {
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let path = crate::config::path();
@@ -227,8 +227,8 @@ pub async fn run(gui: bool) -> Result<(), String> {
result.map(|_| ())
}
/// Returns the account nickname (or user id) on success.
async fn flow(ui: &LoginUi) -> Result<String, String> {
/// Local installation identifiers only; guest creation does not require device/init.
pub fn prepare_identity() -> Result<(Value, Credentials), String> {
let mut cfg = crate::config::file()?.cloned().unwrap_or_else(|| json!({}));
let get = |cfg: &Value, k: &str| std::env::var(format!("UU_{}", k.to_uppercase())).ok().filter(|v| !v.is_empty())
.or_else(|| cfg.get(k).and_then(|v| v.as_str()).map(str::to_owned)).unwrap_or_default();
@@ -237,8 +237,16 @@ async fn flow(ui: &LoginUi) -> Result<String, String> {
for (key, make) in [("client_id", random_uuid as fn() -> String), ("system_id", || random_uuid().to_uppercase()), ("machine_guid", machine_guid)] {
if get(&cfg, key).is_empty() { cfg[key] = json!(make()); }
}
let mut creds = Credentials { client_id: get(&cfg, "client_id"), system_id: get(&cfg, "system_id"), sign_key, ..Default::default() };
let creds = Credentials { client_id: get(&cfg, "client_id"), system_id: get(&cfg, "system_id"), device_id: get(&cfg, "device_id"), sign_key, ..Default::default() };
write_config(&cfg)?;
Ok((cfg, creds))
}
pub async fn prepare_device() -> Result<(Value, Credentials), String> {
let (mut cfg, mut creds) = prepare_identity()?;
let get = |cfg: &Value, k: &str| std::env::var(format!("UU_{}", k.to_uppercase())).ok().filter(|v| !v.is_empty())
.or_else(|| cfg.get(k).and_then(|v| v.as_str()).map(str::to_owned)).unwrap_or_default();
if get(&cfg, "device_id").is_empty() {
let body = json!({
"name": hostname(), "client_id": creds.client_id, "system_id": creds.system_id, "machine_guid": get(&cfg, "machine_guid"),
@@ -248,11 +256,17 @@ async fn flow(ui: &LoginUi) -> Result<String, String> {
let (status, resp) = UUAuthClient::new(creds.clone()).post_json("/api/v1/device/windows/init", &body).await?;
let d = data("device init", status, &resp)?;
let id = d.get("device_id").and_then(|v| v.as_str()).ok_or("device init returned no device_id")?;
println!("Registered device: name={} id={}", d.get("alias").and_then(|v| v.as_str()).unwrap_or(""), id);
log::info!("Registered local device identity");
cfg["device_id"] = json!(id);
write_config(&cfg)?; // keep the device even if the QR step is abandoned
}
creds.device_id = get(&cfg, "device_id");
Ok((cfg, creds))
}
/// Returns the account nickname (or user id) on success.
pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let (mut cfg, creds) = prepare_device().await?;
let client = UUAuthClient::new(creds.clone());
loop {
@@ -274,7 +288,7 @@ async fn flow(ui: &LoginUi) -> Result<String, String> {
let mut file=std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(path).map_err(|e|e.to_string())?;
file.write_all(&crate::cursor::encode_png(edge as u32,edge as u32,&rgba)).map_err(|e|e.to_string())?;
}
println!("\nScan with the UU Remote mobile app (网易UU远程 App 扫码登录):\n{}", render_qr(&url)?);
if !ui.quiet() { println!("\nScan with the UU Remote mobile app (网易UU远程 App 扫码登录):\n{}", render_qr(&url)?); }
// Status is a long poll: send the state already shown (server enum 1..4; observed:
// 1 waiting, 2 scanned, 4 after the phone confirmed); the server answers when it changes.
let mut login_status = 1i64;
@@ -315,8 +329,13 @@ async fn flow(ui: &LoginUi) -> Result<String, String> {
cfg["token"] = json!(token);
cfg["user_id"] = json!(user);
cfg["csrf"] = json!(csrf_from_token(token).ok_or("token carries no csrf claim")?);
let path = write_config(&cfg)?;
let nickname = d.get("nickname").and_then(|v| v.as_str()).unwrap_or("");
if !nickname.is_empty() { cfg["account_name"] = json!(nickname); }
// Keep settings saved meanwhile (e.g. from the assist card): merge into the fresh file.
if let Ok(Some(Value::Object(fresh))) = crate::config::read_fresh() {
for (k, v) in fresh { if cfg.get(&k).is_none() { cfg[k] = v; } }
}
let path = write_config(&cfg)?;
println!("Logged in as {} ({}); saved to {}", nickname, user, path.display());
return Ok(if nickname.is_empty() { user.to_string() } else { nickname.to_string() });
}
+14 -4
View File
@@ -15,13 +15,13 @@ extern "C" {
#[derive(Clone, Copy)]
pub enum Tone { Info = 0, Ok = 1, Error = 2 }
pub struct LoginUi { shown: bool }
pub struct LoginUi { shown: bool, attached: bool }
#[cfg(uu_gtk)]
fn cstr(s: &str) -> std::ffi::CString { std::ffi::CString::new(s.replace('\0', "")).unwrap_or_default() }
impl LoginUi {
pub fn none() -> Self { LoginUi { shown: false } }
pub fn none() -> Self { LoginUi { shown: false, attached: false } }
/// Opens the window when built with GTK and a display is present; falls back silently otherwise.
#[allow(unused_variables)]
@@ -30,13 +30,23 @@ impl LoginUi {
if std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() {
let (n, o, c, g) = (cstr(name), cstr(os), cstr(cpu), cstr(gpu));
if unsafe { uu_login_ui_start(n.as_ptr(), o.as_ptr(), c.as_ptr(), g.as_ptr()) } == 0 {
return LoginUi { shown: true };
return LoginUi { shown: true, attached: false };
}
eprintln!("Login window unavailable; using the terminal QR code");
}
LoginUi::none()
}
/// Account card of the host's own main window (already open): the QR stays in the window only
/// (a service's stdout is the journal and the QR URL is a login ticket), and dropping this
/// handle never closes the shared window.
pub fn attached() -> Self {
#[cfg(uu_gtk)]
{ unsafe { uu_login_ui_start(std::ptr::null(), std::ptr::null(), std::ptr::null(), std::ptr::null()) }; LoginUi { shown: true, attached: true } }
#[cfg(not(uu_gtk))]
LoginUi { shown: false, attached: true }
}
pub fn quiet(&self) -> bool { self.attached }
pub fn shown(&self) -> bool { self.shown }
#[allow(unused_variables)]
@@ -73,6 +83,6 @@ impl LoginUi {
impl Drop for LoginUi {
fn drop(&mut self) {
#[cfg(uu_gtk)]
if self.shown { unsafe { uu_login_ui_close() } }
if self.shown && !self.attached { unsafe { uu_login_ui_close() } }
}
}
+301 -54
View File
@@ -7,6 +7,7 @@ mod network_diagnostics;
mod session_ice;
mod wayland;
mod auth;
mod assist;
mod config;
mod login;
mod login_ui;
@@ -53,18 +54,103 @@ use std::sync::Arc;
use tokio::sync::{mpsc, Mutex};
use webrtc::WebRtcSession;
/// Set before a normal return when the host must come back in the other mode (signed in / out).
static RESTART: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// Re-executes this host; the new instance opens its window so the user sees the result.
fn restart_host() -> ! {
use std::os::unix::process::CommandExt;
let error = std::process::Command::new("/proc/self/exe").args(std::env::args_os().skip(1)).env("UU_SHOW_WINDOW", "1").exec();
eprintln!("restart failed: {error}");
std::process::exit(1);
}
/// systemd user unit running this process (from /proc/self/cgroup), e.g. "uuremote-native.service".
fn systemd_unit() -> Option<String> {
std::env::var_os("INVOCATION_ID")?;
let cgroup = std::fs::read_to_string("/proc/self/cgroup").ok()?;
cgroup.lines().find_map(|l| l.rsplit('/').next().filter(|u| u.ends_with(".service")).map(str::to_owned))
}
fn display_present() -> bool { std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() }
/// SIGUSR1 (`uuremote-server show`) opens the host window.
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
// Install the handler before publishing the pid: SIGUSR1's default action terminates the process.
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
write_host_pid();
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
}
fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.pid") }
/// Lets `uuremote-server show` find this host service to open its window (SIGUSR1).
fn write_host_pid() {
use std::os::unix::fs::OpenOptionsExt;
use std::io::Write;
if let Ok(mut f) = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(host_pid_path()) {
let _ = write!(f, "{}", std::process::id());
}
}
/// `uuremote-server show` (desktop launcher): open the running host's window, or start the host in the
/// foreground with its window when none runs (e.g. no systemd unit installed yet).
fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
let running = std::fs::read_to_string(host_pid_path()).ok().and_then(|s| s.trim().parse::<i32>().ok()).filter(|p| *p > 1)
.filter(|pid| {
let exe = std::fs::read_link(format!("/proc/{pid}/exe")).ok();
let own = std::env::current_exe().ok();
exe.is_some() && exe.as_ref().and_then(|p| p.file_name()) == own.as_ref().and_then(|p| p.file_name())
});
if let Some(pid) = running {
if unsafe { libc::kill(pid, libc::SIGUSR1) } == 0 { return Ok(()); }
}
// Stopped from the tray but installed as a user service: start the service (not a second,
// unmanaged host), wait for it to publish its pid, then ask it to show the window.
let unit = std::env::var("UU_SERVICE_UNIT").unwrap_or_else(|_| "uuremote-native.service".into());
let installed = std::process::Command::new("systemctl").args(["--user", "cat", &unit])
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null()).status().is_ok_and(|s| s.success());
if installed && std::process::Command::new("systemctl").args(["--user", "start", &unit]).status().is_ok_and(|s| s.success()) {
let before = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok();
for _ in 0..60 {
std::thread::sleep(std::time::Duration::from_millis(500));
let fresh = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok().is_some_and(|t| Some(t) != before);
let pid = std::fs::read_to_string(host_pid_path()).ok().and_then(|s| s.trim().parse::<i32>().ok());
if let (true, Some(pid)) = (fresh, pid) {
std::thread::sleep(std::time::Duration::from_millis(500)); // signal handler installed right after the pid
if unsafe { libc::kill(pid, libc::SIGUSR1) } == 0 { return Ok(()); }
}
}
return Err("the UU remote host service started but did not open its window".into());
}
use std::os::unix::process::CommandExt;
Err(Box::new(std::process::Command::new("/proc/self/exe").env("UU_SHOW_WINDOW", "1").exec()))
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
// Not signed in, with a desktop: one window offers remote assistance (guest identity) and the QR
// login together; signing in restarts the host in account mode (assistance continues there).
let unified = std::env::args().nth(1).is_none() && display_present()
&& std::env::var("UU_REMOTE_ASSIST").ok().as_deref() != Some("0") && std::env::var("UU_LOGIN_WINDOW").ok().as_deref() != Some("0")
&& config::read_fresh().ok().flatten().and_then(|c| c.get("token").and_then(|t| t.as_str()).map(|t| !t.is_empty())) != Some(true)
&& ["UU_USER_ID", "UU_TOKEN", "UU_CSRF"].iter().all(|k| std::env::var_os(k).map_or(true, |v| v.is_empty()));
let assist_enabled = unified || std::env::args().nth(1).as_deref() == Some("assist")
|| (std::env::args().nth(1).is_none() && std::env::var("UU_REMOTE_ASSIST").ok().as_deref() == Some("1"));
if assist_enabled {
// HTTP/WS dependency trace logging can expose Authorization or room headers.
env_logger::Builder::new().filter_level(log::LevelFilter::Off)
.filter_module("uuremote_server", log::LevelFilter::Info).init();
} else { env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init(); }
// An unknown argument must never fall through to starting a second full host server.
const SUBCOMMANDS: [&str; 11] = ["desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
const SUBCOMMANDS: [&str; 13] = ["show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "clipboard-acceptance", "portal-acceptance"];
if let Some(arg) = std::env::args().nth(1).filter(|a| !SUBCOMMANDS.contains(&a.as_str())) {
let usage = format!("usage: uuremote-server [{}]\n (no argument: run the host)", SUBCOMMANDS.join(" | "));
if matches!(arg.as_str(), "help" | "-h" | "--help") { println!("{usage}"); return Ok(()); }
eprintln!("unknown argument: {arg}\n{usage}");
eprintln!("unknown argument\n{usage}");
std::process::exit(2);
}
if std::env::args().nth(1).as_deref() == Some("show") { return show_running_host(); }
if assist_enabled && !unified {
if std::env::args().len() > 2 { return Err("assist accepts no additional arguments; configure it with a private UU_CONFIG".into()); }
assist::configure()?;
}
if std::env::args().nth(1).as_deref() == Some("clipboard-acceptance") {
return tokio::task::spawn_blocking(clipboard_probe::run).await?.map_err(Into::into);
}
@@ -261,7 +347,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let _audio_cleanup=virtual_audio::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
let mut capture = Arc::new((if desktop_backend::headless() {
let capture = Arc::new((if desktop_backend::headless() {
Err("headless mode (UU_DESKTOP_BACKEND=none)".to_owned())
} else if desktop_backend::detect()?==desktop_backend::DesktopBackend::Portal
&& std::env::var("UU_PORTAL_PREAUTHORIZE").ok().as_deref()!=Some("1") {
@@ -274,34 +360,122 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
input.bind_portal(capture.portal.clone());
input.release_held(); // recover stale input before accepting any peer
let _pointer_worker = input.start_pointer_worker();
#[cfg(target_os="linux")]
{
let shutdown_input=input.clone();
let (shutdown_tx, mut shutdown) = tokio::sync::watch::channel(false);
let shutdown_input = input.clone();
let signal_tx = shutdown_tx.clone();
tokio::spawn(async move {
#[cfg(target_os="linux")]
{
let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).expect("SIGTERM handler");
tokio::select! { _ = term.recv() => {}, _ = tokio::signal::ctrl_c() => {} }
}
#[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await;
if !assist_enabled { shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
let _ = signal_tx.send(true);
});
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
if let Some(session) = assist.as_ref().filter(|_| unified) {
present_on_usr1(session.ui());
let login_done = shutdown_tx.clone();
tokio::spawn(async move {
if let Ok(mut term)=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) {
tokio::select! { _=term.recv()=>{}, _=tokio::signal::ctrl_c()=>{} }
shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0);
let ui = login_ui::LoginUi::attached();
loop {
match login::flow(&ui).await {
Ok(_) => { RESTART.store(true, std::sync::atomic::Ordering::SeqCst); let _ = login_done.send(true); return; }
Err(error) => { log::warn!("QR login failed: {error}; retrying"); tokio::time::sleep(std::time::Duration::from_secs(5)).await; }
}
}
});
}
let creds = match config::file().and_then(Credentials::load) {
Ok(creds) => creds,
Err(e) => {
log::warn!("Not logged in: {e} ({} or UU_* environment variables)", config::path().display());
login::wait_for_credentials(None).await
let webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>> = Arc::new(Mutex::new(HashMap::new()));
let (mut commands, command_task) = match assist.as_ref() {
Some(s) => { let (rx, task) = s.commands(shutdown_tx); (rx, Some(task)) },
None => (tokio::sync::mpsc::channel(1).1, None),
};
let mut immediate_shutdown = shutdown.clone();
let result = tokio::select! {
result = serve(capture, input.clone(), &mut shutdown, &mut assist, &mut commands, webrtc_sessions.clone()) => result,
_ = immediate_shutdown.changed() => Ok(()),
};
if let Some(task) = command_task { task.abort(); }
// One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { let _ = old.pc.close().await; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
// (a guest cancel then fails). Only a real stop withdraws here.
let switching = RESTART.load(std::sync::atomic::Ordering::SeqCst);
let revoke = match assist.as_mut() { Some(s) if !switching => s.cancel().await, _ => Ok(()) };
if revoke.is_err() { log::error!("Cloud assistance revocation failed; host is closed locally"); }
result?;
if RESTART.load(std::sync::atomic::Ordering::SeqCst) { restart_host(); }
revoke.map_err(|_| "assist disabled locally, but cloud cancel failed; cloud revocation is unverified")?;
Ok(())
}
async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutdown: &mut tokio::sync::watch::Receiver<bool>,
assist: &mut Option<assist::Assist>, commands: &mut mpsc::Receiver<assist::Command>, webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>>) -> Result<(), Box<dyn std::error::Error>> {
let mut auth = if let Some(session) = assist.as_ref() { session.client.clone() } else {
let creds = match config::file().and_then(Credentials::load) {
Ok(creds) => creds,
Err(e) => {
log::warn!("Not logged in: {e} ({} or UU_* environment variables)", config::path().display());
login::wait_for_credentials(None).await
}
};
let client = Arc::new(UUAuthClient::new(creds.clone()));
// Logged-in host: remote assistance (ID + code) alongside the device list, like the official
// client. Shown in a hidden window opened with `uuremote-server show`; UU_REMOTE_ASSIST=0 disables.
if std::env::var("UU_REMOTE_ASSIST").ok().as_deref() != Some("0") {
match assist::Assist::start_account(client.clone(), creds) {
Ok(session) => {
let (rx, _task) = session.commands(tokio::sync::watch::channel(false).0);
*commands = rx;
session.load_account_name().await;
present_on_usr1(session.ui());
if std::env::var("UU_SHOW_WINDOW").ok().as_deref() == Some("1") { session.ui().present(); }
std::env::remove_var("UU_SHOW_WINDOW");
log::info!("Remote assistance ready on the logged-in host (window: uuremote-server show)");
*assist = Some(session);
}
Err(error) => log::info!("Remote assistance unavailable on this host: {error}"),
}
}
client
};
let mut auth = Arc::new(UUAuthClient::new(creds));
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
let webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>> = Arc::new(Mutex::new(HashMap::new()));
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
let mut mac_by_ice: HashMap<String, bool> = HashMap::new();
let mut next_mac = false;
loop {
if *shutdown.borrow() {
return Ok(());
}
log::info!("Requesting fresh room credentials from NetEase cloud...");
let room_data = match auth.create_room().await {
Ok(data) => data,
let room_result = tokio::select! {
result = async {
match assist.as_mut() {
Some(session) if !session.is_account() => {
let result = session.room().await.map_err(auth::RoomError::Other);
auth = session.client.clone(); result
}
_ => auth.create_room().await,
}
} => result,
_ = shutdown.changed() => return Ok(()),
};
let room_data = match room_result {
Ok(data) => {
if let Some(session) = assist.as_mut().filter(|s| s.is_account()) {
if let Err(error) = session.ensure_published().await { log::warn!("Remote assistance share info failed: {error}"); }
}
data
}
Err(auth::RoomError::LoginExpired) => {
// Like the official client: an expired token needs a new QR login, not retries.
log::error!("UU login is invalid or expired; a new QR login is required");
@@ -316,20 +490,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
}
};
log::info!(
"Acquired room signaling target: {}",
room_data.signaling_server
);
log::info!("Acquired room signaling credentials");
let (tx_event, mut rx_event) = mpsc::channel::<SignalingEvent>(64);
let tx_timer = tx_event.clone();
let signaling_client = match SignalingClient::connect(
&room_data.signaling_server,
&room_data.token,
tx_event,
)
.await
{
let connected = tokio::select! {
result = SignalingClient::connect(&room_data.signaling_server, &room_data.token, tx_event) => result,
_ = shutdown.changed() => return Ok(()),
};
let signaling_client = match connected {
Ok(cli) => {
let renewal_peers=webrtc_sessions.clone();
tokio::spawn(async move {
@@ -351,27 +520,88 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
Arc::new(cli)
}
Err(e) => {
log::error!("Failed to connect signaling: {}. Retrying in 5s...", e);
let _ = e;
log::error!("Failed to connect signaling; retrying in 5s (details omitted)");
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
continue;
}
};
// 事件处理主循环
while let Some(evt) = rx_event.recv().await {
// Guest display/control commands never use stdout, stderr or logs.
let mut assist_tick = tokio::time::interval(std::time::Duration::from_secs(1));
loop {
let event = tokio::select! {
biased;
_ = shutdown.changed() => Some(SignalingEvent::Stop),
command = commands.recv(), if assist.is_some() => Some(SignalingEvent::AssistCommand(command.unwrap_or(assist::Command::Stop))),
_ = assist_tick.tick(), if assist.is_some() => Some(SignalingEvent::AssistTick),
event = rx_event.recv() => event,
};
let Some(evt) = event else { break; };
match evt {
SignalingEvent::Stop | SignalingEvent::AssistCommand(assist::Command::Stop) => {
return Ok(());
}
SignalingEvent::AssistCommand(assist::Command::Allow) => { if let Some(s) = assist.as_mut() { s.allow()?; } }
SignalingEvent::AssistCommand(assist::Command::Deny) => { if let Some(s) = assist.as_mut() { s.deny()?; } }
SignalingEvent::AssistCommand(assist::Command::Verify(v)) => { if let Some(s) = assist.as_mut() { s.set_verify(v)?; } }
SignalingEvent::AssistCommand(assist::Command::Refresh(r)) => { if let Some(s) = assist.as_mut() { s.set_refresh(r)?; } }
SignalingEvent::AssistCommand(assist::Command::Custom(c)) => { if let Some(s) = assist.as_mut() { s.set_custom(c)?; } }
SignalingEvent::AssistCommand(assist::Command::Quit) => {
// Tray 退出: under systemd (Restart=always) stop the unit itself, else just exit.
log::info!("Quit requested from the tray");
if let Some(unit) = systemd_unit() {
let _ = std::process::Command::new("systemctl").args(["--user", "stop", "--no-block", &unit]).status();
}
return Ok(());
}
SignalingEvent::AssistCommand(assist::Command::Logout) => {
if let Some(s) = assist.as_mut().filter(|s| s.is_account()) {
s.logout().await;
RESTART.store(true, std::sync::atomic::Ordering::SeqCst);
return Ok(());
}
}
SignalingEvent::AssistCommand(assist::Command::Reset) => { if let Some(s) = assist.as_mut() { s.reset()?; } }
SignalingEvent::AssistTick => {
let mut sessions = webrtc_sessions.lock().await;
let ended: Vec<_> = sessions.iter().filter(|(_, s)| matches!(s.pc.connection_state(),
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(id, _)| id.clone()).collect();
let mut desktop_ended = false;
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.desktop; let _ = s.pc.close().await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
SignalingEvent::Connected => {
log::info!("Signaling handshake established.");
}
SignalingEvent::RoomInfoAck(val) => {
log::info!(
"RoomInfo acknowledged by NetEase server: room_id={}",
val.get("room_id")
.and_then(|v| v.as_str())
.unwrap_or("unknown")
);
}
SignalingEvent::RoomInfoAck(_) => { log::info!("RoomInfo acknowledged by NetEase server"); }
SignalingEvent::DeviceInfoChanged(val) => {
if assist.is_some() {
// Shape only (type value + key names), never field values: guest challenges carry salts/ids.
let keys = |v: Option<&serde_json::Value>| v.and_then(|v| v.as_object()).map(|o| o.keys().cloned().collect::<Vec<_>>()).unwrap_or_default();
log::debug!("Assist bmsg_push shape: type={:?} keys={:?} data_keys={:?}",
val.get("type").and_then(serde_json::Value::as_str), keys(Some(&val)), keys(val.get("data")));
}
if val.get("type").and_then(serde_json::Value::as_str) == Some("get_control_mode") {
if let Some(s) = assist.as_mut() {
match s.control_mode(val.get("data").unwrap_or(&serde_json::Value::Null)).await {
Ok(()) => log::info!("Assist control mode reported"),
Err(error) => log::warn!("Assist control mode report failed: {error}"),
}
}
continue;
}
if val.get("type").and_then(serde_json::Value::as_str) == Some("remote_control") {
if let Some(s) = assist.as_mut() {
if let Err(error) = s.challenge(val.get("data").unwrap_or(&serde_json::Value::Null)).await {
log::warn!("Assist challenge failed: {error}");
}
if s.renewed { break; }
}
continue;
}
log::info!(
"Device status synchronized: status={:?}, availability={:?}",
val.get("data")
@@ -382,7 +612,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
.and_then(|s| s.as_str())
);
}
SignalingEvent::ConnectRequest { capture_type, ice_id, transport } => {
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller_mac } => {
if mac_by_ice.len()>=32 { mac_by_ice.clear(); }
match ice_id.clone() { Some(id) => { mac_by_ice.insert(id, controller_mac); } None => next_mac = controller_mac }
// Pending cloud credentials live only within this room; cap
// requests that never receive an offer rather than retain them.
if capture_types.len()>=32 { capture_types.clear(); }
@@ -394,23 +626,27 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
}
SignalingEvent::Soac(soac) => {
log::info!(
"SOAC signaling received: type={}, ice_id={:?}",
soac.msg_type,
soac.ice_id
);
log::info!("SOAC signaling received: offer={} candidate={}", soac.msg_type == "offer", soac.msg_type == "candidate");
// Guest host: every peer is an assist peer. A logged-in host must keep serving its owner;
// assist peers there are already gated by the cloud (allow_control / code check).
if assist.as_ref().is_some_and(|s| !s.is_account() && !s.allowed) { continue; }
let ice = soac.ice_id.as_ref().map(|v| v.as_str().map(str::to_owned).unwrap_or_else(|| v.to_string())).unwrap_or_default();
let mut sessions = webrtc_sessions.lock().await;
// Drop peers that already ended.
let ended: Vec<String> = sessions.iter().filter(|(_, s)| matches!(s.pc.connection_state(),
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect();
for k in ended { if let Some(old) = sessions.remove(&k) { let _ = old.pc.close().await; } }
let mut desktop_ended = false;
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.desktop; let _ = old.pc.close().await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
if soac.msg_type == "offer" {
let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default()));
// CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping.
let desktop = capture_type <= 2;
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
if desktop { input.set_mac_controller(controller_mac); }
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
if let Some(old) = sessions.remove(&ice) { let _ = old.pc.close().await; }
if desktop {
@@ -439,7 +675,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// current desktop's authorized Portal input session.
if desktop { input.bind_portal(session_capture.portal.clone()); }
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport).await {
Ok(sess) => match sess.handle_offer(&soac).await {
Ok(sess) => {
// Register before awaiting SDP: shutdown can always close
// a peer whose answer may already be queued to the viewer.
sessions.insert(ice.clone(), sess);
let offer = sessions.get(&ice).expect("registered peer").handle_offer(&soac).await;
match offer {
Ok(answer_sdp) => {
log::info!("Local SDP Answer generated, emitting soac response...");
let resp = SoacMessage {
@@ -454,15 +695,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
app_control_id: soac.app_control_id.clone(),
};
if let Err(e) = signaling_client.emit_soac(resp).await { log::error!("Answer signaling send failed: {}", e); }
sessions.insert(ice, sess);
}
Err(e) => { log::error!("Failed to handle offer: {}", e); let _ = sess.pc.close().await; }
},
Err(e) => log::error!("Create peer failed: {}", e),
Err(_) => {
log::error!("Failed to handle offer (details omitted)");
if let Some(session) = sessions.remove(&ice) { let _ = session.pc.close().await; }
}
}},
Err(_) => log::error!("Create peer failed (details omitted)"),
}
} else if soac.msg_type == "candidate" {
if let Some(sess) = sessions.get(&ice) {
if let Err(e) = sess.add_candidate(&soac).await { log::error!("Remote ICE candidate failed: {}", e); }
if let Err(e) = sess.add_candidate(&soac).await { let _ = e; log::error!("Remote ICE candidate failed (details omitted)"); }
} else {
log::warn!("Remote ICE candidate for unknown connection");
}
@@ -478,11 +721,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
_ => sessions.keys().cloned().collect(),
};
log::info!("Remote controller disconnected: keys={:?} ice_matched={} closing={}", keys, ice.as_ref().is_some_and(|i| sessions.contains_key(i)), targets.len());
let mut desktop_ended = false;
for k in targets {
if let Some(old) = sessions.remove(&k) {
desktop_ended |= old.desktop;
if let Err(e) = old.pc.close().await { log::warn!("Close released peer failed: {}", e); }
}
}
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; }
}
SignalingEvent::Disconnected => {
capture_types.clear();
+22 -5
View File
@@ -32,13 +32,16 @@ pub struct SoacMessage {
}
pub enum SignalingEvent {
Stop,
AssistCommand(crate::assist::Command),
AssistTick,
Connected,
RoomInfoAck(Value),
DeviceInfoChanged(Value),
BeControlled(Value),
/// be-controlled with its binary app_data (ConnectOptions): capture type and the
/// ice_id it announces, when present.
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce },
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce, controller_mac: bool },
Soac(SoacMessage),
Released(Value),
Left(Value),
@@ -119,7 +122,7 @@ impl SignalingClient {
.await
.map_err(|e| format!("WS connect failed: {}", e))?;
log::info!("Connected to Engine.IO / Socket.IO at {}", ws_url);
log::info!("Connected to Engine.IO / Socket.IO");
let (mut write, mut read) = ws_stream.split();
let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32);
@@ -127,7 +130,8 @@ impl SignalingClient {
let writer=tokio::spawn(async move {
while let Some(msg) = rx_outgoing.recv().await {
if let Err(e) = write.send(Message::Text(msg)).await {
log::warn!("WS send error: {}", e);
let _ = e;
log::warn!("WS send failed (details omitted)");
break;
}
}
@@ -267,7 +271,8 @@ impl SignalingClient {
.await;
}
Err(e) => {
log::error!("Failed to deserialize SoacMessage: error={}, raw={}", e, data);
let _ = e;
log::error!("Failed to deserialize SoacMessage (payload omitted)");
}
}
}
@@ -312,7 +317,19 @@ impl SignalingClient {
let ice_id = ["ice_id", "iceId"].iter().find_map(|k| header.get(*k).or_else(|| header.get("data").and_then(|d| d.get(*k))))
.and_then(|v| v.as_str()).map(str::to_owned);
log::info!("be-controlled connect request: capture_type={} header_keys={:?} ice_id_present={}", capture_type, keys, ice_id.is_some());
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header) }).await;
// ConnectOptions 4 decoder_cap_list: DecoderCap {1 fps, 2 codec_type (1 H264, 2 H265),
// 3 width, 4 height, 5 chroma_format (1 4:2:0, 3 4:4:4)}. Numbers only.
let caps: Vec<Vec<(u32, u64)>> = fields.iter().flatten().filter(|f| f.number == 4).filter_map(|f| match f.value {
crate::protocol::WireValue::Bytes(b) => crate::protocol::decode_wire(b).ok().map(|cap| cap.iter().filter_map(|x| match x.value {
crate::protocol::WireValue::Varint(v) => Some((x.number, v)), _ => None }).collect()),
_ => None }).collect();
if !caps.is_empty() { log::info!("Viewer decoder caps (fps,codec,w,h,chroma fields): {:?}", caps); }
// Viewer platform (website enum: 1 windows, 2 android, 3 ios, 4 macos, 5 tv).
let platform = header.get("controller_platform").or_else(|| header.get("data").and_then(|d| d.get("controller_platform")));
let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4)
|| v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin")));
log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac);
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await;
}
}
}
+42 -2
View File
@@ -34,6 +34,7 @@ const MAGIC: &[u8; 4] = b"TERM";
const HEADER: usize = 16;
const MAX_PAYLOAD: usize = 0x10_0000;
const SCROLLBACK: usize = 256 * 1024;
const OUTPUT_CHUNK: usize = 16 * 1024;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Frame { pub kind: u8, pub flags: [u8; 2], pub session: u32, pub payload: Vec<u8> }
@@ -140,7 +141,7 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?);
let worker = session.clone();
std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || {
let mut buf = vec![0u8; 16 * 1024];
let mut buf = vec![0u8; OUTPUT_CHUNK];
loop {
match reader.read(&mut buf) {
Ok(0) | Err(_) => break,
@@ -222,7 +223,8 @@ impl TerminalConn {
self.send(OPEN_RESP, s.id, &reply(0, "ok"));
*sink = Some(self.out.clone());
let replay: Vec<u8> = s.scrollback.lock().unwrap().iter().copied().collect();
if !replay.is_empty() { self.send(STDOUT, s.id, &replay); }
// A full scrollback exceeds SCTP's 64 KiB outbound message limit.
for chunk in replay.chunks(OUTPUT_CHUNK) { self.send(STDOUT, s.id, chunk); }
}
Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); }
}
@@ -289,6 +291,44 @@ mod tests {
}
}
#[test]
fn reconnect_replays_large_history_in_bounded_frames() {
let pty = nix::pty::openpty(None, None).unwrap();
let id = u32::MAX - 1;
let history: Vec<u8> = (0..SCROLLBACK).map(|n| (n % 251) as u8).collect();
let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(),
master: pty.master, pid: 0, sink: Mutex::new(None),
scrollback: Mutex::new(history.iter().copied().collect()) });
registry().lock().unwrap().insert(id, session.clone());
struct Cleanup(u32);
impl Drop for Cleanup { fn drop(&mut self) { registry().lock().unwrap().remove(&self.0); } }
let _cleanup = Cleanup(id);
for _ in 0..2 {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let conn = TerminalConn::new(tx);
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24}"#));
let opened = decode(&rx.try_recv().unwrap()).unwrap();
assert_eq!(opened.kind, OPEN_RESP);
assert_eq!(opened.session, id);
let mut replay = Vec::new();
while replay.len() < history.len() {
let packet = rx.try_recv().unwrap();
// SCTP's default outbound limit includes the TERM header.
assert!(packet.len() <= 65536, "terminal replay exceeds the SCTP message limit");
let frame = decode(&packet).unwrap();
assert_eq!(frame.kind, STDOUT);
assert_eq!(frame.session, id);
replay.extend(frame.payload);
}
assert!(replay == history, "terminal replay must preserve every byte in order");
assert!(session.emit(STDOUT, b"live output"));
assert_eq!(decode(&rx.try_recv().unwrap()).unwrap().payload, b"live output");
conn.handle(&encode(LIST_REQ, 7, &[]));
assert_eq!(decode(&rx.try_recv().unwrap()).unwrap().kind, LIST_RESP);
conn.handle(&encode(DETACH, id, &[]));
}
}
#[test]
fn open_spawns_shell_and_streams_output() {
for requested_id in [0, u32::MAX] {
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+20 -3
View File
@@ -68,6 +68,22 @@ impl Encoder {
fn nvidia_present() -> bool {
std::path::Path::new("/proc/driver/nvidia/version").exists() || std::path::Path::new("/dev/nvidia0").exists()
}
/// 真彩 (4:4:4) needs the FFmpeg process pipeline with NVENC or libx264 (h264_vaapi and the
/// in-process encoder are 4:2:0 only).
pub fn full_chroma_available() -> bool {
#[cfg(feature = "inproc-av")]
if crate::inproc_encoder::selected() { return false; }
Encoder::requested() != Encoder::Vaapi
}
/// (-profile:v, -pix_fmt) for NVENC / libx264: 4:4:4 needs a High 4:4:4 profile.
fn chroma_args(settings: &VideoSettings, encoder: Encoder) -> (&'static str, &'static str) {
match (settings.chroma == crate::capture_setting::CHROMA_444, encoder) {
(true, Encoder::Nvenc) => ("high444p", "yuv444p"),
(true, _) => ("high444", "yuv444p"),
(false, _) => ("baseline", "yuv420p"),
}
}
pub(crate) fn vaapi_device() -> String { std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into()) }
/// NV12 conversion must precede upload; scaling runs on software frames, before hwupload.
@@ -232,7 +248,8 @@ async fn read_encoder_with(
let (maxrate, bufsize) = rate_args(&settings, encoder);
let cq = settings.cq().to_string();
let target = settings.max_kbps().map_or("16M".to_string(), |k| format!("{}k", k * 3 / 4));
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name());
let (profile, pix_fmt) = chroma_args(&settings, encoder);
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} pix_fmt={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name(),if encoder == Encoder::Vaapi { "nv12" } else { pix_fmt });
// A bundled FFmpeg prefix (config ffmpeg_root / UU_FFMPEG_ROOT) or `ffmpeg` on PATH.
let mut command=match crate::config::ffmpeg_root() {
Some(root) => { let mut c=Command::new(root.join("bin/ffmpeg")); c.env("LD_LIBRARY_PATH",root.join("lib/x86_64-linux-gnu")); c }
@@ -258,14 +275,14 @@ async fn read_encoder_with(
command.args(vaapi_options(&settings, &gop));
} else if encoder == Encoder::Nvenc {
command.args(["-c:v","h264_nvenc","-preset","p4","-tune","ull",
"-profile:v","baseline","-pix_fmt","yuv420p","-g",&gop,"-bf","0",
"-profile:v",profile,"-pix_fmt",pix_fmt,"-g",&gop,"-bf","0",
"-rc","vbr","-cq",&cq,"-b:v",&target,"-maxrate",&maxrate,"-bufsize",&bufsize,
"-rc-lookahead","0","-zerolatency","1","-delay","0","-aud","1"]);
}else{
let x264 = format!("aud=1:repeat-headers=1:scenecut=0:keyint={gop}:min-keyint={gop}");
command.args([
"-c:v", "libx264", "-preset", "superfast", "-tune", "zerolatency",
"-profile:v", "baseline", "-pix_fmt", "yuv420p", "-g", &gop, "-threads", "4",
"-profile:v", profile, "-pix_fmt", pix_fmt, "-g", &gop, "-threads", "4",
"-crf", &cq, "-maxrate", &maxrate, "-bufsize", &bufsize,
"-x264-params", &x264]);
}
+1 -1
View File
@@ -839,7 +839,7 @@ impl WebRtcSession {
ctx.client_id = soac.client_id.clone();
ctx.ice_id = soac.ice_id.clone();
ctx.app_control_id = soac.app_control_id.clone();
log::info!("Updated WebRTC session context: client_id={:?}, ice_id={:?}", ctx.client_id, ctx.ice_id);
log::info!("Updated WebRTC session context: client_id_present={} ice_id_present={}", ctx.client_id.is_some(), ctx.ice_id.is_some());
}
let mut sdp_str = soac.sdp.clone().unwrap_or_default();
if sdp_str.is_empty() {