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),
};
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)?;
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;
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 {
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");
}
}