wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/dns/gai/tokio.rs

@@ -0,0 +1,90 @@
+// This module contains the `GaiResolver` implementation for the `tokio` runtime.
+
+use std::{
+    future::Future,
+    io,
+    net::ToSocketAddrs,
+    pin::Pin,
+    task::{self, Poll},
+};
+
+use tower::Service;
+
+use super::{GaiAddrs, GaiResolver};
+use crate::dns::{Addrs, Name, Resolve, Resolving, SocketAddrs};
+
+/// A future to resolve a name returned by `GaiResolver`.
+pub struct GaiFuture {
+    inner: tokio::task::JoinHandle<Result<SocketAddrs, io::Error>>,
+}
+
+// ==== impl GaiResolver ====
+
+impl GaiResolver {
+    /// Creates a new [`GaiResolver`].
+    pub fn new() -> Self {
+        GaiResolver { _priv: () }
+    }
+}
+
+impl Service<Name> for GaiResolver {
+    type Response = GaiAddrs;
+    type Error = io::Error;
+    type Future = GaiFuture;
+
+    #[inline]
+    fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, name: Name) -> Self::Future {
+        let blocking = tokio::task::spawn_blocking(move || {
+            debug!("resolving {}", name);
+            (name.as_str(), 0)
+                .to_socket_addrs()
+                .map(|i| SocketAddrs { iter: i })
+        });
+        GaiFuture { inner: blocking }
+    }
+}
+
+impl Resolve for GaiResolver {
+    fn resolve(&self, name: Name) -> Resolving {
+        let mut this = self.clone();
+        Box::pin(async move {
+            this.call(name)
+                .await
+                .map(|addrs| Box::new(addrs) as Addrs)
+                .map_err(Into::into)
+        })
+    }
+}
+
+// ==== impl GaiFuture ====
+
+impl Future for GaiFuture {
+    type Output = Result<GaiAddrs, io::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.inner).poll(cx).map(|res| match res {
+            Ok(Ok(addrs)) => Ok(GaiAddrs { inner: addrs }),
+            Ok(Err(err)) => Err(err),
+            Err(join_err) => {
+                #[cfg(feature = "tokio-rt")]
+                if join_err.is_cancelled() {
+                    return Err(io::Error::new(io::ErrorKind::Interrupted, join_err));
+                }
+
+                Err(io::Error::other(format!(
+                    "DNS resolution blocked task panicked: {join_err}"
+                )))
+            }
+        })
+    }
+}
+
+impl Drop for GaiFuture {
+    fn drop(&mut self) {
+        self.inner.abort();
+    }
+}

data/vendor/wreq/src/dns/gai.rs

@@ -1,16 +1,18 @@
-use std::{
-    future::Future,
-    io,
-    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs},
-    pin::Pin,
-    task::{self, Poll},
-    vec,
-};
+if_tokio_rt! {
+    mod tokio;
+}
+
+if_compio_rt!(
+    mod compio;
+);
 
-use tokio::task::JoinHandle;
-use tower::Service;
+if_all_rt!(
+    mod tokio;
+);
 
-use super::{Addrs, Name, Resolve, Resolving};
+use std::net::SocketAddr;
+
+use crate::dns::SocketAddrs;
 
 /// A resolver using blocking `getaddrinfo` calls in a threadpool.
 #[derive(Clone, Default)]
@@ -23,86 +25,6 @@ pub struct GaiAddrs {
     inner: SocketAddrs,
 }
 
