use std::error::Error as StdError;
use std::fmt;
use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use http::header::{CONTENT_TYPE, USER_AGENT};
use http_body_util::{BodyExt, Full, Limited};
use hyper::Request;
use hyper_rustls::{ConfigBuilderExt, HttpsConnector};
use hyper_util::client::legacy::Client;
use hyper_util::client::legacy::connect::HttpConnector;
use hyper_util::client::legacy::connect::proxy::Tunnel;
use hyper_util::rt::TokioExecutor;
use crate::http::proxy::{ProxyConfigError, ProxySetup};
use crate::http::transport::{
HttpMethod, RawRequest, RawResponse, Transport, TransportError, TransportErrorKind,
};
const MAX_RESPONSE_BYTES: usize = 10 * 1024 * 1024;
type DirectClient = Client<HttpsConnector<HttpConnector>, Full<Bytes>>;
type ProxiedClient = Client<HttpsConnector<Tunnel<HttpConnector>>, Full<Bytes>>;
enum Backend {
Direct(DirectClient),
Proxied(ProxiedClient),
Misconfigured(ProxyConfigError),
}
pub(crate) struct HyperTransport {
backend: Backend,
proxy: Option<Box<str>>,
timeout: Duration,
user_agent: &'static str,
}
impl fmt::Debug for HyperTransport {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let proxy: &dyn fmt::Debug = match (&self.backend, &self.proxy) {
(Backend::Misconfigured(_), _) => &"<invalid>",
(_, Some(host_port)) => host_port,
(_, None) => &Option::<&str>::None,
};
f.debug_struct("HyperTransport")
.field("timeout", &self.timeout)
.field("user_agent", &self.user_agent)
.field("proxy", proxy)
.finish_non_exhaustive()
}
}
fn tls_config() -> rustls::ClientConfig {
rustls::ClientConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
.with_safe_default_protocol_versions()
.expect("the ring provider supports rustls' default protocol versions")
.with_webpki_roots()
.with_no_client_auth()
}
impl HyperTransport {
pub(crate) fn new(timeout: Duration, user_agent: &'static str, proxy: ProxySetup) -> Self {
let (backend, proxy_display) = match proxy {
ProxySetup::Direct => {
let https = hyper_rustls::HttpsConnectorBuilder::new()
.with_tls_config(tls_config())
.https_or_http()
.enable_http1()
.build();
(
Backend::Direct(Client::builder(TokioExecutor::new()).build(https)),
None,
)
}
ProxySetup::Tunnel { uri, auth, display } => {
let mut tunnel = Tunnel::new(uri, HttpConnector::new());
if let Some(auth) = auth {
tunnel = tunnel.with_auth(auth);
}
let https = hyper_rustls::HttpsConnectorBuilder::new()
.with_tls_config(tls_config())
.https_or_http()
.enable_http1()
.wrap_connector(tunnel);
(
Backend::Proxied(Client::builder(TokioExecutor::new()).build(https)),
Some(display),
)
}
ProxySetup::Invalid(err) => (Backend::Misconfigured(err), None),
};
Self {
backend,
proxy: proxy_display,
timeout,
user_agent,
}
}
fn build(&self, req: &RawRequest<'_>) -> Result<Request<Full<Bytes>>, TransportError> {
let url = append_query(req.url, req.query);
let mut builder = Request::builder()
.method(method_of(req.method))
.uri(url)
.header(USER_AGENT, self.user_agent);
for (k, v) in req.headers {
builder = builder.header(*k, *v);
}
let body = match req.body {
Some(bytes) => {
builder = builder.header(CONTENT_TYPE, "application/json");
Full::new(Bytes::copy_from_slice(bytes))
}
None => Full::new(Bytes::new()),
};
builder.body(body).map_err(|e| TransportError {
kind: TransportErrorKind::Request,
source: Box::new(e),
})
}
}
fn method_of(m: HttpMethod) -> http::Method {
match m {
HttpMethod::Get => http::Method::GET,
HttpMethod::Post => http::Method::POST,
HttpMethod::Put => http::Method::PUT,
HttpMethod::Delete => http::Method::DELETE,
}
}
fn encode_form_component(s: &str, out: &mut String) {
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'*' | b'-' | b'.' | b'_' => {
out.push(b as char);
}
b' ' => out.push('+'),
_ => out.push_str(&format!("%{b:02X}")),
}
}
}
fn append_query(url: &str, query: &[(&str, String)]) -> String {
if query.is_empty() {
return url.to_string();
}
let mut out = String::with_capacity(url.len() + query.len() * 16);
out.push_str(url);
out.push(if url.contains('?') { '&' } else { '?' });
for (i, (k, v)) in query.iter().enumerate() {
if i > 0 {
out.push('&');
}
encode_form_component(k, &mut out);
out.push('=');
encode_form_component(v, &mut out);
}
out
}
#[derive(Debug)]
struct ResponseTooLarge {
limit: usize,
}
impl fmt::Display for ResponseTooLarge {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"response body exceeded the {}-byte client-side limit",
self.limit
)
}
}
impl StdError for ResponseTooLarge {}
fn hyper_error_of<'a>(err: &'a (dyn StdError + 'static)) -> Option<&'a hyper::Error> {
let mut cursor = err.source();
while let Some(e) = cursor {
if let Some(h) = e.downcast_ref::<hyper::Error>() {
return Some(h);
}
cursor = e.source();
}
None
}
fn classify(err: &hyper_util::client::legacy::Error) -> TransportErrorKind {
if err.is_connect() {
return TransportErrorKind::Connect;
}
if let Some(h) = hyper_error_of(err) {
if h.is_timeout() {
return TransportErrorKind::Timeout;
}
if h.is_parse() || h.is_incomplete_message() || h.is_canceled() || h.is_closed() {
return TransportErrorKind::Request;
}
}
TransportErrorKind::Other
}
impl Transport for HyperTransport {
fn execute<'a>(
&'a self,
req: RawRequest<'a>,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<RawResponse, TransportError>> + Send + 'a>,
> {
if let Backend::Misconfigured(err) = &self.backend {
let err = err.clone();
return Box::pin(async move {
Err(TransportError {
kind: TransportErrorKind::Other,
source: Box::new(err),
})
});
}
let built = self.build(&req);
Box::pin(async move {
let built = built?;
let exchange = async {
let sent = match &self.backend {
Backend::Direct(client) => client.request(built).await,
Backend::Proxied(client) => client.request(built).await,
Backend::Misconfigured(err) => {
return Err(TransportError {
kind: TransportErrorKind::Other,
source: Box::new(err.clone()),
});
}
};
let resp = sent.map_err(|e| TransportError {
kind: classify(&e),
source: Box::new(e),
})?;
let status = resp.status().as_u16();
let headers = resp
.headers()
.iter()
.filter_map(|(k, v)| v.to_str().ok().map(|v| (k.as_str().into(), v.into())))
.collect();
let limited = Limited::new(resp.into_body(), MAX_RESPONSE_BYTES);
let body = match limited.collect().await {
Ok(collected) => collected.to_bytes().to_vec(),
Err(e)
if e.downcast_ref::<http_body_util::LengthLimitError>()
.is_some() =>
{
return Err(TransportError {
kind: TransportErrorKind::Body,
source: Box::new(ResponseTooLarge {
limit: MAX_RESPONSE_BYTES,
}),
});
}
Err(e) if (200..300).contains(&status) => {
return Err(TransportError {
kind: TransportErrorKind::Body,
source: e,
});
}
Err(_) => Vec::new(),
};
Ok(RawResponse::new(status, headers, body))
};
match tokio::time::timeout(self.timeout, exchange).await {
Ok(result) => result,
Err(elapsed) => Err(TransportError {
kind: TransportErrorKind::Timeout,
source: Box::new(elapsed),
}),
}
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::proxy::{ProxyMode, resolve};
fn direct_transport() -> HyperTransport {
HyperTransport::new(
Duration::from_secs(1),
"delopay-rust/test",
ProxySetup::Direct,
)
}
fn encode(s: &str) -> String {
let mut out = String::new();
encode_form_component(s, &mut out);
out
}
#[test]
fn form_encoding_passes_unreserved_bytes() {
assert_eq!(encode("abcXYZ019*-._"), "abcXYZ019*-._");
}
#[test]
fn form_encoding_writes_space_as_plus() {
assert_eq!(encode("a b"), "a+b");
}
#[test]
fn form_encoding_escapes_separators_and_plus() {
assert_eq!(encode("a&b"), "a%26b");
assert_eq!(encode("a=b"), "a%3Db");
assert_eq!(encode("a+b"), "a%2Bb");
}
#[test]
fn form_encoding_escapes_non_ascii_as_utf8_bytes() {
assert_eq!(encode("é"), "%C3%A9");
assert_eq!(encode("日"), "%E6%97%A5");
}
#[test]
fn form_encoding_escapes_tilde_unlike_path_segments() {
assert_eq!(encode("~"), "%7E");
assert_eq!(crate::core::encoding::encode_segment("~"), "~");
}
#[test]
fn append_query_leaves_url_untouched_when_empty() {
assert_eq!(
append_query("https://api.test/payments", &[]),
"https://api.test/payments"
);
}
#[test]
fn append_query_joins_pairs_with_ampersands() {
assert_eq!(
append_query(
"https://api.test/payments/list",
&[("limit", "10".to_string()), ("status", "succeeded".into())],
),
"https://api.test/payments/list?limit=10&status=succeeded"
);
}
#[test]
fn append_query_extends_an_existing_query_string() {
assert_eq!(
append_query("https://api.test/x?a=1", &[("b", "2".to_string())]),
"https://api.test/x?a=1&b=2"
);
}
#[test]
fn append_query_encodes_keys_and_values() {
assert_eq!(
append_query(
"https://api.test/x",
&[("a key", "a&b=c".to_string()), ("é", "d e".into())],
),
"https://api.test/x?a+key=a%26b%3Dc&%C3%A9=d+e"
);
}
#[test]
fn built_request_carries_user_agent_and_no_content_type_without_a_body() {
let transport = direct_transport();
let headers = [("api-key", "prd_x")];
let req = transport
.build(&RawRequest {
method: HttpMethod::Get,
url: "https://api.test/payments",
headers: &headers,
query: &[],
body: None,
})
.unwrap();
assert_eq!(req.method(), http::Method::GET);
assert_eq!(req.uri(), "https://api.test/payments");
assert_eq!(req.headers()[USER_AGENT], "delopay-rust/test");
assert_eq!(req.headers()["api-key"], "prd_x");
assert!(
!req.headers().contains_key(CONTENT_TYPE),
"a body-less request must not claim a JSON content type"
);
}
#[test]
fn built_request_with_a_body_sets_json_content_type_and_query() {
let transport = direct_transport();
let req = transport
.build(&RawRequest {
method: HttpMethod::Post,
url: "https://api.test/payments",
headers: &[],
query: &[("limit", "10".to_string())],
body: Some(b"{\"amount\":1999}"),
})
.unwrap();
assert_eq!(req.method(), http::Method::POST);
assert_eq!(req.uri(), "https://api.test/payments?limit=10");
assert_eq!(req.headers()[CONTENT_TYPE], "application/json");
}
#[test]
fn built_request_maps_put_to_the_put_verb() {
let transport = direct_transport();
let req = transport
.build(&RawRequest {
method: HttpMethod::Put,
url: "https://api.test/payouts/po_1",
headers: &[],
query: &[],
body: Some(b"{}"),
})
.unwrap();
assert_eq!(req.method(), http::Method::PUT);
}
#[test]
fn a_malformed_url_is_a_request_error_not_a_panic() {
let transport = direct_transport();
let err = transport
.build(&RawRequest {
method: HttpMethod::Get,
url: "not a url",
headers: &[],
query: &[],
body: None,
})
.unwrap_err();
assert_eq!(err.kind, TransportErrorKind::Request);
assert!(
err.is_retriable(),
"`Request` stays retriable, matching how reqwest classified it"
);
}
#[test]
fn response_too_large_error_names_the_limit() {
let err = ResponseTooLarge {
limit: MAX_RESPONSE_BYTES,
};
assert!(err.to_string().contains(&MAX_RESPONSE_BYTES.to_string()));
}
fn proxied_transport(proxy_url: &str) -> HyperTransport {
HyperTransport::new(
Duration::from_secs(1),
"delopay-rust/test",
resolve(
&ProxyMode::Explicit(proxy_url.to_string()),
"https://api.delopay.net",
),
)
}
#[test]
fn transport_debug_never_reveals_proxy_credentials() {
let transport = proxied_transport("http://alice:hunter2@corp-egress:3128");
let formatted = format!("{transport:?}");
assert!(
!formatted.contains("hunter2"),
"Debug output must not contain the proxy password: {formatted}"
);
assert!(
!formatted.contains("alice"),
"Debug output must not contain the proxy username: {formatted}"
);
assert!(
!formatted.contains("YWxpY2U6aHVudGVyMg=="),
"Debug output must not contain the Proxy-Authorization value: {formatted}"
);
assert!(
formatted.contains("corp-egress:3128"),
"the proxy host and port stay visible, so operators can see where \
traffic is going: {formatted}"
);
}
#[test]
fn transport_debug_reports_no_proxy_when_direct() {
let formatted = format!("{:?}", direct_transport());
assert!(
formatted.contains("proxy: None"),
"a direct transport must say so: {formatted}"
);
}
#[tokio::test]
async fn a_misconfigured_proxy_fails_every_request_instead_of_going_direct() {
let transport = HyperTransport::new(
Duration::from_secs(1),
"delopay-rust/test",
resolve(
&ProxyMode::Explicit("socks5://corp-egress:1080".into()),
"https://api.delopay.net",
),
);
let err = transport
.execute(RawRequest {
method: HttpMethod::Get,
url: "https://api.delopay.net/payments",
headers: &[],
query: &[],
body: None,
})
.await
.expect_err("a request through an unusable proxy must not succeed");
assert_eq!(err.kind, TransportErrorKind::Other);
assert!(
!err.is_retriable(),
"a configuration error will not fix itself between attempts"
);
assert!(err.source.to_string().contains("proxy"));
}
#[test]
fn a_misconfigured_proxy_is_visible_in_debug_without_leaking_the_url() {
let transport = HyperTransport::new(
Duration::from_secs(1),
"delopay-rust/test",
resolve(
&ProxyMode::Explicit("socks5://alice:hunter2@corp-egress:1080".into()),
"https://api.delopay.net",
),
);
let formatted = format!("{transport:?}");
assert!(formatted.contains("<invalid>"), "{formatted}");
assert!(!formatted.contains("hunter2"), "{formatted}");
}
}