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
128

//! Windows integration tests.
//!
//! Read-only tests run against the real system. Tests that mutate DNS state
//! are gated behind the `OSDNS_ALLOW_SYSTEM_MUTATION=1` environment variable
//! and must only run on disposable machines with administrator privileges.

#![cfg(target_os = "windows")]
#![cfg(feature = "test-util")]

mod common;

use common::*;
use osdns::{BackendKind, Capabilities, DnsConfig, DnsManager, DnsScope, InterfaceSelector};

fn real_manager(tag: &str) -> Option<DnsManager> {
    let dir = temp_dir(tag);
    match DnsManager::builder()
        .owner("io.osdns.test")
        .state_dir(&dir)
        .build()
    {
        Ok(manager) => Some(manager),
        Err(osdns::Error::RequiresPrivilege(_)) => None,
        Err(error) => panic!("unexpected builder error: {error}"),
    }
}

#[test]
fn default_backend_is_windows_ip_helper() {
    let Some(manager) = real_manager("win-backend") else {
        return;
    };
    let caps = manager.capabilities().unwrap();
    assert_eq!(caps.backend, BackendKind::WindowsIpHelper);
    assert!(caps.read);
    assert!(caps.per_interface_dns);
    assert!(caps.split_dns);
    assert!(caps.default_route);
    assert!(caps.watch);
    assert!(caps.cache_flush);
    assert!(!caps.global_dns);
}

#[test]
fn interfaces_listing_is_read_only() {
    let Some(manager) = real_manager("win-interfaces") else {
        return;
    };
    let interfaces = manager.interfaces().unwrap();
    assert!(!interfaces.is_empty());
    assert!(interfaces.iter().all(|i| i.guid.is_some()));
}

#[test]
fn snapshot_of_real_adapter_is_read_only() {
    let Some(manager) = real_manager("win-snapshot") else {
        return;
    };
    let interfaces = manager.interfaces().unwrap();
    let target = interfaces
        .iter()
        .find(|i| i.is_up)
        .expect("at least one up interface");
    let scope = DnsScope::Interface(InterfaceSelector::Name(target.name.clone()));
    let snapshot = manager.snapshot(&scope).unwrap();
    let _ = snapshot;
}

#[test]
fn global_scope_is_unsupported() {
    let Some(manager) = real_manager("win-global") else {
        return;
    };
    let config = DnsConfig::builder(DnsScope::Global)
        .nameserver(ip("1.1.1.1"))
        .build()
        .unwrap();
    assert!(matches!(
        manager.apply(&config).unwrap_err(),
        osdns::Error::Unsupported { .. }
    ));
}

#[test]
fn validation_rejects_unrepresentable_configs() {
    let Some(manager) = real_manager("win-validate") else {
        return;
    };
    let caps = manager.capabilities().unwrap();
    let expected: Capabilities = caps;
    assert!(expected.split_dns);
    let config = DnsConfig::builder(DnsScope::Interface(InterfaceSelector::Index(1)))
        .nameserver(ip("1.1.1.1"))
        .routing_domain("corp.example")
        .build()
        .unwrap();
    manager.validate(&config).unwrap();
}

#[test]
fn mutation_requires_explicit_opt_in() {
    if std::env::var_os("OSDNS_ALLOW_SYSTEM_MUTATION").is_none() {
        return;
    }
    let Some(manager) = real_manager("win-mutate") else {
        return;
    };
    let loopback = windows_test_interface(&manager);
    let scope = DnsScope::Interface(InterfaceSelector::Name(loopback.name.clone()));
    let config = DnsConfig::builder(scope.clone())
        .nameserver(ip("127.0.0.1"))
        .search_domain("osdns.test")
        .build()
        .unwrap();

    match manager.apply(&config) {
        Ok(lease) => {
            let snapshot = manager.snapshot(&scope).unwrap();
            assert_eq!(snapshot.nameservers(), &[ip("127.0.0.1")]);
            assert_eq!(
                snapshot.search_domains(),
                &[osdns::DnsSuffix::parse("osdns.test").unwrap()]
            );
            lease.restore().unwrap();
        }
        Err(error) => panic!("unexpected apply error: {error}"),
    }
}