Compare commits

..
10 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 73c503a244 release: v0.2.47
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 01:26:54 +08:00
Jeff ZhangandJeff Zhang 3bce605eaa feat(host): 上报系统壁纸,补齐设备卡片缩略图 (#153)
* feat(host): report system wallpaper for device cards

* fix(host): handle quoted wallpaper paths and KDE defaults

* docs: align wallpaper guidance and disclose default uploads

* fix(host): validate active KDE plugin for stored wallpapers

* fix(host): support Plasma 5 wallpaper config queries

* fix(host): exclude Plasma panels from wallpaper reporting

* fix(host): follow image symlinks in KDE wallpaper packages

---------

Co-authored-by: Jeff Zhang <[email protected]>
2026-11-03 01:25:57 +08:00
VallierDevandClaude Opus 5.5 ebdd362452 release: v0.2.46
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 18:23:23 +08:00
VallierDevandClaude Opus 5.5 26811018e0 fix(clipboard): name the Unicode text offer predefined_13 for Windows viewers
A CF_UNICODETEXT name made the Windows viewer register a custom
clipboard format instead of using id 13, so Linux text never reached
the standard Unicode format. Fixes #151.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 18:23:23 +08:00
VallierDevandClaude Opus 5.5 c3959c01e9 release: v0.2.45
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 13:20:08 +08:00
m ef14f76422 fix(viewer): disable local IME text input in remote desktop window (#150) 2026-11-02 13:18:55 +08:00
VallierDevandClaude Opus 5.5 480819e369 release: v0.2.44
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 11:18:42 +08:00
Jeff Zhang f4f16aafe4 fix(privacy): synchronize Mac viewer privacy status over TEXT (#148)
* fix(privacy): synchronize Mac viewer privacy status over TEXT

* fix(webrtc): bound pending TEXT replies and coalesce metrics
2026-11-02 11:17:55 +08:00
VallierDevandClaude Opus 5.5 cb6f5b6617 release: v0.2.43
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 02:14:37 +08:00
Jeff Zhang 8e30371317 feat(host): KDE Wayland privacy screen (RPC 7) (#146)
* 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
2026-11-02 01:14:10 +08:00
43 changed files with 2046 additions and 68 deletions

No files matched your search

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