add DnsConfig and ZoneConfig with proto definitions

easytier/src/dns/config.rs

@@ -0,0 +1,112 @@
+use crate::dns::utils::{sanitize, NameServerAddr};
+use crate::proto::dns::{DnsConfigKind, DnsConfigPb, ZoneConfigPb};
+use gethostname::gethostname;
+use hickory_proto::rr::LowerName;
+use serde::{Deserialize, Serialize};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+use std::str::FromStr;
+use std::sync::LazyLock;
+
+pub const DNS_DEFAULT_ADDRESS: SocketAddr =
+    SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(100, 100, 100, 101), 53));
+pub static DNS_DEFAULT_TLD: LazyLock<LowerName> =
+    LazyLock::new(|| LowerName::from_str("et.net.").unwrap());
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[serde(default)]
+pub struct DnsConfig {
+    #[serde(rename = "zone")]
+    pub zones: Vec<ZoneConfig>,
+    name: LowerName,
+    pub domain: LowerName,
+    pub addresses: Vec<SocketAddr>,
+    pub listeners: Vec<NameServerAddr>,
+}
+
+impl DnsConfig {
+    pub fn get_name(&self) -> String {
+        if self.name.is_empty() {
+            gethostname().to_string_lossy().to_string()
+        } else {
+            self.name.to_string()
+        }
+    }
+
+    pub fn set_name(&mut self, name: &str) {
+        self.name = match LowerName::from_str(name) {
+            Ok(name) => name,
+            Err(_) => {
+                let sanitized = sanitize(name);
+                tracing::debug!("invalid hostname: {}, sanitized to: {}", name, sanitized);
+                LowerName::from_str(&sanitized).unwrap_or_default()
+            }
+        };
+    }
+
+    pub fn to_pb(&self, kind: DnsConfigKind) -> DnsConfigPb {
+        let pb = DnsConfigPb {
+            kind: kind.into(),
+            name: self.get_name(),
+            domain: self.domain.to_string(),
+
+            ..Default::default()
+        };
+
+        match kind {
+            DnsConfigKind::Local => DnsConfigPb {
+                zones: self.zones.iter().map(Into::into).collect(),
+                addresses: self.addresses.clone().into_iter().map(Into::into).collect(),
+                listeners: self.listeners.iter().map(ToString::to_string).collect(),
+
+                ..pb
+            },
+
+            DnsConfigKind::Remote => DnsConfigPb {
+                zones: self
+                    .zones
+                    .iter()
+                    .filter(|z| z.broadcast)
+                    .map(Into::into)
+                    .collect(),
+
+                ..pb
+            },
+        }
+    }
+}
+
+impl Default for DnsConfig {
+    fn default() -> Self {
+        Self {
+            name: LowerName::default(),
+            domain: DNS_DEFAULT_TLD.clone(),
+            addresses: vec![DNS_DEFAULT_ADDRESS],
+            listeners: vec![],
+            zones: vec![],
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Default)]
+pub struct ZoneConfig {
+    #[serde(default)]
+    pub broadcast: bool,
+    pub origin: LowerName,
+    #[serde(default)]
+    pub ttl: u32,
+    #[serde(default)]
+    pub records: Vec<String>,
+    #[serde(default)]
+    pub forwarders: Vec<NameServerAddr>,
+}
+
+impl From<&ZoneConfig> for ZoneConfigPb {
+    fn from(value: &ZoneConfig) -> Self {
+        Self {
+            origin: value.origin.to_string(),
+            ttl: value.ttl,
+            records: value.records.clone(),
+            forwarders: value.forwarders.iter().map(ToString::to_string).collect(),
+        }
+    }
+}

easytier/src/dns/mod.rs

@@ -0,0 +1,2 @@
+pub mod config;
+mod utils;

easytier/src/dns/utils.rs

@@ -0,0 +1,106 @@
+use anyhow::{anyhow, Error};
+use hickory_proto::xfer::Protocol;
+use hickory_resolver::config::NameServerConfig;
+use idna::AsciiDenyList;
+use serde_with::{DeserializeFromStr, SerializeDisplay};
+use std::fmt::{Display, Formatter};
+use std::net::{IpAddr, SocketAddr};
+use std::str::FromStr;
+use url::Url;
+
+pub fn sanitize(name: &str) -> String {
+    let dot = name.ends_with('.');
+    let mut name = idna::domain_to_ascii_cow(name.as_ref(), AsciiDenyList::EMPTY)
+        .unwrap_or_default()
+        .into_owned()
+        .to_lowercase()
+        .split('.')
+        .map(|label| {
+            label
+                .chars()
+                .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
+                .take(63)
+                .collect::<String>()
+                .trim_matches('-')
+                .to_string()
+        })
+        .filter(|label| !label.is_empty())
+        .collect::<Vec<_>>()
+        .join(".");
+    name.truncate(253);
+    if dot {
+        name.push('.');
+    }
+    name
+}
+
+static DNS_SUPPORTED_PROTOCOLS: [Protocol; 2] = [
+    Protocol::Udp,
+    Protocol::Tcp,
+    // Protocol::Tls,
+    // Protocol::Https,
+    // Protocol::Quic,
+    // Protocol::H3,
+];
+
+#[derive(Debug, Clone, SerializeDisplay, DeserializeFromStr, PartialEq, Eq, Hash)]
+pub struct NameServerAddr {
+    protocol: Protocol,
+    addr: SocketAddr,
+}
+
+impl From<NameServerAddr> for NameServerConfig {
+    fn from(value: NameServerAddr) -> Self {
+        Self::new(value.addr, value.protocol)
+    }
+}
+
+impl TryFrom<Url> for NameServerAddr {
+    type Error = Error;
+
+    fn try_from(value: Url) -> Result<Self, Self::Error> {
+        let scheme = value.scheme();
+        let protocol = *DNS_SUPPORTED_PROTOCOLS
+            .iter()
+            .find(|p| p.to_string() == scheme)
+            .ok_or(anyhow!("unsupported scheme: {}", scheme))?;
+        let addr = value.host_str().ok_or(anyhow!("host not found"))?;
+        let addr = addr
+            .trim_start_matches('[')
+            .trim_end_matches(']')
+            .parse::<IpAddr>()
+            .map_err(|e| anyhow!("invalid ip address '{}': {}", addr, e))?;
+        let port = if let Some(port) = value.port() {
+            port
+        } else {
+            match protocol {
+                Protocol::Udp | Protocol::Tcp => 53,
+                _ => return Err(anyhow!("port not found")),
+            }
+        };
+
+        Ok(Self {
+            protocol,
+            addr: SocketAddr::new(addr, port),
+        })
+    }
+}
+
+impl FromStr for NameServerAddr {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let url = if s.parse::<IpAddr>().is_ok() || s.parse::<SocketAddr>().is_ok() {
+            Url::parse(&format!("udp://{}", s))?
+        } else {
+            Url::parse(s)?
+        };
+
+        url.try_into()
+    }
+}
+
+impl Display for NameServerAddr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}://{}", self.protocol, self.addr)
+    }
+}