use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::time::{Duration, Instant};
use hickory_resolver::TokioAsyncResolver;
use hickory_resolver::config::{ResolverConfig, ResolverOpts};
use super::entry::DnsEntry;
use crate::error::Aria2Error;
use crate::network::{ConnectionContext, EndpointKey};
pub struct DnsCache {
pub(crate) cache: HashMap<EndpointKey, DnsEntry>,
default_ttl: Duration,
negative_ttl: Duration,
pub(crate) negative_entries: HashMap<EndpointKey, Instant>,
ipv4_preference: bool,
resolver: Option<TokioAsyncResolver>,
}
impl DnsCache {
pub fn new() -> Self {
Self {
cache: HashMap::new(),
default_ttl: Duration::from_secs(300), negative_ttl: Duration::from_secs(60), negative_entries: HashMap::new(),
ipv4_preference: true, resolver: build_default_resolver(),
}
}
pub fn with_ttl(default_ttl_secs: u64, negative_ttl_secs: u64) -> Self {
Self {
default_ttl: Duration::from_secs(default_ttl_secs),
negative_ttl: Duration::from_secs(negative_ttl_secs),
..Self::new()
}
}
pub fn with_resolver(mut self, resolver: TokioAsyncResolver) -> Self {
self.resolver = Some(resolver);
self
}
pub async fn resolve(
&mut self,
hostname: &str,
port: u16,
) -> Result<Vec<SocketAddr>, Aria2Error> {
let endpoint = EndpointKey::new(hostname, port);
if let Some(entry) = self.cache.get(&endpoint)
&& !entry.is_expired()
{
return Ok(entry.all_addresses());
}
if let Some(failed_at) = self.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())
)));
}
if let Some(resolver) = self.resolver.as_ref() {
match resolver.lookup_ip(hostname).await {
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);
if self.ipv4_preference {
addrs.sort_by_key(|a| match a.ip() {
IpAddr::V4(_) => 0u8,
IpAddr::V6(_) => 1u8,
});
}
let entry = DnsEntry::new(
endpoint.clone(),
addrs.clone(),
Instant::now(),
actual_ttl,
self.ipv4_preference,
);
self.cache.insert(endpoint.clone(), entry);
self.negative_entries.remove(&endpoint);
tracing::trace!(
hostname = hostname,
addr_count = addrs.len(),
ttl_secs = actual_ttl.as_secs(),
"DNS resolved via hickory async resolver"
);
return Ok(addrs);
}
tracing::debug!(
hostname = hostname,
"hickory returned no addresses, falling back to tokio::net::lookup_host"
);
}
Err(e) => {
tracing::debug!(
hostname = hostname,
error = %e,
"hickory DNS lookup failed, falling back to tokio::net::lookup_host"
);
}
}
}
let addr_str = format!("{}:{}", hostname, port);
match tokio::net::lookup_host(&addr_str).await {
Ok(addrs) => {
let mut sorted: Vec<SocketAddr> = addrs.collect();
if self.ipv4_preference {
sorted.sort_by_key(|a| match a.ip() {
IpAddr::V4(_) => 0u8,
IpAddr::V6(_) => 1u8,
});
}
let entry = DnsEntry::new(
endpoint.clone(),
sorted.clone(),
Instant::now(),
self.default_ttl,
self.ipv4_preference,
);
self.cache.insert(endpoint.clone(), entry);
self.negative_entries.remove(&endpoint);
tracing::trace!(
hostname = hostname,
addr_count = sorted.len(),
"DNS resolved via tokio::net::lookup_host fallback"
);
Ok(sorted)
}
Err(e) => {
self.negative_entries.insert(endpoint, Instant::now());
tracing::debug!(
hostname = hostname,
error = %e,
"DNS resolution failed via fallback"
);
Err(Aria2Error::NameResolve(format!(
"DNS resolution failed for {}: {}",
hostname, e
)))
}
}
}
pub async fn force_refresh(
&mut self,
hostname: &str,
port: u16,
) -> Result<Vec<SocketAddr>, Aria2Error> {
self.remove_cached(hostname, port);
self.resolve(hostname, port).await
}
pub fn clear(&mut self) {
self.cache.clear();
self.negative_entries.clear();
}
pub fn mark_bad(&mut self, hostname: &str, address: SocketAddr) {
self.mark_bad_context(&ConnectionContext::new(hostname, address.port(), address));
}
pub fn mark_bad_context(&mut self, context: &ConnectionContext) {
if let Some(entry) = self.cache.get_mut(&context.endpoint) {
entry.mark_bad(context.peer_addr);
}
}
pub fn has_good_address(&self, endpoint: &EndpointKey) -> bool {
self.cache
.get(endpoint)
.is_some_and(|entry| !entry.all_addresses().is_empty())
}
pub fn remove_cached(&mut self, hostname: &str, port: u16) {
let endpoint = EndpointKey::new(hostname, port);
self.cache.remove(&endpoint);
self.negative_entries.remove(&endpoint);
}
pub fn purge_expired(&mut self) -> usize {
let before = self.cache.len();
self.cache.retain(|_, v| !v.is_expired());
self.negative_entries
.retain(|_, t| t.elapsed() < self.negative_ttl);
before - self.cache.len()
}
pub fn set_ipv4_preference(&mut self, prefer_ipv4: bool) {
self.ipv4_preference = prefer_ipv4;
}
pub fn len(&self) -> usize {
self.cache.len()
}
pub fn is_empty(&self) -> bool {
self.cache.is_empty()
}
pub fn default_ttl(&self) -> Duration {
self.default_ttl
}
pub fn negative_ttl(&self) -> Duration {
self.negative_ttl
}
pub fn record_failure(&mut self, hostname: &str, port: u16) {
self.negative_entries
.insert(EndpointKey::new(hostname, port), Instant::now());
}
pub fn resolve_no_network(
&mut self,
hostname: &str,
port: u16,
) -> Result<Vec<SocketAddr>, Aria2Error> {
let endpoint = EndpointKey::new(hostname, port);
if let Some(entry) = self.cache.get(&endpoint)
&& !entry.is_expired()
{
return Ok(entry.all_addresses());
}
if let Some(failed_at) = self.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 build_default_resolver() -> Option<TokioAsyncResolver> {
let mut opts = ResolverOpts::default();
opts.use_hosts_file = true;
Some(TokioAsyncResolver::tokio(ResolverConfig::default(), opts))
}
impl Default for DnsCache {
fn default() -> Self {
Self::new()
}
}