mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Privacy: recover the input devices after a reboot renumbers them (#173)
* fix(privacy): match recorded input devices after a reboot The recovery record stores KWin's `eventN` sysNames, but udev renumbers them between boots. A record replayed after a reboot (privacy was on at shutdown) then set `enabled` on a device path that no longer exists; the restore failed, kept the record, and every later switch failed at the same step. The device that had been blocked could also stay disabled. Records now keep name/product/vendor next to the sysName, and a restore matches the current device by that identity, falling back to the exact sysName for older string-only records. A device that no longer exists is skipped with a log line instead of failing the restore, so the record, the guard and the outputs are cleaned up; a device that exists but cannot be enabled still fails and keeps the record for the next attempt. Verified by replaying records with the release build on KDE Plasma 6.8: a stale `event14` for a mouse now on `event12` is re-enabled and the record removed; a record for a missing device logs the skip and restores normally. `cargo test --features wayland,portal`: 330 passed, 10 ignored. * fix(privacy): restore every device sharing an identity - enable every current device whose identity matches a record entry, deduplicated by sysName: two record entries can describe one device, and one identity can cover several (identical keyboards, or a receiver exposing several event nodes under the same name) - a failed property read during restore is an error instead of a missing device, so the record and the guard stay for the next attempt; blocking keeps the lenient read - the gone-device warning logs a count only, matching the log-privacy rule * fix(privacy): re-enable readable devices before reporting incomplete enumeration A failed property read during restore no longer aborts enumeration before set_sys runs: the readable matching devices are re-enabled first, then the incomplete read is returned as an error so the record and the guard stay for another attempt. Blocking still skips unreadable devices.
This commit is contained in:
1 parent
b9586f226d
commit
f67de7cc7d
2 files changed
+176
-15
No files matched your search
+172
-12
@@ -1,24 +1,87 @@
|
||||
//! Local input devices through KWin's InputDevice D-Bus interface (sysName `eventN`). KWin saves
|
||||
//! the enabled flag, which is why the controller runs the guard.
|
||||
//!
|
||||
//! `eventN` comes from udev enumeration and can change between boots, while a recovery record may
|
||||
//! be replayed after a reboot. Records therefore store the name/product/vendor KWin reports next
|
||||
//! to the sysName, and a restore matches the current device by that identity.
|
||||
use super::super::tool::{gdbus, variant};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
|
||||
/// One blocked device. `Legacy` is a record written before identities were stored.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(untagged)]
|
||||
pub enum Device {
|
||||
Named { sys: String, name: String, product: u32, vendor: u32 },
|
||||
Legacy(String),
|
||||
}
|
||||
|
||||
impl Device {
|
||||
pub fn sys(&self) -> &str {
|
||||
match self { Self::Named { sys, .. } | Self::Legacy(sys) => sys }
|
||||
}
|
||||
fn name(&self) -> &str {
|
||||
match self { Self::Named { name, .. } => name, Self::Legacy(sys) => sys }
|
||||
}
|
||||
fn identity(&self) -> Option<(&str, u32, u32)> {
|
||||
match self { Self::Named { name, product, vendor, .. } => Some((name, *product, *vendor)), Self::Legacy(_) => None }
|
||||
}
|
||||
}
|
||||
|
||||
/// `'key': <uint32 16500>` carries a type prefix; strings and booleans do not.
|
||||
fn number(text: &str, key: &str) -> Option<u32> { variant(text, key)?.split_whitespace().last()?.parse().ok() }
|
||||
|
||||
#[derive(Clone, Copy, Default)]
|
||||
struct Flags { keyboard: bool, pointer: bool, touch: bool, switch: bool, enabled: bool }
|
||||
|
||||
/// Every device KWin lists, blocked or not: restore must find a device that is still disabled.
|
||||
/// The flag says whether a property read failed. A restore re-enables the readable devices, then
|
||||
/// returns the flag as an error so its record and the guard stay for another attempt; blocking
|
||||
/// skips such a device, which is all it can do.
|
||||
fn enumerate() -> Result<(Vec<(Device, Flags)>, bool), String> {
|
||||
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
|
||||
let mut devices = Vec::new();
|
||||
let mut incomplete = false;
|
||||
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) {
|
||||
let text = match call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) {
|
||||
Ok(text) => text,
|
||||
Err(_) => { incomplete = true; continue; }
|
||||
};
|
||||
let yes = |key| variant(&text, key) == Some("true");
|
||||
devices.push((Device::Named {
|
||||
sys: sys.to_owned(),
|
||||
name: variant(&text, "name").unwrap_or_default().to_owned(),
|
||||
product: number(&text, "product").unwrap_or(0),
|
||||
vendor: number(&text, "vendor").unwrap_or(0),
|
||||
}, Flags { keyboard: yes("keyboard"), pointer: yes("pointer"), touch: yes("touch"), switch: yes("switchDevice"), enabled: yes("enabled") }));
|
||||
}
|
||||
Ok((devices, incomplete))
|
||||
}
|
||||
|
||||
/// Keyboards, pointers and touch to block: everything except our own uinput devices, the power
|
||||
/// button and switches (lid). Software devices fed by local hardware (gesture daemons, ydotoold)
|
||||
/// are blocked too.
|
||||
pub fn local() -> Result<Vec<String>, String> {
|
||||
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
|
||||
let mut blocked = Vec::new();
|
||||
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) {
|
||||
let Ok(text) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) else { continue };
|
||||
let yes = |key| variant(&text, key) == Some("true");
|
||||
let name = variant(&text, "name").unwrap_or_default();
|
||||
if (yes("keyboard") || yes("pointer") || yes("touch")) && !yes("switchDevice") && yes("enabled")
|
||||
&& !name.starts_with("uu-remote-linux") && name != "Power Button" { blocked.push(sys.to_owned()); }
|
||||
}
|
||||
Ok(blocked)
|
||||
pub fn local() -> Result<Vec<Device>, String> {
|
||||
Ok(enumerate()?.0.into_iter().filter(|(d, f)| {
|
||||
(f.keyboard || f.pointer || f.touch) && !f.switch && f.enabled
|
||||
&& !d.name().starts_with("uu-remote-linux") && d.name() != "Power Button"
|
||||
}).map(|(d, _)| d).collect())
|
||||
}
|
||||
pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
|
||||
|
||||
/// Every current device matching `wanted`: same name/product/vendor, or the exact sysName for a
|
||||
/// legacy record. Several devices can share one identity (two identical keyboards, or one receiver
|
||||
/// exposing several event nodes under the same name), so callers must handle every match.
|
||||
fn matching<'a>(devices: &'a [Device], wanted: &Device) -> impl Iterator<Item = &'a Device> + 'a {
|
||||
let identity = wanted.identity().map(|(name, product, vendor)| (name.to_owned(), product, vendor));
|
||||
let sys = wanted.sys().to_owned();
|
||||
devices.iter().filter(move |d| match (&identity, d.identity()) {
|
||||
(Some((name, product, vendor)), Some((current, p, v))) => current == name && p == *product && v == *vendor,
|
||||
_ => d.sys() == sys,
|
||||
})
|
||||
}
|
||||
|
||||
fn set_sys<'a>(devices: impl Iterator<Item = &'a str>, enabled: bool) -> Result<(), String> {
|
||||
let value = if enabled { "<true>" } else { "<false>" };
|
||||
let mut failure = None;
|
||||
for sys in devices {
|
||||
@@ -28,3 +91,100 @@ pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
|
||||
}
|
||||
failure.map_or(Ok(()), Err)
|
||||
}
|
||||
|
||||
pub fn set(devices: &[Device], enabled: bool) -> Result<(), String> {
|
||||
set_sys(devices.iter().map(Device::sys), enabled)
|
||||
}
|
||||
|
||||
/// Current sysNames to re-enable and how many record entries have no current match.
|
||||
fn restore_targets<'a>(now: &'a [Device], recorded: &[Device]) -> (Vec<&'a str>, usize) {
|
||||
let mut targets: Vec<&str> = Vec::new();
|
||||
let mut gone = 0;
|
||||
for wanted in recorded {
|
||||
let mut found = false;
|
||||
for current in matching(now, wanted) {
|
||||
found = true;
|
||||
if !targets.contains(¤t.sys()) { targets.push(current.sys()); }
|
||||
}
|
||||
if !found { gone += 1; }
|
||||
}
|
||||
(targets, gone)
|
||||
}
|
||||
|
||||
/// Re-enables every current device matching a record entry, deduplicated by sysName: two record
|
||||
/// entries can describe the same device, and one identity can cover several devices. A recorded
|
||||
/// device that no longer exists is skipped: its `eventN` may belong to a different device after a
|
||||
/// reboot, and failing the whole restore would keep the recovery record forever. A device that
|
||||
/// exists but cannot be enabled still fails the restore, so the record and the guard stay for the
|
||||
/// next attempt.
|
||||
pub fn restore(devices: &[Device]) -> Result<(), String> {
|
||||
if devices.is_empty() { return Ok(()); }
|
||||
let (found, incomplete) = enumerate()?;
|
||||
let now: Vec<Device> = found.into_iter().map(|(d, _)| d).collect();
|
||||
let (targets, gone) = restore_targets(&now, devices);
|
||||
// Counts only: device names and sysNames are not logged (AGENTS.md).
|
||||
if gone > 0 { log::warn!("Privacy restore: {gone} recorded device(s) are gone; skipping"); }
|
||||
// Re-enable the readable devices first: one unreadable device must not keep every other one
|
||||
// off. The error afterwards keeps the record and the guard for another attempt.
|
||||
set_sys(targets.into_iter(), true)?;
|
||||
if incomplete { return Err("input device properties could not be read; retrying later".into()); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn named(sys: &str, name: &str, product: u32, vendor: u32) -> Device {
|
||||
Device::Named { sys: sys.into(), name: name.into(), product, vendor }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_numbered_variants() {
|
||||
let text = "({'name': <'Logitech G304'>, 'product': <uint32 16500>, 'vendor': <uint32 1133>},)";
|
||||
assert_eq!(number(text, "product"), Some(16500));
|
||||
assert_eq!(number(text, "vendor"), Some(1133));
|
||||
assert_eq!(number(text, "missing"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_legacy_and_named_records() {
|
||||
let legacy: Vec<Device> = serde_json::from_str(r#"["event5","event6"]"#).unwrap();
|
||||
assert!(matches!(&legacy[0], Device::Legacy(sys) if sys == "event5"));
|
||||
let named: Device = serde_json::from_str(r#"{"sys":"event12","name":"Logitech G304","product":16500,"vendor":1133}"#).unwrap();
|
||||
assert_eq!(named.identity(), Some(("Logitech G304", 16500, 1133)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn matches_a_renumbered_device_by_identity() {
|
||||
let mouse = named("event12", "Logitech G304", 16500, 1133);
|
||||
let keyboard = named("event3", "AT Translated Set 2 keyboard", 1, 1);
|
||||
let recorded = [named("event14", "Logitech G304", 16500, 1133)];
|
||||
let now = [keyboard, mouse];
|
||||
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event12"], 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enables_every_device_sharing_an_identity_once() {
|
||||
let first = named("event12", "Logitech G304", 16500, 1133);
|
||||
let second = named("event15", "Logitech G304", 16500, 1133);
|
||||
let now = [first, second];
|
||||
// Two record entries for one identity, as a receiver exposing several event nodes produces.
|
||||
let recorded = [named("event14", "Logitech G304", 16500, 1133), named("event16", "Logitech G304", 16500, 1133)];
|
||||
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event12", "event15"], 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_device_counts_as_gone() {
|
||||
let recorded = [named("event14", "Logitech G304", 16500, 1133)];
|
||||
let now = [named("event3", "AT Translated Set 2 keyboard", 1, 1)];
|
||||
assert_eq!(super::restore_targets(&now, &recorded), (Vec::new(), 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_legacy_record_matches_the_exact_sysname() {
|
||||
let recorded = [Device::Legacy("event5".into())];
|
||||
let now = [named("event5", "AT Translated Set 2 keyboard", 1, 1)];
|
||||
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event5"], 0));
|
||||
}
|
||||
}
|
||||
@@ -16,7 +16,7 @@ pub const NAME: &str = "kde";
|
||||
pub struct Kde;
|
||||
|
||||
#[derive(Default, serde::Serialize, serde::Deserialize)]
|
||||
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<String> }
|
||||
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<input::Device> }
|
||||
|
||||
impl Kde {
|
||||
pub fn detected() -> bool {
|
||||
@@ -84,8 +84,9 @@ impl Backend for Kde {
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String> {
|
||||
let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?;
|
||||
// KWin persists the device flag: a failure is returned (after restoring the outputs) so the
|
||||
// controller keeps the recovery record and the guard for the next attempt.
|
||||
let devices = input::set(&data.devices, true).map_err(|e| format!("enable input devices: {e}"));
|
||||
// controller keeps the recovery record and the guard for the next attempt. A device that
|
||||
// no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery.
|
||||
let devices = input::restore(&data.devices).map_err(|e| format!("enable input devices: {e}"));
|
||||
// Physical outputs first: switching back opens a monitor share, which needs them enabled.
|
||||
// The wait also matters: a share opened before KWin applies the mode got the virtual
|
||||
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
|
||||
|
||||
Reference in new issue
Block a user