wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/conn/net/uds/compio.rs

@@ -0,0 +1,60 @@
+//! Compio-based unix socket connector.
+
+#![allow(dead_code)]
+
+use std::{
+    io,
+    path::Path,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use compio::net::UnixStream;
+use http::Uri;
+use wreq_rt::rt::compio::{future::SendFuture, io::CompioIO};
+
+use super::BoxConnecting;
+use crate::conn::{Connected, Connection, net::io::CompioConnection, tls_info::TlsInfoFactory};
+
+#[derive(Clone)]
+pub struct UnixConnector(Arc<Path>);
+
+impl UnixConnector {
+    /// Creates a new [`UnixConnector`] for the specified socket path.
+    #[inline]
+    pub fn new(path: impl Into<Arc<Path>>) -> Self {
+        Self(path.into())
+    }
+}
+
+impl tower::Service<Uri> for UnixConnector {
+    type Response = CompioConnection<UnixStream>;
+    type Error = io::Error;
+    type Future = BoxConnecting<Self::Response>;
+
+    #[inline]
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, _: Uri) -> Self::Future {
+        let fut = UnixStream::connect(self.0.clone());
+        Box::pin(SendFuture::new(async move {
+            let io = fut.await?;
+            Ok(CompioConnection {
+                peer_addr: None,
+                local_addr: None,
+                inner: CompioIO::new(io),
+            })
+        }))
+    }
+}
+
+impl Connection for CompioConnection<UnixStream> {
+    #[inline]
+    fn connected(&self) -> Connected {
+        Connected::new()
+    }
+}
+
+impl TlsInfoFactory for CompioConnection<UnixStream> {}

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

@@ -1,7 +1,8 @@
+//! Tokio-based unix socket connector.
+
 use std::{
     io,
     path::Path,
-    pin::Pin,
     sync::Arc,
     task::{Context, Poll},
 };
@@ -9,30 +10,33 @@ use std::{
 use http::Uri;
 use tokio::net::UnixStream;
 
-use super::{Connected, Connection};
-
-type ConnectResult = io::Result<UnixStream>;
-type BoxConnecting = Pin<Box<dyn Future<Output = ConnectResult> + Send>>;
+use super::BoxConnecting;
+use crate::conn::{Connected, Connection, tls_info::TlsInfoFactory};
 
 #[derive(Clone)]
-pub struct UnixConnector(pub(crate) Arc<Path>);
+pub struct UnixConnector(Arc<Path>);
+
+impl UnixConnector {
+    /// Creates a new [`UnixConnector`] for the specified socket path.
+    #[inline]
+    pub fn new(path: impl Into<Arc<Path>>) -> Self {
+        Self(path.into())
+    }
+}
 
 impl tower::Service<Uri> for UnixConnector {
     type Response = UnixStream;
     type Error = io::Error;
-    type Future = BoxConnecting;
+    type Future = BoxConnecting<Self::Response>;
 
     #[inline]
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
+    #[inline]
     fn call(&mut self, _: Uri) -> Self::Future {
-        let fut = UnixStream::connect(self.0.clone());
-        Box::pin(async move {
-            let io = fut.await?;
-            Ok::<_, io::Error>(io)
-        })
+        Box::pin(UnixStream::connect(self.0.clone()))
     }
 }
 
@@ -42,3 +46,5 @@ impl Connection for UnixStream {
         Connected::new()
     }
 }
+
+impl TlsInfoFactory for UnixStream {}

data/vendor/wreq/src/conn/net/uds.rs

@@ -0,0 +1,11 @@
+//! Unix Domain Socket (UDS) connection types and utilities.
+
+#[cfg(all(unix, feature = "tokio-rt"))]
+pub mod tokio;
+
+#[cfg(all(unix, feature = "compio-rt"))]
+pub mod compio;
+
+use std::{io::Result, pin::Pin};
+
+type BoxConnecting<T> = Pin<Box<dyn Future<Output = Result<T>> + Send>>;

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

