feat: add tls_config to Config

Only supports the h1 client, but has two different options, one each for native-tls and rustls.

Author: Fishrock123

Cargo.toml

@@ -30,7 +30,7 @@ wasm_client = ["js-sys", "web-sys", "wasm-bindgen", "wasm-bindgen-futures", "fut
 hyper_client = ["hyper", "hyper-tls", "http-types/hyperium_http", "futures-util", "tokio"]
 
 native-tls = ["async-native-tls"]
-rustls = ["async-tls"]
+rustls = ["async-tls", "rustls_crate"]
 
 unstable-config = []
 
@@ -50,6 +50,7 @@ futures = { version = "0.3.8", optional = true }
 
 # h1_client_rustls
 async-tls = { version = "0.10.0", optional = true }
+rustls_crate = { version = "0.18", optional = true, package = "rustls" }
 
 # hyper_client
 hyper = { version = "0.13.6", features = ["tcp"], optional = true }

src/config.rs

@@ -1,10 +1,11 @@
 //! Configuration for `HttpClient`s.
 
+use std::fmt::Debug;
 use std::time::Duration;
 
 /// Configuration for `HttpClient`s.
 #[non_exhaustive]
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Config {
     /// HTTP/1.1 `keep-alive` (connection pooling).
     ///
@@ -18,6 +19,37 @@ pub struct Config {
     ///
     /// Default: `Some(Duration::from_secs(60))`.
     pub timeout: Option<Duration>,
+    /// TLS Configuration (Rustls)
+    #[cfg(all(feature = "h1_client", feature = "rustls"))]
+    pub tls_config: Option<std::sync::Arc<rustls_crate::ClientConfig>>,
+    /// TLS Configuration (Native TLS)
+    #[cfg(all(feature = "h1_client", feature = "native-tls", not(feature = "rustls")))]
+    pub tls_config: Option<std::sync::Arc<async_native_tls::TlsConnector>>,
+}
+
+impl Debug for Config {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut dbg_struct = f.debug_struct("Config");
+        dbg_struct
+            .field("http_keep_alive", &self.http_keep_alive)
+            .field("tcp_no_delay", &self.tcp_no_delay)
+            .field("timeout", &self.timeout);
+
+        #[cfg(all(feature = "h1_client", feature = "rustls"))]
+        {
+            if self.tls_config.is_some() {
+                dbg_struct.field("tls_config", &"Some(rustls::ClientConfig)");
+            } else {
+                dbg_struct.field("tls_config", &"None");
+            }
+        }
+        #[cfg(all(feature = "h1_client", feature = "native-tls", not(feature = "rustls")))]
+        {
+            dbg_struct.field("tls_config", &self.tls_config);
+        }
+
+        dbg_struct.finish()
+    }
 }
 
 impl Config {
@@ -27,6 +59,8 @@ impl Config {
             http_keep_alive: true,
             tcp_no_delay: false,
             timeout: Some(Duration::from_secs(60)),
+            #[cfg(all(feature = "h1_client", any(feature = "rustls", feature = "native-tls")))]
+            tls_config: None,
         }
     }
 }
@@ -55,4 +89,23 @@ impl Config {
         self.timeout = timeout;
         self
     }
+
+    /// Set TLS Configuration (Rustls)
+    #[cfg(all(feature = "h1_client", feature = "rustls"))]
+    pub fn set_tls_config(
+        mut self,
+        tls_config: Option<std::sync::Arc<rustls_crate::ClientConfig>>,
+    ) -> Self {
+        self.tls_config = tls_config;
+        self
+    }
+    /// Set TLS Configuration (Native TLS)
+    #[cfg(all(feature = "h1_client", feature = "native-tls", not(feature = "rustls")))]
+    pub fn set_tls_config(
+        mut self,
+        tls_config: Option<std::sync::Arc<async_native_tls::TlsConnector>>,
+    ) -> Self {
+        self.tls_config = tls_config;
+        self
+    }
 }

