Update to hickory-resolver 0.25

Author: tottoto

Cargo.lock

@@ -98,8 +98,8 @@ futures-io = "0.3.21"
 futures-core = "0.3.14"
 futures-util = { version = "0.3.14", features = ["io"] }
 hex = "0.4.0"
-hickory-proto = { version = "0.24.2", optional = true }
-hickory-resolver = { version = "0.24.2", optional = true }
+hickory-proto = { version = "0.25", optional = true }
+hickory-resolver = { version = "0.25", optional = true }
 hmac = "0.12.1"
 log = { version = "0.4.17", optional = true }
 md-5 = "0.10.1"

Cargo.toml

@@ -5,12 +5,33 @@ use hickory_resolver::config::ResolverConfig as HickoryResolverConfig;
 ///
 /// This is a thin wrapper around a `hickory_resolver::config::ResolverConfig` provided to ensure
 /// API stability.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug)]
 pub struct ResolverConfig {
     #[cfg(feature = "dns-resolver")]
     pub(crate) inner: HickoryResolverConfig,
 }
 
+impl PartialEq for ResolverConfig {
+    fn eq(&self, other: &Self) -> bool {
+        let (left, right) = (&self.inner, &other.inner);
+
+        if !(left.domain() == right.domain()
+            && left.search() == right.search()
+            && left.name_servers().len() == right.name_servers().len())
+        {
+            return false;
+        }
+
+        for (a, b) in std::iter::zip(left.name_servers(), right.name_servers()) {
+            if !(a.socket_addr == b.socket_addr && a.protocol == b.protocol) {
+                return false;
+            }
+        }
+
+        true
+    }
+}
+
 #[cfg(feature = "dns-resolver")]
 impl ResolverConfig {
     /// Creates a default configuration, using 1.1.1.1, 1.0.0.1 and 2606:4700:4700::1111,

src/client/options/resolver_config.rs

@@ -317,15 +317,15 @@ impl Error {
     }
 
     #[cfg(feature = "dns-resolver")]
-    pub(crate) fn from_resolve_error(error: hickory_resolver::error::ResolveError) -> Self {
+    pub(crate) fn from_resolve_error(error: hickory_resolver::ResolveError) -> Self {
         ErrorKind::DnsResolve {
             message: error.to_string(),
         }
         .into()
     }
 
     #[cfg(feature = "dns-resolver")]
-    pub(crate) fn from_resolve_proto_error(error: hickory_proto::error::ProtoError) -> Self {
+    pub(crate) fn from_resolve_proto_error(error: hickory_proto::ProtoError) -> Self {
         ErrorKind::DnsResolve {
             message: error.to_string(),
         }

src/error.rs

@@ -1,7 +1,6 @@
 use crate::error::{Error, Result};
 use hickory_resolver::{
     config::ResolverConfig,
-    error::ResolveErrorKind,
     lookup::{SrvLookup, TxtLookup},
     Name,
 };
@@ -17,16 +16,20 @@ use std::net::IpAddr;
 
 /// An async runtime agnostic DNS resolver.
 pub(crate) struct AsyncResolver {
-    resolver: hickory_resolver::TokioAsyncResolver,
+    resolver: hickory_resolver::TokioResolver,
 }
 
 impl AsyncResolver {
     pub(crate) async fn new(config: Option<ResolverConfig>) -> Result<Self> {
         let resolver = match config {
-            Some(config) => hickory_resolver::TokioAsyncResolver::tokio(config, Default::default()),
-            None => hickory_resolver::TokioAsyncResolver::tokio_from_system_conf()
+            Some(config) => hickory_resolver::TokioResolver::builder_with_config(
+                config,
+                hickory_resolver::name_server::TokioConnectionProvider::default(),
+            ),
+            None => hickory_resolver::TokioResolver::builder_tokio()
                 .map_err(Error::from_resolve_error)?,
-        };
+        }
+        .build();
 
         Ok(Self { resolver })
     }
@@ -80,10 +83,8 @@ impl AsyncResolver {
         let lookup_result = self.resolver.txt_lookup(name).await;
         match lookup_result {
             Ok(lookup) => Ok(Some(lookup)),
-            Err(e) => match e.kind() {
-                ResolveErrorKind::NoRecordsFound { .. } => Ok(None),
-                _ => Err(Error::from_resolve_error(e)),
-            },
+            Err(e) if e.is_no_records_found() => Ok(None),
+            Err(e) => Err(Error::from_resolve_error(e)),
         }
     }
 }

src/runtime/resolver.rs

@@ -133,9 +133,8 @@ impl SrvResolver {
         let mut hosts = vec![];
         let mut min_ttl = u32::MAX;
         for record in srv_lookup.as_lookup().record_iter() {
-            let srv = match record.data() {
-                Some(RData::SRV(s)) => s,
-                _ => continue,
+            let RData::SRV(srv) = record.data() else {
+                continue;
             };
             let mut host = srv.target().to_utf8();
             // Remove the trailing '.'