tez 0.0.2

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
use std::{
    io,
    panic::AssertUnwindSafe,
    sync::Mutex,
    task::{Context, Poll},
    time::Duration,
};

use crate::{
    Body, Error, Request, Response, Result,
    body::Kind,
    proxy::{Kind as ProxyKind, Policy as ProxyPolicy},
    redirect::{self, Decision, Policy},
};
use futures_util::FutureExt as _;

pub(crate) struct BackendConfig {
    decompresses_responses: bool,
    cookie_jar: bool,
    redirects: Policy,
    proxy: ProxyPolicy,
    tls: TlsPolicy,
}

#[derive(Default)]
pub(crate) struct TlsPolicy {
    root_certificates_pem: Option<Vec<u8>>,
    client_identity_pem: Option<Vec<u8>>,
    https_only: bool,
}

impl BackendConfig {
    pub(crate) const fn new(
        decompresses_responses: bool,
        cookie_jar: bool,
        redirects: Policy,
        proxy: ProxyPolicy,
        tls: TlsPolicy,
    ) -> Self {
        Self {
            decompresses_responses,
            cookie_jar,
            redirects,
            proxy,
            tls,
        }
    }
}

impl TlsPolicy {
    pub(crate) fn set_root_certificates_pem(&mut self, pem: &[u8]) {
        self.root_certificates_pem = Some(pem.to_vec());
    }

    pub(crate) fn set_client_identity_pem(&mut self, pem: &[u8]) {
        self.client_identity_pem = Some(pem.to_vec());
    }

    pub(crate) const fn enable_https_only(&mut self) {
        self.https_only = true;
    }

    pub(crate) const fn has_custom_roots(&self) -> bool {
        self.root_certificates_pem.is_some()
    }

    pub(crate) const fn has_client_identity(&self) -> bool {
        self.client_identity_pem.is_some()
    }

    pub(crate) const fn is_https_only(&self) -> bool {
        self.https_only
    }
}

pub(crate) struct Backend {
    client: reqwest::Client,
}

impl Backend {
    pub(crate) fn new(config: BackendConfig) -> Result<Self> {
        let BackendConfig {
            decompresses_responses,
            cookie_jar,
            redirects,
            proxy,
            tls,
        } = config;
        let roots = tls
            .root_certificates_pem
            .as_deref()
            .map(parse_root_certificates)
            .transpose()?;
        let identity = tls
            .client_identity_pem
            .as_deref()
            .map(parse_client_identity)
            .transpose()?;
        let https_only = tls.https_only;
        let (proxy, system_proxy) = match proxy.into_kind() {
            ProxyKind::Direct => (None, false),
            ProxyKind::All(url) => (Some(all_proxy(&url)?), false),
            #[cfg(feature = "system-proxy")]
            ProxyKind::System => (None, true),
        };

        // Reqwest can panic outside a compatible runtime. Normalize that
        // backend detail into Tez's documented runtime error.
        let client = std::panic::catch_unwind(AssertUnwindSafe(move || {
            let builder = reqwest::Client::builder()
                .tls_backend_rustls()
                .no_hickory_dns()
                .https_only(https_only)
                .referer(false)
                .redirect(reqwest_redirect_policy(redirects, https_only));
            let builder = match roots {
                Some(roots) => builder.tls_certs_only(roots),
                None => builder,
            };
            let builder = match identity {
                Some(identity) => builder.identity(identity),
                None => builder,
            };
            let builder = match proxy {
                Some(proxy) => builder.proxy(proxy),
                None if system_proxy => builder,
                None => builder.no_proxy(),
            };
            let builder = configure_decompression(builder, decompresses_responses);
            #[cfg(feature = "cookies")]
            let builder = builder.cookie_store(cookie_jar);
            #[cfg(not(feature = "cookies"))]
            let _ = cookie_jar;
            builder.build()
        }))
        .map_err(|_| Error::runtime())?
        .map_err(|_| Error::request("client HTTP configuration is invalid"))?;
        Ok(Self { client })
    }

    pub(crate) async fn execute(
        &self,
        request: Request,
        timeout: Option<Duration>,
    ) -> Result<Response> {
        let request = into_reqwest_request(request, timeout)?;
        // Sending can trigger the same runtime check. Keep it behind Tez's
        // stable error instead of exposing a reqwest panic.
        let response = AssertUnwindSafe(async { self.client.execute(request).await })
            .catch_unwind()
            .await
            .map_err(|_| Error::runtime())?
            .map_err(map_reqwest_error)?;
        into_response(response)
    }
}

fn configure_decompression(
    builder: reqwest::ClientBuilder,
    enabled: bool,
) -> reqwest::ClientBuilder {
    let _ = enabled;

    // Disable every backend codec first so dependency feature unification
    // cannot silently expand Tez's advertised or accepted encodings.
    let builder = builder.no_gzip().no_brotli().no_deflate().no_zstd();

    #[cfg(feature = "gzip")]
    let builder = builder.gzip(enabled);
    #[cfg(feature = "brotli")]
    let builder = builder.brotli(enabled);
    #[cfg(feature = "deflate")]
    let builder = builder.deflate(enabled);
    #[cfg(feature = "zstd")]
    let builder = builder.zstd(enabled);

    builder
}