src/h1/mod.rs

@@ -81,11 +81,11 @@ impl Debug for H1Client {
                     .collect::<Vec<String>>(),
             )
             .field("https_pools", &https_pools)
-            .field("config", &self.config)
             .field(
                 "max_concurrent_connections",
                 &self.max_concurrent_connections,
             )
+            .field("config", &self.config)
             .finish()
     }
 }
@@ -175,7 +175,7 @@ impl HttpClient for H1Client {
                         let raw_stream = async_std::net::TcpStream::connect(addr).await?;
                         req.set_peer_addr(raw_stream.peer_addr().ok());
                         req.set_local_addr(raw_stream.local_addr().ok());
-                        let tls_stream = tls::add_tls(&host, raw_stream).await?;
+                        let tls_stream = tls::add_tls(&host, raw_stream, &self.config).await?;
                         let tsl_conn = client::connect(tls_stream, req);
                         return if let Some(timeout) = self.config.timeout {
                             async_std::future::timeout(timeout, tsl_conn).await?

src/h1/tcp.rs

@@ -1,4 +1,3 @@
-use std::fmt::Debug;
 use std::net::SocketAddr;
 use std::pin::Pin;
 
@@ -10,7 +9,8 @@ use futures::task::{Context, Poll};
 
 use crate::Config;
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
+#[cfg_attr(not(feature = "rustls"), derive(std::fmt::Debug))]
 pub(crate) struct TcpConnection {
     addr: SocketAddr,
     config: Config,

src/h1/tls.rs

@@ -1,4 +1,3 @@
-use std::fmt::Debug;
 use std::net::SocketAddr;
 use std::pin::Pin;
 
@@ -18,7 +17,8 @@ cfg_if::cfg_if! {
 
 use crate::{Config, Error};
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
+#[cfg_attr(not(feature = "rustls"), derive(std::fmt::Debug))]
 pub(crate) struct TlsConnection {
     host: String,
     addr: SocketAddr,
@@ -76,7 +76,7 @@ impl Manager<TlsStream<TcpStream>, Error> for TlsConnection {
         #[cfg(feature = "unstable-config")]
         raw_stream.set_nodelay(self.config.tcp_no_delay)?;
 
-        let tls_stream = add_tls(&self.host, raw_stream).await?;
+        let tls_stream = add_tls(&self.host, raw_stream, &self.config).await?;
         Ok(tls_stream)
     }
 
@@ -105,16 +105,32 @@ impl Manager<TlsStream<TcpStream>, Error> for TlsConnection {
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "rustls")] {
-        pub(crate) async fn add_tls(host: &str, stream: TcpStream) -> Result<TlsStream<TcpStream>, std::io::Error> {
+        #[allow(unused_variables)]
+        pub(crate) async fn add_tls(host: &str, stream: TcpStream, config: &Config) -> Result<TlsStream<TcpStream>, std::io::Error> {
+            #[cfg(all(feature = "h1_client", feature = "unstable-config"))]
+            let connector = if let Some(tls_config) = config.tls_config.as_ref().cloned() {
+                tls_config.into()
+            } else {
+                async_tls::TlsConnector::default()
+            };
+            #[cfg(not(feature = "unstable-config"))]
             let connector = async_tls::TlsConnector::default();
+
             connector.connect(host, stream).await
         }
     } else if #[cfg(feature = "native-tls")] {
+        #[allow(unused_variables)]
         pub(crate) async fn add_tls(
             host: &str,
             stream: TcpStream,
+            config: &Config,
         ) -> Result<TlsStream<TcpStream>, async_native_tls::Error> {
-            async_native_tls::connect(host, stream).await
+            #[cfg(feature = "unstable-config")]
+            let connector = config.tls_config.as_ref().cloned().unwrap_or_default();
+            #[cfg(not(feature = "unstable-config"))]
+            let connector = async_native_tls::TlsConnector::new();
+
+            connector.connect(host, stream).await
         }
     }
 }