Decode logind session paths by reply signature

Author: neko-kai

llm-docs/LLM-TODO.md

@@ -39,4 +39,4 @@ The project daemon is located at `src/daemon/` (Rust).
 # Notes
 - 2026-01-18: logind session monitoring failure is non-fatal; daemon continues without native terminal switching.
 - 2026-01-18: logind session resolution now falls back to the user’s `Display` session when `GetSessionByPID` reports no session (systemd user service with lingering).
-- 2026-01-19: logind object path parsing accepts object paths, single-field structures, or strings (robust reply decoding).
+- 2026-01-19: logind object path parsing accepts signatures `o`, `s`, `v`, or single-field structures (robust reply decoding).

llm-docs/implementation-notes.md

@@ -115,7 +115,7 @@ When all windows are closed (no window focused), the daemon switches to the defa
 The daemon watches `org.freedesktop.login1.Session.Active` on the system bus. When the session becomes inactive (Ctrl+Alt+F*), it applies the `on_native_terminal` rule if present, otherwise it behaves like an unfocused state. When the session becomes active again, it refreshes focus by querying the backend (GNOME GetFocus DBus, KDE script callback, Wayland/X11 active-window query).
 
 Session resolution prefers `XDG_SESSION_ID`, otherwise `GetSessionByPID`. If the PID is not in a logind session (common for systemd user services with lingering), it falls back to the user’s `Display` session via `GetUserByPID` + `org.freedesktop.login1.User.Display`.
-Logind replies are decoded via `OwnedValue` to tolerate object paths returned as a direct value, a single-field structure, or a string.
+Logind replies are decoded by inspecting the reply signature (accepting `o`, `s`, `v`, or single-field structures) to tolerate object paths returned as a direct value, a single-field structure, or a string.
 
 If logind monitoring fails to start (no system bus, permissions, etc.), the daemon logs the error and continues without native terminal switching.
 

src/daemon/main.rs

