RubyGems - wreq-rb - Versions diffs - 0.3.0 - Mend

wreq-rb 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (167) hide show

checksums.yaml +7 -0
data/Cargo.lock +2688 -0
data/Cargo.toml +6 -0
data/README.md +179 -0
data/ext/wreq_rb/Cargo.toml +39 -0
data/ext/wreq_rb/extconf.rb +22 -0
data/ext/wreq_rb/src/client.rs +565 -0
data/ext/wreq_rb/src/error.rs +25 -0
data/ext/wreq_rb/src/lib.rs +20 -0
data/ext/wreq_rb/src/response.rs +132 -0
data/lib/wreq-rb/version.rb +5 -0
data/lib/wreq-rb.rb +17 -0
data/patches/0001-add-transfer-size-tracking.patch +292 -0
data/vendor/wreq/Cargo.toml +306 -0
data/vendor/wreq/LICENSE +202 -0
data/vendor/wreq/README.md +122 -0
data/vendor/wreq/examples/cert_store.rs +77 -0
data/vendor/wreq/examples/connect_via_lower_priority_tokio_runtime.rs +258 -0
data/vendor/wreq/examples/emulation.rs +118 -0
data/vendor/wreq/examples/form.rs +14 -0
data/vendor/wreq/examples/http1_websocket.rs +37 -0
data/vendor/wreq/examples/http2_websocket.rs +45 -0
data/vendor/wreq/examples/json_dynamic.rs +41 -0
data/vendor/wreq/examples/json_typed.rs +47 -0
data/vendor/wreq/examples/keylog.rs +16 -0
data/vendor/wreq/examples/request_with_emulation.rs +115 -0
data/vendor/wreq/examples/request_with_interface.rs +37 -0
data/vendor/wreq/examples/request_with_local_address.rs +16 -0
data/vendor/wreq/examples/request_with_proxy.rs +13 -0
data/vendor/wreq/examples/request_with_redirect.rs +22 -0
data/vendor/wreq/examples/request_with_version.rs +15 -0
data/vendor/wreq/examples/tor_socks.rs +24 -0
data/vendor/wreq/examples/unix_socket.rs +33 -0
data/vendor/wreq/src/client/body.rs +304 -0
data/vendor/wreq/src/client/conn/conn.rs +231 -0
data/vendor/wreq/src/client/conn/connector.rs +549 -0
data/vendor/wreq/src/client/conn/http.rs +1023 -0
data/vendor/wreq/src/client/conn/proxy/socks.rs +233 -0
data/vendor/wreq/src/client/conn/proxy/tunnel.rs +260 -0
data/vendor/wreq/src/client/conn/proxy.rs +39 -0
data/vendor/wreq/src/client/conn/tls_info.rs +98 -0
data/vendor/wreq/src/client/conn/uds.rs +44 -0
data/vendor/wreq/src/client/conn/verbose.rs +149 -0
data/vendor/wreq/src/client/conn.rs +323 -0
data/vendor/wreq/src/client/core/body/incoming.rs +485 -0
data/vendor/wreq/src/client/core/body/length.rs +118 -0
data/vendor/wreq/src/client/core/body.rs +34 -0
data/vendor/wreq/src/client/core/common/buf.rs +149 -0
data/vendor/wreq/src/client/core/common/rewind.rs +141 -0
data/vendor/wreq/src/client/core/common/watch.rs +76 -0
data/vendor/wreq/src/client/core/common.rs +3 -0
data/vendor/wreq/src/client/core/conn/http1.rs +342 -0
data/vendor/wreq/src/client/core/conn/http2.rs +307 -0
data/vendor/wreq/src/client/core/conn.rs +11 -0
data/vendor/wreq/src/client/core/dispatch.rs +299 -0
data/vendor/wreq/src/client/core/error.rs +435 -0
data/vendor/wreq/src/client/core/ext.rs +201 -0
data/vendor/wreq/src/client/core/http1.rs +178 -0
data/vendor/wreq/src/client/core/http2.rs +483 -0
data/vendor/wreq/src/client/core/proto/h1/conn.rs +988 -0
data/vendor/wreq/src/client/core/proto/h1/decode.rs +1170 -0
data/vendor/wreq/src/client/core/proto/h1/dispatch.rs +684 -0
data/vendor/wreq/src/client/core/proto/h1/encode.rs +580 -0
data/vendor/wreq/src/client/core/proto/h1/io.rs +879 -0
data/vendor/wreq/src/client/core/proto/h1/role.rs +694 -0
data/vendor/wreq/src/client/core/proto/h1.rs +104 -0
data/vendor/wreq/src/client/core/proto/h2/client.rs +650 -0
data/vendor/wreq/src/client/core/proto/h2/ping.rs +539 -0
data/vendor/wreq/src/client/core/proto/h2.rs +379 -0
data/vendor/wreq/src/client/core/proto/headers.rs +138 -0
data/vendor/wreq/src/client/core/proto.rs +58 -0
data/vendor/wreq/src/client/core/rt/bounds.rs +57 -0
data/vendor/wreq/src/client/core/rt/timer.rs +150 -0
data/vendor/wreq/src/client/core/rt/tokio.rs +99 -0
data/vendor/wreq/src/client/core/rt.rs +25 -0
data/vendor/wreq/src/client/core/upgrade.rs +267 -0
data/vendor/wreq/src/client/core.rs +16 -0
data/vendor/wreq/src/client/emulation.rs +161 -0
data/vendor/wreq/src/client/http/client/error.rs +142 -0
data/vendor/wreq/src/client/http/client/exec.rs +29 -0
data/vendor/wreq/src/client/http/client/extra.rs +77 -0
data/vendor/wreq/src/client/http/client/lazy.rs +79 -0
data/vendor/wreq/src/client/http/client/pool.rs +1105 -0
data/vendor/wreq/src/client/http/client/util.rs +104 -0
data/vendor/wreq/src/client/http/client.rs +1003 -0
data/vendor/wreq/src/client/http/future.rs +99 -0
data/vendor/wreq/src/client/http.rs +1629 -0
data/vendor/wreq/src/client/layer/config/options.rs +156 -0
data/vendor/wreq/src/client/layer/config.rs +116 -0
data/vendor/wreq/src/client/layer/cookie.rs +161 -0
data/vendor/wreq/src/client/layer/decoder.rs +139 -0
data/vendor/wreq/src/client/layer/redirect/future.rs +270 -0
data/vendor/wreq/src/client/layer/redirect/policy.rs +63 -0
data/vendor/wreq/src/client/layer/redirect.rs +145 -0
data/vendor/wreq/src/client/layer/retry/classify.rs +105 -0
data/vendor/wreq/src/client/layer/retry/scope.rs +51 -0
data/vendor/wreq/src/client/layer/retry.rs +151 -0
data/vendor/wreq/src/client/layer/timeout/body.rs +233 -0
data/vendor/wreq/src/client/layer/timeout/future.rs +90 -0
data/vendor/wreq/src/client/layer/timeout.rs +177 -0
data/vendor/wreq/src/client/layer.rs +15 -0
data/vendor/wreq/src/client/multipart.rs +717 -0
data/vendor/wreq/src/client/request.rs +818 -0
data/vendor/wreq/src/client/response.rs +534 -0
data/vendor/wreq/src/client/ws/json.rs +99 -0
data/vendor/wreq/src/client/ws/message.rs +453 -0
data/vendor/wreq/src/client/ws.rs +714 -0
data/vendor/wreq/src/client.rs +27 -0
data/vendor/wreq/src/config.rs +140 -0
data/vendor/wreq/src/cookie.rs +579 -0
data/vendor/wreq/src/dns/gai.rs +249 -0
data/vendor/wreq/src/dns/hickory.rs +78 -0
data/vendor/wreq/src/dns/resolve.rs +180 -0
data/vendor/wreq/src/dns.rs +69 -0
data/vendor/wreq/src/error.rs +502 -0
data/vendor/wreq/src/ext.rs +398 -0
data/vendor/wreq/src/hash.rs +143 -0
data/vendor/wreq/src/header.rs +506 -0
data/vendor/wreq/src/into_uri.rs +187 -0
data/vendor/wreq/src/lib.rs +586 -0
data/vendor/wreq/src/proxy/mac.rs +82 -0
data/vendor/wreq/src/proxy/matcher.rs +806 -0
data/vendor/wreq/src/proxy/uds.rs +66 -0
data/vendor/wreq/src/proxy/win.rs +31 -0
data/vendor/wreq/src/proxy.rs +569 -0
data/vendor/wreq/src/redirect.rs +575 -0
data/vendor/wreq/src/retry.rs +198 -0
data/vendor/wreq/src/sync.rs +129 -0
data/vendor/wreq/src/tls/conn/cache.rs +123 -0
data/vendor/wreq/src/tls/conn/cert_compression.rs +125 -0
data/vendor/wreq/src/tls/conn/ext.rs +82 -0
data/vendor/wreq/src/tls/conn/macros.rs +34 -0
data/vendor/wreq/src/tls/conn/service.rs +138 -0
data/vendor/wreq/src/tls/conn.rs +681 -0
data/vendor/wreq/src/tls/keylog/handle.rs +64 -0
data/vendor/wreq/src/tls/keylog.rs +99 -0
data/vendor/wreq/src/tls/options.rs +464 -0
data/vendor/wreq/src/tls/x509/identity.rs +122 -0
data/vendor/wreq/src/tls/x509/parser.rs +71 -0
data/vendor/wreq/src/tls/x509/store.rs +228 -0
data/vendor/wreq/src/tls/x509.rs +68 -0
data/vendor/wreq/src/tls.rs +154 -0
data/vendor/wreq/src/trace.rs +55 -0
data/vendor/wreq/src/util.rs +122 -0
data/vendor/wreq/tests/badssl.rs +228 -0
data/vendor/wreq/tests/brotli.rs +350 -0
data/vendor/wreq/tests/client.rs +1098 -0
data/vendor/wreq/tests/connector_layers.rs +227 -0
data/vendor/wreq/tests/cookie.rs +306 -0
data/vendor/wreq/tests/deflate.rs +347 -0
data/vendor/wreq/tests/emulation.rs +260 -0
data/vendor/wreq/tests/gzip.rs +347 -0
data/vendor/wreq/tests/layers.rs +261 -0
data/vendor/wreq/tests/multipart.rs +165 -0
data/vendor/wreq/tests/proxy.rs +438 -0
data/vendor/wreq/tests/redirect.rs +629 -0
data/vendor/wreq/tests/retry.rs +135 -0
data/vendor/wreq/tests/support/delay_server.rs +117 -0
data/vendor/wreq/tests/support/error.rs +16 -0
data/vendor/wreq/tests/support/layer.rs +183 -0
data/vendor/wreq/tests/support/mod.rs +9 -0
data/vendor/wreq/tests/support/server.rs +232 -0
data/vendor/wreq/tests/timeouts.rs +281 -0
data/vendor/wreq/tests/unix_socket.rs +135 -0
data/vendor/wreq/tests/upgrade.rs +98 -0
data/vendor/wreq/tests/zstd.rs +559 -0
metadata +225 -0

