wreq-rb 0.3.0

data/vendor/wreq/src/client/conn/conn.rs

@@ -0,0 +1,231 @@
+use std::{
+    io::{self, IoSlice},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
+#[cfg(unix)]
+use tokio::net::UnixStream;
+use tokio::{
+    io::{AsyncRead, AsyncWrite, ReadBuf},
+    net::TcpStream,
+};
+use tokio_boring2::SslStream;
+
+use super::{AsyncConnWithInfo, Connected, Connection, TlsInfoFactory};
+use crate::{
+    proxy::matcher::Intercept,
+    tls::{TlsInfo, conn::MaybeHttpsStream},
+};
+
+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 `is_proxy == false`, or
+    /// * absolute-form (`GET http://foo.bar/and/a/path HTTP/1.1`), otherwise.
+    pub struct Conn {
+        #[pin]
+        pub(super) inner: Box<dyn AsyncConnWithInfo>,
+        pub(super) tls_info: bool,
+        pub(super) proxy: Option<Intercept>,
+    }
+}
+
+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]
+        inner: SslStream<T>,
+    }
+}
+
+// ==== impl Conn ====
+
+impl Connection for Conn {
+    fn connected(&self) -> Connected {
+        let mut connected = self.inner.connected();
+
+        if let Some(proxy) = &self.proxy {
+            connected = connected.proxy(proxy.clone());
+        }
+
+        if self.tls_info {
+            if let Some(tls_info) = self.inner.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().inner, 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().inner, 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().inner, cx, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+        AsyncWrite::poll_flush(self.project().inner, cx)
+    }
+
+    #[inline]
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+        AsyncWrite::poll_shutdown(self.project().inner, cx)
+    }
+}
+
+// ==== impl TlsConn ====
+
+impl<T> TlsConn<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    /// Creates a new `TlsConn` wrapping the provided `SslStream`.
+    #[inline(always)]
+    pub fn new(inner: SslStream<T>) -> Self {
+        Self { inner }
+    }
+}
+
+// ===== impl TcpStream =====
+
+impl Connection for TlsConn<TcpStream> {
+    fn connected(&self) -> Connected {
+        let connected = self.inner.get_ref().connected();
+        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
+            connected.negotiated_h2()
+        } else {
+            connected
+        }
+    }
+}
+
+impl Connection for TlsConn<MaybeHttpsStream<TcpStream>> {
+    fn connected(&self) -> Connected {
+        let connected = self.inner.get_ref().connected();
+        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
+            connected.negotiated_h2()
+        } else {
+            connected
+        }
+    }
+}
+
+// ===== impl UnixStream =====
+
+#[cfg(unix)]
+impl Connection for TlsConn<UnixStream> {
+    fn connected(&self) -> Connected {
+        let connected = self.inner.get_ref().connected();
+        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
+            connected.negotiated_h2()
+        } else {
+            connected
+        }
+    }
+}
+
+#[cfg(unix)]
+impl Connection for TlsConn<MaybeHttpsStream<UnixStream>> {
+    fn connected(&self) -> Connected {
+        let connected = self.inner.get_ref().connected();
+        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
+            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().inner, 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().inner, 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().inner, cx, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), tokio::io::Error>> {
+        AsyncWrite::poll_flush(self.project().inner, cx)
+    }
+
+    #[inline]
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), tokio::io::Error>> {
+        AsyncWrite::poll_shutdown(self.project().inner, cx)
+    }
+}
+
+impl<T> TlsInfoFactory for TlsConn<T>
+where
+    SslStream<T>: TlsInfoFactory,
+{
+    fn tls_info(&self) -> Option<TlsInfo> {
+        self.inner.tls_info()
+    }
+}