@@ -2058,22 +2058,17 @@ async fn resolve_logind_session_path(
 
     if let Ok(session_id) = env::var("XDG_SESSION_ID") {
         println!("[Logind] Using XDG_SESSION_ID={}", session_id);
-        let path = parse_logind_object_path(
-            manager.call::<_, _, OwnedValue>("GetSession", &(session_id)).await?,
-            "GetSession",
-        )?;
+        let reply = manager.call_method("GetSession", &(session_id)).await?;
+        let path = decode_logind_object_path_reply(&reply, "GetSession")?;
         println!("[Logind] Using session path: {}", path.as_str());
         return Ok(path);
     }
     println!("[Logind] XDG_SESSION_ID not set; resolving session via logind");
 
     let pid = std::process::id();
-    match manager
-        .call::<_, _, OwnedValue>("GetSessionByPID", &(pid))
-        .await
-    {
-        Ok(value) => {
-            let path = parse_logind_object_path(value, "GetSessionByPID")?;
+    match manager.call_method("GetSessionByPID", &(pid)).await {
+        Ok(reply) => {
+            let path = decode_logind_object_path_reply(&reply, "GetSessionByPID")?;
             println!("[Logind] Using session path: {}", path.as_str());
             Ok(path)
         }
@@ -2134,6 +2129,48 @@ fn parse_logind_object_path_from_structure(structure: &Structure<'_>) -> Option<
     logind_object_path_from_value(&fields[0])
 }
 
+fn decode_logind_object_path_reply(
+    reply: &zbus::Message,
+    context: &str,
+) -> Result<OwnedObjectPath, Box<dyn std::error::Error + Send + Sync>> {
+    let body = reply.body();
+    let signature = body.signature().to_string();
+    match signature.as_str() {
+        "o" => Ok(body.deserialize_unchecked::<OwnedObjectPath>()?),
+        "s" => {
+            let text = body.deserialize_unchecked::<String>()?;
+            OwnedObjectPath::try_from(text).map_err(|error| {
+                format!(
+                    "logind {} returned invalid object path string: {}",
+                    context, error
+                )
+                .into()
+            })
+        }
+        "v" => {
+            let value = body.deserialize::<OwnedValue>()?;
+            parse_logind_object_path(value, context)
+        }
+        _ => {
+            if signature.starts_with('(') {
+                let structure = body.deserialize::<Structure>()?;
+                return parse_logind_object_path_from_structure(&structure).ok_or_else(|| {
+                    format!(
+                        "logind {} returned unexpected structure: {}",
+                        context, signature
+                    )
+                    .into()
+                });
+            }
+            Err(format!(
+                "logind {} returned unexpected signature: {}",
+                context, signature
+            )
+            .into())
+        }
+    }
+}
+
 fn logind_object_path_from_value(value: &Value<'_>) -> Option<OwnedObjectPath> {
     match value {
         Value::ObjectPath(path) => Some(OwnedObjectPath::from(path.clone())),
@@ -2148,10 +2185,8 @@ async fn resolve_logind_display_session_path(
     connection: &Connection,
     pid: u32,
 ) -> Result<OwnedObjectPath, Box<dyn std::error::Error + Send + Sync>> {
-    let user_path = parse_logind_object_path(
-        manager.call::<_, _, OwnedValue>("GetUserByPID", &(pid)).await?,
-        "GetUserByPID",
-    )?;
+    let user_reply = manager.call_method("GetUserByPID", &(pid)).await?;
+    let user_path = decode_logind_object_path_reply(&user_reply, "GetUserByPID")?;
     let user_proxy = zbus::Proxy::new(
         connection,
         LOGIND_BUS_NAME,

src/daemon/tests.rs

@@ -1,5 +1,6 @@
 use super::*;
 use clap::Parser;
+use zbus::Message;
 use proptest::prelude::*;
 use std::future::Future;
 use std::path::Path;
@@ -1816,3 +1817,47 @@ fn test_parse_logind_object_path_string() {
 
     assert_eq!(parsed.as_str(), "/org/freedesktop/login1/session/_1");
 }
+
+#[test]
+fn test_decode_logind_object_path_reply_object_path() {
+    use zbus::zvariant::ObjectPath;
+
+    let path = ObjectPath::try_from("/org/freedesktop/login1/session/_1").unwrap();
+    let reply = Message::method_call("/org/freedesktop/login1", "GetSession")
+        .unwrap()
+        .build(&path)
+        .unwrap();
+    let parsed = decode_logind_object_path_reply(&reply, "test").unwrap();
+
+    assert_eq!(parsed.as_str(), "/org/freedesktop/login1/session/_1");
+}
+
+#[test]
+fn test_decode_logind_object_path_reply_structure() {
+    use zbus::zvariant::{ObjectPath, StructureBuilder};
+
+    let path = ObjectPath::try_from("/org/freedesktop/login1/session/_1").unwrap();
+    let structure = StructureBuilder::new().add_field(path).build().unwrap();
+    let reply = Message::method_call("/org/freedesktop/login1", "GetSession")
+        .unwrap()
+        .build(&structure)
+        .unwrap();
+    let parsed = decode_logind_object_path_reply(&reply, "test").unwrap();
+
+    assert_eq!(parsed.as_str(), "/org/freedesktop/login1/session/_1");
+}
+
+#[test]
+fn test_decode_logind_object_path_reply_variant() {
+    use zbus::zvariant::{ObjectPath, Value};
+
+    let path = ObjectPath::try_from("/org/freedesktop/login1/session/_1").unwrap();
+    let value = OwnedValue::try_from(Value::from(path)).unwrap();
+    let reply = Message::method_call("/org/freedesktop/login1", "GetSession")
+        .unwrap()
+        .build(&value)
+        .unwrap();
+    let parsed = decode_logind_object_path_reply(&reply, "test").unwrap();
+
+    assert_eq!(parsed.as_str(), "/org/freedesktop/login1/session/_1");
+}