wreq-rb 0.5.0 → 0.5.1

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

@@ -1,41 +1,44 @@
-#[allow(clippy::module_inception)]
-mod conn;
-mod connector;
-mod http;
-mod proxy;
 mod tls_info;
-#[cfg(unix)]
-mod uds;
 mod verbose;
 
+pub(super) mod connector;
+pub(super) mod descriptor;
+pub(super) mod http;
+pub(super) mod net;
+pub(super) mod proxy;
+
 use std::{
     fmt::{self, Debug, Formatter},
+    io,
+    io::IoSlice,
+    pin::Pin,
     sync::{
         Arc,
         atomic::{AtomicBool, Ordering},
     },
+    task::{Context, Poll},
 };
 
 use ::http::{Extensions, HeaderMap, HeaderValue};
-use tokio::io::{AsyncRead, AsyncWrite};
+#[cfg(any(feature = "tokio-rt", feature = "compio-rt"))]
+use net::TcpConnector;
+use pin_project_lite::pin_project;
+use tls_info::TlsInfoFactory;
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio_btls::SslStream;
 use tower::{
     BoxError,
     util::{BoxCloneSyncService, BoxCloneSyncServiceLayer},
 };
 
-#[cfg(feature = "socks")]
-pub(super) use self::proxy::socks;
-pub(super) use self::{
-    conn::Conn,
-    connector::Connector,
-    http::{HttpInfo, TcpConnectOptions},
-    proxy::tunnel,
-    tls_info::TlsInfoFactory,
+use crate::{
+    dns::DynResolver,
+    proxy::matcher::Intercept,
+    tls::{AlpnProtocol, TlsInfo},
 };
-use crate::{client::ConnectRequest, dns::DynResolver, proxy::matcher::Intercept};
 
 /// HTTP connector with dynamic DNS resolver.
-pub type HttpConnector = self::http::HttpConnector<DynResolver>;
+pub type HttpConnector = http::HttpConnector<DynResolver, TcpConnector>;
 
 /// Boxed connector service for establishing connections.
 pub type BoxedConnectorService = BoxCloneSyncService<Unnameable, Conn, BoxError>;
@@ -44,12 +47,12 @@ pub type BoxedConnectorService = BoxCloneSyncService<Unnameable, Conn, BoxError>
 pub type BoxedConnectorLayer =
     BoxCloneSyncServiceLayer<BoxedConnectorService, Unnameable, Conn, BoxError>;
 
-/// A wrapper type for [`ConnectRequest`] used to erase its concrete type.
+/// A wrapper type for [`descriptor::ConnectionDescriptor`] used to erase its concrete type.
 ///
 /// [`Unnameable`] allows passing connection requests through trait objects or
 /// type-erased interfaces where the concrete type of the request is not important.
 /// This is mainly used internally to simplify service composition and dynamic dispatch.
-pub struct Unnameable(pub(super) ConnectRequest);
+pub struct Unnameable(pub(super) descriptor::ConnectionDescriptor);
 
 /// A trait alias for types that can be used as async connections.
 ///
@@ -69,6 +72,31 @@ impl<T> AsyncConn for T where T: AsyncRead + AsyncWrite + Connection + Send + Sy
 
 impl<T> AsyncConnWithInfo for T where T: AsyncConn + TlsInfoFactory {}
 
+pin_project! {
+    /// Note: the `is_proxy` member means *is plain text HTTP proxy*.
+    /// This tells core whether the URI should be written in
+    /// * origin-form (`GET /just/a/path HTTP/1.1`), when `proxy == None`, or
+    /// * absolute-form (`GET http://foo.bar/and/a/path HTTP/1.1`), otherwise.
+    pub struct Conn {
+        tls_info: bool,
+        proxy: Option<Intercept>,
+        #[pin]
+        stream: Box<dyn AsyncConnWithInfo>,
+    }
+}
+
+pin_project! {
+    /// A wrapper around `SslStream` that adapts it for use as a generic async connection.
+    ///
+    /// This type enables unified handling of plain TCP and TLS-encrypted streams by providing
+    /// implementations of `Connection`, `Read`, `Write`, and `TlsInfoFactory`.
+    /// It is mainly used internally to abstract over different connection types.
+    pub struct TlsConn<T> {
+        #[pin]
+        stream: SslStream<T>,
+    }
+}
+
 /// Describes a type returned by a connector.
 pub trait Connection {
     /// Return metadata describing the connection.
@@ -84,9 +112,7 @@ enum Alpn {
 
 /// A pill that can be poisoned to indicate that a connection should not be reused.
 #[derive(Clone)]
-struct PoisonPill {
-    poisoned: Arc<AtomicBool>,
-}
+struct PoisonPill(Arc<AtomicBool>);
 
 /// A boxed asynchronous connection with associated information.
 #[derive(Debug)]
@@ -121,7 +147,7 @@ struct ProxyIdentity {
 ///
 /// This can be used to inform recipients about things like if ALPN
 /// was used, or if connected to an HTTP proxy.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Connected {
     alpn: Alpn,
     proxy: Box<ProxyIdentity>,
@@ -129,6 +155,151 @@ pub struct Connected {
     poisoned: PoisonPill,
 }
 
+// ==== impl Conn ====
+
+impl Connection for Conn {
+    fn connected(&self) -> Connected {
+        let mut connected = self.stream.connected();
+
+        if let Some(proxy) = &self.proxy {
+            connected = connected.proxy(proxy.clone());
+        }
+
+        if self.tls_info {
+            if let Some(tls_info) = self.stream.tls_info() {
+                connected.extra(tls_info)
+            } else {
+                connected
+            }
+        } else {
+            connected
+        }
+    }
+}
+
+impl AsyncRead for Conn {
+    #[inline]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        AsyncRead::poll_read(self.project().stream, cx, buf)
+    }
+}
+
+impl AsyncWrite for Conn {
+    #[inline]
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        AsyncWrite::poll_write(self.project().stream, cx, buf)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        AsyncWrite::poll_write_vectored(self.project().stream, cx, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        self.stream.is_write_vectored()
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+        AsyncWrite::poll_flush(self.project().stream, cx)
+    }
+
+    #[inline]
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+        AsyncWrite::poll_shutdown(self.project().stream, cx)
+    }
+}
+
+// ===== impl TlsConn =====
+
+impl<T> Connection for TlsConn<T>
+where
+    T: Connection,
+{
+    fn connected(&self) -> Connected {
+        let connected = self.stream.get_ref().connected();
+        if self
+            .stream
+            .ssl()
+            .selected_alpn_protocol()
+            .is_some_and(|alpn| AlpnProtocol::HTTP2.eq(alpn))
+        {
+            connected.negotiated_h2()
+        } else {
+            connected
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin> AsyncRead for TlsConn<T> {
+    #[inline]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<tokio::io::Result<()>> {
+        AsyncRead::poll_read(self.project().stream, cx, buf)
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin> AsyncWrite for TlsConn<T> {
+    #[inline]
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &[u8],
+    ) -> Poll<Result<usize, tokio::io::Error>> {
+        AsyncWrite::poll_write(self.project().stream, cx, buf)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        AsyncWrite::poll_write_vectored(self.project().stream, cx, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        self.stream.is_write_vectored()
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), tokio::io::Error>> {
+        AsyncWrite::poll_flush(self.project().stream, cx)
+    }
+
+    #[inline]
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), tokio::io::Error>> {
+        AsyncWrite::poll_shutdown(self.project().stream, cx)
+    }
+}
+
+impl<T> TlsInfoFactory for TlsConn<T>
+where
+    SslStream<T>: TlsInfoFactory,
+{
+    #[inline]
+    fn tls_info(&self) -> Option<TlsInfo> {
+        self.stream.tls_info()
+    }
+}
+
 // ===== impl PoisonPill =====
 
 impl fmt::Debug for PoisonPill {
@@ -137,8 +308,8 @@ impl fmt::Debug for PoisonPill {
         write!(
             f,
             "PoisonPill@{:p} {{ poisoned: {} }}",
-            self.poisoned,
-            self.poisoned.load(Ordering::Relaxed)
+            self.0,
+            self.0.load(Ordering::Relaxed)
         )
     }
 }
@@ -147,21 +318,7 @@ impl PoisonPill {
     /// Create a healthy (not poisoned) pill.
     #[inline]
     fn healthy() -> Self {
-        Self {
-            poisoned: Arc::new(AtomicBool::new(false)),
-        }
-    }
-
-    /// Poison this pill.
-    #[inline]
-    fn poison(&self) {
-        self.poisoned.store(true, Ordering::Relaxed)
-    }
-
-    /// Check if this pill is poisoned.
-    #[inline]
-    fn poisoned(&self) -> bool {
-        self.poisoned.load(Ordering::Relaxed)
+        Self(Arc::new(AtomicBool::new(false)))
     }
 }
 
@@ -189,6 +346,7 @@ impl Connected {
     }
 
     /// Copies the extra connection information into an `Extensions` map.
+    #[inline]
     pub fn set_extras(&self, extensions: &mut Extensions) {
         if let Some(extra) = &self.extra {
             extra.set(extensions);
@@ -244,30 +402,20 @@ impl Connected {
     /// Determine if this connection is poisoned
     #[inline]
     pub fn poisoned(&self) -> bool {
-        self.poisoned.poisoned()
+        self.poisoned.0.load(Ordering::Relaxed)
     }
 
     /// Poison this connection
     ///
     /// A poisoned connection will not be reused for subsequent requests by the pool
+    #[allow(unused)]
     #[inline]
     pub fn poison(&self) {
-        self.poisoned.poison();
+        self.poisoned.0.store(true, Ordering::Relaxed);
         debug!(
             "connection was poisoned. this connection will not be reused for subsequent requests"
         );
     }
-
-    // Don't public expose that `Connected` is `Clone`, unsure if we want to
-    // keep that contract...
-    pub(crate) fn clone(&self) -> Connected {
-        Connected {
-            alpn: self.alpn,
-            proxy: self.proxy.clone(),
-            extra: self.extra.clone(),
-            poisoned: self.poisoned.clone(),
-        }
-    }
 }
 
 // ===== impl Extra =====