-/// A future to resolve a name returned by `GaiResolver`.
-pub struct GaiFuture {
-    inner: JoinHandle<Result<SocketAddrs, io::Error>>,
-}
-
-/// A wrapper around `SocketAddrs` to implement the `Iterator` trait.
-pub(crate) struct SocketAddrs {
-    iter: vec::IntoIter<SocketAddr>,
-}
-
-// ==== impl GaiResolver ====
-
-impl GaiResolver {
-    /// Creates a new [`GaiResolver`].
-    pub fn new() -> Self {
-        GaiResolver { _priv: () }
-    }
-}
-
-impl Service<Name> for GaiResolver {
-    type Response = GaiAddrs;
-    type Error = io::Error;
-    type Future = GaiFuture;
-
-    fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(), io::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, name: Name) -> Self::Future {
-        let blocking = tokio::task::spawn_blocking(move || {
-            debug!("resolving {}", name);
-            (name.as_str(), 0)
-                .to_socket_addrs()
-                .map(|i| SocketAddrs { iter: i })
-        });
-
-        GaiFuture { inner: blocking }
-    }
-}
-
-impl Resolve for GaiResolver {
-    fn resolve(&self, name: Name) -> Resolving {
-        let mut this = self.clone();
-        Box::pin(async move {
-            this.call(name)
-                .await
-                .map(|addrs| Box::new(addrs) as Addrs)
-                .map_err(Into::into)
-        })
-    }
-}
-
-// ==== impl GaiFuture ====
-
-impl Future for GaiFuture {
-    type Output = Result<GaiAddrs, io::Error>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.inner).poll(cx).map(|res| match res {
-            Ok(Ok(addrs)) => Ok(GaiAddrs { inner: addrs }),
-            Ok(Err(err)) => Err(err),
-            Err(join_err) => {
-                if join_err.is_cancelled() {
-                    Err(io::Error::new(io::ErrorKind::Interrupted, join_err))
-                } else {
-                    panic!("gai background task failed: {join_err:?}")
-                }
-            }
-        })
-    }
-}
-
-impl Drop for GaiFuture {
-    fn drop(&mut self) {
-        self.inner.abort();
-    }
-}
-
-// ==== impl GaiAddrs ====
-
 impl Iterator for GaiAddrs {
     type Item = SocketAddr;
 
@@ -111,83 +33,11 @@ impl Iterator for GaiAddrs {
     }
 }
 
