fix: use custom DNS resolver (#1364)

* add DefaultResolver

* style: fmt

* chore: remove unused feature

Co-authored-by: Jiahao XU <Jiahao_XU@outlook.com>

* chore: remove unused `ipconfig/computer` feature

Co-authored-by: Jiahao XU <Jiahao_XU@outlook.com>

* chore: update `trust-dns-resolver`

* refactor: apply requested changes

* chore: revert `trust-dns-resolver` upgrade

I mistakenly thought `reqwest` already updated to the newest version, but it hasn't! (no release was made yet)

* refactor: cleanup

---------

Co-authored-by: GNQG <my.t.gnq+dev@gmail.com>
Co-authored-by: Jiahao XU <Jiahao_XU@outlook.com>

crates/binstalk-downloader/src/lib.rs

@@ -12,4 +12,7 @@ pub mod gh_api_client;
 
 pub mod remote;
 
+#[cfg(feature = "trust-dns")]
+mod resolver;
+
 mod utils;

crates/binstalk-downloader/src/remote.rs

@@ -18,6 +18,9 @@ use tracing::{debug, info, instrument};
 pub use reqwest::{header, Error as ReqwestError, Method, StatusCode};
 pub use url::Url;
 
+#[cfg(feature = "trust-dns")]
+use crate::resolver::TrustDnsResolver;
+
 mod delay_request;
 use delay_request::DelayRequest;
 
@@ -107,6 +110,11 @@ impl Client {
                 .https_only(true)
                 .tcp_nodelay(false);
 
+            #[cfg(feature = "trust-dns")]
+            {
+                builder = builder.dns_resolver(Arc::new(TrustDnsResolver::default()));
+            }
+
             #[cfg(feature = "__tls")]
             {
                 let tls_ver = min_tls

crates/binstalk-downloader/src/resolver.rs

@@ -0,0 +1,64 @@
+use std::{net::SocketAddr, sync::Arc};
+
+use hyper::client::connect::dns::Name;
+use once_cell::sync::OnceCell;
+use reqwest::dns::{Addrs, Resolve};
+use trust_dns_resolver::config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts};
+use trust_dns_resolver::TokioAsyncResolver;
+
+#[derive(Debug, Default, Clone)]
+pub struct TrustDnsResolver(Arc<OnceCell<TokioAsyncResolver>>);
+
+impl Resolve for TrustDnsResolver {
+    fn resolve(&self, name: Name) -> reqwest::dns::Resolving {
+        let resolver = self.clone();
+        Box::pin(async move {
+            let resolver = resolver.0.get_or_try_init(new_resolver)?;
+
+            let lookup = resolver.lookup_ip(name.as_str()).await?;
+            let addrs: Addrs = Box::new(lookup.into_iter().map(|ip| SocketAddr::new(ip, 0)));
+            Ok(addrs)
+        })
+    }
+}
+
+fn new_resolver() -> Result<TokioAsyncResolver, Box<dyn std::error::Error + Send + Sync>> {
+    #[cfg(unix)]
+    {
+        let (config, opts) = trust_dns_resolver::system_conf::read_system_conf()?;
+        Ok(TokioAsyncResolver::tokio(config, opts)?)
+    }
+    #[cfg(windows)]
+    {
+        let mut config = ResolverConfig::new();
+        let opts = ResolverOpts::default();
+
+        let current_interface = default_net::get_default_interface()?;
+        ipconfig::get_adapters()?
+            .iter()
+            .filter_map(|adapter| {
+                if adapter.adapter_name() == current_interface.name {
+                    Some(adapter.dns_servers())
+                } else {
+                    None
+                }
+            })
+            .flatten()
+            .for_each(|addr| {
+                let socket_addr = SocketAddr::new(*addr, 53);
+                for protocol in [Protocol::Udp, Protocol::Tcp] {
+                    config.add_name_server(NameServerConfig {
+                        socket_addr,
+                        protocol,
+                        tls_dns_name: None,
+                        trust_nx_responses: false,
+                        #[cfg(feature = "rustls")]
+                        tls_config: None,
+                        bind_addr: None,
+                    })
+                }
+            });
+
+        Ok(TokioAsyncResolver::tokio(config, opts)?)
+    }
+}