feat(#540): expose NetworkManager global DNS configuration

docs/src/api/network-manager.md

@@ -153,6 +153,13 @@ devices that NetworkManager reports as `veth`.
 | `connectivity_report()` | `Result<ConnectivityReport>` | Full report with captive portal URL |
 | `captive_portal_url()` | `Result<Option<String>>` | Captive portal URL if in Portal state |
 
+## Global DNS
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `global_dns_configuration()` | `Result<GlobalDnsConfiguration>` | Read the manager-wide DNS override |
+| `set_global_dns_configuration(&config)` | `Result<()>` | Write it; empty config clears the override |
+
 ## Bluetooth Methods
 
 | Method | Returns | Description |

nmrs/CHANGELOG.md

@@ -4,11 +4,17 @@ All notable changes to the `nmrs` crate will be documented in this file.
 
 ## [Unreleased]
 
+
 ### Added
 
 - Device snapshots now expose per-device autoconnect state, and
   `NetworkManager::set_device_autoconnect()` / `set_device_managed()` provide
   high-level control of both writable properties. ([#541](https://github.com/freedesktop-rs/nmrs/issues/541))
+- `NetworkManager::global_dns_configuration()` /
+  `set_global_dns_configuration()` read and write the manager
+  `GlobalDnsConfiguration` property. An empty value clears the
+  override. ([#540](https://github.com/freedesktop-rs/nmrs/issues/540))
+
 
 ### Fixed
 

nmrs/src/api/models/dns.rs

@@ -0,0 +1,315 @@
+//! Global DNS override exposed as NetworkManager.GlobalDnsConfiguration.
+
+use std::collections::HashMap;
+use zvariant::{OwnedValue, Value};
+
+use super::error::ConnectionError;
+
+/// One domain entry under `domains`.
+#[non_exhaustive]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct GlobalDnsDomain {
+    /// Nameservers for this domain (plain IPs or `dns+udp` / `dns+tls` URIs).
+    pub servers: Vec<String>,
+
+    /// Domain-specific resolver options.
+    pub options: Vec<String>,
+}
+
+impl GlobalDnsDomain {
+    /// Empty domain entry.
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets this domain's nameservers.
+    #[must_use]
+    pub fn with_servers(mut self, servers: impl Into<Vec<String>>) -> Self {
+        self.servers = servers.into();
+        self
+    }
+
+    /// Sets this domain's resolver options.
+    #[must_use]
+    pub fn with_options(mut self, options: impl Into<Vec<String>>) -> Self {
+        self.options = options.into();
+        self
+    }
+}
+
+/// Typed form of NetworkManager's `GlobalDnsConfiguration` property.
+///
+/// An empty value (no searches, options, or domain servers) serializes to an
+/// empty dict and clears the global override.
+#[non_exhaustive]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct GlobalDnsConfiguration {
+    /// Global search domains, applied when the override is active.
+    pub searches: Vec<String>,
+
+    /// Global resolver options (for example `timeout:2`, `rotate`).
+    pub options: Vec<String>,
+
+    /// Per-domain configuration. The `"*"` key is the default domain and is
+    /// required on any non-empty override.
+    pub domains: HashMap<String, GlobalDnsDomain>,
+}
+
+impl GlobalDnsConfiguration {
+    /// Empty configuration; writing it clears the global override.
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Default-domain nameservers only (`domains["*"].servers`).
+    #[must_use]
+    pub fn from_servers(servers: impl Into<Vec<String>>) -> Self {
+        Self::new().with_default_servers(servers)
+    }
+
+    /// Sets the global search domains.
+    #[must_use]
+    pub fn with_searches(mut self, searches: impl Into<Vec<String>>) -> Self {
+        self.searches = searches.into();
+        self
+    }
+
+    /// Sets the global resolver options.
+    #[must_use]
+    pub fn with_options(mut self, options: impl Into<Vec<String>>) -> Self {
+        self.options = options.into();
+        self
+    }
+
+    /// Inserts or replaces one domain entry.
+    #[must_use]
+    pub fn with_domain(mut self, name: impl Into<String>, domain: GlobalDnsDomain) -> Self {
+        self.domains.insert(name.into(), domain);
+        self
+    }
+
+    /// Sets nameservers for the default `"*"` domain.
+    #[must_use]
+    pub fn with_default_servers(self, servers: impl Into<Vec<String>>) -> Self {
+        self.with_domain("*", GlobalDnsDomain::new().with_servers(servers))
+    }
+
+    /// `true` when writing this value should send an empty dict.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.searches.is_empty()
+            && self.options.is_empty()
+            && self
+                .domains
+                .values()
+                .all(|domain| domain.servers.is_empty() && domain.options.is_empty())
+    }
+
+    /// Validates a value before writing it to NetworkManager.
+    ///
+    /// Empty configs are valid and clear the override. A non-empty config must
+    /// include the default `"*"` domain, and that domain must list at least one
+    /// nameserver.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`ConnectionError::InvalidInput`] when the default domain or its
+    /// servers list is missing.
+    pub fn validate(&self) -> Result<(), ConnectionError> {
+        if self.is_empty() {
+            return Ok(());
+        }
+
+        let Some(default_domain) = self.domains.get("*") else {
+            return Err(ConnectionError::InvalidInput {
+                field: "domains".into(),
+                reason: "missing default domain \"*\"".into(),
+            });
+        };
+
+        if default_domain.servers.is_empty() {
+            return Err(ConnectionError::InvalidInput {
+                field: "domains.*.servers".into(),
+                reason: "default domain \"*\" must include at least one nameserver".into(),
+            });
+        }
+
+        Ok(())
+    }
+
+    /// Nameservers configured on the default `"*"` domain.
+    #[must_use]
+    pub fn default_servers(&self) -> &[String] {
+        self.domains
+            .get("*")
+            .map(|domain| domain.servers.as_slice())
+            .unwrap_or(&[])
+    }
+
+    pub(crate) fn to_dbus(&self) -> HashMap<&'static str, Value<'static>> {
+        if self.is_empty() {
+            return HashMap::new();
+        }
+
+        let mut map = HashMap::new();
+        if !self.searches.is_empty() {
+            map.insert("searches", Value::from(self.searches.clone()));
+        }
+        if !self.options.is_empty() {
+            map.insert("options", Value::from(self.options.clone()));
+        }
+        if !self.domains.is_empty() {
+            let mut domains = HashMap::new();
+            for (name, domain) in &self.domains {
+                domains.insert(name.clone(), domain_to_dbus(domain));
+            }
+            map.insert("domains", Value::from(domains));
+        }
+        map
+    }
+
+    pub(crate) fn from_dbus(map: &HashMap<String, OwnedValue>) -> Self {
+        let searches = take_strings(map, "searches");
+        let options = take_strings(map, "options");
+        let mut domains = HashMap::new();
+
+        if let Some(value) = map.get("domains")
+            && let Ok(raw_domains) = HashMap::<String, OwnedValue>::try_from(value.clone())
+        {
+            for (name, raw_domain) in raw_domains {
+                let inner = HashMap::<String, OwnedValue>::try_from(raw_domain).unwrap_or_default();
+                domains.insert(
+                    name,
+                    GlobalDnsDomain {
+                        servers: take_strings(&inner, "servers"),
+                        options: take_strings(&inner, "options"),
+                    },
+                );
+            }
+        }
+
+        Self {
+            searches,
+            options,
+            domains,
+        }
+    }
+}
+
+fn domain_to_dbus(domain: &GlobalDnsDomain) -> Value<'static> {
+    let mut inner: HashMap<&str, Value<'static>> = HashMap::new();
+    if !domain.servers.is_empty() {
+        inner.insert("servers", Value::from(domain.servers.clone()));
+    }
+    if !domain.options.is_empty() {
+        inner.insert("options", Value::from(domain.options.clone()));
+    }
+    Value::from(inner)
+}
+
+fn take_strings(map: &HashMap<String, OwnedValue>, key: &str) -> Vec<String> {
+    map.get(key)
+        .and_then(|value| Vec::<String>::try_from(value.clone()).ok())
+        .unwrap_or_default()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use zvariant::Str;
+
+    #[test]
+    fn empty_encodes_as_empty_dict() {
+        let encoded = GlobalDnsConfiguration::default().to_dbus();
+        assert!(encoded.is_empty());
+    }
+
+    #[test]
+    fn empty_dict_decodes_as_empty_config() {
+        let decoded = GlobalDnsConfiguration::from_dbus(&HashMap::new());
+        assert!(decoded.is_empty());
+        assert!(decoded.default_servers().is_empty());
+    }
+
+    #[test]
+    fn default_servers_round_trip() {
+        let original =
+            GlobalDnsConfiguration::from_servers(vec!["1.1.1.1".into(), "8.8.8.8".into()]);
+
+        let encoded = original.to_dbus();
+        assert!(!encoded.contains_key("searches"));
+        assert!(encoded.contains_key("domains"));
+
+        let owned: HashMap<String, OwnedValue> = encoded
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), OwnedValue::try_from(v).expect("owned value")))
+            .collect();
+        let decoded = GlobalDnsConfiguration::from_dbus(&owned);
+
+        assert_eq!(decoded.default_servers(), &["1.1.1.1", "8.8.8.8"]);
+        assert!(decoded.searches.is_empty());
+        assert!(decoded.options.is_empty());
+    }
+
+    #[test]
+    fn searches_options_and_split_domain_round_trip() {
+        let original = GlobalDnsConfiguration::new()
+            .with_searches(vec!["example.test".into()])
+            .with_options(vec!["timeout:2".into()])
+            .with_default_servers(vec!["9.9.9.9".into()])
+            .with_domain(
+                "corp.example",
+                GlobalDnsDomain::new().with_servers(vec!["10.0.0.1".into()]),
+            );
+
+        let owned: HashMap<String, OwnedValue> = original
+            .to_dbus()
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), OwnedValue::try_from(v).expect("owned value")))
+            .collect();
+        let decoded = GlobalDnsConfiguration::from_dbus(&owned);
+
+        assert_eq!(decoded, original);
+    }
+
+    #[test]
+    fn missing_keys_decode_as_empty() {
+        let decoded = GlobalDnsConfiguration::from_dbus(&HashMap::from([(
+            "unrelated".into(),
+            OwnedValue::from(Str::from("x")),
+        )]));
+        assert!(decoded.is_empty());
+    }
+
+    #[test]
+    fn validate_accepts_empty_and_default_servers() {
+        GlobalDnsConfiguration::default().validate().unwrap();
+        GlobalDnsConfiguration::from_servers(vec!["1.1.1.1".into()])
+            .validate()
+            .unwrap();
+    }
+
+    #[test]
+    fn validate_rejects_missing_default_domain() {
+        let config = GlobalDnsConfiguration::new().with_searches(vec!["example.test".into()]);
+        assert!(matches!(
+            config.validate().unwrap_err(),
+            ConnectionError::InvalidInput { field, reason }
+                if field == "domains" && reason.contains("missing default domain")
+        ));
+    }
+
+    #[test]
+    fn validate_rejects_default_domain_without_servers() {
+        let config = GlobalDnsConfiguration::new()
+            .with_searches(vec!["example.test".into()])
+            .with_domain("*", GlobalDnsDomain::new());
+        assert!(matches!(
+            config.validate().unwrap_err(),
+            ConnectionError::InvalidInput { field, reason }
+                if field == "domains.*.servers" && reason.contains("nameserver")
+        ));
+    }
+}

nmrs/src/api/models/mod.rs

@@ -5,6 +5,7 @@ mod config;
 mod connection_state;
 mod connectivity;
 mod device;
+mod dns;
 mod error;
 mod monitor;
 mod network_event;
@@ -18,6 +19,7 @@ mod vpn;
 mod wifi;
 mod wireguard;
 
+pub use dns::*;
 use std::fmt;
 
 pub(crate) struct Redacted;