feat: add windows_named_pipe() option to client builder

Author: seanmonstar

src/async_impl/client.rs

@@ -20,6 +20,8 @@ use crate::async_impl::h3_client::H3Client;
 use crate::config::{RequestConfig, RequestTimeout};
 #[cfg(unix)]
 use crate::connect::uds::UnixSocketProvider;
+#[cfg(target_os = "windows")]
+use crate::connect::windows_named_pipe::WindowsNamedPipeProvider;
 use crate::connect::{
     sealed::{Conn, Unnameable},
     BoxedConnectorLayer, BoxedConnectorService, Connector, ConnectorBuilder,
@@ -259,6 +261,8 @@ struct Config {
 
     #[cfg(unix)]
     unix_socket: Option<Arc<std::path::Path>>,
+    #[cfg(target_os = "windows")]
+    windows_named_pipe: Option<Arc<str>>,
 }
 
 impl Default for ClientBuilder {
@@ -384,6 +388,8 @@ impl ClientBuilder {
                 dns_resolver: None,
                 #[cfg(unix)]
                 unix_socket: None,
+                #[cfg(target_os = "windows")]
+                windows_named_pipe: None,
             },
         }
     }
@@ -918,6 +924,8 @@ impl ClientBuilder {
         // ways TLS can be configured...
         #[cfg(unix)]
         connector_builder.set_unix_socket(config.unix_socket);
+        #[cfg(target_os = "windows")]
+        connector_builder.set_windows_named_pipe(config.windows_named_pipe.clone());
 
         let mut builder =
             hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new());
@@ -1757,6 +1765,26 @@ impl ClientBuilder {
         self
     }
 
+    /// Set that all connections will use this Windows named pipe.
+    ///
+    /// If a request URI uses the `https` scheme, TLS will still be used over
+    /// the Windows named pipe.
+    ///
+    /// # Note
+    ///
+    /// This option is not compatible with any of the TCP or Proxy options.
+    /// Setting this will ignore all those options previously set.
+    ///
+    /// Likewise, DNS resolution will not be done on the domain name.
+    #[cfg(target_os = "windows")]
+    pub fn windows_named_pipe(mut self, pipe: impl WindowsNamedPipeProvider) -> ClientBuilder {
+        self.config.windows_named_pipe = Some(
+            pipe.reqwest_windows_named_pipe_path(crate::connect::windows_named_pipe::Internal)
+                .into(),
+        );
+        self
+    }
+
     // TLS options
 
     /// Add a custom root certificate.

src/connect.rs

@@ -82,6 +82,8 @@ pub(crate) struct ConnectorBuilder {
     resolver: Option<DynResolver>,
     #[cfg(unix)]
     unix_socket: Option<Arc<std::path::Path>>,
+    #[cfg(target_os = "windows")]
+    windows_named_pipe: Option<Arc<std::ffi::OsStr>>,
 }
 
 impl ConnectorBuilder {
@@ -103,13 +105,20 @@ where {
             resolver: self.resolver.unwrap_or_else(DynResolver::gai),
             #[cfg(unix)]
             unix_socket: self.unix_socket,
+            #[cfg(target_os = "windows")]
+            windows_named_pipe: self.windows_named_pipe,
         };
 
         #[cfg(unix)]
         if base_service.unix_socket.is_some() && !base_service.proxies.is_empty() {
             base_service.proxies = Default::default();
             log::trace!("unix_socket() set, proxies are ignored");
         }
+        #[cfg(target_os = "windows")]
+        if base_service.windows_named_pipe.is_some() && !base_service.proxies.is_empty() {
+            base_service.proxies = Default::default();
+            log::trace!("windows_named_pipe() set, proxies are ignored");
+        }
 
         if layers.is_empty() {
             // we have no user-provided layers, only use concrete types
@@ -208,6 +217,8 @@ where {
             resolver: None,
             #[cfg(unix)]
             unix_socket: None,
+            #[cfg(target_os = "windows")]
+            windows_named_pipe: None,
         }
     }
 
@@ -319,6 +330,8 @@ where {
             resolver: None,
             #[cfg(unix)]
             unix_socket: None,
+            #[cfg(target_os = "windows")]
+            windows_named_pipe: None,
         }
     }
 
@@ -392,6 +405,8 @@ where {
             resolver: None,
             #[cfg(unix)]
             unix_socket: None,
+            #[cfg(target_os = "windows")]
+            windows_named_pipe: None,
         }
     }
 
@@ -457,6 +472,11 @@ where {
     pub(crate) fn set_unix_socket(&mut self, path: Option<Arc<std::path::Path>>) {
         self.unix_socket = path;
     }
+
+    #[cfg(target_os = "windows")]
+    pub(crate) fn set_windows_named_pipe(&mut self, pipe: Option<Arc<std::ffi::OsStr>>) {
+        self.windows_named_pipe = pipe;
+    }
 }
 
 #[allow(missing_debug_implementations)]
