Compare commits

..
11 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 5f28047a34 release: v0.2.59
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-14 13:15:56 +08:00
Mr. Error 661263fe37 fix(portal): capture the lock screen on locked cold connections (#229)
* fix(portal): capture the lock screen on locked cold connections

KWin keeps the Portal screencast alive while the session is locked, but maintain() refused to open a session until unlock, so a cold connection only received synthetic black frames. Allow capture during lock on KDE and keep the black-frame fallback for compositors that close the session. A consent failure behind the lock screen and auto privacy now wait for the local unlock.

* docs: document the KDE lock-screen capture default

Cover the new default, the UU_LOCKED_CAPTURE opt-out and the desktop-detection fallback in both READMEs, as requested in #229.
2026-11-14 14:14:42 +09:00
ff2bd9c582 build: copy engine plugins to the profile dir under Cargo's newer build-dir layout (#226)
Rust 1.100 CI places OUT_DIR one level deeper, so ancestors().nth(3) no longer
reached target/<profile> and the release feature-set checks lost libuu-wayland.so.

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-11-13 13:40:01 +09:00
VallierDevandClaude Opus 5.5 0e1e935fb4 release: v0.2.58
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-12 19:20:09 +08:00
Onekkiandzhuwangqi 4649149ff5 viewer: pick a CJK-capable font for the HUD (#219)
The HUD rasterizes text with a single font and has no per-character
fallback. On systems where fontconfig strongly prefers a Latin-only
sans-serif (e.g. Liberation Sans on Omarchy), 'sans-serif:lang=zh-cn'
resolves to a face without Han glyphs and the Chinese labels render as
empty boxes.

Require U+63A7 (控, from 控制中心) in the fc-match pattern so coverage
influences selection while still respecting the system's font families.

Co-authored-by: zhuwangqi <[email protected]>
2026-11-12 18:17:13 +08:00
阿夜 50a7447b7b 使用 logind D-Bus 监听锁屏变化,减少进程轮询和审计噪声 (#218)
* fix: monitor logind lock state over D-Bus instead of spawning loginctl

* docs: add redacted lock-monitor audit evidence and validation

* fix: retain logind subscription without a graphical session
2026-11-12 17:14:51 +08:00
Kitlee0252 890c46e280 test: keep waiting for the listed session's LIST_RESP on the binary channel (#216)
locked_control_unlock_requests_and_tools_work_without_a_video_frame broke
out of its wait loop on the first BINARY_DATA_CHANNEL message and unwrapped
terminal::decode on it. The process-global terminal change watch also sends
the field-28 list-invalidated notification on that channel
(terminal::changed_message, an initialization::envelope with an empty field
28), which is not a TERM frame, so decode returns None. Any concurrently
running test that opens, kills or reconciles a terminal session can
broadcast it inside this test's wait window, and the suite panics at
desktop_control_tests.rs:302.

Skip messages that do not decode and keep waiting until the LIST_RESP of the
session being listed (71, then 72) arrives, following the sibling terminal
test in webrtc_lifecycle_tests.rs. Test-only change.
2026-11-12 13:08:51 +08:00
Xianjie ZhanandClaude Sonnet 5.5 fe052cdca7 wol: send inner_ip when registering as wake helper (#209)
The helper registration (POST /api/v1/device/wake_on_lan/info) was rejected
with HTTP 422 / code 1001, so the cloud reported 'no helper online' and never
forwarded wake_on_lan pushes. The official macOS client sends inner_ip, ip,
mac and subnet_mask; adding inner_ip makes the server accept the helper.

Verified end to end: headless Linux host in Docker on a NAS, UU_WOL_HELPER=1,
official iOS controller. Registration returns 200 / code 0, the cloud pushes
wake_on_lan, the host sends the magic packet and the Windows PC boots.

Co-authored-by: Claude Sonnet 5.5 <[email protected]>
2026-11-09 22:10:47 +08:00
VallierDevandClaude Opus 5.5 b84e6e4543 release: v0.2.57
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 18:48:41 +08:00
Juck Zhang bfbbe2f677 feat: add opt-in controller microphone input (#207)
* feat: add opt-in controller microphone input

* fix: address microphone CI and review feedback
2026-11-09 17:47:07 +08:00
VallierDevandClaude Opus 5.5 f437328ad1 file_trans: reject send_request without a path instead of walking /
Refs #208

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 14:45:18 +08:00
25 changed files with 2378 additions and 67 deletions

No files matched your search

Generated
+342 -2
View File
@@ -172,6 +172,29 @@ dependencies = [
"syn 1.0.109",
]
[[package]]
name = "async-broadcast"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
dependencies = [
"event-listener",
"event-listener-strategy",
"futures-core",
"pin-project-lite",
]
[[package]]
name = "async-recursion"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f8abc12baad266b1c8cec146854c195b5864b4221d4b2ca7296a7ae82d9e451"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]]
name = "async-trait"
version = "0.1.92"
@@ -640,6 +663,33 @@ dependencies = [
"zeroize",
]
[[package]]
name = "endi"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
[[package]]
name = "enumflags2"
version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
dependencies = [
"enumflags2_derive",
"serde",
]
[[package]]
name = "enumflags2_derive"
version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]]
name = "env_filter"
version = "2.0.0"
@@ -663,6 +713,12 @@ dependencies = [
"log",
]
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]]
name = "errno"
version = "0.3.14"
@@ -673,6 +729,32 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "event-listener"
version = "5.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"
dependencies = [
"parking",
"pin-project-lite",
]
[[package]]
name = "event-listener-strategy"
version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
dependencies = [
"event-listener",
"pin-project-lite",
]
[[package]]
name = "fastrand"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
[[package]]
name = "fdeflate"
version = "0.3.7"
@@ -797,6 +879,19 @@ version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
[[package]]
name = "futures-lite"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
dependencies = [
"fastrand",
"futures-core",
"futures-io",
"parking",
"pin-project-lite",
]
[[package]]
name = "futures-macro"
version = "0.3.34"
@@ -912,6 +1007,12 @@ dependencies = [
"subtle",
]
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
[[package]]
name = "hermit-abi"
version = "0.5.3"
@@ -1145,6 +1246,16 @@ dependencies = [
"icu_properties",
]
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
]
[[package]]
name = "inout"
version = "0.1.4"
@@ -1326,6 +1437,15 @@ dependencies = [
"autocfg",
]
[[package]]
name = "memoffset"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
dependencies = [
"autocfg",
]
[[package]]
name = "minimal-lexical"
version = "0.2.1"
@@ -1372,7 +1492,7 @@ dependencies = [
"bitflags 1.3.2",
"cfg-if",
"libc",
"memoffset",
"memoffset 0.7.1",
"pin-utils",
]
@@ -1475,6 +1595,16 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
[[package]]
name = "ordered-stream"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
dependencies = [
"futures-core",
"pin-project-lite",
]
[[package]]
name = "owned_ttf_parser"
version = "0.25.1"
@@ -1508,6 +1638,12 @@ dependencies = [
"sha2",
]
[[package]]
name = "parking"
version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
[[package]]
name = "parking_lot"
version = "0.12.5"
@@ -1663,6 +1799,15 @@ dependencies = [
"elliptic-curve",
]
[[package]]
name = "proc-macro-crate"
version = "3.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
dependencies = [
"toml_edit",
]
[[package]]
name = "proc-macro2"
version = "1.0.107"
@@ -2229,6 +2374,17 @@ dependencies = [
"zmij",
]
[[package]]
name = "serde_repr"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
@@ -2463,6 +2619,19 @@ dependencies = [
"syn 3.0.9",
]
[[package]]
name = "tempfile"
version = "3.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"once_cell",
"rustix",
"windows-sys 0.61.2",
]
[[package]]
name = "thiserror"
version = "1.0.69"
@@ -2563,6 +2732,7 @@ dependencies = [
"signal-hook-registry",
"socket2 0.6.5",
"tokio-macros",
"tracing",
"windows-sys 0.61.2",
]
@@ -2616,6 +2786,36 @@ dependencies = [
"tokio",
]
[[package]]
name = "toml_datetime"
version = "1.1.3+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "173f25c883cd2176a2d8212155638c0a60d484a9d84546d270866f40f56b6e49"
dependencies = [
"serde_core",
]
[[package]]
name = "toml_edit"
version = "0.25.19+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd43688c4858d7264ae1cf9a9f874a67c3feb74a883b1cd7bebd6a4ea8307218"
dependencies = [
"indexmap",
"toml_datetime",
"toml_parser",
"winnow",
]
[[package]]
name = "toml_parser"
version = "1.1.5+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c"
dependencies = [
"winnow",
]
[[package]]
name = "tower"
version = "0.5.3"
@@ -2668,9 +2868,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
dependencies = [
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-attributes"
version = "0.1.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]]
name = "tracing-core"
version = "0.1.36"
@@ -2738,6 +2950,17 @@ version = "1.20.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
[[package]]
name = "uds_windows"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
dependencies = [
"memoffset 0.9.1",
"tempfile",
"windows-sys 0.61.2",
]
[[package]]
name = "unicode-ident"
version = "1.0.27"
@@ -2804,7 +3027,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.2.56"
version = "0.2.59"
dependencies = [
"ab_glyph",
"async-trait",
@@ -2834,6 +3057,7 @@ dependencies = [
"tokio-tungstenite",
"webrtc",
"x11rb",
"zbus",
]
[[package]]
@@ -2844,6 +3068,7 @@ checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606"
dependencies = [
"getrandom 0.4.3",
"js-sys",
"serde_core",
"wasm-bindgen",
]
@@ -3291,6 +3516,15 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "winnow"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef"
dependencies = [
"memchr",
]
[[package]]
name = "writeable"
version = "0.6.4"
@@ -3378,6 +3612,71 @@ dependencies = [
"synstructure 0.14.0",
]
[[package]]
name = "zbus"
version = "5.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907"
dependencies = [
"async-broadcast",
"async-recursion",
"async-trait",
"enumflags2",
"event-listener",
"futures-core",
"futures-lite",
"hex",
"libc",
"ordered-stream",
"rustix",
"serde",
"serde_repr",
"tokio",
"tracing",
"uds_windows",
"uuid",
"windows-sys 0.61.2",
"winnow",
"zbus_macros",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus_macros"
version = "5.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 3.0.9",
"zbus_names",
"zvariant",
"zvariant_utils",
]
[[package]]
name = "zbus_names"
version = "4.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "812a12be4ead7a59e18ea8f047d08add0066b73bc62fc1467066a2472ae088dd"
dependencies = [
"serde",
"winnow",
"zvariant",
]
[[package]]
name = "zcheapstr"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "939f186d9ecebe044315a5cb6d6f78568bbc21152adc954d5a0c2f58bdbc9920"
dependencies = [
"serde",
]
[[package]]
name = "zerocopy"
version = "0.8.62"
@@ -3483,3 +3782,44 @@ name = "zmij"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
[[package]]
name = "zvariant"
version = "5.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80bf6d6cd6a4b601acb64cfb8284cdc643fcfa75ef26ae3c46ec8aa4e8a1fbb7"
dependencies = [
"endi",
"enumflags2",
"serde",
"winnow",
"zcheapstr",
"zvariant_derive",
"zvariant_utils",
]
[[package]]
name = "zvariant_derive"
version = "5.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef2672456ba1cb54b5eaec136e63135b3c7495fb938e53b28a62e633496d486d"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 3.0.9",
"zvariant_utils",
]
[[package]]
name = "zvariant_utils"
version = "4.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3"
dependencies = [
"proc-macro2",
"quote",
"serde",
"syn 3.0.9",
"winnow",
]
+2 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.2.56"
version = "0.2.59"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
@@ -38,6 +38,7 @@ inproc-av = ["dep:x11rb"]
tokio = { version = "1", features = ["full"] }
tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] }
futures-util = "0.3"
zbus = { version = "5", default-features = false, features = ["tokio"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] }
+7 -3
View File
@@ -126,7 +126,11 @@ GNOME Portal CONTROL no longer waits for a consent dialog or the first video fra
The host also accepts a desktop connection while GNOME is locked with no Portal session yet (a cold connection): it reports lock state and accepts auto unlock, then restores picture, input and clipboard after unlock. While Portal is pending, the host sends generated black video once per second on the negotiated track by default, allowing the official iPhone viewer to enter its auto-unlock flow without extra configuration. Verified on Ubuntu GNOME Wayland with the official Mac viewer; iPhone 4.42.0 with H.265 completed a same-executable control experiment: black video ON succeeded, OFF failed, and ON succeeded again ([#29](../../issues/29)). **Limitation**: this is synthetic black video, not the GNOME lock screen, and it does not enable native mouse/keyboard input while locked. Enable 「自动解锁被控端」 in the UU client under 控制中心 → 安全 and enter the password. Without saved Portal permission, local consent is still required after unlock before the real desktop can appear.
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Desktop input is blocked and real video is hidden while locked or when lock state is unknown. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path.
On KDE Plasma (KWin), the Portal screencast stays alive after the session locks. The host now opens capture while locked by default, so a cold connection shows the real lock screen and the password can be entered with the remote keyboard instead of receiving black video ([#227](../../issues/227), [#229](../../pull/229)). Set `UU_LOCKED_CAPTURE=0` to disable this and return to the black-video and auto-unlock path. Detection requires `XDG_CURRENT_DESKTOP` or `XDG_SESSION_DESKTOP` in the systemd user environment. Without either the host falls back to black video, and `UU_LOCKED_CAPTURE=1` forces the new behavior. Portal pointer input remains blocked while locked, and the keyboard uses uinput and can enter the password. This does not apply to GNOME: Mutter closes the Portal session on lock, so the black-video and auto-unlock behavior above is unchanged.
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Portal input is blocked while locked. KDE keeps sending the real lock screen, while GNOME hides real video and uses black video. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path.
Lock monitoring reads logind `LockedHint` over the system D-Bus and subscribes to changes instead of spawning `loginctl` every second. Without a graphical session it stays subscribed with unknown state, so login signals trigger a fresh read. It reconciles the session over D-Bus every 30 seconds; if D-Bus fails, it retries with a bounded `loginctl` fallback every 30 seconds, resolving the executable path once. Notifications may be delayed during fallback; unreadable state remains unknown. The locker must still report its state to logind. Suspend, locking and remote connection policies are unchanged.
Locked black video requires FFmpeg's libx264/libx265 encoder for the negotiated H.264/H.265 codec; hardware encoding support alone does not satisfy this dependency. Encoder failures are logged explicitly. Synthetic video does not change capture permissions or advertised monitor dimensions. It pauses on unlock or unknown lock state, ends when capture is ready/rejected or the connection closes, and then hands the same video track to real capture. See [#29](../../issues/29) and [#34](../../pull/34) for the controlled experiment and validation scope.
@@ -161,7 +165,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
| HDR | Not implemented |
| Super screen / virtual display | 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; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; 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) | Experimental: Opus to a virtual input with `UU_MICROPHONE=1`; supports PulseAudio / PipeWire-pulse, see [notes](docs/remote-microphone.md) |
| 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 |
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
@@ -405,7 +409,7 @@ Common environment variables:
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing |
| `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) |
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (not verified end to end) |
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (verified end to end with a headless Linux host on a NAS and the official iOS controller) |
| `UU_USE_PROXY=1` | Share environment HTTP/HTTPS proxy policy between REST and host/viewer WebSocket signaling; proxies are ignored by default |
+7 -3
View File
@@ -112,7 +112,11 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
桌面锁屏且尚未建立 Portal 时(冷连接),主机也会建立控制通道:上报锁屏状态并接受自动解锁,解锁后再恢复画面、键鼠和剪贴板。Portal 等待就绪期间,主机默认通过已协商的视频轨每秒发送一帧生成的纯黑画面,让官方 iPhone 客户端进入自动解锁流程,无需额外配置。Ubuntu GNOME Wayland 上已用官方 Mac 客户端验证;iPhone 4.42.0 的 H.265 冷连接完成了同一实验二进制「开启黑帧成功 → 关闭失败 → 再开成功」对照([#29](../../issues/29))。**局限**:黑帧不是真实 GNOME 锁屏画面,也不支持在锁屏界面操作原生键鼠;需要在 UU 客户端 控制中心 → 安全 → 自动解锁被控端 中启用自动解锁并输入密码。若本机没有已保存的 Portal 授权,解锁后仍需本机确认授权才能显示真实桌面。
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏及锁状态未知时停止桌面输入并隐藏真实画面;独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。
KDE Plasma(KWin)的 Portal 采集在锁屏后仍会继续。主机默认在锁屏时也打开采集,冷连接可以直接看到真实锁屏界面,并用远程键盘输入密码,不再只发黑帧([#227](../../issues/227)、[#229](../../pull/229))。`UU_LOCKED_CAPTURE=0` 关闭这一行为,回到黑帧和自动解锁的路径。KDE 判断依赖 systemd 用户环境里的 `XDG_CURRENT_DESKTOP` 或 `XDG_SESSION_DESKTOP`,两者都没有时回落到黑帧行为,可以手动设 `UU_LOCKED_CAPTURE=1` 开启。锁屏时 Portal 指针输入仍会被拦截,键盘通过 uinput 注入,可以输入密码。GNOME 不适用这一段,Mutter 在锁屏时关闭 Portal 会话,仍走上面的黑帧和自动解锁。
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏时停止 Portal 输入。KDE 下继续传输真实锁屏画面,GNOME 下隐藏真实画面并发黑帧。独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。
锁屏状态优先通过系统 D-Bus 读取 logind 的 `LockedHint` 并监听变化,正常监测不按秒启动 `loginctl`。尚无图形会话时保持未知并继续监听,登录后由信号触发重新读取。每 30 秒通过 D-Bus 校验会话;D-Bus 异常时每 30 秒重试并使用带超时的 `loginctl` 回退查询,命令路径只解析一次。回退期间状态通知可能延迟;无法读取时保持未知。锁屏程序仍需正确上报 logind 状态,这不改变睡眠、锁屏或远程连接策略。
锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。
@@ -142,7 +146,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
| HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
| 麦克风(控制端声音传到被控端) | 实验性:Opus → 虚拟麦克风,需 `UU_MICROPHONE=1`;支持 PulseAudio / PipeWire-pulse,见 [说明](docs/remote-microphone.md) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
@@ -368,7 +372,7 @@ systemctl --user restart uuremote-native.service
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(已在 NAS 上的无头 Linux 主机配合官方 iOS 控制端实测可远程开机) |
| `UU_USE_PROXY=1` | REST API 与 host/viewer WebSocket 信令共用环境 HTTP/HTTPS 代理策略;默认忽略代理、直连 |
+7 -2
View File
@@ -173,6 +173,11 @@ fn shared_engine(name: &str, sources: &[&str], includes: &[&std::path::Path], cf
command.args(cflags.split_whitespace()).args(sources).args(libs.split_whitespace()).arg("-lpthread");
let status = command.status().expect("C compiler for the engine plugin");
assert!(status.success(), "building {name} failed");
// OUT_DIR = target/<profile>/build/<package>-<hash>/out
if let Some(profile) = out.ancestors().nth(3) { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); }
// OUT_DIR = target/<profile>/build/<package>-<hash>/out, or target/<profile>/build/<package>/<hash>/out with
// the newer Cargo build-dir layout (Rust 1.100 CI): the profile dir is the parent of the `build` component.
let profile = out.ancestors().find(|dir| dir.file_name().is_some_and(|n| n == "build")).and_then(|dir| dir.parent());
match profile {
Some(profile) => { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); }
None => println!("cargo:warning={name} built in {} but no target/<profile> dir found to copy it to", out.display()),
}
}
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Run the opt-in microphone sink-loss regression on a private PulseAudio daemon.
No hardware modules or default configuration are loaded. The Rust test generates
audio in memory and observes only its own null sinks. Requires pactl and parec.
在独立 PulseAudio 服务中运行麦克风回归;仅使用空设备及内存生成音,需要 pactl、parec。
"""
import argparse
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import time
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--daemon", default=shutil.which("pulseaudio"), help="PulseAudio 可执行文件 / PulseAudio executable")
parser.add_argument("--module-dir", help="解压包的模块目录 / module directory for an unpacked package")
parser.add_argument("--test-binary", help="已有 Cargo 测试程序;默认构建 / existing Cargo test executable; otherwise build")
parser.add_argument("--smoke", action="store_true", help="验证生成音传输 / check generated audio delivery instead of target loss")
args = parser.parse_args()
if not args.daemon:
parser.error("请用 --daemon 指定 PulseAudio,无需系统服务 / provide --daemon; no system service is needed")
repo = Path(__file__).resolve().parent.parent
with tempfile.TemporaryDirectory(prefix="uu-microphone-test-") as temp:
private = Path(temp)
for name in ["runtime", "state", "config", "cache"]:
(private / name).mkdir(mode=0o700)
cookie = private / "cookie"
cookie.write_bytes(os.urandom(256))
socket = private / "runtime/native"
env = os.environ.copy()
env.update(
XDG_RUNTIME_DIR=str(private / "runtime"), XDG_CONFIG_HOME=str(private / "config"),
XDG_STATE_HOME=str(private / "state"), XDG_CACHE_HOME=str(private / "cache"),
PULSE_RUNTIME_PATH=str(private / "runtime"), PULSE_STATE_PATH=str(private / "state"),
PULSE_COOKIE=str(cookie), PULSE_SERVER="unix:" + str(socket), UU_MICROPHONE_ISOLATED_TEST="1",
UU_MICROPHONE="1",
)
command = [args.daemon, "-n", "--daemonize=no", "--use-pid-file=no", "--exit-idle-time=-1",
"--disable-shm=yes", "--realtime=no", "--high-priority=no",
"--load=module-native-protocol-unix socket=" + str(socket)
+ " auth-anonymous=1 auth-cookie=" + str(cookie)]
if args.module_dir:
command.append("--dl-search-path=" + args.module_dir)
with (private / "daemon.log").open("w") as log:
daemon = subprocess.Popen(command, env=env, stdout=log, stderr=log)
try:
for _ in range(100):
if daemon.poll() is not None:
raise RuntimeError("独立服务启动失败 / isolated server failed:\n" + (private / "daemon.log").read_text()[-2000:])
if socket.exists() and subprocess.run(
["pactl", "--server=" + env["PULSE_SERVER"], "info"], env=env,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
).returncode == 0:
break
time.sleep(0.03)
else:
raise RuntimeError("独立 PulseAudio 未就绪 / isolated PulseAudio did not become ready")
test = "microphone::tests::pulse_target_loss_never_routes_to_default_output"
if args.smoke:
test = "microphone::tests::pipewire_virtual_microphone_receives_generated_tone"
if args.test_binary:
command = [str(Path(args.test_binary).resolve()), test, "--ignored", "--exact"]
else:
command = ["cargo", "test", "--locked", "--bin", "uuremote-server", test,
"--", "--ignored", "--exact"]
listing = subprocess.run(command + ["--list", "--color=never"], cwd=repo, env=env,
capture_output=True, text=True)
if listing.returncode:
print(listing.stderr, file=sys.stderr)
return listing.returncode
if f"{test}: test" not in listing.stdout.splitlines():
parser.error("目标测试不存在,拒绝零项成功 / requested test is absent; refusing a zero-test success")
return subprocess.run(command, cwd=repo, env=env).returncode
finally:
if daemon.poll() is None:
daemon.terminate()
try:
daemon.wait(timeout=3)
except subprocess.TimeoutExpired:
daemon.kill()
daemon.wait()
if __name__ == "__main__":
raise SystemExit(main())
+17
View File
@@ -0,0 +1,17 @@
功能与修复版:可选控制端麦克风输入、文件传输空路径防护。/ Feature and fix release: opt-in controller microphone, file-transfer empty-path guard.
### 新增 / Added
- **控制端麦克风输入(实验性,默认关闭,#207)**:设置 `UU_MICROPHONE=1` 后,主机通过已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,并提供独立虚拟麦克风 **UU-远程麦克风**(`uu-remote-microphone`),不修改系统默认输入输出。需要 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0`、`libpulse.so.0` 与 `pactl`;详见 `docs/remote-microphone.md`。/ With `UU_MICROPHONE=1` the host receives the viewer's Opus track over the authenticated desktop WebRTC connection and exposes a dedicated virtual microphone, leaving system defaults untouched. See `docs/remote-microphone.md`.
### 修复 / Fixed
- **文件传输空路径(#208)**:不带路径的 `send_request` 现在返回协议错误,不再从根目录遍历。/ A `send_request` without a path now returns a protocol error instead of walking `/`.
感谢 @JuckZ 的贡献。/ Thanks to @JuckZ.
### 验证范围 / Validation
单元测试与 CI;维护方未做麦克风实机验收。Windows 4.44.1 新下载流程与端口映射(#208)仍未支持。
### 下载 / Download
`uu-remote-linux_0.2.57_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.57-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.57`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复版:唤醒助手注册、锁屏监测改用 logind D-Bus、HUD 中文字体。/ Fix release: wake-helper registration, logind D-Bus lock monitoring, CJK HUD font.
### 修复 / Fixed
- **网络唤醒助手注册(#209)**:注册唤醒助手时补发 `inner_ip`,云端不再以 422 拒绝,`UU_WOL_HELPER=1` 的主机可以接收唤醒推送并发送魔术包。/ The wake helper registration now sends `inner_ip`, so the cloud accepts it and forwards wake-on-LAN pushes.
- **锁屏监测(#217、#218)**:改为通过 D-Bus 订阅 logind `LockedHint`,不再每秒启动 `loginctl`,减少进程轮询与审计日志噪声;无图形会话时保持订阅、不阻塞启动。/ Lock state is now watched via logind D-Bus `LockedHint` instead of spawning `loginctl` every second.
- **HUD 中文显示(#219)**:HUD 字体选择优先含汉字的字体,修复部分系统(如 Omarchy)HUD 中文显示为方框。/ The HUD prefers a CJK-capable font, fixing tofu boxes on some systems.
感谢 @enrzh、@AYssu、@Onekki 的贡献。/ Thanks to @enrzh, @AYssu and @Onekki.
### 验证范围 / Validation
单元测试与 CI;#209 由贡献者端到端实测(iOS 控制端唤醒 Windows PC)。维护方未做锁屏监测与 HUD 字体实机验收。
### 下载 / Download
`uu-remote-linux_0.2.58_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.58-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.58`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
修复版:KDE 锁屏冷连接显示真实锁屏界面、适配 Cargo 新 build-dir 布局。/ Fix release: real lock screen on KDE locked cold connections, Cargo build-dir layout fix.
### 修复 / Fixed
- **KDE 锁屏冷连接(#227、#229)**:KDE Plasma(KWin)锁屏后 Portal 采集仍可用,主机默认在锁屏时也打开采集,冷连接直接看到真实锁屏界面并可用远程键盘输入密码,不再停在「正在传输画面」;`UU_LOCKED_CAPTURE=0` 关闭,`UU_LOCKED_CAPTURE=1` 在无法识别桌面时强制开启。GNOME 行为不变。/ On KDE Plasma the host now keeps Portal capture open while locked, so a cold connection shows the real lock screen; `UU_LOCKED_CAPTURE=0` disables it. GNOME is unchanged.
- **源码构建(#226)**:适配 Cargo 新的 build-dir 布局,引擎插件复制到 profile 目录。/ Engine plugins are copied to the profile directory under Cargo's newer build-dir layout.
感谢 @RiverOnVenus 的贡献。/ Thanks to @RiverOnVenus.
### 验证范围 / Validation
单元测试与 CI;#229 由贡献者在 Plasma 6.8.2 + 官方 Windows 控制端实测锁屏冷连接与远程键盘解锁。维护方未做 KDE 实机验收。
### 下载 / Download
`uu-remote-linux_0.2.59_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.59-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.59`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+79
View File
@@ -0,0 +1,79 @@
# Remote microphone / 控制端麦克风(实验性)
Opt-in controller-to-host Opus audio uses the existing authenticated desktop WebRTC connection and exposes a dedicated virtual microphone to Linux applications.
可选功能:通过原有、已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,为 Linux 应用提供独立虚拟麦克风。
## Enable / 启用
Requires Linux, running PipeWire-pulse or PulseAudio 13+, the `libopus.so.0` / `libpulse.so.0` runtimes, and `pactl`. Debian/Ubuntu: install `libopus0 pulseaudio-utils`; Arch: install `opus libpulse`. No administrator privileges or additional network listener are needed at runtime. Both libraries are loaded only when requested; ordinary builds need no PulseAudio or Opus development package or extra link-time dependency.
需要 Linux、已运行的 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0` / `libpulse.so.0` 和 `pactl`。Debian/Ubuntu 对应 `libopus0 pulseaudio-utils`;Arch 对应 `opus libpulse`。运行时无需管理员权限,也不新增监听端口;普通构建无需安装 PulseAudio、Opus 开发包或增加链接依赖。
```ini
# ~/.config/systemd/user/uuremote-native.service.d/microphone.conf
[Service]
Environment=UU_MICROPHONE=1
```
```sh
systemctl --user daemon-reload
systemctl --user restart uuremote-native.service
```
The host creates the input device **UU-Remote-Microphone** (`uu-remote-microphone`) and a private backing sink (`uu-remote-mic-input`). In the application that should receive your voice, select UU-Remote-Microphone as its input. This patch does not change the system default input or output device. The backing sink is an audio destination for the decoder; it is not the device to select as an application microphone.
被控端会出现 **UU-远程麦克风** 输入设备(英文界面显示 **UU-Remote-Microphone**)。在需要使用麦克风的应用中选择这个输入。设备与音频流的显示名称跟随被控端语言,技术名称 `uu-remote-microphone`、`uu-remote-mic-input` 不变。补丁不修改系统默认输入、输出;底层的 `uu-remote-mic-input` 是解码器内部输出目标,不是应用应选择的麦克风。
Device and stream display labels follow the host language; the technical sink/source identifiers stay unchanged.
Enable the controller's microphone in the official UU client. The host completes VirtualAudioDriverPolicyRequest (RpcRequest field 21) using RpcResponse field 17 with a correctly encoded two-byte tag. It commits the reception gate and queues its reply/notification as one ordered transition before any network send can block. CONTROL and TEXT callbacks share the same transition lock, so a stalled open reply cannot overwrite a later close. Reception starts closed; connecting alone does not request capture. Opus is decoded at 48 kHz stereo and written through libpulse with PA_STREAM_DONT_MOVE, preventing rescue to a physical output on either supported audio server. A disconnected or superseded desktop drops queued audio and closes playback. Tool-only peers cannot inject microphone audio. A new incoming track replaces the previous track of the same peer.
在官方控制端中开启麦克风。被控端通过正确编码的 RPC 响应确认虚拟声卡策略;接收开关和回复、通知的排队操作使用统一的状态锁,均在网络发送之前完成,避免拥塞时旧开麦请求覆盖后到的关麦。接收初始为关闭,单纯建立远控连接不会主动要求采集。Opus 解码为 48 kHz 双声道,通过 libpulse 的禁止迁移标志仅写入虚拟麦克风,两个支持的音频后端均不会在目标丢失后转向物理输出。断开或桌面会话被替换时清空待播放内容并停止播放;文件、终端等非桌面连接不接收麦克风。
If an external tool removes the virtual endpoints, or the audio server restarts, reception stops. Restart the host to recreate its endpoints.
如果外部工具删除了虚拟设备,或音频服务重启,接收会停止。重启被控端服务可重新创建设备。
No microphone audio is logged, saved or played through physical speakers by this receiver. Applications consuming the virtual input retain their own behavior. A 40 ms initial jitter window and a maximum 12-packet queue limit backlog. RTP timestamps determine missing audio duration for Opus loss concealment, including variable-duration packets and sequence/timestamp rollover. Each track claims a unique generation before its worker is spawned; a superseded worker checks that generation before processing audio.
接收器不记录、保存麦克风音频,也不将它播放到物理扬声器。读取虚拟输入的应用仍按各自设置工作。初始抖动缓冲为 40 毫秒,队列最多 12 包;根据 RTP 时间戳推导缺失音频时长后进行 Opus 补偿,支持可变包长与序号、时间戳回绕。新音轨在启动接收任务前取得唯一归属编号,旧任务处理音频前会核验该编号。
The endpoint lock lives in a private per-user directory under `/tmp`, independently of `UU_CONFIG`, `XDG_RUNTIME_DIR` and `TMPDIR`. Recovery requires an exact match of module kind and arguments, including the remap source's master. Cleanup checks the module id and arguments again before unloading, and the route is released on ordinary error returns as well as shutdown.
设备锁位于 `/tmp` 下的用户私有目录,不随配置目录、`XDG_RUNTIME_DIR` 或 `TMPDIR` 变化。恢复设备时严格匹配模块类型及全部参数,包括虚拟输入的 master;清理前再次核验模块编号及参数。常规错误返回与正常关闭都会释放设备。
Native PulseAudio uses its `norewinds` null-sink option to avoid the default two-second idle buffer on first playback. This Pulse-only option is not passed to PipeWire. Unsupported older PulseAudio servers leave the opt-in microphone disabled.
原生 PulseAudio 使用空设备的 `norewinds` 选项,避免首次播放时的默认两秒空闲缓冲;不向 PipeWire 传递这个专用参数。较旧、不受支持的 PulseAudio 不会启用麦克风。
## Validation / 验证
Opus-dependent unit tests print a skip diagnostic when `libopus.so.0` is unavailable, so default tests still pass without this optional runtime. CI's `inproc-av` jobs install libopus and exercise these tests. The explicitly requested audio-server smoke tests require the runtime and fail if it is missing.
缺少可选的 `libopus.so.0` 时,依赖 Opus 的单元测试会输出跳过说明,默认测试仍能通过。CI 的 `inproc-av` 任务安装 libopus 并实际运行这些测试;显式启用的音频服务真机测试需要该运行库,缺少时会失败。
```sh
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins microphone::tests
# Real audio-server smoke test: independent test endpoints, generated audio only, in memory.
UU_MICROPHONE=1 \
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins \
microphone::tests::pipewire_virtual_microphone_receives_generated_tone -- --ignored --exact
```
The smoke test creates process-specific sink/source names, plays and captures only through those endpoints, waits for its playback task to end before removing them, and never reuses the host's microphone. A separate config file alone does not isolate audio resources. Unit tests cover cross-process locking, module ownership, concurrent track claims, 10/20/40/60 ms loss, mixed-duration gaps, clock rollover, WebRTC track replacement, and CONTROL/TEXT ordering under send congestion. Earlier controller acceptance passed with Windows 4.44.0.3919 on CachyOS using the previous receiver backend. The native playback backend is checked separately with generated audio; Windows acceptance has not been repeated after that backend change.
真机测试使用进程专属的虚拟输入、输出名称,仅在测试设备之间播放和采集,等播放任务结束后再删除设备,不复用正式服务的麦克风。单独更换配置文件不能隔离音频资源。回归测试覆盖跨进程锁、模块归属、并发音轨、10/20/40/60 毫秒包的丢包、混合时长缺口、时钟回绕、WebRTC 音轨替换及拥塞时的 CONTROL/TEXT 顺序。之前的接收后端已用 Windows 4.44.0.3919 在 CachyOS 实机通过控制端验收;原生播放后端另用生成音验证,更换后尚未重复 Windows 实机验收。
An optional native PulseAudio check starts a private server with no hardware modules. It first confirms sustained generated audio, then verifies that removing its playback target closes the stream and leaves the default null sink silent. Use `--smoke` to check audio delivery alone. The wrapper verifies that the named test exists before running it, so an old `--test-binary` cannot silently pass with zero tests. It needs a PulseAudio executable; `--daemon` and `--module-dir` also support unpacked packages. It does not start or modify a system service.
可选的原生 PulseAudio 检查会启动不加载硬件模块的独立服务,先确认持续生成音正常,再验证播放目标消失后音频流关闭、默认空设备保持静音;`--smoke` 仅验证生成音传输。脚本会检查目标测试存在,旧 `--test-binary` 不会以零项测试误报成功。需要 PulseAudio 可执行文件,`--daemon`、`--module-dir` 也支持解压后的程序包,不启动或修改系统服务。
```sh
python3 contrib/check-microphone-pulse.py
python3 contrib/check-microphone-pulse.py --smoke
```
To disable, remove `microphone.conf`, reload the user manager and restart the host. The virtual endpoints are removed on normal shutdown. After a crash, the next enabled run reuses only the exact tagged modules created by this receiver.
停用时删除 `microphone.conf`,重新加载并重启用户服务。正常退出会删除虚拟设备;异常退出后,下次启用仅复用本接收器创建并标记的同名模块。
+20 -2
View File
@@ -243,7 +243,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); }
if channel != "BINARY_DATA_CHANNEL" {
continue;
}
// The process-global terminal change watch also broadcasts the field-28
// list-invalidated notification here, which is not a TERM frame.
if let Some(frame) = crate::terminal::decode(&message) {
if frame.kind == crate::terminal::LIST_RESP && frame.session == 71 {
break frame;
}
}
}
}).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71));
@@ -299,7 +308,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); }
if channel != "BINARY_DATA_CHANNEL" {
continue;
}
// The process-global terminal change watch also broadcasts the field-28
// list-invalidated notification here, which is not a TERM frame.
if let Some(frame) = crate::terminal::decode(&message) {
if frame.kind == crate::terminal::LIST_RESP && frame.session == 72 {
break frame;
}
}
}
}).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72));
+199 -25
View File
@@ -1,6 +1,6 @@
//! Portal availability is independent of the authenticated CONTROL transport.
use std::future::Future;
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
use std::sync::{Arc, OnceLock, atomic::{AtomicBool, Ordering}};
use std::time::Instant;
use tokio::sync::{watch, Mutex};
use crate::{capture::ScreenCapture, input::DesktopInputSession};
@@ -29,6 +29,7 @@ pub struct PortalDesktop {
state: watch::Sender<State>,
opening: Arc<Mutex<()>>,
locked: watch::Receiver<Option<bool>>,
capture_while_locked: bool,
}
struct CancelOnDrop(Arc<AtomicBool>);
@@ -71,6 +72,7 @@ enum AttemptOutcome {
Ready(Arc<ScreenCapture>),
Retry(String),
Terminal(String),
Deferred,
Cancelled,
}
@@ -85,14 +87,52 @@ fn classify(result: Result<Arc<ScreenCapture>, PortalError>) -> AttemptOutcome {
}
}
/// A consent dialog opened behind the lock screen cannot be approved, so its denied/timed-out
/// error must not end this connection's supervisor: ask again after the local unlock.
fn defer_consent(error: &PortalError, state: Option<bool>) -> bool {
state == Some(true) && matches!(error.code, 4 | 5)
}
/// True when this iteration sees a lock state it has not attempted under yet. Waking and resetting
/// the retry delay must happen once per transition, not once per 200 ms poll: a locked state would
/// otherwise re-run wake, inhibitor and publish on every tick and defeat the 5 s retry backoff.
fn fresh_state(previous: Option<Option<bool>>, state: Option<bool>) -> bool {
previous != Some(state)
}
fn should_prepare_power(healthy: bool, force_wake: bool) -> bool {
!healthy || force_wake
}
/// KWin keeps the Portal screencast, including the lock screen, alive while the session is
/// locked, so a cold connection can show the real lock screen. Mutter closes the session on
/// lock, so other desktops keep the existing black-frame path. `UU_LOCKED_CAPTURE=0` opts out.
fn capture_while_locked() -> bool {
static ENABLED: OnceLock<bool> = OnceLock::new();
*ENABLED.get_or_init(|| {
match std::env::var("UU_LOCKED_CAPTURE").ok().filter(|value| !value.is_empty()) {
Some(value) => !matches!(value.to_ascii_lowercase().as_str(), "0" | "off" | "false" | "no"),
None => ["XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP"].iter().any(|key|
std::env::var(key).is_ok_and(|desktop| desktop.split(':')
.any(|part| part.eq_ignore_ascii_case("KDE")))),
}
})
}
/// Capture may start and continue in this lock state. An unknown state keeps the old wait on
/// desktops whose compositor closes the session on lock.
fn attempt_allowed(state: Option<bool>, capture_while_locked: bool) -> bool {
match state {
Some(false) => true,
Some(true) | None => capture_while_locked,
}
}
fn prepare_attempt<W, I>(
cancelled: &AtomicBool,
owner: &DesktopInputSession,
locked: &watch::Receiver<Option<bool>>,
allow_locked: bool,
wake: W,
inhibit: I,
) -> Option<AttemptPrep>
@@ -102,7 +142,7 @@ where
{
let current = || !cancelled.load(Ordering::Acquire)
&& owner.is_current()
&& *locked.borrow() == Some(false);
&& attempt_allowed(*locked.borrow(), allow_locked);
if !current() { return None; }
let wake = wake();
if !current() { return None; }
@@ -114,7 +154,8 @@ where
impl PortalDesktop {
pub fn new(screen: Arc<ScreenCapture>) -> Self {
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked() }
opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked(),
capture_while_locked: capture_while_locked() }
}
pub fn begin(&self) {
// GNOME closes the Portal session on lock; a cached screen with a dead session
@@ -133,10 +174,21 @@ impl PortalDesktop {
}
pub fn subscribe(&self) -> watch::Receiver<State> { self.state.subscribe() }
pub fn lock_state(&self) -> watch::Receiver<Option<bool>> { self.locked.clone() }
/// Whether capture may run in this lock state for this desktop. Shares the rule used by
/// maintain(), so capture-setting requests do not stall behind a lock the compositor does
/// not honor.
pub fn capture_allowed(&self, locked: Option<bool>) -> bool {
attempt_allowed(locked, self.capture_while_locked)
}
#[cfg(test)]
pub fn with_lock_state(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>) -> Self {
Self::with_lock_state_and_capture(screen, locked, false)
}
#[cfg(test)]
pub fn with_lock_state_and_capture(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>,
capture_while_locked: bool) -> Self {
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
opening: Arc::new(Mutex::new(())), locked }
opening: Arc::new(Mutex::new(())), locked, capture_while_locked }
}
#[cfg(test)]
pub fn publish_test_screen(&self, screen: Arc<ScreenCapture>) {
@@ -204,22 +256,27 @@ impl PortalDesktop {
let inhibit = Arc::new(inhibit);
let open = Arc::new(open);
let mut locked = self.locked.clone();
let mut previous = None;
let allow_locked = self.capture_while_locked;
let mut previous: Option<Option<bool>> = None;
let mut defer_until_unlock = false;
let mut retry_at = Instant::now();
loop {
if !owner.is_current() { return Ok(()); }
let state = *locked.borrow_and_update();
if state != Some(false) {
if previous == Some(false) { self.pause(&owner); }
} else {
// A fresh unlocked transition gets an immediate wake/recovery attempt.
let force_wake = previous != Some(false);
if state == Some(false) { defer_until_unlock = false; }
if state != Some(false) && previous == Some(Some(false)) { self.pause(&owner); }
if state == Some(true) && previous != Some(Some(true)) && allow_locked {
log::info!("Desktop is locked; opening Portal capture for the lock screen");
}
if attempt_allowed(state, allow_locked) && !defer_until_unlock {
// A fresh transition into an attempted state gets an immediate wake/recovery attempt.
let force_wake = fresh_state(previous, state);
if force_wake { retry_at = Instant::now(); }
let mut attempt_locked = locked.clone();
let outcome = tokio::select! {
biased;
_ = wait_for_lock(&mut locked) => AttemptOutcome::Cancelled,
outcome = self.portal_attempt(&owner, &mut attempt_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome,
_ = wait_for_lock(&mut locked, allow_locked) => AttemptOutcome::Cancelled,
outcome = self.portal_attempt(&owner, &mut attempt_locked, allow_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome,
};
match outcome {
AttemptOutcome::Ready(screen) => self.publish(&owner, screen),
@@ -228,11 +285,12 @@ impl PortalDesktop {
log::warn!("Portal desktop recovery deferred: {error}");
retry_at = Instant::now() + std::time::Duration::from_secs(5);
}
AttemptOutcome::Deferred => { defer_until_unlock = true; }
AttemptOutcome::Cancelled => {}
}
if *locked.borrow_and_update() != Some(false) { self.pause(&owner); }
if !attempt_allowed(*locked.borrow_and_update(), allow_locked) { self.pause(&owner); }
}
previous = *locked.borrow_and_update();
previous = Some(*locked.borrow_and_update());
tokio::select! {
_ = locked.changed() => {},
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {},
@@ -241,20 +299,20 @@ impl PortalDesktop {
}
async fn portal_attempt<W, I, O>(&self, owner: &Arc<DesktopInputSession>,
locked: &mut watch::Receiver<Option<bool>>, retry_at: Instant, force_wake: bool,
locked: &mut watch::Receiver<Option<bool>>, allow_locked: bool, retry_at: Instant, force_wake: bool,
wake: Arc<W>, inhibit: Arc<I>, open: Arc<O>) -> AttemptOutcome
where
W: Fn() -> Result<(), String> + Send + Sync + 'static,
I: Fn() -> IdleGuard + Send + Sync + 'static,
O: Fn(Arc<ScreenCapture>, Arc<AtomicBool>) -> Result<Arc<ScreenCapture>, PortalError> + Send + Sync + 'static,
{
if !owner.is_current() || *locked.borrow() != Some(false) || Instant::now() < retry_at {
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) || Instant::now() < retry_at {
return AttemptOutcome::Cancelled;
}
let gate = self.opening.clone().lock_owned().await;
// The state can change while this attempt waits for an earlier worker
// to finish rotating the Portal permission token.
if !owner.is_current() || *locked.borrow() != Some(false) {
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
return AttemptOutcome::Cancelled;
}
let screen = self.snapshot().screen;
@@ -271,6 +329,7 @@ impl PortalDesktop {
&prep_cancel,
&prep_owner,
&prep_locked,
allow_locked,
|| (*wake)(),
|| (*inhibit)(),
)).await {
@@ -282,7 +341,7 @@ impl PortalDesktop {
// Held by the cancellable async helper, not the blocking worker, so a
// lock transition releases it while worker cleanup may still be running.
let _inhibitor = prep.inhibitor;
if !owner.is_current() || *locked.borrow() != Some(false) {
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
return AttemptOutcome::Cancelled;
}
// A new controller can arrive while the cached Portal handle is alive
@@ -298,19 +357,25 @@ impl PortalDesktop {
}
open(screen, worker_cancel)
}).await;
if !owner.is_current() || *locked.borrow() != Some(false) {
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
return AttemptOutcome::Cancelled;
}
match result {
Ok(Err(error)) if defer_consent(&error, *locked.borrow()) => {
// The consent dialog opened behind the lock screen cannot be approved here.
// Keep this connection alive and ask again after the local unlock.
log::info!("Portal consent is behind the lock screen; waiting for the local unlock");
AttemptOutcome::Deferred
}
Ok(result) => classify(result),
Err(_) => AttemptOutcome::Terminal("Portal initialization worker failed".into()),
}
}
}
async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>) {
async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>, allow_locked: bool) {
while locked.changed().await.is_ok() {
if *locked.borrow_and_update() != Some(false) { return; }
if !attempt_allowed(*locked.borrow_and_update(), allow_locked) { return; }
}
}
@@ -441,19 +506,19 @@ mod tests {
let wakes = AtomicUsize::new(0);
let inhibitors = AtomicUsize::new(0);
let cancelled = AtomicBool::new(true);
assert!(prepare_attempt(&cancelled, &owner, &locked,
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
assert_eq!(wakes.load(Ordering::Relaxed), 0);
cancelled.store(false, Ordering::Release);
lock.send(Some(true)).unwrap();
assert!(prepare_attempt(&cancelled, &owner, &locked,
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
assert_eq!(wakes.load(Ordering::Relaxed), 0);
lock.send(Some(false)).unwrap();
let locked_during_wake = lock.clone();
assert!(prepare_attempt(&cancelled, &owner, &locked,
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| {
wakes.fetch_add(1, Ordering::Relaxed);
locked_during_wake.send(Some(true)).unwrap();
@@ -464,7 +529,7 @@ mod tests {
assert_eq!(inhibitors.load(Ordering::Relaxed), 0);
lock.send(Some(false)).unwrap();
let replacement = input.desktop_session();
assert!(prepare_attempt(&cancelled, &owner, &locked,
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
assert_eq!(wakes.load(Ordering::Relaxed), 1);
@@ -479,6 +544,115 @@ mod tests {
drop(guard);
assert!(flag.load(Ordering::Acquire));
}
#[test]
fn locked_capture_gate_follows_the_compositor_rule() {
assert!(attempt_allowed(Some(false), false));
assert!(!attempt_allowed(Some(true), false));
assert!(!attempt_allowed(None, false));
assert!(attempt_allowed(Some(true), true));
assert!(attempt_allowed(None, true));
}
#[test]
fn wake_and_retry_reset_once_per_lock_transition() {
assert!(fresh_state(None, Some(true)));
assert!(!fresh_state(Some(Some(true)), Some(true)));
assert!(fresh_state(Some(Some(true)), Some(false)));
assert!(!fresh_state(Some(Some(false)), Some(false)));
assert!(fresh_state(Some(Some(true)), None));
assert!(!fresh_state(Some(None), None));
}
#[test]
fn consent_failures_are_deferred_only_while_locked() {
for code in [4, 5] {
assert!(defer_consent(&PortalError { code }, Some(true)));
assert!(!defer_consent(&PortalError { code }, Some(false)));
assert!(!defer_consent(&PortalError { code }, None));
}
assert!(!defer_consent(&PortalError { code: 8 }, Some(true)));
assert!(!defer_consent(&PortalError { code: 13 }, Some(true)));
}
#[tokio::test]
async fn wait_for_lock_ends_on_a_lock_the_compositor_does_not_honor() {
use std::time::Duration;
let (lock, mut locked) = watch::channel(Some(false));
let mut task = tokio::spawn(async move { wait_for_lock(&mut locked, false).await; });
lock.send(Some(true)).unwrap();
tokio::time::timeout(Duration::from_secs(1), &mut task).await
.expect("lock must end the wait").unwrap();
}
#[tokio::test]
async fn wait_for_lock_ignores_lock_changes_when_capture_is_allowed() {
use std::time::Duration;
let (lock, mut locked) = watch::channel(Some(false));
let mut task = tokio::spawn(async move { wait_for_lock(&mut locked, true).await; });
lock.send(Some(true)).unwrap();
assert!(tokio::time::timeout(Duration::from_millis(100), &mut task).await.is_err(),
"lock cancelled an allowed wait");
lock.send(None).unwrap();
assert!(tokio::time::timeout(Duration::from_millis(100), &mut task).await.is_err(),
"unknown lock cancelled an allowed wait");
task.abort();
let _ = task.await;
}
#[test]
fn locked_attempt_is_allowed_when_the_compositor_keeps_the_stream() {
let input = Arc::new(crate::input::InputInjector::without_desktop());
let owner = input.desktop_session();
let (lock, locked) = watch::channel(Some(true));
let cancelled = AtomicBool::new(false);
let wakes = AtomicUsize::new(0);
assert!(prepare_attempt(&cancelled, &owner, &locked, true,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| IdleGuard::default()).is_some());
lock.send(None).unwrap();
assert!(prepare_attempt(&cancelled, &owner, &locked, true,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| IdleGuard::default()).is_some());
assert_eq!(wakes.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn locked_capture_keeps_the_attempt_running() {
use std::time::Duration;
let (lock, locked) = watch::channel(Some(false));
let host = Arc::new(PortalDesktop::with_lock_state_and_capture(
Arc::new(ScreenCapture::unavailable("pending".into())), locked, true));
let input = Arc::new(crate::input::InputInjector::without_desktop());
let owner = input.desktop_session();
let releases = Arc::new(AtomicUsize::new(0));
let worker_release = Arc::new(AtomicBool::new(false));
let (started, mut started_rx) = tokio::sync::mpsc::unbounded_channel();
let task = tokio::spawn({
let host = host.clone();
let owner = owner.clone();
let releases = releases.clone();
let worker_release = worker_release.clone();
async move {
host.maintain_with(owner,
|| Ok(()),
move || IdleGuard(Some(Inhibitor::Fake(DropSignal(releases.clone())))),
move |screen, cancel| {
let _ = started.send(());
while !worker_release.load(Ordering::Acquire) && !cancel.load(Ordering::Acquire) {
std::thread::sleep(Duration::from_millis(1));
}
if cancel.load(Ordering::Acquire) { return Err(PortalError { code: 13 }); }
Ok(screen)
}).await
}
});
started_rx.recv().await.unwrap();
lock.send(Some(true)).unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(releases.load(Ordering::Relaxed), 0, "lock released a compositor-backed attempt");
worker_release.store(true, Ordering::Release);
let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
while host.snapshot().waiting {
assert!(tokio::time::Instant::now() < deadline, "locked attempt did not publish");
tokio::task::yield_now().await;
}
task.abort();
let _ = task.await;
}
#[tokio::test]
async fn lock_transition_cancels_blocked_attempt_and_releases_inhibitor() {
let (lock, locked) = watch::channel(Some(false));
+5
View File
@@ -127,6 +127,11 @@ pub async fn run() -> Result<(), String> {
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio");
line(crate::i18n::s("麦克风输入", "microphone input"),
crate::i18n::s("控制端 Opus 到固定虚拟输入(可选)", "controller Opus to pinned virtual input (opt-in)"));
line("UU_MICROPHONE", if crate::microphone::requested() { crate::i18n::s("已启用", "enabled") } else { crate::i18n::s("已禁用", "disabled") });
line(crate::i18n::s("虚拟麦克风", "virtual microphone"), command_output("pactl", &["list", "short", "sources"]).await
.is_some_and(|sources| sources.lines().any(|line| line.split('\t').nth(1) == Some(crate::microphone::SOURCE))));
for tool in ["pactl", "pw-cli"] {
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
}
+7
View File
@@ -568,6 +568,13 @@ impl FileSession {
fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f);
let raw = get_text(f, 2);
// Newer viewers (Windows 4.44.1, #208) send only the task id here; an empty path must not
// become "/" and walk the whole filesystem into a misleading permission error.
if raw.trim().is_empty() {
log::info!("File transfer send_request without path: task={} fields={:?}", id.task, f.iter().map(|x| x.number).collect::<Vec<_>>());
self.respond(rid, 2, Enc::default().msg(1, id.enc()).uint(2, FT_PROTOCOL));
return;
}
let path = normalize(&raw);
let collected = collect_download(&path).map_err(|e| io_error(&e));
let mut body = Enc::default().msg(1, id.enc());
+5 -2
View File
@@ -45,6 +45,7 @@ mod damage_capture;
mod inproc_encoder;
mod capture_setting;
mod audio;
mod microphone;
mod virtual_audio;
mod privacy_screen;
mod system_actions;
@@ -649,6 +650,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
privacy_screen::recover();
virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup;
microphone::init();
let _microphone_cleanup = microphone::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
@@ -685,7 +688,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
}
#[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await;
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); microphone::shutdown().await; virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
let _ = signal_tx.send(true);
});
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
@@ -716,7 +719,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
privacy_screen::shutdown(); virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
privacy_screen::shutdown(); microphone::shutdown().await; virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
// (a guest cancel then fails). Only a real stop withdraws here.
+439
View File
@@ -0,0 +1,439 @@
//! Controller Opus -> a dedicated virtual microphone. Never record or log audio payloads.
//! Opt in with UU_MICROPHONE=1. The normal desktop-output/monitor route is not changed.
use std::collections::HashMap;
use std::os::fd::AsRawFd;
use std::process::{Command, Stdio};
use std::sync::{Arc, Mutex, OnceLock, atomic::{AtomicBool, Ordering}};
use std::time::Duration;
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio::sync::watch;
use webrtc::{peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState},
rtp::packet::Packet, rtp_transceiver::rtp_codec::RTPCodecType, track::track_remote::TrackRemote};
mod pulse;
pub const SOURCE: &str = "uu-remote-microphone";
const SINK: &str = "uu-remote-mic-input";
const MAX_PACKETS: u16 = 12;
static AVAILABLE: AtomicBool = AtomicBool::new(false);
static ROUTE: OnceLock<Mutex<Option<Route>>> = OnceLock::new();
struct Workers { stopped: watch::Sender<bool>, active: watch::Sender<usize> }
fn workers() -> &'static Workers {
static STATE: OnceLock<Workers> = OnceLock::new();
STATE.get_or_init(|| Workers { stopped: watch::channel(false).0, active: watch::channel(0).0 })
}
struct Worker;
impl Worker {
fn new() -> Self { workers().active.send_modify(|count| *count += 1); Self }
}
impl Drop for Worker {
fn drop(&mut self) { workers().active.send_modify(|count| *count -= 1); }
}
struct Module { id: u32, kind: &'static str, args: Vec<String> }
struct Route { source: Module, sink: Module, _lock: std::fs::File }
pub fn requested() -> bool { std::env::var("UU_MICROPHONE").is_ok_and(|v| v == "1") }
pub fn available() -> bool { AVAILABLE.load(Ordering::Acquire) }
pub fn policy_request(rpc: &[crate::protocol::WireField]) -> Option<u64> {
use crate::protocol::{decode_wire, WireValue};
let body = rpc.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None })?;
let fields = decode_wire(body).ok()?;
Some(fields.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0))
}
fn pactl(args: &[&str]) -> Result<String, String> {
let out = Command::new("pactl").args(args).env("LC_ALL", "C")
.stdin(Stdio::null()).stderr(Stdio::null()).output().map_err(|_| "pactl unavailable")?;
if !out.status.success() { return Err("PulseAudio virtual microphone operation failed".into()); }
Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
}
impl Module {
fn matching_id(line: &str, kind: &str, args: &[String]) -> Option<u32> {
let mut fields = line.split('\t');
let id = fields.next()?.parse().ok()?;
if fields.next()? != kind { return None; }
let actual: Vec<_> = fields.next()?.split_whitespace().collect();
(actual.len() == args.len() && args.iter().all(|arg| actual.contains(&arg.as_str()))).then_some(id)
}
fn open(kind: &'static str, args: Vec<String>) -> Result<Self, String> {
let modules = pactl(&["list", "short", "modules"])?;
let key = &args[0];
let named: Vec<_> = modules.lines().filter(|line| line.split('\t').nth(2)
.is_some_and(|a| a.split_whitespace().any(|a| a == key))).collect();
let id = if named.is_empty() {
let mut command = vec!["load-module", kind];
command.extend(args.iter().map(String::as_str));
pactl(&command)?.parse().map_err(|_| "Virtual microphone module returned no id")?
} else if named.len() == 1 {
Self::matching_id(named[0], kind, &args).ok_or("Virtual microphone name already belongs to another module")?
} else {
return Err("Virtual microphone module ownership is ambiguous".into());
};
Ok(Self { id, kind, args })
}
fn unload(&self) {
// Audio-server restarts may reuse numeric ids; never unload an unrelated replacement.
if pactl(&["list", "short", "modules"]).is_ok_and(|list| list.lines()
.any(|line| Self::matching_id(line, self.kind, &self.args) == Some(self.id))) {
let _ = pactl(&["unload-module", &self.id.to_string()]);
}
}
}
fn route_lock_path(source: &str) -> Result<std::path::PathBuf, String> {
use std::os::unix::fs::{DirBuilderExt, MetadataExt};
// Fixed per-user endpoints need a lock shared even by launchers with different UU_CONFIG,
// XDG_RUNTIME_DIR or TMPDIR. Only the lock inode persists; flock releases on process exit.
let dir = std::path::PathBuf::from(format!("/tmp/uu-remote-linux-{}", unsafe { libc::geteuid() }));
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(&dir)
.map_err(|_| "Microphone runtime directory unavailable")?;
let metadata = std::fs::symlink_metadata(&dir).map_err(|_| "Microphone runtime directory unavailable")?;
if !metadata.is_dir() || metadata.uid() != unsafe { libc::geteuid() } || metadata.mode() & 0o077 != 0 {
return Err("Microphone runtime directory is not private".into());
}
Ok(dir.join(format!("{source}.lock")))
}
fn route_lock(source: &str) -> Result<std::fs::File, String> {
use std::os::unix::fs::OpenOptionsExt;
let lock = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).mode(0o600)
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC).open(route_lock_path(source)?)
.map_err(|_| "Microphone ownership lock unavailable")?;
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
return Err("Another host owns the virtual microphone".into());
}
Ok(lock)
}
fn native_pulse(info: &str) -> Result<bool, String> {
let field = |key: &str| info.lines().find_map(|line| line.strip_prefix(key).map(str::trim));
let name = field("Server Name:").ok_or("Microphone audio server unavailable")?;
if name.to_ascii_lowercase().contains("pipewire") { return Ok(false); }
if !name.eq_ignore_ascii_case("pulseaudio") { return Err("Unsupported microphone audio server".into()); }
let major = field("Server Version:").and_then(|v| v.split('.').next()).and_then(|v| v.parse::<u32>().ok());
if !major.is_some_and(|v| v >= 13) { return Err("Remote microphone requires PulseAudio 13 or newer".into()); }
Ok(true)
}
fn sink_args(name: &str) -> Result<Vec<String>, String> {
let description = crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input");
let mut args = vec![format!("sink_name={name}"), format!("sink_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()];
// PulseAudio 13+: norewinds starts the null sink with a 50 ms block instead of 2 s of
// idle silence. PipeWire's compatible module does not accept this Pulse-only argument.
if native_pulse(&pactl(&["info"])?)? { args.push("norewinds=1".into()); }
Ok(args)
}
impl Route {
fn new(sink_name: &str, source_name: &str) -> Result<Self, String> {
let lock = route_lock(source_name)?;
let sink = Module::open("module-null-sink", sink_args(sink_name)?)?;
let description = crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone");
let source = Module::open("module-remap-source", vec![format!("source_name={source_name}"),
format!("master={sink_name}.monitor"), format!("source_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()]);
match source {
Ok(source) => Ok(Route { source, sink, _lock: lock }),
Err(e) => { sink.unload(); Err(e) }
}
}
}
impl Drop for Route {
fn drop(&mut self) { self.source.unload(); self.sink.unload(); }
}
pub struct Cleanup;
impl Drop for Cleanup {
fn drop(&mut self) {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
// On an unexpected unwind leave recovery to the next run rather than move a live stream
// off its disappearing sink. Normal shutdown waits for every playback worker below.
if *workers().active.borrow() == 0 { release_route(); }
}
}
pub fn init() {
if !requested() { return; }
let mut state = ROUTE.get_or_init(|| Mutex::new(None)).lock().unwrap();
if state.is_some() { return; }
let result = (|| {
let _ = Decoder::new()?;
pulse::available()?;
Route::new(SINK, SOURCE)
})();
match result {
Ok(route) => {
*state = Some(route);
workers().stopped.send_replace(false);
AVAILABLE.store(true, Ordering::Release);
log::info!("Remote microphone virtual input ready (48 kHz stereo, pinned Pulse stream)");
}
Err(error) => log::warn!("Remote microphone unavailable: {error}"),
}
}
pub async fn shutdown() {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
let mut active = workers().active.subscribe();
let _ = active.wait_for(|count| *count == 0).await;
release_route();
}
fn release_route() {
if let Some(state) = ROUTE.get() {
state.lock().unwrap().take();
}
}
#[cfg(target_os = "linux")]
struct Opus {
_handle: usize,
create: unsafe extern "C" fn(i32, i32, *mut i32) -> *mut libc::c_void,
destroy: unsafe extern "C" fn(*mut libc::c_void),
decode: unsafe extern "C" fn(*mut libc::c_void, *const u8, i32, *mut i16, i32, i32) -> i32,
samples: unsafe extern "C" fn(*const u8, i32, i32) -> i32,
}
#[cfg(target_os = "linux")]
fn opus() -> Result<&'static Opus, String> {
static LIB: OnceLock<Option<Opus>> = OnceLock::new();
LIB.get_or_init(|| unsafe {
let handle = libc::dlopen(c"libopus.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if handle.is_null() { return None; }
let names = [c"opus_decoder_create", c"opus_decoder_destroy", c"opus_decode", c"opus_packet_get_nb_samples"];
let functions: Vec<_> = names.iter().map(|name| libc::dlsym(handle, name.as_ptr())).collect();
if functions.iter().any(|f| f.is_null()) { libc::dlclose(handle); return None; }
// The library stays loaded for the process lifetime; signatures match the public Opus API.
Some(Opus { _handle: handle as usize, create: std::mem::transmute(functions[0]),
destroy: std::mem::transmute(functions[1]), decode: std::mem::transmute(functions[2]),
samples: std::mem::transmute(functions[3]) })
}).as_ref().ok_or_else(|| "libopus runtime unavailable".into())
}
struct Decoder(*mut libc::c_void);
#[derive(Debug, PartialEq, Eq)]
enum Frame { Opus(Vec<u8>), Conceal(u32) }
// One task owns the decoder and all calls; no decoder state is shared concurrently.
unsafe impl Send for Decoder {}
impl Decoder {
fn new() -> Result<Self, String> {
#[cfg(target_os = "linux")] {
let mut error = 0;
let decoder = unsafe { (opus()?.create)(48000, 2, &mut error) };
if error == 0 && !decoder.is_null() { return Ok(Self(decoder)); }
}
Err("Opus microphone decoder unavailable".into())
}
fn decode(&mut self, frame: &Frame) -> Result<(Vec<u8>, u32), String> {
#[cfg(target_os = "linux")] {
let (packet, size) = match frame {
Frame::Opus(data) if valid_packet(data) => (Some(data.as_slice()), 5760),
Frame::Conceal(samples) if (120..=5760).contains(samples) && samples % 120 == 0 => (None, *samples as i32),
_ => return Err("Invalid microphone Opus frame".into()),
};
let data = packet.unwrap_or(&[]);
let mut pcm = vec![0i16; 5760 * 2];
let samples = unsafe { (opus()?.decode)(self.0, if packet.is_some() { data.as_ptr() } else { std::ptr::null() },
data.len() as i32, pcm.as_mut_ptr(), size, 0) };
if samples <= 0 { return Err("Microphone Opus decode failed".into()); }
let bytes = pcm[..samples as usize * 2].iter().flat_map(|s| s.to_le_bytes()).collect();
return Ok((bytes, samples as u32));
}
#[allow(unreachable_code)] { let _ = frame; Err("Microphone decoding requires Linux".into()) }
}
}
impl Drop for Decoder {
fn drop(&mut self) { #[cfg(target_os = "linux")] if let Ok(lib) = opus() { unsafe { (lib.destroy)(self.0); } } }
}
fn packet_samples(data: &[u8]) -> Option<u32> {
if data.is_empty() || data.len() > 8192 { return None; }
#[cfg(target_os = "linux")] {
let samples = unsafe { (opus().ok()?.samples)(data.as_ptr(), data.len() as i32, 48000) };
return (120..=5760).contains(&samples).then_some(samples as u32);
}
#[allow(unreachable_code)] None
}
fn valid_packet(data: &[u8]) -> bool { packet_samples(data).is_some() }
/// Fixed memory and bounded reordering across sequence wrap; stale backlog is discarded.
#[derive(Default)]
struct Jitter { next: Option<u16>, timestamp: Option<u32>, last_samples: Option<u32>, packets: HashMap<u16, QueuedPacket> }
struct QueuedPacket { timestamp: u32, samples: u32, payload: Vec<u8> }
impl Jitter {
fn push(&mut self, packet: Packet) {
let Some(samples) = packet_samples(&packet.payload) else { return; };
let seq = packet.header.sequence_number;
let next = *self.next.get_or_insert(seq);
let ahead = seq.wrapping_sub(next);
if ahead >= 0x8000 { return; }
if ahead >= MAX_PACKETS { self.packets.clear(); self.next = Some(seq); self.timestamp = None; }
self.packets.entry(seq).or_insert_with(|| QueuedPacket {
timestamp: packet.header.timestamp, samples, payload: packet.payload.to_vec(),
});
}
/// A future packet's RTP clock bounds the missing audio, including variable packet durations.
fn pop(&mut self) -> Option<Frame> {
if self.packets.is_empty() { return None; }
let seq = self.next?;
self.next = Some(seq.wrapping_add(1));
if let Some(packet) = self.packets.remove(&seq) {
self.timestamp = Some(packet.timestamp.wrapping_add(packet.samples));
self.last_samples = Some(packet.samples);
return Some(Frame::Opus(packet.payload));
}
let inferred = self.timestamp.and_then(|timestamp| {
let (&future, packet) = self.packets.iter().min_by_key(|(n, _)| n.wrapping_sub(seq))?;
let missing = u32::from(future.wrapping_sub(seq));
let gap = packet.timestamp.wrapping_sub(timestamp);
// Ignore timestamp discontinuities/DTX; do not manufacture seconds of concealment.
(missing > 0 && (missing * 120..=missing * 5760).contains(&gap) && gap % 120 == 0)
.then(|| gap / missing / 120 * 120)
});
let samples = inferred.or(self.last_samples).unwrap_or(960);
self.timestamp = self.timestamp.map(|timestamp| timestamp.wrapping_add(samples));
Some(Frame::Conceal(samples))
}
}
type Writer = std::pin::Pin<Box<dyn AsyncWrite + Send>>;
struct Playback { decoder: Decoder, writer: Writer, output: Option<pulse::Output> }
impl Playback {
fn new() -> Result<Self, String> {
Self::at(SINK)
}
fn at(sink: &str) -> Result<Self, String> {
let decoder = Decoder::new()?;
let (writer, output) = pulse::start(sink)?;
Ok(Self { decoder, writer: Box::pin(writer), output: Some(output) })
}
async fn write(&mut self, frame: &Frame) -> Result<u32, String> {
let (bytes, samples) = self.decoder.decode(frame)?;
match tokio::time::timeout(Duration::from_millis(200), self.writer.write_all(&bytes)).await {
Ok(Ok(())) => {},
Ok(Err(_)) => {
if let Some(output) = self.output.as_mut() {
if let Err(error) = output.stop().await { return Err(error); }
}
return Err("Microphone playback ended".into());
},
Err(_) => return Err("Microphone playback stalled".into()),
}
Ok(samples)
}
async fn stop(&mut self) {
if let Some(output) = self.output.as_mut() { let _ = output.stop().await; }
}
}
type Factory = Arc<dyn Fn() -> Result<Playback, String> + Send + Sync>;
#[derive(Clone)]
pub struct Session { open: watch::Sender<bool>, owner: watch::Sender<u64>, serial: Arc<Mutex<()>>, factory: Factory }
impl Session {
pub fn new() -> Self {
// Do not request or accept capture until the controller explicitly enables it.
Self { open: watch::channel(false).0, owner: watch::channel(0).0, serial: Arc::new(Mutex::new(())), factory: Arc::new(Playback::new) }
}
/// Official SimpleAction map: 23 microphone_opened, 24 microphone_closed.
pub fn action(&self, action: u64) -> bool {
self.action_with(action, || {})
}
/// Commit the gate and enqueue its notifications as one ordered transition across channels.
/// The callback only queues messages; actual network sends must happen outside this lock.
pub fn action_with(&self, action: u64, enqueue: impl FnOnce()) -> bool {
match action {
23 | 24 => {
let _serial = self.serial.lock().unwrap();
self.open.send_replace(action == 23);
enqueue();
log::info!("Remote microphone switch: open={}", action == 23);
true
},
_ => false,
}
}
fn claim_track(&self) -> (u64, watch::Receiver<u64>) {
let owner = self.owner.subscribe();
let mut generation = 0;
self.owner.send_modify(|id| { *id = id.wrapping_add(1); generation = *id; });
(generation, owner)
}
pub fn attach(&self, pc: &Arc<RTCPeerConnection>, active: watch::Receiver<bool>) {
let weak = Arc::downgrade(pc);
let session = self.clone();
pc.on_track(Box::new(move |track, _, _| {
let (session, active, weak) = (session.clone(), active.clone(), weak.clone());
Box::pin(async move {
if track.kind() != RTPCodecType::Audio { return; }
if !track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus") {
log::warn!("Incoming microphone track uses an unsupported codec"); return;
}
log::info!("Incoming microphone Opus track received");
if let Some(pc) = weak.upgrade() {
let (generation, owner) = session.claim_track();
let worker = Worker::new();
tokio::spawn(session.receive(track, pc, active, generation, owner, worker));
}
})
}));
}
async fn receive(self, track: Arc<TrackRemote>, pc: Arc<RTCPeerConnection>, mut active: watch::Receiver<bool>,
generation: u64, mut owner: watch::Receiver<u64>, _worker: Worker) {
let mut stopped = workers().stopped.subscribe();
let mut open = self.open.subscribe();
let mut jitter = Jitter::default();
let mut player: Option<Playback> = None;
let mut next = tokio::time::Instant::now();
let mut health = tokio::time::interval(Duration::from_millis(100));
let mut played = 0u64;
let mut lost = 0u64;
// TrackRemote reads are not cancel safe. Keep the same future across timer and gate ticks.
let mut pending = Box::pin(track.read_rtp());
loop {
// A worker can first run after its replacement has already subscribed. Check the id,
// not only changed(): both receivers may otherwise have marked the latest id as seen.
if *stopped.borrow() || *owner.borrow_and_update() != generation { break; }
let allowed = *open.borrow() && *active.borrow() && pc.connection_state() == RTCPeerConnectionState::Connected;
if !allowed {
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; log::info!("Remote microphone playback paused"); }
}
tokio::select! {
biased;
_ = stopped.changed() => break,
_ = owner.changed() => break,
change = open.changed() => {
if change.is_err() { break; }
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; }
},
change = active.changed() => if change.is_err() { break; },
_ = health.tick() => {
if matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) { break; }
},
_ = tokio::time::sleep_until(next), if player.is_some() && allowed => {
if let Some(packet) = jitter.pop() {
if matches!(packet, Frame::Conceal(_)) { lost += 1; }
match player.as_mut().unwrap().write(&packet).await {
Ok(samples) => {
played += 1;
next = (next + Duration::from_secs_f64(f64::from(samples) / 48000.)).max(tokio::time::Instant::now());
if played == 1 || played % 250 == 0 { log::info!("Remote microphone playback: frames={played} concealed={lost}"); }
},
Err(error) => { log::warn!("{error}"); break; }
}
} else {
next = tokio::time::Instant::now() + Duration::from_millis(10);
}
},
received = &mut pending => {
let Ok((packet, _)) = received else { break; };
pending.set(track.read_rtp());
if !allowed || !valid_packet(&packet.payload) { continue; }
if player.is_none() {
match (self.factory)() {
Ok(output) => { player = Some(output); next = tokio::time::Instant::now() + Duration::from_millis(40); },
Err(error) => { log::warn!("{error}"); break; }
}
}
jitter.push(packet);
},
}
}
if let Some(mut output) = player { output.stop().await; }
log::info!("Remote microphone track ended: frames={played} concealed={lost}");
}
}
#[cfg(test)]
mod tests;
+187
View File
@@ -0,0 +1,187 @@
//! Pulse playback pinned with PA_STREAM_DONT_MOVE, supported by PulseAudio and PipeWire-pulse.
//! Load the stable public C API at runtime so opt-out builds need no Pulse development package.
use std::ffi::{CStr, CString};
use std::sync::OnceLock;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, DuplexStream};
use tokio::sync::watch;
type Handle = *mut libc::c_void;
type Free = Option<unsafe extern "C" fn(Handle)>;
#[repr(C)]
struct SampleSpec { format: i32, rate: u32, channels: u8 }
#[repr(C)]
struct BufferAttr { maxlength: u32, tlength: u32, prebuf: u32, minreq: u32, fragsize: u32 }
struct Api {
_library: usize,
mainloop_new: unsafe extern "C" fn() -> Handle,
mainloop_free: unsafe extern "C" fn(Handle),
mainloop_get_api: unsafe extern "C" fn(Handle) -> Handle,
mainloop_iterate: unsafe extern "C" fn(Handle, i32, *mut i32) -> i32,
context_new: unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle,
context_connect: unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32,
context_get_state: unsafe extern "C" fn(Handle) -> i32,
context_disconnect: unsafe extern "C" fn(Handle),
context_unref: unsafe extern "C" fn(Handle),
stream_new: unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle,
stream_connect_playback: unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32,
stream_get_state: unsafe extern "C" fn(Handle) -> i32,
stream_get_device_name: unsafe extern "C" fn(Handle) -> *const libc::c_char,
stream_writable_size: unsafe extern "C" fn(Handle) -> usize,
stream_write: unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32,
stream_disconnect: unsafe extern "C" fn(Handle) -> i32,
stream_unref: unsafe extern "C" fn(Handle),
}
fn api() -> Result<&'static Api, String> {
static API: OnceLock<Option<Api>> = OnceLock::new();
API.get_or_init(|| unsafe {
let library = libc::dlopen(c"libpulse.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if library.is_null() { return None; }
macro_rules! load {
($name:expr, $signature:ty) => {{
let function = libc::dlsym(library, $name.as_ptr());
if function.is_null() { return None; }
std::mem::transmute::<Handle, $signature>(function)
}};
}
let result = (|| Some(Api {
_library: library as usize,
mainloop_new: load!(c"pa_mainloop_new", unsafe extern "C" fn() -> Handle),
mainloop_free: load!(c"pa_mainloop_free", unsafe extern "C" fn(Handle)),
mainloop_get_api: load!(c"pa_mainloop_get_api", unsafe extern "C" fn(Handle) -> Handle),
mainloop_iterate: load!(c"pa_mainloop_iterate", unsafe extern "C" fn(Handle, i32, *mut i32) -> i32),
context_new: load!(c"pa_context_new", unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle),
context_connect: load!(c"pa_context_connect", unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32),
context_get_state: load!(c"pa_context_get_state", unsafe extern "C" fn(Handle) -> i32),
context_disconnect: load!(c"pa_context_disconnect", unsafe extern "C" fn(Handle)),
context_unref: load!(c"pa_context_unref", unsafe extern "C" fn(Handle)),
stream_new: load!(c"pa_stream_new", unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle),
stream_connect_playback: load!(c"pa_stream_connect_playback", unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32),
stream_get_state: load!(c"pa_stream_get_state", unsafe extern "C" fn(Handle) -> i32),
stream_get_device_name: load!(c"pa_stream_get_device_name", unsafe extern "C" fn(Handle) -> *const libc::c_char),
stream_writable_size: load!(c"pa_stream_writable_size", unsafe extern "C" fn(Handle) -> usize),
stream_write: load!(c"pa_stream_write", unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32),
stream_disconnect: load!(c"pa_stream_disconnect", unsafe extern "C" fn(Handle) -> i32),
stream_unref: load!(c"pa_stream_unref", unsafe extern "C" fn(Handle)),
}))();
if result.is_none() { libc::dlclose(library); }
result
}).as_ref().ok_or_else(|| "libpulse runtime unavailable".into())
}
pub(super) fn available() -> Result<(), String> { api().map(|_| ()) }
struct Stream { api: &'static Api, mainloop: Handle, context: Handle, stream: Handle }
impl Drop for Stream {
fn drop(&mut self) { unsafe {
if !self.stream.is_null() { (self.api.stream_disconnect)(self.stream); (self.api.stream_unref)(self.stream); }
if !self.context.is_null() { (self.api.context_disconnect)(self.context); (self.api.context_unref)(self.context); }
if !self.mainloop.is_null() { (self.api.mainloop_free)(self.mainloop); }
} }
}
impl Stream {
fn connect(api: &'static Api, sink: &CStr, stopped: &watch::Receiver<bool>) -> Result<Self, String> { unsafe {
let mut output = Self { api, mainloop: (api.mainloop_new)(), context: std::ptr::null_mut(), stream: std::ptr::null_mut() };
if output.mainloop.is_null() { return Err("Microphone audio loop unavailable".into()); }
let client = CString::new(crate::i18n::s("UU 远程麦克风", "UU Remote microphone")).unwrap();
output.context = (api.context_new)((api.mainloop_get_api)(output.mainloop), client.as_ptr());
// PA_CONTEXT_NOAUTOSPAWN: connecting to the configured server must not start another one.
if output.context.is_null() || (api.context_connect)(output.context, std::ptr::null(), 1, std::ptr::null_mut()) < 0 {
return Err("Microphone audio server unavailable".into());
}
let context = output.context;
output.wait(stopped, || (api.context_get_state)(context) == 4)?; // PA_CONTEXT_READY
let spec = SampleSpec { format: 3, rate: 48000, channels: 2 }; // PA_SAMPLE_S16LE
let name = CString::new(crate::i18n::s("远程麦克风", "Remote-Microphone")).unwrap();
output.stream = (api.stream_new)(context, name.as_ptr(), &spec, std::ptr::null_mut());
let attr = BufferAttr { maxlength: u32::MAX, tlength: 5760, prebuf: u32::MAX, minreq: 1920, fragsize: u32::MAX };
// pulse/def.h: PA_STREAM_DONT_MOVE | PA_STREAM_ADJUST_LATENCY. A disappearing target
// must fail closed; PipeWire-only node properties cannot enforce this on PulseAudio.
if output.stream.is_null() || (api.stream_connect_playback)(output.stream, sink.as_ptr(), &attr,
0x0200 | 0x2000, std::ptr::null_mut(), std::ptr::null_mut()) < 0 {
return Err("Microphone audio target unavailable".into());
}
let stream = output.stream;
output.wait(stopped, || (api.stream_get_state)(stream) == 2)?; // PA_STREAM_READY
let actual = (api.stream_get_device_name)(stream);
if actual.is_null() || CStr::from_ptr(actual) != sink { return Err("Microphone audio target changed".into()); }
Ok(output)
} }
fn pump(&mut self) -> Result<(), String> { unsafe {
if (self.api.mainloop_iterate)(self.mainloop, 0, std::ptr::null_mut()) < 0
|| (self.api.context_get_state)(self.context) >= 5
|| (!self.stream.is_null() && (self.api.stream_get_state)(self.stream) >= 3) {
return Err("Microphone audio connection ended".into());
}
Ok(())
} }
fn wait(&mut self, stopped: &watch::Receiver<bool>, ready: impl Fn() -> bool) -> Result<(), String> {
let deadline = Instant::now() + Duration::from_secs(3);
loop {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
if ready() { return Ok(()); }
if Instant::now() >= deadline { return Err("Microphone audio connection timed out".into()); }
std::thread::sleep(Duration::from_millis(2));
}
}
fn write(&mut self, pcm: &[u8], stopped: &watch::Receiver<bool>) -> Result<(), String> {
if pcm.len() % 4 != 0 { return Err("Invalid microphone PCM frame".into()); }
let deadline = Instant::now() + Duration::from_millis(200);
let mut offset = 0;
while offset < pcm.len() {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
let available = unsafe { (self.api.stream_writable_size)(self.stream) };
if available == usize::MAX { return Err("Microphone audio stream ended".into()); }
let count = available.min(pcm.len() - offset) & !3;
if count > 0 {
// With no free callback libpulse copies these bytes before returning.
if unsafe { (self.api.stream_write)(self.stream, pcm[offset..].as_ptr().cast(), count, None, 0, 0) } < 0 {
return Err("Microphone audio write failed".into());
}
offset += count;
} else {
if Instant::now() >= deadline {
return Err(format!("Microphone playback stalled: remaining={} writable={available}", pcm.len() - offset));
}
std::thread::sleep(Duration::from_millis(2));
}
}
self.pump()
}
}
pub(super) struct Output { stopped: watch::Sender<bool>, task: Option<tokio::task::JoinHandle<Result<(), String>>> }
impl Output {
pub(super) async fn stop(&mut self) -> Result<(), String> {
self.stopped.send_replace(true);
if let Some(task) = self.task.take() {
return task.await.map_err(|_| "Microphone audio worker aborted")?;
}
Ok(())
}
}
impl Drop for Output { fn drop(&mut self) { self.stopped.send_replace(true); } }
pub(super) fn start(sink: &str) -> Result<(DuplexStream, Output), String> {
let api = api()?;
let sink = CString::new(sink).map_err(|_| "Invalid microphone audio target")?;
let (writer, mut reader) = tokio::io::duplex(65536);
let (stop, mut stopped) = watch::channel(false);
let runtime = tokio::runtime::Handle::current();
let task = tokio::task::spawn_blocking(move || {
let mut output = Stream::connect(api, &sink, &stopped)?;
let mut buffer = [0; 23040]; // maximum 120 ms stereo PCM
loop {
if *stopped.borrow() { return Ok(()); }
let count = runtime.block_on(async { tokio::select! {
biased;
_ = stopped.changed() => Ok(0),
result = reader.read(&mut buffer) => result,
} }).map_err(|_| "Microphone PCM input ended")?;
if count == 0 { return Ok(()); }
output.write(&buffer[..count], &stopped)?;
}
});
Ok((writer, Output { stopped: stop, task: Some(task) }))
}
+533
View File
@@ -0,0 +1,533 @@
#![cfg(target_os = "linux")]
use super::*;
use tokio::io::AsyncReadExt;
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP, TrackLocalWriter};
use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
use webrtc::interceptor::{mock::{mock_builder::MockBuilder, mock_interceptor::MockInterceptor},
registry::Registry, Attributes, RTPReader};
fn have_opus() -> bool {
match opus() {
Ok(_) => true,
Err(error) => { eprintln!("Skipping Opus-dependent microphone test: {error}"); false }
}
}
#[derive(Default)]
struct ReadPause {
requested: AtomicBool, entered: tokio::sync::Notify,
resume: tokio::sync::Notify, completed: tokio::sync::Notify,
}
struct PausedReader { reader: Arc<dyn RTPReader + Send + Sync>, pause: Arc<ReadPause> }
#[async_trait::async_trait]
impl RTPReader for PausedReader {
async fn read(&self, buffer: &mut [u8], attributes: &Attributes) -> Result<(Packet, Attributes), webrtc::interceptor::Error> {
let result = self.reader.read(buffer, attributes).await?;
if self.pause.requested.swap(false, Ordering::AcqRel) {
// The packet has already been consumed; cancelling here would lose it.
self.pause.entered.notify_one();
self.pause.resume.notified().await;
self.pause.completed.notify_one();
}
Ok(result)
}
}
fn pause_registry(pause: Arc<ReadPause>) -> Registry {
let mut registry = Registry::new();
registry.add(Box::new(MockBuilder::new(move |_| {
let pause = pause.clone();
Ok(Arc::new(MockInterceptor { bind_remote_stream_fn: Some(Box::new(move |_, reader| {
let pause = pause.clone();
Box::pin(async move {
Arc::new(PausedReader { reader, pause }) as Arc<dyn RTPReader + Send + Sync>
})
})), ..Default::default() }))
})));
registry
}
fn tone() -> Vec<u8> {
tone_samples(960)
}
fn tone_samples(samples: usize) -> Vec<u8> {
let handle = opus().unwrap()._handle as *mut libc::c_void;
let create: unsafe extern "C" fn(i32, i32, i32, *mut i32) -> *mut libc::c_void = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_create".as_ptr()))
};
let encode: unsafe extern "C" fn(*mut libc::c_void, *const i16, i32, *mut u8, i32) -> i32 = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encode".as_ptr()))
};
let destroy: unsafe extern "C" fn(*mut libc::c_void) = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_destroy".as_ptr()))
};
let pcm: Vec<i16> = (0..samples).flat_map(|i| {
let s = ((i as f64 * std::f64::consts::TAU * 1000. / 48000.).sin() * 6000.) as i16;
[s, s]
}).collect();
let mut error = 0;
let enc = unsafe { create(48000, 2, 2048, &mut error) };
assert_eq!(error, 0);
assert!(!enc.is_null());
let mut out = vec![0; 4000];
let n = unsafe { encode(enc, pcm.as_ptr(), samples as i32, out.as_mut_ptr(), out.len() as i32) };
unsafe { destroy(enc); }
assert!(n > 0);
out.truncate(n as usize);
out
}
fn packet(seq: u16, data: &[u8]) -> Packet {
packet_at(seq, u32::from(seq) * 960, data)
}
fn packet_at(seq: u16, timestamp: u32, data: &[u8]) -> Packet {
Packet { header: webrtc::rtp::header::Header { version: 2, sequence_number: seq,
timestamp, marker: true, ..Default::default() },
payload: bytes::Bytes::copy_from_slice(data) }
}
fn rms(bytes: &[u8]) -> f64 {
let sum: f64 = bytes.chunks_exact(2).map(|s| f64::from(i16::from_le_bytes([s[0], s[1]])).powi(2)).sum();
(sum / (bytes.len() / 2).max(1) as f64).sqrt()
}
#[test]
fn opus_decodes_generated_tone_and_conceals_loss() {
if !have_opus() { return; }
assert!(!valid_packet(&[]));
assert!(!valid_packet(&vec![0; 8193]));
let data = tone();
let mut decoder = Decoder::new().unwrap();
let (pcm, frames) = decoder.decode(&Frame::Opus(data)).unwrap();
assert_eq!(frames, 960);
assert_eq!(pcm.len(), 3840);
assert!(rms(&pcm) > 1000.);
assert_eq!(decoder.decode(&Frame::Conceal(960)).unwrap().0.len(), 3840);
assert!(decoder.decode(&Frame::Opus(vec![])).is_err());
assert!(decoder.decode(&Frame::Conceal(0)).is_err());
}
#[test]
fn reorder_handles_wrap_loss_duplicates_and_bounded_backlog() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
for seq in [65535, 1, 0, 0] { jitter.push(packet(seq, &data)); }
for _ in 0..3 { assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone()))); }
assert!(jitter.pop().is_none());
jitter.push(packet(3, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // sequence 2 was lost
assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone())));
jitter.push(packet(0, &data)); // late retransmission
assert!(jitter.pop().is_none());
for seq in 4..1000 { jitter.push(packet(seq, &data)); assert!(jitter.packets.len() <= MAX_PACKETS as usize); }
assert!(jitter.next.unwrap() >= 988);
}
#[test]
fn loss_duration_follows_rtp_clock_across_wrap_and_packet_sizes() {
if !have_opus() { return; }
for samples in [480, 960, 1920, 2880] {
let data = tone_samples(samples);
let mut decoder = Decoder::new().unwrap();
let mut jitter = Jitter::default();
let timestamp = u32::MAX - 239;
jitter.push(packet_at(65535, timestamp, &data));
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
jitter.push(packet_at(1, timestamp.wrapping_add(samples as u32 * 2), &data));
let loss = jitter.pop().unwrap();
assert_eq!(loss, Frame::Conceal(samples as u32));
assert_eq!(decoder.decode(&loss).unwrap().1, samples as u32);
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
assert!(jitter.pop().is_none());
}
}
#[test]
fn variable_losses_preserve_total_time_and_bound_discontinuities() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
let mut decoder = Decoder::new().unwrap();
jitter.push(packet_at(0, 0, &data));
decoder.decode(&jitter.pop().unwrap()).unwrap();
// Two missing packets total 50 ms; their individual durations cannot be inferred.
jitter.push(packet_at(3, 960 + 2400, &data));
let mut concealed = 0;
for _ in 0..2 { concealed += decoder.decode(&jitter.pop().unwrap()).unwrap().1; }
assert_eq!(concealed, 2400);
decoder.decode(&jitter.pop().unwrap()).unwrap();
jitter.push(packet_at(5, 48_000_000, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // discontinuity is not a huge loss
}
#[test]
fn ownership_lock_is_shared_across_config_directories() {
const CHILD: &str = "UU_MICROPHONE_TEST_LOCK";
if let Ok(source) = std::env::var(CHILD) {
assert!(route_lock(&source).is_err(), "a different UU_CONFIG bypassed the endpoint lock");
return;
}
let source = format!("uu-microphone-test-{}", std::process::id());
let lock = route_lock(&source).unwrap();
for config in ["first/config.json", "second/config.json"] {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::ownership_lock_is_shared_across_config_directories", "--exact"])
.env(CHILD, &source).env("UU_CONFIG", std::env::temp_dir().join(config))
.env("XDG_RUNTIME_DIR", std::env::temp_dir().join(config).with_extension("runtime"))
.env("TMPDIR", std::env::temp_dir().join(config).with_extension("temporary"))
.output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
}
drop(lock);
drop(route_lock(&source).expect("the lock must be released on drop"));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
#[test]
fn recovery_requires_exact_module_arguments_and_master() {
let args = vec!["source_name=uu-remote-microphone".into(), "master=uu-remote-mic-input.monitor".into(),
"source_properties=device.description=UU-Remote-Microphone".into(), "rate=48000".into(), "channels=2".into()];
let line = format!("42\tmodule-remap-source\t{}", args.join(" "));
assert_eq!(Module::matching_id(&line, "module-remap-source", &args), Some(42));
for foreign in [line.replace("master=uu-remote-mic-input.monitor", "master=physical-microphone"),
line.replace("description=UU-Remote-Microphone", "description=UU-Remote-Microphone-Foreign"),
format!("{line} remix=no")] {
assert_eq!(Module::matching_id(&foreign, "module-remap-source", &args), None);
}
}
#[test]
fn native_sink_options_are_not_applied_to_pipewire_or_unsupported_servers() {
assert_eq!(native_pulse("Server Name: pulseaudio\nServer Version: 13.0"), Ok(true));
assert_eq!(native_pulse("Server Name: PulseAudio (on PipeWire 1.6.9)\nServer Version: 15.0.0"), Ok(false));
assert!(native_pulse("Server Name: pulseaudio\nServer Version: 12.2").is_err());
assert!(native_pulse("Server Name: unsupported\nServer Version: 99.0").is_err());
assert!(native_pulse("").is_err());
}
#[test]
fn concurrent_track_claims_have_only_one_current_owner() {
let session = Session::new();
let claimed = Arc::new(std::sync::Barrier::new(2));
let workers: Vec<_> = (0..2).map(|_| {
let (session, claimed) = (session.clone(), claimed.clone());
std::thread::spawn(move || {
let (generation, mut owner) = session.claim_track();
claimed.wait(); // both workers start receiving only after both tracks have claimed
let current = *owner.borrow_and_update() == generation;
(generation, current)
})
}).collect();
let owners: Vec<_> = workers.into_iter().map(|w| w.join().unwrap()).collect();
assert_eq!(owners.iter().filter(|(_, current)| *current).count(), 1);
assert!(owners.contains(&(2, true)));
assert!(owners.contains(&(1, false)));
}
#[tokio::test]
async fn congested_reply_cannot_overwrite_a_later_close() {
let session = Session::new();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let (pending, wait_pending) = tokio::sync::oneshot::channel();
let (resume, wait_resume) = tokio::sync::oneshot::channel();
let sending = tokio::spawn(async move {
let notice = rx.recv().await.unwrap();
pending.send(()).unwrap();
wait_resume.await.unwrap(); // the ordered outbox is blocked in its network send
notice
});
session.action_with(23, || { tx.send(23).unwrap(); });
wait_pending.await.unwrap();
assert!(*session.open.borrow());
session.action(24); // independent TEXT callback closes while the CONTROL reply is pending
assert!(!*session.open.borrow());
resume.send(()).unwrap();
assert_eq!(sending.await.unwrap(), 23);
assert!(!*session.open.borrow(), "completing an old send must not apply an old policy");
}
#[test]
fn state_and_notice_enqueue_are_serialized_across_channels() {
let session = Session::new();
let notices = Arc::new(Mutex::new(Vec::new()));
let (inside, entered) = std::sync::mpsc::channel();
let release = Arc::new(std::sync::Barrier::new(2));
let open = {
let (session, notices, release) = (session.clone(), notices.clone(), release.clone());
std::thread::spawn(move || { session.action_with(23, || {
inside.send(()).unwrap();
release.wait();
notices.lock().unwrap().push(23);
}); })
};
entered.recv().unwrap();
let close = {
let (session, notices) = (session.clone(), notices.clone());
std::thread::spawn(move || { session.action_with(24, || { notices.lock().unwrap().push(24); }); })
};
release.wait();
open.join().unwrap(); close.join().unwrap();
assert_eq!(*notices.lock().unwrap(), [23, 24]);
assert!(!*session.open.borrow());
}
#[tokio::test]
async fn shutdown_waits_for_receivers_before_removing_endpoints() {
const CHILD: &str = "UU_MICROPHONE_TEST_SHUTDOWN";
if std::env::var_os(CHILD).is_none() {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::shutdown_waits_for_receivers_before_removing_endpoints", "--exact"])
.env(CHILD, "1").output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
return;
}
let worker = Worker::new();
let stopped = Arc::new(AtomicBool::new(false));
let finished = stopped.clone();
let task = tokio::spawn(async move {
let mut stopping = workers().stopped.subscribe();
stopping.wait_for(|stopped| *stopped).await.unwrap();
tokio::time::sleep(Duration::from_millis(20)).await;
finished.store(true, Ordering::Release);
drop(worker);
});
tokio::time::timeout(Duration::from_secs(1), shutdown()).await.unwrap();
assert!(stopped.load(Ordering::Acquire));
task.await.unwrap();
}
#[tokio::test]
async fn webrtc_microphone_obeys_mute_desktop_role_and_disconnect() {
if !have_opus() { return; }
tokio::time::timeout(Duration::from_secs(15), async {
let (left, right, router) = crate::test_network::virtual_network().await;
async fn peer(settings: webrtc::api::setting_engine::SettingEngine, registry: Registry) -> Arc<RTCPeerConnection> {
let mut m = webrtc::api::media_engine::MediaEngine::default();
m.register_default_codecs().unwrap();
Arc::new(webrtc::api::APIBuilder::new().with_media_engine(m).with_setting_engine(settings).with_interceptor_registry(registry)
.build().new_peer_connection(Default::default()).await.unwrap())
}
let pause = Arc::new(ReadPause::default());
let sender = peer(left, Registry::new()).await;
let host = peer(right, pause_registry(pause.clone())).await;
// Match the real host: its existing desktop sound track negotiates a bidirectional m-line.
host.add_track(Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "desktop-sound".into(), "host".into()))).await.unwrap();
let track = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "mic".into(), "generated-tone".into()));
sender.add_track(track.clone()).await.unwrap();
let replacement = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "replacement-mic".into(), "generated-tone".into()));
sender.add_track(replacement.clone()).await.unwrap();
let (created, mut outputs) = tokio::sync::mpsc::unbounded_channel();
let session = Session { factory: Arc::new(move || {
let (writer, reader) = tokio::io::duplex(65536);
created.send(reader).unwrap();
Ok(Playback { decoder: Decoder::new()?, writer: Box::pin(writer), output: None })
}), ..Session::new() };
assert!(!session.action(2));
assert!(session.action(24));
let (desktop, active) = watch::channel(true);
session.attach(&host, active);
let mut gathered = sender.gathering_complete_promise().await;
let offer = sender.create_offer(None).await.unwrap();
sender.set_local_description(offer).await.unwrap(); gathered.recv().await;
host.set_remote_description(sender.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
let answer = host.create_answer(None).await.unwrap();
host.set_local_description(answer).await.unwrap(); gathered.recv().await;
sender.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while sender.connection_state() != RTCPeerConnectionState::Connected { tokio::time::sleep(Duration::from_millis(10)).await; }
let data = tone();
let sending = tokio::spawn(async move {
for seq in 0..500 { let _ = track.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(outputs.try_recv().is_err()); // muted before the first packet
session.action(23);
let mut pcm = outputs.recv().await.unwrap();
let mut frame = vec![0; 3840];
pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
// Playback must keep pace with a continuous 20 ms source, not add a polling delay
// to every frame (which eventually overflows the jitter buffer and skips speech).
let mut played_frames = 0;
let _ = tokio::time::timeout(Duration::from_millis(600), async {
loop { pcm.read_exact(&mut frame).await.unwrap(); played_frames += 1; }
}).await;
assert!((25..=35).contains(&played_frames), "wrong real-time playout rate: {played_frames} frames / 600 ms");
pause.requested.store(true, Ordering::Release);
pause.entered.notified().await;
// Span several playout ticks and at least two health ticks with a consumed RTP packet.
tokio::time::sleep(Duration::from_millis(250)).await;
pause.resume.notify_one();
tokio::time::timeout(Duration::from_secs(1), pause.completed.notified()).await
.expect("timer ticks cancelled a pending RTP read and lost its packet");
let data = tone();
let replacing = tokio::spawn(async move {
for seq in 0..500 { let _ = replacement.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
let mut replacement_pcm = outputs.recv().await.unwrap();
replacement_pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
let mut pcm = replacement_pcm;
session.action(24);
let mut remainder = Vec::new();
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut remainder)).await.unwrap().unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err());
desktop.send_replace(false);
session.action(23);
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err()); // a demoted desktop cannot inject audio
desktop.send_replace(true);
let mut resumed = outputs.recv().await.unwrap();
resumed.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
host.close().await.unwrap(); sender.close().await.unwrap();
tokio::time::timeout(Duration::from_secs(1), resumed.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
sending.abort(); replacing.abort(); router.lock().await.stop().await.unwrap();
}).await.expect("microphone WebRTC integration timed out");
}
/// Explicit opt-in only; records the generated tone from our isolated virtual source in memory.
#[tokio::test]
#[ignore]
async fn pipewire_virtual_microphone_receives_generated_tone() {
assert!(requested(), "run with UU_MICROPHONE=1; the test creates independent audio endpoints");
let sink = format!("uu-mic-test-input-{}", std::process::id());
let source = format!("uu-mic-test-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
let mut player = Playback::at(&sink).unwrap();
let (stop, mut stopped) = watch::channel(false);
let generating = tokio::spawn(async move {
let data = tone();
for _ in 0..100 {
if *stopped.borrow() { break; }
player.write(&Frame::Opus(data.clone())).await.unwrap();
tokio::select! { _ = stopped.changed() => break, _ = tokio::time::sleep(Duration::from_millis(20)) => {} }
}
player.stop().await;
});
let received = tokio::time::timeout(Duration::from_secs(4), async {
let mut frame = vec![0; 3840];
loop { capture.read_exact(&mut frame).await?; if rms(&frame) > 1000. { return Ok::<_, std::io::Error>(()); } }
}).await;
let inputs = pactl(&["--format=json", "list", "sink-inputs"]);
let devices = [pactl(&["--format=json", "list", "sinks"]), pactl(&["--format=json", "list", "sources"])];
let stopped = recorder.kill().await;
stop.send_replace(true);
let generated = generating.await;
drop(route);
let sources = pactl(&["list", "short", "sources"]).unwrap();
assert!(!sources.lines().any(|line| line.split('\t').nth(1) == Some(source.as_str())));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
stopped.unwrap();
assert!(!generated.is_err_and(|e| e.is_panic()), "tone generator panicked");
received.expect("generated tone did not reach the virtual microphone").unwrap();
let inputs: serde_json::Value = serde_json::from_str(&inputs.unwrap()).unwrap();
let pid = std::process::id().to_string();
let properties = inputs.as_array().unwrap().iter().find_map(|input| {
let properties = input.get("properties")?;
(properties.get("application.process.id")?.as_str()? == pid
&& properties.get("media.name")?.as_str()? == crate::i18n::s("远程麦克风", "Remote-Microphone")).then_some(properties)
}).expect("localized microphone stream missing");
assert_eq!(properties["application.name"], crate::i18n::s("UU 远程麦克风", "UU Remote microphone"));
for (data, name, description) in [
(&devices[0], &sink, crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input")),
(&devices[1], &source, crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone")),
] {
let devices: serde_json::Value = serde_json::from_str(data.as_ref().unwrap()).unwrap();
let device = devices.as_array().unwrap().iter().find(|device| device["name"] == name.as_str()).unwrap();
assert_eq!(device["description"], description);
}
}
/// Run through contrib/check-microphone-pulse.py, never against the desktop's audio server.
#[tokio::test]
#[ignore]
async fn pulse_target_loss_never_routes_to_default_output() {
assert_eq!(std::env::var("UU_MICROPHONE_ISOLATED_TEST").as_deref(), Ok("1"));
assert!(std::env::var("PULSE_SERVER").is_ok_and(|s| s.starts_with("unix:")));
assert!(pactl(&["list", "short", "sinks"]).unwrap().is_empty(), "requires an empty isolated server");
assert!(pactl(&["list", "short", "sources"]).unwrap().is_empty(), "requires an empty isolated server");
let fallback_name = format!("uu-mic-test-default-{}", std::process::id());
let fallback = Module::open("module-null-sink", sink_args(&fallback_name).unwrap()).unwrap();
struct Fallback(Module);
impl Drop for Fallback { fn drop(&mut self) { self.0.unload(); } }
let _fallback = Fallback(fallback);
pactl(&["set-default-sink", &fallback_name]).unwrap();
let sink = format!("uu-mic-test-pinned-{}", std::process::id());
let source = format!("uu-mic-test-pinned-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut player = Playback::at(&sink).unwrap();
let generating = tokio::spawn(async move {
let frame = Frame::Opus(tone());
let mut failed_closed = false;
for _ in 0..150 {
if player.write(&frame).await.is_err() { failed_closed = true; break; }
tokio::time::sleep(Duration::from_millis(20)).await;
}
player.stop().await;
failed_closed
});
tokio::time::timeout(Duration::from_secs(3), async {
while pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
}).await.unwrap();
let mut probe = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut baseline = probe.stdout.take().unwrap();
let flowing = tokio::time::timeout(Duration::from_secs(3), async {
let mut frame = vec![0; 3840];
let mut audible = 0;
loop {
baseline.read_exact(&mut frame).await?;
audible = if rms(&frame) > 1000. { audible + 1 } else { 0 };
if audible >= 15 { return Ok::<_, std::io::Error>(()); } // 300 ms of healthy playback
}
}).await;
let probe_stopped = probe.kill().await;
if !matches!(&flowing, Ok(Ok(()))) {
generating.abort(); let _ = generating.await;
panic!("no sustained generated tone before removing the target: {flowing:?}");
}
probe_stopped.unwrap();
flowing.expect("no sustained generated tone before removing the target").unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={fallback_name}.monitor"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(!generating.is_finished(), "playback failed before the target was removed");
route.source.unload(); route.sink.unload(); // remove the target while audio is still flowing
let mut generating = generating;
let ended = tokio::time::timeout(Duration::from_secs(2), &mut generating).await;
if ended.is_err() { generating.abort(); let _ = generating.await; }
let mut peak = 0.0_f64;
let observed = async {
let deadline = tokio::time::sleep(Duration::from_millis(350));
tokio::pin!(deadline);
let mut frame = vec![0; 3840];
loop { tokio::select! {
_ = &mut deadline => break,
read = capture.read_exact(&mut frame) => { read?; peak = peak.max(rms(&frame)); },
} }
Ok::<_, std::io::Error>(())
}.await;
recorder.kill().await.unwrap();
observed.unwrap();
assert!(ended.expect("playback did not stop after its target disappeared").unwrap());
assert!(pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty());
assert_eq!(peak, 0.0, "microphone audio reached the default output");
drop(route);
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
+39 -3
View File
@@ -12,7 +12,7 @@ mod record;
mod tool;
pub use mode::Mode;
use std::sync::{atomic::{AtomicBool, Ordering}, Mutex};
use std::sync::{atomic::{AtomicBool, AtomicU64, Ordering}, Mutex};
struct Active { mode: Mode, record: Option<record::Record> }
struct State { sessions: usize, active: Option<Active> }
@@ -25,6 +25,9 @@ static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection
/// opens but before `session_started` bumps the counter.
static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false);
/// Bumped when a new first desktop session spawns its auto-enable thread. A reconnect that beats
/// the 500 ms poll would otherwise leave the old waiter running for up to five minutes.
static AUTO_GENERATION: AtomicU64 = AtomicU64::new(0);
/// iOS viewers encode "screen off" as `enable=0, type=3`, and Windows viewers carry every request
/// in `type` with `enable=0`; see `protocol::Request::normalize_ios_screen_off` and
/// `protocol::Request::normalize_windows`.
@@ -182,10 +185,42 @@ fn auto_set(mode: Mode) -> Result<bool, String> {
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
result.map(|_| true)
}
/// The watch is authoritative while it has a value. A None (the logind monitor lost the session)
/// must not fail open: ask logind directly before covering a possibly locked desktop.
fn currently_locked() -> bool {
let locked = crate::session_lock::watch_locked();
let state = *locked.borrow();
match state {
Some(state) => state,
None => crate::session_lock::locked_now() == Some(true),
}
}
/// The capture session and the viewer's CONTROL state need a moment after the peer connects;
/// retry while the portal session is still missing, and let the viewer's RPC 7 win if it arrives.
fn auto_enable(mode: Mode) {
fn auto_enable(mode: Mode, generation: u64) {
// A locked desktop is already covered. Switching the share to the virtual output would hide
// the lock screen the viewer needs to unlock, so wait for the local unlock first. Bounded:
// a viewer that never unlocks, or leaves, must not hold this thread forever.
let current = || AUTO_GENERATION.load(Ordering::Acquire) == generation;
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(300);
while currently_locked() {
if !current() { return; }
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
log::info!("Privacy auto: skipped, the viewer already chose a mode");
return;
}
if STATE.try_lock().is_ok_and(|state| state.sessions == 0) {
log::info!("Privacy auto: skipped, the desktop session ended");
return;
}
if std::time::Instant::now() >= deadline {
log::info!("Privacy auto: desktop stayed locked; not covering it");
return;
}
std::thread::sleep(std::time::Duration::from_millis(500));
}
for attempt in 1..=5 {
if !current() { return; }
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
log::info!("Privacy auto: skipped, the viewer already chose a mode");
return;
@@ -215,9 +250,10 @@ pub fn session_started() {
let first = STATE.lock().ok().is_some_and(|mut s| { s.sessions += 1; s.sessions == 1 });
let Some(mode) = auto else { return };
if !first { return; }
let generation = AUTO_GENERATION.fetch_add(1, Ordering::AcqRel) + 1;
std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(1500));
auto_enable(mode);
auto_enable(mode, generation);
});
}
pub fn session_ended() {
+74 -19
View File
@@ -11,11 +11,15 @@
//! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes
//! and gives an exact wrong-password result. The password is never logged or stored.
use std::process::Command;
use std::process::{Command, Stdio};
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use std::time::Duration;
use tokio::sync::watch;
mod logind;
/// Official UnlockResult cases (LockScreenManager).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed }
@@ -29,10 +33,44 @@ extern "C" {
fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int;
}
// Resolve once: execvp's unsuccessful PATH candidates are also recorded by auditd.
fn loginctl_path() -> Option<&'static Path> {
static PATH: OnceLock<Option<PathBuf>> = OnceLock::new();
PATH.get_or_init(|| {
std::env::var_os("PATH").into_iter().flat_map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
.map(|dir| dir.join("loginctl"))
.find(|path| path.is_file() && std::ffi::CString::new(path.as_os_str().as_encoded_bytes())
.map(|p| unsafe { libc::access(p.as_ptr(), libc::X_OK) == 0 }).unwrap_or(false))
.and_then(|path| std::fs::canonicalize(path).ok())
}).as_deref()
}
#[cfg(test)]
static COMMAND_STARTS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
fn bounded_command(path: &Path, args: &[&str], timeout: Duration) -> Option<String> {
use std::io::Read;
#[cfg(test)]
COMMAND_STARTS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let mut child = Command::new(path).args(args).stdin(Stdio::null()).stdout(Stdio::piped())
.stderr(Stdio::null()).spawn().ok()?;
let deadline = std::time::Instant::now() + timeout;
loop {
match child.try_wait() {
Ok(Some(status)) => {
if !status.success() { return None; }
let mut text = String::new();
child.stdout.take()?.take(4096).read_to_string(&mut text).ok()?;
return Some(text.trim().to_owned());
}
Ok(None) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
_ => { let _ = child.kill(); let _ = child.wait(); return None; }
}
}
}
fn loginctl(args: &[&str]) -> Option<String> {
let out = Command::new("loginctl").args(args).output().ok()?;
if !out.status.success() { return None; }
Some(String::from_utf8_lossy(&out.stdout).trim().to_string()).filter(|s| !s.is_empty())
bounded_command(loginctl_path()?, args, Duration::from_secs(3)).filter(|s| !s.is_empty())
}
/// The logind session that owns this user's graphical display.
@@ -44,7 +82,7 @@ fn display_session() -> Option<String> {
pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) }
fn session_locked(session: &str) -> Option<bool> {
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).map(|v| v == "yes")
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).and_then(|v| match v.as_str() { "yes" => Some(true), "no" => Some(false), _ => None })
}
fn user_name() -> Option<String> {
@@ -78,30 +116,28 @@ pub fn supported() -> bool {
*SUPPORTED.get_or_init(|| pam_available() && display_session().is_some())
}
/// Current lock state (None = unknown), refreshed every second by one background thread.
/// Current lock state (None = unknown), shared by all desktop connections.
pub fn watch_locked() -> watch::Receiver<Option<bool>> {
static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new();
STATE.get_or_init(|| {
let (tx, _) = watch::channel(None);
let sender = tx.clone();
std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || {
let mut session = None;
loop {
if session.is_none() { session = display_session(); }
let locked = session.as_deref().and_then(session_locked);
if locked.is_none() { session = None; } // session ended or changed: look it up again
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
*current = locked; true
} else { false });
std::thread::sleep(Duration::from_secs(1));
}
tokio::runtime::Builder::new_current_thread().enable_all().build()
.expect("lock monitor runtime").block_on(logind::monitor(sender));
}).expect("spawn lock state thread");
tx
}).subscribe()
}
fn publish_lock_state(sender: &watch::Sender<Option<bool>>, locked: Option<bool>) {
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
*current = locked; true
} else { false });
}
/// Verifies the session user's password and unlocks the display session. Blocking (PAM may
/// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password.
pub fn unlock(password: String) -> UnlockResult {
@@ -117,7 +153,7 @@ fn unlock_with(password: &str) -> UnlockResult {
let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser };
if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; }
match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed }
if Command::new("loginctl").args(["unlock-session", &session]).status().map(|s| !s.success()).unwrap_or(true) {
if loginctl_path().and_then(|path| bounded_command(path, &["unlock-session", &session], Duration::from_secs(3))).is_none() {
return UnlockResult::NoPermission;
}
if let Err(error) = crate::capture::keep_display_awake() {
@@ -204,6 +240,25 @@ pub fn password_from_args(args: &[u8]) -> Option<String> {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn unknown_state_is_preserved_and_repeated_states_do_not_notify() {
let (tx, mut rx) = watch::channel(Some(true));
publish_lock_state(&tx, None);
assert_eq!(*rx.borrow_and_update(), None);
publish_lock_state(&tx, None);
assert!(!rx.has_changed().unwrap());
publish_lock_state(&tx, Some(false));
assert!(rx.has_changed().unwrap());
assert_eq!(*rx.borrow_and_update(), Some(false));
}
#[test]
fn hung_fallback_is_killed_and_reaped() {
let start = std::time::Instant::now();
assert_eq!(bounded_command(Path::new("/bin/sleep"), &["10"], Duration::from_millis(30)), None);
assert!(start.elapsed() < Duration::from_secs(2));
}
#[test]
fn password_comes_from_the_official_key_field() {
assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word"));
+208
View File
@@ -0,0 +1,208 @@
//! logind signals replace per-second process spawning; loginctl is a bounded fallback.
use super::{publish_lock_state, Duration};
use futures_util::StreamExt;
use tokio::sync::watch;
use zbus::{Connection, MatchRule, MessageStream, Proxy, proxy::CacheProperties};
const SERVICE: &str = "org.freedesktop.login1";
const ROOT: &str = "/org/freedesktop/login1";
const CALL_TIMEOUT: Duration = Duration::from_secs(5);
const RETRY: Duration = Duration::from_secs(30);
async fn locked(connection: &Connection) -> zbus::Result<Option<bool>> {
let path = format!("{ROOT}/user/_{}", unsafe { libc::getuid() });
let user = zbus::proxy::Builder::<Proxy<'_>>::new(connection).destination(SERVICE)?
.path(path)?.interface("org.freedesktop.login1.User")?
.cache_properties(CacheProperties::No).build().await?;
// No cached property reads: signals, including invalidations, trigger a fresh snapshot.
let display: (String, zbus::zvariant::OwnedObjectPath) = user.get_property("Display").await?;
if display.0.is_empty() { return Ok(None); }
let session = zbus::proxy::Builder::<Proxy<'_>>::new(connection).destination(SERVICE)?
.path(display.1)?.interface("org.freedesktop.login1.Session")?
.cache_properties(CacheProperties::No).build().await?;
session.get_property("LockedHint").await.map(Some)
}
async fn snapshot(connection: &Connection) -> zbus::Result<Option<bool>> {
tokio::time::timeout(CALL_TIMEOUT, locked(connection)).await
.map_err(|_| zbus::Error::Failure("lock query timed out".into()))?
}
async fn monitor_connection(connection: &Connection, sender: &watch::Sender<Option<bool>>) -> zbus::Result<()> {
// Subscribe before reading: any change during the first snapshot stays queued.
// Watch all logind signals so User.Display, SessionNew/Removed and invalidated
// properties also re-resolve the graphical session instead of trusting a stale path.
let rule = MatchRule::builder().msg_type(zbus::message::Type::Signal)
.sender(SERVICE)?.path_namespace(ROOT)?.build();
let mut signals = tokio::time::timeout(CALL_TIMEOUT, MessageStream::for_match_rule(rule, connection, Some(64))).await
.map_err(|_| zbus::Error::Failure("lock subscription timed out".into()))??;
publish_lock_state(sender, snapshot(connection).await?);
let mut reconcile = tokio::time::interval(RETRY);
reconcile.tick().await;
loop {
tokio::select! {
event = signals.next() => { event.ok_or_else(|| zbus::Error::Failure("system bus closed".into()))??; },
_ = reconcile.tick() => {},
}
publish_lock_state(sender, snapshot(connection).await?);
}
}
pub(super) async fn monitor(sender: watch::Sender<Option<bool>>) {
let mut degraded = false;
loop {
let result = tokio::time::timeout(CALL_TIMEOUT, async { zbus::connection::Builder::system()?.method_timeout(CALL_TIMEOUT).build().await }).await;
if let Ok(Ok(connection)) = result {
if !degraded { log::debug!("Desktop lock monitor: logind D-Bus"); }
// Recovery is announced only after a valid snapshot, via the state channel.
let _ = monitor_connection(&connection, &sender).await;
}
publish_lock_state(&sender, None);
if !degraded { log::warn!("Desktop lock monitor unavailable; retrying D-Bus with bounded loginctl fallback every 30s"); }
degraded = true;
let fallback = tokio::task::spawn_blocking(super::locked_now).await.ok().flatten();
publish_lock_state(&sender, fallback);
tokio::time::sleep(RETRY).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Arc, Mutex, atomic::{AtomicBool, Ordering}};
use zbus::zvariant::{OwnedObjectPath, Value};
struct User(Arc<Mutex<String>>);
#[zbus::interface(name = "org.freedesktop.login1.User")]
impl User {
#[zbus(property)]
fn display(&self) -> (String, OwnedObjectPath) {
let id = self.0.lock().unwrap().clone();
let path = if id.is_empty() { "/".into() } else { format!("{ROOT}/session/{id}") };
(id, OwnedObjectPath::try_from(path).unwrap())
}
}
struct Session { locked: Arc<AtomicBool>, valid: Arc<AtomicBool> }
#[zbus::interface(name = "org.freedesktop.login1.Session")]
impl Session {
#[zbus(property)]
fn locked_hint(&self) -> zbus::fdo::Result<bool> {
if !self.valid.load(Ordering::SeqCst) { return Err(zbus::fdo::Error::Failed("unavailable".into())); }
Ok(self.locked.load(Ordering::SeqCst))
}
}
async fn expect(rx: &mut watch::Receiver<Option<bool>>, value: Option<bool>) {
tokio::time::timeout(Duration::from_secs(3), async {
loop {
let current = *rx.borrow_and_update();
if current == value { return; }
rx.changed().await.unwrap();
}
}).await.expect("lock state update");
}
async fn invalidated(server: &Connection, path: &str, interface: &str, property: &str) {
// An invalidation has no replacement value: the client must re-read it.
let changed = std::collections::HashMap::<&str, Value<'_>>::new();
server.emit_signal(None::<&str>, path, "org.freedesktop.DBus.Properties", "PropertiesChanged",
&(interface, changed, vec![property])).await.unwrap();
}
#[tokio::test]
#[ignore = "isolated D-Bus integration; requires dbus-daemon, never changes the real desktop"]
async fn private_bus_tracks_initial_state_invalidation_session_change_and_failure() {
use tokio::io::{AsyncBufReadExt, BufReader};
let mut daemon = tokio::process::Command::new("dbus-daemon")
.args(["--session", "--nofork", "--print-address=1"])
.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::null())
.kill_on_drop(true).spawn().unwrap();
let mut address = String::new();
tokio::time::timeout(Duration::from_secs(3), BufReader::new(daemon.stdout.take().unwrap()).read_line(&mut address)).await.unwrap().unwrap();
let address = address.trim();
let display = Arc::new(Mutex::new(String::new()));
let locked = Arc::new(AtomicBool::new(true));
let valid = Arc::new(AtomicBool::new(true));
let user_path = format!("{ROOT}/user/_{}", unsafe { libc::getuid() });
let server = zbus::connection::Builder::address(address).unwrap().name(SERVICE).unwrap()
.serve_at(user_path.clone(), User(display.clone())).unwrap()
.serve_at(format!("{ROOT}/session/a"), Session { locked: locked.clone(), valid: valid.clone() }).unwrap()
.serve_at(format!("{ROOT}/session/b"), Session { locked: Arc::new(AtomicBool::new(true)), valid: valid.clone() }).unwrap()
.build().await.unwrap();
let client = zbus::connection::Builder::address(address).unwrap().build().await.unwrap();
let (tx, mut rx) = watch::channel(Some(false));
let monitor = tokio::spawn(async move {
let result = monitor_connection(&client, &tx).await;
publish_lock_state(&tx, None);
result
});
expect(&mut rx, None).await;
assert!(!monitor.is_finished(), "no graphical session must keep the D-Bus subscription alive");
*display.lock().unwrap() = "a".into();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, Some(true)).await; // login is observed without waiting for the retry timer
locked.store(false, Ordering::SeqCst);
invalidated(&server, &format!("{ROOT}/session/a"), "org.freedesktop.login1.Session", "LockedHint").await;
expect(&mut rx, Some(false)).await;
*display.lock().unwrap() = "b".into();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, Some(true)).await;
display.lock().unwrap().clear();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, None).await;
assert!(!monitor.is_finished(), "logout must keep the D-Bus subscription alive");
*display.lock().unwrap() = "b".into();
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
expect(&mut rx, Some(true)).await;
valid.store(false, Ordering::SeqCst);
invalidated(&server, &format!("{ROOT}/session/b"), "org.freedesktop.login1.Session", "LockedHint").await;
expect(&mut rx, None).await; // failure must not become unlocked
assert!(monitor.await.unwrap().is_err());
// A fresh connection must recover after a service/property failure.
valid.store(true, Ordering::SeqCst);
let client = zbus::connection::Builder::address(address).unwrap().build().await.unwrap();
let close = client.clone();
let (tx, mut rx) = watch::channel(None);
let monitor = tokio::spawn(async move {
let result = monitor_connection(&client, &tx).await;
publish_lock_state(&tx, None);
result
});
expect(&mut rx, Some(true)).await;
close.close().await.unwrap();
expect(&mut rx, None).await;
assert!(monitor.await.unwrap().is_err());
daemon.kill().await.unwrap();
daemon.wait().await.unwrap();
}
#[tokio::test]
#[ignore = "manual acceptance: observes a real lock/unlock for up to three minutes"]
async fn live_lock_unlock_signals() {
let before = super::super::COMMAND_STARTS.load(Ordering::SeqCst);
let mut rx = super::super::watch_locked();
let start = std::time::Instant::now();
tokio::time::timeout(Duration::from_secs(180), async {
let mut saw_lock = false;
loop {
let state = *rx.borrow_and_update();
println!("live lock state: {state:?}; elapsed_ms={}", start.elapsed().as_millis());
if state == Some(true) { saw_lock = true; }
if saw_lock && state == Some(false) { break; }
rx.changed().await.unwrap();
}
}).await.expect("please lock and unlock the desktop during this probe");
let started = super::super::COMMAND_STARTS.load(Ordering::SeqCst) - before;
println!("lock monitor command starts: {started}");
assert_eq!(started, 0, "healthy D-Bus monitoring should not spawn loginctl");
}
#[tokio::test]
#[ignore = "read-only live logind probe; requires an active graphical logind session"]
async fn live_logind_snapshot_matches_loginctl_without_changing_lock_state() {
let connection = Connection::system().await.unwrap();
let dbus = snapshot(&connection).await.unwrap();
let command = tokio::task::spawn_blocking(super::super::locked_now).await.unwrap();
assert_eq!(dbus, command);
}
}
+27 -2
View File
@@ -300,15 +300,26 @@ impl PeerActions {
/// 0 is always sent), 21 virtual_audio_driver_policy_req -> 17 (no virtual driver needed: the
/// sink monitor is captured directly). Responses carry error_code 0 (default).
pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
session_rpc_response_with_error(rpc, 0)
}
pub fn session_rpc_response_with_error(rpc: &[crate::protocol::WireField], error: u8) -> Option<Vec<u8>> {
use crate::protocol::{decode_wire, WireValue};
let body = |n: u32| rpc.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None });
let (request, response_field) = [(15u32, 11u8), (21, 17)].into_iter().find_map(|(req, resp)| body(req).map(|b| (b, resp)))?;
let value = decode_wire(request).ok().and_then(|f| f.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }));
log::info!("Session RPC answered: response_field={} value={:?}", response_field, value);
let header = body(1).unwrap_or(&[]);
let mut out = vec![10, header.len() as u8];
fn varint(mut value: usize, out: &mut Vec<u8>) {
while value >= 128 { out.push((value as u8 & 127) | 128); value >>= 7; }
out.push(value as u8);
}
let mut out = vec![10];
varint(header.len(), &mut out);
out.extend_from_slice(header);
out.extend_from_slice(&[response_field << 3 | 2, 0]);
// Field 17 has a two-byte tag (0x8a 0x01). A truncated tag prevents the client's
// microphone request from completing even though the data channel delivers it.
varint(usize::from(response_field) << 3 | 2, &mut out);
if error == 0 { out.push(0); } else { out.extend([2, 8, error]); }
Some(out)
}
@@ -337,6 +348,20 @@ pub fn plugin_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
mod tests {
use super::*;
#[test]
fn virtual_audio_policy_reply_completes_field_17_and_preserves_request_id() {
use crate::protocol::{decode_wire, WireValue};
let request = [10, 2, 8, 9, 170, 1, 2, 8, 1];
let rpc = decode_wire(&request).unwrap();
let response = session_rpc_response(&rpc).unwrap();
let fields = decode_wire(&response).expect("valid protobuf reply, including the field 17 tag");
assert_eq!(fields[0].value, WireValue::Bytes(&[8, 9]));
assert_eq!(fields[1].number, 17);
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
let denied = session_rpc_response_with_error(&rpc, 1).unwrap();
let fields = decode_wire(&denied).unwrap();
assert_eq!(fields[1].value, WireValue::Bytes(&[8, 1]));
}
#[test]
fn toggle_values_from_value_field_json_and_text() {
assert!(!toggle_value(Some(0), b"1"));
assert!(toggle_value(Some(1), b""));
+3 -1
View File
@@ -67,7 +67,9 @@ pub fn load_font() -> Option<FontVec> {
let (path, index) = match std::env::var("UU_VIEWER_FONT") {
Ok(p) if !p.is_empty() => (p, 0),
_ => {
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn"]).output().ok()?;
// Request U+63A7 (控, from 控制中心) to prefer a CJK-capable font;
// the HUD uses a single font without per-glyph fallback.
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn:charset=63a7"]).output().ok()?;
let line = String::from_utf8(out.stdout).ok()?;
let (file, index) = line.split_once('\t').unwrap_or((line.as_str(), "0"));
// fontconfig puts the variable-font named instance in the upper 16 bits; the face is below.
+32 -1
View File
@@ -274,6 +274,8 @@ impl WebRtcSession {
let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
let microphone = crate::microphone::Session::new();
if crate::microphone::available() { microphone.attach(&pc, role.active.subscribe()); }
let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc));
@@ -530,6 +532,7 @@ impl WebRtcSession {
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(()));
let data_role = role.clone();
let data_microphone = microphone.clone();
// 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string();
@@ -538,6 +541,7 @@ impl WebRtcSession {
let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone();
let channel_role=data_role.clone();
let channel_microphone = data_microphone.clone();
let screen = control_capture.clone();
let portal_desktop = portal_desktop.clone();
let desktop_pc = desktop_pc.clone();
@@ -708,7 +712,7 @@ impl WebRtcSession {
}
let live = state.screen.init_error.is_none()
&& (cfg!(test) || state.screen.portal.as_ref().is_some_and(|portal| portal.is_alive()))
&& *manager.lock_state().borrow() == Some(false);
&& manager.capture_allowed(*manager.lock_state().borrow());
if live { break Some(state.screen); }
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; }
@@ -1169,6 +1173,7 @@ impl WebRtcSession {
let input_worker = inp.clone();
let message_input_session=channel_role.input();
let message_role=channel_role.clone();
let message_microphone = channel_microphone.clone();
let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone();
let text_out = text_out.clone();
@@ -1244,6 +1249,30 @@ impl WebRtcSession {
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return;
}
if let Some(policy) = rpc_fields.as_deref().and_then(crate::microphone::policy_request) {
let supported = policy <= 1 && crate::microphone::available() && message_role.is_desktop();
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);
let response = crate::system_actions::session_rpc_response_with_error(rpc_fields.as_deref().unwrap(), u8::from(!supported)).unwrap();
let response = crate::initialization::envelope(next(), ts, 22, &response);
// Windows NevaudioHelper completes the request on TEXT; mirror CONTROL
// for viewers that dispatch responses there, as for privacy RPCs.
let enqueue = |message: Vec<u8>| {
let _ = text_out.send(message.clone());
if channel_name != "TEXT_DATA_CHANNEL" { let _ = rpc_out.send(message); }
};
if supported {
let action = if policy == 1 { 23 } else { 24 };
// Use the channel's ordered outbox: a stalled SCTP send must
// never delay this state transition past a later close on TEXT.
message_microphone.action_with(action, || {
enqueue(response);
enqueue(crate::initialization::envelope(next(), ts, 3, &[8, action as u8]));
});
} else { enqueue(response); }
log::info!("Remote microphone policy: value={policy} supported={supported}");
return;
}
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
@@ -1452,6 +1481,8 @@ impl WebRtcSession {
} else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
}
} else if matches!(action, 23 | 24) && crate::microphone::available() && message_role.is_desktop() {
message_microphone.action(action);
} else if action > 1 && action != 15 {
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
+18 -1
View File
@@ -83,10 +83,18 @@ pub fn lan_info() -> Option<(String, String, String)> {
#[cfg(not(target_os = "linux"))]
pub fn lan_info() -> Option<(String, String, String)> { None }
/// Body of the helper registration request (same address as `inner_ip` and `ip`: this host has one LAN address).
fn report_body(mac: &str, ip: &str, subnet_mask: &str) -> serde_json::Value {
serde_json::json!({ "mac": mac, "inner_ip": ip, "ip": ip, "subnet_mask": subnet_mask })
}
/// Report this host's LAN identity like the official host after sign-in.
/// The server rejects the report (HTTP 422, code 1001) unless `inner_ip` is present; the official macOS
/// client sends `inner_ip`, `ip`, `mac` and `subnet_mask`. Verified live: with `inner_ip` the helper is
/// accepted (HTTP 200) and the cloud forwards `wake_on_lan` pushes to this host.
pub async fn report(auth: &crate::auth::UUAuthClient) {
let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; };
let body = serde_json::json!({ "mac": mac, "ip": ip, "subnet_mask": subnet_mask });
let body = report_body(&mac, &ip, &subnet_mask);
match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await {
Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}",
value.get("code").and_then(serde_json::Value::as_i64),
@@ -108,6 +116,15 @@ mod tests {
assert_eq!(&packet[..6], &[0xff; 6]);
assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]);
}
#[test]
fn report_body_has_inner_ip() {
let body = report_body("aa:bb:cc:dd:ee:01", "192.168.2.29", "255.255.255.0");
assert_eq!(body["inner_ip"], "192.168.2.29");
assert_eq!(body["ip"], "192.168.2.29");
assert_eq!(body["mac"], "aa:bb:cc:dd:ee:01");
assert_eq!(body["subnet_mask"], "255.255.255.0");
}
#[test]
fn directed_broadcast() {
assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255)));