Compare commits

..
6 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
12 changed files with 573 additions and 4 deletions

No files matched your search

Generated
+1 -1
View File
@@ -2772,7 +2772,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.44" 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.44" 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"]
+9
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`).
@@ -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
+5
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`)。
@@ -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),
未知值会报错,不猜测键码。账号连接缺少平台字段时查询目标设备;远程协助必须由连接响应提供平台。只看模式不需要此识别。 未知值会报错,不猜测键码。账号连接缺少平台字段时查询目标设备;远程协助必须由连接响应提供平台。只看模式不需要此识别。
+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.
+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
@@ -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;
@@ -775,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();
@@ -812,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) => {
+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()); }
}
}