fn parse_root_certificates(pem: &[u8]) -> Result<Vec<reqwest::Certificate>> {
    let certificates = reqwest::Certificate::from_pem_bundle(pem)
        .map_err(|_| Error::request("client TLS root certificates are invalid"))?;
    if certificates.is_empty() {
        return Err(Error::request("client TLS root certificates are invalid"));
    }
    Ok(certificates)
}

fn parse_client_identity(pem: &[u8]) -> Result<reqwest::Identity> {
    reqwest::Identity::from_pem(pem).map_err(|_| Error::request("client TLS identity is invalid"))
}

fn all_proxy(value: &str) -> Result<reqwest::Proxy> {
    let url = url::Url::parse(value).map_err(|_| Error::request("client proxy URL is invalid"))?;
    if !matches!(url.scheme(), "http" | "https")
        || url.host_str().is_none()
        || url.path() != "/"
        || url.query().is_some()
        || url.fragment().is_some()
    {
        return Err(Error::request("client proxy URL is invalid"));
    }
    reqwest::Proxy::all(url).map_err(|_| Error::request("client proxy URL is invalid"))
}

fn reqwest_redirect_policy(policy: Policy, https_only: bool) -> reqwest::redirect::Policy {
    match policy {
        Policy::NoFollow => return reqwest::redirect::Policy::none(),
        Policy::SameOrigin => {}
    }

    reqwest::redirect::Policy::custom(move |attempt| {
        let Some(previous) = attempt.previous().last() else {
            return attempt.error(io::Error::other("redirect has no preceding request URL"));
        };
        match redirect::decide(
            policy,
            https_only,
            previous,
            attempt.url(),
            attempt.previous().len(),
        ) {
            Decision::Follow => attempt.follow(),
            Decision::Return => attempt.stop(),
            Decision::Error => attempt.error(io::Error::other("redirect was rejected")),
        }
    })
}

fn into_reqwest_request(request: Request, timeout: Option<Duration>) -> Result<reqwest::Request> {
    let (parts, body) = request.into_parts();
    if parts.version == http::Version::HTTP_3 {
        return Err(Error::request("HTTP/3 requests are unsupported"));
    }
    let url = url::Url::parse(&parts.uri.to_string())
        .map_err(|_| Error::request("prepared request URL is invalid"))?;
    let mut request = reqwest::Request::new(parts.method, url);
    *request.headers_mut() = parts.headers;
    *request.version_mut() = parts.version;
    *request.body_mut() = into_reqwest_body(body);
    *request.timeout_mut() = timeout;
    Ok(request)
}

pub(crate) fn into_reqwest_body(body: Body) -> Option<reqwest::Body> {
    match body.into_kind() {
        Kind::Empty => None,
        Kind::Buffered(Some(bytes)) => Some(reqwest::Body::from(bytes)),
        Kind::Buffered(None) => Some(reqwest::Body::from(bytes::Bytes::new())),
        Kind::Streaming(body) => Some(reqwest::Body::wrap(SyncBody {
            body: Mutex::new(Body::from_kind(Kind::Streaming(body))),
        })),
    }
}

fn into_response(response: reqwest::Response) -> Result<Response> {
    let url = response
        .url()
        .as_str()
        .parse()
        .map_err(|_| Error::request("response URL is invalid"))?;
    let content_length = response.content_length();
    let remote_addr = response.remote_addr();
    let response: http::Response<reqwest::Body> = response.into();
    let (parts, body) = response.into_parts();
    Ok(Response::new(
        parts.status,
        parts.version,
        parts.headers,
        Body::from_http_body(body, map_reqwest_error),
        url,
        content_length,
        remote_addr,
    ))
}

fn map_reqwest_error(error: reqwest::Error) -> Error {
    if error.is_timeout() {
        Error::timeout()
    } else if error.is_redirect() {
        Error::redirect()
    } else if error.is_connect() {
        Error::connect()
    } else if error.is_decode() {
        Error::decode("HTTP response could not be decoded")
    } else {
        Error::body()
    }
}

struct SyncBody {
    // Reqwest requires a Sync stream, while Tez accepts the less restrictive
    // standard Send body contract. This private mutex serializes polls of one
    // one-shot body.
    body: Mutex<Body>,
}

impl http_body::Body for SyncBody {
    type Data = bytes::Bytes;
    type Error = Error;

    fn poll_frame(
        self: std::pin::Pin<&mut Self>,
        context: &mut Context<'_>,
    ) -> Poll<Option<std::result::Result<http_body::Frame<Self::Data>, Self::Error>>> {
        let mut body = self.body.lock().map_err(|_| Error::body());
        match body {
            Ok(ref mut body) => std::pin::Pin::new(&mut **body).poll_frame(context),
            Err(error) => Poll::Ready(Some(Err(error))),
        }
    }

    fn is_end_stream(&self) -> bool {
        self.body
            .lock()
            .map(|body| body.is_end_stream())
            .unwrap_or(true)
    }

    fn size_hint(&self) -> http_body::SizeHint {
        self.body
            .lock()
            .map(|body| body.size_hint())
            .unwrap_or_default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn raw_http_three_requests_are_rejected_before_transport() {
        let request = http::Request::builder()
            .uri("https://example.com")
            .version(http::Version::HTTP_3)
            .body(Body::empty())
            .unwrap();

        let error = into_reqwest_request(request, None).unwrap_err();

        assert!(error.is_request());
        assert_eq!(error.to_string(), "HTTP/3 requests are unsupported");
    }
}