mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
73c503a244 | ||
|
|
3bce605eaa | ||
|
|
ebdd362452 | ||
|
|
26811018e0 | ||
|
|
c3959c01e9 | ||
|
|
ef14f76422 | ||
|
|
480819e369 | ||
|
|
f4f16aafe4 | ||
|
|
cb6f5b6617 | ||
|
|
8e30371317 |
No files matched your search
@@ -160,6 +160,7 @@ for a new QR login.
|
||||
| `src/clipboard*.rs` | text clipboard bridge and protocol |
|
||||
| `src/file_trans.rs` | FileTransferFtp RPC |
|
||||
| `src/terminal.rs` | TERM frames + PTY sessions |
|
||||
| `src/privacy_screen/`, `c_engine/privacy_wallpaper.c` | host privacy screen (RPC 7): desktop-independent controller, recovery record, guard and cover processes; `Backend` per desktop (`kde/`: KWin virtual output, kscreen-doctor, KWin input devices). See docs/privacy-screen.md |
|
||||
| `src/session_lock.rs`, `c_engine/pam_check.c` | lock state reporting, auto unlock via PAM + logind |
|
||||
| `src/system_actions.rs`, `src/system_metrics.rs` | SimpleAction system commands, mute, auto-lock, SystemMetrics |
|
||||
| `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL |
|
||||
|
||||
Generated
+1
-1
@@ -2772,7 +2772,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.42"
|
||||
version = "0.2.47"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"async-trait",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.42"
|
||||
version = "0.2.47"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
|
||||
+10
-1
@@ -25,6 +25,12 @@
|
||||
|
||||
## Appearance / 外观
|
||||
|
||||
Signed-in graphical hosts report the system wallpaper for disconnected device cards in official clients
|
||||
(no desktop-window screenshot). GNOME/Cinnamon, KDE and Xfce are supported; checks run every 60 seconds
|
||||
and unchanged content is not uploaded again. Other desktops can set `UU_WALLPAPER=/absolute/path/image.png`
|
||||
(PNG/JPEG/WebP). Set `UU_WALLPAPER_UPLOAD=0` to disable; guest and headless hosts skip reporting.
|
||||
See [protocol evidence and limitations](docs/wallpaper-protocol.md).
|
||||
|
||||
Choose **System / Light / Dark** (default: System) in the viewer's **Settings → General → Appearance**, or via the gear settings button in host / tool windows.
|
||||
The choice is saved to `$XDG_CONFIG_HOME/uuremote/theme` (default `~/.config/uuremote/theme`).
|
||||
|
||||
@@ -151,7 +157,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
|
||||
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; `inproc-av` native NVENC encodes H.264 High 4:4:4 / HEVC FRExt; VAAPI stays 4:2:0 and reports that to the client |
|
||||
| HDR | Not implemented |
|
||||
| Super screen / virtual display | Not implemented |
|
||||
| Privacy screen on the host | Not implemented |
|
||||
| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; see [docs/privacy-screen.md](docs/privacy-screen.md) |
|
||||
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) |
|
||||
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
|
||||
| Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
|
||||
@@ -458,6 +464,7 @@ flowchart LR
|
||||
|
||||
## Security and privacy
|
||||
|
||||
- By default, signed-in graphical hosts upload the current wallpaper image to UU's file service for device-card backgrounds. Set `UU_WALLPAPER_UPLOAD=0` to disable this upload.
|
||||
- Logs never contain keystrokes, terminal text, clipboard contents, file contents, passwords or tokens.
|
||||
- For auto unlock the password is stored in the **viewer** (the official client). The host only checks it
|
||||
once with PAM; it is never written to disk or logs.
|
||||
@@ -640,6 +647,8 @@ GNOME-to-official-Mac bidirectional clipboard synchronization is still unverifie
|
||||
- Frames are decoded at the host's native resolution and scaled to the window with linear filtering; a host resolution
|
||||
change restarts the decoder. `UU_VIEWER_SIZE=WxH` forces a fixed letterboxed canvas instead.
|
||||
|
||||
The SDL remote desktop window disables local IME text composition and forwards physical keys; use the remote host’s input method and its language toggle (for example, Shift) to enter Chinese.
|
||||
|
||||
Mac targets use native macOS keycodes; Windows / Linux targets retain Windows VK. Keys follow physical positions, without
|
||||
automatically translating Ctrl to Command; on a Mac target the PC Super / Windows key acts as Command. Only verified target
|
||||
platform values 1 (Windows / this project's Linux host) and 4 (Mac) are accepted; unknown values fail explicitly. Account
|
||||
|
||||
@@ -21,6 +21,8 @@
|
||||
|
||||
## 外观 / Appearance
|
||||
|
||||
已登录的图形主机会上报系统壁纸,供官方客户端的设备卡片在未连接时显示背景图(不是桌面窗口截图)。支持 GNOME/Cinnamon、KDE、Xfce;每 60 秒检查一次,内容不变则不重复上传。其他桌面可用 `UU_WALLPAPER=/绝对路径/图片.png` 指定 PNG/JPEG/WebP;`UU_WALLPAPER_UPLOAD=0` 关闭。访客和无桌面模式跳过上报。协议依据与限制见 [设备壁纸上报](docs/wallpaper-protocol.md)。
|
||||
|
||||
在控制端的 **设置 → 常规 → 外观**,或主机 / 工具窗口的齿轮设置按钮中选择 **跟随系统 / 浅色 / 深色**(默认跟随系统)。
|
||||
选择保存在 `$XDG_CONFIG_HOME/uuremote/theme`(默认 `~/.config/uuremote/theme`)。
|
||||
|
||||
@@ -136,7 +138,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
|
||||
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;`inproc-av` 原生 NVENC 输出 H.264 High 4:4:4 / HEVC FRExt;VAAPI 管线仍为 4:2:0,并如实回报给客户端 |
|
||||
| HDR | 未实现 |
|
||||
| 超级屏 / 虚拟显示器 | 未实现 |
|
||||
| 被控端防窥模式 | 未实现 |
|
||||
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
|
||||
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
|
||||
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
|
||||
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
|
||||
@@ -402,6 +404,7 @@ flowchart LR
|
||||
|
||||
## 安全与隐私
|
||||
|
||||
- 已登录的图形主机默认会将当前壁纸图片上传到 UU 的文件服务,供设备卡片显示背景;可用 `UU_WALLPAPER_UPLOAD=0` 关闭上传。
|
||||
- 日志不记录键盘输入、终端内容、剪贴板内容、文件内容、密码和令牌。
|
||||
- 自动解锁的密码保存在**控制端**(官方客户端)里,被控端只拿来做一次 PAM 校验,不落盘、不写日志。
|
||||
- 能连上这台机器的,只有登录了同一个 UU 账号的设备。请保管好你的 UU 账号。
|
||||
@@ -563,6 +566,8 @@ GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不
|
||||
以 CaptureSettingSync 回报为准。两种色度均由 FFmpeg 转为 RGB24 显示。
|
||||
- 按被控端原始分辨率解码,窗口缩放使用线性过滤;被控端分辨率变化时自动重启解码器。`UU_VIEWER_SIZE=WxH` 可改为固定的留黑边画布。
|
||||
|
||||
SDL 远程画面窗口关闭本地输入法的文本组合,按物理键转发;输入中文时请使用被控端的输入法及其中英切换键(例如 Shift)。
|
||||
|
||||
Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command;
|
||||
控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac),
|
||||
未知值会报错,不猜测键码。账号连接缺少平台字段时查询目标设备;远程协助必须由连接响应提供平台。只看模式不需要此识别。
|
||||
|
||||
@@ -11,6 +11,7 @@ fn main() {
|
||||
println!("cargo:rerun-if-changed=vendor/ffnvcodec/ffnvcodec/nvEncodeAPI.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/clipboard.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/assist_window.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/privacy_wallpaper.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/viewer_window.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/viewer_tools.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/ui_theme.c");
|
||||
@@ -78,7 +79,7 @@ fn main() {
|
||||
match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() {
|
||||
Some((cflags, libs)) => {
|
||||
let mut build = cc::Build::new();
|
||||
build.file("c_engine/assist_window.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").file("c_engine/ui_theme.c").flag_if_supported("-Wno-deprecated-declarations");
|
||||
build.file("c_engine/assist_window.c").file("c_engine/privacy_wallpaper.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").file("c_engine/ui_theme.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() {
|
||||
|
||||
@@ -596,7 +596,7 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
|
||||
}
|
||||
static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height) {
|
||||
int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) {
|
||||
*error = 0; *width = *height = 0;
|
||||
struct uu_portal *p = calloc(1, sizeof(*p));
|
||||
if (!p) { *error = 8; return NULL; }
|
||||
@@ -644,7 +644,8 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
if (!results) goto done;
|
||||
g_variant_unref(results);
|
||||
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(1));
|
||||
/* 1 monitor; 4 virtual (KDE creates a KWin virtual output for the stream). */
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(source_types));
|
||||
g_variant_builder_add(&options, "{sv}", "multiple", g_variant_new_boolean(FALSE));
|
||||
/* Hidden cursor avoids duplicate pointer; supported since ScreenCast v1. */
|
||||
results = request(p, SCREEN, "SelectSources", &options, 1, error);
|
||||
@@ -707,17 +708,21 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
|
||||
void (*save_token)(const char *, void *), void *save_data,
|
||||
uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, 0, error, width, height);
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, 0, error, width, height, 1);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist_capture(const char *restore,
|
||||
void (*save_token)(const char *, void *), void *save_data,
|
||||
uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height);
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height);
|
||||
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 1);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 4);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) {
|
||||
return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
|
||||
|
||||
@@ -8,6 +8,7 @@ typedef int (*uu_portal_cancelled_fn)(void *data);
|
||||
/* One object owns one consent/session and one PipeWire stream. */
|
||||
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
|
||||
/* Saves the rotated token immediately after Start, before video initialization. */
|
||||
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
||||
/* The cancellation callback and data are used only until this call returns. */
|
||||
struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int *error, uint32_t *width, uint32_t *height);
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
// Privacy screen, wallpaper mode: a fullscreen keep-above window on each physical monitor showing
|
||||
// a picture and a notice, while the remote session works on a KWin virtual output. Runs in its own
|
||||
// process (`uuremote-server privacy-wallpaper`), which the host kills on restore.
|
||||
#include <gtk/gtk.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "i18n.h"
|
||||
|
||||
typedef struct { int x, y, w, h; } Rect;
|
||||
static GdkPixbuf *picture;
|
||||
|
||||
static gboolean host_closed(GIOChannel *channel, GIOCondition condition, gpointer data) {
|
||||
(void)channel; (void)condition; (void)data;
|
||||
gtk_main_quit();
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
|
||||
static gboolean draw(GtkWidget *widget, cairo_t *cr, gpointer data) {
|
||||
(void)data;
|
||||
int w = gtk_widget_get_allocated_width(widget), h = gtk_widget_get_allocated_height(widget);
|
||||
cairo_set_source_rgb(cr, 0, 0, 0); cairo_paint(cr);
|
||||
if (picture) {
|
||||
// Cover: scale to fill, crop the overflow, keep the aspect ratio.
|
||||
double pw = gdk_pixbuf_get_width(picture), ph = gdk_pixbuf_get_height(picture);
|
||||
double s = w / pw > h / ph ? w / pw : h / ph;
|
||||
cairo_save(cr);
|
||||
cairo_translate(cr, (w - pw * s) / 2, (h - ph * s) / 2);
|
||||
cairo_scale(cr, s, s);
|
||||
gdk_cairo_set_source_pixbuf(cr, picture, 0, 0);
|
||||
cairo_paint(cr);
|
||||
cairo_restore(cr);
|
||||
}
|
||||
PangoLayout *layout = gtk_widget_create_pango_layout(widget, L("此设备正在被远程控制", "This device is being remotely controlled"));
|
||||
PangoFontDescription *font = pango_font_description_from_string("Sans 20");
|
||||
pango_layout_set_font_description(layout, font);
|
||||
int tw, th; pango_layout_get_pixel_size(layout, &tw, &th);
|
||||
cairo_set_source_rgba(cr, 0, 0, 0, 0.45);
|
||||
cairo_rectangle(cr, (w - tw) / 2.0 - 24, h - th - 96, tw + 48, th + 32); cairo_fill(cr);
|
||||
cairo_set_source_rgb(cr, 1, 1, 1);
|
||||
cairo_move_to(cr, (w - tw) / 2.0, h - th - 80);
|
||||
pango_cairo_show_layout(cr, layout);
|
||||
pango_font_description_free(font); g_object_unref(layout);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* `rects` are the physical outputs in logical coordinates; monitors elsewhere (the virtual output)
|
||||
* stay uncovered. Returns when every window is closed or the process is killed. */
|
||||
int uu_privacy_wallpaper_run(const char *image, const int *rects, int count) {
|
||||
if (!gtk_init_check(NULL, NULL)) return 1;
|
||||
if (image && *image) picture = gdk_pixbuf_new_from_file(image, NULL);
|
||||
GdkDisplay *display = gdk_display_get_default();
|
||||
int shown = 0;
|
||||
for (int i = 0; i < gdk_display_get_n_monitors(display); i++) {
|
||||
GdkMonitor *monitor = gdk_display_get_monitor(display, i);
|
||||
GdkRectangle g; gdk_monitor_get_geometry(monitor, &g);
|
||||
int physical = 0;
|
||||
for (int r = 0; r < count; r++) {
|
||||
const int *c = rects + r * 4;
|
||||
if (c[0] == g.x && c[1] == g.y && c[2] == g.width && c[3] == g.height) physical = 1;
|
||||
}
|
||||
if (!physical) continue;
|
||||
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), "uu-remote-linux privacy");
|
||||
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
|
||||
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
|
||||
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
|
||||
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
|
||||
gtk_window_set_default_size(GTK_WINDOW(window), g.width, g.height);
|
||||
g_signal_connect(window, "draw", G_CALLBACK(draw), NULL);
|
||||
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
|
||||
gtk_window_fullscreen_on_monitor(GTK_WINDOW(window), gtk_widget_get_screen(window), i);
|
||||
gtk_widget_show_all(window);
|
||||
shown++;
|
||||
}
|
||||
if (!shown) return 2;
|
||||
/* EOF follows the host process, including crashes, rather than its spawning worker thread. */
|
||||
GIOChannel *host = g_io_channel_unix_new(0);
|
||||
guint watch = g_io_add_watch(host, G_IO_HUP | G_IO_ERR | G_IO_NVAL, host_closed, NULL);
|
||||
/* Readiness handshake: the host treats picture mode as on only after this line. */
|
||||
fputs("ready\n", stdout); fflush(stdout);
|
||||
gtk_main();
|
||||
if (g_main_context_find_source_by_id(NULL, watch)) g_source_remove(watch);
|
||||
g_io_channel_unref(host);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
# 实验性防窥 / Experimental privacy screen
|
||||
|
||||
仅支持 KDE Plasma Wayland(portal 后端)。开启后,采集和输入切换到 KWin 虚拟输出
|
||||
(portal ScreenCast 的 VIRTUAL 源),再用 `kscreen-doctor` 禁用物理屏;远程操作不会点亮
|
||||
本机屏幕。关闭、最后一个桌面连接断开或正常退出时,先重新启用物理屏,再结束虚拟输出、切回物理屏采集。
|
||||
顺序参考 KRdp 虚拟显示器的 replace 策略和 Sunshine 的 KDE 方案:创建虚拟输出前记录物理屏,
|
||||
从不禁用虚拟输出本身(KWin bug 527747)。GNOME、其他 Wayland 桌面和 X11 不支持。
|
||||
|
||||
壁纸模式:窗口随物理屏禁用迁到虚拟输出后,重新启用物理屏,把虚拟输出设为主屏、用 KWin 脚本把窗口
|
||||
留在虚拟输出上,再由 `privacy-wallpaper` 子进程在每块物理屏上全屏置顶显示 Plasma 当前桌面壁纸和
|
||||
“此设备正在被远程控制”。物理屏开着时 uinput 绝对坐标覆盖整个布局,主机按虚拟输出在布局中的位置换算。
|
||||
需要 GTK3。
|
||||
|
||||
KDE Plasma Wayland only (portal backend). Enabling moves capture and input to a KWin virtual
|
||||
output (portal ScreenCast VIRTUAL source) and disables the physical outputs with `kscreen-doctor`,
|
||||
so remote input cannot wake them. Disabling, the last desktop disconnect or a normal exit re-enables
|
||||
the physical outputs first, then ends the virtual share and returns to the monitor. Physical outputs
|
||||
are recorded before the virtual one exists; the virtual output itself is never disabled (KWin bug
|
||||
527747). GNOME, other Wayland desktops and X11 are unsupported.
|
||||
|
||||
Wallpaper mode: after the windows have moved to the virtual output, the physical outputs are turned
|
||||
back on as secondary outputs, a KWin script keeps the windows on the virtual one, and the
|
||||
`privacy-wallpaper` child process covers each physical output with Plasma's desktop wallpaper and a
|
||||
notice (fullscreen, keep-above). uinput's absolute axes then span the whole layout, so pointer input
|
||||
is aimed at the virtual output's region. Needs GTK3.
|
||||
|
||||
注意 / Notes:
|
||||
|
||||
- 虚拟屏分辨率由 KDE 决定(默认 1920x1080,首次可能在本机弹窗选择,之后沿用保存的授权
|
||||
`portal-permissions/kde-virtual`)。窗口会被 KWin 移到虚拟屏,恢复后位置可能变化。
|
||||
The virtual size is KDE's (1920x1080 by default; the first share may ask on the host, later ones
|
||||
reuse `portal-permissions/kde-virtual`). KWin moves windows to it; positions may change on restore.
|
||||
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
|
||||
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
|
||||
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
|
||||
privacy screen is on (`/dev/uinput` access required); mobile drag gestures act as plain mouse drags.
|
||||
- 开启期间通过 KWin 的 InputDevice 接口禁用本地键盘、鼠标、触摸板和触摸屏(含手势守护进程、ydotoold
|
||||
等由本机驱动的虚拟设备),保留电源键、合盖开关和主机自己的 uinput 设备;`UU_PRIVACY_BLOCK_INPUT=0` 关闭此项。
|
||||
KWin 会保存设备开关,所以主机另起 `privacy-guard` 子进程:主机以任何方式结束(包括 SIGKILL)都会按恢复记录
|
||||
重新启用设备和物理屏;下次启动也会重试。防窥期间新插入的设备不会被禁用。
|
||||
While on, local keyboards, pointers, touchpads and touchscreens are disabled through KWin's
|
||||
InputDevice interface (including software devices fed by local hardware such as gesture daemons and
|
||||
ydotoold); the power button, lid switch and the host's own uinput devices stay. Set
|
||||
`UU_PRIVACY_BLOCK_INPUT=0` to keep local input. KWin saves the device flag, so a `privacy-guard`
|
||||
child restores devices and outputs from the record whenever the host ends, including SIGKILL; the
|
||||
next start retries too. Devices plugged in during privacy are not blocked.
|
||||
- 这是尽力而为的遮挡,不是保密边界。/ This is best-effort obscuring, not a confidentiality boundary.
|
||||
- 恢复记录保存在配置文件旁的 `privacy-power.json`(0600);崩溃后下次启动重新启用记录的物理屏。
|
||||
若主机无法启动,可在本机终端执行 `kscreen-doctor output.<name>.enable`。
|
||||
The recovery record `privacy-power.json` (0600) re-enables the recorded outputs at the next start
|
||||
after a crash; manually: `kscreen-doctor output.<name>.enable`.
|
||||
- 需要 coreutils `timeout`、`gdbus` 和可用的 uinput(`/dev/uinput` 可写,且未设 `UU_INPUT_BACKEND=native`);
|
||||
缺少时请求在改动屏幕和设备之前被拒绝。隐私模式的遮挡窗口建好后才算开启,失败即回滚。
|
||||
Requires coreutils `timeout`, `gdbus` and working uinput (`/dev/uinput` writable, not
|
||||
`UU_INPUT_BACKEND=native`); otherwise the request is refused before outputs or devices change.
|
||||
Picture mode counts as on only after the cover window reports ready; a failure rolls back.
|
||||
|
||||
## 协议 / Protocol
|
||||
|
||||
字段号来自官方 Mac 客户端的 SwiftProtobuf name map / Field numbers from the Mac UURemote name maps:
|
||||
|
||||
- RPC 7 `PrivateScreenSettingRequest {1 enable, 2 privacy_type, 3 setting_source}` → RpcResponse 3
|
||||
`{1 error_code, 2 req_privacy_type, 3 cur_privacy_type}`;PrivateScreenType 2 隐私/picture, 3 关屏/screen off。
|
||||
主机先应答再切换(客户端约数秒超时,报 9998);切换失败发 ReportError -7。
|
||||
The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7.
|
||||
成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。
|
||||
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
|
||||
- RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。
|
||||
Sent before picture mode; answered empty (success), the host keeps its own wallpaper.
|
||||
- FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type`
|
||||
上报当前实际模式(1 关闭、2 屏保、3 关屏),不使用 host_settings.json 中的历史选项;SystemStateChange 5
|
||||
`PrivateScreenState` 在状态变化时推送。
|
||||
SettingMetric 4/7 report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference;
|
||||
SystemStateChange 5 is sent after a switch.
|
||||
|
||||
Mac 4.43.0 从 CONTROL 发送请求,但只在 TEXT 接收分支处理上述 RPC 应答与 SystemMetrics。
|
||||
防窥与屏保应答走 TEXT;SystemMetrics 同步发送到 TEXT,并保留 CONTROL 上报以兼容其他客户端。
|
||||
每个 peer 独立排队,TEXT 打开后才发送;待发 SystemMetrics 只保留最新一条,其他应答最多 64 条,
|
||||
按入队顺序发送。满队列时丢弃新增应答并记录一次警告,不阻塞 CONTROL 请求处理。
|
||||
SystemMetrics 优先读取非零的 field 7,仅在其为 0 时回退
|
||||
到 field 4。SystemMetrics field 1 `metrics` 必须列出本次报告的类型(general=1、setting=2),
|
||||
否则客户端直接忽略消息内容。已用原签名 Mac 4.43.0 客户端验证三种模式的安全浮层回显,
|
||||
关屏后断开恢复物理屏与输入设备,再次连接回显“不启用”。
|
||||
Mac 4.43.0 sends requests on CONTROL, but handles these RPC responses and SystemMetrics only on TEXT.
|
||||
Privacy/screensaver replies use TEXT; SystemMetrics are also sent on TEXT, retaining CONTROL for other
|
||||
viewers. Each peer queues messages until its TEXT channel opens, retaining only the latest pending
|
||||
SystemMetrics and up to 64 other replies in FIFO order. Excess replies are dropped with one warning
|
||||
per peer, without blocking CONTROL request handling. Nonzero field 7 takes precedence over
|
||||
field 4. SystemMetrics field 1 `metrics` must list the reported sections (general=1, setting=2), or the
|
||||
viewer ignores the payload. The original signed Mac 4.43.0 viewer was verified for all three labels,
|
||||
physical-screen/input restoration on disconnect, and an off label after reconnecting.
|
||||
|
||||
官方主机侧依据:原签名 Mac `UURemoteServer` 4.43.0(626),arm64 UUID
|
||||
`7E10CB24-F516-3728-8375-BA5EC124A2C5`。`SystemMetricsHandler.handleSystemMetrics`(`0x10000a96c`)
|
||||
按请求填充各节,general 分支在 `0x10000abe8` 追加 `1`,setting helper(`0x10000a230`)
|
||||
在 `0x10000a64c` 追加 `2`;`GvPb_SystemMetrics.traverse`(`0x100423840`)将列表按 packed enum
|
||||
写入 field 1。发送链 `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` 使用 TEXT。
|
||||
这是静态主机代码依据:请求 general 和 setting 时得到 `[1,2]`,不是抓包,也不表示每条响应都固定
|
||||
包含两节或证明官方 CONTROL 报文。本实现总是报告两节,因此列出 `[1,2]`。
|
||||
Official host evidence: the original signed Mac `UURemoteServer` 4.43.0 (626), arm64 UUID
|
||||
`7E10CB24-F516-3728-8375-BA5EC124A2C5`. `SystemMetricsHandler.handleSystemMetrics` (`0x10000a96c`)
|
||||
fills the requested sections, appending GENERAL=1 at `0x10000abe8` and SETTING=2 at `0x10000a64c`
|
||||
in helper `0x10000a230`. `GvPb_SystemMetrics.traverse` (`0x100423840`) encodes that list as packed
|
||||
field 1. The send chain `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` uses TEXT.
|
||||
This is static host-code evidence: requesting both sections produces `[1,2]`; it is not a packet
|
||||
capture or proof that every response includes both sections or that the official host sends it on
|
||||
CONTROL. Our payload always reports both sections, so it lists `[1,2]`.
|
||||
|
||||
Android 4.43.0 已确认打开 TEXT;主机日志和手机端人工验收确认,关屏、隐私屏保、取消三种操作的
|
||||
实际模式与菜单选中状态均正确。Windows/iOS 未在本轮验收。
|
||||
Android 4.43.0 opens TEXT; host logs and manual phone-side acceptance confirmed that screen-off,
|
||||
picture and off operations update both the effective mode and the selected menu item.
|
||||
Windows/iOS were not tested in this round.
|
||||
|
||||
## 本机诊断 / Local diagnostic
|
||||
|
||||
禁用物理屏 5 秒后恢复,不登录、不启动第二个主机;先停止使用同一配置目录的主机。
|
||||
Disables the physical outputs for five seconds, then restores them. Stop the host first.
|
||||
|
||||
```sh
|
||||
cargo build --locked --features wayland,portal --bin uuremote-server
|
||||
target/debug/uuremote-server privacy-screen-probe
|
||||
UU_PRIVACY_PROBE_WALLPAPER=1 target/debug/uuremote-server privacy-screen-probe # 壁纸模式 / wallpaper mode
|
||||
```
|
||||
|
||||
## 代码结构 / Code layout
|
||||
|
||||
`src/privacy_screen/` 分两层:与桌面无关的控制器和共享部件,以及每种桌面一个后端。
|
||||
The module has a desktop-independent controller with shared parts, and one backend per desktop.
|
||||
|
||||
| 文件 / File | 职责 / Responsibility |
|
||||
|---|---|
|
||||
| `mod.rs` | 控制器:桌面会话计数、模式切换(先恢复再进入)、失败回滚、崩溃恢复、probe / controller: sessions, mode switch (leave, then enter), rollback, crash recovery, probe |
|
||||
| `mode.rs` | `Mode { Picture, ScreenOff }` ↔ 协议 `privacy_type` 1 关 / 2 隐私 / 3 关屏 |
|
||||
| `protocol.rs` | RPC 7 请求解析与 RpcResponse 3 编码 / request parsing and response encoding |
|
||||
| `backend.rs` | `Backend` trait 与按桌面选择后端 / the trait and backend selection |
|
||||
| `record.rs` | 恢复记录 `{backend, mode, data}`、进程锁、`Journal` / recovery record, process lock, journal |
|
||||
| `guard.rs` | `privacy-guard` 子进程:主机以任何方式结束都按记录恢复 / restores from the record however the host ends |
|
||||
| `cover.rs` | `privacy-wallpaper` 子进程:GTK 全屏遮挡窗口 / GTK cover window process |
|
||||
| `tool.rs` | 带超时的外部命令、gdbus、等待生效 / bounded tool calls, gdbus, wait-until |
|
||||
| `kde/` | KDE 后端:`outputs.rs` kscreen-doctor 布局,`input.rs` KWin 输入设备,`kwin.rs` KWin 脚本,`mod.rs` 编排 |
|
||||
|
||||
新增桌面(X11、GNOME…)只需实现 `Backend` 并在 `backend::detect` / `backend::named` 登记:
|
||||
`enter` 在每一步改动之前通过 `Journal::save` 写入足以撤销它的数据;`leave` 只依据这些数据撤销,
|
||||
因为崩溃恢复时(守护进程或下次启动)没有桌面视频流。Picture 模式可复用 `cover::show`;
|
||||
若物理屏保持开启而 uinput 坐标覆盖整个布局,返回 `Entered::pointer_region`。
|
||||
|
||||
To add a desktop (X11, GNOME, ...), implement `Backend` and register it in `backend::detect` and
|
||||
`backend::named`. `enter` saves, through `Journal::save`, what undoes each step before making it;
|
||||
`leave` must undo from that data alone, because crash recovery (guard or next start) has no
|
||||
desktop stream. Picture mode can reuse `cover::show`; when physical outputs stay on and uinput's
|
||||
axes span the whole layout, return `Entered::pointer_region`.
|
||||
@@ -0,0 +1,15 @@
|
||||
KDE Wayland 被控端新增实验性防窥模式。/ Experimental privacy screen for KDE Wayland hosts.
|
||||
|
||||
### 新增 / Added
|
||||
- **KDE Wayland 被控端防窥模式(隐私 / 关屏,#146,感谢 @ferstar,对应 #140)**:控制端开启防窥后,采集与输入切到 KWin 虚拟输出,物理屏关闭或以壁纸遮挡,本地键鼠暂停;主机进程以任何方式退出都会恢复屏幕和输入。需要 `kscreen-doctor` 与 uinput 权限。
|
||||
KDE Wayland hosts: privacy screen (privacy / screen-off) switches capture and input to a KWin virtual output and blanks or covers the physical display; local input is paused and restored on any host exit. Requires `kscreen-doctor` and uinput access.
|
||||
- 已知限制:Mac 控制端的防窥菜单切换后仍显示“不启用”,实际模式正确;X11 与其他 Wayland 桌面暂不支持。
|
||||
Known limitation: the Mac viewer menu still shows "off" after switching; X11 and other Wayland desktops are not supported yet.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI。防窥模式由贡献者在 KDE Wayland 实机验证;维护者尚未用官方客户端复测。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.43_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.43-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.43`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,13 @@
|
||||
Mac 控制端防窥菜单正确显示当前模式。/ The Mac viewer privacy menu now shows the active mode.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **Mac 控制端防窥状态回显(#147、#148,感谢 @ferstar)**:防窥切换应答与 SystemMetrics 改经 TEXT 通道发送(TEXT 打开前排队,metrics 只保留最新一份),SystemMetrics 带上报告的分节列表并报告当前防窥模式,修复 v0.2.43 中菜单切换后仍显示“不启用”的问题。
|
||||
Privacy replies and SystemMetrics are now also delivered over the TEXT channel (queued until it opens, keeping only the latest metrics); SystemMetrics lists its reported sections and the current privacy mode, so the Mac viewer menu no longer shows "off" after switching.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI。贡献者在 KDE Wayland + Mac 控制端实机验证;维护者尚未用 Windows/iOS/Android 控制端复测。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.44_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.44-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.44`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,13 @@
|
||||
控制端远程窗口不再被本地输入法截获按键。/ The viewer's remote window no longer lets the local IME swallow keys.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **控制端本地输入法截获按键(#149、#150,感谢 @xfjm136)**:SDL 远程桌面窗口创建后关闭本地文本输入,按键只按物理键转发,由被控端输入法处理;修复本地与远端都用 Shift 切换中英文时,Shift 等按键被本地输入法吞掉的问题。不修改系统输入法设置,GTK 启动器不受影响。
|
||||
The SDL remote desktop window now disables local text input after creation, so keys are forwarded as physical keys and the remote IME handles composition; Shift and similar keys are no longer swallowed by the local IME. System IME settings and the GTK launcher are unchanged.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试(含 SDL dummy 子进程测试)与 CI。贡献者在 KDE Wayland + Fcitx5 连接 Windows 实机验证;其他桌面/输入法后端未复测。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.45_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.45-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.45`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,13 @@
|
||||
Linux 复制的文本可直接粘贴到 Windows 控制端。/ Text copied on Linux now pastes in the Windows viewer.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **Linux → Windows 文本剪贴板无法粘贴(#151,感谢 @afwer1231 的定位)**:主机提供 Unicode 文本格式时,格式名改用官方 Windows 端的 `predefined_13`(id 仍为 13)。此前的 `CF_UNICODETEXT` 名字会让 Windows 控制端注册一个同名的自定义格式,文本虽已到达但普通粘贴读不到。Mac 控制端按 id 13 识别,不受影响。
|
||||
The host now names its Unicode text offer `predefined_13` (id 13), as official Windows peers do. The previous `CF_UNICODETEXT` name made the Windows viewer register a custom format of that name, so the text arrived but normal paste could not read it. The Mac viewer matches by id 13 and is unaffected.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;格式名依据官方 Windows/Mac 程序中的字符串对照(推断)。尚未在 Windows 控制端实机验证。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.46_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.46-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.46`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,17 @@
|
||||
官方客户端的设备卡片在未连接时也能显示 Linux 主机的壁纸。/ Device cards in official clients now show the Linux host's wallpaper while disconnected.
|
||||
|
||||
### 新增 / Added
|
||||
- **上报系统壁纸(#152/#153,感谢 @ferstar)**:已登录的图形主机按官方 Windows 被控端的流程获取文件令牌、上传当前壁纸并回报地址,每 60 秒检查一次,内容不变不重复上传。支持 GNOME/Cinnamon、KDE(Plasma 5/6,含壁纸包和主题默认壁纸)、Xfce;其他桌面可用 `UU_WALLPAPER=/绝对路径/图片` 指定(PNG/JPEG/WebP)。访客与无桌面模式不上报。
|
||||
Signed-in graphical hosts fetch a file token, upload the current wallpaper and report its URL, following the official Windows host. Checks run every 60 seconds; unchanged content is not re-uploaded. Supports GNOME/Cinnamon, KDE (Plasma 5/6, including wallpaper packages and theme defaults) and Xfce; other desktops can set `UU_WALLPAPER=/absolute/path/image`. Guest and headless hosts skip it.
|
||||
|
||||
### 隐私 / Privacy
|
||||
默认会把当前壁纸图片上传到 UU 的文件服务;设置 `UU_WALLPAPER_UPLOAD=0` 可关闭。日志只记录结果和失败阶段。
|
||||
By default the current wallpaper image is uploaded to UU's file service; set `UU_WALLPAPER_UPLOAD=0` to disable. Logs record only the outcome and failing stage.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;贡献者在 KDE 上实机确认官方客户端显示壁纸。GNOME/Cinnamon、Xfce 尚无实机验收;多屏、动态/XML 壁纸不在本次范围。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.47_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.47-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.47`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,43 @@
|
||||
# Device-card wallpaper reporting
|
||||
|
||||
The official Windows host publishes the system wallpaper for device cards. This is separate from
|
||||
the Linux viewer's local last-frame cache and does not require capturing desktop windows on disconnect.
|
||||
|
||||
## Static protocol evidence
|
||||
|
||||
Read-only analysis of the locally installed `GameViewerServer.exe` (SHA-256
|
||||
`af3a15c3887e06bfa9506971e01cd8ec58f41efe8ac9eb5831e31dae1fc1cef8`) found:
|
||||
|
||||
- `ApplicationManager::updateWallpaper`, `getWallpaperPath`, `uploadWallpaper`, and log strings
|
||||
`wallpaper check`, `wallpaper is not changed, the same md5`, `wallpaper file upload succeeded`.
|
||||
The source path recorded in the executable is `server_core/business/apps/application_manager.cpp`.
|
||||
- `0x140ade430`: GET `/api/v1/tool/fp/token?filetype=1`. Response parser `0x140ae3410`
|
||||
reads `token`, `req_url`, `ttl`, optional `max_size` from API data.
|
||||
- `0x140aeb8c0`: POST raw file bytes to `req_url`, with `Authorization` set directly to the
|
||||
file token (no Bearer prefix, multipart wrapper, or account credentials).
|
||||
- Upload callback `0x140ad1010` requires HTTP 200; parser `0x140ae1550` reads top-level
|
||||
`fsize`, `url`, `md5`, `mime`. The wallpaper callback `0x1404206c0` uses `url`.
|
||||
- `0x140b48d80`: POST `/api/v1/device/wallpaper`, JSON `{"wallpaper_url":"<uploaded URL>"}`.
|
||||
Device response parsers and the official viewer also contain `wallpaper_url`.
|
||||
|
||||
Addresses are preferred virtual addresses for that executable only. No official binary, assets,
|
||||
account data, upload tokens, desktop pictures, or account URLs are included here.
|
||||
This establishes the wallpaper flow statically; it does not prove that every official client's
|
||||
last-frame display uses this flow or establish the official timer interval.
|
||||
|
||||
## Linux behavior
|
||||
|
||||
Signed-in graphical hosts check the configured wallpaper on startup and every 60 seconds, upload
|
||||
only changed supported image bytes, and retry failures on a later check. Guest and headless hosts skip
|
||||
reporting. Account renewal replaces the reporting task; stopping the host cancels it. Network work
|
||||
does not block signaling or alter peer connections. Images are bounded to 10 MiB and the file service's
|
||||
advertised limit. HTTPS is required and upload redirects are disabled.
|
||||
|
||||
GNOME/Unity/Cinnamon use GSettings (GNOME dark preference included); KDE reads the first image
|
||||
wallpaper containment, including image packages, or the installed look-and-feel's default wallpaper
|
||||
when no explicit wallpaper is configured; Xfce reads the first `last-image`. Multi-monitor selection, slideshow/XML
|
||||
wallpapers, compositor-specific wallpaper daemons, and unsupported formats are not inferred.
|
||||
`UU_WALLPAPER=/absolute/path/image.png` selects a file explicitly; `UU_WALLPAPER_UPLOAD=0` disables
|
||||
reporting. PNG, JPEG, and WebP are supported. No desktop screenshot fallback is used.
|
||||
|
||||
Only success/failure is logged. Paths, hashes, URLs, response bodies and credentials stay out of logs.
|
||||
@@ -181,6 +181,7 @@ impl Drop for ScreenCapture {
|
||||
|
||||
/// Keep the display visible only while a peer is streaming; never unlock it.
|
||||
pub fn keep_display_awake() -> Result<(), String> {
|
||||
if crate::privacy_screen::active() { return Ok(()); }
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Kms { return Ok(()); }
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal {
|
||||
return crate::desktop_power::wake();
|
||||
|
||||
+10
-2
@@ -17,6 +17,9 @@ impl TextFormat {
|
||||
}
|
||||
fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}}
|
||||
fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}}
|
||||
/// Name in a format-list offer. Official Windows peers name predefined formats `predefined_<id>`; a plain
|
||||
/// `CF_UNICODETEXT` makes the Windows viewer register a custom format instead of id 13 (issue #151).
|
||||
fn offer_name(self)->&'static str{match self{Self::Windows=>WINDOWS_OFFER_NAME,Self::Mac=>MAC_TEXT}}
|
||||
fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}}
|
||||
fn decode(self,data:&[u8])->Result<String,&'static str>{
|
||||
match self{
|
||||
@@ -31,6 +34,7 @@ impl TextFormat {
|
||||
}
|
||||
}
|
||||
}
|
||||
const WINDOWS_OFFER_NAME:&str="predefined_13";
|
||||
const BLOCK_BYTES:usize=0x20000;
|
||||
const MAX_BYTES:usize=MAX_TEXT*2+2;
|
||||
pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>}
|
||||
@@ -96,7 +100,7 @@ impl State{
|
||||
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
|
||||
self.local=Some(text);
|
||||
let mut list=Vec::new();
|
||||
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.name(),&mut format);nested(1,&format,&mut list);}
|
||||
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.offer_name(),&mut format);nested(1,&format,&mut list);}
|
||||
Ok(request(id,1,&list))
|
||||
}
|
||||
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
|
||||
@@ -210,7 +214,11 @@ mod tests{
|
||||
let data=bytes(bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap(),3).unwrap().unwrap();
|
||||
assert_eq!(data,b"hi");
|
||||
// Host-side offers are unchanged: CF_UNICODETEXT only.
|
||||
assert_eq!(format_ids(&State::default().offer(1,"hi".into()).unwrap()),vec![13]);
|
||||
let host_offer=State::default().offer(1,"hi".into()).unwrap();
|
||||
assert_eq!(format_ids(&host_offer),vec![13]);
|
||||
let list=bytes(bytes(&host_offer,9).unwrap().unwrap(),1).unwrap().unwrap();
|
||||
let format=bytes(list,1).unwrap().unwrap();
|
||||
assert_eq!(text_field(format,2),Ok(WINDOWS_OFFER_NAME));
|
||||
}
|
||||
#[test]
|
||||
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
|
||||
|
||||
@@ -182,6 +182,10 @@ pub fn encode_echo_response_with_clipboard(seq: u64, timestamp: u64, request_seq
|
||||
// 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE.
|
||||
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8,
|
||||
16, crate::system_actions::FF_SIMPLE_ACTION, 24, crate::system_actions::FF_SYSTEM_METRICS, 48, 2];
|
||||
// Privacy screen (Mac UURemote name maps): 3 ff_system_metrics = FF_SYSTEM_METRICS_SETTING_PRIVATE_SCREEN
|
||||
// (3, after AUTO_LOCK 2; the viewer then reads SettingMetric 4/7), 4 ff_private_screen =
|
||||
// FF_PRIVATE_SCREEN_ENHANCED_PRIVACY (2): screen off besides the picture mode.
|
||||
if crate::privacy_screen::supported() { flags[5] = 3; flags.extend([32, 2]); }
|
||||
if clipboard { flags.extend_from_slice(&[64, 3]); }
|
||||
action.push(34);
|
||||
action.push(flags.len() as u8);
|
||||
|
||||
@@ -79,6 +79,60 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
|
||||
crate::initialization::envelope(1, 0, 27, &frame)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn privacy_replies_wait_for_each_peers_text_channel() {
|
||||
tokio::time::timeout(Duration::from_secs(25), async {
|
||||
let mut peers = Vec::new();
|
||||
for request_id in [41, 51] {
|
||||
let (host, mut viewer) = connect(Arc::new(InputInjector::without_desktop()), false, None,
|
||||
&["CONTROL_DATA_CHANNEL"]).await;
|
||||
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
|
||||
for (id, case, payload) in [(request_id, 25, &[][..]), (request_id + 1, 7, &[8, 1, 16, 3][..])] {
|
||||
let mut rpc = bytes(1, &[8, id]);
|
||||
rpc.extend(bytes(case, payload));
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(1, 0, 21, &rpc)).await;
|
||||
}
|
||||
// A synthetic host rejects privacy without touching a physical desktop.
|
||||
// Echo is a dispatch barrier: both replies are queued before TEXT exists.
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(2, 0, 3, &[8, 0])).await;
|
||||
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
|
||||
peers.push((request_id, host, viewer));
|
||||
}
|
||||
for (request_id, host, mut viewer) in peers {
|
||||
let text = viewer.pc.create_data_channel("TEXT_DATA_CHANNEL", None).await.unwrap();
|
||||
let (tx, messages) = mpsc::unbounded_channel();
|
||||
text.on_message(Box::new(move |message| {
|
||||
let _ = tx.send(("TEXT_DATA_CHANNEL".into(), message.data.to_vec()));
|
||||
Box::pin(async {})
|
||||
}));
|
||||
viewer.messages = messages;
|
||||
let mut replies = Vec::new();
|
||||
let mut metrics_seen = false;
|
||||
while replies.len() < 2 || !metrics_seen {
|
||||
let (channel, message) = tokio::time::timeout(Duration::from_secs(5), viewer.messages.recv()).await
|
||||
.expect("late TEXT delivery timed out").expect("peer stopped responding");
|
||||
assert_eq!(channel, "TEXT_DATA_CHANNEL");
|
||||
if let Some(metrics) = body(&message, 13) {
|
||||
assert_eq!(body(metrics, 1), Some([1, 2].as_slice()));
|
||||
metrics_seen = true;
|
||||
}
|
||||
if body(&message, 22).is_some() { replies.push(message); }
|
||||
}
|
||||
for ((id, case), message) in [(request_id, 21), (request_id + 1, 3)].into_iter().zip(replies) {
|
||||
let rpc = body(&message, 22).unwrap();
|
||||
assert_eq!(body(rpc, 1), Some([8, id].as_slice()));
|
||||
let response = body(rpc, case).expect("wrong RPC response case");
|
||||
if case == 3 {
|
||||
assert!(decode_wire(response).unwrap().iter().any(|f| f.number == 1 && f.value == WireValue::Varint(1)));
|
||||
}
|
||||
}
|
||||
host.pc.close().await.unwrap();
|
||||
viewer.pc.close().await.unwrap();
|
||||
viewer.router.lock().await.stop().await.unwrap();
|
||||
}
|
||||
}).await.expect("privacy TEXT routing regression exceeded deadline");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ready_portal_control_input_is_forwarded_while_locked() {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
|
||||
@@ -38,6 +38,7 @@ mod native {
|
||||
/// Set GNOME's display power-save mode to on. This does not unlock the session or change
|
||||
/// lock-screen policy. Session-bus setup and each method call are bounded to three seconds.
|
||||
pub fn wake() -> Result<(), String> {
|
||||
if crate::privacy_screen::active() { return Ok(()); }
|
||||
if !gnome_portal_active() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
+53
-6
@@ -116,6 +116,11 @@ fn single_portal_output() -> bool {
|
||||
.and_then(|output| active_output_count(&output.stdout)) == Some(1)
|
||||
}
|
||||
|
||||
/// The desktop injector opened uinput devices. The privacy screen needs them: KDE ignores portal
|
||||
/// input on its virtual-output share, so without uinput nobody could operate the desktop.
|
||||
static UINPUT_READY: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
pub fn uinput_ready() -> bool { UINPUT_READY.load(std::sync::atomic::Ordering::Acquire) }
|
||||
|
||||
impl InputInjector {
|
||||
pub fn new() -> Self {
|
||||
let backend = crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11);
|
||||
@@ -125,6 +130,7 @@ impl InputInjector {
|
||||
Err(e) => { log::warn!("uinput unavailable ({}); using the desktop input path. See README for the udev rule.", e.kind()); None }
|
||||
}
|
||||
} else { None };
|
||||
if uinput.is_some() { UINPUT_READY.store(true, std::sync::atomic::Ordering::Release); }
|
||||
let uinput_pointer = uinput.is_some() && (std::env::var("UU_INPUT_BACKEND").as_deref() == Ok("uinput")
|
||||
|| (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output()));
|
||||
if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); }
|
||||
@@ -322,7 +328,8 @@ impl InputInjector {
|
||||
};
|
||||
}
|
||||
if touch.finger != Finger::Up { return true }
|
||||
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some();
|
||||
// Gesture scrolling is portal-only; on the privacy screen's virtual share drags stay mouse drags.
|
||||
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some() && !self.virtual_uinput();
|
||||
let Some(start) = touch.at.filter(|_| bound) else { return false };
|
||||
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
if !REPORTED.swap(true, std::sync::atomic::Ordering::Relaxed) { log::info!("Mobile controller drag input: gesture (drag scrolls, hold selects)"); }
|
||||
@@ -502,9 +509,12 @@ impl InputInjector {
|
||||
if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
|
||||
let (w,h) = *self.screen.lock().unwrap();
|
||||
if w > 1 && h > 1 {
|
||||
let scale = |v: i32, extent: u32| (i64::from(v).clamp(0, i64::from(extent - 1))
|
||||
* i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
|
||||
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
|
||||
let (ax, ay) = self.privacy_absolute(x, y, (w, h)).unwrap_or_else(|| {
|
||||
let scale = |v: i32, extent: u32| (i64::from(v).clamp(0, i64::from(extent - 1))
|
||||
* i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
|
||||
(scale(x, w), scale(y, h))
|
||||
});
|
||||
return Self::uinput_result(uinput.move_absolute(ax, ay));
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -521,7 +531,12 @@ impl InputInjector {
|
||||
// Portal (GNOME/KDE): absolute motion is addressed to the shared stream, i.e. the captured
|
||||
// monitor; a uinput tablet would stretch the point across every monitor of the desktop.
|
||||
if !relative && self.backend==crate::desktop_backend::DesktopBackend::Portal {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
|
||||
// Privacy screen: KDE accepts absolute motion for a virtual-output stream but does not
|
||||
// move the pointer. The physical outputs are disabled then, so the uinput tablet's
|
||||
// desktop-wide axes cover exactly the virtual output.
|
||||
if !self.virtual_uinput() {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
|
||||
}
|
||||
}
|
||||
// X11 multi-screen: the point is inside the selected monitor; XTest and uinput span the root.
|
||||
let placement=if relative || self.backend!=crate::desktop_backend::DesktopBackend::X11 {None} else {crate::wayland::x11_placement()};
|
||||
@@ -531,6 +546,7 @@ impl InputInjector {
|
||||
let (w,h)=placement.and_then(|_|crate::capture::x11_last_size()).unwrap_or(*self.screen.lock().unwrap());
|
||||
if w > 1 && h > 1 {
|
||||
let scale = |v: i32, extent: u32| (i64::from(v) * i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
|
||||
if let Some((ax, ay)) = self.privacy_absolute(x, y, (w, h)) { return Self::uinput_result(uinput.move_absolute(ax, ay)); }
|
||||
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
|
||||
}
|
||||
}
|
||||
@@ -540,10 +556,23 @@ impl InputInjector {
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::move_pointer(x,y,relative) }
|
||||
else if relative { unsafe { x11_mouse_relative(x,y) } } else { unsafe { x11_mouse_move(x,y) } }
|
||||
}
|
||||
/// Privacy picture mode keeps the physical outputs on, so uinput's axes span them too: aim the
|
||||
/// stream point inside the virtual output's region of the layout.
|
||||
fn privacy_absolute(&self, x: i32, y: i32, (w, h): (u32, u32)) -> Option<(i32, i32)> {
|
||||
let [rx, ry, rw, rh] = crate::privacy_screen::pointer_region().filter(|_| self.virtual_uinput())?;
|
||||
let abs = |v: i32, extent: u32, o: f64, span: f64| ((o + f64::from(v.clamp(0, extent as i32 - 1)) / f64::from(extent - 1) * span)
|
||||
* f64::from(crate::uinput::ABS_MAX)).round() as i32;
|
||||
Some((abs(x, w, rx, rw), abs(y, h, ry, rh)))
|
||||
}
|
||||
/// Privacy screen: KDE ignores portal pointer events (motion and buttons) on a virtual-output
|
||||
/// share, so the pointer uses uinput, whose axes then span just the virtual output.
|
||||
fn virtual_uinput(&self)->bool {
|
||||
self.uinput.is_some() && self.portal.lock().unwrap().as_ref().is_some_and(|p| p.is_virtual())
|
||||
}
|
||||
fn inject_button(&self,button:i32,pressed:bool)->i32 {
|
||||
// Portal: clicks follow absolute motion on the same session, so a tap cannot land
|
||||
// before the compositor has moved the pointer there (uinput is a separate queue).
|
||||
if !self.uinput_pointer && self.backend==crate::desktop_backend::DesktopBackend::Portal {
|
||||
if !self.uinput_pointer && self.backend==crate::desktop_backend::DesktopBackend::Portal && !self.virtual_uinput() {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); }
|
||||
}
|
||||
if let Some(uinput)=&self.uinput {
|
||||
@@ -755,9 +784,27 @@ impl InputInjector {
|
||||
fn type_portal_keysyms(&self, text: &str) -> usize {
|
||||
let Some(symbols)=ascii_keysyms(text) else { return 0 };
|
||||
if !gnome_layout_types_ascii() { return 0; }
|
||||
if self.virtual_uinput() { return self.type_uinput_ascii(&symbols); }
|
||||
let Some(portal)=self.portal.lock().unwrap().clone() else { return 0 };
|
||||
symbols.iter().take_while(|&&symbol| portal.type_keysym(symbol).is_ok()).count()
|
||||
}
|
||||
/// Privacy screen: KDE ignores portal keysyms on a virtual-output share. Type through uinput
|
||||
/// on the US layout the keysym path already requires, adding Shift for shifted characters.
|
||||
fn type_uinput_ascii(&self, symbols: &[u32]) -> usize {
|
||||
const SHIFTED: &str = "~!@#$%^&*()_+{}|:\"<>?";
|
||||
const BASE: &str = "`1234567890-=[]\\;',./";
|
||||
symbols.iter().take_while(|&&symbol| {
|
||||
let c=char::from_u32(symbol).unwrap_or('\0');
|
||||
let (base, shift)=if c.is_ascii_uppercase() { (c.to_ascii_lowercase() as u64, true) }
|
||||
else if let Some(i)=SHIFTED.find(c) { (BASE.as_bytes()[i] as u64, true) }
|
||||
else { (u64::from(symbol), false) };
|
||||
if crate::uinput::keysym_to_evdev(base).is_none() { return false; }
|
||||
if shift && self.inject_key(0xffe1, true)!=0 { return false; }
|
||||
let ok=self.inject_key(base, true)==0 && self.inject_key(base, false)==0;
|
||||
if shift { self.inject_key(0xffe1, false); }
|
||||
ok
|
||||
}).count()
|
||||
}
|
||||
pub fn key_event(&self, keycode: i32, is_press: bool) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
if self.backend!=crate::desktop_backend::DesktopBackend::X11 { return; }
|
||||
|
||||
+22
-3
@@ -5,6 +5,7 @@ mod ws_transport;
|
||||
mod engine_plugin;
|
||||
mod doctor;
|
||||
mod wol;
|
||||
mod wallpaper;
|
||||
mod desktop_backend;
|
||||
mod desktop_mode;
|
||||
mod desktop_session;
|
||||
@@ -45,6 +46,7 @@ mod inproc_encoder;
|
||||
mod capture_setting;
|
||||
mod audio;
|
||||
mod virtual_audio;
|
||||
mod privacy_screen;
|
||||
mod system_actions;
|
||||
mod capability;
|
||||
mod protocol;
|
||||
@@ -208,7 +210,7 @@ pub(crate) fn cli_pref_ok(which: &str, value: &str) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
const SUBCOMMANDS: [&str; 17] = ["doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
|
||||
const SUBCOMMANDS: [&str; 20] = ["privacy-guard", "privacy-wallpaper", "privacy-screen-probe", "doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
|
||||
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
|
||||
|
||||
/// Unknown arguments and illegal set-encoder / set-codec values exit 2 (never start a second host).
|
||||
@@ -630,6 +632,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
if login::run(gui).await.is_err() { std::process::exit(1); } // error already shown
|
||||
return Ok(());
|
||||
}
|
||||
if std::env::args().nth(1).as_deref() == Some("privacy-guard") { std::process::exit(privacy_screen::guard_main()); }
|
||||
if std::env::args().nth(1).as_deref() == Some("privacy-wallpaper") {
|
||||
std::process::exit(privacy_screen::cover_main(&std::env::args().skip(2).collect::<Vec<_>>()));
|
||||
}
|
||||
if std::env::args().nth(1).as_deref() == Some("privacy-screen-probe") {
|
||||
let screen = ScreenCapture::new()?;
|
||||
if screen.portal.is_none() { return Err(std::io::Error::other("privacy screen needs the portal backend").into()); }
|
||||
let _input = input::InputInjector::new(); // the privacy screen requires its uinput devices
|
||||
let mode = if std::env::var("UU_PRIVACY_PROBE_WALLPAPER").as_deref() == Ok("1") { privacy_screen::Mode::Picture } else { privacy_screen::Mode::ScreenOff };
|
||||
tokio::task::spawn_blocking(move || privacy_screen::probe(mode)).await?.map_err(std::io::Error::other)?;
|
||||
drop(screen);
|
||||
return Ok(());
|
||||
}
|
||||
privacy_screen::recover();
|
||||
virtual_audio::init();
|
||||
let _audio_cleanup=virtual_audio::Cleanup;
|
||||
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
|
||||
@@ -668,7 +684,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
}
|
||||
#[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); }
|
||||
if !assist_enabled { privacy_screen::shutdown(); 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 };
|
||||
@@ -699,7 +715,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
// 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() { close_peer(&old.pc).await; }
|
||||
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
|
||||
privacy_screen::shutdown(); 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.
|
||||
@@ -760,6 +776,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
client
|
||||
};
|
||||
|
||||
let mut wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
|
||||
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
|
||||
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
|
||||
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
|
||||
@@ -797,6 +814,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
log::error!("UU login is invalid or expired; a new QR login is required");
|
||||
let stale = config::read_fresh().ok().flatten().and_then(|f| f.get("token").and_then(|t| t.as_str()).map(str::to_owned));
|
||||
auth = Arc::new(UUAuthClient::new(login::wait_for_credentials(stale).await));
|
||||
wallpaper_task.0.abort();
|
||||
wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
|
||||
continue;
|
||||
}
|
||||
Err(e) => {
|
||||
|
||||
+82
-20
@@ -38,6 +38,7 @@ mod native {
|
||||
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}};
|
||||
crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
|
||||
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_capture(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
|
||||
@@ -110,7 +111,7 @@ mod native {
|
||||
was_locked.store(false, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>> }
|
||||
pub struct Session { handle: Mutex<Handle>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool }
|
||||
impl Session {
|
||||
fn take_lock_observation(&self) -> Result<bool, String> {
|
||||
// A recovery in progress must see the lock even if another capture
|
||||
@@ -137,7 +138,8 @@ mod native {
|
||||
/// Opens a session for `monitor` (a Mutter connector) with that monitor's saved consent;
|
||||
/// None means the screen currently selected, or the only monitor.
|
||||
/// `fresh` asks the host again instead of restoring the saved consent (which stays saved).
|
||||
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool) -> Result<Self, super::PortalError> {
|
||||
/// `virtual_output` shares a KWin virtual output instead (privacy screen) with its own consent.
|
||||
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool, virtual_output: bool) -> Result<Self, super::PortalError> {
|
||||
extern "C" fn is_cancelled(data: *mut c_void) -> i32 {
|
||||
let cancelled = unsafe { &*(data as *const std::sync::atomic::AtomicBool) };
|
||||
i32::from(cancelled.load(std::sync::atomic::Ordering::Acquire))
|
||||
@@ -150,12 +152,20 @@ mod native {
|
||||
let (mut error, mut width, mut height) = (0, 0, 0);
|
||||
let directory = super::permissions::directory();
|
||||
let key = super::permissions::desktop_key();
|
||||
let wanted = monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor);
|
||||
let wanted = if virtual_output { None } else { monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor) };
|
||||
let virtual_key = format!("{key}-virtual");
|
||||
// One opener at a time: consent tokens are single-use, and two concurrent openers
|
||||
// (privacy virtual-output switch and closure recovery after a quick reconnect) each
|
||||
// consumed one and both failed, leaving no saved consent (seen live, KDE).
|
||||
static OPENING: Mutex<()> = Mutex::new(());
|
||||
let _opening = OPENING.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
// Each monitor has its own consent; the desktop-wide key is the single-monitor one.
|
||||
let token = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
|
||||
wanted.as_deref().and_then(|name| super::permissions::take(dir, &super::permissions::monitor_key(name)))
|
||||
.or_else(|| super::permissions::take(dir, key))
|
||||
}).and_then(|value| std::ffi::CString::new(value).ok());
|
||||
let taken = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
|
||||
let take = |k: String| super::permissions::take(dir, &k).map(|v| (k, v));
|
||||
if virtual_output { return take(virtual_key.clone()); }
|
||||
wanted.as_deref().and_then(|name| take(super::permissions::monitor_key(name))).or_else(|| take(key.to_owned()))
|
||||
});
|
||||
let token = taken.as_ref().and_then(|(_, value)| std::ffi::CString::new(value.as_str()).ok());
|
||||
// The new token is saved once the granted monitor is known (after open).
|
||||
let mut cache: Option<String> = None;
|
||||
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
|
||||
@@ -167,10 +177,18 @@ mod native {
|
||||
if result.is_err() { log::warn!("Portal permission cache callback failed"); }
|
||||
}
|
||||
let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr());
|
||||
// A failed open must not cost the saved consent: put the token back unless the
|
||||
// portal handed out a new one. A stale token only makes the next open ask again.
|
||||
let failed = |code: i32, cache: &Option<String>| {
|
||||
if let (Some(dir), Some((k, value)), None) = (directory.as_deref(), taken.as_ref(), cache.as_ref()) {
|
||||
if super::permissions::save(dir, k, value).is_err() { log::warn!("Portal permission cache could not be restored"); }
|
||||
}
|
||||
super::PortalError { code }
|
||||
};
|
||||
#[allow(unused_mut)]
|
||||
let mut pointer: *mut c_void = std::ptr::null_mut();
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal)
|
||||
if !virtual_output && crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal)
|
||||
&& !std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0") {
|
||||
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
@@ -178,11 +196,13 @@ mod native {
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
|
||||
&mut error, &mut width, &mut height,
|
||||
) };
|
||||
if pointer.is_null() && error != 0 { return Err(super::PortalError { code: error }); }
|
||||
if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
|
||||
if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
|
||||
}
|
||||
let pointer = if !pointer.is_null() { pointer } else { unsafe {
|
||||
if let Some(cancelled) = cancelled {
|
||||
if virtual_output {
|
||||
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
} else if let Some(cancelled) = cancelled {
|
||||
uu_portal_open_persist_cancellable(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void,
|
||||
is_cancelled, cancelled as *const _ as *mut c_void,
|
||||
@@ -192,12 +212,13 @@ mod native {
|
||||
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
}
|
||||
} };
|
||||
let handle = NonNull::new(pointer).ok_or(super::PortalError { code: error })?;
|
||||
let Some(handle) = NonNull::new(pointer) else { return Err(failed(error, &cache)) };
|
||||
let (mut x, mut y) = (0, 0);
|
||||
let granted = (unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
|
||||
let granted = (!virtual_output && unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
|
||||
.then(|| crate::wayland::portal_monitor_at(x, y)).flatten();
|
||||
if let (Some(dir), Some(token)) = (directory.as_deref(), cache.take()) {
|
||||
let saved = match &granted {
|
||||
_ if virtual_output => virtual_key.clone(),
|
||||
Some(name) => super::permissions::monitor_key(name),
|
||||
None => key.to_owned(),
|
||||
};
|
||||
@@ -206,7 +227,7 @@ mod native {
|
||||
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
|
||||
// Keep a freshly granted compositor frame regardless of lock state. Discarding it
|
||||
// before new damage can leave a static desktop permanently blank (#2).
|
||||
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted) })
|
||||
Ok(Self { handle: Mutex::new(Handle(handle)), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into() })
|
||||
}
|
||||
/// Frame pixels of the monitor the stream currently follows.
|
||||
pub fn size(&self) -> (u32, u32) {
|
||||
@@ -224,7 +245,7 @@ mod native {
|
||||
/// time GNOME asks on the host) and swap it in, so every holder of this Arc follows.
|
||||
pub fn switch_to(&self, connector: &str) -> Result<(), String> {
|
||||
if self.monitor().as_deref() == Some(connector) { return Ok(()); }
|
||||
let replacement = Self::open_inner(None, Some(connector), false).map_err(|error| error.to_string())?;
|
||||
let replacement = Self::open_inner(None, Some(connector), false, false).map_err(|error| error.to_string())?;
|
||||
if replacement.monitor().as_deref() != Some(connector) {
|
||||
return Err("Another monitor was shared; choose this monitor in the host dialog".into());
|
||||
}
|
||||
@@ -239,8 +260,32 @@ mod native {
|
||||
drop(previous);
|
||||
Ok(())
|
||||
}
|
||||
pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) }
|
||||
/// Privacy screen: capture and input move to a KWin virtual output (on) or back to the
|
||||
/// physical monitor (off). The caller enables physical outputs before switching back.
|
||||
pub fn set_virtual(&self, on: bool) -> Result<(), String> {
|
||||
if self.is_virtual() == on { return Ok(()); }
|
||||
// Closure recovery would otherwise see the replaced share end and reopen the wrong source.
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
let monitor = self.monitor();
|
||||
// KDE restores a monitor share against the whole workspace while the virtual output
|
||||
// exists (seen live: 3968x1280 = panel + virtual), so end the virtual share first.
|
||||
if !on { self.end(); }
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), false, on).map_err(|error| error.to_string())?;
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = {
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
|
||||
std::mem::replace(&mut *handle, next)
|
||||
};
|
||||
drop(previous);
|
||||
log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1);
|
||||
Ok(())
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
Self::open_inner(None, None, false).map_err(|error| error.to_string())
|
||||
Self::open_inner(None, None, false, false).map_err(|error| error.to_string())
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub(crate) fn test_lock_watch(&mut self, locked: tokio::sync::watch::Receiver<Option<bool>>) {
|
||||
@@ -255,7 +300,7 @@ mod native {
|
||||
if !available || self.touch_supported() { return Ok(false); }
|
||||
log::info!("Portal touch consent: asking the host again for the touchscreen");
|
||||
let monitor = self.monitor();
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), true).map_err(|error| error.to_string())?;
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?;
|
||||
// The new consent is saved for whichever monitor was granted, so a later connection uses it.
|
||||
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
|
||||
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
|
||||
@@ -266,7 +311,7 @@ mod native {
|
||||
Ok(true)
|
||||
}
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
|
||||
Self::open_inner(Some(cancelled), None, false)
|
||||
Self::open_inner(Some(cancelled), None, false, false)
|
||||
}
|
||||
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, super::PortalError> {
|
||||
use std::sync::atomic::Ordering;
|
||||
@@ -291,7 +336,10 @@ mod native {
|
||||
};
|
||||
if alive { return Ok(false); }
|
||||
|
||||
let result = super::open_then_install(cancelled, || Self::open_cancellable(cancelled), |replacement| {
|
||||
// The privacy screen's virtual share is reopened as itself, not as the monitor.
|
||||
let virtual_output = self.is_virtual();
|
||||
let monitor = self.monitor();
|
||||
let result = super::open_then_install(cancelled, || Self::open_inner(Some(cancelled), monitor.as_deref(), false, virtual_output), |replacement| {
|
||||
self.check_geometry(&replacement)?;
|
||||
let replacement_handle = replacement.handle.into_inner().map_err(|_| super::PortalError { code: 3 })?;
|
||||
let mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
@@ -401,7 +449,7 @@ mod native {
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
false
|
||||
}) { return Ok(None); }
|
||||
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false) {
|
||||
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false, self.is_virtual()) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
log::warn!("Portal capture recovery deferred: {error}");
|
||||
@@ -525,7 +573,7 @@ mod native {
|
||||
was_locked: std::sync::atomic::AtomicBool::new(false),
|
||||
recovery: Mutex::new(Recovery::default()),
|
||||
size: pack(physical.0, physical.1).into(),
|
||||
monitor: Mutex::new(None),
|
||||
monitor: Mutex::new(None), virtual_output: false.into(),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -792,6 +840,8 @@ impl PortalSession {
|
||||
pub fn monitor(&self) -> Option<String> { None }
|
||||
pub fn end(&self) {}
|
||||
pub fn switch_to(&self, _: &str) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn set_virtual(&self, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn is_virtual(&self) -> bool { false }
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
impl PortalSession {
|
||||
@@ -833,6 +883,13 @@ pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connect
|
||||
pub fn register(session: &Arc<PortalSession>) {
|
||||
*ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session));
|
||||
}
|
||||
/// Privacy screen: see `Session::set_virtual`. Restoring without a live session is a no-op;
|
||||
/// failures switching a live session must reach the controller so its recovery record survives.
|
||||
pub fn set_virtual_active(on: bool) -> Result<(), String> {
|
||||
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade);
|
||||
let Some(session) = session else { return if on { Err("Portal desktop unavailable".into()) } else { Ok(()) }; };
|
||||
session.set_virtual(on)
|
||||
}
|
||||
pub fn switch_active(connector: &str) -> Result<(), String> {
|
||||
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade)
|
||||
.ok_or("Portal desktop unavailable")?;
|
||||
@@ -873,6 +930,11 @@ pub fn write_frames(session: Arc<PortalSession>, mut output: impl std::io::Write
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn privacy_restore_without_a_desktop_is_a_noop_but_enable_fails() {
|
||||
assert!(super::set_virtual_active(false).is_ok());
|
||||
assert_eq!(super::set_virtual_active(true).unwrap_err(), "Portal desktop unavailable");
|
||||
}
|
||||
#[test]
|
||||
fn monitor_lines_parse_and_reject_unsafe_connectors() {
|
||||
let m = super::parse_monitors("eDP-1\t2880\t1800\t0\t0\t1\nHDMI-1\t2560\t1440\t1920\t0\t0\n../x\t1\t1\t0\t0\t0\n");
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
//! One implementation per desktop. The controller (mod.rs) owns sessions, mode switching, the
|
||||
//! recovery record and the guard; a backend only changes and restores its desktop.
|
||||
use super::{record::Journal, Mode};
|
||||
|
||||
/// What the controller keeps while privacy is on.
|
||||
#[derive(Default)]
|
||||
pub struct Entered {
|
||||
/// Picture mode keeps physical outputs on, so uinput's absolute axes span them too: the
|
||||
/// captured (virtual) output as fractions (x, y, w, h) of the layout's bounding box.
|
||||
pub pointer_region: Option<[f64; 4]>,
|
||||
}
|
||||
|
||||
pub trait Backend: Send + Sync {
|
||||
/// Stored in the recovery record to pick the same backend for recovery.
|
||||
fn name(&self) -> &'static str;
|
||||
/// Why `mode` cannot be served on this desktop.
|
||||
fn unavailable(&self, mode: Mode) -> Option<String>;
|
||||
/// Hide the local screen and block local input. Save what undoes each step through `journal`
|
||||
/// before making it; on an error the controller calls `leave` with the last saved data.
|
||||
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String>;
|
||||
/// Undo `data` from `enter`. Also used for crash recovery, where no desktop stream exists.
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String>;
|
||||
}
|
||||
|
||||
/// The backend for this session, if the desktop has one.
|
||||
pub fn detect() -> Option<&'static dyn Backend> {
|
||||
if cfg!(test) { return None; }
|
||||
if super::kde::Kde::detected() { return Some(&super::kde::Kde); }
|
||||
None
|
||||
}
|
||||
pub fn named(name: &str) -> Option<&'static dyn Backend> {
|
||||
match name { super::kde::NAME => Some(&super::kde::Kde), _ => None }
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
//! Picture mode's cover: a fullscreen keep-above window per physical monitor (GTK, in its own
|
||||
//! process so it cannot disturb the host's UI thread), killed on restore and with the host.
|
||||
use std::{process::{Child, Command, Stdio}, sync::Mutex};
|
||||
|
||||
static COVER: Mutex<Option<Child>> = Mutex::new(None);
|
||||
|
||||
pub fn supported() -> bool { cfg!(uu_gtk) }
|
||||
/// `rects` are the monitors to cover in the desktop's logical coordinates (x, y, w, h).
|
||||
pub fn show(image: Option<&std::path::Path>, rects: &[[f64; 4]]) -> Result<(), String> {
|
||||
hide();
|
||||
let exe = std::env::current_exe().map_err(|e| e.kind().to_string())?;
|
||||
let mut command = Command::new(exe);
|
||||
command.arg("privacy-wallpaper").arg(image.map(|p| p.as_os_str().to_owned()).unwrap_or_default());
|
||||
for rect in rects { command.arg(rect.iter().map(|v| (v.round() as i64).to_string()).collect::<Vec<_>>().join(",")); }
|
||||
// Keep the pipe writer in Child for the host's lifetime, independently of its spawning thread.
|
||||
let mut child = command.stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().map_err(|e| format!("cover window: {}", e.kind()))?;
|
||||
// A spawned child is not a shown cover: GTK init or monitor matching can still fail (exit 1/2).
|
||||
let stdout = child.stdout.take().ok_or("cover window: no stdout")?;
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
std::thread::spawn(move || {
|
||||
use std::io::BufRead;
|
||||
let mut line = String::new();
|
||||
let _ = tx.send(std::io::BufReader::new(stdout).read_line(&mut line).is_ok() && line.trim() == "ready");
|
||||
});
|
||||
if rx.recv_timeout(std::time::Duration::from_secs(5)) != Ok(true) {
|
||||
let _ = child.kill();
|
||||
let status = child.wait().ok().and_then(|s| s.code());
|
||||
return Err(format!("cover window not shown (exit {status:?})"));
|
||||
}
|
||||
*COVER.lock().map_err(|_| "cover state poisoned")? = Some(child);
|
||||
Ok(())
|
||||
}
|
||||
pub fn hide() {
|
||||
if let Some(mut child) = COVER.lock().ok().and_then(|mut c| c.take()) { let _ = child.kill(); let _ = child.wait(); }
|
||||
}
|
||||
/// `privacy-wallpaper <image> <x,y,w,h>...`: the cover window process.
|
||||
pub fn main(args: &[String]) -> i32 {
|
||||
let rects: Vec<i32> = args.iter().skip(1).flat_map(|r| r.split(',').map(|v| v.parse().unwrap_or(-1))).collect();
|
||||
#[cfg(uu_gtk)] {
|
||||
extern "C" { fn uu_privacy_wallpaper_run(image: *const libc::c_char, rects: *const i32, count: i32) -> i32; }
|
||||
let image = std::ffi::CString::new(args.first().cloned().unwrap_or_default()).unwrap_or_default();
|
||||
unsafe { uu_privacy_wallpaper_run(image.as_ptr(), rects.as_ptr(), (rects.len() / 4) as i32) }
|
||||
}
|
||||
#[cfg(not(uu_gtk))] { let _ = rects; 1 }
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
//! Desktops may persist what a backend changes (KWin saves input-device flags), so a killed host
|
||||
//! could leave local input or screens off for good. This child recovers from the record when the
|
||||
//! host's end of its stdin pipe closes, however the host ends; after a normal restore the record is
|
||||
//! gone and it just exits.
|
||||
use std::{process::{Child, Command, Stdio}, sync::Mutex};
|
||||
|
||||
static GUARD: Mutex<Option<Child>> = Mutex::new(None);
|
||||
|
||||
pub fn start() -> Result<(), String> {
|
||||
let mut guard = GUARD.lock().map_err(|_| "guard state poisoned")?;
|
||||
if guard.is_some() { return Ok(()); }
|
||||
let exe = std::env::current_exe().map_err(|e| e.kind().to_string())?;
|
||||
let child = Command::new(exe).arg("privacy-guard").stdin(Stdio::piped()).stdout(Stdio::null()).spawn()
|
||||
.map_err(|e| format!("privacy guard: {}", e.kind()))?;
|
||||
*guard = Some(child);
|
||||
Ok(())
|
||||
}
|
||||
pub fn stop() {
|
||||
if let Some(mut child) = GUARD.lock().ok().and_then(|mut g| g.take()) { drop(child.stdin.take()); let _ = child.wait(); }
|
||||
}
|
||||
/// `privacy-guard`: waits for the host to go away, then recovers.
|
||||
pub fn main() -> i32 {
|
||||
use std::io::Read;
|
||||
let _ = std::io::stdin().read_to_end(&mut Vec::new());
|
||||
// A normal restore removes the record before closing the pipe.
|
||||
if !super::record::pending() { return 0; }
|
||||
// The host's flock is released with its last descriptor; give a dying host a moment.
|
||||
super::tool::wait_until(|| super::record::ownership().is_ok());
|
||||
if super::record::pending() { log::warn!("Privacy guard: host ended without restoring; recovering"); super::recover(); }
|
||||
0
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
//! Local input devices through KWin's InputDevice D-Bus interface (sysName `eventN`). KWin saves
|
||||
//! the enabled flag, which is why the controller runs the guard.
|
||||
use super::super::tool::{gdbus, variant};
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
/// Keyboards, pointers and touch to block: everything except our own uinput devices, the power
|
||||
/// button and switches (lid). Software devices fed by local hardware (gesture daemons, ydotoold)
|
||||
/// are blocked too.
|
||||
pub fn local() -> Result<Vec<String>, String> {
|
||||
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
|
||||
let mut blocked = Vec::new();
|
||||
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) {
|
||||
let Ok(text) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) else { continue };
|
||||
let yes = |key| variant(&text, key) == Some("true");
|
||||
let name = variant(&text, "name").unwrap_or_default();
|
||||
if (yes("keyboard") || yes("pointer") || yes("touch")) && !yes("switchDevice") && yes("enabled")
|
||||
&& !name.starts_with("uu-remote-linux") && name != "Power Button" { blocked.push(sys.to_owned()); }
|
||||
}
|
||||
Ok(blocked)
|
||||
}
|
||||
pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
|
||||
let value = if enabled { "<true>" } else { "<false>" };
|
||||
let mut failure = None;
|
||||
for sys in devices {
|
||||
if let Err(e) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.Set", &["org.kde.KWin.InputDevice", "enabled", value]) {
|
||||
failure = Some(e);
|
||||
}
|
||||
}
|
||||
failure.map_or(Ok(()), Err)
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
//! One-shot KWin scripts (org.kde.kwin.Scripting).
|
||||
use super::super::tool::gdbus;
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
fn script(js: &str) -> Result<(), String> {
|
||||
let dir = std::env::var_os("XDG_RUNTIME_DIR").map(std::path::PathBuf::from).ok_or("missing runtime directory")?;
|
||||
let file = dir.join(format!("uu-privacy-{}.js", std::process::id()));
|
||||
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
|
||||
let name = "uu-privacy";
|
||||
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
|
||||
let result = call("/Scripting", "org.kde.kwin.Scripting.loadScript", &[&file.to_string_lossy(), name]).and_then(|out| {
|
||||
let id: String = out.chars().filter(char::is_ascii_digit).collect();
|
||||
if id.is_empty() { return Err("script not loaded".into()); }
|
||||
call(&format!("/Scripting/Script{id}"), "org.kde.kwin.Script.run", &[])
|
||||
});
|
||||
std::thread::sleep(std::time::Duration::from_millis(300));
|
||||
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
|
||||
let _ = std::fs::remove_file(file);
|
||||
result.map(|_| ())
|
||||
}
|
||||
/// Sends every normal window and dialog to `output` (a name from kscreen-doctor, file-name safe).
|
||||
pub fn move_windows_to(output: &str) -> Result<(), String> {
|
||||
script(&format!(r#"const v = workspace.screens.find(o => o.name == "{output}");
|
||||
if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) workspace.sendClientToScreen(w, v);"#))
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
//! KDE Plasma Wayland: capture and input move to a KWin virtual output through the portal
|
||||
//! (ScreenCast source type VIRTUAL), then the physical outputs are disabled with kscreen-doctor,
|
||||
//! so remote input cannot wake them (KWin treats injected input as user activity and undoes DPMS).
|
||||
//! Same order as KRdp's virtual-monitor "replace" policy and Sunshine's KDE setup: snapshot the
|
||||
//! physical outputs before the virtual one exists (KWin applies stored configs on creation),
|
||||
//! re-enable them before the virtual output goes away, and never disable the virtual output
|
||||
//! itself (KWin bug 527747 persists that and breaks later virtual shares).
|
||||
//! Picture mode then turns the physical outputs back on as secondary ones and covers them.
|
||||
mod input;
|
||||
mod kwin;
|
||||
mod outputs;
|
||||
|
||||
use super::{backend::{Backend, Entered}, record::Journal, tool, Mode};
|
||||
|
||||
pub const NAME: &str = "kde";
|
||||
pub struct Kde;
|
||||
|
||||
#[derive(Default, serde::Serialize, serde::Deserialize)]
|
||||
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<String> }
|
||||
|
||||
impl Kde {
|
||||
pub fn detected() -> bool {
|
||||
let kde = std::env::var_os("WAYLAND_DISPLAY").is_some()
|
||||
&& std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().split(':').any(|s| s.eq_ignore_ascii_case("KDE"));
|
||||
cfg!(feature = "portal") && kde && tool::available("timeout") && tool::available("kscreen-doctor")
|
||||
&& crate::desktop_backend::detect().ok() == Some(crate::desktop_backend::DesktopBackend::Portal)
|
||||
}
|
||||
}
|
||||
fn block_input() -> bool { std::env::var("UU_PRIVACY_BLOCK_INPUT").as_deref() != Ok("0") }
|
||||
/// Plasma's desktop wallpaper image, if it is a plain file.
|
||||
fn wallpaper() -> Option<std::path::PathBuf> {
|
||||
let home = std::env::var_os("HOME").map(std::path::PathBuf::from)?;
|
||||
let config = std::env::var_os("XDG_CONFIG_HOME").map(std::path::PathBuf::from).unwrap_or(home.join(".config"));
|
||||
let text = std::fs::read_to_string(config.join("plasma-org.kde.plasma.desktop-appletsrc")).ok()?;
|
||||
text.lines().find_map(|l| l.strip_prefix("Image=")).map(|v| std::path::PathBuf::from(v.trim().trim_start_matches("file://")))
|
||||
.filter(|p| p.is_file())
|
||||
}
|
||||
/// Windows moved to the virtual output when the physical outputs went away. Turn those back on as
|
||||
/// secondary outputs, keep the windows on the virtual one, and cover the physical ones.
|
||||
fn cover(data: &Data) -> Result<[f64; 4], String> {
|
||||
let virtual_name = outputs::layout()?.into_iter().map(|o| o.name).find(|n| !data.outputs.contains(n)).ok_or("virtual output not found")?;
|
||||
outputs::set(&data.outputs, true).map_err(|e| format!("enable outputs: {e}"))?;
|
||||
if let Err(e) = outputs::set_primary(&virtual_name) { log::warn!("Privacy virtual output priority: {e}"); }
|
||||
kwin::move_windows_to(&virtual_name).map_err(|e| format!("move windows: {e}"))?;
|
||||
let layout = outputs::layout()?;
|
||||
let physical: Vec<[f64; 4]> = layout.iter().filter(|o| data.outputs.contains(&o.name)).map(|o| o.rect).collect();
|
||||
if physical.len() != data.outputs.len() { return Err("physical outputs did not come back".into()); }
|
||||
let region = outputs::region(&layout, &virtual_name).ok_or("virtual output geometry")?;
|
||||
super::cover::show(wallpaper().as_deref(), &physical)?;
|
||||
Ok(region)
|
||||
}
|
||||
|
||||
impl Backend for Kde {
|
||||
fn name(&self) -> &'static str { NAME }
|
||||
fn unavailable(&self, mode: Mode) -> Option<String> {
|
||||
if !tool::available("gdbus") { return Some("privacy screen needs gdbus".into()); }
|
||||
// Checked before any output or device changes: on the virtual share KDE drops portal input,
|
||||
// and local devices get blocked, so without uinput neither side could operate.
|
||||
if !crate::input::uinput_ready() { return Some("privacy screen needs uinput input (UU_INPUT_BACKEND=native or /dev/uinput unavailable)".into()); }
|
||||
(mode == Mode::Picture && !super::cover::supported()).then(|| "picture mode needs GTK".into())
|
||||
}
|
||||
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String> {
|
||||
let mut data = Data { outputs: outputs::physical()?, devices: Vec::new() };
|
||||
journal.save(&data)?;
|
||||
crate::portal::set_virtual_active(true).map_err(|e| format!("virtual output: {e}"))?;
|
||||
outputs::set(&data.outputs, false).map_err(|e| format!("disable outputs: {e}"))?;
|
||||
let mut entered = Entered::default();
|
||||
if mode == Mode::Picture { entered.pointer_region = Some(cover(&data)?); }
|
||||
if block_input() {
|
||||
data.devices = input::local().map_err(|e| format!("input devices: {e}"))?;
|
||||
journal.save(&data)?;
|
||||
input::set(&data.devices, false).map_err(|e| format!("block input: {e}"))?;
|
||||
}
|
||||
log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
|
||||
Ok(entered)
|
||||
}
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String> {
|
||||
let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?;
|
||||
// KWin persists the device flag: a failure is returned (after restoring the outputs) so the
|
||||
// controller keeps the recovery record and the guard for the next attempt.
|
||||
let devices = input::set(&data.devices, true).map_err(|e| format!("enable input devices: {e}"));
|
||||
// Physical outputs first: switching back opens a monitor share, which needs them enabled.
|
||||
// The wait also matters: a share opened before KWin applies the mode got the virtual
|
||||
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
|
||||
if let Err(e) = outputs::set(&data.outputs, true) {
|
||||
if !outputs::physical().is_ok_and(|now| data.outputs.iter().all(|o| now.contains(o))) { return Err(format!("enable outputs: {e}")); }
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(500));
|
||||
crate::portal::set_virtual_active(false).map_err(|e| format!("restore capture source: {e}"))?;
|
||||
devices?;
|
||||
log::info!("Privacy KDE restored: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
//! KWin output layout through libkscreen's `kscreen-doctor`.
|
||||
use super::super::tool::{run, wait_until};
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct Output { pub name: String, pub rect: [f64; 4] }
|
||||
|
||||
fn json() -> Result<String, String> { run("kscreen-doctor", &["-j".into()]) }
|
||||
/// Enabled, connected outputs that KWin did not create for a screencast.
|
||||
fn physical_in(text: &str) -> Result<Vec<String>, String> {
|
||||
let json: serde_json::Value = serde_json::from_str(text).map_err(|_| "invalid output configuration")?;
|
||||
let outputs = json["outputs"].as_array().ok_or("missing outputs")?;
|
||||
let names: Vec<String> = outputs.iter()
|
||||
.filter(|o| o["enabled"] == true && o["connected"] == true)
|
||||
.filter_map(|o| o["name"].as_str())
|
||||
.filter(|name| !name.starts_with("Virtual") && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_'))
|
||||
.map(str::to_owned).collect();
|
||||
if names.is_empty() { return Err("no active physical outputs".into()); }
|
||||
Ok(names)
|
||||
}
|
||||
pub fn physical() -> Result<Vec<String>, String> { physical_in(&json()?) }
|
||||
/// Enabled outputs in KWin's logical coordinates (mode size / scale, rotated).
|
||||
fn layout_in(text: &str) -> Result<Vec<Output>, String> {
|
||||
let json: serde_json::Value = serde_json::from_str(text).map_err(|_| "invalid output configuration")?;
|
||||
let outputs = json["outputs"].as_array().ok_or("missing outputs")?;
|
||||
// KWin's screencast virtual output has no "enabled" field (seen live, Plasma 6).
|
||||
Ok(outputs.iter().filter(|o| o["enabled"] != false).filter_map(|o| {
|
||||
let mode = o["modes"].as_array()?.iter().find(|m| m["id"] == o["currentModeId"])?;
|
||||
let (mut w, mut h) = (mode["size"]["width"].as_f64()?, mode["size"]["height"].as_f64()?);
|
||||
if matches!(o["rotation"].as_u64(), Some(2 | 8)) { std::mem::swap(&mut w, &mut h); }
|
||||
let scale = o["scale"].as_f64().filter(|s| *s > 0.0).unwrap_or(1.0);
|
||||
Some(Output { name: o["name"].as_str()?.into(), rect: [o["pos"]["x"].as_f64()?, o["pos"]["y"].as_f64()?, w / scale, h / scale] })
|
||||
}).collect())
|
||||
}
|
||||
pub fn layout() -> Result<Vec<Output>, String> { layout_in(&json()?) }
|
||||
/// `name` as fractions (x, y, w, h) of the layout's bounding box.
|
||||
pub fn region(layout: &[Output], name: &str) -> Option<[f64; 4]> {
|
||||
let target = layout.iter().find(|o| o.name == name)?.rect;
|
||||
let (x0, y0) = layout.iter().fold((f64::MAX, f64::MAX), |(x, y), o| (x.min(o.rect[0]), y.min(o.rect[1])));
|
||||
let (x1, y1) = layout.iter().fold((f64::MIN, f64::MIN), |(x, y), o| (x.max(o.rect[0] + o.rect[2]), y.max(o.rect[1] + o.rect[3])));
|
||||
let (w, h) = (x1 - x0, y1 - y0);
|
||||
(w > 0.0 && h > 0.0).then(|| [(target[0] - x0) / w, (target[1] - y0) / h, target[2] / w, target[3] / h])
|
||||
}
|
||||
/// Enables or disables `outputs` and waits until KWin has applied it.
|
||||
pub fn set(outputs: &[String], enable: bool) -> Result<(), String> {
|
||||
let action = if enable { "enable" } else { "disable" };
|
||||
run("kscreen-doctor", &outputs.iter().map(|o| format!("output.{o}.{action}")).collect::<Vec<_>>())?;
|
||||
let applied = wait_until(|| {
|
||||
let now = physical().unwrap_or_default();
|
||||
outputs.iter().all(|o| now.contains(o) == enable)
|
||||
});
|
||||
if applied { Ok(()) } else { Err(format!("outputs not {action}d")) }
|
||||
}
|
||||
pub fn set_primary(name: &str) -> Result<(), String> { run("kscreen-doctor", &[format!("output.{name}.priority.1")]).map(|_| ()) }
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn snapshot_keeps_enabled_physical_outputs_only() {
|
||||
let names = physical_in(r#"{"outputs":[{"name":"eDP-1","enabled":true,"connected":true},
|
||||
{"name":"DP-1","enabled":false,"connected":true},{"name":"Virtual-uu","enabled":true,"connected":true},
|
||||
{"name":"HDMI-A-1","enabled":true,"connected":false}]}"#).unwrap();
|
||||
assert_eq!(names, ["eDP-1"]);
|
||||
assert!(physical_in(r#"{"outputs":[{"name":"Virtual-x","enabled":true,"connected":true}]}"#).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn pointer_region_is_the_virtual_output_in_the_layout() {
|
||||
let all = layout_in(r#"{"outputs":[
|
||||
{"name":"eDP-1","enabled":true,"currentModeId":"2","modes":[{"id":"2","size":{"width":3072,"height":1920}}],"pos":{"x":0,"y":0},"scale":1.5,"rotation":1},
|
||||
{"name":"Virtual-1","currentModeId":"1","modes":[{"id":"1","size":{"width":1920,"height":1080}}],"pos":{"x":2048,"y":0},"scale":1,"rotation":1},
|
||||
{"name":"DP-1","enabled":false,"currentModeId":"1","modes":[{"id":"1","size":{"width":1,"height":1}}],"pos":{"x":0,"y":0}}]}"#).unwrap();
|
||||
assert_eq!(all.len(), 2);
|
||||
assert_eq!(all[0].rect, [0.0, 0.0, 2048.0, 1280.0]);
|
||||
assert_eq!(region(&all, "Virtual-1").unwrap(), [2048.0 / 3968.0, 0.0, 1920.0 / 3968.0, 1080.0 / 1280.0]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
//! Host privacy screen (防窥): the viewer's RPC 7 hides the local screen and blocks local input
|
||||
//! while it controls the desktop. This module is the desktop-independent controller: it counts
|
||||
//! desktop sessions, switches modes, rolls back failures, keeps the recovery record and the guard,
|
||||
//! and serves the protocol. Desktop work lives behind `backend::Backend` (only `kde` so far).
|
||||
mod backend;
|
||||
mod cover;
|
||||
mod guard;
|
||||
mod kde;
|
||||
mod mode;
|
||||
mod protocol;
|
||||
mod record;
|
||||
mod tool;
|
||||
|
||||
pub use mode::Mode;
|
||||
use std::sync::{atomic::{AtomicBool, Ordering}, Mutex};
|
||||
|
||||
struct Active { mode: Mode, record: Option<record::Record> }
|
||||
struct State { sessions: usize, active: Option<Active> }
|
||||
static STATE: Mutex<State> = Mutex::new(State { sessions: 0, active: None });
|
||||
/// Lock-free view of `STATE.active` for capture/input paths.
|
||||
static ACTIVE: AtomicBool = AtomicBool::new(false);
|
||||
static PICTURE: AtomicBool = AtomicBool::new(false);
|
||||
static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
|
||||
|
||||
pub fn supported() -> bool { backend::detect().is_some() }
|
||||
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
|
||||
/// The viewer's privacy_type now in effect.
|
||||
pub fn current_type() -> u8 {
|
||||
if !active() { mode::TYPE_OFF } else if PICTURE.load(Ordering::Relaxed) { Mode::Picture.wire_type() } else { Mode::ScreenOff.wire_type() }
|
||||
}
|
||||
/// Message 15 SystemStateChange { 5 PrivateScreenState } for the state now in effect.
|
||||
pub fn state_message(seq: u64, timestamp: u64) -> Vec<u8> {
|
||||
crate::initialization::envelope(seq, timestamp, 15, &protocol::state_change(current_type()))
|
||||
}
|
||||
/// See `backend::Entered::pointer_region`.
|
||||
pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? }
|
||||
|
||||
fn publish(active: Option<&Active>) {
|
||||
ACTIVE.store(active.is_some(), Ordering::Relaxed);
|
||||
PICTURE.store(active.is_some_and(|a| a.mode == Mode::Picture), Ordering::Relaxed);
|
||||
}
|
||||
fn leave(state: &mut State) -> Result<(), String> {
|
||||
let Some(active) = state.active.as_ref() else { return Ok(()) };
|
||||
cover::hide();
|
||||
if let Ok(mut p) = POINTER.lock() { *p = None; }
|
||||
if let Some(record) = &active.record {
|
||||
let backend = backend::named(&record.backend).ok_or("unknown privacy backend in the recovery record")?;
|
||||
backend.leave(&record.data)?;
|
||||
}
|
||||
record::remove()?;
|
||||
state.active = None;
|
||||
publish(None);
|
||||
guard::stop();
|
||||
log::info!("Privacy screen restored");
|
||||
Ok(())
|
||||
}
|
||||
fn enter(state: &mut State, mode: Mode) -> Result<(), String> {
|
||||
record::ownership()?;
|
||||
if state.active.as_ref().is_some_and(|a| a.mode == mode) { return Ok(()); }
|
||||
// Switching mode: start over from the restored desktop.
|
||||
leave(state)?;
|
||||
let backend = backend::detect().ok_or("privacy screen is not supported on this desktop")?;
|
||||
if let Some(reason) = backend.unavailable(mode) { return Err(reason); }
|
||||
// A pending recovery must never be overwritten by a new snapshot.
|
||||
if record::pending() { return Err("previous output recovery is pending".into()); }
|
||||
guard::start()?;
|
||||
// Published before the backend runs: capture keep-awake paths must not undo its changes.
|
||||
state.active = Some(Active { mode, record: None });
|
||||
publish(state.active.as_ref());
|
||||
let mut journal = record::Journal::new(backend.name(), mode);
|
||||
let result = backend.enter(mode, &mut journal);
|
||||
if let Some(active) = state.active.as_mut() { active.record = journal.into_record(); }
|
||||
let entered = result?;
|
||||
*POINTER.lock().map_err(|_| "pointer state poisoned")? = entered.pointer_region;
|
||||
log::info!("Privacy screen enabled: backend={} mode={mode:?}", backend.name());
|
||||
Ok(())
|
||||
}
|
||||
fn save_preference(mode: Mode) {
|
||||
// Session lifecycle takes the settings lock before STATE; never take it while holding STATE.
|
||||
if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_type = Some(mode.wire_type())) { log::warn!("Privacy mode not saved: {e}"); }
|
||||
}
|
||||
/// RPC 7: `mode` is None for an unknown privacy_type.
|
||||
fn set(enable: bool, mode: Option<Mode>) -> Result<(), String> {
|
||||
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
|
||||
if !enable { return leave(&mut state); }
|
||||
let mode = mode.ok_or("unsupported privacy type")?;
|
||||
if state.sessions == 0 { return Err("no active desktop session".into()); }
|
||||
let result = enter(&mut state, mode);
|
||||
// A failed rollback keeps the record and the guard: the next request, exit or start retries.
|
||||
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
|
||||
drop(state);
|
||||
if result.is_ok() { save_preference(mode); }
|
||||
result
|
||||
}
|
||||
/// Why RPC 7 cannot be served at all; checked before answering.
|
||||
fn refuse(enable: bool, mode: Option<Mode>) -> Option<String> {
|
||||
if !enable { return None; }
|
||||
let Some(mode) = mode else { return Some("unsupported privacy type".into()) };
|
||||
if STATE.lock().map_or(true, |s| s.sessions == 0) { return Some("no active desktop session".into()); }
|
||||
let Some(backend) = backend::detect() else { return Some("privacy screen is not supported on this desktop".into()) };
|
||||
backend.unavailable(mode)
|
||||
}
|
||||
/// A switch the RPC accepted; run it with `Accepted::apply` after sending the response.
|
||||
pub struct Accepted { enable: bool, mode: Option<Mode> }
|
||||
/// RPC 7 answer, sent before the switch: the Mac viewer gives up on the RPC after a few seconds
|
||||
/// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is
|
||||
/// reported as ReportError -7, which the viewer handles by resetting its privacy menu.
|
||||
pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> {
|
||||
let (header, request) = protocol::parse(rpc)?;
|
||||
if let Some(e) = refuse(request.enable, request.mode) {
|
||||
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
|
||||
return Some((protocol::response(&header, &request, true, current_type()), None));
|
||||
}
|
||||
let expected = if request.enable { request.mode.map_or(mode::TYPE_OFF, Mode::wire_type) } else { mode::TYPE_OFF };
|
||||
Some((protocol::response(&header, &request, false, expected), Some(Accepted { enable: request.enable, mode: request.mode })))
|
||||
}
|
||||
/// Mac 4.43.0 handleForReportError: -7 resets privacy to off; -9 reports an RDP session change,
|
||||
/// not privacy success. Success is carried by RpcResponse 3 and SystemMetrics.setting 7.
|
||||
pub const REPORT_ERROR: i32 = -7;
|
||||
impl Accepted {
|
||||
pub fn apply(self) -> Result<(), String> {
|
||||
let result = set(self.enable, self.mode);
|
||||
if let Err(e) = &result { log::warn!("Privacy request failed: enable={} mode={:?}: {e}", self.enable, self.mode); }
|
||||
result
|
||||
}
|
||||
}
|
||||
pub fn session_started() { if let Ok(mut s) = STATE.lock() { s.sessions += 1; } }
|
||||
pub fn session_ended() {
|
||||
if let Ok(mut s) = STATE.lock() {
|
||||
s.sessions = s.sessions.saturating_sub(1);
|
||||
if s.sessions == 0 { if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } }
|
||||
}
|
||||
}
|
||||
pub fn shutdown() {
|
||||
if let Ok(mut s) = STATE.lock() {
|
||||
s.sessions = 0;
|
||||
if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); }
|
||||
}
|
||||
}
|
||||
/// Undo a record left by a crash (host start, guard). Failure keeps the record for the next try.
|
||||
pub fn recover() {
|
||||
if let Err(e) = record::ownership() { log::warn!("Privacy control unavailable: {e}"); return; }
|
||||
let Some(saved) = record::load() else { return };
|
||||
if let Ok(mut state) = STATE.lock() {
|
||||
state.active = Some(Active { mode: saved.mode, record: Some(saved) });
|
||||
if let Err(e) = leave(&mut state) { log::warn!("Privacy recovery failed: {e}"); }
|
||||
}
|
||||
}
|
||||
/// Local diagnostic: needs an existing portal session (registered by the caller).
|
||||
pub fn probe(mode: Mode) -> Result<(), String> {
|
||||
recover();
|
||||
let result = {
|
||||
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
|
||||
state.sessions = 1;
|
||||
enter(&mut state, mode)
|
||||
};
|
||||
if result.is_ok() { save_preference(mode); }
|
||||
if result.is_ok() { std::thread::sleep(std::time::Duration::from_secs(5)); }
|
||||
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
|
||||
let restored = leave(&mut state);
|
||||
if restored.is_err() { log::warn!("Privacy probe restore failed; the next start retries"); }
|
||||
result.and(restored)
|
||||
}
|
||||
pub use protocol::screensaver_response;
|
||||
pub fn guard_main() -> i32 { guard::main() }
|
||||
pub fn cover_main(args: &[String]) -> i32 { cover::main(args) }
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn enabling_without_a_backend_is_refused_and_reports_off() {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
|
||||
let (response, accepted) = super::rpc_accept(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert_eq!(response, [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
|
||||
assert!(accepted.is_none());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
/// What the viewer asks the local screen to show while it controls the desktop.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum Mode {
|
||||
/// A picture covers the physical screens (the official viewer's privacy/wallpaper mode).
|
||||
Picture,
|
||||
/// The physical screens are off.
|
||||
ScreenOff,
|
||||
}
|
||||
|
||||
/// `privacy_type` as the official viewer numbers it (seen live): 1 off, 2 picture, 3 screen off.
|
||||
pub const TYPE_OFF: u8 = 1;
|
||||
impl Mode {
|
||||
pub fn from_type(value: u64) -> Option<Self> {
|
||||
match value { 2 => Some(Self::Picture), 3 => Some(Self::ScreenOff), _ => None }
|
||||
}
|
||||
pub fn wire_type(self) -> u8 { match self { Self::Picture => 2, Self::ScreenOff => 3 } }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn wire_types_round_trip() {
|
||||
for mode in [Mode::Picture, Mode::ScreenOff] { assert_eq!(Mode::from_type(mode.wire_type().into()), Some(mode)); }
|
||||
assert_eq!(Mode::from_type(1), None);
|
||||
assert_eq!(Mode::from_type(0), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
//! Official protobuf maps: RpcRequest 7 {1 enable, 2 privacy_type, 3 setting_source};
|
||||
//! RpcResponse 3 {1 error_code, 2 req_privacy_type, 3 cur_privacy_type}. Types: see `Mode`.
|
||||
//! Field numbers and enums verified against the Mac UURemote SwiftProtobuf name maps.
|
||||
use super::Mode;
|
||||
|
||||
pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 }
|
||||
|
||||
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
|
||||
use crate::protocol::{decode_wire, WireValue};
|
||||
let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None });
|
||||
let header = body(1)?.to_vec();
|
||||
let req = decode_wire(body(7)?).ok()?;
|
||||
let value = |n| req.iter().find_map(|f| match f.value { WireValue::Varint(v) if f.number == n => Some(v), _ => None }).unwrap_or(0);
|
||||
log::info!("Privacy request: enable_value={} requested_type={} source={}", value(1), value(2), value(3));
|
||||
Some((header, Request { enable: value(1) != 0, mode: Mode::from_type(value(2)), requested: value(2) }))
|
||||
}
|
||||
|
||||
/// RpcResponse with the request's header, error_code 1 on failure, and the type now in effect.
|
||||
pub fn response(header: &[u8], request: &Request, failed: bool, current: u8) -> Vec<u8> {
|
||||
let mut payload = Vec::new();
|
||||
if failed { payload.extend([8, 1]); }
|
||||
if request.requested != 0 { payload.push(16); varint(request.requested, &mut payload); }
|
||||
payload.extend([24, current]);
|
||||
let mut out = vec![10];
|
||||
varint(header.len() as u64, &mut out);
|
||||
out.extend(header);
|
||||
out.push(26);
|
||||
varint(payload.len() as u64, &mut out);
|
||||
out.extend(payload);
|
||||
out
|
||||
}
|
||||
/// RpcRequest 25 update_screen_saver_req → RpcResponse 21 update_screen_saver_rsp (Mac UURemote
|
||||
/// name maps). The viewer sends it before enabling picture mode (notifyScreensaverUpdate) and aborts
|
||||
/// with error 9998 when it times out. The picture itself is the host's: answer an empty (success) one.
|
||||
pub fn screensaver_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
|
||||
use crate::protocol::WireValue;
|
||||
if !rpc.iter().any(|f| f.number == 25) { return None; }
|
||||
let header = rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == 1 => Some(*b), _ => None })?;
|
||||
let mut out = vec![10];
|
||||
varint(header.len() as u64, &mut out);
|
||||
out.extend(header);
|
||||
out.extend([0xaa, 1, 0]); // field 21, length-delimited, empty
|
||||
log::info!("Privacy screensaver update answered");
|
||||
Some(out)
|
||||
}
|
||||
/// SystemStateChange { 5 PrivateScreenState { 1 error_code, 2 req_privacy_type, 3 cur_privacy_type } }
|
||||
/// (field numbers from the Mac UURemote name map); the host pushes it when the state changes.
|
||||
pub fn state_change(current: u8) -> Vec<u8> {
|
||||
let state = [16, current, 24, current];
|
||||
let mut out = vec![42, state.len() as u8];
|
||||
out.extend(state);
|
||||
out
|
||||
}
|
||||
fn varint(mut n: u64, out: &mut Vec<u8>) {
|
||||
while n >= 128 { out.push((n as u8 & 127) | 128); n >>= 7; }
|
||||
out.push(n as u8);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parses_request_and_echoes_header() {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
|
||||
let (header, request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert!(request.enable);
|
||||
assert_eq!(request.mode, Some(Mode::ScreenOff));
|
||||
assert_eq!(response(&header, &request, true, 1), [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
|
||||
assert_eq!(response(&header, &request, false, 3), [10, 2, 8, 42, 26, 4, 16, 3, 24, 3]);
|
||||
assert_eq!(state_change(2), [42, 4, 16, 2, 24, 2]);
|
||||
let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap();
|
||||
assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
//! Recovery record beside the config (`privacy-power.json`, 0600) and the process lock.
|
||||
use super::Mode;
|
||||
|
||||
/// What a backend changed, so the guard or the next start can undo it after a crash.
|
||||
/// `data` belongs to the backend named in `backend`.
|
||||
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
|
||||
pub struct Record { pub backend: String, pub mode: Mode, pub data: serde_json::Value }
|
||||
|
||||
pub fn path() -> std::path::PathBuf { crate::config::path().with_file_name("privacy-power.json") }
|
||||
pub fn pending() -> bool { path().exists() }
|
||||
|
||||
/// One process controls the outputs of a config directory (host, probe, guard). Only success is
|
||||
/// kept: a lock still held by a dying host must be retried (the guard polls this).
|
||||
pub fn ownership() -> Result<(), String> {
|
||||
use std::os::{fd::AsRawFd, unix::fs::OpenOptionsExt};
|
||||
static LOCK: std::sync::Mutex<Option<std::fs::File>> = std::sync::Mutex::new(None);
|
||||
let mut held = LOCK.lock().map_err(|_| "privacy lock state poisoned")?;
|
||||
if held.is_some() { return Ok(()); }
|
||||
let path = path().with_extension("lock");
|
||||
std::fs::create_dir_all(path.parent().ok_or("missing config directory")?).map_err(|e| e.kind().to_string())?;
|
||||
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).mode(0o600)
|
||||
.open(path).map_err(|e| e.kind().to_string())?;
|
||||
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
|
||||
return Err("output control is owned by another process".into());
|
||||
}
|
||||
*held = Some(file);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn load() -> Option<Record> { serde_json::from_slice(&std::fs::read(path()).ok()?).ok() }
|
||||
fn store(record: &Record) -> Result<(), String> {
|
||||
use std::{io::Write, os::unix::fs::OpenOptionsExt};
|
||||
let path = path();
|
||||
std::fs::create_dir_all(path.parent().ok_or("missing config directory")?).map_err(|e| e.kind().to_string())?;
|
||||
let tmp = path.with_extension("tmp");
|
||||
let mut file = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600)
|
||||
.open(&tmp).map_err(|e| e.kind().to_string())?;
|
||||
file.write_all(&serde_json::to_vec(record).map_err(|_| "invalid saved state")?).map_err(|e| e.kind().to_string())?;
|
||||
file.sync_all().map_err(|e| e.kind().to_string())?;
|
||||
std::fs::rename(tmp, path).map_err(|e| e.kind().to_string())
|
||||
}
|
||||
pub fn remove() -> Result<(), String> {
|
||||
std::fs::remove_file(path()).or_else(|e| if e.kind() == std::io::ErrorKind::NotFound { Ok(()) } else { Err(e) })
|
||||
.map_err(|e| format!("remove recovery record: {}", e.kind()))
|
||||
}
|
||||
|
||||
/// Handed to `Backend::enter`: save what undoes a step before making it.
|
||||
pub struct Journal { record: Record, saved: bool }
|
||||
impl Journal {
|
||||
pub fn new(backend: &str, mode: Mode) -> Self {
|
||||
Self { record: Record { backend: backend.into(), mode, data: serde_json::Value::Null }, saved: false }
|
||||
}
|
||||
pub fn save<T: serde::Serialize>(&mut self, data: &T) -> Result<(), String> {
|
||||
self.record.data = serde_json::to_value(data).map_err(|_| "invalid saved state")?;
|
||||
store(&self.record)?;
|
||||
self.saved = true;
|
||||
Ok(())
|
||||
}
|
||||
/// The last saved record; None when the backend changed nothing.
|
||||
pub fn into_record(self) -> Option<Record> { self.saved.then_some(self.record) }
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
//! External desktop tools shared by the backends.
|
||||
use std::process::{Command, Stdio};
|
||||
|
||||
// timeout bounds desktop tools even when their compositor/D-Bus service stops responding.
|
||||
pub fn run(tool: &str, args: &[String]) -> Result<String, String> {
|
||||
let out = Command::new("timeout").args(["--kill-after=1", "5", tool]).args(args)
|
||||
.env("LC_ALL", "C").stdin(Stdio::null()).stderr(Stdio::null()).output()
|
||||
.map_err(|e| format!("{tool} unavailable: {}", e.kind()))?;
|
||||
if !out.status.success() { return Err(format!("{tool} failed: {}", out.status)); }
|
||||
String::from_utf8(out.stdout).map_err(|_| "invalid display tool output".into())
|
||||
}
|
||||
pub fn available(tool: &str) -> bool {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
std::env::var_os("PATH").is_some_and(|paths| std::env::split_paths(&paths).any(|p|
|
||||
p.join(tool).metadata().is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)))
|
||||
}
|
||||
/// One session-bus method call through gdbus; returns its GVariant text.
|
||||
pub fn gdbus(destination: &str, object: &str, method: &str, args: &[&str]) -> Result<String, String> {
|
||||
let mut all: Vec<String> = ["call", "--session", "-d", destination, "-o", object, "-m", method].map(String::from).into();
|
||||
all.extend(args.iter().map(|a| a.to_string()));
|
||||
run("gdbus", &all)
|
||||
}
|
||||
/// `'key': <value>` from gdbus's text for an a{sv} (strings unquoted).
|
||||
pub fn variant<'a>(text: &'a str, key: &str) -> Option<&'a str> {
|
||||
let start = text.find(&format!("'{key}': <"))? + key.len() + 5;
|
||||
let rest = &text[start..];
|
||||
if let Some(quoted) = rest.strip_prefix('\'') { return quoted.split('\'').next(); }
|
||||
rest.split('>').next()
|
||||
}
|
||||
/// Polls `done` for up to three seconds: desktop tools return before the compositor applies a change.
|
||||
pub fn wait_until(mut done: impl FnMut() -> bool) -> bool {
|
||||
for _ in 0..30 {
|
||||
if done() { return true; }
|
||||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn reads_properties_from_gdbus_text() {
|
||||
let text = "({'alphaNumericKeyboard': <true>, 'enabled': <true>, 'name': <'AT Translated Set 2 keyboard'>, 'pointer': <false>},)";
|
||||
assert_eq!(variant(text, "name"), Some("AT Translated Set 2 keyboard"));
|
||||
assert_eq!(variant(text, "enabled"), Some("true"));
|
||||
assert_eq!(variant(text, "pointer"), Some("false"));
|
||||
assert_eq!(variant(text, "touch"), None);
|
||||
}
|
||||
}
|
||||
@@ -36,6 +36,8 @@ pub(crate) struct Settings {
|
||||
/// video field cannot drop auto_lock / mute when the document is loaded.
|
||||
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_encoder: Option<String>,
|
||||
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option<String>,
|
||||
/// Last privacy_type the viewer enabled (2 picture, 3 screen off), not the current live state.
|
||||
#[serde(default)] pub(crate) privacy_type: Option<u8>,
|
||||
}
|
||||
|
||||
fn lenient_string<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
|
||||
@@ -260,6 +262,7 @@ impl PeerActions {
|
||||
if self.started.swap(true, Ordering::Relaxed) { return; }
|
||||
let mut state = state().lock().unwrap();
|
||||
state.desktop_sessions += 1;
|
||||
crate::privacy_screen::session_started();
|
||||
if state.desktop_sessions == 1 && state.settings.keep_mute {
|
||||
mute_for_session(&mut state);
|
||||
log::info!("Host muted for remote session (静音运行)");
|
||||
@@ -272,6 +275,7 @@ impl PeerActions {
|
||||
if !self.started.swap(false, Ordering::Relaxed) { return; }
|
||||
let mut state = state().lock().unwrap();
|
||||
state.desktop_sessions = state.desktop_sessions.saturating_sub(1);
|
||||
crate::privacy_screen::session_ended();
|
||||
if state.desktop_sessions > 0 { return; }
|
||||
crate::virtual_audio::disable();
|
||||
if !state.settings.mute_permanent { restore_mute(&mut state); }
|
||||
@@ -287,6 +291,7 @@ impl PeerActions {
|
||||
let current = state().lock().unwrap().settings.clone();
|
||||
payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings {
|
||||
sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock,
|
||||
private_screen: crate::privacy_screen::supported().then(crate::privacy_screen::current_type),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+36
-12
@@ -27,10 +27,15 @@ pub fn payload_with_location(capture: Permission, operation: Permission, control
|
||||
/// Optional host settings the viewer shows in 声音 / 安全 (SettingMetric 1 keep_mute,
|
||||
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support).
|
||||
#[derive(Debug, Default, Clone, Copy)]
|
||||
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool }
|
||||
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option<u8> }
|
||||
|
||||
pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec<u8> {
|
||||
let mut setting = Vec::new();
|
||||
// Mac 4.43.0 callBackSystemMetrics reads field 7 first, falling back to field 4 only when 7=0.
|
||||
// Report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference.
|
||||
if let Some(kind) = settings.private_screen {
|
||||
setting.extend([4 << 3, u8::from(kind != 1), 7 << 3, kind]);
|
||||
}
|
||||
for (field, on) in [(1u8, settings.keep_mute), (2, settings.mute_permanent), (3, settings.auto_lock)] {
|
||||
if on { setting.push(field << 3); setting.push(1); }
|
||||
}
|
||||
@@ -47,7 +52,13 @@ pub fn payload_with_settings(capture: Permission, operation: Permission, control
|
||||
}
|
||||
// SystemMetrics.general: system_sound_support = SS_SUPPORT (2) when desktop audio is streamed
|
||||
// (GvPb_SystemSoundSupport: 0 unknown, 1 nonsupport, 2 support).
|
||||
let mut out = if settings.sound { vec![26, 2, 16, 2] } else { vec![26, 0] };
|
||||
// Official Mac host 4.43.0 (626), arm64: SystemMetricsHandler (0x10000a96c)
|
||||
// appends GENERAL=1 (0x10000abe8) and SETTING=2 (helper 0x10000a230, write
|
||||
// 0x10000a64c) as it fills those sections; traverse (0x100423840) packs field 1.
|
||||
// We always report both sections. The Mac viewer ignores an empty list
|
||||
// (callBackSystemMetrics, 0x1003b4584). Host evidence: docs/privacy-screen.md.
|
||||
let mut out = vec![10, 2, 1, 2];
|
||||
out.extend(if settings.sound { &[26, 2, 16, 2][..] } else { &[26, 0][..] });
|
||||
// No support_touch, sound capability, win_os_ver, private-screen, virtual
|
||||
// mouse, auto-lock, file path or optional feature claims are fabricated.
|
||||
out.push(34); // SystemMetrics.setting field 4
|
||||
@@ -81,27 +92,29 @@ mod tests {
|
||||
fn measured_allow_capabilities_use_official_enum_values() {
|
||||
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
assert_eq!(fields.len(), 2);
|
||||
assert_eq!(fields[0].number, 3);
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[]));
|
||||
let WireValue::Bytes(setting) = fields[1].value else { panic!("setting not a message") };
|
||||
assert_eq!(fields[1].number, 4);
|
||||
assert_eq!(fields.len(), 3);
|
||||
assert_eq!(fields[0].number, 1);
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2]));
|
||||
assert_eq!(fields[1].number, 3);
|
||||
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
|
||||
let WireValue::Bytes(setting) = fields[2].value else { panic!("setting not a message") };
|
||||
assert_eq!(fields[2].number, 4);
|
||||
let s = decode_wire(setting).unwrap();
|
||||
assert_eq!(s.iter().map(|f| f.number).collect::<Vec<_>>(), vec![8, 9, 10]);
|
||||
assert!(s.iter().all(|f| f.value == WireValue::Varint(2)));
|
||||
}
|
||||
#[test]
|
||||
fn rejected_and_unknown_observations_are_not_promoted_to_allow() {
|
||||
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![26, 0, 34, 0]);
|
||||
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
|
||||
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![10, 2, 1, 2, 26, 0, 34, 0]);
|
||||
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![10, 2, 1, 2, 26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
|
||||
}
|
||||
#[test]
|
||||
fn emits_no_audio_touch_windows_or_auto_unlock_capability() {
|
||||
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
let WireValue::Bytes(general) = fields[0].value else { panic!() };
|
||||
let WireValue::Bytes(general) = fields[1].value else { panic!() };
|
||||
assert!(general.is_empty());
|
||||
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
|
||||
let WireValue::Bytes(setting) = fields[2].value else { panic!() };
|
||||
assert!(decode_wire(setting).unwrap().iter().all(|f| (8..=10).contains(&f.number)));
|
||||
}
|
||||
#[test]
|
||||
@@ -109,10 +122,21 @@ mod tests {
|
||||
let home = "/home/user/".repeat(12);
|
||||
let p = payload_with_location(Permission::Allow, Permission::Allow, Permission::Allow, &home);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
|
||||
let WireValue::Bytes(setting) = fields[2].value else { panic!() };
|
||||
let s = decode_wire(setting).unwrap();
|
||||
assert_eq!(s[0].number, 5);
|
||||
assert_eq!(s[0].value, WireValue::Bytes(home.as_bytes()));
|
||||
assert_eq!(decode_wire(&remote_download_path("/home/x")).unwrap()[0].value, WireValue::Bytes(b"/home/x"));
|
||||
}
|
||||
#[test]
|
||||
fn privacy_modes_report_matching_flag_and_current_type() {
|
||||
for (kind, expected) in [(1, [32, 0, 56, 1]), (2, [32, 1, 56, 2]), (3, [32, 1, 56, 3])] {
|
||||
let settings = Settings { private_screen: Some(kind), ..Settings::default() };
|
||||
let p = payload_with_settings(Permission::Unknown, Permission::Unknown, Permission::Unknown, "", &settings);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
assert_eq!(fields[0].number, 1);
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2]));
|
||||
assert_eq!(fields.iter().find(|f| f.number == 4).unwrap().value, WireValue::Bytes(&expected));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
//! Per-peer TEXT backlog: one current metrics snapshot and bounded ordered replies.
|
||||
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
|
||||
use tokio::sync::{mpsc, watch};
|
||||
|
||||
const REPLY_CAPACITY: usize = 64;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(super) struct Sender {
|
||||
replies: mpsc::Sender<Vec<u8>>,
|
||||
metrics: watch::Sender<Option<Vec<u8>>>,
|
||||
overflow_reported: Arc<AtomicBool>,
|
||||
}
|
||||
pub(super) struct Receiver {
|
||||
replies: mpsc::Receiver<Vec<u8>>,
|
||||
metrics: watch::Receiver<Option<Vec<u8>>>,
|
||||
metrics_open: bool,
|
||||
replies_open: bool,
|
||||
}
|
||||
pub(super) fn channel() -> (Sender, Receiver) {
|
||||
let (replies, rx) = mpsc::channel(REPLY_CAPACITY);
|
||||
let (metrics, latest) = watch::channel(None);
|
||||
(Sender { replies, metrics, overflow_reported: Arc::new(AtomicBool::new(false)) },
|
||||
Receiver { replies: rx, metrics: latest, metrics_open: true, replies_open: true })
|
||||
}
|
||||
impl Sender {
|
||||
pub(super) fn send(&self, message: Vec<u8>) -> Result<(), mpsc::error::SendError<Vec<u8>>> {
|
||||
self.replies.try_send(message).map_err(|error| {
|
||||
// Never wait for TEXT inside CONTROL's request handler: some viewers never open it.
|
||||
if matches!(error, mpsc::error::TrySendError::Full(_))
|
||||
&& !self.overflow_reported.swap(true, Ordering::Relaxed) {
|
||||
log::warn!("TEXT reply queue full; dropping excess replies");
|
||||
}
|
||||
mpsc::error::SendError(error.into_inner())
|
||||
})
|
||||
}
|
||||
pub(super) fn metrics(&self, message: Vec<u8>) {
|
||||
let _ = self.metrics.send(Some(message));
|
||||
}
|
||||
}
|
||||
impl Receiver {
|
||||
pub(super) async fn recv(&mut self) -> Option<Vec<u8>> {
|
||||
loop {
|
||||
if !self.metrics_open && !self.replies_open { return None; }
|
||||
tokio::select! {
|
||||
changed = self.metrics.changed(), if self.metrics_open => {
|
||||
if changed.is_err() { self.metrics_open = false; continue; }
|
||||
if let Some(message) = self.metrics.borrow_and_update().clone() { return Some(message); }
|
||||
}
|
||||
message = self.replies.recv(), if self.replies_open => match message {
|
||||
Some(message) => return Some(message),
|
||||
None => self.replies_open = false,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn unopened_text_keeps_latest_metrics_and_bounded_fifo_replies() {
|
||||
let (tx, mut rx) = channel();
|
||||
for i in 0..10_000u32 { tx.metrics(i.to_le_bytes().to_vec()); }
|
||||
for i in 0..REPLY_CAPACITY { tx.send(vec![i as u8]).unwrap(); }
|
||||
assert_eq!(tx.send(vec![255]).unwrap_err().0, vec![255]);
|
||||
let mut replies = Vec::new();
|
||||
let mut metrics = Vec::new();
|
||||
for _ in 0..REPLY_CAPACITY + 1 {
|
||||
let message = rx.recv().await.unwrap();
|
||||
if message.len() == 4 { metrics.push(message); } else { replies.push(message[0]); }
|
||||
}
|
||||
assert_eq!(metrics, vec![9_999u32.to_le_bytes().to_vec()]);
|
||||
assert_eq!(replies, (0..REPLY_CAPACITY as u8).collect::<Vec<_>>());
|
||||
assert!(tokio::time::timeout(std::time::Duration::from_millis(20), rx.recv()).await.is_err());
|
||||
tx.send(vec![100]).unwrap();
|
||||
assert_eq!(rx.recv().await, Some(vec![100]));
|
||||
drop(tx);
|
||||
assert_eq!(rx.recv().await, None);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn closed_text_rejects_replies() {
|
||||
let (tx, rx) = channel();
|
||||
tx.metrics(vec![13]);
|
||||
tx.send(vec![22]).unwrap();
|
||||
drop(rx);
|
||||
assert!(tx.send(vec![23]).is_err());
|
||||
tx.metrics(vec![14]);
|
||||
}
|
||||
}
|
||||
+15
-1
@@ -1201,6 +1201,8 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
|
||||
}
|
||||
};
|
||||
let mut reader = EncoderTask(tokio::spawn(open(size, live_selection, current)));
|
||||
// The privacy screen swaps the portal stream to a virtual output that can have another size.
|
||||
let mut portal_size = portal.as_ref().map(|p| p.size());
|
||||
let mut previous = None;
|
||||
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
|
||||
let mut settings_open = true;
|
||||
@@ -1302,7 +1304,19 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
|
||||
}
|
||||
return result;
|
||||
},
|
||||
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
|
||||
_ = health.tick() => {
|
||||
if transport_closed(&pc) { return Ok(()); }
|
||||
let now = portal.as_ref().map(|p| p.size());
|
||||
if now != portal_size {
|
||||
log::info!("Portal stream size changed; restarting capture");
|
||||
portal_size = now;
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
while receiver.try_recv().is_ok() {}
|
||||
idr.store(true, std::sync::atomic::Ordering::Relaxed);
|
||||
reader.0 = tokio::spawn(open(size, live_selection, current));
|
||||
}
|
||||
},
|
||||
changed = settings.changed(), if settings_open => {
|
||||
if changed.is_err() { settings_open = false; }
|
||||
continue;
|
||||
|
||||
@@ -19,6 +19,9 @@ impl Window {
|
||||
let name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
|
||||
let window=video.window(&format!("{name} · {}",crate::i18n::s("UU 远程 Linux 控制端","UU Remote Linux viewer")),1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
|
||||
let mut canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
|
||||
// This window forwards scancodes, not SDL_TEXTINPUT. SDL enables text input by
|
||||
// default; its X11 IME path can consume keys before KeyDown/KeyUp (#149).
|
||||
video.text_input().stop();
|
||||
// Wayland maps a toplevel only after its first buffer; without this the window stays
|
||||
// invisible until the first decoded frame, which a stalled stream never delivers.
|
||||
canvas.set_draw_color(LOADING_BG);canvas.clear();canvas.present();
|
||||
@@ -708,6 +711,33 @@ async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Wi
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
#[cfg_attr(target_os="macos",ignore)]
|
||||
#[test] fn remote_window_disables_local_text_input_and_forwards_shift(){
|
||||
if std::env::var_os("UU_VIEWER_IME_TEST_CHILD").is_none(){
|
||||
let output=std::process::Command::new(std::env::current_exe().unwrap())
|
||||
.args(["--exact","viewer::sdl::tests::remote_window_disables_local_text_input_and_forwards_shift","--test-threads=1"])
|
||||
.env("SDL_VIDEODRIVER","dummy").env("UU_VIEWER_IME_TEST_CHILD","1").output().unwrap();
|
||||
assert!(output.status.success(),"{}{}",String::from_utf8_lossy(&output.stdout),String::from_utf8_lossy(&output.stderr));return
|
||||
}
|
||||
let mut window=Window::new().unwrap();
|
||||
assert!(!window.canvas.window().subsystem().text_input().is_active());
|
||||
let id=window.canvas.window().id();
|
||||
let key=|down,scan|if down {
|
||||
Event::KeyDown{timestamp:0,window_id:id,keycode:None,scancode:Some(scan),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false}
|
||||
}else{
|
||||
Event::KeyUp{timestamp:0,window_id:id,keycode:None,scancode:Some(scan),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false}
|
||||
};
|
||||
let push=|event|window._sdl.event().unwrap().push_event(event).unwrap();
|
||||
use sdl2::keyboard::Scancode as S;
|
||||
for event in [key(true,S::LShift),key(false,S::LShift),key(true,S::A),key(false,S::A),
|
||||
key(true,S::RShift),Event::Window{timestamp:0,window_id:id,win_event:WindowEvent::FocusLost},
|
||||
Event::Window{timestamp:0,window_id:id,win_event:WindowEvent::FocusGained}] {push(event);}
|
||||
let (_,messages)=window.poll(&mut Input::new(false));
|
||||
let keys:Vec<_>=messages.iter().filter_map(|m|Some((m.get("action")?.as_str()?,m.get("key")?.as_i64()?))).collect();
|
||||
assert_eq!(keys,vec![("kbd_press",0xa0),("kbd_release",0xa0),("kbd_press",0x41),("kbd_release",0x41),
|
||||
("kbd_press",0xa1),("kbd_release",0xa1)]);
|
||||
assert!(!window.canvas.window().subsystem().text_input().is_active());
|
||||
}
|
||||
// macOS: SDL video must start on the main thread, which the test harness does not use; CI runs it on Linux.
|
||||
#[cfg_attr(target_os="macos",ignore)]
|
||||
#[tokio::test] async fn clipboard_requests_use_existing_window(){
|
||||
|
||||
@@ -0,0 +1,427 @@
|
||||
//! Official device-card background reporting. Protocol evidence: docs/wallpaper-protocol.md.
|
||||
use std::{path::PathBuf, sync::Arc, time::Duration};
|
||||
use sha2::{Digest, Sha256};
|
||||
use tokio::io::AsyncReadExt;
|
||||
use crate::auth::UUAuthClient;
|
||||
|
||||
const LIMIT: usize = 10 * 1024 * 1024;
|
||||
const TIMEOUT: Duration = Duration::from_secs(20);
|
||||
|
||||
pub fn start(auth: Arc<UUAuthClient>) -> tokio::task::AbortHandle {
|
||||
tokio::spawn(async move {
|
||||
if auth.creds.user_id.is_empty() || crate::desktop_backend::headless()
|
||||
|| std::env::var("UU_WALLPAPER_UPLOAD").as_deref() == Ok("0") { return; }
|
||||
let mut previous = None;
|
||||
loop {
|
||||
if let Some(path) = source().await {
|
||||
match read_image(&path).await {
|
||||
Ok(image) => {
|
||||
let hash = Sha256::digest(&image).to_vec();
|
||||
if previous.as_ref() != Some(&hash) {
|
||||
match publish(&auth, image).await {
|
||||
Ok(()) => { previous = Some(hash); log::info!("Device wallpaper synchronized"); }
|
||||
Err(stage) => log::warn!("Device wallpaper synchronization failed: stage={stage}; will retry"),
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(()) => log::debug!("Device wallpaper unavailable or unsupported"),
|
||||
}
|
||||
}
|
||||
tokio::time::sleep(Duration::from_secs(60)).await;
|
||||
}
|
||||
}).abort_handle()
|
||||
}
|
||||
|
||||
async fn command(program: &str, args: &[&str]) -> Option<String> {
|
||||
let output = tokio::time::timeout(Duration::from_secs(3), tokio::process::Command::new(program)
|
||||
.args(args).kill_on_drop(true).output()).await.ok()?.ok()?;
|
||||
output.status.success().then(|| String::from_utf8(output.stdout).ok()).flatten()
|
||||
}
|
||||
|
||||
async fn kde_config(programs: &[&str], args: &[&str]) -> Option<String> {
|
||||
for program in programs {
|
||||
if let Some(value) = command(program, args).await { return Some(value); }
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
async fn source() -> Option<PathBuf> {
|
||||
if let Some(path) = std::env::var_os("UU_WALLPAPER") {
|
||||
let path = PathBuf::from(path); return path.is_absolute().then_some(path);
|
||||
}
|
||||
let desktop = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().to_lowercase();
|
||||
if desktop.contains("gnome") || desktop.contains("unity") || desktop.contains("cinnamon") {
|
||||
let schema = if desktop.contains("cinnamon") { "org.cinnamon.desktop.background" } else { "org.gnome.desktop.background" };
|
||||
if schema == "org.gnome.desktop.background" && command("gsettings", &["get", "org.gnome.desktop.interface", "color-scheme"])
|
||||
.await.is_some_and(|v| v.contains("prefer-dark")) {
|
||||
if let Some(path) = command("gsettings", &["get", schema, "picture-uri-dark"]).await.and_then(|v| gsettings_path(&v)) { return Some(path); }
|
||||
}
|
||||
return command("gsettings", &["get", schema, "picture-uri"]).await.and_then(|v| gsettings_path(&v));
|
||||
}
|
||||
if desktop.contains("kde") {
|
||||
let config = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
|
||||
.filter(|p| p.is_absolute()).or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))?;
|
||||
let text = tokio::fs::read_to_string(config.join("plasma-org.kde.plasma.desktop-appletsrc")).await.unwrap_or_default();
|
||||
if let Some(path) = kde_image(&text) { return package_image(path).await; }
|
||||
// Plasma omits Image for the look-and-feel's default wallpaper.
|
||||
if !kde_default_allowed(&text) { return None; }
|
||||
let readers = ["kreadconfig6", "kreadconfig5"];
|
||||
let theme = kde_config(&readers, &["--file", "kdeglobals", "--group", "KDE", "--key", "LookAndFeelPackage"])
|
||||
.await.unwrap_or_default();
|
||||
let theme = if theme.trim().is_empty() { "org.kde.breeze.desktop" } else { theme.trim() };
|
||||
if theme.contains('/') || theme.contains("..") { return None; }
|
||||
let defaults = format!("/usr/share/plasma/look-and-feel/{theme}/contents/defaults");
|
||||
let image = kde_config(&readers, &["--file", &defaults, "--group", "Wallpaper", "--key", "Image"]).await?;
|
||||
let image = image.trim();
|
||||
if image.is_empty() || image.contains('/') || image.contains("..") { return None; }
|
||||
return package_image(PathBuf::from("/usr/share/wallpapers").join(image)).await;
|
||||
}
|
||||
if desktop.contains("xfce") {
|
||||
let text = command("xfconf-query", &["-c", "xfce4-desktop", "-lv"]).await?;
|
||||
for line in text.lines() {
|
||||
if let Some((key, value)) = line.trim().split_once(char::is_whitespace) {
|
||||
if key.ends_with("/last-image") { if let Some(path) = local_path(value) { return Some(path); } }
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
async fn package_image(path: PathBuf) -> Option<PathBuf> {
|
||||
if tokio::fs::metadata(&path).await.ok()?.is_file() { return Some(path); }
|
||||
let mut entries = tokio::fs::read_dir(path.join("contents/images")).await.ok()?;
|
||||
let mut candidates = Vec::new();
|
||||
while let Some(entry) = entries.next_entry().await.ok()? {
|
||||
if !tokio::fs::metadata(entry.path()).await.is_ok_and(|meta| meta.is_file()) { continue; }
|
||||
let path = entry.path();
|
||||
let Some((w,h)) = path.file_stem().and_then(|s| s.to_str()).and_then(|s| s.split_once('x'))
|
||||
.and_then(|(w,h)| Some((w.parse::<u32>().ok()?,h.parse::<u32>().ok()?))) else { continue; };
|
||||
candidates.push(((w < h, u64::from(w) * u64::from(h)), path));
|
||||
}
|
||||
candidates.sort_by_key(|(score, _)| *score);
|
||||
candidates.into_iter().next().map(|(_, path)| path)
|
||||
}
|
||||
|
||||
fn kde_image(text: &str) -> Option<PathBuf> {
|
||||
let plugins = kde_plugins(text);
|
||||
let mut image_section = false;
|
||||
for line in text.lines().map(str::trim) {
|
||||
if line.starts_with('[') {
|
||||
image_section = line.strip_prefix("[Containments][").and_then(|s| s.split_once(']'))
|
||||
.is_some_and(|(id, section)| section == "[Wallpaper][org.kde.image][General]"
|
||||
&& plugins.get(id).map_or(true, |plugin| *plugin == KdeWallpaper::Image));
|
||||
}
|
||||
if image_section { if let Some(value) = line.strip_prefix("Image=") { if let Some(path) = local_path(value) { return Some(path); } } }
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum KdeWallpaper { Image, Unsupported }
|
||||
|
||||
fn kde_plugins(text: &str) -> std::collections::HashMap<&str, KdeWallpaper> {
|
||||
let mut containment = None;
|
||||
let mut plugins = std::collections::HashMap::new();
|
||||
let mut panels = Vec::new();
|
||||
for line in text.lines().map(str::trim) {
|
||||
if line.starts_with('[') {
|
||||
containment = line.strip_prefix("[Containments][").and_then(|s| s.split_once(']'))
|
||||
.filter(|(_, section)| section.is_empty()).map(|(id, _)| id);
|
||||
}
|
||||
if let Some(id) = containment {
|
||||
plugins.entry(id).or_insert(KdeWallpaper::Image);
|
||||
if line.strip_prefix("plugin=").is_some_and(|plugin| plugin.trim() == "org.kde.panel") { panels.push(id); }
|
||||
if let Some(plugin) = line.strip_prefix("wallpaperplugin=") {
|
||||
plugins.insert(id, if plugin.trim() == "org.kde.image" { KdeWallpaper::Image } else { KdeWallpaper::Unsupported });
|
||||
}
|
||||
}
|
||||
}
|
||||
// Panels can keep an image wallpaper setting, but do not supply a desktop background.
|
||||
for id in panels { plugins.insert(id, KdeWallpaper::Unsupported); }
|
||||
plugins
|
||||
}
|
||||
|
||||
fn kde_default_allowed(text: &str) -> bool {
|
||||
let plugins = kde_plugins(text);
|
||||
if !plugins.is_empty() { return plugins.values().any(|plugin| *plugin == KdeWallpaper::Image); }
|
||||
!text.contains("[Wallpaper][") || text.contains("[Wallpaper][org.kde.image]")
|
||||
}
|
||||
|
||||
fn gsettings_path(value: &str) -> Option<PathBuf> {
|
||||
// gsettings prints a GVariant string, with either quote style and C/Unicode escapes.
|
||||
// https://docs.gtk.org/glib/gvariant-text-format.html#strings
|
||||
let mut chars = value.trim().chars();
|
||||
let quote = chars.next()?;
|
||||
if quote != '\'' && quote != '"' { return None; }
|
||||
let mut decoded = String::new();
|
||||
while let Some(ch) = chars.next() {
|
||||
if ch == quote { return chars.as_str().is_empty().then(|| local_path(&decoded)).flatten(); }
|
||||
if ch != '\\' { decoded.push(ch); continue; }
|
||||
let escaped = chars.next()?;
|
||||
decoded.push(match escaped {
|
||||
'a' => '\x07', 'b' => '\x08', 'f' => '\x0c', 'n' => '\n',
|
||||
'r' => '\r', 't' => '\t', 'v' => '\x0b', '\\' => '\\', '\'' => '\'', '"' => '"',
|
||||
'u' | 'U' => {
|
||||
let mut code = 0u32;
|
||||
for _ in 0..if escaped == 'u' { 4 } else { 8 } { code = u32::checked_add(code.checked_mul(16)?, chars.next()?.to_digit(16)?)?; }
|
||||
char::from_u32(code).filter(|c| *c != '\0')?
|
||||
}
|
||||
'\n' => continue,
|
||||
_ => escaped,
|
||||
});
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn local_path(value: &str) -> Option<PathBuf> {
|
||||
let value = value.trim();
|
||||
let path = if value.starts_with("file:") {
|
||||
let url = reqwest::Url::parse(value).ok()?;
|
||||
if url.query().is_some() || url.fragment().is_some() { return None; }
|
||||
url.to_file_path().ok()?
|
||||
} else { PathBuf::from(value) };
|
||||
path.is_absolute().then_some(path)
|
||||
}
|
||||
|
||||
async fn read_image(path: &std::path::Path) -> Result<Vec<u8>, ()> {
|
||||
if !tokio::fs::metadata(path).await.map_err(|_| ())?.is_file() { return Err(()); }
|
||||
let file = tokio::fs::File::open(path).await.map_err(|_| ())?;
|
||||
if !file.metadata().await.map_err(|_| ())?.is_file() { return Err(()); }
|
||||
let mut image = Vec::new();
|
||||
file.take((LIMIT + 1) as u64).read_to_end(&mut image).await.map_err(|_| ())?;
|
||||
if image.len() > LIMIT || image_type(&image).is_none() { return Err(()); }
|
||||
Ok(image)
|
||||
}
|
||||
|
||||
fn image_type(image: &[u8]) -> Option<&'static str> {
|
||||
if image.starts_with(b"\x89PNG\r\n\x1a\n") { Some("image/png") }
|
||||
else if image.starts_with(b"\xff\xd8\xff") { Some("image/jpeg") }
|
||||
else if image.starts_with(b"RIFF") && image.get(8..12) == Some(b"WEBP") { Some("image/webp") }
|
||||
else { None }
|
||||
}
|
||||
|
||||
fn api_data(status: u16, body: &serde_json::Value) -> Result<&serde_json::Value, ()> {
|
||||
if status != 200 || body.get("code").and_then(|v| v.as_i64()) != Some(0) { return Err(()); }
|
||||
body.get("data").ok_or(())
|
||||
}
|
||||
|
||||
async fn publish(auth: &UUAuthClient, image: Vec<u8>) -> Result<(), &'static str> {
|
||||
let http = crate::auth::http_client_builder().redirect(reqwest::redirect::Policy::none()).build().map_err(|_| "http-client")?;
|
||||
publish_to(auth, image, crate::auth::BASE_URL, &http).await
|
||||
}
|
||||
|
||||
async fn json(request: reqwest::RequestBuilder) -> Result<(u16, serde_json::Value), ()> {
|
||||
let mut response = request.timeout(TIMEOUT).send().await.map_err(|_| ())?;
|
||||
let status = response.status().as_u16();
|
||||
let mut bytes = Vec::new();
|
||||
while let Some(chunk) = response.chunk().await.map_err(|_| ())? {
|
||||
if bytes.len() + chunk.len() > 65536 { return Err(()); }
|
||||
bytes.extend_from_slice(&chunk);
|
||||
}
|
||||
Ok((status, serde_json::from_slice(&bytes).map_err(|_| ())?))
|
||||
}
|
||||
|
||||
async fn publish_to(auth: &UUAuthClient, image: Vec<u8>, base: &str, http: &reqwest::Client) -> Result<(), &'static str> {
|
||||
let path = "/api/v1/tool/fp/token?filetype=1";
|
||||
let result = json(http.get(format!("{base}{path}")).headers(auth.build_headers("GET", path, ""))).await.map_err(|_| "token-request")?;
|
||||
let data = api_data(result.0, &result.1).map_err(|_| "token-response")?;
|
||||
let token = data.get("token").and_then(|v| v.as_str()).filter(|v| !v.is_empty()).ok_or("file-token")?;
|
||||
let url = data.get("req_url").and_then(|v| v.as_str()).ok_or("upload-url")?;
|
||||
let url = https_url(url).map_err(|_| "upload-url")?;
|
||||
let max = data.get("max_size").and_then(|v| v.as_u64()).filter(|n| *n > 0).unwrap_or(LIMIT as u64);
|
||||
if image.len() as u64 > max { return Err("file-size"); }
|
||||
// Filepicker takes raw bytes and its own Authorization value, never account headers.
|
||||
let response = json(http.post(url).header("Authorization", token)
|
||||
.header("Content-Type", image_type(&image).ok_or("file-type")?).body(image)
|
||||
).await.map_err(|_| "file-upload")?;
|
||||
if response.0 != 200 { return Err("file-upload-status"); }
|
||||
let url = response.1.get("url").and_then(|v| v.as_str()).ok_or("file-response")?;
|
||||
https_url(url).map_err(|_| "file-response-url")?;
|
||||
let path = "/api/v1/device/wallpaper";
|
||||
let body = serde_json::json!({"wallpaper_url": url}).to_string();
|
||||
let result = json(http.post(format!("{base}{path}")).headers(auth.build_headers("POST", path, &body)).body(body)).await.map_err(|_| "report-request")?;
|
||||
if result.0 != 200 || result.1.get("code").and_then(|v| v.as_i64()) != Some(0) { return Err("report-response"); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn https_url(value: &str) -> Result<reqwest::Url, ()> {
|
||||
let url = reqwest::Url::parse(value).map_err(|_| ())?;
|
||||
if url.scheme() != "https" || url.host_str().is_none() || !url.username().is_empty() || url.password().is_some() { return Err(()); }
|
||||
Ok(url)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use tokio::io::AsyncWriteExt;
|
||||
#[tokio::test]
|
||||
async fn kde_config_uses_plasma5_when_plasma6_reader_is_unavailable() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let root = std::env::temp_dir().join(format!("uu-kreadconfig-test-{}-{}", std::process::id(), rand::random::<u64>()));
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
let five = root.join("kreadconfig5"); let six = root.join("kreadconfig6");
|
||||
std::fs::write(&five, "#!/bin/sh\ncase \"$*\" in *LookAndFeelPackage*) echo org.kde.breeze.desktop;; *Image*) echo Next;; esac\n").unwrap();
|
||||
std::fs::set_permissions(&five, std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
let readers = [six.to_str().unwrap(), five.to_str().unwrap()];
|
||||
assert_eq!(kde_config(&readers, &["--key", "LookAndFeelPackage"]).await.as_deref(), Some("org.kde.breeze.desktop\n"));
|
||||
assert_eq!(kde_config(&readers, &["--key", "Image"]).await.as_deref(), Some("Next\n"));
|
||||
std::fs::write(&six, "#!/bin/sh\necho Plasma6\n").unwrap();
|
||||
std::fs::set_permissions(&six, std::fs::Permissions::from_mode(0o700)).unwrap();
|
||||
assert_eq!(kde_config(&readers, &["--key", "Image"]).await.as_deref(), Some("Plasma6\n"));
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn kde_packages_select_landscape_and_image_reads_are_bounded() {
|
||||
let root = std::env::temp_dir().join(format!("uu-wallpaper-test-{}-{}", std::process::id(), rand::random::<u64>()));
|
||||
let images = root.join("contents/images");
|
||||
std::fs::create_dir_all(&images).unwrap();
|
||||
for name in ["1440x2960.png", "5120x2880.png", "7680x2160.png"] {
|
||||
std::fs::write(images.join(name), b"\x89PNG\r\n\x1a\n").unwrap();
|
||||
}
|
||||
let image = package_image(root.clone()).await.unwrap();
|
||||
assert_eq!(image.file_name().unwrap(), "5120x2880.png");
|
||||
assert_eq!(package_image(image.clone()).await, Some(image.clone()));
|
||||
assert!(read_image(&image).await.is_ok());
|
||||
std::fs::write(&image, b"private text is not an image").unwrap();
|
||||
assert!(read_image(&image).await.is_err());
|
||||
std::fs::OpenOptions::new().write(true).open(&image).unwrap().set_len((LIMIT + 1) as u64).unwrap();
|
||||
assert!(read_image(&image).await.is_err());
|
||||
assert!(read_image(&root).await.is_err());
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn kde_packages_follow_image_symlinks_and_skip_invalid_targets() {
|
||||
use std::os::unix::fs::symlink;
|
||||
let root = std::env::temp_dir().join(format!("uu-wallpaper-links-test-{}-{}", std::process::id(), rand::random::<u64>()));
|
||||
let images = root.join("contents/images");
|
||||
std::fs::create_dir_all(&images).unwrap();
|
||||
let target = root.join("shared.png");
|
||||
std::fs::write(&target, b"\x89PNG\r\n\x1a\n").unwrap();
|
||||
let image = images.join("1920x1080.png");
|
||||
symlink("../../shared.png", &image).unwrap();
|
||||
symlink("../../missing.png", images.join("640x480.png")).unwrap();
|
||||
symlink(&root, images.join("800x600.png")).unwrap();
|
||||
assert_eq!(package_image(root.clone()).await, Some(image.clone()));
|
||||
assert!(read_image(&image).await.is_ok());
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn reporting_protocol_keeps_file_token_separate_and_stops_on_failures() {
|
||||
use tokio_rustls::{rustls, TlsAcceptor};
|
||||
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};
|
||||
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
|
||||
let der = cert.serialize_der().unwrap();
|
||||
let http = reqwest::Client::builder().no_proxy().redirect(reqwest::redirect::Policy::none())
|
||||
.add_root_certificate(reqwest::Certificate::from_der(&der).unwrap()).build().unwrap();
|
||||
let config = rustls::ServerConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
|
||||
.with_safe_default_protocol_versions().unwrap().with_no_client_auth()
|
||||
.with_single_cert(vec![CertificateDer::from(der)], PrivateKeyDer::Pkcs8(
|
||||
PrivatePkcs8KeyDer::from(cert.serialize_private_key_der()))).unwrap();
|
||||
let acceptor = TlsAcceptor::from(Arc::new(config));
|
||||
let auth = UUAuthClient::new(crate::auth::Credentials {
|
||||
token: "fixture-account-token".into(), csrf: "fixture-csrf".into(),
|
||||
sign_key: "fixture-key".into(), ..Default::default()
|
||||
});
|
||||
for scenario in ["success", "token-failed", "too-large", "upload-failed", "report-failed"] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let base = format!("https://localhost:{}", listener.local_addr().unwrap().port());
|
||||
let server_base = base.clone(); let acceptor = acceptor.clone();
|
||||
let steps = match scenario { "token-failed" | "too-large" => 1, "upload-failed" => 2, _ => 3 };
|
||||
let server = tokio::spawn(async move {
|
||||
for step in 0..steps {
|
||||
let (socket, _) = listener.accept().await.unwrap();
|
||||
let mut tls = acceptor.accept(socket).await.unwrap();
|
||||
let mut bytes = Vec::new(); let mut byte = [0u8; 1];
|
||||
while !bytes.ends_with(b"\r\n\r\n") {
|
||||
tls.read_exact(&mut byte).await.unwrap(); bytes.push(byte[0]); assert!(bytes.len() < 16384);
|
||||
}
|
||||
let headers = String::from_utf8(bytes).unwrap().to_lowercase();
|
||||
let length: usize = headers.lines().find_map(|l| l.strip_prefix("content-length:")
|
||||
.and_then(|s| s.trim().parse().ok())).unwrap_or(0);
|
||||
let mut body = vec![0; length]; tls.read_exact(&mut body).await.unwrap();
|
||||
let (status, reply) = match step {
|
||||
0 => {
|
||||
assert!(headers.starts_with("get /api/v1/tool/fp/token?filetype=1 "));
|
||||
assert!(headers.contains("authorization: bearer fixture-account-token\r\n"));
|
||||
assert!(headers.contains("x-param-sign:")); assert!(body.is_empty());
|
||||
(200, serde_json::json!({"code":if scenario=="token-failed" {1120}else{0},
|
||||
"data":{"token":"fixture-file-token","req_url":format!("{server_base}/upload"),"ttl":60,
|
||||
"max_size":if scenario=="too-large" {1}else{1024}}}))
|
||||
}
|
||||
1 => {
|
||||
assert!(headers.starts_with("post /upload "));
|
||||
assert!(headers.contains("authorization: fixture-file-token\r\n"));
|
||||
for secret in ["fixture-account-token", "fixture-csrf", "cookie:", "x-param-"] { assert!(!headers.contains(secret)); }
|
||||
assert_eq!(body, b"\x89PNG\r\n\x1a\n");
|
||||
(if scenario=="upload-failed" {500}else{200}, serde_json::json!({"url":"https://example.invalid/wallpaper.png","fsize":8,"md5":"fixture","mime":"image/png"}))
|
||||
}
|
||||
_ => {
|
||||
assert!(headers.starts_with("post /api/v1/device/wallpaper "));
|
||||
assert!(headers.contains("authorization: bearer fixture-account-token\r\n"));
|
||||
assert!(!headers.contains("fixture-file-token"));
|
||||
assert_eq!(serde_json::from_slice::<serde_json::Value>(&body).unwrap(), serde_json::json!({"wallpaper_url":"https://example.invalid/wallpaper.png"}));
|
||||
(200, serde_json::json!({"code":if scenario=="report-failed" {1120}else{0}}))
|
||||
}
|
||||
};
|
||||
let reply = reply.to_string();
|
||||
tls.write_all(format!("HTTP/1.1 {status} Fixture\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{reply}", reply.len()).as_bytes()).await.unwrap();
|
||||
tls.shutdown().await.unwrap();
|
||||
}
|
||||
});
|
||||
let result = tokio::time::timeout(Duration::from_secs(5), publish_to(&auth, b"\x89PNG\r\n\x1a\n".to_vec(), &base, &http)).await.unwrap();
|
||||
assert_eq!(result.is_ok(), scenario == "success", "{scenario}");
|
||||
tokio::time::timeout(Duration::from_secs(5), server).await.unwrap().unwrap();
|
||||
}
|
||||
}
|
||||
#[test] fn wallpaper_sources_are_local_and_scoped() {
|
||||
assert_eq!(gsettings_path("'file:///usr/share/a%20b.png'"), Some(PathBuf::from("/usr/share/a b.png")));
|
||||
for value in ["", "relative.png", "https://example.com/a.png", "file://remote/a.png", "file:///tmp/a.png?token=secret"] { assert!(local_path(value).is_none()); }
|
||||
assert_eq!(kde_image("[Other]\nImage=/wrong.png\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=file:///right.png"), Some(PathBuf::from("/right.png")));
|
||||
}
|
||||
#[test] fn gsettings_decodes_quotes_backslashes_and_unicode() {
|
||||
assert_eq!(gsettings_path("\"file:///tmp/it's.png\""), Some(PathBuf::from("/tmp/it's.png")));
|
||||
assert_eq!(gsettings_path(r#"'file:///tmp/it\'s.png'"#), Some(PathBuf::from("/tmp/it's.png")));
|
||||
assert_eq!(gsettings_path(r#"'/tmp/a\\b\t\u00e9\U0001f600.png'"#), Some(PathBuf::from("/tmp/a\\b\té😀.png")));
|
||||
for value in ["'unterminated", "'/tmp/a' trailing", r#"'/tmp/\uD800'"#, r#"'/tmp/\Uffffffff'"#] { assert!(gsettings_path(value).is_none()); }
|
||||
assert_eq!(gsettings_path(r#"'/tmp/\x41'"#), Some(PathBuf::from("/tmp/x41")));
|
||||
assert_eq!(local_path("/tmp/it's.png"), Some(PathBuf::from("/tmp/it's.png")));
|
||||
}
|
||||
#[test] fn kde_default_survives_saved_image_settings_but_not_other_plugins() {
|
||||
let image = "[Containments][1]\nwallpaperplugin=org.kde.image\n[Containments][1][Wallpaper][org.kde.image][General]\nFillMode=1\n";
|
||||
assert!(kde_image(image).is_none()); assert!(kde_default_allowed(image));
|
||||
assert!(kde_default_allowed("[Containments][1][Wallpaper][org.kde.image][General]\nFillMode=1"));
|
||||
assert!(kde_default_allowed(""));
|
||||
assert!(!kde_default_allowed(&image.replace("wallpaperplugin=org.kde.image", "wallpaperplugin=org.kde.slideshow")));
|
||||
assert!(!kde_default_allowed("[Containments][1][Wallpaper][org.kde.slideshow][General]\nSlidePaths=/tmp"));
|
||||
}
|
||||
#[test] fn kde_stored_images_belong_to_the_same_active_image_containment() {
|
||||
let stale = "[Containments][1]\nwallpaperplugin=org.kde.slideshow\n[Containments][1][Wallpaper][org.kde.image][General]\nImage=/tmp/previous.png\n";
|
||||
assert!(kde_image(stale).is_none());
|
||||
assert!(!kde_default_allowed(stale));
|
||||
let mixed = format!("{stale}[Containments][2]\nwallpaperplugin=org.kde.image\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=/tmp/current.png\n");
|
||||
assert_eq!(kde_image(&mixed), Some(PathBuf::from("/tmp/current.png")));
|
||||
assert_eq!(kde_image(&stale.replace("org.kde.slideshow", "org.kde.image")), Some(PathBuf::from("/tmp/previous.png")));
|
||||
}
|
||||
#[test] fn kde_panels_do_not_enable_default_wallpaper_or_supply_saved_images() {
|
||||
let panel = "[Containments][2]\nwallpaperplugin=org.kde.image\nplugin=org.kde.panel\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=/tmp/panel.png\n";
|
||||
let slideshow = "[Containments][1]\nplugin=org.kde.plasma.folder\nwallpaperplugin=org.kde.slideshow\n";
|
||||
assert!(!kde_default_allowed(slideshow));
|
||||
assert!(!kde_default_allowed(&format!("{slideshow}{panel}")));
|
||||
assert!(kde_image(&format!("{slideshow}{panel}")).is_none());
|
||||
assert!(!kde_default_allowed(panel));
|
||||
let desktop = "[Containments][1]\nplugin=org.kde.plasma.folder\n";
|
||||
assert!(kde_default_allowed(&format!("{desktop}{panel}")));
|
||||
}
|
||||
#[test] fn only_supported_image_files_are_uploaded() {
|
||||
assert_eq!(image_type(b"\x89PNG\r\n\x1a\n"), Some("image/png"));
|
||||
assert_eq!(image_type(b"\xff\xd8\xff"), Some("image/jpeg"));
|
||||
assert_eq!(image_type(b"RIFF1234WEBP"), Some("image/webp"));
|
||||
assert_eq!(image_type(b"<wallpaper>private text</wallpaper>"), None);
|
||||
}
|
||||
#[test] fn failed_api_responses_and_unsafe_upload_urls_are_rejected() {
|
||||
assert!(api_data(200, &serde_json::json!({"code":0,"data":{}})).is_ok());
|
||||
assert!(api_data(422, &serde_json::json!({"code":1120})).is_err());
|
||||
assert!(api_data(200, &serde_json::json!({"data":{}})).is_err());
|
||||
for url in ["http://example.com", "file:///tmp/a", "https://[email protected]"] { assert!(https_url(url).is_err()); }
|
||||
}
|
||||
}
|
||||
+106
-14
@@ -4,6 +4,9 @@ use crate::capture::ScreenCapture;
|
||||
use crate::input::InputInjector;
|
||||
use crate::signaling::SoacMessage;
|
||||
|
||||
#[path = "text_outbox.rs"]
|
||||
mod text_outbox;
|
||||
|
||||
use base64::Engine;
|
||||
use flate2::read::GzDecoder;
|
||||
use std::io::Read;
|
||||
@@ -489,6 +492,11 @@ impl WebRtcSession {
|
||||
let file_channel: Arc<std::sync::Mutex<Option<Arc<RTCDataChannel>>>> = Arc::new(std::sync::Mutex::new(None));
|
||||
let (file_tx, mut file_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
|
||||
let peer_files = crate::file_trans::FileSession::new(file_tx, control_sequence.clone());
|
||||
// Mac 4.43: streamerDidReceiveTextData (0x1001f56b4, arm64) reaches
|
||||
// the metrics/RPC dispatcher at 0x1003a8560; CONTROL does not.
|
||||
// Keep CONTROL metrics for other viewers; privacy replies use TEXT.
|
||||
let (text_tx, text_rx) = text_outbox::channel();
|
||||
let text_rx = Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Text(text_rx))));
|
||||
// 端口映射 frames (Message 27) also travel on FILE_DATA_CHANNEL; one session per peer.
|
||||
let port_mapping = crate::port_mapping::Session::new(file_channel.clone(), control_sequence.clone());
|
||||
{
|
||||
@@ -537,6 +545,8 @@ impl WebRtcSession {
|
||||
let echo_seen = echo_seen.clone();
|
||||
let channel_lock_state = channel_lock_state.clone();
|
||||
let peer_files = peer_files.clone();
|
||||
let text_out = text_tx.clone();
|
||||
let text_rx = text_rx.clone();
|
||||
let peer_port_mapping = port_mapping.clone();
|
||||
let peer_video_settings = video_settings.clone();
|
||||
let peer_video_track = control_video_track.clone();
|
||||
@@ -565,12 +575,16 @@ impl WebRtcSession {
|
||||
}
|
||||
// Ordered outbound queue for protocol replies produced outside this callback.
|
||||
// webrtc-rs announces the channel before handle_open (ready_state Connecting);
|
||||
// send() returns ErrClosedPipe until Open. Draining CONTROL here would drop
|
||||
// Message 25 and every later reply. Start CONTROL from the on_open below
|
||||
// send() returns ErrClosedPipe until Open. Draining CONTROL/TEXT here would
|
||||
// drop initial state and replies. Start them from the on_open below
|
||||
// (one handler; a second on_open replaces it). Receiver taken once.
|
||||
let mut control_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
|
||||
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
|
||||
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
|
||||
let mut open_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
|
||||
let (outbound, outbound_rx) = if label == "TEXT_DATA_CHANNEL" {
|
||||
(Outbound::Text(text_out.clone()), text_rx)
|
||||
} else {
|
||||
let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
|
||||
(Outbound::Other(tx), Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Other(rx)))))
|
||||
};
|
||||
if label == "CONTROL_DATA_CHANNEL" {
|
||||
if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() {
|
||||
let sync_out = outbound.clone();
|
||||
@@ -603,8 +617,8 @@ impl WebRtcSession {
|
||||
});
|
||||
}) as std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
|
||||
};
|
||||
if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); }
|
||||
else { control_drain = Some(Box::new(start_drain)); }
|
||||
if !matches!(label.as_str(), "CONTROL_DATA_CHANNEL" | "TEXT_DATA_CHANNEL") { tokio::spawn(start_drain()); }
|
||||
else { open_drain = Some(Box::new(start_drain)); }
|
||||
}
|
||||
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
|
||||
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
|
||||
@@ -686,7 +700,7 @@ impl WebRtcSession {
|
||||
};
|
||||
let Some(active_screen) = active_screen else { continue; };
|
||||
let input_size = if active_screen.init_error.is_none() {
|
||||
(active_screen.width, active_screen.height)
|
||||
active_screen.portal.as_ref().map_or((active_screen.width, active_screen.height), |p| p.size())
|
||||
} else { (1920, 1080) };
|
||||
let input_size=crate::wayland::input_size(input_size);
|
||||
let source_changed=source_before!=crate::wayland::selected();
|
||||
@@ -776,9 +790,10 @@ impl WebRtcSession {
|
||||
Some(peer_files.clone())
|
||||
} else { None };
|
||||
// CT_TERMINAL: TERM frames and terminal RPCs (check_env/rename) on BINARY.
|
||||
let terminal_conn = if label == "BINARY_DATA_CHANNEL" {
|
||||
Some(Arc::new(crate::terminal::TerminalConn::new(outbound.clone())))
|
||||
} else { None };
|
||||
let terminal_conn = match (&outbound, label.as_str()) {
|
||||
(Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))),
|
||||
_ => None,
|
||||
};
|
||||
if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" {
|
||||
let channel = d.clone();
|
||||
let initial_sequence = out_sequence.clone();
|
||||
@@ -795,8 +810,9 @@ impl WebRtcSession {
|
||||
let open_role = channel_role.clone();
|
||||
let open_screen = screen.clone();
|
||||
let open_selection = peer_selection;
|
||||
let open_text_out = text_out.clone();
|
||||
d.on_open(Box::new(move || {
|
||||
if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); }
|
||||
if let Some(start_drain) = open_drain { tokio::spawn(start_drain()); }
|
||||
let init_actions = open_actions.clone();
|
||||
let init_video = open_video.clone();
|
||||
let init_track = open_track.clone();
|
||||
@@ -810,6 +826,7 @@ impl WebRtcSession {
|
||||
let owner = open_owner.clone();
|
||||
let role = open_role.clone();
|
||||
let pc = desktop_pc.upgrade();
|
||||
let text_out = open_text_out.clone();
|
||||
Box::pin(async move {
|
||||
// Permission dialogs and first-frame waits must not occupy the
|
||||
// channel-open callback or delay CONTROL message dispatch.
|
||||
@@ -962,6 +979,7 @@ impl WebRtcSession {
|
||||
let message = crate::initialization::envelope(
|
||||
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13,
|
||||
&init_actions.metrics_payload(desktop_sound, snapshot.permission(true)));
|
||||
text_out.metrics(message.clone());
|
||||
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
|
||||
let mut updates = portal.subscribe();
|
||||
match crate::desktop_session::wait_ready(&mut updates, &channel).await {
|
||||
@@ -972,6 +990,7 @@ impl WebRtcSession {
|
||||
let message = crate::initialization::envelope(
|
||||
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13,
|
||||
&init_actions.metrics_payload(desktop_sound, crate::system_metrics::Permission::Reject));
|
||||
text_out.metrics(message.clone());
|
||||
let _ = channel.send(&bytes::Bytes::from(message)).await;
|
||||
}
|
||||
return;
|
||||
@@ -1019,6 +1038,7 @@ impl WebRtcSession {
|
||||
Ok(message) => message,
|
||||
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
|
||||
};
|
||||
if field == 13 { text_out.metrics(message.clone()); }
|
||||
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
|
||||
log::error!("CONTROL initialization field {} failed: {}", field, e);
|
||||
return;
|
||||
@@ -1036,6 +1056,28 @@ impl WebRtcSession {
|
||||
if !lock_reported {
|
||||
lock_reported = true;
|
||||
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
|
||||
let (channel, sequence, actions) = (channel.clone(), sequence.clone(), init_actions.clone());
|
||||
let portal = portal_desktop.clone();
|
||||
let text_out = text_out.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut previous = crate::privacy_screen::current_type();
|
||||
let mut tick = tokio::time::interval(std::time::Duration::from_secs(1));
|
||||
loop {
|
||||
tick.tick().await;
|
||||
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
|
||||
let current = crate::privacy_screen::current_type();
|
||||
if current == previous { continue; }
|
||||
previous = current;
|
||||
let permission = portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(true));
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let payload = actions.metrics_payload(desktop_sound, permission);
|
||||
let message = crate::initialization::envelope(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &payload);
|
||||
text_out.metrics(message.clone());
|
||||
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
|
||||
let state = crate::privacy_screen::state_message(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts);
|
||||
if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; }
|
||||
}
|
||||
});
|
||||
}
|
||||
// Mirror the Linux pointer shape; the video itself carries no pointer.
|
||||
let mut shapes = crate::cursor::monitor(&screen.display);
|
||||
@@ -1087,6 +1129,7 @@ impl WebRtcSession {
|
||||
let message_role=channel_role.clone();
|
||||
let terminal_worker = terminal_conn.clone();
|
||||
let rpc_out = outbound.clone();
|
||||
let text_out = text_out.clone();
|
||||
let reply_chan = d_reply.clone();
|
||||
let out_sequence = reply_sequence.clone();
|
||||
let clipboard_sink = clipboard_input.clone();
|
||||
@@ -1103,7 +1146,8 @@ impl WebRtcSession {
|
||||
let capture_requests = capture_tx.clone();
|
||||
|
||||
Box::pin(async move {
|
||||
let input_size = crate::wayland::input_size((screen.width, screen.height));
|
||||
// The privacy screen can swap the portal stream to a virtual output of another size.
|
||||
let input_size = crate::wayland::input_size(screen.portal.as_ref().map_or((screen.width, screen.height), |p| p.size()));
|
||||
// After a RandR resize the stream restarts capture at the new size; map the pointer to it.
|
||||
let live_x11 = screen.init_error.is_none() && screen.portal.is_none() && screen.backend == crate::desktop_backend::DesktopBackend::X11;
|
||||
if let Some(term) = &terminal_worker {
|
||||
@@ -1121,6 +1165,32 @@ impl WebRtcSession {
|
||||
use crate::protocol::WireValue;
|
||||
let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None });
|
||||
let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
|
||||
if let Some(request) = rpc.filter(|_| rpc_fields.as_ref().is_some_and(|r| r.iter().any(|f| f.number == 7))) {
|
||||
let Some((response, accepted)) = rpc_fields.as_deref().and_then(crate::privacy_screen::rpc_accept) else { return };
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
let Some(accepted) = accepted else { return };
|
||||
let failed = tokio::task::spawn_blocking(move || accepted.apply().is_err()).await.unwrap_or(true);
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let next = || out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
if failed {
|
||||
let report = crate::initialization::encode_report_error(next(), ts, crate::privacy_screen::REPORT_ERROR, "privacy screen failed");
|
||||
let _ = reply_chan.send(&bytes::Bytes::from(report)).await;
|
||||
}
|
||||
let permission = portal_for_message.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(desktop));
|
||||
let metrics = actions.metrics_payload(desktop_sound, permission);
|
||||
text_out.metrics(crate::initialization::envelope(next(), ts, 13, &metrics));
|
||||
let _ = reply_chan.send(&bytes::Bytes::from(crate::initialization::envelope(next(), ts, 13, &metrics))).await;
|
||||
let state = crate::privacy_screen::state_message(next(), ts);
|
||||
let _ = reply_chan.send(&bytes::Bytes::from(state)).await;
|
||||
log::info!("Privacy switch done: failed={failed} type={}", crate::privacy_screen::current_type());
|
||||
return;
|
||||
}
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(crate::privacy_screen::screensaver_response) {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
return;
|
||||
}
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
@@ -1302,6 +1372,7 @@ impl WebRtcSession {
|
||||
crate::control_protocol::simple_action_name(action).unwrap_or("?"), value, sa::args_shape(&args));
|
||||
let (actions, input, chan, seq_out) = (actions.clone(), input_worker.clone(), reply_chan.clone(), out_sequence.clone());
|
||||
let settings_portal = portal_for_message.clone();
|
||||
let text_out = text_out.clone();
|
||||
tokio::spawn(async move {
|
||||
let worker = actions.clone();
|
||||
let report = tokio::task::spawn_blocking(move || worker.handle(action, value, &args, || {
|
||||
@@ -1315,6 +1386,7 @@ impl WebRtcSession {
|
||||
crate::system_metrics::Permission::Allow,
|
||||
|manager| manager.snapshot().permission(desktop));
|
||||
let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, permission));
|
||||
text_out.metrics(message.clone());
|
||||
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
|
||||
}
|
||||
});
|
||||
@@ -1669,8 +1741,28 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
|
||||
None
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Outbound {
|
||||
Text(text_outbox::Sender),
|
||||
Other(tokio::sync::mpsc::UnboundedSender<Vec<u8>>),
|
||||
}
|
||||
impl Outbound {
|
||||
fn send(&self, message: Vec<u8>) -> Result<(), tokio::sync::mpsc::error::SendError<Vec<u8>>> {
|
||||
match self { Self::Text(tx) => tx.send(message), Self::Other(tx) => tx.send(message) }
|
||||
}
|
||||
}
|
||||
enum OutboundReceiver {
|
||||
Text(text_outbox::Receiver),
|
||||
Other(tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>),
|
||||
}
|
||||
impl OutboundReceiver {
|
||||
async fn recv(&mut self) -> Option<Vec<u8>> {
|
||||
match self { Self::Text(rx) => rx.recv().await, Self::Other(rx) => rx.recv().await }
|
||||
}
|
||||
}
|
||||
|
||||
/// First drain owns the outbound receiver; a later open must not start another.
|
||||
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
|
||||
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<T>>) -> Option<T> {
|
||||
slot.lock().await.take()
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user