transport: Allow changing DNS resolver config

src/config.rs

@@ -124,6 +124,9 @@ pub struct ConfigBuilder {
 
     /// Close the connection if no substreams are open within this time frame.
     keep_alive_timeout: Duration,
+
+    /// Use system's DNS config.
+    use_system_dns_config: bool,
 }
 
 impl Default for ConfigBuilder {
@@ -157,6 +160,7 @@ impl ConfigBuilder {
             known_addresses: Vec::new(),
             connection_limits: ConnectionLimitsConfig::default(),
             keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
+            use_system_dns_config: false,
         }
     }
 
@@ -278,6 +282,12 @@ impl ConfigBuilder {
         self
     }
 
+    /// Set DNS resolver according to system configuration instead of default (Google).
+    pub fn with_system_resolver(mut self) -> Self {
+        self.use_system_dns_config = true;
+        self
+    }
+
     /// Build [`Litep2pConfig`].
     pub fn build(mut self) -> Litep2pConfig {
         let keypair = match self.keypair {
@@ -307,6 +317,7 @@ impl ConfigBuilder {
             known_addresses: self.known_addresses,
             connection_limits: self.connection_limits,
             keep_alive_timeout: self.keep_alive_timeout,
+            use_system_dns_config: self.use_system_dns_config,
         }
     }
 }
@@ -369,4 +380,7 @@ pub struct Litep2pConfig {
 
     /// Close the connection if no substreams are open within this time frame.
     pub(crate) keep_alive_timeout: Duration,
+
+    /// Use system's DNS config.
+    pub(crate) use_system_dns_config: bool,
 }

src/error.rs

