use std::{
fmt,
future::Future,
pin::Pin,
sync::{Arc, Mutex},
task::{Context, Poll},
time::Duration,
};
use bytes::Bytes;
use http::{
HeaderMap, HeaderName, HeaderValue, Version,
header::{TRAILER, TRANSFER_ENCODING},
};
use http_body::Body as _;
use http_body::{Frame, SizeHint};
use crate::{
Body, BodyChunk, BodyFrame, BodySource, Error, ErrorKind, Proxy, Request, Response, Result, Tls,
};
#[cfg(feature = "rustls")]
use crate::{Certificate, TlsVersion, tls::CertificateEncoding};
pub(crate) type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
pub(crate) trait Transport: Send + Sync + 'static {
fn send(&self, request: Request) -> BoxFuture<'_, Result<Response>>;
}
impl<T> Transport for Arc<T>
where
T: Transport + ?Sized,
{
fn send(&self, request: Request) -> BoxFuture<'_, Result<Response>> {
(**self).send(request)
}
}
#[derive(Clone)]
pub(crate) struct ReqwestTransport {
client: reqwest::Client,
}
pub(crate) struct ReqwestConfig {
pub(crate) proxies: Vec<Proxy>,
pub(crate) connect_timeout: Duration,
pub(crate) read_timeout: Duration,
pub(crate) tls: Tls,
}
impl ReqwestTransport {
pub(crate) fn new(config: ReqwestConfig) -> Result<Self> {
let mut builder = reqwest::Client::builder()
.redirect(reqwest::redirect::Policy::none())
.referer(false)
.retry(reqwest::retry::never())
.connect_timeout(config.connect_timeout)
.read_timeout(config.read_timeout)
.no_proxy();
#[cfg(not(feature = "gzip"))]
{
builder = builder.no_gzip();
}
#[cfg(not(feature = "brotli"))]
{
builder = builder.no_brotli();
}
#[cfg(not(feature = "deflate"))]
{
builder = builder.no_deflate();
}
#[cfg(not(feature = "zstd"))]
{
builder = builder.no_zstd();
}
#[cfg(not(feature = "http2"))]
{
builder = builder.http1_only();
}
#[cfg(feature = "rustls")]
{
let roots = config
.tls
.roots
.iter()
.map(to_reqwest_certificate)
.collect::<Result<Vec<_>>>()?;
builder = builder
.tls_backend_rustls()
.tls_certs_merge(roots)
.https_only(config.tls.https_only)
.tls_version_min(match config.tls.minimum_version {
TlsVersion::Tls12 => reqwest::tls::Version::TLS_1_2,
TlsVersion::Tls13 => reqwest::tls::Version::TLS_1_3,
});
if let Some(identity) = config.tls.identity {
let identity = reqwest::Identity::from_pem(identity.pem.as_slice())
.map_err(|_| Error::new(ErrorKind::Tls, "invalid PEM client identity"))?;
builder = builder.identity(identity);
}
}
#[cfg(not(feature = "rustls"))]
if !config.tls.is_default() {
return Err(Error::new(
ErrorKind::Tls,
"custom TLS configuration requires the rustls feature",
));
}
for proxy in config.proxies {
for proxy in proxy.into_reqwest()? {
builder = builder.proxy(proxy);
}
}
let client = builder.build().map_err(Error::from_reqwest)?;
Ok(Self { client })
}
}
#[cfg(feature = "rustls")]
fn to_reqwest_certificate(certificate: &Certificate) -> Result<reqwest::Certificate> {
match certificate.encoding {
CertificateEncoding::Pem => reqwest::Certificate::from_pem(&certificate.bytes),
CertificateEncoding::Der => reqwest::Certificate::from_der(&certificate.bytes),
}
.map_err(|_| Error::new(ErrorKind::Tls, "invalid custom TLS root certificate"))
}
impl Transport for ReqwestTransport {
fn send(&self, request: Request) -> BoxFuture<'_, Result<Response>> {
Box::pin(async move {
#[cfg(not(feature = "rustls"))]
if request.url().scheme() == "https" {
return Err(Error::new(
ErrorKind::Tls,
"the default transport requires the rustls feature for HTTPS",
));
}
let (method, url, mut headers, body, timeout) = request.into_parts();
let declared_trailers = body.trailer_names();
if !body.is_absent() && (body.len().is_none() || body.may_have_trailers()) {
headers.insert(TRANSFER_ENCODING, HeaderValue::from_static("chunked"));
}
let mut builder = self.client.request(method, url.clone()).headers(headers);
if !body.is_absent() {
builder = builder.body(reqwest::Body::wrap(OutgoingBody {
body: Mutex::new(body),
declared_trailers,
}));
}
if let Some(timeout) = timeout {
builder = builder.timeout(timeout);
}
let response = builder.send().await.map_err(Error::from_reqwest)?;
let status = response.status();
let version = response.version();
let headers = response.headers().clone();
let effective_url = response.url().clone();
let remote_addr = response.remote_addr();
let trailer_names = declared_trailer_names(&headers);
let response: http::Response<reqwest::Body> = response.into();
let (_, body) = response.into_parts();
let may_have_trailers = !trailer_names.is_empty()
|| matches!(version, Version::HTTP_2 | Version::HTTP_3)
|| body.size_hint().exact().is_none();
let mut response = Response::builder()
.status(status)
.version(version)
.headers(headers)
.effective_url(effective_url)
.body(Body::from_source(IncomingBody {
body,
may_have_trailers,
trailer_names,
}));
if let Some(remote_addr) = remote_addr {
response = response.remote_addr(remote_addr);
}
response.build()
})
}
}
impl fmt::Debug for ReqwestTransport {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("DefaultTransport")
.finish_non_exhaustive()
}
}
struct IncomingBody {
body: reqwest::Body,
may_have_trailers: bool,
trailer_names: Vec<HeaderName>,
}
struct OutgoingBody {
body: Mutex<Body>,
declared_trailers: Vec<HeaderName>,
}
impl http_body::Body for OutgoingBody {
type Data = Bytes;
type Error = Error;
fn poll_frame(
mut self: Pin<&mut Self>,
context: &mut Context<'_>,
) -> Poll<Option<Result<Frame<Self::Data>>>> {
let body = self
.body
.get_mut()
.unwrap_or_else(std::sync::PoisonError::into_inner);
match BodySource::poll_frame(Pin::new(body), context) {
Poll::Ready(Ok(Some(BodyFrame::Data(chunk)))) => {
Poll::Ready(Some(Ok(Frame::data(chunk.into_shared()))))
}
Poll::Ready(Ok(Some(BodyFrame::Trailers(trailers)))) => {
if self.declared_trailers.is_empty()
|| trailers
.keys()
.any(|name| !self.declared_trailers.contains(name))
|| trailers
.keys()
.any(|name| trailers.get_all(name).iter().count() > 1)
{
Poll::Ready(Some(Err(Error::new(
ErrorKind::BodyIo,
"outgoing trailers were undeclared or used repeated field values unsupported by HTTP/1",
))))
} else {
Poll::Ready(Some(Ok(Frame::trailers(trailers))))
}
}
Poll::Ready(Ok(None)) => Poll::Ready(None),
Poll::Ready(Err(error)) => Poll::Ready(Some(Err(error))),
Poll::Pending => Poll::Pending,
}
}
fn size_hint(&self) -> SizeHint {
let mut hint = SizeHint::new();
let body = self
.body
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if !body.may_have_trailers()
&& let Some(length) = body.len()
{
hint.set_exact(length);
}
hint
}
}
impl BodySource for IncomingBody {
fn poll_frame(
mut self: Pin<&mut Self>,
context: &mut Context<'_>,
) -> Poll<Result<Option<BodyFrame>>> {
loop {
let frame = match Pin::new(&mut self.body).poll_frame(context) {
Poll::Ready(Some(Ok(frame))) => frame,
Poll::Ready(Some(Err(error))) => {
return Poll::Ready(Err(Error::from_reqwest(error)));
}
Poll::Ready(None) => return Poll::Ready(Ok(None)),
Poll::Pending => return Poll::Pending,
};
let frame = match frame.into_data() {
Ok(data) => {
return Poll::Ready(Ok(Some(BodyFrame::Data(BodyChunk::from_shared(data)))));
}
Err(frame) => frame,
};
if let Ok(trailers) = frame.into_trailers() {
return Poll::Ready(Ok(Some(BodyFrame::Trailers(trailers))));
}
}
}
fn len(&self) -> Option<u64> {
self.body.size_hint().exact()
}
fn may_have_trailers(&self) -> bool {
self.may_have_trailers
}
fn trailer_names(&self) -> Vec<HeaderName> {
self.trailer_names.clone()
}
}
fn declared_trailer_names(headers: &HeaderMap) -> Vec<HeaderName> {
let mut names = Vec::new();
for value in headers.get_all(TRAILER) {
let Ok(value) = value.to_str() else {
continue;
};
for name in value
.split(',')
.map(str::trim)
.filter(|name| !name.is_empty())
{
let Ok(name) = HeaderName::from_bytes(name.as_bytes()) else {
continue;
};
if !names.contains(&name) {
names.push(name);
}
}
}
names
}
#[cfg(test)]
mod describe_transport {
use super::*;
#[test]
fn it_default_transport_debug_hides_backend_identity() {
let transport = ReqwestTransport::new(ReqwestConfig {
proxies: Vec::new(),
connect_timeout: Duration::from_secs(10),
read_timeout: Duration::from_secs(30),
tls: Tls::default(),
})
.unwrap();
assert_eq!(
format!("{transport:?}").split_whitespace().next(),
Some("DefaultTransport")
);
}
#[cfg(not(feature = "rustls"))]
#[tokio::test]
async fn it_default_transport_rejects_https_without_rustls() {
let transport = ReqwestTransport::new(ReqwestConfig {
proxies: Vec::new(),
connect_timeout: Duration::from_secs(10),
read_timeout: Duration::from_secs(30),
tls: Tls::default(),
})
.unwrap();
let request = Request::get("https://example.com").build().unwrap();
let error = transport.send(request).await.unwrap_err();
assert_eq!(error.kind(), ErrorKind::Tls);
}
}