@@ -0,0 +1,130 @@
+//! Network connection types and utilities.
+
+pub(super) mod tcp;
+
+if_any_rt!(
+    mod io;
+    #[cfg(unix)]
+    mod uds;
+);
+
+if_all_rt! {
+    pub use tcp::tokio::TcpConnector;
+    #[cfg(unix)]
+    pub use uds::tokio::UnixConnector;
+}
+
+if_tokio_rt! {
+    pub use tcp::tokio::TcpConnector;
+    #[cfg(unix)]
+    pub use uds::tokio::UnixConnector;
+}
+
+if_compio_rt! {
+    pub use tcp::compio::TcpConnector;
+    #[cfg(unix)]
+    pub use uds::compio::UnixConnector;
+}
+
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+/// Options for configuring socket bind behavior for outbound connections.
+#[derive(Debug, Clone, Hash, PartialEq, Eq, Default)]
+pub(crate) struct SocketBindOptions {
+    #[cfg(any(
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "solaris",
+        target_os = "tvos",
+        target_os = "visionos",
+        target_os = "watchos",
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "linux",
+    ))]
+    pub interface: Option<std::borrow::Cow<'static, str>>,
+    pub ipv4_address: Option<Ipv4Addr>,
+    pub ipv6_address: Option<Ipv6Addr>,
+}
+
+impl SocketBindOptions {
+    /// Sets the name of the network interface to bind the socket to.
+    ///
+    /// ## Platform behavior
+    /// - On Linux/Fuchsia/Android: sets `SO_BINDTODEVICE`
+    /// - On macOS/illumos/Solaris/iOS/etc.: sets `IP_BOUND_IF`
+    ///
+    /// If `interface` is `None`, the socket will not be explicitly bound to any device.
+    ///
+    /// # Errors
+    ///
+    /// On platforms that require a `CString` (e.g. macOS), this will return an error if the
+    /// interface name contains an internal null byte (`\0`), which is invalid in C strings.
+    ///
+    /// # See Also
+    /// - [VRF documentation](https://www.kernel.org/doc/Documentation/networking/vrf.txt)
+    /// - [`man 7 socket`](https://man7.org/linux/man-pages/man7/socket.7.html)
+    /// - [`man 7p ip`](https://docs.oracle.com/cd/E86824_01/html/E54777/ip-7p.html)
+    #[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",
+    ))]
+    #[inline]
+    pub fn set_interface<I>(&mut self, interface: I) -> &mut Self
+    where
+        I: Into<std::borrow::Cow<'static, str>>,
+    {
+        self.interface = Some(interface.into());
+        self
+    }
+
+    /// Set that all sockets are bound to the configured address before connection.
+    ///
+    /// If `None`, the sockets will not be bound.
+    ///
+    /// Default is `None`.
+    #[inline]
+    pub fn set_local_address<V>(&mut self, local_address: V)
+    where
+        V: Into<Option<IpAddr>>,
+    {
+        match local_address.into() {
+            Some(IpAddr::V4(a)) => {
+                self.ipv4_address = Some(a);
+            }
+            Some(IpAddr::V6(a)) => {
+                self.ipv6_address = Some(a);
+            }
+            _ => {}
+        };
+    }
+
+    /// Set that all sockets are bound to the configured IPv4 or IPv6 address (depending on host's
+    /// preferences) before connection.
+    ///
+    /// If `None`, the sockets will not be bound.
+    ///
+    /// Default is `None`.
+    #[inline]
+    pub fn set_local_addresses<V4, V6>(&mut self, ipv4_address: V4, ipv6_address: V6)
+    where
+        V4: Into<Option<Ipv4Addr>>,
+        V6: Into<Option<Ipv6Addr>>,
+    {
+        if let Some(addr) = ipv4_address.into() {
+            self.ipv4_address = Some(addr);
+        }
+        if let Some(addr) = ipv6_address.into() {
+            self.ipv6_address = Some(addr);
+        }
+    }
+}

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

