mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
73462ee57f | ||
|
|
bc683b3cef | ||
|
|
94039c092a | ||
|
|
03f611811c | ||
|
|
1b7ec0a94f |
No files matched your search
@@ -112,6 +112,7 @@ viewer does not reconnect them automatically.
|
||||
| `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 +139,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`,
|
||||
@@ -189,6 +190,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
@@ -2649,7 +2649,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.9"
|
||||
version = "0.1.11"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"bytes",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.9"
|
||||
version = "0.1.11"
|
||||
edition = "2021"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
|
||||
|
||||
+33
-2
@@ -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,7 +31,8 @@
|
||||
|
||||
| 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) |
|
||||
@@ -180,6 +181,34 @@ 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.
|
||||
- **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 +249,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) |
|
||||
|
||||
|
||||
@@ -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,7 +27,8 @@
|
||||
|
||||
| 功能 | 说明 |
|
||||
|---|---|
|
||||
| 扫码登录 | 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) |
|
||||
@@ -164,6 +165,26 @@ 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 主机」打开。关闭窗口只是隐藏,不会停止服务。
|
||||
- **设置**(与官方一致):「允许他人远程协助」开关(默认关闭);验证方式:仅临时验证码 / 仅自定义验证码(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 +224,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,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() {
|
||||
|
||||
@@ -0,0 +1,576 @@
|
||||
// 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>
|
||||
|
||||
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 };
|
||||
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;
|
||||
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 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();
|
||||
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;
|
||||
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(); }
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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
|
||||
@@ -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 |
@@ -0,0 +1,18 @@
|
||||
修复 iOS 和 Windows 客户端无法打开终端。/ Fixes the terminal for iOS and Windows viewers.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **iOS 和 Windows 客户端打开终端失败**(#12,感谢 @cnetst):iOS 提示「创建失败」,Windows 提示「连接已断开」。
|
||||
终端协议的应答和官方实现不一致:会话列表改为直接返回数组并保留请求编号;客户端指定会话编号时沿用该编号;
|
||||
「打开成功」的应答保证先于终端输出发送。
|
||||
✅ 实机验收:官方 iOS 和 Mac 客户端都能正常创建终端、执行命令,后连接的客户端能看到并接着使用已有的终端会话。
|
||||
Terminal replies now match the official host (bare-array session list, client session ids, OPEN_RESP first).
|
||||
Verified with the official iOS and Mac viewers.
|
||||
|
||||
### 说明 / Note
|
||||
- 同一时间只能有一台控制设备连接同一个被控端:另一台设备连上时,先连接的会被云端断开,这是网易 UU 的服务端行为,与官方被控端一致。
|
||||
The UU cloud allows one controlling device at a time; a new controller disconnects the previous one (official behavior).
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.10-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -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.**
|
||||
+530
@@ -0,0 +1,530 @@
|
||||
//! 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 }
|
||||
|
||||
#[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,
|
||||
_ => 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();
|
||||
let mut bytes = [0u8; 1024];
|
||||
let n = master.read(&mut bytes).unwrap();
|
||||
let text = std::str::from_utf8(&bytes[..n]).unwrap();
|
||||
assert!(text.contains("fixture-123") && text.contains("FIXTURE8") && text.contains("false"));
|
||||
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
@@ -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, ¶m_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", ¶ms, ""));
|
||||
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, ""));
|
||||
}
|
||||
}
|
||||
+26
-7
@@ -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
@@ -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() } }
|
||||
}
|
||||
}
|
||||
+263
-53
@@ -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,80 @@ 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);
|
||||
}
|
||||
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>) {
|
||||
write_host_pid();
|
||||
tokio::spawn(async move {
|
||||
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
|
||||
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(()); }
|
||||
}
|
||||
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 +324,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 +337,120 @@ 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();
|
||||
|
||||
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 +465,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 +495,80 @@ 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::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")
|
||||
@@ -394,18 +591,20 @@ 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()));
|
||||
@@ -439,7 +638,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 +658,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 +684,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();
|
||||
|
||||
+8
-3
@@ -32,6 +32,9 @@ pub struct SoacMessage {
|
||||
}
|
||||
|
||||
pub enum SignalingEvent {
|
||||
Stop,
|
||||
AssistCommand(crate::assist::Command),
|
||||
AssistTick,
|
||||
Connected,
|
||||
RoomInfoAck(Value),
|
||||
DeviceInfoChanged(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)");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+56
-21
@@ -104,7 +104,7 @@ static NEXT_ID: AtomicU32 = AtomicU32::new(1);
|
||||
|
||||
fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_millis() as u64 }
|
||||
|
||||
fn spawn(cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> {
|
||||
fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, String> {
|
||||
use std::os::unix::process::CommandExt;
|
||||
let win = nix::pty::Winsize { ws_row: rows.max(1), ws_col: cols.max(1), ws_xpixel: 0, ws_ypixel: 0 };
|
||||
let pty = nix::pty::openpty(Some(&win), None).map_err(|e| format!("openpty failed: {e}"))?;
|
||||
@@ -128,7 +128,13 @@ fn spawn(cols: u16, rows: u16, shell: Option<&str>) -> Result<Arc<Session>, Stri
|
||||
}
|
||||
let mut child = cmd.spawn().map_err(|e| format!("shell spawn failed: {e}"))?;
|
||||
drop(slave);
|
||||
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
|
||||
// Official Mac 4.42.0 (TerminalManager.open) allocates an ID only for OPEN(0).
|
||||
let id = if requested_id != 0 { requested_id } else {
|
||||
loop {
|
||||
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
|
||||
if id != 0 && !registry().lock().unwrap().contains_key(&id) { break id; }
|
||||
}
|
||||
};
|
||||
let session = Arc::new(Session { id, shell: shell.clone(), created_ms: now_ms(), pid: child.id() as i32,
|
||||
master: pty.master, sink: Mutex::new(None), scrollback: Mutex::new(VecDeque::new()) });
|
||||
let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?);
|
||||
@@ -207,12 +213,14 @@ impl TerminalConn {
|
||||
let (cols, rows) = dims(&v);
|
||||
let session = match existing {
|
||||
Some(s) => { s.resize(cols, rows); Ok(s) }
|
||||
None => spawn(cols, rows, v.get("shell").and_then(|s| s.as_str())),
|
||||
None => spawn(frame.session, cols, rows, v.get("shell").and_then(|s| s.as_str())),
|
||||
};
|
||||
match session {
|
||||
Ok(s) => {
|
||||
*s.sink.lock().unwrap() = Some(self.out.clone());
|
||||
// Queue the acknowledgement before the PTY reader can emit live output.
|
||||
let mut sink = s.sink.lock().unwrap();
|
||||
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); }
|
||||
}
|
||||
@@ -241,7 +249,8 @@ impl TerminalConn {
|
||||
"state": if attached { "running" } else { "detached" }, "created_at_ms": s.created_ms})
|
||||
}).collect();
|
||||
log::info!("Terminal list sessions: count={}", sessions.len());
|
||||
self.send(LIST_RESP, 0, serde_json::json!({"code": 0, "message": "ok", "sessions": sessions}).to_string().as_bytes());
|
||||
// Official Mac 4.42.0 (handleListSessionsReq) sends a bare array with the request's header ID.
|
||||
self.send(LIST_RESP, frame.session, serde_json::Value::Array(sessions).to_string().as_bytes());
|
||||
}
|
||||
UNLOCK_REQ => self.send(UNLOCK_RESP, frame.session, &reply(0, "ok")),
|
||||
_ => self.send(ERROR, frame.session, &reply(1, "unsupported frame")),
|
||||
@@ -268,25 +277,51 @@ mod tests {
|
||||
assert_eq!(signal_number(b"whatever"), libc::SIGINT);
|
||||
}
|
||||
#[test]
|
||||
fn open_spawns_shell_and_streams_output() {
|
||||
fn list_reply_is_an_array_and_preserves_request_id() {
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let conn = TerminalConn::new(tx);
|
||||
conn.handle(&encode(OPEN, 0, br#"{"cols":100,"rows":30,"shell":"/bin/sh"}"#));
|
||||
let resp = decode(&rx.blocking_recv().unwrap()).unwrap();
|
||||
assert_eq!(resp.kind, OPEN_RESP);
|
||||
assert_eq!(json(&resp.payload)["code"], 0);
|
||||
conn.handle(&encode(STDIN, resp.session, b"echo uu-term-ok; exit 3\n"));
|
||||
let mut seen = Vec::new();
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
let mut exit = None;
|
||||
while std::time::Instant::now() < deadline && exit.is_none() {
|
||||
if let Ok(m) = rx.try_recv() {
|
||||
let f = decode(&m).unwrap();
|
||||
if f.kind == STDOUT { seen.extend(f.payload) } else if f.kind == EXIT { exit = Some(json(&f.payload)["exit_code"].clone()) }
|
||||
} else { std::thread::sleep(std::time::Duration::from_millis(20)); }
|
||||
for request in [0, 7, u32::MAX] {
|
||||
conn.handle(&encode(LIST_REQ, request, &[]));
|
||||
let response = decode(&rx.try_recv().unwrap()).unwrap();
|
||||
assert_eq!(response.kind, LIST_RESP);
|
||||
assert_eq!(response.session, request);
|
||||
assert!(json(&response.payload).is_array());
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn open_spawns_shell_and_streams_output() {
|
||||
for requested_id in [0, u32::MAX] {
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let conn = TerminalConn::new(tx);
|
||||
conn.handle(&encode(OPEN, requested_id, br#"{"cols":100,"rows":30,"shell":"/bin/sh"}"#));
|
||||
let resp = decode(&rx.blocking_recv().unwrap()).unwrap();
|
||||
assert_eq!(resp.kind, OPEN_RESP);
|
||||
assert_eq!(json(&resp.payload)["code"], 0);
|
||||
assert_ne!(resp.session, 0);
|
||||
if requested_id != 0 { assert_eq!(resp.session, requested_id); }
|
||||
|
||||
let (list_tx, mut list_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
TerminalConn::new(list_tx).handle(&encode(LIST_REQ, 7, &[]));
|
||||
let list = decode(&list_rx.try_recv().unwrap()).unwrap();
|
||||
let sessions: Vec<serde_json::Value> = serde_json::from_slice(&list.payload).unwrap();
|
||||
let session = sessions.iter().find(|s| s["session_id"] == resp.session).unwrap();
|
||||
assert_eq!(session["shell"], "/bin/sh");
|
||||
assert_eq!(session["state"], "running");
|
||||
|
||||
conn.handle(&encode(STDIN, resp.session, b"echo uu-term-ok; exit 3\n"));
|
||||
let mut seen = Vec::new();
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
||||
let mut exit = None;
|
||||
while std::time::Instant::now() < deadline && exit.is_none() {
|
||||
if let Ok(m) = rx.try_recv() {
|
||||
let f = decode(&m).unwrap();
|
||||
assert_eq!(f.session, resp.session);
|
||||
if f.kind == STDOUT { seen.extend(f.payload) } else if f.kind == EXIT { exit = Some(json(&f.payload)["exit_code"].clone()) }
|
||||
} else { std::thread::sleep(std::time::Duration::from_millis(20)); }
|
||||
}
|
||||
assert!(String::from_utf8_lossy(&seen).contains("uu-term-ok"));
|
||||
assert_eq!(exit, Some(serde_json::json!(3)));
|
||||
}
|
||||
assert!(String::from_utf8_lossy(&seen).contains("uu-term-ok"));
|
||||
assert_eq!(exit, Some(serde_json::json!(3)));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -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() {
|
||||
|
||||
Reference in new issue
Block a user