data/vendor/wreq/src/retry.rs ADDED Viewed

@@ -0,0 +1,198 @@
+//! Retry requests
+//!
+//! A `Client` has the ability to retry requests, by sending additional copies
+//! to the server if a response is considered retryable.
+//!
+//! The [`Policy`] makes it easier to configure what requests to retry, along
+//! with including best practices by default, such as a retry budget.
+//!
+//! # Defaults
+//!
+//! The default retry behavior of a `Client` is to only retry requests where an
+//! error or low-level protocol NACK is encountered that is known to be safe to
+//! retry. Note however that providing a specific retry policy will override
+//! the default, and you will need to explicitly include that behavior.
+//!
+//! All policies default to including a retry budget that permits 20% extra
+//! requests to be sent.
+//!
+//! # Scoped
+//!
+//! A client's retry policy is scoped. That means that the policy doesn't
+//! apply to all requests, but only those within a user-defined scope.
+//!
+//! Since all policies include a budget by default, it doesn't make sense to
+//! apply it on _all_ requests. Rather, the retry history applied by a budget
+//! should likely only be applied to the same host.
+//!
+//! # Classifiers
+//!
+//! A retry policy needs to be configured with a classifier that determines
+//! if a request should be retried. Knowledge of the destination server's
+//! behavior is required to make a safe classifier. **Requests should not be
+//! retried** if the server cannot safely handle the same request twice, or if
+//! it causes side effects.
+//!
+//! Some common properties to check include if the request method is
+//! idempotent, or if the response status code indicates a transient error.
+use std::sync::Arc;
+use http::Request;
+use crate::{
+    Body,
+    client::layer::retry::{Action, Classifier, ClassifyFn, ReqRep, ScopeFn, Scoped},
+};
+/// A retry policy.
+pub struct Policy {
+    pub(crate) budget: Option<f32>,
+    pub(crate) classifier: Classifier,
+    pub(crate) max_retries_per_request: u32,
+    pub(crate) scope: Scoped,
+}
+impl Policy {
+    /// Create a retry policy that will never retry any request.
+    ///
+    /// This is useful for disabling the `Client`s default behavior of retrying
+    /// protocol nacks.
+    #[inline]
+    pub fn never() -> Policy {
+        Self::scoped(|_| false).no_budget()
+    }
+    /// Create a retry policy scoped to requests for a specific host.
+    ///
+    /// This is a convenience method that creates a retry policy which only applies
+    /// to requests targeting the specified host. Requests to other hosts will not
+    /// be retried under this policy.
+    ///
+    /// # Arguments
+    /// * `host` - The hostname to match against request URIs (e.g., "api.example.com")
+    ///
+    /// # Example
+    /// ```rust
+    /// use wreq::retry::Policy;
+    ///
+    /// // Only retry requests to rust-lang.org
+    /// let policy = Policy::for_host("rust-lang.org");
+    /// ```
+    #[inline]
+    pub fn for_host<S>(host: S) -> Policy
+    where
+        S: for<'a> PartialEq<&'a str> + Send + Sync + 'static,
+    {
+        Self::scoped(move |req| {
+            req.uri()
+                .host()
+                .is_some_and(|request_host| host == request_host)
+        })
+    }
+    /// Create a scoped retry policy.
+    ///
+    /// For a more convenient constructor, see [`Policy::for_host()`].
+    #[inline]
+    fn scoped<F>(func: F) -> Policy
+    where
+        F: Fn(&Request<Body>) -> bool + Send + Sync + 'static,
+    {
+        Self {
+            budget: Some(0.2),
+            classifier: Classifier::Never,
+            max_retries_per_request: 2,
+            scope: Scoped::Dyn(Arc::new(ScopeFn(func))),
+        }
+    }
+    /// Set no retry budget.
+    ///
+    /// Sets that no budget will be enforced. This could also be considered
+    /// to be an infinite budget.
+    ///
+    /// This is NOT recommended. Disabling the budget can make your system more
+    /// susceptible to retry storms.
+    #[inline]
+    pub fn no_budget(mut self) -> Self {
+        self.budget = None;
+        self
+    }
+    /// Sets the max extra load the budget will allow.
+    ///
+    /// Think of the amount of requests your client generates, and how much
+    /// load that puts on the server. This option configures as a percentage
+    /// how much extra load is allowed via retries.
+    ///
+    /// For example, if you send 1,000 requests per second, setting a maximum
+    /// extra load value of `0.3` would allow 300 more requests per second
+    /// in retries. A value of `2.5` would allow 2,500 more requests.
+    ///
+    /// # Panics
+    ///
+    /// The `extra_percent` value must be within reasonable values for a
+    /// percentage. This method will panic if it is less than `0.0`, or greater
+    /// than `1000.0`.
+    #[inline]
+    pub fn max_extra_load(mut self, extra_percent: f32) -> Self {
+        assert!(extra_percent >= 0.0);
+        assert!(extra_percent <= 1000.0);
+        self.budget = Some(extra_percent);
+        self
+    }
+    /// Set the max retries allowed per request.
+    ///
+    /// For each logical (initial) request, only retry up to `max` times.
+    ///
+    /// This value is used in combination with a token budget that is applied
+    /// to all requests. Even if the budget would allow more requests, this
+    /// limit will prevent. Likewise, the budget may prevent retrying up to
+    /// `max` times. This setting prevents a single request from consuming
+    /// the entire budget.
+    ///
+    /// Default is currently 2 retries.
+    #[inline]
+    pub fn max_retries_per_request(mut self, max: u32) -> Self {
+        self.max_retries_per_request = max;
+        self
+    }
+    /// Provide a classifier to determine if a request should be retried.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn with_policy(policy: wreq::retry::Policy) -> wreq::retry::Policy {
+    /// policy.classify_fn(|req_rep| {
+    ///     match (req_rep.method(), req_rep.status()) {
+    ///         (&http::Method::GET, Some(http::StatusCode::SERVICE_UNAVAILABLE)) => {
+    ///             req_rep.retryable()
+    ///         },
+    ///         _ => req_rep.success()
+    ///     }
+    /// })
+    /// # }
+    /// ```
+    #[inline]
+    pub fn classify_fn<F>(mut self, func: F) -> Self
+    where
+        F: Fn(ReqRep<'_>) -> Action + Send + Sync + 'static,
+    {
+        self.classifier = Classifier::Dyn(Arc::new(ClassifyFn(func)));
+        self
+    }
+}
+impl Default for Policy {
+    fn default() -> Self {
+        Self {
+            budget: None,
+            classifier: Classifier::ProtocolNacks,
+            max_retries_per_request: 2,
+            scope: Scoped::Unscoped,
+        }
+    }
+}

data/vendor/wreq/src/sync.rs ADDED Viewed

@@ -0,0 +1,129 @@
+//! Synchronization primitives: [`Mutex`] and [`RwLock`] that never poison.
+//!
+//! These types expose APIs identical to [`std::sync::Mutex`] and [`std::sync::RwLock`],
+//! but **do not return** [`std::sync::PoisonError`] even if a thread panics while holding the lock.
+//!
+//! This is useful in high-availability systems where panic recovery is done externally,
+//! or poisoning is not meaningful in context.
+use std::{
+    ops::{Deref, DerefMut},
+    sync,
+};
+/// A [`Mutex`] that never poisons and has the same interface as [`std::sync::Mutex`].
+pub struct Mutex<T: ?Sized>(sync::Mutex<T>);
+impl<T> Mutex<T> {
+    /// Like [`std::sync::Mutex::new`].
+    #[inline]
+    pub fn new(t: T) -> Mutex<T> {
+        Mutex(sync::Mutex::new(t))
+    }
+}
+impl<T: ?Sized> Mutex<T> {
+    /// Like [`std::sync::Mutex::lock`].
+    #[inline]
+    pub fn lock(&self) -> MutexGuard<'_, T> {
+        MutexGuard(self.0.lock().unwrap_or_else(|e| e.into_inner()))
+    }
+}
+impl<T> Default for Mutex<T>
+where
+    T: Default,
+{
+    #[inline]
+    fn default() -> Self {
+        Mutex::new(T::default())
+    }
+}
+/// Like [`std::sync::MutexGuard`].
+#[must_use]
+pub struct MutexGuard<'a, T: ?Sized + 'a>(sync::MutexGuard<'a, T>);
+impl<T: ?Sized> Deref for MutexGuard<'_, T> {
+    type Target = T;
+    #[inline]
+    fn deref(&self) -> &T {
+        self.0.deref()
+    }
+}
+impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        self.0.deref_mut()
+    }
+}
+/// A [`RwLock`] that never poisons and has the same interface as [`std::sync::RwLock`].
+pub struct RwLock<T: ?Sized>(sync::RwLock<T>);
+impl<T> RwLock<T> {
+    /// Like [`std::sync::RwLock::new`].
+    #[inline]
+    pub fn new(t: T) -> RwLock<T> {
+        RwLock(sync::RwLock::new(t))
+    }
+}
+impl<T: ?Sized> RwLock<T> {
+    /// Like [`std::sync::RwLock::read`].
+    #[inline]
+    pub fn read(&self) -> RwLockReadGuard<'_, T> {
+        RwLockReadGuard(self.0.read().unwrap_or_else(|e| e.into_inner()))
+    }
+    /// Like [`std::sync::RwLock::write`].
+    #[inline]
+    pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+        RwLockWriteGuard(self.0.write().unwrap_or_else(|e| e.into_inner()))
+    }
+}
+impl<T> Default for RwLock<T>
+where
+    T: Default,
+{
+    #[inline]
+    fn default() -> Self {
+        RwLock::new(T::default())
+    }
+}
+/// Like [`std::sync::RwLockReadGuard`].
+#[must_use]
+pub struct RwLockReadGuard<'a, T: ?Sized + 'a>(sync::RwLockReadGuard<'a, T>);
+impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
+    type Target = T;
+    #[inline]
+    fn deref(&self) -> &T {
+        self.0.deref()
+    }
+}
+/// Like [`std::sync::RwLockWriteGuard`].
+#[must_use]
+pub struct RwLockWriteGuard<'a, T: ?Sized + 'a>(sync::RwLockWriteGuard<'a, T>);
+impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
+    type Target = T;
+    #[inline]
+    fn deref(&self) -> &T {
+        self.0.deref()
+    }
+}
+impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        self.0.deref_mut()
+    }
+}

