use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard, Weak};
use std::time::{Duration, Instant};
use hickory_resolver::TokioResolver;
use hickory_resolver::config::{
NameServerConfig, ResolveHosts, ResolverConfig, ResolverOpts, ServerOrderingStrategy,
};
use hickory_resolver::net::runtime::TokioRuntimeProvider;
use super::entry::DnsEntry;
use crate::error::Aria2Error;
use crate::network::{ConnectionContext, EndpointKey};
#[derive(Clone)]
pub struct DnsCache {
pub(super) state: Arc<RwLock<DnsCacheState>>,
default_ttl: Duration,
negative_ttl: Duration,
ipv4_preference: Arc<AtomicBool>,
dns_timeout: Duration,
dns_server_addresses: Arc<[SocketAddr]>,
resolvers: Vec<Arc<TokioResolver>>,
}
#[derive(Default)]
pub(super) struct DnsCacheState {
pub(super) cache: HashMap<EndpointKey, DnsEntry>,
pub(super) negative_entries: HashMap<EndpointKey, Instant>,
lookup_flights: HashMap<EndpointKey, Weak<LookupFlight>>,
}
struct LookupFlight {
lock: tokio::sync::Mutex<()>,
generation: std::sync::atomic::AtomicU64,
}
impl LookupFlight {
fn new() -> Self {
Self {
lock: tokio::sync::Mutex::new(()),
generation: std::sync::atomic::AtomicU64::new(0),
}
}
}
impl DnsCache {
const DEFAULT_DNS_TIMEOUT: Duration = Duration::from_secs(30);
pub fn new() -> Self {
Self::with_ttl_and_dns_timeout(300, 60, Self::DEFAULT_DNS_TIMEOUT)
}
pub fn with_ttl(default_ttl_secs: u64, negative_ttl_secs: u64) -> Self {
Self::with_ttl_and_dns_timeout(
default_ttl_secs,
negative_ttl_secs,
Self::DEFAULT_DNS_TIMEOUT,
)
}
pub fn with_dns_timeout(timeout: Duration) -> Self {
Self::with_ttl_and_dns_timeout(300, 60, timeout)
}
pub fn with_dns_servers(timeout: Duration, servers: Vec<SocketAddr>) -> Self {
let mut cache = Self::with_dns_timeout(timeout);
let per_server_timeout = timeout / servers.len().max(1) as u32;
cache.resolvers = servers
.iter()
.filter_map(|address| build_resolver(per_server_timeout, Some(*address)).map(Arc::new))
.collect();
cache.dns_server_addresses = Arc::from(servers);
cache
}
pub fn parse_dns_server_list(raw: &str) -> Result<Vec<SocketAddr>, String> {
raw.split(',')
.map(str::trim)
.map(|value| {
if value.is_empty() {
return Err("DNS server list contains an empty address".to_string());
}
value
.parse::<IpAddr>()
.map(|ip| SocketAddr::new(ip, 53))
.map_err(|error| format!("invalid DNS server address '{}': {}", value, error))
})
.collect()
}
fn with_ttl_and_dns_timeout(
default_ttl_secs: u64,
negative_ttl_secs: u64,
dns_timeout: Duration,
) -> Self {
Self {
state: Arc::new(RwLock::new(DnsCacheState::default())),
default_ttl: Duration::from_secs(default_ttl_secs),
negative_ttl: Duration::from_secs(negative_ttl_secs),
ipv4_preference: Arc::new(AtomicBool::new(true)), dns_timeout,
dns_server_addresses: Arc::from([]),
resolvers: build_resolver(dns_timeout, None)
.into_iter()
.map(Arc::new)
.collect(),
}
}
fn read_state(&self) -> RwLockReadGuard<'_, DnsCacheState> {
self.state.read().unwrap_or_else(|error| error.into_inner())
}
fn write_state(&self) -> RwLockWriteGuard<'_, DnsCacheState> {
self.state
.write()
.unwrap_or_else(|error| error.into_inner())
}
fn lookup_flight(&self, endpoint: &EndpointKey) -> Arc<LookupFlight> {
let mut state = self.write_state();
state
.lookup_flights
.retain(|_, flight| flight.strong_count() > 0);
if let Some(flight) = state.lookup_flights.get(endpoint).and_then(Weak::upgrade) {
return flight;
}
let flight = Arc::new(LookupFlight::new());
state
.lookup_flights
.insert(endpoint.clone(), Arc::downgrade(&flight));
flight
}
pub fn with_resolver(mut self, resolver: TokioResolver) -> Self {
self.resolvers = vec![Arc::new(resolver)];
self
}
pub async fn resolve(&self, hostname: &str, port: u16) -> Result<Vec<SocketAddr>, Aria2Error> {
self.purge_expired();
let endpoint = EndpointKey::new(hostname, port);
if let Some(result) = self.cached_result(&endpoint, hostname) {
return result;
}
let flight = self.lookup_flight(&endpoint);
let _lookup_guard = flight.lock.lock().await;
self.purge_expired();
if let Some(result) = self.cached_result(&endpoint, hostname) {
return result;
}
let generation = flight.generation.load(Ordering::Acquire);
let lookup = self.lookup_uncached(hostname, port).await;
let mut state = self.write_state();
if flight.generation.load(Ordering::Acquire) == generation {
match &lookup {
Ok((addresses, ttl)) => {
let entry = DnsEntry::new(
endpoint.clone(),
addresses.clone(),
Instant::now(),
*ttl,
self.ipv4_preference.load(Ordering::Relaxed),
);
state.cache.insert(endpoint.clone(), entry);
state.negative_entries.remove(&endpoint);
}
Err(_) => {
state.negative_entries.insert(endpoint, Instant::now());
}
}
}
lookup.map(|(addresses, _)| addresses)
}
fn cached_result(
&self,
endpoint: &EndpointKey,
hostname: &str,
) -> Option<Result<Vec<SocketAddr>, Aria2Error>> {
let state = self.read_state();
if let Some(entry) = state.cache.get(endpoint)
&& !entry.is_expired()
{
return Some(Ok(entry.all_addresses()));
}
if let Some(failed_at) = state.negative_entries.get(endpoint)
&& failed_at.elapsed() < self.negative_ttl
{
return Some(Err(Aria2Error::NameResolve(format!(
"DNS lookup recently failed for {} (retry after {:?})",
hostname,
self.negative_ttl.saturating_sub(failed_at.elapsed())
))));
}
None
}
async fn lookup_uncached(
&self,
hostname: &str,
port: u16,
) -> Result<(Vec<SocketAddr>, Duration), Aria2Error> {
let lookup_started = Instant::now();
let mut hickory_failure = None;
let per_server_timeout = self.dns_timeout / self.resolvers.len().max(1) as u32;
for resolver in &self.resolvers {
let remaining_timeout = self.dns_timeout.saturating_sub(lookup_started.elapsed());
if remaining_timeout.is_zero() {
hickory_failure = Some("DNS lookup deadline elapsed".to_string());
break;
}
match tokio::time::timeout(
remaining_timeout.min(per_server_timeout),
resolver.lookup_ip(hostname),
)
.await
{
Err(error) => {
hickory_failure = Some(format!("Hickory lookup timed out: {error}"));
tracing::debug!(
hostname = hostname,
timeout = ?per_server_timeout,
error = %error,
"Hickory DNS lookup timed out"
);
}
Ok(Err(error)) => {
hickory_failure = Some(error.to_string());
tracing::debug!(
hostname = hostname,
error = %error,
"Hickory DNS lookup failed"
);
}
Ok(Ok(lookup)) => {
let mut addrs: Vec<SocketAddr> =
lookup.iter().map(|ip| SocketAddr::new(ip, port)).collect();
if !addrs.is_empty() {
let record_ttl = lookup
.valid_until()
.saturating_duration_since(Instant::now());
let actual_ttl = record_ttl.min(self.default_ttl);
let ipv4_preference = self.ipv4_preference.load(Ordering::Relaxed);
if ipv4_preference {
addrs.sort_by_key(|a| match a.ip() {
IpAddr::V4(_) => 0u8,
IpAddr::V6(_) => 1u8,
});
}
tracing::trace!(
hostname = hostname,
addr_count = addrs.len(),
ttl_secs = actual_ttl.as_secs(),
"DNS resolved via hickory async resolver"
);
return Ok((addrs, actual_ttl));
}
hickory_failure = Some("Hickory returned no addresses".to_string());
tracing::debug!(hostname = hostname, "Hickory returned no addresses");
}
}
}
if !self.dns_server_addresses.is_empty() {
let reason = hickory_failure
.unwrap_or_else(|| "the configured resolver is unavailable".to_string());
tracing::debug!(
hostname = hostname,
error = %reason,
"DNS resolution failed using explicitly configured servers"
);
return Err(Aria2Error::NameResolve(format!(
"DNS resolution failed for {} using explicitly configured servers: {}",
hostname, reason
)));
}
let addr_str = format!("{}:{}", hostname, port);
let remaining_timeout = self.dns_timeout.saturating_sub(lookup_started.elapsed());
let fallback = tokio::time::timeout(remaining_timeout, tokio::net::lookup_host(&addr_str))
.await
.map_err(|error| {
std::io::Error::new(
std::io::ErrorKind::TimedOut,
format!("DNS lookup timed out after {:?}: {error}", self.dns_timeout),
)
})
.and_then(|result| result);
match fallback {
Ok(addrs) => {
let mut sorted: Vec<SocketAddr> = addrs.collect();
let ipv4_preference = self.ipv4_preference.load(Ordering::Relaxed);
if ipv4_preference {
sorted.sort_by_key(|a| match a.ip() {
IpAddr::V4(_) => 0u8,
IpAddr::V6(_) => 1u8,
});
}
tracing::trace!(
hostname = hostname,
addr_count = sorted.len(),
"DNS resolved via tokio::net::lookup_host fallback"
);
Ok((sorted, self.default_ttl))
}
Err(e) => {
tracing::debug!(
hostname = hostname,
error = %e,
"DNS resolution failed via fallback"
);
Err(Aria2Error::NameResolve(format!(
"DNS resolution failed for {}: {}",
hostname, e
)))
}
}
}
pub async fn resolve_with_refresh(
&self,
hostname: &str,
port: u16,
) -> Result<Vec<SocketAddr>, Aria2Error> {
let addresses = self.resolve(hostname, port).await?;
if !addresses.is_empty() {
return Ok(addresses);
}
self.remove_cached(hostname, port);
self.resolve(hostname, port).await
}
pub async fn force_refresh(
&self,
hostname: &str,
port: u16,
) -> Result<Vec<SocketAddr>, Aria2Error> {
self.remove_cached(hostname, port);
self.resolve(hostname, port).await
}
pub fn clear(&self) {
let mut state = self.write_state();
state.cache.clear();
state.negative_entries.clear();
for flight in state.lookup_flights.values().filter_map(Weak::upgrade) {
flight.generation.fetch_add(1, Ordering::AcqRel);
}
}
pub fn mark_bad(&self, hostname: &str, address: SocketAddr) {
self.mark_bad_context(&ConnectionContext::new(hostname, address.port(), address));
}
pub fn mark_bad_context(&self, context: &ConnectionContext) {
let mut state = self.write_state();
if let Some(entry) = state.cache.get_mut(&context.endpoint) {
entry.mark_bad(context.peer_addr);
}
Self::invalidate_lookup(&mut state, &context.endpoint);
}
pub fn has_good_address(&self, endpoint: &EndpointKey) -> bool {
self.read_state()
.cache
.get(endpoint)
.is_some_and(|entry| !entry.all_addresses().is_empty())
}
pub fn remove_cached(&self, hostname: &str, port: u16) {
let endpoint = EndpointKey::new(hostname, port);
let mut state = self.write_state();
state.cache.remove(&endpoint);
state.negative_entries.remove(&endpoint);
Self::invalidate_lookup(&mut state, &endpoint);
}
pub fn purge_expired(&self) -> usize {
let mut state = self.write_state();
let before = state.cache.len();
state.cache.retain(|_, v| !v.is_expired());
state
.negative_entries
.retain(|_, t| t.elapsed() < self.negative_ttl);
state
.lookup_flights
.retain(|_, flight| flight.strong_count() > 0);
before - state.cache.len()
}
pub fn set_ipv4_preference(&self, prefer_ipv4: bool) {
self.ipv4_preference.store(prefer_ipv4, Ordering::Relaxed);
}
pub fn len(&self) -> usize {
self.read_state().cache.len()
}
pub fn is_empty(&self) -> bool {
self.read_state().cache.is_empty()
}
pub fn default_ttl(&self) -> Duration {
self.default_ttl
}
pub fn negative_ttl(&self) -> Duration {
self.negative_ttl
}
pub fn dns_timeout(&self) -> Duration {
self.dns_timeout
}
pub fn dns_server_addresses(&self) -> &[SocketAddr] {
&self.dns_server_addresses
}
pub fn record_failure(&self, hostname: &str, port: u16) {
self.write_state()
.negative_entries
.insert(EndpointKey::new(hostname, port), Instant::now());
}
pub fn resolve_no_network(
&self,
hostname: &str,
port: u16,
) -> Result<Vec<SocketAddr>, Aria2Error> {
let endpoint = EndpointKey::new(hostname, port);
let state = self.read_state();
if let Some(entry) = state.cache.get(&endpoint)
&& !entry.is_expired()
{
return Ok(entry.all_addresses());
}
if let Some(failed_at) = state.negative_entries.get(&endpoint)
&& failed_at.elapsed() < self.negative_ttl
{
return Err(Aria2Error::NameResolve(format!(
"DNS lookup recently failed for {} (retry after {:?})",
hostname,
self.negative_ttl.saturating_sub(failed_at.elapsed())
)));
}
Err(Aria2Error::NameResolve(format!(
"No cached entry for {}:{}",
hostname, port
)))
}
fn invalidate_lookup(state: &mut DnsCacheState, endpoint: &EndpointKey) {
if let Some(flight) = state.lookup_flights.get(endpoint).and_then(Weak::upgrade) {
flight.generation.fetch_add(1, Ordering::AcqRel);
}
}
}
fn build_resolver(timeout: Duration, server: Option<SocketAddr>) -> Option<TokioResolver> {
let (config, mut opts) = match server {
Some(address) => {
let mut name_server = NameServerConfig::udp(address.ip());
name_server.connections[0].port = address.port();
(
ResolverConfig::from_parts(None, Vec::new(), vec![name_server]),
ResolverOpts::default(),
)
}
None => hickory_resolver::system_conf::read_system_conf().ok()?,
};
opts.use_hosts_file = ResolveHosts::Always;
opts.num_concurrent_reqs = 1;
opts.server_ordering_strategy = ServerOrderingStrategy::UserProvidedOrder;
opts.timeout = timeout.min(Duration::from_secs(5));
TokioResolver::builder_with_config(config, TokioRuntimeProvider::default())
.with_options(opts)
.build()
.ok()
}
impl Default for DnsCache {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod concurrency_tests {
use super::*;
#[test]
fn lookup_flights_are_scoped_by_endpoint() {
let cache = DnsCache::new();
let endpoint = EndpointKey::new("same.test", 80);
let same_endpoint = cache.lookup_flight(&endpoint);
let same_endpoint_again = cache.lookup_flight(&endpoint);
let other_endpoint = cache.lookup_flight(&EndpointKey::new("other.test", 80));
assert!(Arc::ptr_eq(&same_endpoint, &same_endpoint_again));
let _held = same_endpoint.lock.try_lock().unwrap();
assert!(same_endpoint_again.lock.try_lock().is_err());
assert!(other_endpoint.lock.try_lock().is_ok());
}
}