@@ -481,6 +501,8 @@ pub(crate) struct ConnectorService {
     /// If set, this always takes priority over TCP.
     #[cfg(unix)]
     unix_socket: Option<Arc<std::path::Path>>,
+    #[cfg(target_os = "windows")]
+    windows_named_pipe: Option<Arc<std::ffi::OsStr>>,
 }
 
 #[derive(Clone)]
@@ -673,21 +695,37 @@ impl ConnectorService {
         }
     }
 
-    /// Connect over Unix Domain Socket (or Windows?).
-    #[cfg(unix)]
+    /// Connect over a local transport: Unix Domain Socket (on Unix) or Windows Named Pipe (on Windows).
+    #[cfg(any(unix, target_os = "windows"))]
     async fn connect_local_transport(self, dst: Uri) -> Result<Conn, BoxError> {
-        let path = self
-            .unix_socket
-            .as_ref()
-            .expect("connect local must have socket path")
-            .clone();
-        let svc = tower::service_fn(move |_| {
-            let fut = tokio::net::UnixStream::connect(path.clone());
-            async move {
-                let io = fut.await?;
-                Ok::<_, std::io::Error>(TokioIo::new(io))
-            }
-        });
+        #[cfg(unix)]
+        let svc = {
+            let path = self
+                .unix_socket
+                .as_ref()
+                .expect("connect local must have socket path")
+                .clone();
+            tower::service_fn(move |_| {
+                let fut = tokio::net::UnixStream::connect(path.clone());
+                async move {
+                    let io = fut.await?;
+                    Ok::<_, std::io::Error>(TokioIo::new(io))
+                }
+            })
+        };
+        #[cfg(target_os = "windows")]
+        let svc = {
+            use tokio::net::windows::named_pipe::ClientOptions;
+            let pipe = self
+                .windows_named_pipe
+                .as_ref()
+                .expect("connect local must have pipe path")
+                .clone();
+            tower::service_fn(move |_| {
+                let pipe = pipe.clone();
+                async move { ClientOptions::new().open(pipe).map(TokioIo::new) }
+            })
+        };
         let is_proxy = false;
         match self.inner {
             #[cfg(not(feature = "__tls"))]
@@ -852,6 +890,15 @@ impl ConnectorService {
 
         self.connect_with_maybe_proxy(proxy_dst, true).await
     }
+
+    #[cfg(any(unix, target_os = "windows"))]
+    fn should_use_local_transport(&self) -> bool {
+        #[cfg(unix)]
+        return self.unix_socket.is_some();
+
+        #[cfg(target_os = "windows")]
+        return self.windows_named_pipe.is_some();
+    }
 }
 
 async fn with_timeout<T, F>(f: F, timeout: Option<Duration>) -> Result<T, BoxError>
@@ -882,9 +929,9 @@ impl Service<Uri> for ConnectorService {
         log::debug!("starting new connection: {dst:?}");
         let timeout = self.simple_timeout;
 
-        // Local transports (UDS) skip proxies
-        #[cfg(unix)]
-        if self.unix_socket.is_some() {
+        // Local transports (UDS, Windows Named Pipes) skip proxies
+        #[cfg(any(unix, target_os = "windows"))]
+        if self.should_use_local_transport() {
             return Box::pin(with_timeout(
                 self.clone().connect_local_transport(dst),
                 timeout,
@@ -1249,6 +1296,39 @@ pub(crate) mod uds {
     ];
 }
 
+// Sealed trait for Windows Named Pipe support
+#[cfg(target_os = "windows")]
+pub(crate) mod windows_named_pipe {
+    use std::ffi::OsStr;
+    /// A provider for Windows Named Pipe paths.
+    ///
+    /// This trait is sealed. This allows us to expand support in the future
+    /// by controlling who can implement the trait.
+    #[cfg(target_os = "windows")]
+    pub trait WindowsNamedPipeProvider {
+        #[doc(hidden)]
+        fn reqwest_windows_named_pipe_path(&self, _: Internal) -> &OsStr;
+    }
+
+    #[allow(missing_debug_implementations)]
+    pub struct Internal;
+
+    macro_rules! as_os_str {
+        ($($t:ty,)+) => {
+            $(
+                impl WindowsNamedPipeProvider for $t {
+                    #[doc(hidden)]
+                    fn reqwest_windows_named_pipe_path(&self, _: Internal) -> &OsStr {
+                        self.as_ref()
+                    }
+                }
+            )+
+        }
+    }
+
+    as_os_str![String, &'_ str,];
+}
+
 pub(crate) type Connecting = Pin<Box<dyn Future<Output = Result<Conn, BoxError>> + Send>>;
 
 #[cfg(feature = "default-tls")]