From 8e303713174d8cf66e3a438aab2d914f9c03e318 Mon Sep 17 00:00:00 2001 From: Jeff Zhang Date: Mon, 2 Nov 2026 01:14:10 +0800 Subject: [PATCH] feat(host): KDE Wayland privacy screen (RPC 7) (#146) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(host): KDE Wayland 被控端防窥模式(隐私 / 关屏) viewer RPC 7 打开防窥时,采集和输入切到 KWin 虚拟输出(portal ScreenCast VIRTUAL), 再用 kscreen-doctor 禁用物理屏;隐私模式随后重新启用物理屏并全屏覆盖桌面壁纸。 防窥期间通过 KWin InputDevice 禁用本地键鼠,指针/按键/文字改走 uinput (KDE 不处理虚拟输出共享上的 portal 输入)。 - privacy_type 实测:1 关闭、2 隐私(壁纸)、3 关屏;SettingMetric 4/7 上报真实状态 - 恢复记录 + privacy-guard 子进程:主机以任何方式结束(含 SIGKILL)都恢复屏幕和输入 - src/privacy_screen/ 分层:控制器/协议/记录/守护/遮挡窗口共享,桌面实现走 Backend trait(kde/) - portal:Session::set_virtual,闭包恢复按当前源重开;编码器随 portal 尺寸变化重建 Refs #140 * fix(privacy): 按 Mac 客户端协议应答防窥请求,修复授权竞态 - FeatureFlag ff_private_screen=2(ENHANCED_PRIVACY),声明支持关屏 - 先回 RPC 7 应答再切换,避免客户端超时报 9998;切换失败发 ReportError -7 - 应答 RPC 25 update_screen_saver_req(RpcResponse 21),隐私模式不再被中止 - SettingMetric 4/7 上报开关与最近一次模式(host_settings.json privacy_type),状态变化推送 SystemStateChange 5 - portal 会话串行打开,打开失败回填一次性授权:快速重连时防窥切换与闭包恢复并发曾清空保存的授权 字段号与枚举取自官方 Mac 客户端的 SwiftProtobuf name map。 已知限制:Mac 客户端防窥菜单切换后仍显示"不启用",实际模式正确。 Refs #140 * fix(privacy): 处理 #146 评审意见 - 预检 uinput:injector 未打开 uinput(/dev/uinput 不可用或 UU_INPUT_BACKEND=native)时, 在改动输出和设备之前拒绝防窥(虚拟输出共享上 KDE 忽略 portal 输入) - leave() 中输入设备恢复失败在恢复输出后向上返回,保留 privacy-power.json 与 guard - record::ownership() 只缓存成功持锁,guard 轮询和 recover() 可重试 - 遮挡窗口就绪握手:privacy-wallpaper 建好窗口后输出 ready,5 秒内未就绪则报错并回滚 - rebase 到 main(#145):DMA-BUF 打开路径跳过虚拟输出、失败同样回填授权; #145 的 uinput 指针路径也按隐私模式的虚拟输出区域换算坐标 - README 表格压缩为一句,细节在 docs/privacy-screen.md Refs #140 * docs(privacy): 注明 ff_system_metrics=3 对应的枚举 Refs #140 * fix(privacy): resolve lifecycle and restoration review findings --- AGENTS.md | 1 + README.en.md | 2 +- README.md | 2 +- build.rs | 3 +- c_engine/portal_engine.c | 15 ++- c_engine/portal_engine.h | 1 + c_engine/privacy_wallpaper.c | 85 ++++++++++++++ docs/privacy-screen.md | 111 ++++++++++++++++++ src/capture.rs | 1 + src/control_protocol.rs | 4 + src/desktop_power.rs | 1 + src/input.rs | 59 +++++++++- src/main.rs | 21 +++- src/portal.rs | 102 +++++++++++++---- src/privacy_screen/backend.rs | 33 ++++++ src/privacy_screen/cover.rs | 45 ++++++++ src/privacy_screen/guard.rs | 31 +++++ src/privacy_screen/kde/input.rs | 30 +++++ src/privacy_screen/kde/kwin.rs | 25 +++++ src/privacy_screen/kde/mod.rs | 94 ++++++++++++++++ src/privacy_screen/kde/outputs.rs | 76 +++++++++++++ src/privacy_screen/mod.rs | 180 ++++++++++++++++++++++++++++++ src/privacy_screen/mode.rs | 29 +++++ src/privacy_screen/protocol.rs | 74 ++++++++++++ src/privacy_screen/record.rs | 61 ++++++++++ src/privacy_screen/tool.rs | 50 +++++++++ src/system_actions.rs | 5 + src/system_metrics.rs | 7 +- src/video.rs | 16 ++- src/webrtc.rs | 47 +++++++- 30 files changed, 1169 insertions(+), 42 deletions(-) create mode 100644 c_engine/privacy_wallpaper.c create mode 100644 docs/privacy-screen.md create mode 100644 src/privacy_screen/backend.rs create mode 100644 src/privacy_screen/cover.rs create mode 100644 src/privacy_screen/guard.rs create mode 100644 src/privacy_screen/kde/input.rs create mode 100644 src/privacy_screen/kde/kwin.rs create mode 100644 src/privacy_screen/kde/mod.rs create mode 100644 src/privacy_screen/kde/outputs.rs create mode 100644 src/privacy_screen/mod.rs create mode 100644 src/privacy_screen/mode.rs create mode 100644 src/privacy_screen/protocol.rs create mode 100644 src/privacy_screen/record.rs create mode 100644 src/privacy_screen/tool.rs diff --git a/AGENTS.md b/AGENTS.md index d4971fa..0e62a16 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -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 | diff --git a/README.en.md b/README.en.md index 32b0090..ecd9a3b 100644 --- a/README.en.md +++ b/README.en.md @@ -151,7 +151,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; 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 | diff --git a/README.md b/README.md index 0d49f90..e9ab2a5 100644 --- a/README.md +++ b/README.md @@ -136,7 +136,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),见 [docs/privacy-screen.md](docs/privacy-screen.md) | | 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) | | 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 | | Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 | diff --git a/build.rs b/build.rs index cfefe31..6a07c94 100644 --- a/build.rs +++ b/build.rs @@ -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() { diff --git a/c_engine/portal_engine.c b/c_engine/portal_engine.c index 927c291..b383240 100644 --- a/c_engine/portal_engine.c +++ b/c_engine/portal_engine.c @@ -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); diff --git a/c_engine/portal_engine.h b/c_engine/portal_engine.h index d0aa951..9f9d16b 100644 --- a/c_engine/portal_engine.h +++ b/c_engine/portal_engine.h @@ -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); diff --git a/c_engine/privacy_wallpaper.c b/c_engine/privacy_wallpaper.c new file mode 100644 index 0000000..e1904e6 --- /dev/null +++ b/c_engine/privacy_wallpaper.c @@ -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 +#include +#include +#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; +} diff --git a/docs/privacy-screen.md b/docs/privacy-screen.md new file mode 100644 index 0000000..dd5f4d3 --- /dev/null +++ b/docs/privacy-screen.md @@ -0,0 +1,111 @@ +# 实验性防窥 / 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..enable`。 + The recovery record `privacy-power.json` (0600) re-enables the recorded outputs at the next start + after a crash; manually: `kscreen-doctor output..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. +- 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` + (最近一次开启的模式,存于 host_settings.json `privacy_type`);SystemStateChange 5 `PrivateScreenState` 在状态变化时推送。 + +已知限制:官方 Mac 客户端的防窥菜单在切换后仍回显"不启用",实际模式正确;客户端未回读上述状态。 +Known limitation: the official Mac viewer's menu still shows "off" after switching although the mode applies. + +## 本机诊断 / 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`. diff --git a/src/capture.rs b/src/capture.rs index 734299b..5e6e850 100644 --- a/src/capture.rs +++ b/src/capture.rs @@ -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(); diff --git a/src/control_protocol.rs b/src/control_protocol.rs index 6f9962f..e569628 100644 --- a/src/control_protocol.rs +++ b/src/control_protocol.rs @@ -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); diff --git a/src/desktop_power.rs b/src/desktop_power.rs index ee753dd..9869ec7 100644 --- a/src/desktop_power.rs +++ b/src/desktop_power.rs @@ -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(()); } diff --git a/src/input.rs b/src/input.rs index 215d1aa..f4c0c6b 100644 --- a/src/input.rs +++ b/src/input.rs @@ -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; } diff --git a/src/main.rs b/src/main.rs index 9169f38..611ab89 100644 --- a/src/main.rs +++ b/src/main.rs @@ -45,6 +45,7 @@ mod inproc_encoder; mod capture_setting; mod audio; mod virtual_audio; +mod privacy_screen; mod system_actions; mod capability; mod protocol; @@ -208,7 +209,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 +631,20 @@ async fn main() -> Result<(), Box> { 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::>())); + } + 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 +683,7 @@ async fn main() -> Result<(), Box> { } #[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 +714,7 @@ async fn main() -> Result<(), Box> { // 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. diff --git a/src/portal.rs b/src/portal.rs index aa8c62a..1e7b37c 100644 --- a/src/portal.rs +++ b/src/portal.rs @@ -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 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, locked: tokio::sync::watch::Receiver>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex, size: std::sync::atomic::AtomicU64, monitor: Mutex> } + pub struct Session { handle: Mutex, locked: tokio::sync::watch::Receiver>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex, size: std::sync::atomic::AtomicU64, monitor: Mutex>, virtual_output: std::sync::atomic::AtomicBool } impl Session { fn take_lock_observation(&self) -> Result { // 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 { + /// `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 { 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 = 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| { + 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::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>) { @@ -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::open_inner(Some(cancelled), None, false) + Self::open_inner(Some(cancelled), None, false, false) } pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result { 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 { 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) { *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, 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"); diff --git a/src/privacy_screen/backend.rs b/src/privacy_screen/backend.rs new file mode 100644 index 0000000..8f51e2c --- /dev/null +++ b/src/privacy_screen/backend.rs @@ -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; + /// 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; + /// 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 } +} diff --git a/src/privacy_screen/cover.rs b/src/privacy_screen/cover.rs new file mode 100644 index 0000000..1c0ccab --- /dev/null +++ b/src/privacy_screen/cover.rs @@ -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> = 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::>().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 ...`: the cover window process. +pub fn main(args: &[String]) -> i32 { + let rects: Vec = 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 } +} diff --git a/src/privacy_screen/guard.rs b/src/privacy_screen/guard.rs new file mode 100644 index 0000000..e3312cc --- /dev/null +++ b/src/privacy_screen/guard.rs @@ -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> = 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 +} diff --git a/src/privacy_screen/kde/input.rs b/src/privacy_screen/kde/input.rs new file mode 100644 index 0000000..c32044b --- /dev/null +++ b/src/privacy_screen/kde/input.rs @@ -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 { 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, 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 { "" } else { "" }; + 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) +} diff --git a/src/privacy_screen/kde/kwin.rs b/src/privacy_screen/kde/kwin.rs new file mode 100644 index 0000000..1fb7901 --- /dev/null +++ b/src/privacy_screen/kde/kwin.rs @@ -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 { 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);"#)) +} diff --git a/src/privacy_screen/kde/mod.rs b/src/privacy_screen/kde/mod.rs new file mode 100644 index 0000000..b974310 --- /dev/null +++ b/src/privacy_screen/kde/mod.rs @@ -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, #[serde(default)] devices: Vec } + +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 { + 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 { + 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 { + 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(()) + } +} diff --git a/src/privacy_screen/kde/outputs.rs b/src/privacy_screen/kde/outputs.rs new file mode 100644 index 0000000..e01153b --- /dev/null +++ b/src/privacy_screen/kde/outputs.rs @@ -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 { run("kscreen-doctor", &["-j".into()]) } +/// Enabled, connected outputs that KWin did not create for a screencast. +fn physical_in(text: &str) -> Result, 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 = 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, String> { physical_in(&json()?) } +/// Enabled outputs in KWin's logical coordinates (mode size / scale, rotated). +fn layout_in(text: &str) -> Result, 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, 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::>())?; + 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]); + } +} diff --git a/src/privacy_screen/mod.rs b/src/privacy_screen/mod.rs new file mode 100644 index 0000000..f6c3507 --- /dev/null +++ b/src/privacy_screen/mod.rs @@ -0,0 +1,180 @@ +//! 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 } +struct State { sessions: usize, active: Option } +static STATE: Mutex = 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> = 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() } +} +/// The mode last enabled (kept in host_settings.json), 1 (PS_NOT_SET) before any. +pub fn preferred_type() -> u8 { + crate::system_actions::load_settings().privacy_type.filter(|t| matches!(t, 2 | 3)).unwrap_or(mode::TYPE_OFF) +} +/// Message 15 SystemStateChange { 5 PrivateScreenState } for the state now in effect. +pub fn state_message(seq: u64, timestamp: u64) -> Vec { + 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) -> 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) -> Option { + 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 } +/// 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, Option)> { + 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 }))) +} +/// ReportError.error_code the Mac viewer treats as a privacy-screen failure (handleForReportError). +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()); + } +} diff --git a/src/privacy_screen/mode.rs b/src/privacy_screen/mode.rs new file mode 100644 index 0000000..47f2e73 --- /dev/null +++ b/src/privacy_screen/mode.rs @@ -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 { + 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); + } +} diff --git a/src/privacy_screen/protocol.rs b/src/privacy_screen/protocol.rs new file mode 100644 index 0000000..3ebfb67 --- /dev/null +++ b/src/privacy_screen/protocol.rs @@ -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, requested: u64 } + +pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec, 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 { + 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> { + 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 { + 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) { + 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]); + } +} diff --git a/src/privacy_screen/record.rs b/src/privacy_screen/record.rs new file mode 100644 index 0000000..f4e1be2 --- /dev/null +++ b/src/privacy_screen/record.rs @@ -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> = 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 { 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(&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 { self.saved.then_some(self.record) } +} diff --git a/src/privacy_screen/tool.rs b/src/privacy_screen/tool.rs new file mode 100644 index 0000000..7c23e72 --- /dev/null +++ b/src/privacy_screen/tool.rs @@ -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 { + 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 { + let mut all: Vec = ["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': ` 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': , 'enabled': , 'name': <'AT Translated Set 2 keyboard'>, 'pointer': },)"; + 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); + } +} diff --git a/src/system_actions.rs b/src/system_actions.rs index 443bb9e..a5d992d 100644 --- a/src/system_actions.rs +++ b/src/system_actions.rs @@ -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, #[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option, + /// Last privacy_type the viewer enabled (2 picture, 3 screen off), reported as SettingMetric 7. + #[serde(default)] pub(crate) privacy_type: Option, } fn lenient_string<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result, 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::active(), crate::privacy_screen::preferred_type())), }) } } diff --git a/src/system_metrics.rs b/src/system_metrics.rs index 5648d65..c954840 100644 --- a/src/system_metrics.rs +++ b/src/system_metrics.rs @@ -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<(bool, u8)> } pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec { let mut setting = Vec::new(); + // Mac UURemote name map: SettingMetric 4 private_screen (on), 7 private_screen_type + // (PrivateScreenType 2 normal/picture, 3 enhanced/screen off): the chosen mode, also while off. + if let Some((on, kind)) = settings.private_screen { + setting.extend([4 << 3, u8::from(on), 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); } } diff --git a/src/video.rs b/src/video.rs index 5c549ec..7b7d435 100644 --- a/src/video.rs +++ b/src/video.rs @@ -1201,6 +1201,8 @@ pub async fn stream_desktop_at(pc: Arc, track: Arc, track: Arc { 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; diff --git a/src/webrtc.rs b/src/webrtc.rs index 9b6f44c..659f3f6 100644 --- a/src/webrtc.rs +++ b/src/webrtc.rs @@ -686,7 +686,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(); @@ -1036,6 +1036,26 @@ 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(); + 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); + 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); @@ -1103,7 +1123,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,7 +1142,27 @@ 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(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) { + 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 _ = rpc_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); + 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(|r| crate::privacy_screen::screensaver_response(r).or_else(|| 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)); return;