wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/config.rs

@@ -73,17 +73,6 @@ where
             .or(self.as_ref())
     }
 
-    /// Stores this value into the given [`http::Extensions`], if a value of the same type is not
-    /// already present.
-    ///
-    /// This method checks whether the provided [`http::Extensions`] contains a
-    /// [`RequestConfig<T>`]. If not, it clones the current value and inserts it into the
-    /// extensions. If a value already exists, the method does nothing.
-    #[inline]
-    pub(crate) fn store<'a>(&'a self, ext: &'a mut Extensions) -> &'a mut Option<T::Value> {
-        &mut ext.get_or_insert_with(|| self.clone()).0
-    }
-
     /// Loads the internal value from the provided [`http::Extensions`], if present.
     ///
     /// This method attempts to remove a value of type [`RequestConfig<T>`] from the provided
@@ -97,6 +86,17 @@ where
         self.as_ref()
     }
 
+    /// Removes and returns the value of this type from the given [`http::Extensions`],
+    /// or returns a clone of the current value if not present.
+    ///
+    /// This method attempts to remove a [`RequestConfig<T>`] from the provided
+    /// [`http::Extensions`]. If a value is found, it is returned. If not, the current value is
+    /// cloned and returned instead.
+    #[inline]
+    pub(crate) fn take<'a>(&'a self, ext: &'a mut Extensions) -> Option<T::Value> {
+        ext.remove().unwrap_or_else(|| self.clone()).0
+    }
+
     /// Returns an immutable reference to the stored value from the given [`http::Extensions`], if
     /// present.
     ///

data/vendor/wreq/src/{client/conn → conn}/connector.rs

