osdns 0.2.0

Safe, transactional control of operating-system DNS configuration
Documentation 
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
124
125
126
127

use std::path::Path;
use std::sync::Arc;

use crate::error::Result;
use crate::platform::Backend;
use crate::platform::linux::direct::DirectResolvConf;
use crate::platform::linux::network_manager::NetworkManager;
use crate::platform::linux::resolvconf::{self, Resolvconf};
use crate::platform::linux::resolved::SystemdResolved;

const RESOLV_CONF: &str = crate::platform::linux::RESOLV_CONF_PATH;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ResolvConfOwner {
    SystemdResolved,
    NetworkManager,
    Resolvconf,
    Foreign,
}

fn resolv_conf_owner() -> ResolvConfOwner {
    let path = Path::new(RESOLV_CONF);
    let target = std::fs::read_link(path)
        .map(|t| t.to_string_lossy().to_string())
        .ok();
    if let Some(target) = target {
        if target.contains("systemd/resolve") {
            return ResolvConfOwner::SystemdResolved;
        }
        if target.contains("NetworkManager") {
            return ResolvConfOwner::NetworkManager;
        }
        if target.contains("resolvconf") {
            return ResolvConfOwner::Resolvconf;
        }
        return ResolvConfOwner::Foreign;
    }
    if let Ok(bytes) = std::fs::read(path) {
        let head = String::from_utf8_lossy(&bytes);
        for line in head.lines().take(5) {
            let line = line.to_ascii_lowercase();
            if line.contains("generated by resolvconf") {
                return ResolvConfOwner::Resolvconf;
            }
            if line.contains("generated by networkmanager") {
                return ResolvConfOwner::NetworkManager;
            }
            if line.contains("generated by") && line.contains("resolved") {
                return ResolvConfOwner::SystemdResolved;
            }
        }
    }
    ResolvConfOwner::Foreign
}

fn resolvconf_indicated() -> bool {
    if resolvconf::probe().is_some() {
        return true;
    }
    Path::new("/etc/resolvconf.conf").is_file()
}

/// Determines who actually owns DNS configuration on this host, not merely
/// which components are installed.
///
/// Precedence (first match wins):
/// 1. `systemd-resolved` when it manages `/etc/resolv.conf` (stub/upstream
///    symlink, owned header, or `ResolvConfMode` stub/managed/upstream/static),
///    or when NetworkManager's DNS mode delegates to it.
/// 2. NetworkManager when it owns `/etc/resolv.conf` directly (symlink,
///    generated header, `dns=dnsmasq`, or an active `rc-manager` file mode).
/// 3. resolvconf/openresolv when its state directory exists and a binary is
///    available (including when NetworkManager delegates via
///    `rc-manager=resolvconf`).
/// 4. Direct `/etc/resolv.conf` manipulation as the last resort.
pub(crate) fn select(owner: &str) -> Result<Arc<dyn Backend>> {
    let file_owner = resolv_conf_owner();
    let resolved = SystemdResolved::connect().ok();
    let resolved_mode = resolved.as_ref().and_then(|backend| backend.mode_hint());
    let resolved_owns = resolved.is_some()
        && (matches!(
            resolved_mode.as_deref(),
            Some("stub") | Some("managed") | Some("upstream") | Some("static")
        ) || file_owner == ResolvConfOwner::SystemdResolved);

    if resolved_owns && let Some(backend) = resolved {
        return Ok(Arc::new(backend));
    }

    let network_manager = NetworkManager::connect().ok();
    let (nm_mode, nm_rc_manager) = network_manager
        .as_ref()
        .map(NetworkManager::dns_configuration)
        .unwrap_or(("", ""));

    if network_manager.is_some()
        && nm_mode == "systemd-resolved"
        && let Some(backend) = resolved
    {
        return Ok(Arc::new(backend));
    }

    if nm_rc_manager == "resolvconf"
        && let Some(probe) = resolvconf::probe()
    {
        return Ok(Arc::new(Resolvconf::new(probe, owner)));
    }

    let nm_owns_directly = network_manager.is_some()
        && (file_owner == ResolvConfOwner::NetworkManager
            || nm_mode == "dnsmasq"
            || matches!(nm_rc_manager, "file" | "symlink" | "managed"));
    if nm_owns_directly {
        return Ok(Arc::new(network_manager.expect("checked above")));
    }

    let resolvconf_owns = file_owner == ResolvConfOwner::Resolvconf || resolvconf_indicated();
    if resolvconf_owns && let Some(probe) = resolvconf::probe() {
        return Ok(Arc::new(Resolvconf::new(probe, owner)));
    }

    if let Some(backend) = resolved {
        return Ok(Arc::new(backend));
    }

    Ok(Arc::new(DirectResolvConf::new()))
}