-// ==== impl SocketAddrs ====
-
-impl SocketAddrs {
-    pub(crate) fn new(addrs: Vec<SocketAddr>) -> Self {
-        SocketAddrs {
-            iter: addrs.into_iter(),
-        }
-    }
-
-    pub(crate) fn try_parse(host: &str, port: u16) -> Option<SocketAddrs> {
-        if let Ok(addr) = host.parse::<Ipv4Addr>() {
-            let addr = SocketAddrV4::new(addr, port);
-            return Some(SocketAddrs {
-                iter: vec![SocketAddr::V4(addr)].into_iter(),
-            });
-        }
-        if let Ok(addr) = host.parse::<Ipv6Addr>() {
-            let addr = SocketAddrV6::new(addr, port, 0, 0);
-            return Some(SocketAddrs {
-                iter: vec![SocketAddr::V6(addr)].into_iter(),
-            });
-        }
-        None
-    }
-
-    #[inline]
-    fn filter(self, predicate: impl FnMut(&SocketAddr) -> bool) -> SocketAddrs {
-        SocketAddrs::new(self.iter.filter(predicate).collect())
-    }
-
-    pub(crate) fn split_by_preference(
-        self,
-        local_addr_ipv4: Option<Ipv4Addr>,
-        local_addr_ipv6: Option<Ipv6Addr>,
-    ) -> (SocketAddrs, SocketAddrs) {
-        match (local_addr_ipv4, local_addr_ipv6) {
-            (Some(_), None) => (self.filter(SocketAddr::is_ipv4), SocketAddrs::new(vec![])),
-            (None, Some(_)) => (self.filter(SocketAddr::is_ipv6), SocketAddrs::new(vec![])),
-            _ => {
-                let preferring_v6 = self
-                    .iter
-                    .as_slice()
-                    .first()
-                    .map(SocketAddr::is_ipv6)
-                    .unwrap_or(false);
-
-                let (preferred, fallback) = self
-                    .iter
-                    .partition::<Vec<_>, _>(|addr| addr.is_ipv6() == preferring_v6);
-
-                (SocketAddrs::new(preferred), SocketAddrs::new(fallback))
-            }
-        }
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.iter.as_slice().is_empty()
-    }
-
-    pub(crate) fn len(&self) -> usize {
-        self.iter.as_slice().len()
-    }
-}
-
-impl Iterator for SocketAddrs {
-    type Item = SocketAddr;
-    #[inline]
-    fn next(&mut self) -> Option<SocketAddr> {
-        self.iter.next()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::net::{Ipv4Addr, Ipv6Addr};
 
-    use super::*;
+    use crate::dns::{Name, SocketAddrs};
 
     #[test]
     fn test_ip_addrs_split_by_preference() {

data/vendor/wreq/src/dns/hickory.rs

@@ -4,9 +4,8 @@ use std::{net::SocketAddr, sync::LazyLock};
 
 use hickory_resolver::{
     TokioResolver,
-    config::{LookupIpStrategy, ResolverConfig},
-    lookup_ip::LookupIpIntoIter,
-    name_server::TokioConnectionProvider,
+    config::{self, LookupIpStrategy, ResolverConfig},
+    net::runtime::TokioRuntimeProvider,
 };
 
 use super::{Addrs, Name, Resolve, Resolving};
@@ -25,8 +24,10 @@ pub struct HickoryDnsResolver {
 impl HickoryDnsResolver {
     /// Create a new resolver with the default configuration,
     /// which reads from `/etc/resolve.conf`. The options are
-    /// overriden to look up for both IPv4 and IPv6 addresses
-    /// to work with "happy eyeballs" algorithm.
+    /// overridden to look up both IPv4 and IPv6 addresses
+    /// to support the "happy eyeballs" algorithm.
+    ///
+    /// SAFETY: `build` only fails if DNS-over-TLS is enabled and default TLS config creation fails.
     pub fn new() -> HickoryDnsResolver {
         static RESOLVER: LazyLock<TokioResolver> = LazyLock::new(|| {
             let mut builder = match TokioResolver::builder_tokio() {
@@ -37,13 +38,13 @@ impl HickoryDnsResolver {
                 Err(_err) => {
                     debug!("error reading DNS system conf: {}, using defaults", _err);
                     TokioResolver::builder_with_config(
-                        ResolverConfig::default(),
-                        TokioConnectionProvider::default(),
+                        ResolverConfig::udp_and_tcp(&config::GOOGLE),
+                        TokioRuntimeProvider::default(),
                     )
                 }
             };
             builder.options_mut().ip_strategy = LookupIpStrategy::Ipv4AndIpv6;
-            builder.build()
+            builder.build().expect("failed to create DNS resolver")
         });
 
         HickoryDnsResolver {
@@ -52,27 +53,19 @@ impl HickoryDnsResolver {
     }
 }
 
-struct SocketAddrs {
-    iter: LookupIpIntoIter,
-}
-
 impl Resolve for HickoryDnsResolver {
     fn resolve(&self, name: Name) -> Resolving {
         let resolver = self.clone();
         Box::pin(async move {
             let lookup = resolver.resolver.lookup_ip(name.as_str()).await?;
-            let addrs: Addrs = Box::new(SocketAddrs {
-                iter: lookup.into_iter(),
-            });
+            let addrs: Addrs = Box::new(
+                lookup
+                    .iter()
+                    .map(|ip_addr| SocketAddr::new(ip_addr, 0))
+                    .collect::<Vec<_>>()
+                    .into_iter(),
+            );
             Ok(addrs)
         })
     }
 }
-
-impl Iterator for SocketAddrs {
-    type Item = SocketAddr;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(|ip_addr| SocketAddr::new(ip_addr, 0))
-    }
-}

data/vendor/wreq/src/dns/resolve.rs

@@ -9,9 +9,7 @@ use std::{
     task::{Context, Poll},
 };
 
-use tower::Service;
-
-use crate::error::BoxError;
+use tower::{BoxError, Service};
 
 /// A domain name to resolve into IP addresses.
 #[derive(Clone, Hash, Eq, PartialEq)]
@@ -74,45 +72,13 @@ pub trait Resolve: Send + Sync {
     fn resolve(&self, name: Name) -> Resolving;
 }
 
-/// Trait for converting types into a shared DNS resolver ([`Arc<dyn Resolve>`]).
-///
-/// Implemented for any [`Resolve`] type, [`Arc<T>`] where `T: Resolve`, and [`Arc<dyn Resolve>`].
-/// Enables ergonomic conversion to a trait object for use in APIs without manual Arc wrapping.
-pub trait IntoResolve {
-    /// Converts the implementor into an [`Arc<dyn Resolve>`].
+impl_into_shared!(
+    /// Trait for converting types into a shared DNS resolver ([`Arc<dyn Resolve>`]).
     ///
-    /// This method enables ergonomic conversion of concrete resolvers, [`Arc<T>`], or
-    /// existing [`Arc<dyn Resolve>`] into a trait object suitable for APIs that expect
-    /// a shared DNS resolver.
-    fn into_resolve(self) -> Arc<dyn Resolve>;
-}
-
-impl IntoResolve for Arc<dyn Resolve> {
-    #[inline]
-    fn into_resolve(self) -> Arc<dyn Resolve> {
-        self
-    }
-}
-
-impl<R> IntoResolve for Arc<R>
-where
-    R: Resolve + 'static,
-{
-    #[inline]
-    fn into_resolve(self) -> Arc<dyn Resolve> {
-        self
-    }
-}
-
-impl<R> IntoResolve for R
-where
-    R: Resolve + 'static,
-{
-    #[inline]
-    fn into_resolve(self) -> Arc<dyn Resolve> {
-        Arc::new(self)
-    }
-}
+    /// Implemented for any [`Resolve`] type, [`Arc<T>`] where `T: Resolve`, and [`Arc<dyn Resolve>`].
+    /// Enables ergonomic conversion to a trait object for use in APIs without manual Arc wrapping.
+    pub trait IntoResolve => Resolve
+);
 
 /// Adapter that wraps a [`Resolve`] trait object to work with Tower's `Service` trait.
 ///

data/vendor/wreq/src/dns.rs

@@ -1,18 +1,102 @@
 //! DNS resolution
 
-pub(crate) mod gai;
+use std::{
+    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
+    vec,
+};
+
+mod gai;
+mod resolve;
+
 #[cfg(feature = "hickory-dns")]
 pub(crate) mod hickory;
-pub(crate) mod resolve;
-
-pub use resolve::{Addrs, IntoResolve, Name, Resolve, Resolving};
 
+pub use self::{
+    gai::GaiResolver,
+    resolve::{Addrs, IntoResolve, Name, Resolve, Resolving},
+};
 pub(crate) use self::{
-    gai::{GaiResolver, SocketAddrs},
     resolve::{DnsResolverWithOverrides, DynResolver},
     sealed::{InternalResolve, resolve},
 };
 
+/// A wrapper around `Vec<SocketAddr>` to implement the `Iterator` trait.
+pub(crate) struct SocketAddrs {
+    iter: vec::IntoIter<SocketAddr>,
+}
+
+impl SocketAddrs {
+    pub(crate) fn new(addrs: Vec<SocketAddr>) -> Self {
+        SocketAddrs {
+            iter: addrs.into_iter(),
+        }
+    }
+
+    pub(crate) fn try_parse(host: &str, port: u16) -> Option<SocketAddrs> {
+        if let Ok(addr) = host.parse::<Ipv4Addr>() {
+            let addr = SocketAddrV4::new(addr, port);
+            return Some(SocketAddrs {
+                iter: vec![SocketAddr::V4(addr)].into_iter(),
+            });
+        }
+        if let Ok(addr) = host.parse::<Ipv6Addr>() {
+            let addr = SocketAddrV6::new(addr, port, 0, 0);
+            return Some(SocketAddrs {
+                iter: vec![SocketAddr::V6(addr)].into_iter(),
+            });
+        }
+        None
+    }
+
+    pub(crate) fn split_by_preference(
+        self,
+        local_addr_ipv4: Option<Ipv4Addr>,
+        local_addr_ipv6: Option<Ipv6Addr>,
+    ) -> (SocketAddrs, SocketAddrs) {
+        match (local_addr_ipv4, local_addr_ipv6) {
+            (Some(_), None) => (self.filter(SocketAddr::is_ipv4), SocketAddrs::new(vec![])),
+            (None, Some(_)) => (self.filter(SocketAddr::is_ipv6), SocketAddrs::new(vec![])),
+            _ => {
+                let preferring_v6 = self
+                    .iter
+                    .as_slice()
+                    .first()
+                    .map(SocketAddr::is_ipv6)
+                    .unwrap_or(false);
+
+                let (preferred, fallback) = self
+                    .iter
+                    .partition::<Vec<_>, _>(|addr| addr.is_ipv6() == preferring_v6);
+
+                (SocketAddrs::new(preferred), SocketAddrs::new(fallback))
+            }
+        }
+    }
+
+    #[inline]
+    fn filter(self, predicate: impl FnMut(&SocketAddr) -> bool) -> SocketAddrs {
+        SocketAddrs::new(self.iter.filter(predicate).collect())
+    }
+
+    #[inline]
+    pub(crate) fn is_empty(&self) -> bool {
+        self.iter.as_slice().is_empty()
+    }
+
+    #[inline]
+    pub(crate) fn len(&self) -> usize {
+        self.iter.as_slice().len()
+    }
+}
+
+impl Iterator for SocketAddrs {
+    type Item = SocketAddr;
+    #[inline]
+    fn next(&mut self) -> Option<SocketAddr> {
+        self.iter.next()
+    }
+}
+
 mod sealed {
     use std::{
         future::Future,
@@ -20,10 +104,9 @@ mod sealed {
         task::{self, Poll},
     };
 
-    use tower::Service;
+    use tower::{BoxError, Service};
 
     use super::Name;
-    use crate::error::BoxError;
 
     /// Internal adapter trait for DNS resolvers.
     ///