@@ -1,6 +1,5 @@
-#[cfg(unix)]
-use std::path::Path;
 use std::{
+    borrow::Cow,
     future::Future,
     pin::Pin,
     sync::Arc,
@@ -8,28 +7,23 @@ use std::{
     time::Duration,
 };
 
-use http::Uri;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tokio_boring2::SslStream;
+use tokio_btls::SslStream;
 use tower::{
-    Service, ServiceBuilder, ServiceExt,
+    BoxError, Service, ServiceBuilder, ServiceExt,
     timeout::TimeoutLayer,
     util::{BoxCloneSyncService, MapRequestLayer},
 };
 
 #[cfg(unix)]
-use super::uds::UnixConnector;
+use super::net::UnixConnector;
 use super::{
-    AsyncConnWithInfo, BoxedConnectorLayer, BoxedConnectorService, Connection, HttpConnector,
-    TlsInfoFactory, Unnameable,
-    conn::{Conn, TlsConn},
-    proxy,
-    verbose::Verbose,
+    AsyncConnWithInfo, BoxedConnectorLayer, BoxedConnectorService, Conn, Connection, HttpConnector,
+    TlsConn, TlsInfoFactory, Unnameable, descriptor::ConnectionDescriptor, http::HttpConnect,
+    net::TcpConnector, proxy, verbose::Verbose,
 };
 use crate::{
-    client::http::{ConnectExtra, ConnectRequest},
     dns::DynResolver,
-    error::{BoxError, ProxyConnect, TimedOut, map_timeout_to_connector_error},
+    error::{ProxyConnect, TimedOut, map_timeout_to_connector_error},
     ext::UriExt,
     proxy::{Intercepted, Matcher as ProxyMatcher, matcher::Intercept},
     tls::{
@@ -47,7 +41,7 @@ type Connecting = Pin<Box<dyn Future<Output = Result<Conn, BoxError>> + Send>>;
 struct Config {
     proxies: Arc<Vec<ProxyMatcher>>,
     verbose: Verbose,
-    tcp_nodelay: bool,
+    nodelay: bool,
     tls_info: bool,
     /// When there is a single timeout layer and no other layers,
     /// we embed it directly inside our base Service::call().
@@ -62,8 +56,7 @@ pub struct ConnectorBuilder {
     #[cfg(feature = "socks")]
     resolver: DynResolver,
     http: HttpConnector,
-    tls_options: TlsOptions,
-    tls_builder: TlsConnectorBuilder,
+    builder: TlsConnectorBuilder,
 }
 
 /// Connector service that establishes connections.
@@ -79,9 +72,9 @@ pub struct ConnectorService {
     config: Config,
     #[cfg(feature = "socks")]
     resolver: DynResolver,
-    http: HttpConnector,
     tls: TlsConnector,
-    tls_builder: Arc<TlsConnectorBuilder>,
+    http: HttpConnector,
+    builder: Arc<TlsConnectorBuilder>,
 }
 
 // ===== impl ConnectorBuilder =====
@@ -103,7 +96,7 @@ impl ConnectorBuilder {
     where
         F: FnOnce(TlsConnectorBuilder) -> TlsConnectorBuilder,
     {
-        self.tls_builder = call(self.tls_builder);
+        self.builder = call(self.builder);
         self
     }
 
@@ -131,24 +124,28 @@ impl ConnectorBuilder {
         self
     }
 
-    /// Sets the TLS options to use.
+    /// Sets the TCP_NODELAY option for connections.
     #[inline]
-    pub fn tls_options(mut self, opts: Option<TlsOptions>) -> ConnectorBuilder {
-        if let Some(opts) = opts {
-            self.tls_options = opts;
-        }
+    pub fn tcp_nodelay(mut self, enabled: bool) -> ConnectorBuilder {
+        self.config.nodelay = enabled;
         self
     }
 
     /// Build a [`Connector`] with the provided layers.
-    pub fn build(self, layers: Vec<BoxedConnectorLayer>) -> crate::Result<Connector> {
+    pub fn build(
+        self,
+        tls_options: Option<TlsOptions>,
+        layers: Vec<BoxedConnectorLayer>,
+    ) -> crate::Result<Connector> {
         let mut service = ConnectorService {
             config: self.config,
             #[cfg(feature = "socks")]
             resolver: self.resolver.clone(),
             http: self.http,
-            tls: self.tls_builder.build(&self.tls_options)?,
-            tls_builder: Arc::new(self.tls_builder),
+            tls: self
+                .builder
+                .build(tls_options.map(Cow::Owned).unwrap_or_default())?,
+            builder: Arc::new(self.builder),
         };
 
         // we have no user-provided layers, only use concrete types
@@ -161,7 +158,7 @@ impl ConnectorBuilder {
 
         // otherwise we have user provided layers
         // so we need type erasure all the way through
-        // as well as mapping the unnameable type of the layers back to ConnectRequest for the
+        // as well as mapping the unnameable type of the layers back to ConnectionDescriptor for the
         // inner service
         let service = layers.into_iter().fold(
             BoxCloneSyncService::new(
@@ -207,20 +204,19 @@ impl Connector {
             config: Config {
                 proxies: Arc::new(proxies),
                 verbose: Verbose::OFF,
-                tcp_nodelay: false,
+                nodelay: true,
                 tls_info: false,
                 timeout: None,
             },
             #[cfg(feature = "socks")]
             resolver: resolver.clone(),
-            http: HttpConnector::new_with_resolver(resolver),
-            tls_options: TlsOptions::default(),
-            tls_builder: TlsConnector::builder(),
+            http: HttpConnector::new(resolver, TcpConnector::new()),
+            builder: TlsConnector::builder(),
         }
     }
 }
 
-impl Service<ConnectRequest> for Connector {
+impl Service<ConnectionDescriptor> for Connector {
     type Response = Conn;
     type Error = BoxError;
     type Future = Connecting;
@@ -234,10 +230,10 @@ impl Service<ConnectRequest> for Connector {
     }
 
     #[inline]
-    fn call(&mut self, req: ConnectRequest) -> Self::Future {
+    fn call(&mut self, descriptor: ConnectionDescriptor) -> Self::Future {
         match self {
-            Connector::Simple(service) => service.call(req),
-            Connector::WithLayers(service) => service.call(Unnameable(req)),
+            Connector::Simple(service) => service.call(descriptor),
+            Connector::WithLayers(service) => service.call(Unnameable(descriptor)),
         }
     }
 }
@@ -245,6 +241,50 @@ impl Service<ConnectRequest> for Connector {
 // ===== impl ConnectorService =====
 
 impl ConnectorService {
+    fn build_https_connector(
+        &self,
+        https: bool,
+        descriptor: &ConnectionDescriptor,
+    ) -> Result<HttpsConnector<HttpConnector>, BoxError> {
+        let mut http = self.http.clone();
+
+        // Disable Nagle's algorithm for TLS handshake
+        //
+        // https://www.openssl.org/docs/man1.1.1/man3/SSL_connect.html#NOTES
+        if https && !self.config.nodelay {
+            http.set_nodelay(true);
+        }
+
+        // Apply TCP options if provided in metadata
+        if let Some(socket_opts) = descriptor.socket_bind_options() {
+            http.set_local_addresses(socket_opts.ipv4_address, socket_opts.ipv6_address);
+            #[cfg(any(
+                target_os = "android",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "ios",
+                target_os = "linux",
+                target_os = "macos",
+                target_os = "solaris",
+                target_os = "tvos",
+                target_os = "visionos",
+                target_os = "watchos",
+            ))]
+            if let Some(interface) = &socket_opts.interface {
+                http.set_interface(interface.clone());
+            }
+        }
+
+        // Prefer TLS options from metadata, fallback to default
+        let tls = descriptor
+            .tls_options()
+            .map(|opts| self.builder.build(Cow::Borrowed(opts)))
+            .transpose()?
+            .unwrap_or_else(|| self.tls.clone());
+
+        Ok(HttpsConnector::new(http, tls))
+    }
+
     fn tunnel_conn_from_stream<IO>(&self, io: MaybeHttpsStream<IO>) -> Result<Conn, BoxError>
     where
         IO: AsyncConnWithInfo,
@@ -252,13 +292,13 @@ impl ConnectorService {
         SslStream<IO>: TlsInfoFactory,
     {
         let conn = match io {
-            MaybeHttpsStream::Http(inner) => Conn {
-                inner: self.config.verbose.wrap(inner),
+            MaybeHttpsStream::Http(stream) => Conn {
+                stream: self.config.verbose.wrap(stream),
                 tls_info: false,
                 proxy: None,
             },
-            MaybeHttpsStream::Https(inner) => Conn {
-                inner: self.config.verbose.wrap(TlsConn::new(inner)),
+            MaybeHttpsStream::Https(stream) => Conn {
+                stream: self.config.verbose.wrap(TlsConn { stream }),
                 tls_info: self.config.tls_info,
                 proxy: None,
             },
@@ -275,111 +315,63 @@ impl ConnectorService {
         P: Into<Option<Intercept>>,
     {
         let conn = match io {
-            MaybeHttpsStream::Http(inner) => self.config.verbose.wrap(inner),
-            MaybeHttpsStream::Https(inner) => self.config.verbose.wrap(TlsConn::new(inner)),
+            MaybeHttpsStream::Http(stream) => self.config.verbose.wrap(stream),
+            MaybeHttpsStream::Https(stream) => self.config.verbose.wrap(TlsConn { stream }),
         };
 
         Ok(Conn {
-            inner: conn,
+            stream: conn,
             tls_info: self.config.tls_info,
             proxy: proxy.into(),
         })
     }
 
-    fn build_https_connector(
-        &self,
-        extra: &ConnectExtra,
-    ) -> Result<HttpsConnector<HttpConnector>, BoxError> {
-        let mut http = self.http.clone();
-
-        // Disable Nagle's algorithm for TLS handshake
-        //
-        // https://www.openssl.org/docs/man1.1.1/man3/SSL_connect.html#NOTES
-        if !self.config.tcp_nodelay {
-            http.set_nodelay(true);
-        }
-
-        // Apply TCP options if provided in metadata
-        if let Some(opts) = extra.tcp_options() {
-            http.set_connect_options(opts.clone());
-        }
-
-        self.build_tls_connector_generic(http, extra)
-    }
-
-    #[cfg(unix)]
-    fn build_unix_connector(
-        &self,
-        unix_socket: Arc<Path>,
-        extra: &ConnectExtra,
-    ) -> Result<HttpsConnector<UnixConnector>, BoxError> {
-        // Create a Unix connector with the specified socket path
-        self.build_tls_connector_generic(UnixConnector(unix_socket), extra)
-    }
-
-    fn build_tls_connector_generic<S, T>(
-        &self,
-        connector: S,
-        extra: &ConnectExtra,
-    ) -> Result<HttpsConnector<S>, BoxError>
-    where
-        S: Service<Uri, Response = T> + Send,
-        S::Error: Into<BoxError>,
-        S::Future: Unpin + Send + 'static,
-        T: AsyncRead + AsyncWrite + Connection + Unpin + std::fmt::Debug + Sync + Send + 'static,
-    {
-        // Prefer TLS options from metadata, fallback to default
-        let tls = extra
-            .tls_options()
-            .map(|opts| self.tls_builder.build(opts))
-            .transpose()?
-            .unwrap_or_else(|| self.tls.clone());
-
-        Ok(HttpsConnector::with_connector(connector, tls))
-    }
-}
-
-impl ConnectorService {
-    async fn connect_auto_proxy<P>(self, req: ConnectRequest, proxy: P) -> Result<Conn, BoxError>
-    where
-        P: Into<Option<Intercept>>,
-    {
+    async fn connect_auto_proxy<P: Into<Option<Intercept>>>(
+        self,
+        descriptor: ConnectionDescriptor,
+        proxy: P,
+    ) -> Result<Conn, BoxError> {
+        let is_https = descriptor.uri().is_https();
         let proxy = proxy.into();
+
         trace!("connect with maybe proxy: {:?}", proxy);
 
-        let mut connector = self.build_https_connector(req.extra())?;
+        let mut connector = self.build_https_connector(is_https, &descriptor)?;
 
         // When using a proxy for HTTPS targets, disable ALPN to avoid protocol negotiation issues
-        if proxy.is_some() && req.uri().is_https() {
+        if proxy.is_some() && is_https {
             connector.no_alpn();
         }
 
-        let io = connector.call(req).await?;
+        let io = connector.call(descriptor).await?;
 
         // Re-enable Nagle's algorithm if it was disabled earlier
-        if !self.config.tcp_nodelay {
-            io.get_ref().set_nodelay(false)?;
-        }
+        if_tokio_rt!(block:{
+            if is_https && !self.config.nodelay {
+                io.as_ref().set_nodelay(false)?;
+            }
+        });
 
         self.conn_from_stream(io, proxy)
     }
 
     async fn connect_via_proxy(
         self,
-        mut req: ConnectRequest,
+        mut descriptor: ConnectionDescriptor,
         proxy: Intercepted,
     ) -> Result<Conn, BoxError> {
-        let uri = req.uri().clone();
+        let uri = descriptor.uri().clone();
 
         match proxy {
             Intercepted::Proxy(proxy) => {
+                let is_https = uri.is_https();
                 let proxy_uri = proxy.uri().clone();
 
                 #[cfg(feature = "socks")]
                 {
                     use proxy::socks::{DnsResolve, SocksConnector, Version};
 
-                    if let Some((version, dns_resolve)) = match proxy.uri().scheme_str() {
+                    if let Some((version, dns_resolve)) = match proxy_uri.scheme_str() {
                         Some("socks4") => Some((Version::V4, DnsResolve::Local)),
                         Some("socks4a") => Some((Version::V4, DnsResolve::Remote)),
                         Some("socks5") => Some((Version::V5, DnsResolve::Local)),
@@ -391,7 +383,7 @@ impl ConnectorService {
                         // Connect to the proxy and establish the SOCKS connection.
                         let conn = {
                             // Build a SOCKS connector.
-                            let mut socks = SocksConnector::new_with_resolver(
+                            let mut socks = SocksConnector::new(
                                 proxy_uri,
                                 self.http.clone(),
                                 self.resolver.clone(),
@@ -403,26 +395,29 @@ impl ConnectorService {
                         };
 
                         // Build an HTTPS connector.
-                        let mut connector = self.build_https_connector(req.extra())?;
+                        let mut connector = self.build_https_connector(is_https, &descriptor)?;
 
                         // Wrap the established SOCKS connection with TLS if needed.
-                        let io = connector.call(EstablishedConn::new(conn, req)).await?;
+                        let io = connector
+                            .call(EstablishedConn::new(conn, descriptor))
+                            .await?;
 
                         // Re-enable Nagle's algorithm if it was disabled earlier
-                        if !self.config.tcp_nodelay {
-                            io.get_ref().set_nodelay(false)?;
-                        }
+                        if_tokio_rt!(block:{
+                            if is_https && !self.config.nodelay {
+                                io.as_ref().set_nodelay(false)?;
+                            }
+                        });
 
                         return self.tunnel_conn_from_stream(io);
                     }
                 }
 
-                // Handle HTTPS proxy tunneling connection
-                if uri.is_https() {
+                if is_https {
                     trace!("tunneling over HTTP(s) proxy: {:?}", proxy_uri);
 
                     // Build an HTTPS connector.
-                    let mut connector = self.build_https_connector(req.extra())?;
+                    let mut connector = self.build_https_connector(is_https, &descriptor)?;
 
                     // Build a tunnel connector to establish the CONNECT tunnel.
                     let tunneled = {
@@ -444,18 +439,22 @@ impl ConnectorService {
                     };
 
                     // Wrap the established tunneled stream with TLS.
-                    let io = connector.call(EstablishedConn::new(tunneled, req)).await?;
+                    let io = connector
+                        .call(EstablishedConn::new(tunneled, descriptor))
+                        .await?;
 
                     // Re-enable Nagle's algorithm if it was disabled earlier
-                    if !self.config.tcp_nodelay {
-                        io.get_ref().get_ref().set_nodelay(false)?;
-                    }
+                    if_tokio_rt!(block:{
+                        if !self.config.nodelay {
+                            io.as_ref().as_ref().set_nodelay(false)?;
+                        }
+                    });
 
                     return self.tunnel_conn_from_stream(io);
                 }
 
-                *req.uri_mut() = proxy_uri;
-                self.connect_auto_proxy(req, proxy)
+                *descriptor.uri_mut() = proxy_uri;
+                self.connect_auto_proxy(descriptor, proxy)
                     .await
                     .map_err(ProxyConnect)
                     .map_err(Into::into)
@@ -465,18 +464,20 @@ impl ConnectorService {
                 trace!("connecting via Unix socket: {:?}", unix_socket);
 
                 // Create a Unix connector with the specified socket path.
-                let mut connector = self.build_unix_connector(unix_socket, req.extra())?;
+                let mut connector =
+                    HttpsConnector::new(UnixConnector::new(unix_socket), self.tls.clone());
 
                 // If the target URI is HTTPS, establish a CONNECT tunnel over the Unix socket,
                 // then upgrade the tunneled stream to TLS.
                 if uri.is_https() {
                     // Use a dummy HTTP URI so the HTTPS connector works over the Unix socket.
-                    let proxy_uri = Uri::from_static("http://localhost");
+                    let proxy_uri = http::Uri::from_static("http://localhost");
 
                     // The tunnel connector will first establish a CONNECT tunnel,
                     // then perform the TLS handshake over the tunneled stream.
                     let tunneled = {
-                        // Create a tunnel connector using the Unix socket and the HTTPS connector.
+                        // Create a tunnel connector using the Unix socket and the HTTPS
+                        // connector.
                         let mut tunnel =
                             proxy::tunnel::TunnelConnector::new(proxy_uri, connector.clone());
 
@@ -484,20 +485,22 @@ impl ConnectorService {
                     };
 
                     // Wrap the established tunneled stream with TLS.
-                    let io = connector.call(EstablishedConn::new(tunneled, req)).await?;
+                    let io = connector
+                        .call(EstablishedConn::new(tunneled, descriptor))
+                        .await?;
 
                     return self.tunnel_conn_from_stream(io);
                 }
 
                 // For plain HTTP, use the Unix connector directly.
-                let io = connector.call(req).await?;
+                let io = connector.call(descriptor).await?;
 
                 self.conn_from_stream(io, None)
             }
         }
     }
 
-    async fn connect_auto(self, req: ConnectRequest) -> Result<Conn, BoxError> {
+    async fn connect_auto(self, req: ConnectionDescriptor) -> Result<Conn, BoxError> {
         debug!("starting new connection: {:?}", req.uri());
 
         let timeout = self.config.timeout;
@@ -505,8 +508,7 @@ impl ConnectorService {
         // Determine if a proxy should be used for this request.
         let fut = async {
             let intercepted = req
-                .extra()
-                .proxy_matcher()
+                .proxy()
                 .and_then(|prox| prox.intercept(req.uri()))
                 .or_else(|| {
                     self.config
@@ -532,7 +534,7 @@ impl ConnectorService {
     }
 }
 
-impl Service<ConnectRequest> for ConnectorService {
+impl Service<ConnectionDescriptor> for ConnectorService {
     type Response = Conn;
     type Error = BoxError;
     type Future = Connecting;
@@ -543,7 +545,7 @@ impl Service<ConnectRequest> for ConnectorService {
     }
 
     #[inline]
-    fn call(&mut self, req: ConnectRequest) -> Self::Future {
-        Box::pin(self.clone().connect_auto(req))
+    fn call(&mut self, descriptor: ConnectionDescriptor) -> Self::Future {
+        Box::pin(self.clone().connect_auto(descriptor))
     }
 }