@@ -126,6 +126,8 @@ pub enum Error {
     ConnectionLimit(ConnectionLimitsError),
     #[error("Failed to dial peer immediately")]
     ImmediateDialError(#[from] ImmediateDialError),
+    #[error("Cannot read system DNS config: `{0}`")]
+    CannotReadSystemDnsConfig(hickory_resolver::ResolveError),
 }
 
 /// Error type for address parsing.

src/lib.rs

@@ -53,6 +53,7 @@ use crate::transport::webrtc::WebRtcTransport;
 #[cfg(feature = "websocket")]
 use crate::transport::websocket::WebSocketTransport;
 
+use hickory_resolver::{name_server::TokioConnectionProvider, TokioResolver};
 use multiaddr::{Multiaddr, Protocol};
 use multihash::Multihash;
 use transport::Endpoint;
@@ -158,6 +159,18 @@ impl Litep2p {
         let bandwidth_sink = BandwidthSink::new();
         let mut listen_addresses = vec![];
 
+        let (resolver_config, resolver_opts) = if litep2p_config.use_system_dns_config {
+            hickory_resolver::system_conf::read_system_conf()
+                .map_err(Error::CannotReadSystemDnsConfig)?
+        } else {
+            (Default::default(), Default::default())
+        };
+        let resolver = Arc::new(
+            TokioResolver::builder_with_config(resolver_config, TokioConnectionProvider::default())
+                .with_options(resolver_opts)
+                .build(),
+        );
+
         let supported_transports = Self::supported_transports(&litep2p_config);
         let (mut transport_manager, transport_handle) = TransportManager::new(
             litep2p_config.keypair.clone(),
@@ -315,7 +328,7 @@ impl Litep2p {
         if let Some(config) = litep2p_config.tcp.take() {
             let handle = transport_manager.transport_handle(Arc::clone(&litep2p_config.executor));
             let (transport, transport_listen_addresses) =
-                <TcpTransport as TransportBuilder>::new(handle, config)?;
+                <TcpTransport as TransportBuilder>::new(handle, config, resolver.clone())?;
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
@@ -332,7 +345,7 @@ impl Litep2p {
         if let Some(config) = litep2p_config.quic.take() {
             let handle = transport_manager.transport_handle(Arc::clone(&litep2p_config.executor));
             let (transport, transport_listen_addresses) =
-                <QuicTransport as TransportBuilder>::new(handle, config)?;
+                <QuicTransport as TransportBuilder>::new(handle, config, resolver.clone())?;
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
@@ -349,7 +362,7 @@ impl Litep2p {
         if let Some(config) = litep2p_config.webrtc.take() {
             let handle = transport_manager.transport_handle(Arc::clone(&litep2p_config.executor));
             let (transport, transport_listen_addresses) =
-                <WebRtcTransport as TransportBuilder>::new(handle, config)?;
+                <WebRtcTransport as TransportBuilder>::new(handle, config, resolver.clone())?;
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());
@@ -366,7 +379,7 @@ impl Litep2p {
         if let Some(config) = litep2p_config.websocket.take() {
             let handle = transport_manager.transport_handle(Arc::clone(&litep2p_config.executor));
             let (transport, transport_listen_addresses) =
-                <WebSocketTransport as TransportBuilder>::new(handle, config)?;
+                <WebSocketTransport as TransportBuilder>::new(handle, config, resolver)?;
 
             for address in transport_listen_addresses {
                 transport_manager.register_listen_address(address.clone());

src/transport/common/listener.rs

@@ -26,9 +26,7 @@ use crate::{
 };
 
 use futures::Stream;
-use hickory_resolver::{
-    config::ResolverConfig, name_server::TokioConnectionProvider, TokioResolver,
-};
+use hickory_resolver::TokioResolver;
 use multiaddr::{Multiaddr, Protocol};
 use network_interface::{Addr, NetworkInterface, NetworkInterfaceConfig};
 use socket2::{Domain, Socket, Type};
@@ -72,7 +70,7 @@ pub enum DnsType {
 
 impl AddressType {
     /// Resolve the address to a concrete IP.
-    pub async fn lookup_ip(self) -> Result<SocketAddr, DnsError> {
+    pub async fn lookup_ip(self, resolver: Arc<TokioResolver>) -> Result<SocketAddr, DnsError> {
         let (url, port, dns_type) = match self {
             // We already have the IP address.
             AddressType::Socket(address) => return Ok(address),
@@ -83,12 +81,6 @@ impl AddressType {
             } => (address, port, dns_type),
         };
 
-        let resolver = TokioResolver::builder_with_config(
-            ResolverConfig::default(),
-            TokioConnectionProvider::default(),
-        )
-        .build();
-
         let lookup = match resolver.lookup_ip(url.clone()).await {
             Ok(lookup) => lookup,
             Err(error) => {

src/transport/mod.rs

@@ -23,9 +23,10 @@
 use crate::{error::DialError, transport::manager::TransportHandle, types::ConnectionId, PeerId};
 
 use futures::Stream;
+use hickory_resolver::TokioResolver;
 use multiaddr::Multiaddr;
 
-use std::{fmt::Debug, time::Duration};
+use std::{fmt::Debug, sync::Arc, time::Duration};
 
 pub(crate) mod common;
 #[cfg(feature = "quic")]
@@ -177,7 +178,11 @@ pub(crate) trait TransportBuilder {
     type Transport: Transport;
 
     /// Create new [`Transport`] object.
-    fn new(context: TransportHandle, config: Self::Config) -> crate::Result<(Self, Vec<Multiaddr>)>
+    fn new(
+        context: TransportHandle,
+        config: Self::Config,
+        resolver: Arc<TokioResolver>,
+    ) -> crate::Result<(Self, Vec<Multiaddr>)>
     where
         Self: Sized;
 }

src/transport/quic/mod.rs

@@ -39,6 +39,7 @@ use futures::{
     stream::{AbortHandle, FuturesUnordered},
     Stream, StreamExt, TryFutureExt,
 };
+use hickory_resolver::TokioResolver;
 use multiaddr::{Multiaddr, Protocol};
 use quinn::{ClientConfig, Connecting, Connection, Endpoint, IdleTimeout};
 
@@ -215,6 +216,7 @@ impl TransportBuilder for QuicTransport {
     fn new(
         context: TransportHandle,
         mut config: Self::Config,
+        _resolver: Arc<TokioResolver>,
     ) -> crate::Result<(Self, Vec<Multiaddr>)>
     where
         Self: Sized,
@@ -621,9 +623,10 @@ mod tests {
                 },
             )]),
         };
+        let resolver = Arc::new(TokioResolver::builder_tokio().unwrap().build());
 
         let (mut transport1, listen_addresses) =
-            QuicTransport::new(handle1, Default::default()).unwrap();
+            QuicTransport::new(handle1, Default::default(), resolver.clone()).unwrap();
         let listen_address = listen_addresses[0].clone();
 
         let keypair2 = Keypair::generate();
@@ -648,7 +651,8 @@ mod tests {
             )]),
         };
 
-        let (mut transport2, _) = QuicTransport::new(handle2, Default::default()).unwrap();
+        let (mut transport2, _) =
+            QuicTransport::new(handle2, Default::default(), resolver).unwrap();
         let peer1: PeerId = PeerId::from_public_key(&keypair1.public().into());
         let _peer2: PeerId = PeerId::from_public_key(&keypair2.public().into());
         let listen_address = listen_address.with(Protocol::P2p(

src/transport/tcp/connection.rs

@@ -752,6 +752,7 @@ mod tests {
     use crate::transport::tcp::TcpTransport;
 
     use super::*;
+    use hickory_resolver::{name_server::TokioConnectionProvider, TokioResolver};
     use tokio::{io::AsyncWriteExt, net::TcpListener};
 
     #[tokio::test]
@@ -775,6 +776,13 @@ mod tests {
             Default::default(),
             Duration::from_secs(10),
             false,
+            Arc::new(
+                TokioResolver::builder_with_config(
+                    Default::default(),
+                    TokioConnectionProvider::default(),
+                )
+                .build(),
+            ),
         )
         .await
         .unwrap();
@@ -870,6 +878,13 @@ mod tests {
             Default::default(),
             Duration::from_secs(10),
             false,
+            Arc::new(
+                TokioResolver::builder_with_config(
+                    Default::default(),
+                    TokioConnectionProvider::default(),
+                )
+                .build(),
+            ),
         )
         .await
         .unwrap();
@@ -1012,6 +1027,13 @@ mod tests {
             Default::default(),
             Duration::from_secs(10),
             false,
+            Arc::new(
+                TokioResolver::builder_with_config(
+                    Default::default(),
+                    TokioConnectionProvider::default(),
+                )
+                .build(),
+            ),
         )
         .await
         .unwrap();
@@ -1058,6 +1080,13 @@ mod tests {
             Default::default(),
             Duration::from_secs(10),
             false,
+            Arc::new(
+                TokioResolver::builder_with_config(
+                    Default::default(),
+                    TokioConnectionProvider::default(),
+                )
+                .build(),
+            ),
         )
         .await
         .unwrap();
@@ -1231,6 +1260,13 @@ mod tests {
             Default::default(),
             Duration::from_secs(10),
             false,
+            Arc::new(
+                TokioResolver::builder_with_config(
+                    Default::default(),
+                    TokioConnectionProvider::default(),
+                )
+                .build(),
+            ),
         )
         .await
         .unwrap();
@@ -1359,6 +1395,13 @@ mod tests {
             Default::default(),
             Duration::from_secs(10),
             false,
+            Arc::new(
+                TokioResolver::builder_with_config(
+                    Default::default(),
+                    TokioConnectionProvider::default(),
+                )
+                .build(),
+            ),
         )
         .await
         .unwrap();