data/vendor/wreq/src/tls/conn/cache.rs ADDED Viewed

@@ -0,0 +1,123 @@
+use std::{
+    borrow::Borrow,
+    collections::hash_map::Entry,
+    hash::{Hash, Hasher},
+};
+use boring2::ssl::{SslSession, SslSessionRef, SslVersion};
+use schnellru::ByLength;
+use crate::hash::{HASHER, HashMap, LruMap};
+/// A typed key for indexing TLS sessions in the cache.
+///
+/// This wrapper provides type safety and allows different key types
+/// (e.g., hostname, connection parameters) to be used for session lookup.
+#[derive(Hash, PartialEq, Eq, Clone)]
+pub struct SessionKey<T>(pub T);
+/// A hashable wrapper around `SslSession` for use in hash-based collections.
+///
+/// Uses the session ID for hashing and equality, enabling efficient
+/// storage and lookup in HashMap/HashSet while maintaining session semantics.
+#[derive(Clone)]
+struct HashSession(SslSession);
+impl PartialEq for HashSession {
+    fn eq(&self, other: &HashSession) -> bool {
+        self.0.id() == other.0.id()
+    }
+}
+impl Eq for HashSession {}
+impl Hash for HashSession {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.0.id().hash(state);
+    }
+}
+impl Borrow<[u8]> for HashSession {
+    fn borrow(&self) -> &[u8] {
+        self.0.id()
+    }
+}
+/// A two-level cache for TLS sessions organized by host keys with LRU eviction.
+///
+/// Maintains both forward (key → sessions) and reverse (session → key) lookups
+/// for efficient session storage, retrieval, and cleanup operations.
+pub struct SessionCache<T> {
+    reverse: HashMap<HashSession, SessionKey<T>>,
+    per_host_sessions: HashMap<SessionKey<T>, LruMap<HashSession, ()>>,
+    per_host_session_capacity: usize,
+}
+impl<T> SessionCache<T>
+where
+    T: Hash + Eq + Clone,
+{
+    pub fn with_capacity(per_host_session_capacity: usize) -> SessionCache<T> {
+        SessionCache {
+            per_host_sessions: HashMap::with_hasher(HASHER),
+            reverse: HashMap::with_hasher(HASHER),
+            per_host_session_capacity,
+        }
+    }
+    pub fn insert(&mut self, key: SessionKey<T>, session: SslSession) {
+        let per_host_sessions = self
+            .per_host_sessions
+            .entry(key.clone())
+            .or_insert_with(|| {
+                LruMap::with_hasher(ByLength::new(self.per_host_session_capacity as _), HASHER)
+            });
+        // Enforce per-key capacity limit by evicting the least recently used session
+        if per_host_sessions.len() >= self.per_host_session_capacity {
+            if let Some((evicted_session, _)) = per_host_sessions.pop_oldest() {
+                // Remove from reverse lookup to maintain consistency
+                self.reverse.remove(&evicted_session);
+            }
+        }
+        let session = HashSession(session);
+        per_host_sessions.insert(session.clone(), ());
+        self.reverse.insert(session, key);
+    }
+    pub fn get(&mut self, key: &SessionKey<T>) -> Option<SslSession> {
+        let session = {
+            let per_host_sessions = self.per_host_sessions.get_mut(key)?;
+            per_host_sessions.peek_oldest()?.0.clone().0
+        };
+        // https://tools.ietf.org/html/rfc8446#appendix-C.4
+        // OpenSSL will remove the session from its cache after the handshake completes anyway, but
+        // this ensures that concurrent handshakes don't end up with the same session.
+        if session.protocol_version() == SslVersion::TLS1_3 {
+            self.remove(&session);
+        }
+        Some(session)
+    }
+    fn remove(&mut self, session: &SslSessionRef) {
+        let key = match self.reverse.remove(session.id()) {
+            Some(key) => key,
+            None => return,
+        };
+        if let Entry::Occupied(mut per_host_sessions) = self.per_host_sessions.entry(key) {
+            per_host_sessions
+                .get_mut()
+                .remove(&HashSession(session.to_owned()));
+            if per_host_sessions.get().is_empty() {
+                per_host_sessions.remove();
+            }
+        }
+    }
+}

