wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/client/{http → layer}/client.rs

@@ -1,124 +1,69 @@
-#[macro_use]
-pub mod error;
-mod exec;
-pub mod extra;
+//! Much of this codebase is adapted and refined from [hyper](https://github.com/hyperium/hyper-util),
+
 mod lazy;
 mod pool;
-mod util;
 
 use std::{
+    error::Error as StdError,
+    fmt,
     future::Future,
-    num::NonZeroU32,
-    pin::Pin,
-    sync::Arc,
+    num::NonZeroUsize,
     task::{self, Poll},
     time::Duration,
 };
 
 use bytes::Bytes;
-use futures_util::future::{Either, FutureExt, TryFutureExt};
+use futures_util::future::{self, BoxFuture, Either, FutureExt, TryFutureExt};
 use http::{
     HeaderValue, Method, Request, Response, Uri, Version,
     header::{HOST, PROXY_AUTHORIZATION},
+    uri::{Authority, PathAndQuery, Scheme},
 };
 use http_body::Body;
 use pool::Ver;
 use tokio::io::{AsyncRead, AsyncWrite};
-use tower::util::Oneshot;
-
-use self::{
-    error::{ClientConnectError, Error, ErrorKind, TrySendError},
-    exec::Exec,
-    extra::{ConnectExtra, ConnectIdentity},
-    lazy::{Started as Lazy, lazy},
+use tower::{BoxError, util::Oneshot};
+use wreq_proto::{
+    body::Incoming,
+    conn::{self, TrySendError as ConnTrySendError},
+    http1::Http1Options,
+    http2::Http2Options,
+    rt::Executor as _,
 };
+#[cfg(feature = "cookies")]
+use {
+    crate::cookie::{CookieStore, Cookies},
+    http::header::COOKIE,
+    std::sync::Arc,
+};
+
+use self::lazy::{Started as Lazy, lazy};
 use crate::{
-    client::{
-        conn::{Connected, Connection},
-        core::{
-            body::Incoming,
-            conn::{self, TrySendError as ConnTrySendError},
-            http1::Http1Options,
-            http2::Http2Options,
-            rt::{ArcTimer, Executor, Timer},
-        },
-        layer::config::RequestOptions,
-    },
+    client::layer::config::RequestOptions,
     config::RequestConfig,
-    error::BoxError,
-    hash::{HASHER, HashMemo},
-    tls::AlpnProtocol,
+    conn::{
+        Connected, Connection,
+        descriptor::{ConnectionDescriptor, ConnectionId},
+        proxy,
+    },
+    error::ProxyConnect,
+    rt::{Executor, Timer},
 };
 
-type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
-
-/// Parameters required to initiate a new connection.
-///
-/// [`ConnectRequest`] holds the target URI and all connection-specific options
-/// (protocol, proxy, TCP/TLS settings) needed to establish a new network connection.
-/// Used by connectors to drive the connection setup process.
-#[must_use]
-#[derive(Clone)]
-pub struct ConnectRequest {
-    uri: Uri,
-    identifier: ConnectIdentity,
-}
-
-// ===== impl ConnectRequest =====
-
-impl ConnectRequest {
-    /// Create a new [`ConnectRequest`] with the given URI and identifier.
-    #[inline]
-    fn new<T>(uri: Uri, identifier: T) -> ConnectRequest
-    where
-        T: Into<Option<RequestOptions>>,
-    {
-        ConnectRequest {
-            uri: uri.clone(),
-            identifier: Arc::new(HashMemo::with_hasher(
-                ConnectExtra::new(uri, identifier),
-                HASHER,
-            )),
-        }
-    }
-
-    /// Returns a reference to the [`Uri`].
-    #[inline]
-    pub fn uri(&self) -> &Uri {
-        &self.uri
-    }
-
-    /// Returns a mutable reference to the [`Uri`].
-    #[inline]
-    pub fn uri_mut(&mut self) -> &mut Uri {
-        &mut self.uri
-    }
-
-    /// Returns a unique [`ConnectIdentity`].
-    #[inline]
-    pub(crate) fn identify(&self) -> ConnectIdentity {
-        self.identifier.clone()
-    }
-
-    /// Returns the [`ConnectExtra`] connection extra.
-    #[inline]
-    pub(crate) fn extra(&self) -> &ConnectExtra {
-        self.identifier.as_ref().as_ref()
-    }
-}
-
 /// A HttpClient to make outgoing HTTP requests.
 ///
 /// `HttpClient` is cheap to clone and cloning is the recommended way to share a `HttpClient`. The
 /// underlying connection pool will be reused.
 #[must_use]
-pub struct HttpClient<C, B> {
+pub(crate) struct HttpClient<C, B> {
     config: Config,
     connector: C,
-    exec: Exec,
+    exec: Executor,
     h1_builder: conn::http1::Builder,
-    h2_builder: conn::http2::Builder<Exec>,
-    pool: pool::Pool<PoolClient<B>, ConnectIdentity>,
+    h2_builder: conn::http2::Builder<Executor>,
+    pool: pool::Pool<PoolClient<B>, ConnectionId>,
+    #[cfg(feature = "cookies")]
+    cookie_store: RequestConfig<Arc<dyn CookieStore>>,
 }
 
 #[derive(Clone, Copy)]
@@ -128,21 +73,71 @@ struct Config {
     ver: Ver,
 }
 
+#[derive(Debug)]
+pub struct Error {
+    kind: ErrorKind,
+    source: Option<BoxError>,
+    #[allow(unused)]
+    connect_info: Option<Connected>,
+}
+
+#[derive(Debug)]
+enum ErrorKind {
+    Canceled,
+    ChannelClosed,
+    Connect,
+    ProxyConnect,
+    UserUnsupportedRequestMethod,
+    UserUnsupportedVersion,
+    UserAbsoluteUriRequired,
+    SendRequest,
+}
+
+enum ClientConnectError {
+    Normal(Error),
+    CheckoutIsClosed(pool::Error),
+}
+
+#[allow(clippy::large_enum_variant)]
+enum TrySendError<B> {
+    Retryable {
+        error: Error,
+        req: Request<B>,
+        connection_reused: bool,
+    },
+    Nope(Error),
+}
+
+macro_rules! e {
+    ($kind:ident) => {
+        Error {
+            kind: ErrorKind::$kind,
+            source: None,
+            connect_info: None,
+        }
+    };
+    ($kind:ident, $src:expr) => {
+        Error {
+            kind: ErrorKind::$kind,
+            source: Some($src.into()),
+            connect_info: None,
+        }
+    };
+}
+
 // ===== impl HttpClient =====
 
 impl HttpClient<(), ()> {
-    /// Create a builder to configure a new `HttpClient`.
-    pub fn builder<E>(executor: E) -> Builder
-    where
-        E: Executor<BoxSendFuture> + Send + Sync + Clone + 'static,
-    {
+    /// Create a builder to configure a new [`HttpClient`].
+    #[inline]
+    pub fn builder(executor: Executor) -> Builder {
         Builder::new(executor)
     }
 }
 
 impl<C, B> HttpClient<C, B>
 where
-    C: tower::Service<ConnectRequest> + Clone + Send + Sync + 'static,
+    C: tower::Service<ConnectionDescriptor> + Clone + Send + Sync + 'static,
     C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
     C::Error: Into<BoxError>,
     C::Future: Unpin + Send + 'static,
@@ -150,64 +145,69 @@ where
     B::Data: Send,
     B::Error: Into<BoxError>,
 {
-    /// Send a constructed `Request` using this `HttpClient`.
-    fn request(&self, mut req: Request<B>) -> ResponseFuture {
+    fn request(
+        &self,
+        mut req: Request<B>,
+    ) -> BoxFuture<'static, Result<Response<Incoming>, BoxError>> {
         let is_http_connect = req.method() == Method::CONNECT;
         // Validate HTTP version early
         match req.version() {
             Version::HTTP_10 if is_http_connect => {
                 warn!("CONNECT is not allowed for HTTP/1.0");
-                return ResponseFuture::new(futures_util::future::err(Error::new_kind(
-                    ErrorKind::UserUnsupportedRequestMethod,
-                )));
+                return Box::pin(future::err(e!(UserUnsupportedRequestMethod).into()));
             }
             Version::HTTP_10 | Version::HTTP_11 | Version::HTTP_2 => {}
             // completely unsupported HTTP version (like HTTP/0.9)!
             _unsupported => {
                 warn!("Request has unsupported version: {:?}", _unsupported);
-                return ResponseFuture::new(futures_util::future::err(Error::new_kind(
-                    ErrorKind::UserUnsupportedVersion,
-                )));
+                return Box::pin(future::err(e!(UserUnsupportedVersion).into()));
             }
         };
 
         // Extract and normalize URI
-        let uri = match util::normalize_uri(&mut req, is_http_connect) {
+        let uri = match normalize_uri(&mut req, is_http_connect) {
             Ok(uri) => uri,
-            Err(err) => return ResponseFuture::new(futures_util::future::err(err)),
+            Err(err) => {
+                return Box::pin(future::err(e!(UserAbsoluteUriRequired, err).into()));
+            }
         };
 
         let mut this = self.clone();
 
-        // Extract per-request options from the request extensions and apply them to the client
-        // builder. This allows each request to override HTTP/1 and HTTP/2 options as
-        // needed.
-        let options = RequestConfig::<RequestOptions>::remove(req.extensions_mut());
-
-        // Apply HTTP/1 and HTTP/2 options if provided
-        if let Some(opts) = options.as_ref().map(RequestOptions::transport_opts) {
-            if let Some(opts) = opts.http1_options() {
-                this.h1_builder.options(opts.clone());
+        // Extract per-request options from the request extensions and apply them to the client.
+        let descriptor = {
+            let RequestOptions {
+                group,
+                proxy,
+                version,
+                tls_options,
+                http1_options,
+                http2_options,
+                socket_bind_options,
+            } = RequestConfig::<RequestOptions>::remove(req.extensions_mut()).unwrap_or_default();
+
+            if let Some(opts) = http1_options {
+                this.h1_builder = this.h1_builder.options(opts);
             }
-
-            if let Some(opts) = opts.http2_options() {
-                this.h2_builder.options(opts.clone());
+            if let Some(opts) = http2_options {
+                this.h2_builder = this.h2_builder.options(opts);
             }
-        }
 
-        let connect_req = ConnectRequest::new(uri, options);
-        ResponseFuture::new(this.send_request(req, connect_req))
+            ConnectionDescriptor::new(uri, group, proxy, version, tls_options, socket_bind_options)
+        };
+
+        Box::pin(this.send_request(req, descriptor).map_err(Into::into))
     }
 
     async fn send_request(
         self,
         mut req: Request<B>,
-        connect_req: ConnectRequest,
+        descriptor: ConnectionDescriptor,
     ) -> Result<Response<Incoming>, Error> {
         let uri = req.uri().clone();
 
         loop {
-            req = match self.try_send_request(req, connect_req.clone()).await {
+            req = match self.try_send_request(req, descriptor.clone()).await {
                 Ok(resp) => return Ok(resp),
                 Err(TrySendError::Nope(err)) => return Err(err),
                 Err(TrySendError::Retryable {
@@ -235,41 +235,34 @@ where
     async fn try_send_request(
         &self,
         mut req: Request<B>,
-        connect_req: ConnectRequest,
+        descriptor: ConnectionDescriptor,
     ) -> Result<Response<Incoming>, TrySendError<B>> {
         let mut pooled = self
-            .connection_for(connect_req)
+            .connection_for(descriptor)
             .await
             // `connection_for` already retries checkout errors, so if
             // it returns an error, there's not much else to retry
             .map_err(TrySendError::Nope)?;
 
+        let uri = req.uri().clone();
+
         if pooled.is_http1() {
             if req.version() == Version::HTTP_2 {
                 warn!("Connection is HTTP/1, but request requires HTTP/2");
                 return Err(TrySendError::Nope(
-                    Error::new_kind(ErrorKind::UserUnsupportedVersion)
-                        .with_connect_info(pooled.conn_info.clone()),
+                    e!(UserUnsupportedVersion).with_connect_info(pooled.conn_info.clone()),
                 ));
             }
 
             if self.config.set_host {
-                let uri = req.uri().clone();
-                req.headers_mut().entry(HOST).or_insert_with(|| {
-                    let hostname = uri.host().expect("authority implies host");
-                    if let Some(port) = util::get_non_default_port(&uri) {
-                        let s = format!("{hostname}:{port}");
-                        HeaderValue::from_maybe_shared(Bytes::from(s))
-                    } else {
-                        HeaderValue::from_str(hostname)
-                    }
-                    .expect("uri host is valid header value")
-                });
+                req.headers_mut()
+                    .entry(HOST)
+                    .or_insert_with(|| generate_host_header(&uri));
             }
 
             // CONNECT always sends authority-form, so check it first...
             if req.method() == Method::CONNECT {
-                util::authority_form(req.uri_mut());
+                authority_form(req.uri_mut());
             } else if pooled.conn_info.is_proxied() {
                 if let Some(auth) = pooled.conn_info.proxy_auth() {
                     req.headers_mut()
@@ -281,12 +274,40 @@ where
                     crate::util::replace_headers(req.headers_mut(), headers.clone());
                 }
 
-                util::absolute_form(req.uri_mut());
+                absolute_form(req.uri_mut());
             } else {
-                util::origin_form(req.uri_mut());
+                origin_form(req.uri_mut());
             }
         } else if req.method() == Method::CONNECT && !pooled.is_http2() {
-            util::authority_form(req.uri_mut());
+            authority_form(req.uri_mut());
+        }
+
+        #[cfg(feature = "cookies")]
+        let cookie_store = self.cookie_store.fetch(req.extensions()).cloned();
+
+        #[cfg(feature = "cookies")]
+        if let Some(ref cookie_store) = cookie_store {
+            let headers = req.headers_mut();
+
+            if !headers.contains_key(COOKIE) {
+                let version = if pooled.is_http2() {
+                    Version::HTTP_2
+                } else {
+                    Version::HTTP_11
+                };
+
+                match cookie_store.cookies(&uri, version) {
+                    Cookies::Compressed(value) => {
+                        headers.insert(COOKIE, value);
+                    }
+                    Cookies::Uncompressed(values) => {
+                        for value in values {
+                            headers.append(COOKIE, value);
+                        }
+                    }
+                    Cookies::Empty => (),
+                }
+            }
         }
 
         let mut res = match pooled.try_send_request(req).await {
@@ -308,9 +329,24 @@ where
             }
         };
 
+        #[cfg(feature = "cookies")]
+        if let Some(cookie_store) = cookie_store {
+            let mut cookies = res
+                .headers()
+                .get_all(http::header::SET_COOKIE)
+                .iter()
+                .peekable();
+            if cookies.peek().is_some() {
+                cookie_store.set_cookies(&mut cookies, &uri);
+            }
+        }
+
         // If the Connector included 'extra' info, add to Response...
         pooled.conn_info.set_extras(res.extensions_mut());
 
+        // If the Connector included connection info, add to Response...
+        res.extensions_mut().insert(pooled.conn_info.clone());
+
         // If pooled is HTTP/2, we can toss this reference immediately.
         //
         // when pooled is dropped, it will try to insert back into the
@@ -333,10 +369,10 @@ where
 
     async fn connection_for(
         &self,
-        req: ConnectRequest,
-    ) -> Result<pool::Pooled<PoolClient<B>, ConnectIdentity>, Error> {
+        descriptor: ConnectionDescriptor,
+    ) -> Result<pool::Pooled<PoolClient<B>, ConnectionId>, Error> {
         loop {
-            match self.one_connection_for(req.clone()).await {
+            match self.one_connection_for(descriptor.clone()).await {
                 Ok(pooled) => return Ok(pooled),
                 Err(ClientConnectError::Normal(err)) => return Err(err),
                 Err(ClientConnectError::CheckoutIsClosed(reason)) => {
@@ -356,12 +392,12 @@ where
 
     async fn one_connection_for(
         &self,
-        req: ConnectRequest,
-    ) -> Result<pool::Pooled<PoolClient<B>, ConnectIdentity>, ClientConnectError> {
+        descriptor: ConnectionDescriptor,
+    ) -> Result<pool::Pooled<PoolClient<B>, ConnectionId>, ClientConnectError> {
         // Return a single connection if pooling is not enabled
         if !self.pool.is_enabled() {
             return self
-                .connect_to(req)
+                .connect_to(descriptor)
                 .await
                 .map_err(ClientConnectError::Normal);
         }
@@ -376,8 +412,8 @@ where
         // - If a new connection is started, but the Checkout wins after (an idle connection became
         //   available first), the started connection future is spawned into the runtime to
         //   complete, and then be inserted into the pool as an idle connection.
-        let checkout = self.pool.checkout(req.identify());
-        let connect = self.connect_to(req);
+        let checkout = self.pool.checkout(descriptor.id());
+        let connect = self.connect_to(descriptor);
         let is_ver_h2 = self.config.ver == Ver::Http2;
 
         // The order of the `select` is depended on below...
@@ -447,8 +483,8 @@ where
 
     fn connect_to(
         &self,
-        req: ConnectRequest,
-    ) -> impl Lazy<Output = Result<pool::Pooled<PoolClient<B>, ConnectIdentity>, Error>>
+        descriptor: ConnectionDescriptor,
+    ) -> impl Lazy<Output = Result<pool::Pooled<PoolClient<B>, ConnectionId>, Error>>
     + Send
     + Unpin
     + 'static {
@@ -457,8 +493,8 @@ where
 
         let h1_builder = self.h1_builder.clone();
         let h2_builder = self.h2_builder.clone();
-        let ver = match req.extra().alpn_protocol() {
-            Some(AlpnProtocol::HTTP2) => Ver::Http2,
+        let ver = match descriptor.version() {
+            Some(Version::HTTP_2) => Ver::Http2,
             _ => self.config.ver,
         };
         let is_ver_h2 = ver == Ver::Http2;
@@ -469,16 +505,15 @@ where
             // If the pool_key is for HTTP/2, and there is already a
             // connection being established, then this can't take a
             // second lock. The "connect_to" future is Canceled.
-            let connecting = match pool.connecting(req.identify(), ver) {
+            let connecting = match pool.connecting(descriptor.id(), ver) {
                 Some(lock) => lock,
                 None => {
-                    let canceled = Error::new_kind(ErrorKind::Canceled);
                     // HTTP/2 connection in progress.
-                    return Either::Right(futures_util::future::err(canceled));
+                    return Either::Right(futures_util::future::err(e!(Canceled)));
                 }
             };
             Either::Left(
-                Oneshot::new(connector, req)
+                Oneshot::new(connector, descriptor)
                     .map_err(|src| Error::new(ErrorKind::Connect, src))
                     .and_then(move |io| {
                         let connected = io.connected();
@@ -629,7 +664,7 @@ where
 
 impl<C, B> tower::Service<Request<B>> for HttpClient<C, B>
 where
-    C: tower::Service<ConnectRequest> + Clone + Send + Sync + 'static,
+    C: tower::Service<ConnectionDescriptor> + Clone + Send + Sync + 'static,
     C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
     C::Error: Into<BoxError>,
     C::Future: Unpin + Send + 'static,
@@ -638,31 +673,8 @@ where
     B::Error: Into<BoxError>,
 {
     type Response = Response<Incoming>;
-    type Error = Error;
-    type Future = ResponseFuture;
-
-    fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: Request<B>) -> Self::Future {
-        self.request(req)
-    }
-}
-
-impl<C, B> tower::Service<Request<B>> for &'_ HttpClient<C, B>
-where
-    C: tower::Service<ConnectRequest> + Clone + Send + Sync + 'static,
-    C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
-    C::Error: Into<BoxError>,
-    C::Future: Unpin + Send + 'static,
-    B: Body + Send + 'static + Unpin,
-    B::Data: Send,
-    B::Error: Into<BoxError>,
-{
-    type Response = Response<Incoming>;
-    type Error = Error;
-    type Future = ResponseFuture;
+    type Error = BoxError;
+    type Future = BoxFuture<'static, Result<Response<Incoming>, Self::Error>>;
 
     fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
@@ -682,6 +694,8 @@ impl<C: Clone, B> Clone for HttpClient<C, B> {
             h2_builder: self.h2_builder.clone(),
             connector: self.connector.clone(),
             pool: self.pool.clone(),
+            #[cfg(feature = "cookies")]
+            cookie_store: self.cookie_store.clone(),
         }
     }
 }
@@ -700,40 +714,43 @@ enum PoolTx<B> {
 // ===== impl PoolClient =====
 
 impl<B> PoolClient<B> {
+    #[inline]
     fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Error>> {
         match self.tx {
             PoolTx::Http1(ref mut tx) => tx.poll_ready(cx).map_err(Error::closed),
-
             PoolTx::Http2(_) => Poll::Ready(Ok(())),
         }
     }
 
+    #[inline]
     fn is_http1(&self) -> bool {
         !self.is_http2()
     }
 
+    #[inline]
     fn is_http2(&self) -> bool {
         match self.tx {
             PoolTx::Http1(_) => false,
-
             PoolTx::Http2(_) => true,
         }
     }
 
+    #[inline]
     fn is_poisoned(&self) -> bool {
         self.conn_info.poisoned()
     }
 
+    #[inline]
     fn is_ready(&self) -> bool {
         match self.tx {
             PoolTx::Http1(ref tx) => tx.is_ready(),
-
             PoolTx::Http2(ref tx) => tx.is_ready(),
         }
     }
 }
 
 impl<B: Body + 'static> PoolClient<B> {
+    #[inline]
     fn try_send_request(
         &mut self,
         req: Request<B>,
@@ -752,6 +769,7 @@ impl<B> pool::Poolable for PoolClient<B>
 where
     B: Send + 'static,
 {
+    #[inline]
     fn is_open(&self) -> bool {
         !self.is_poisoned() && self.is_ready()
     }
@@ -777,61 +795,30 @@ where
         }
     }
 
+    #[inline]
     fn can_share(&self) -> bool {
         self.is_http2()
     }
 }
 
-/// A `Future` that will resolve to an HTTP Response.
-#[must_use = "futures do nothing unless polled"]
-pub struct ResponseFuture {
-    inner: Pin<Box<dyn Future<Output = Result<Response<Incoming>, Error>> + Send>>,
-}
-
-// ===== impl ResponseFuture =====
-
-impl ResponseFuture {
-    #[inline]
-    pub(super) fn new<F>(value: F) -> ResponseFuture
-    where
-        F: Future<Output = Result<Response<Incoming>, Error>> + Send + 'static,
-    {
-        ResponseFuture {
-            inner: Box::pin(value),
-        }
-    }
-}
-
-impl Future for ResponseFuture {
-    type Output = Result<Response<Incoming>, Error>;
-
-    #[inline]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
-        self.inner.as_mut().poll(cx)
-    }
-}
-
 /// A builder to configure a new [`HttpClient`].
 #[derive(Clone)]
 pub struct Builder {
     config: Config,
-    exec: Exec,
-
+    exec: Executor,
     h1_builder: conn::http1::Builder,
-    h2_builder: conn::http2::Builder<Exec>,
+    h2_builder: conn::http2::Builder<Executor>,
     pool_config: pool::Config,
-    pool_timer: Option<ArcTimer>,
+    pool_timer: Timer,
+    #[cfg(feature = "cookies")]
+    cookie_store: Option<Arc<dyn CookieStore>>,
 }
 
 // ===== impl Builder =====
 
 impl Builder {
     /// Construct a new Builder.
-    pub fn new<E>(executor: E) -> Self
-    where
-        E: Executor<BoxSendFuture> + Send + Sync + Clone + 'static,
-    {
-        let exec = Exec::new(executor);
+    pub fn new(exec: Executor) -> Self {
         Self {
             config: Config {
                 retry_canceled_requests: true,
@@ -839,17 +826,19 @@ impl Builder {
                 ver: Ver::Auto,
             },
             exec: exec.clone(),
-
-            h1_builder: conn::http1::Builder::new(),
+            h1_builder: conn::http1::Builder::default(),
             h2_builder: conn::http2::Builder::new(exec),
             pool_config: pool::Config {
                 idle_timeout: Some(Duration::from_secs(90)),
                 max_idle_per_host: usize::MAX,
                 max_pool_size: None,
             },
-            pool_timer: None,
+            pool_timer: Timer::default(),
+            #[cfg(feature = "cookies")]
+            cookie_store: None,
         }
     }
+
     /// Set an optional timeout for idle sockets being kept-alive.
     /// A `Timer` is required for this to take effect. See `Builder::pool_timer`
     ///
@@ -878,7 +867,7 @@ impl Builder {
     ///
     /// Default is `None` (no limit).
     #[inline]
-    pub fn pool_max_size(mut self, max_size: impl Into<Option<NonZeroU32>>) -> Self {
+    pub fn pool_max_size(mut self, max_size: impl Into<Option<NonZeroUsize>>) -> Self {
         self.pool_config.max_pool_size = max_size.into();
         self
     }
@@ -906,11 +895,8 @@ impl Builder {
     ///
     /// [`http2::client::Builder::timer`]: https://docs.rs/http2/latest/http2/client/struct.Builder.html#method.timer
     #[inline]
-    pub fn http2_timer<M>(mut self, timer: M) -> Self
-    where
-        M: Timer + Send + Sync + 'static,
-    {
-        self.h2_builder.timer(timer);
+    pub fn http2_timer(mut self, timer: Timer) -> Self {
+        self.h2_builder = self.h2_builder.timer(timer);
         self
     }
 
@@ -921,7 +907,7 @@ impl Builder {
         O: Into<Option<Http1Options>>,
     {
         if let Some(opts) = opts.into() {
-            self.h1_builder.options(opts);
+            self.h1_builder = self.h1_builder.options(opts);
         }
 
         self
@@ -934,54 +920,30 @@ impl Builder {
         O: Into<Option<Http2Options>>,
     {
         if let Some(opts) = opts.into() {
-            self.h2_builder.options(opts);
+            self.h2_builder = self.h2_builder.options(opts);
         }
         self
     }
 
     /// Provide a timer to be used for timeouts and intervals in connection pools.
     #[inline]
-    pub fn pool_timer<M>(mut self, timer: M) -> Self
-    where
-        M: Timer + Clone + Send + Sync + 'static,
-    {
-        self.pool_timer = Some(ArcTimer::new(timer));
-        self
-    }
-
-    /// Set whether to retry requests that get disrupted before ever starting
-    /// to write.
-    ///
-    /// This means a request that is queued, and gets given an idle, reused
-    /// connection, and then encounters an error immediately as the idle
-    /// connection was found to be unusable.
-    ///
-    /// When this is set to `false`, the related `ResponseFuture` would instead
-    /// resolve to an `Error::Cancel`.
-    ///
-    /// Default is `true`.
-    #[inline]
-    pub fn retry_canceled_requests(mut self, val: bool) -> Self {
-        self.config.retry_canceled_requests = val;
+    pub fn pool_timer(mut self, timer: Timer) -> Self {
+        self.pool_timer = timer;
         self
     }
 
-    /// Set whether to automatically add the `Host` header to requests.
-    ///
-    /// If true, and a request does not include a `Host` header, one will be
-    /// added automatically, derived from the authority of the `Uri`.
-    ///
-    /// Default is `true`.
+    /// Provide a cookie store for automatic cookie management.
     #[inline]
-    pub fn set_host(mut self, val: bool) -> Self {
-        self.config.set_host = val;
+    #[cfg(feature = "cookies")]
+    pub fn cookie_store(mut self, cookie_store: Option<Arc<dyn CookieStore>>) -> Self {
+        self.cookie_store = cookie_store;
         self
     }
 
     /// Combine the configuration of this builder with a connector to create a `HttpClient`.
     pub fn build<C, B>(self, connector: C) -> HttpClient<C, B>
     where
-        C: tower::Service<ConnectRequest> + Clone + Send + Sync + 'static,
+        C: tower::Service<ConnectionDescriptor> + Clone + Send + Sync + 'static,
         C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
         C::Error: Into<BoxError>,
         C::Future: Unpin + Send + 'static,
@@ -993,11 +955,195 @@ impl Builder {
         HttpClient {
             config: self.config,
             exec: exec.clone(),
-
+            connector,
             h1_builder: self.h1_builder,
             h2_builder: self.h2_builder,
-            connector,
             pool: pool::Pool::new(self.pool_config, exec, timer),
+            #[cfg(feature = "cookies")]
+            cookie_store: RequestConfig::new(self.cookie_store),
         }
     }
 }
+
+// ==== impl Error ====
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "client error ({:?})", self.kind)
+    }
+}
+
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.source.as_ref().map(|e| &**e as _)
+    }
+}
+
+impl Error {
+    fn new<E>(kind: ErrorKind, error: E) -> Self
+    where
+        E: Into<BoxError>,
+    {
+        let error = error.into();
+        let kind = if error.is::<proxy::tunnel::TunnelError>() || error.is::<ProxyConnect>() || {
+            #[cfg(feature = "socks")]
+            {
+                error.is::<proxy::socks::SocksError>()
+            }
+            #[cfg(not(feature = "socks"))]
+            {
+                false
+            }
+        } {
+            ErrorKind::ProxyConnect
+        } else {
+            kind
+        };
+
+        Self {
+            kind,
+            source: Some(error),
+            connect_info: None,
+        }
+    }
+
+    /// Returns true if this was an error from [`ErrorKind::Connect`].
+    #[inline]
+    pub fn is_connect(&self) -> bool {
+        matches!(self.kind, ErrorKind::Connect)
+    }
+
+    /// Returns true if this was an error from [`ErrorKind::ProxyConnect`].
+    #[inline]
+    pub fn is_proxy_connect(&self) -> bool {
+        matches!(self.kind, ErrorKind::ProxyConnect)
+    }
+
+    #[inline]
+    fn with_connect_info(self, connect_info: Connected) -> Self {
+        Self {
+            connect_info: Some(connect_info),
+            ..self
+        }
+    }
+
+    #[inline]
+    fn is_canceled(&self) -> bool {
+        matches!(self.kind, ErrorKind::Canceled)
+    }
+
+    #[inline]
+    fn tx(src: wreq_proto::Error) -> Self {
+        Self::new(ErrorKind::SendRequest, src)
+    }
+
+    #[inline]
+    fn closed(src: wreq_proto::Error) -> Self {
+        Self::new(ErrorKind::ChannelClosed, src)
+    }
+}
+
+fn origin_form(uri: &mut Uri) {
+    let path = match uri.path_and_query() {
+        Some(path) if path.as_str() != "/" => {
+            let mut parts = ::http::uri::Parts::default();
+            parts.path_and_query.replace(path.clone());
+            Uri::from_parts(parts).expect("path is valid uri")
+        }
+        _none_or_just_slash => {
+            debug_assert!(Uri::default() == "/");
+            Uri::default()
+        }
+    };
+    *uri = path
+}
+
+fn absolute_form(uri: &mut Uri) {
+    debug_assert!(uri.scheme().is_some(), "absolute_form needs a scheme");
+    debug_assert!(
+        uri.authority().is_some(),
+        "absolute_form needs an authority"
+    );
+}
+
+fn authority_form(uri: &mut Uri) {
+    if let Some(path) = uri.path_and_query() {
+        // `https://hyper.rs` would parse with `/` path, don't
+        // annoy people about that...
+        if path != "/" {
+            warn!("HTTP/1.1 CONNECT request stripping path: {:?}", path);
+        }
+    }
+    *uri = match uri.authority() {
+        Some(auth) => {
+            let mut parts = ::http::uri::Parts::default();
+            parts.authority = Some(auth.clone());
+            Uri::from_parts(parts).expect("authority is valid")
+        }
+        None => {
+            unreachable!("authority_form with relative uri");
+        }
+    };
+}
+
+fn normalize_uri<B>(req: &mut Request<B>, is_http_connect: bool) -> Result<Uri, Error> {
+    let uri = req.uri().clone();
+
+    let build_base_uri = |scheme: Scheme, authority: Authority| {
+        Uri::builder()
+            .scheme(scheme)
+            .authority(authority)
+            .path_and_query(PathAndQuery::from_static("/"))
+            .build()
+            .expect("valid base URI")
+    };
+
+    match (uri.scheme(), uri.authority()) {
+        (Some(scheme), Some(auth)) => Ok(build_base_uri(scheme.clone(), auth.clone())),
+        (None, Some(auth)) if is_http_connect => {
+            let scheme = match auth.port_u16() {
+                Some(443) => Scheme::HTTPS,
+                _ => Scheme::HTTP,
+            };
+            set_scheme(req.uri_mut(), scheme.clone());
+            Ok(build_base_uri(scheme, auth.clone()))
+        }
+        _ => {
+            debug!("Client requires absolute-form URIs, received: {:?}", uri);
+            Err(e!(UserAbsoluteUriRequired))
+        }
+    }
+}
+
+fn generate_host_header(uri: &Uri) -> HeaderValue {
+    let hostname = uri.host().expect("authority implies host");
+    let port = match (uri.port().map(|p| p.as_u16()), is_schema_secure(uri)) {
+        (Some(443), true) | (Some(80), false) => None,
+        _ => uri.port(),
+    };
+    if let Some(port) = port {
+        let host = format!("{hostname}:{port}");
+        HeaderValue::from_maybe_shared(Bytes::from(host))
+    } else {
+        HeaderValue::from_str(hostname)
+    }
+    .expect("uri host is valid header value")
+}
+
+fn set_scheme(uri: &mut Uri, scheme: Scheme) {
+    debug_assert!(
+        uri.scheme().is_none(),
+        "set_scheme expects no existing scheme"
+    );
+    let old = std::mem::take(uri);
+    let mut parts: ::http::uri::Parts = old.into();
+    parts.scheme = Some(scheme);
+    parts.path_and_query = Some(PathAndQuery::from_static("/"));
+    *uri = Uri::from_parts(parts).expect("scheme is valid");
+}
+
+fn is_schema_secure(uri: &Uri) -> bool {
+    uri.scheme_str()
+        .map(|scheme_str| matches!(scheme_str, "wss" | "https"))
+        .unwrap_or_default()
+}