systemd-resolved-rs 0.1.1

A compatibility-oriented reimplementation of systemd-resolved
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// SPDX-License-Identifier: LGPL-2.1-or-later
#[derive(Debug)]
struct DnssdServiceObject {
    id: String,
    authorization: Arc<DbusAuthorization>,
}

#[dbus_interface(name = "org.freedesktop.resolve1.DnssdService")]
impl DnssdServiceObject {
    fn unregister(
        &self,
        #[zbus(header)] header: MessageHeader<'_>,
    ) -> Result<(), DbusError> {
        let originator_uid = crate::mdns::dnssd_runtime::dynamic_originator(&self.id)
            .ok_or_else(|| DbusError::NoSuchDnssdService(self.id.clone()))?;
        self.authorization.authorize_good_user(
            &header,
            "org.freedesktop.resolve1.unregister-service",
            no_details(),
            originator_uid,
        )?;
        crate::mdns::dnssd_runtime::unregister_dynamic(&self.id)
            .map_err(map_dynamic_service_error)
    }

    #[dbus_interface(signal)]
    async fn conflicted(context: &zbus::SignalContext<'_>) -> zbus::Result<()>;
}

fn synchronize_dnssd_objects(
    connection: &Connection,
    authorization: &Arc<DbusAuthorization>,
    registered: &mut BTreeSet<String>,
) -> zbus::Result<()> {
    let current = crate::mdns::dnssd_runtime::dynamic_ids();
    for id in current.difference(registered) {
        let path = dnssd_object_path(id)
            .map_err(|error| zbus::Error::Failure(error.to_string()))?;
        connection.object_server().at(
            path.as_str(),
            DnssdServiceObject {
                id: id.clone(),
                authorization: Arc::clone(authorization),
            },
        )?;
    }
    for id in registered.difference(&current).cloned().collect::<Vec<_>>() {
        let path = dnssd_object_path(&id)
            .map_err(|error| zbus::Error::Failure(error.to_string()))?;
        connection
            .object_server()
            .remove::<DnssdServiceObject, _>(path.as_str())?;
    }
    *registered = current;
    Ok(())
}

fn emit_dnssd_conflicts(connection: &Connection) -> zbus::Result<()> {
    for id in crate::mdns::dnssd_runtime::take_conflicts() {
        let path = dnssd_object_path(&id)
            .map_err(|error| zbus::Error::Failure(error.to_string()))?;
        connection.emit_signal(
            None::<&str>,
            path.as_str(),
            "org.freedesktop.resolve1.DnssdService",
            "Conflicted",
            &(),
        )?;
    }
    Ok(())
}

fn remove_vanished_dnssd_services(
    bus: &zbus::blocking::fdo::DBusProxy<'_>,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    for owner in crate::mdns::dnssd_runtime::dynamic_owners() {
        let name = zbus::names::BusName::try_from(owner.as_str())?;
        if !bus.name_has_owner(name)? {
            crate::mdns::dnssd_runtime::unregister_dynamic_owner(&owner);
        }
    }
    Ok(())
}

fn dnssd_object_path(id: &str) -> Result<OwnedObjectPath, DbusError> {
    if id.is_empty() || id.len() > 255 || matches!(id, "." | "..") || id.contains('/') {
        return Err(DbusError::InvalidArgs(format!(
            "DNS-SD service identifier '{id}' is invalid"
        )));
    }
    let encoded = encode_bus_label(id);
    OwnedObjectPath::try_from(format!("{DNSSD_PATH_PREFIX}/{encoded}"))
        .map_err(|error| DbusError::InvalidArgs(error.to_string()))
}

fn dnssd_id_from_path(path: &OwnedObjectPath) -> Result<String, DbusError> {
    crate::mdns::dnssd_runtime::dynamic_ids()
        .into_iter()
        .find(|id| {
            dnssd_object_path(id)
                .is_ok_and(|candidate| candidate.as_str() == path.as_str())
        })
        .ok_or_else(|| {
            DbusError::NoSuchDnssdService(format!(
                "DNS-SD service with object path '{}' does not exist",
                path.as_str()
            ))
        })
}

fn map_dynamic_service_error(
    error: crate::mdns::dnssd_runtime::DynamicServiceError,
) -> DbusError {
    use crate::mdns::dnssd_runtime::DynamicServiceError;
    match error {
        DynamicServiceError::AlreadyExists => DbusError::DnssdServiceExists(error.to_string()),
        DynamicServiceError::NotFound => DbusError::NoSuchDnssdService(error.to_string()),
        DynamicServiceError::InvalidIdentifier
        | DynamicServiceError::InvalidNameTemplate
        | DynamicServiceError::InvalidTxtKey
        | DynamicServiceError::Service(_) => DbusError::InvalidArgs(error.to_string()),
    }
}