wreq-rb 0.6.0 → 0.6.2

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

@@ -9,8 +9,11 @@ use std::{
     task::{Context, Poll},
 };
 
+use futures_util::{TryFutureExt, future::MapErr};
 use tower::{BoxError, Service};
 
+use crate::error::DnsError;
+
 /// A domain name to resolve into IP addresses.
 #[derive(Clone, Hash, Eq, PartialEq)]
 pub struct Name {
@@ -99,14 +102,17 @@ impl DynResolver {
 impl Service<Name> for DynResolver {
     type Response = Addrs;
     type Error = BoxError;
-    type Future = Resolving;
+    type Future = MapErr<MapErr<Resolving, fn(BoxError) -> DnsError>, fn(DnsError) -> Self::Error>;
 
     fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
     fn call(&mut self, name: Name) -> Self::Future {
-        self.resolver.resolve(name)
+        self.resolver
+            .resolve(name)
+            .map_err(DnsError as _)
+            .map_err(Into::into)
     }
 }
 

data/vendor/wreq/src/dns.rs

@@ -17,7 +17,7 @@ pub use self::{
 };
 pub(crate) use self::{
     resolve::{DnsResolverWithOverrides, DynResolver},
-    sealed::{InternalResolve, resolve},
+    sealed::{DnsResolver, resolve},
 };
 
 /// A wrapper around `Vec<SocketAddr>` to implement the `Iterator` trait.
@@ -113,7 +113,7 @@ mod sealed {
     /// This trait provides a unified interface for different resolver implementations,
     /// allowing both custom [`super::Resolve`] types and Tower [`Service`] implementations
     /// to be used interchangeably within the connector.
-    pub trait InternalResolve {
+    pub trait DnsResolver {
         type Addrs: Iterator<Item = SocketAddr>;
         type Error: Into<BoxError>;
         type Future: Future<Output = Result<Self::Addrs, Self::Error>>;
@@ -123,7 +123,7 @@ mod sealed {
     }
 
     /// Automatic implementation for any Tower [`Service`] that resolves names to socket addresses.
-    impl<S> InternalResolve for S
+    impl<S> DnsResolver for S
     where
         S: Service<Name>,
         S::Response: Iterator<Item = SocketAddr>,
@@ -144,7 +144,7 @@ mod sealed {
 
     pub async fn resolve<R>(resolver: &mut R, name: Name) -> Result<R::Addrs, R::Error>
     where
-        R: InternalResolve,
+        R: DnsResolver,
     {
         std::future::poll_fn(|cx| resolver.poll_ready(cx)).await?;
         resolver.resolve(name).await

data/vendor/wreq/src/error.rs

@@ -183,16 +183,16 @@ impl Error {
                 return true;
             }
 
-            if let Some(core_err) = err.downcast_ref::<wreq_proto::Error>() {
-                if core_err.is_timeout() {
-                    return true;
-                }
+            if let Some(core_err) = err.downcast_ref::<wreq_proto::Error>()
+                && core_err.is_timeout()
+            {
+                return true;
             }
 
-            if let Some(io) = err.downcast_ref::<io::Error>() {
-                if io.kind() == io::ErrorKind::TimedOut {
-                    return true;
-                }
+            if let Some(io) = err.downcast_ref::<io::Error>()
+                && io.kind() == io::ErrorKind::TimedOut
+            {
+                return true;
             }
 
             source = err.source();
@@ -214,10 +214,10 @@ impl Error {
         let mut source = self.source();
 
         while let Some(err) = source {
-            if let Some(err) = err.downcast_ref::<Error>() {
-                if err.is_connect() {
-                    return true;
-                }
+            if let Some(err) = err.downcast_ref::<Error>()
+                && err.is_connect()
+            {
+                return true;
             }
 
             source = err.source();
@@ -233,10 +233,10 @@ impl Error {
         let mut source = self.source();
 
         while let Some(err) = source {
-            if let Some(err) = err.downcast_ref::<Error>() {
-                if err.is_proxy_connect() {
-                    return true;
-                }
+            if let Some(err) = err.downcast_ref::<Error>()
+                && err.is_proxy_connect()
+            {
+                return true;
             }
 
             source = err.source();
@@ -250,10 +250,10 @@ impl Error {
         let mut source = self.source();
 
         while let Some(err) = source {
-            if let Some(io) = err.downcast_ref::<io::Error>() {
-                if io.kind() == io::ErrorKind::ConnectionReset {
-                    return true;
-                }
+            if let Some(io) = err.downcast_ref::<io::Error>()
+                && io.kind() == io::ErrorKind::ConnectionReset
+            {
+                return true;
             }
             source = err.source();
         }
@@ -261,6 +261,21 @@ impl Error {
         false
     }
 
+    /// Returns true if the error is related to DNS resolution.
+    pub fn is_dns(&self) -> bool {
+        let mut source = self.source();
+
+        while let Some(err) = source {
+            if err.is::<DnsError>() {
+                return true;
+            }
+
+            source = err.source();
+        }
+
+        false
+    }
+
     /// Returns true if the error is related to the request or response body
     #[inline]
     pub fn is_body(&self) -> bool {
@@ -403,6 +418,9 @@ pub(crate) struct BadScheme;
 #[derive(Debug)]
 pub(crate) struct ProxyConnect(pub(crate) BoxError);
 
+#[derive(Debug)]
+pub(crate) struct DnsError(pub(crate) BoxError);
+
 // ==== impl TimedOut ====
 
 impl StdError for TimedOut {}
@@ -438,6 +456,21 @@ impl fmt::Display for ProxyConnect {
     }
 }
 
+// ==== impl DnsError ====
+
+impl StdError for DnsError {
+    #[inline]
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(&*self.0)
+    }
+}
+
+impl fmt::Display for DnsError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "dns resolution error: {}", self.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/vendor/wreq/src/lib.rs

@@ -2,6 +2,7 @@
 #![deny(unsafe_code)]
 #![deny(missing_docs)]
 #![cfg_attr(test, deny(warnings))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 //! # wreq
 //!

data/vendor/wreq/src/proxy/matcher.rs

@@ -288,10 +288,10 @@ impl Builder {
         if let Some(https) = https.as_mut() {
             https.extra = extra.clone();
         }
-        if http.is_none() || https.is_none() {
-            if let Some(all) = all.as_mut() {
-                all.extra = extra;
-            }
+        if (http.is_none() || https.is_none())
+            && let Some(all) = all.as_mut()
+        {
+            all.extra = extra;
         }
 
         Matcher {
@@ -437,14 +437,7 @@ impl NoProxy {
 
     /// Return true if this matches the host (domain or IP).
     pub fn contains(&self, host: &str) -> bool {
-        // According to RFC3986, raw IPv6 hosts will be wrapped in []. So we need to strip those off
-        // the end in order to parse correctly
-        let host = if host.starts_with('[') {
-            let x: &[_] = &['[', ']'];
-            host.trim_matches(x)
-        } else {
-            host
-        };
+        let host = crate::util::strip_ipv6_brackets(host);
         match host.parse::<IpAddr>() {
             // If we can parse an IP addr, then use it, otherwise, assume it is a domain
             Ok(ip) => self.ips.contains(ip),
@@ -544,6 +537,8 @@ mod builder {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(all(feature = "system-proxy", windows))]
+    use super::super::win;
     use super::*;
 
     #[test]
@@ -627,6 +622,25 @@ mod tests {
         }
     }
 
+    #[cfg(all(feature = "system-proxy", windows))]
+    #[test]
+    fn test_windows_proxy_override_ip_wildcard() {
+        let normalized =
+            win::normalize_proxy_override("127.*; 10.*.*.*; 192.168.*; 192.168.1.*; *.example.com");
+        let no_proxy = NoProxy::from_string(&normalized);
+
+        assert!(no_proxy.contains("127.0.0.1"));
+        assert!(no_proxy.contains("10.12.34.56"));
+        assert!(no_proxy.contains("192.168.42.1"));
+        assert!(no_proxy.contains("192.168.1.42"));
+        assert!(no_proxy.contains("www.example.com"));
+        assert!(!no_proxy.contains("128.0.0.1"));
+        assert!(!no_proxy.contains("192.169.42.1"));
+
+        let subnet = NoProxy::from_string(&win::normalize_proxy_override("192.168.1.*"));
+        assert!(!subnet.contains("192.168.2.42"));
+    }
+
     macro_rules! p {
         ($($n:ident = $v:expr,)*) => ({Builder {
             $($n: $v.into(),)*

data/vendor/wreq/src/proxy/win.rs

@@ -1,3 +1,38 @@
+fn ipv4_wildcard_to_cidr(value: &str) -> Option<String> {
+    let parts = value.split('.').collect::<Vec<_>>();
+    let wildcard = parts.iter().position(|part| *part == "*")?;
+
+    if wildcard == 0 || wildcard > 3 || parts[wildcard..].iter().any(|part| *part != "*") {
+        return None;
+    }
+
+    let mut octets = [0; 4];
+    for (index, part) in parts[..wildcard].iter().enumerate() {
+        octets[index] = part.parse().ok()?;
+    }
+
+    Some(format!(
+        "{}.{}.{}.{}/{}",
+        octets[0],
+        octets[1],
+        octets[2],
+        octets[3],
+        wildcard * 8
+    ))
+}
+
+pub(super) fn normalize_proxy_override(value: &str) -> String {
+    value
+        .split(';')
+        .map(|entry| {
+            let entry = entry.trim();
+            ipv4_wildcard_to_cidr(entry).unwrap_or_else(|| entry.to_string())
+        })
+        .collect::<Vec<_>>()
+        .join(",")
+        .replace("*.", "")
+}
+
 pub(super) fn with_system(builder: &mut super::matcher::Builder) {
     let Ok(settings) = windows_registry::CURRENT_USER
         .open("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
@@ -18,14 +53,9 @@ pub(super) fn with_system(builder: &mut super::matcher::Builder) {
         }
     }
 
-    if builder.no.is_empty() {
-        if let Ok(val) = settings.get_string("ProxyOverride") {
-            builder.no = val
-                .split(';')
-                .map(|s| s.trim())
-                .collect::<Vec<&str>>()
-                .join(",")
-                .replace("*.", "");
-        }
+    if builder.no.is_empty()
+        && let Ok(val) = settings.get_string("ProxyOverride")
+    {
+        builder.no = normalize_proxy_override(&val);
     }
 }