use std::future::Future;
use std::io;
use std::net::{IpAddr, Ipv6Addr, SocketAddr};
use std::pin::Pin;
use std::sync::{Arc, Once};
use std::task::{Context, Poll};
use std::time::Duration;
use hickory_resolver::config::{NameServerConfig, ResolveHosts, ResolverConfig, ResolverOpts};
use hickory_resolver::net::runtime::{DnsUdpSocket, RuntimeProvider, TokioRuntimeProvider};
use hickory_resolver::{ConnectionProvider, Resolver, TokioResolver};
use crate::{info, warn};
pub(crate) struct DnsConfig {
pub(crate) global: Result<(ResolverConfig, ResolverOpts), String>,
pub(crate) scoped: Vec<ScopedServers>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ScopedServers {
pub(crate) domain: String,
pub(crate) servers: Result<Vec<SocketAddr>, String>,
}
impl DnsConfig {
pub(crate) fn read_system() -> Self {
let global = hickory_resolver::system_conf::read_system_conf().map_err(|e| e.to_string());
Self {
global,
scoped: read_scoped(),
}
}
}
pub(crate) struct Unicast {
global: Result<TokioResolver, String>,
scoped: Vec<Scope>,
searched: Vec<String>,
unconfigured: Once,
}
impl Unicast {
pub(crate) fn from_config(config: DnsConfig) -> Self {
let base_opts = config
.global
.as_ref()
.map_or_else(|_| ResolverOpts::default(), |(_, opts)| opts.clone());
let (global, searched) = match config.global {
Ok((conf, opts)) => {
let searched = conf
.domain()
.into_iter()
.chain(conf.search())
.map(|name| fold(&name.to_ascii()))
.collect();
(build(conf, opts, TokioRuntimeProvider::default()), searched)
}
Err(e) => (Err(e), Vec::new()),
};
let mut scoped: Vec<Scope> = config
.scoped
.into_iter()
.map(|scope| {
let client = scope.servers.and_then(|servers| {
let runtime = ZonedRuntime::for_servers(&servers);
let servers = servers.iter().map(|at| {
let mut server = NameServerConfig::udp_and_tcp(at.ip());
for connection in &mut server.connections {
connection.port = at.port();
}
server
});
let conf = ResolverConfig::from_parts(None, Vec::new(), servers.collect());
build(conf, base_opts.clone(), runtime)
});
Scope {
domain: scope.domain,
client,
unasked: Once::new(),
}
})
.collect();
scoped.sort_by_key(|scope| std::cmp::Reverse(scope.domain.len()));
Self {
global,
scoped,
searched,
unconfigured: Once::new(),
}
}
pub(crate) fn claims(&self, name: &str) -> bool {
let name = fold(name);
self.scoped.iter().any(|scope| covers(&scope.domain, &name))
|| self.searched.iter().any(|domain| covers(domain, &name))
}
pub(crate) async fn lookup(&self, name: &str) -> Vec<IpAddr> {
let folded = fold(name);
if let Some(scope) = self
.scoped
.iter()
.find(|scope| covers(&scope.domain, &folded))
{
return match &scope.client {
Ok(client) => ask(client, name).await,
Err(why) => {
scope
.unasked
.call_once(|| warn!("DNS for {} not asked ({why})", scope.domain));
Vec::new()
}
};
}
let client = match &self.global {
Ok(client) => client,
Err(why) => {
self.say_unconfigured(why);
return Vec::new();
}
};
ask(client, name).await
}
pub(crate) async fn reverse(&self, ip: IpAddr) -> Reverse {
if let Some(scope) = self.reverse_scope(ip).map(|index| &self.scoped[index]) {
return match &scope.client {
Ok(client) => ask_reverse(client, ip).await,
Err(why) => {
scope
.unasked
.call_once(|| warn!("DNS for {} not asked ({why})", scope.domain));
Reverse::Unasked
}
};
}
match &self.global {
Ok(client) => ask_reverse(client, ip).await,
Err(why) => {
self.say_unconfigured(why);
Reverse::Unasked
}
}
}
pub(crate) fn reverse_scope(&self, ip: IpAddr) -> Option<usize> {
let name = reverse_name(ip);
self.scoped
.iter()
.position(|scope| covers(&scope.domain, &name))
}
fn say_unconfigured(&self, why: &str) {
self.unconfigured.call_once(|| {
warn!("DNS lookups skipped (no DNS server configured)");
info!(
verbosity = 1,
"system resolver configuration unusable: {why}"
);
});
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum Reverse {
Listed(String),
Named(String),
Unnamed,
Unanswered,
Unasked,
}
async fn ask_reverse<P: ConnectionProvider>(client: &Resolver<P>, ip: IpAddr) -> Reverse {
use hickory_resolver::proto::rr::RData;
let lookup = match client.reverse_lookup(ip).await {
Ok(lookup) => lookup,
Err(hickory_resolver::net::NetError::Dns(_)) => return Reverse::Unnamed,
Err(_) => return Reverse::Unanswered,
};
lookup
.answers()
.iter()
.find_map(|record| match &record.data {
RData::PTR(ptr) => Some(ptr.to_string()),
_ => None,
})
.map_or(Reverse::Unnamed, Reverse::Named)
}
pub(crate) fn reverse_name(ip: IpAddr) -> String {
fold(&hickory_resolver::proto::rr::Name::from(ip).to_ascii())
}
struct Scope {
domain: String,
client: Result<Resolver<ZonedRuntime>, String>,
unasked: Once,
}
async fn ask<P: ConnectionProvider>(client: &Resolver<P>, name: &str) -> Vec<IpAddr> {
match client.lookup_ip(name).await {
Ok(lookup) => lookup.iter().collect(),
Err(_) => Vec::new(),
}
}
fn build<P: ConnectionProvider>(
conf: ResolverConfig,
mut opts: ResolverOpts,
runtime: P,
) -> Result<Resolver<P>, String> {
opts.use_hosts_file = ResolveHosts::Never;
Resolver::builder_with_config(conf, runtime)
.with_options(opts)
.build()
.map_err(|e| e.to_string())
}
#[derive(Clone)]
struct ZonedRuntime {
tokio: TokioRuntimeProvider,
zones: Arc<[(Ipv6Addr, u32)]>,
}
impl ZonedRuntime {
fn for_servers(servers: &[SocketAddr]) -> Self {
let zones = servers
.iter()
.filter_map(|at| match at {
SocketAddr::V6(v6) if v6.scope_id() != 0 => Some((*v6.ip(), v6.scope_id())),
_ => None,
})
.collect();
Self {
tokio: TokioRuntimeProvider::default(),
zones,
}
}
fn zoned(zones: &[(Ipv6Addr, u32)], to: SocketAddr) -> SocketAddr {
match to {
SocketAddr::V6(mut v6) if v6.scope_id() == 0 => {
if let Some((_, scope)) = zones.iter().find(|(ip, _)| ip == v6.ip()) {
v6.set_scope_id(*scope);
}
SocketAddr::V6(v6)
}
other => other,
}
}
}
impl RuntimeProvider for ZonedRuntime {
type Handle = <TokioRuntimeProvider as RuntimeProvider>::Handle;
type Timer = <TokioRuntimeProvider as RuntimeProvider>::Timer;
type Udp = ZonedUdp;
type Tcp = <TokioRuntimeProvider as RuntimeProvider>::Tcp;
fn create_handle(&self) -> Self::Handle {
self.tokio.create_handle()
}
fn connect_tcp(
&self,
server_addr: SocketAddr,
bind_addr: Option<SocketAddr>,
timeout: Option<Duration>,
) -> Pin<Box<dyn Send + Future<Output = Result<Self::Tcp, io::Error>>>> {
let server_addr = Self::zoned(&self.zones, server_addr);
self.tokio.connect_tcp(server_addr, bind_addr, timeout)
}
fn bind_udp(
&self,
local_addr: SocketAddr,
server_addr: SocketAddr,
) -> Pin<Box<dyn Send + Future<Output = Result<Self::Udp, io::Error>>>> {
let zones = Arc::clone(&self.zones);
let bound = self.tokio.bind_udp(local_addr, server_addr);
Box::pin(async move {
Ok(ZonedUdp {
socket: bound.await?,
zones,
})
})
}
}
struct ZonedUdp {
socket: <TokioRuntimeProvider as RuntimeProvider>::Udp,
zones: Arc<[(Ipv6Addr, u32)]>,
}
impl DnsUdpSocket for ZonedUdp {
type Time = <<TokioRuntimeProvider as RuntimeProvider>::Udp as DnsUdpSocket>::Time;
fn poll_recv_from(
&self,
cx: &mut Context<'_>,
buf: &mut [u8],
) -> Poll<io::Result<(usize, SocketAddr)>> {
DnsUdpSocket::poll_recv_from(&self.socket, cx, buf)
}
fn poll_send_to(
&self,
cx: &mut Context<'_>,
buf: &[u8],
target: SocketAddr,
) -> Poll<io::Result<usize>> {
let target = ZonedRuntime::zoned(&self.zones, target);
DnsUdpSocket::poll_send_to(&self.socket, cx, buf, target)
}
}
pub(crate) fn covers(domain: &str, name: &str) -> bool {
!domain.is_empty()
&& (name == domain
|| name
.strip_suffix(domain)
.is_some_and(|host| host.ends_with('.')))
}
fn fold(name: &str) -> String {
name.trim_end_matches('.').to_ascii_lowercase()
}
#[cfg(target_vendor = "apple")]
fn read_scoped() -> Vec<ScopedServers> {
match std::process::Command::new("/usr/sbin/scutil")
.arg("--dns")
.output()
{
Ok(out) if out.status.success() => {
parse_scutil_dns(&String::from_utf8_lossy(&out.stdout), interface_index)
}
Ok(out) => {
info!(
verbosity = 1,
"scoped resolvers not read (scutil: {})", out.status
);
Vec::new()
}
Err(e) => {
info!(verbosity = 1, "scoped resolvers not read (scutil: {e})");
Vec::new()
}
}
}
#[cfg(target_vendor = "apple")]
fn interface_index(name: &str) -> Option<u32> {
let name = std::ffi::CString::new(name).ok()?;
let index = unsafe { libc::if_nametoindex(name.as_ptr()) };
(index != 0).then_some(index)
}
#[cfg(not(target_vendor = "apple"))]
fn read_scoped() -> Vec<ScopedServers> {
Vec::new()
}
#[cfg(any(target_vendor = "apple", test))]
fn parse_scutil_dns(report: &str, index_of: impl Fn(&str) -> Option<u32>) -> Vec<ScopedServers> {
const DNS_PORT: u16 = 53;
#[derive(Default)]
struct Entry {
domain: Option<String>,
servers: Vec<Result<(IpAddr, u32), String>>,
port: Option<Result<u16, String>>,
mdns: bool,
}
fn finish(entry: Entry, into: &mut Vec<ScopedServers>) {
let Some(domain) = entry.domain else { return };
if entry.mdns || entry.servers.is_empty() {
return;
}
let servers = entry.port.unwrap_or(Ok(DNS_PORT)).and_then(|port| {
let (usable, unusable): (Vec<_>, Vec<_>) =
entry.servers.into_iter().partition(Result::is_ok);
let usable: Vec<SocketAddr> = usable
.into_iter()
.flatten()
.map(|(ip, scope)| match ip {
IpAddr::V4(v4) => SocketAddr::new(v4.into(), port),
IpAddr::V6(v6) => std::net::SocketAddrV6::new(v6, port, 0, scope).into(),
})
.collect();
match unusable.into_iter().find_map(Result::err) {
Some(why) if usable.is_empty() => Err(why),
_ => Ok(usable),
}
});
into.push(ScopedServers { domain, servers });
}
fn server(
value: &str,
index_of: &impl Fn(&str) -> Option<u32>,
) -> Result<(IpAddr, u32), String> {
let (address, zone) = match value.split_once('%') {
Some((address, zone)) => (address, Some(zone)),
None => (value, None),
};
let unreadable = || format!("server {value} unreadable");
match (address.parse().map_err(|_| unreadable())?, zone) {
(ip @ IpAddr::V6(_), Some(zone)) => index_of(zone)
.filter(|&index| index != 0)
.map(|index| (ip, index))
.ok_or_else(|| format!("{zone} not found")),
(IpAddr::V4(_), Some(_)) => Err(unreadable()),
(IpAddr::V6(v6), None) if v6.is_unicast_link_local() => {
Err(format!("server {value} has no interface"))
}
(ip, None) => Ok((ip, 0)),
}
}
let mut found = Vec::new();
let mut entry: Option<Entry> = None;
for line in report.lines() {
let line = line.trim();
if line.starts_with("DNS configuration (") {
break;
}
if line.starts_with("resolver #") {
if let Some(done) = entry.replace(Entry::default()) {
finish(done, &mut found);
}
continue;
}
let (Some(current), Some((key, value))) = (entry.as_mut(), line.split_once(':')) else {
continue;
};
let (key, value) = (key.trim(), value.trim());
match key {
"domain" => current.domain = Some(fold(value)).filter(|d| !d.is_empty()),
"port" => {
current.port = Some(
value
.parse()
.ok()
.filter(|&port| port != 0)
.ok_or_else(|| format!("port {value} unreadable")),
);
}
"options" => current.mdns |= value.split_whitespace().any(|o| o == "mdns"),
_ if key.starts_with("nameserver[") => current.servers.push(server(value, &index_of)),
_ => {}
}
}
if let Some(done) = entry {
finish(done, &mut found);
}
found
}
#[cfg(test)]
mod tests {
use super::*;
use crate::logging::logged;
const REPORT: &str = "\
DNS configuration
resolver #1
search domain[0] : home.example
nameserver[0] : 192.0.2.1
if_index : 15 (en1)
flags : Request A records, Request AAAA records
reach : 0x00020002 (Reachable,Directly Reachable Address)
resolver #2
domain : Corp.Example.
nameserver[0] : 198.51.100.53
nameserver[1] : fe80::53%utun4
nameserver[2] : 2001:db8::53
flags : Supplemental, Request A records, Request AAAA records
order : 102400
resolver #3
domain : local
options : mdns
timeout : 5
order : 300000
resolver #4
domain : lab.example
nameserver[0] : 203.0.113.53
port : 5353
resolver #5
domain : nothing-to-ask.example
DNS configuration (for scoped queries)
resolver #1
domain : scoped-only.example
nameserver[0] : 192.0.2.99
if_index : 15 (en1)
";
fn utun4_is_9(name: &str) -> Option<u32> {
(name == "utun4").then_some(9)
}
#[test]
fn a_scutil_report_yields_the_domains_with_servers_of_their_own() {
let at = |s: &str| s.parse::<SocketAddr>().expect("a socket address");
assert_eq!(
parse_scutil_dns(REPORT, utun4_is_9),
vec![
ScopedServers {
domain: "corp.example".into(),
servers: Ok(vec![
at("198.51.100.53:53"),
at("[fe80::53%9]:53"),
at("[2001:db8::53]:53"),
]),
},
ScopedServers {
domain: "lab.example".into(),
servers: Ok(vec![at("203.0.113.53:5353")]),
},
]
);
}
const ZONED_REPORT: &str = "\
DNS configuration
resolver #1
domain : vpn.example
nameserver[0] : fe80::53%utun4
";
fn global_at(at: SocketAddr) -> (ResolverConfig, ResolverOpts) {
let mut server = NameServerConfig::udp(at.ip());
for connection in &mut server.connections {
connection.port = at.port();
}
let mut opts = ResolverOpts::default();
opts.attempts = 1;
opts.timeout = std::time::Duration::from_millis(200);
(
ResolverConfig::from_parts(None, Vec::new(), vec![server]),
opts,
)
}
#[test]
fn a_domain_whose_only_server_is_link_local_keeps_it_with_its_scope() {
let scoped = parse_scutil_dns(ZONED_REPORT, utun4_is_9);
assert_eq!(
scoped,
vec![ScopedServers {
domain: "vpn.example".into(),
servers: Ok(vec!["[fe80::53%9]:53".parse().expect("an address")]),
}]
);
let unicast = Unicast::from_config(DnsConfig {
global: Err("none configured".into()),
scoped,
});
assert!(unicast.claims("intranet.vpn.example"));
}
#[test]
fn a_domain_whose_server_interface_is_gone_is_never_asked_of_the_global_server() {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("a runtime builds");
let global = crate::testing::loopback::SilentUdpPort::open();
let unicast = Unicast::from_config(DnsConfig {
global: Ok(global_at(global.addr())),
scoped: parse_scutil_dns(ZONED_REPORT, |_| None),
});
assert!(unicast.claims("intranet.vpn.example"));
let mut resolved = Vec::new();
let lines = logged(|| {
runtime.block_on(async {
for name in ["intranet.vpn.example", "wiki.vpn.example"] {
resolved.extend(unicast.lookup(name).await);
}
});
});
assert_eq!(resolved, Vec::<IpAddr>::new());
assert!(
global.datagrams().is_empty(),
"the VPN name reached the global server"
);
let said: Vec<_> = lines
.iter()
.filter(|l| l.verbosity == 0 && l.message.contains("vpn.example"))
.map(|l| l.message.as_str())
.collect();
assert_eq!(said, ["DNS for vpn.example not asked (utun4 not found)"]);
}
#[test]
fn a_resolver_whose_servers_do_not_read_keeps_its_domain() {
let report = "\
DNS configuration
resolver #1
domain : port.example
nameserver[0] : 198.51.100.53
port : domain
resolver #2
domain : garbled.example
nameserver[0] : 198.51.100.53:53
resolver #3
domain : zoneless.example
nameserver[0] : fe80::53
resolver #4
domain : zoned-v4.example
nameserver[0] : 198.51.100.53%utun4
resolver #5
domain : mixed.example
nameserver[0] : fe80::53%utun9
nameserver[1] : 2001:db8::53
";
let unasked = |domain: &str, why: &str| ScopedServers {
domain: domain.into(),
servers: Err(why.into()),
};
assert_eq!(
parse_scutil_dns(report, utun4_is_9),
vec![
unasked("port.example", "port domain unreadable"),
unasked("garbled.example", "server 198.51.100.53:53 unreadable"),
unasked("zoneless.example", "server fe80::53 has no interface"),
unasked("zoned-v4.example", "server 198.51.100.53%utun4 unreadable"),
ScopedServers {
domain: "mixed.example".into(),
servers: Ok(vec!["[2001:db8::53]:53".parse().expect("an address")]),
},
]
);
}
#[test]
fn the_runtime_sends_to_a_link_local_server_through_its_interface() {
let at = |s: &str| s.parse::<SocketAddr>().expect("a socket address");
let runtime = ZonedRuntime::for_servers(&[at("[fe80::53%9]:53"), at("192.0.2.53:53")]);
assert_eq!(
ZonedRuntime::zoned(&runtime.zones, at("[fe80::53]:53")),
at("[fe80::53%9]:53")
);
for untouched in ["[fe80::53%4]:53", "[fe80::54]:53", "192.0.2.53:53"] {
assert_eq!(
ZonedRuntime::zoned(&runtime.zones, at(untouched)),
at(untouched)
);
}
}
#[test]
fn a_domain_covers_itself_and_the_names_under_it_and_nothing_else() {
assert!(covers("corp.example", "corp.example"));
assert!(covers("corp.example", "dc01.corp.example"));
assert!(!covers("corp.example", "notcorp.example"));
assert!(!covers("corp.example", "example"));
assert!(!covers("", "example"));
}
}