polyresolver 0.1.1

DNS resolver for client-side split horizon resolution over multiple domain arenas
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

use std::{
    collections::BTreeMap,
    net::{IpAddr, SocketAddr},
    path::PathBuf,
    time::Duration,
};

use anyhow::anyhow;
use trust_dns_resolver::{
    config::{NameServerConfig, ResolverConfig, ResolverOpts},
    error::ResolveError,
    name_server::{GenericConnection, GenericConnectionProvider, TokioRuntime},
    AsyncResolver, Name,
};

use crate::{
    catalog::LockedCatalog,
    config::{Config, ConfigUpdate},
};

pub type Resolver = AsyncResolver<GenericConnection, GenericConnectionProvider<TokioRuntime>>;

pub fn create_resolver(
    nameservers: Vec<IpAddr>,
    search_names: Vec<Name>,
) -> Result<Resolver, ResolveError> {
    let mut opts = ResolverOpts::default();
    opts.timeout = Duration::new(1, 0);
    opts.cache_size = 0;
    opts.rotate = true;
    opts.use_hosts_file = false;
    opts.positive_min_ttl = Some(Duration::new(0, 0));
    opts.positive_max_ttl = Some(Duration::new(0, 0));
    opts.negative_min_ttl = Some(Duration::new(0, 0));
    opts.negative_max_ttl = Some(Duration::new(0, 0));

    let mut resolver_config = ResolverConfig::new();
    for nameserver in nameservers {
        for name in search_names.clone() {
            resolver_config.add_search(name);
        }

        resolver_config.add_name_server(NameServerConfig {
            bind_addr: None,
            socket_addr: SocketAddr::new(nameserver, 53),
            protocol: trust_dns_resolver::config::Protocol::Udp,
            tls_dns_name: None,
            trust_nx_responses: true,
            tls_config: None,
        });
    }

    trust_dns_resolver::TokioAsyncResolver::tokio(resolver_config, opts)
}

#[derive(Clone)]
pub struct ResolverCollection {
    configs: BTreeMap<PathBuf, Config>,
    catalog: LockedCatalog,
}

impl ResolverCollection {
    pub fn new(catalog: LockedCatalog) -> Self {
        Self {
            catalog,
            configs: BTreeMap::new(),
        }
    }

    pub async fn set_config(&mut self, update: ConfigUpdate) -> Result<(), anyhow::Error> {
        if update.config.is_none() {
            return Err(anyhow!(
                "Tried to insert deleted configuration {}",
                update.config_filename.display()
            ));
        }

        let config = update.config.unwrap();

        self.configs.insert(update.config_filename, config.clone());

        self.catalog
            .write()
            .await
            .upsert(config.domain_name().into(), config.forwarder()?);

        Ok(())
    }

    pub async fn remove_config(&mut self, update: ConfigUpdate) -> Result<(), anyhow::Error> {
        let config = self.configs.remove(&update.config_filename);

        if let Some(config) = config {
            self.catalog
                .write()
                .await
                .remove(&config.domain_name().into());
        }

        Ok(())
    }
}