data/vendor/wreq/src/tls/conn/cert_compression.rs ADDED Viewed

@@ -0,0 +1,125 @@
+use std::io::{self, Read, Result, Write};
+use boring2::ssl::{CertificateCompressionAlgorithm, CertificateCompressor};
+use brotli::{CompressorWriter, Decompressor};
+use flate2::{Compression, read::ZlibDecoder, write::ZlibEncoder};
+use zstd::stream::{Decoder as ZstdDecoder, Encoder as ZstdEncoder};
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct BrotliCertificateCompressor;
+impl CertificateCompressor for BrotliCertificateCompressor {
+    const ALGORITHM: CertificateCompressionAlgorithm = CertificateCompressionAlgorithm::BROTLI;
+    const CAN_COMPRESS: bool = true;
+    const CAN_DECOMPRESS: bool = true;
+    fn compress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
+    where
+        W: Write,
+    {
+        let mut writer = CompressorWriter::new(output, input.len(), 11, 22);
+        writer.write_all(input)?;
+        writer.flush()?;
+        Ok(())
+    }
+    fn decompress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
+    where
+        W: Write,
+    {
+        let mut reader = Decompressor::new(input, 4096);
+        let mut buf = [0u8; 4096];
+        loop {
+            match reader.read(&mut buf[..]) {
+                Err(e) => {
+                    if let io::ErrorKind::Interrupted = e.kind() {
+                        continue;
+                    }
+                    return Err(e);
+                }
+                Ok(size) => {
+                    if size == 0 {
+                        break;
+                    }
+                    output.write_all(&buf[..size])?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct ZlibCertificateCompressor;
+impl CertificateCompressor for ZlibCertificateCompressor {
+    const ALGORITHM: CertificateCompressionAlgorithm = CertificateCompressionAlgorithm::ZLIB;
+    const CAN_COMPRESS: bool = true;
+    const CAN_DECOMPRESS: bool = true;
+    fn compress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
+    where
+        W: Write,
+    {
+        let mut encoder = ZlibEncoder::new(output, Compression::default());
+        encoder.write_all(input)?;
+        encoder.finish()?;
+        Ok(())
+    }
+    fn decompress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
+    where
+        W: Write,
+    {
+        let mut decoder = ZlibDecoder::new(input);
+        io::copy(&mut decoder, output)?;
+        Ok(())
+    }
+}
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct ZstdCertificateCompressor;
+impl CertificateCompressor for ZstdCertificateCompressor {
+    const ALGORITHM: CertificateCompressionAlgorithm = CertificateCompressionAlgorithm::ZSTD;
+    const CAN_COMPRESS: bool = true;
+    const CAN_DECOMPRESS: bool = true;
+    fn compress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
+    where
+        W: Write,
+    {
+        let mut writer = ZstdEncoder::new(output, 0)?;
+        writer.write_all(input)?;
+        writer.flush()?;
+        Ok(())
+    }
+    fn decompress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
+    where
+        W: Write,
+    {
+        let mut reader = ZstdDecoder::new(input)?;
+        let mut buf = [0u8; 4096];
+        loop {
+            match reader.read(&mut buf[..]) {
+                Err(e) => {
+                    if let io::ErrorKind::Interrupted = e.kind() {
+                        continue;
+                    }
+                    return Err(e);
+                }
+                Ok(size) => {
+                    if size == 0 {
+                        break;
+                    }
+                    output.write_all(&buf[..size])?;
+                }
+            }
+        }
+        Ok(())
+    }
+}

data/vendor/wreq/src/tls/conn/ext.rs ADDED Viewed

@@ -0,0 +1,82 @@
+use boring2::ssl::{SslConnectorBuilder, SslVerifyMode};
+use crate::{
+    Error,
+    tls::{
+        CertificateCompressionAlgorithm,
+        conn::cert_compression::{
+            BrotliCertificateCompressor, ZlibCertificateCompressor, ZstdCertificateCompressor,
+        },
+        x509::CertStore,
+    },
+};
+/// SslConnectorBuilderExt trait for `SslConnectorBuilder`.
+pub trait SslConnectorBuilderExt {
+    /// Configure the CertStore for the given `SslConnectorBuilder`.
+    fn set_cert_store(self, store: Option<&CertStore>) -> crate::Result<SslConnectorBuilder>;
+    /// Configure the certificate verification for the given `SslConnectorBuilder`.
+    fn set_cert_verification(self, enable: bool) -> crate::Result<SslConnectorBuilder>;
+    /// Configure the certificate compression algorithm for the given `SslConnectorBuilder`.
+    fn add_certificate_compression_algorithms(
+        self,
+        algs: Option<&[CertificateCompressionAlgorithm]>,
+    ) -> crate::Result<SslConnectorBuilder>;
+}
+impl SslConnectorBuilderExt for SslConnectorBuilder {
+    #[inline]
+    fn set_cert_store(mut self, store: Option<&CertStore>) -> crate::Result<SslConnectorBuilder> {
+        if let Some(store) = store {
+            store.add_to_tls(&mut self);
+        } else {
+            self.set_default_verify_paths().map_err(Error::tls)?;
+        }
+        Ok(self)
+    }
+    #[inline]
+    fn set_cert_verification(mut self, enable: bool) -> crate::Result<SslConnectorBuilder> {
+        if enable {
+            self.set_verify(SslVerifyMode::PEER);
+        } else {
+            self.set_verify(SslVerifyMode::NONE);
+        }
+        Ok(self)
+    }
+    #[inline]
+    fn add_certificate_compression_algorithms(
+        mut self,
+        algs: Option<&[CertificateCompressionAlgorithm]>,
+    ) -> crate::Result<SslConnectorBuilder> {
+        if let Some(algs) = algs {
+            for algorithm in algs.iter() {
+                let res =
+                    match *algorithm {
+                        CertificateCompressionAlgorithm::ZLIB => self
+                            .add_certificate_compression_algorithm(
+                                ZlibCertificateCompressor::default(),
+                            ),
+                        CertificateCompressionAlgorithm::BROTLI => self
+                            .add_certificate_compression_algorithm(
+                                BrotliCertificateCompressor::default(),
+                            ),
+                        CertificateCompressionAlgorithm::ZSTD => self
+                            .add_certificate_compression_algorithm(
+                                ZstdCertificateCompressor::default(),
+                            ),
+                        _ => continue,
+                    };
+                if let Err(e) = res {
+                    return Err(Error::tls(e));
+                }
+            }
+        }
+        Ok(self)
+    }
+}

data/vendor/wreq/src/tls/conn/macros.rs ADDED Viewed

@@ -0,0 +1,34 @@
+macro_rules! set_bool {
+    ($cfg:expr, $field:ident, $conn:expr, $setter:ident) => {
+        if $cfg.$field {
+            $conn.$setter();
+        }
+    };
+    ($cfg:expr, !$field:ident, $conn:expr, $setter:ident, $arg:expr) => {
+        if !$cfg.$field {
+            $conn.$setter($arg);
+        }
+    };
+}
+macro_rules! set_option {
+    ($cfg:expr, $field:ident, $conn:expr, $setter:ident) => {
+        if let Some(val) = $cfg.$field {
+            $conn.$setter(val);
+        }
+    };
+}
+macro_rules! set_option_ref_try {
+    ($cfg:expr, $field:ident, $conn:expr, $setter:ident) => {
+        if let Some(val) = $cfg.$field.as_ref() {
+            $conn.$setter(val).map_err(Error::tls)?;
+        }
+    };
+}
+macro_rules! set_option_inner_try {
+    ($field:ident, $conn:expr, $setter:ident) => {
+        $conn.$setter($field.map(|v| v.0)).map_err(Error::tls)?;
+    };
+}