From 94039c092a4b7d056dd06dfe04c3df844b1577d7 Mon Sep 17 00:00:00 2001 From: VallierDev <24893073+VallierDev@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:17:25 +0800 Subject: [PATCH] Remote assistance (experimental) and unified host window MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Like the official client: share a device ID + verification code; the other person connects from 开始协助. Guest identity before sign-in, account identity after (same share ID). One GTK window: 本设备 (allow switch, ID/code with copy, verification modes incl. custom code, rotation schedule, copy & share) and 账号 (QR before sign-in, masked account + sign out after). Logged-in hosts keep the window hidden; `uuremote-server show` / the desktop launcher opens it. App icon and .desktop entry in contrib/desktop. Protocol from the official Windows lite host; guest flow, wrong-code rejection, rotation, switching off, sign-in/sign-out verified with the official Mac viewer. Signed-in assistance from another account is not yet verified. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 20 +- README.en.md | 33 +- README.md | 25 +- build.rs | 4 +- c_engine/assist_window.c | 576 ++++++++++++++++++++++++ c_engine/login_window.c | 321 ------------- contrib/desktop/uu-remote-linux.desktop | 13 + contrib/desktop/uu-remote-linux.svg | 13 + src/assist.rs | 530 ++++++++++++++++++++++ src/auth.rs | 90 +++- src/login.rs | 33 +- src/login_ui.rs | 18 +- src/main.rs | 316 ++++++++++--- src/signaling.rs | 11 +- src/webrtc.rs | 2 +- 15 files changed, 1606 insertions(+), 399 deletions(-) create mode 100644 c_engine/assist_window.c delete mode 100644 c_engine/login_window.c create mode 100644 contrib/desktop/uu-remote-linux.desktop create mode 100644 contrib/desktop/uu-remote-linux.svg create mode 100644 src/assist.rs diff --git a/AGENTS.md b/AGENTS.md index 4ff3de9..668822b 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -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 diff --git a/README.en.md b/README.en.md index 5740b9e..4795e07 100644 --- a/README.en.md +++ b/README.en.md @@ -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) | diff --git a/README.md b/README.md index 0870363..4c0a061 100644 --- a/README.md +++ b/README.md @@ -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`。 diff --git a/build.rs b/build.rs index a3b34dc..88ebe44 100644 --- a/build.rs +++ b/build.rs @@ -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() { diff --git a/c_engine/assist_window.c b/c_engine/assist_window.c new file mode 100644 index 0000000..1bbeaca --- /dev/null +++ b/c_engine/assist_window.c @@ -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 +#include +#include +#include +#include + +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(); } diff --git a/c_engine/login_window.c b/c_engine/login_window.c deleted file mode 100644 index 47abe54..0000000 --- a/c_engine/login_window.c +++ /dev/null @@ -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 -#include -#include -#include -#include - -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; -} diff --git a/contrib/desktop/uu-remote-linux.desktop b/contrib/desktop/uu-remote-linux.desktop new file mode 100644 index 0000000..f18c777 --- /dev/null +++ b/contrib/desktop/uu-remote-linux.desktop @@ -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 diff --git a/contrib/desktop/uu-remote-linux.svg b/contrib/desktop/uu-remote-linux.svg new file mode 100644 index 0000000..1ddc03e --- /dev/null +++ b/contrib/desktop/uu-remote-linux.svg @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/src/assist.rs b/src/assist.rs new file mode 100644 index 0000000..ab2e9dd --- /dev/null +++ b/src/assist.rs @@ -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 { 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 { 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 { 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::Session, Self::Hour, Self::Hour12, Self::Hour24, Self::Never].get(usize::try_from(i).ok()?).copied() } + fn period(self) -> Option { + 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::>().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), #[cfg(uu_gtk)] Window } +impl LocalUi { + /// Standalone `assist`: visible window (closing it stops assistance), else /dev/tty. + pub fn open() -> Result { 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 { + #[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 { + #[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::().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) -> 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::())) + .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 { + 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 { + 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 { + 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, + ui: std::sync::Arc, + code: String, + custom: Option, + 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, service: bool) -> Result { + 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, 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 { + 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, device: Credentials) -> Result { + 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 { 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 { + 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 { + 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 { + 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::(&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::(&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) -> (tokio::sync::mpsc::Receiver, 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))); } + } +} diff --git a/src/auth.rs b/src/auth.rs index 210169e..1a35134 100644 --- a/src/auth.rs +++ b/src/auth.rs @@ -73,7 +73,7 @@ pub struct ApiResponse { pub data: Option, } -#[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, } +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, } 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 { + 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 { 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::(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 = 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, "")); + } +} diff --git a/src/login.rs b/src/login.rs index 6b1e592..94f25d2 100644 --- a/src/login.rs +++ b/src/login.rs @@ -143,7 +143,7 @@ fn qr_rgba(content: &str, scale: usize, quiet: usize) -> Result<(Vec, usize) Ok((rgba, edge)) } -fn write_config(cfg: &Value) -> Result { +pub(crate) fn write_config(cfg: &Value) -> Result { 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 { +/// 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 { 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 { 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 { + let (mut cfg, creds) = prepare_device().await?; let client = UUAuthClient::new(creds.clone()); loop { @@ -274,7 +288,7 @@ async fn flow(ui: &LoginUi) -> Result { 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 { 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() }); } diff --git a/src/login_ui.rs b/src/login_ui.rs index d493b26..3e6a637 100644 --- a/src/login_ui.rs +++ b/src/login_ui.rs @@ -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() } } } } diff --git a/src/main.rs b/src/main.rs index 2d5fe45..34abc7c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -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) { + 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> { + let running = std::fs::read_to_string(host_pid_path()).ok().and_then(|s| s.trim().parse::().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> { - 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> { 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> { 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>> = 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, input: Arc, shutdown: &mut tokio::sync::watch::Receiver, + assist: &mut Option, commands: &mut mpsc::Receiver, webrtc_sessions: Arc>>) -> Result<(), Box> { + 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>> = Arc::new(Mutex::new(HashMap::new())); let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None; let mut capture_types: HashMap = 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> { } }; - log::info!( - "Acquired room signaling target: {}", - room_data.signaling_server - ); + log::info!("Acquired room signaling credentials"); let (tx_event, mut rx_event) = mpsc::channel::(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> { 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::>()).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> { } 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 = 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> { // 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> { 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> { _ => 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(); diff --git a/src/signaling.rs b/src/signaling.rs index eb775fb..a706107 100644 --- a/src/signaling.rs +++ b/src/signaling.rs @@ -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::(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)"); } } } diff --git a/src/webrtc.rs b/src/webrtc.rs index 1eb750e..4490981 100644 --- a/src/webrtc.rs +++ b/src/webrtc.rs @@ -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() {