@@ -102,15 +102,8 @@ impl<C, R> SocksConnector<C, R>
 where
     R: InternalResolve + Clone,
 {
-    /// Create a new SOCKS connector with the given inner service.
-    ///
-    /// This wraps an underlying connector, and stores the address of a
-    /// SOCKS proxy server.
-    ///
-    /// A `SocksConnector` can then be called with any destination. The `proxy_dst` passed to
-    /// `call` will not be used to create the underlying connection, but will
-    /// be used in a SOCKS handshake sent to the proxy destination.
-    pub fn new_with_resolver(proxy_dst: Uri, inner: C, resolver: R) -> Self {
+    /// Create a new [`SocksConnector`].
+    pub fn new(proxy_dst: Uri, inner: C, resolver: R) -> Self {
         SocksConnector {
             inner,
             resolver,

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

@@ -1,16 +1,15 @@
 use std::{
-    io,
     marker::{PhantomData, Unpin},
-    pin::Pin,
-    task::{self, Poll, ready},
+    task::{self, Poll},
 };
 
+use bytes::BytesMut;
 use http::{HeaderMap, HeaderValue, Uri};
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
-use tower::Service;
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use tower::{BoxError, Service};
 
 use super::Tunneling;
-use crate::{error::BoxError, ext::UriExt};
+use crate::ext::UriExt;
 
 /// Tunnel Proxy via HTTP CONNECT
 ///
@@ -35,9 +34,9 @@ enum Headers {
 pub enum TunnelError {
     ConnectFailed(BoxError),
     Io(std::io::Error),
+    Parse(httparse::Error),
     MissingHost,
     ProxyAuthRequired,
-    ProxyHeadersTooLong,
     TunnelUnexpectedEof,
     TunnelUnsuccessful,
 }
@@ -175,64 +174,29 @@ where
     // headers end
     buf.extend_from_slice(b"\r\n");
 
-    write_all(&mut conn, &buf).await.map_err(TunnelError::Io)?;
+    conn.write_all(&buf).await.map_err(TunnelError::Io)?;
+    conn.flush().await.map_err(TunnelError::Io)?;
 
-    let mut buf = [0; 8192];
-    let mut pos = 0;
+    let mut buf = BytesMut::with_capacity(8192);
 
     loop {
-        let n = read(&mut conn, &mut buf[pos..])
-            .await
-            .map_err(TunnelError::Io)?;
-
-        if n == 0 {
+        if conn.read_buf(&mut buf).await.map_err(TunnelError::Io)? == 0 {
             return Err(TunnelError::TunnelUnexpectedEof);
         }
-        pos += n;
 
-        let recvd = &buf[..pos];
-        if recvd.starts_with(b"HTTP/1.1 200") || recvd.starts_with(b"HTTP/1.0 200") {
-            if recvd.ends_with(b"\r\n\r\n") {
-                return Ok(conn);
-            }
-            if pos == buf.len() {
-                return Err(TunnelError::ProxyHeadersTooLong);
-            }
-        // else read more
-        } else if recvd.starts_with(b"HTTP/1.1 407") {
-            return Err(TunnelError::ProxyAuthRequired);
-        } else {
-            return Err(TunnelError::TunnelUnsuccessful);
+        let mut headers = [httparse::EMPTY_HEADER; 64];
+        let mut res = httparse::Response::new(&mut headers);
+        match res.parse(&buf).map_err(TunnelError::Parse)? {
+            httparse::Status::Partial => continue,
+            httparse::Status::Complete(_) => match res.code {
+                Some(200) => return Ok(conn),
+                Some(407) => return Err(TunnelError::ProxyAuthRequired),
+                Some(_) | None => return Err(TunnelError::TunnelUnsuccessful),
+            },
         }
     }
 }
 
-async fn read<T>(io: &mut T, buf: &mut [u8]) -> io::Result<usize>
-where
-    T: AsyncRead + Unpin,
-{
-    std::future::poll_fn(move |cx| {
-        let mut buf = ReadBuf::new(buf);
-        ready!(Pin::new(&mut *io).poll_read(cx, &mut buf))?;
-        Poll::Ready(Ok(buf.filled().len()))
-    })
-    .await
-}
-
-async fn write_all<T>(io: &mut T, buf: &[u8]) -> io::Result<()>
-where
-    T: AsyncWrite + Unpin,
-{
-    let mut n = 0;
-    std::future::poll_fn(move |cx| {
-        while n < buf.len() {
-            n += ready!(Pin::new(&mut *io).poll_write(cx, &buf[n..])?);
-        }
-        Poll::Ready(Ok(()))
-    })
-    .await
-}
-
 impl std::fmt::Display for TunnelError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str("tunnel error: ")?;
@@ -240,7 +204,7 @@ impl std::fmt::Display for TunnelError {
         f.write_str(match self {
             TunnelError::MissingHost => "missing destination host",
             TunnelError::ProxyAuthRequired => "proxy authorization required",
-            TunnelError::ProxyHeadersTooLong => "proxy response headers too long",
+            TunnelError::Parse(_) => "invalid proxy response",
             TunnelError::TunnelUnexpectedEof => "unexpected end of file",
             TunnelError::TunnelUnsuccessful => "unsuccessful",
             TunnelError::ConnectFailed(_) => "failed to create underlying connection",
@@ -253,6 +217,7 @@ impl std::error::Error for TunnelError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
             TunnelError::Io(e) => Some(e),
+            TunnelError::Parse(e) => Some(e),
             TunnelError::ConnectFailed(e) => Some(&**e),
             _ => None,
         }

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

@@ -0,0 +1,47 @@
+use bytes::Bytes;
+use tokio_btls::SslStream;
+
+use crate::tls::{TlsInfo, conn::MaybeHttpsStream};
+
+/// A trait for extracting TLS information from a connection.
+pub trait TlsInfoFactory {
+    #[inline]
+    fn tls_info(&self) -> Option<TlsInfo> {
+        None
+    }
+}
+
+fn extract_tls_info<S>(ssl_stream: &SslStream<S>) -> TlsInfo {
+    let ssl = ssl_stream.ssl();
+    TlsInfo {
+        peer_certificate: ssl
+            .peer_certificate()
+            .and_then(|cert| cert.to_der().ok())
+            .map(Bytes::from),
+        peer_certificate_chain: ssl.peer_cert_chain().map(|chain| {
+            chain
+                .iter()
+                .filter_map(|cert| cert.to_der().ok())
+                .map(Bytes::from)
+                .collect()
+        }),
+    }
+}
+
+// Generic impl: any SslStream can provide TLS info.
+impl<T> TlsInfoFactory for SslStream<T> {
+    #[inline]
+    fn tls_info(&self) -> Option<TlsInfo> {
+        Some(extract_tls_info(self))
+    }
+}
+
+// Generic impl: MaybeHttpsStream delegates to the inner stream.
+impl<T: TlsInfoFactory> TlsInfoFactory for MaybeHttpsStream<T> {
+    fn tls_info(&self) -> Option<TlsInfo> {
+        match self {
+            MaybeHttpsStream::Https(tls) => tls.tls_info(),
+            MaybeHttpsStream::Http(_) => None,
+        }
+    }
+}