use std::sync::Arc;
use std::time::Duration;
use bytes::Bytes;
use crate::body::{RequestBody, ResponseBody};
use crate::client::{Client, ClientInner};
use crate::error::{Error, Result};
use crate::headers::Headers;
use crate::pool::{OriginKey, PoolGuard};
#[cfg(feature = "proxy")]
use crate::proxy::{Proxy, ProxyConfig};
use crate::redirect;
#[cfg(feature = "proxy")]
use crate::request::ProxyOverride;
use crate::request::Request;
use crate::response::{HistoryEntry, Response};
use crate::retry::{should_retry, RetryCause, RetryPolicy};
use crate::stream::{read_timeout_stream, write_timeout_stream};
use crate::timeout::{Timeout, TimeoutPhase};
#[cfg(feature = "proxy")]
use crate::transport::proxy::send_proxy_request;
async fn sleep_if_budget_allows(
policy: &RetryPolicy,
delay: Duration,
attempt: usize,
start_time: std::time::Instant,
) -> Result<()> {
if let Some(max_elapsed) = policy.max_elapsed() {
let elapsed = start_time.elapsed();
if elapsed + delay > max_elapsed {
return Err(Error::RetryBudgetExhausted { attempts: attempt });
}
}
tokio::time::sleep(delay).await;
Ok(())
}
async fn send_with_total_timeout<F>(
send_future: F,
remaining_total: Option<Duration>,
) -> Result<Response>
where
F: std::future::Future<Output = Result<Response>>,
{
match remaining_total {
Some(duration) => {
let started = std::time::Instant::now();
tokio::time::timeout(duration, send_future)
.await
.map_err(|_| Error::Timeout {
phase: TimeoutPhase::Total,
elapsed: started.elapsed(),
})?
}
None => send_future.await,
}
}
const DRAIN_MAX_BYTES: usize = 256 * 1024;
const DRAIN_MAX_TIME: Duration = Duration::from_secs(30);
async fn drain_response_body(response: &mut Response) {
let Ok(stream) = response.raw_bytes_stream() else {
return; };
let mut remaining = DRAIN_MAX_BYTES;
let mut stream = std::pin::pin!(stream);
let drain = async {
while let Some(chunk) = futures_util::StreamExt::next(&mut stream).await {
match chunk {
Ok(bytes) => {
if bytes.len() >= remaining {
break;
}
remaining -= bytes.len();
}
Err(_) => break,
}
}
};
let _ = tokio::time::timeout(DRAIN_MAX_TIME, drain).await;
}
fn has_budget(policy: &RetryPolicy, attempt: usize, start_time: std::time::Instant) -> bool {
if attempt >= policy.max_attempts() {
return false;
}
if let Some(max_elapsed) = policy.max_elapsed() {
if start_time.elapsed() >= max_elapsed {
return false;
}
}
true
}
#[allow(clippy::too_many_lines)]
pub(crate) async fn send_with_retry(client: &Client, request: Request) -> Result<Response> {
let body_replayable = request.body().is_replayable();
let effective_policy = request
.retry()
.cloned()
.or_else(|| client.config().retry.clone());
let policy = match effective_policy {
Some(p) if p.is_enabled() => p,
_ => {
return Box::pin(send_with_redirects(client, request)).await;
}
};
if !body_replayable {
return Box::pin(send_with_redirects(client, request)).await;
}
let saved = request.into_parts();
let saved_timeout = saved.timeout;
let start_time = std::time::Instant::now();
let mut attempt = 0usize;
loop {
attempt += 1;
if attempt > policy.max_attempts() {
return Err(Error::RetryBudgetExhausted {
attempts: attempt - 1,
});
}
let elapsed = start_time.elapsed();
if let Some(max_elapsed) = policy.max_elapsed() {
if elapsed >= max_elapsed {
return Err(Error::RetryBudgetExhausted {
attempts: attempt - 1,
});
}
}
if let Some(total) = saved_timeout.as_ref().and_then(|t| t.total) {
if elapsed >= total {
return Err(Error::Timeout {
phase: TimeoutPhase::Total,
elapsed,
});
}
}
let attempt_timeout =
saved_timeout.map(|t| crate::request::RequestParts::shrink_total_deadline(&t, elapsed));
if attempt_timeout
.as_ref()
.and_then(|t| t.total)
.is_some_and(|remaining| remaining.is_zero())
{
return Err(Error::Timeout {
phase: TimeoutPhase::Total,
elapsed,
});
}
let attempt_request = saved.retry_request(attempt_timeout)?;
let result = Box::pin(send_with_redirects(client, attempt_request)).await;
match result {
Ok(response) => {
if response.status().is_success() {
return Ok(response);
}
let status = response.status().as_u16();
if let Some(cause) =
should_retry(&policy, &saved.method, &saved.body, None, Some(status))
{
if !has_budget(&policy, attempt, start_time) {
return Ok(response);
}
let mut resp = response;
let retry_after = resp
.headers()
.get("retry-after")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
drain_response_body(&mut resp).await;
if let Some(dur) =
compute_retry_delay(&policy, &cause, attempt, retry_after.as_deref())
{
sleep_if_budget_allows(&policy, dur, attempt, start_time).await?;
}
continue;
}
return Ok(response);
}
Err(err) => {
if let Some(cause) =
should_retry(&policy, &saved.method, &saved.body, Some(&err), None)
{
if !has_budget(&policy, attempt, start_time) {
return Err(err);
}
if let Some(dur) = compute_retry_delay(&policy, &cause, attempt, None) {
sleep_if_budget_allows(&policy, dur, attempt, start_time).await?;
}
continue;
}
return Err(err);
}
}
}
}
fn compute_retry_delay(
policy: &RetryPolicy,
cause: &RetryCause,
attempt: usize,
retry_after: Option<&str>,
) -> Option<Duration> {
if let Some(value) = retry_after {
if let Some(delay) = policy.retry_after_delay(value) {
return Some(delay);
}
}
let base = policy.backoff_delay(attempt)?;
if matches!(cause, RetryCause::Status(429)) {
let max = policy.backoff().max_delay().as_secs_f64();
let increased = (base.as_secs_f64() * 1.5).min(max);
return Some(Duration::from_secs_f64(increased));
}
Some(base)
}
#[allow(
clippy::struct_excessive_bools,
reason = "hop policy is three orthogonal booleans (first-hop, credentials, cookies); an enum would obscure call sites"
)]
struct HopBuildParams {
method: http::Method,
url: url::Url,
headers: Headers,
body: RequestBody,
version: http::Version,
timeout: Timeout,
decompress: Option<bool>,
#[cfg(feature = "proxy")]
proxy_override: ProxyOverride,
transport_hints: crate::request::TransportHints,
auth: Option<crate::auth::AuthScheme>,
auth_disabled: bool,
is_first_hop: bool,
credentials_allowed: bool,
cookie_allowed: bool,
}
fn build_hop_request(client: &Client, params: HopBuildParams) -> Result<Request> {
let HopBuildParams {
method,
url,
headers,
body,
version,
timeout,
decompress,
#[cfg(feature = "proxy")]
proxy_override,
transport_hints,
auth,
auth_disabled,
is_first_hop,
credentials_allowed,
cookie_allowed,
} = params;
let mut hop = Request::new(method, url);
*hop.headers_mut() = headers;
hop.set_body(body);
hop.set_version(version);
hop.set_timeout(Some(timeout));
hop.set_decompress(decompress);
#[cfg(feature = "proxy")]
hop.set_proxy_override(proxy_override);
if is_first_hop {
hop.set_transport_hints(transport_hints);
}
hop.set_auth(if credentials_allowed { auth } else { None });
hop.set_auth_disabled(auth_disabled);
#[cfg(feature = "cookies")]
{
if !cookie_allowed {
hop.headers_mut().remove("cookie");
} else if !hop.headers().contains("cookie") {
if let Some(cookie_header) = client.config().cookie_jar.cookies_for_url(hop.url()) {
hop.headers_mut().insert("cookie", &cookie_header)?;
}
}
}
#[cfg(not(feature = "cookies"))]
let _ = (client, cookie_allowed);
{
let effective_auth = crate::auth::resolve_request_auth(
hop.auth(),
hop.is_auth_disabled(),
if credentials_allowed {
client.config().auth.as_ref()
} else {
None
},
hop.headers(),
)?;
if let Some(auth) = effective_auth {
auth.apply(hop.headers_mut())?;
}
}
Ok(hop)
}
#[derive(Debug)]
struct RedirectHop {
method: http::Method,
url: url::Url,
headers: Headers,
body: RequestBody,
version: http::Version,
}
fn advance_redirect_hop(
cur_method: &http::Method,
cur_url: &url::Url,
cur_headers: &Headers,
cur_version: http::Version,
replay_body: &mut Option<Bytes>,
status: http::StatusCode,
location: &str,
) -> Result<RedirectHop> {
let new_method = redirect::redirect_method(status, cur_method);
let drop_body = redirect::drops_body_on_redirect(status, cur_method);
if drop_body {
*replay_body = Some(Bytes::new());
} else if replay_body.is_none() {
return Err(Error::BodyNotReplayableForRedirect);
}
let mut temp_request = Request::new(cur_method.clone(), cur_url.clone());
*temp_request.headers_mut() = cur_headers.clone();
let temp_body = if drop_body {
RequestBody::Empty
} else {
RequestBody::Bytes(
replay_body
.as_ref()
.ok_or(Error::BodyNotReplayableForRedirect)?
.clone(),
)
};
temp_request.set_body(temp_body);
temp_request.set_version(cur_version);
let redirect_req = redirect::build_redirect_request_with_policy(
&temp_request,
location,
new_method.clone(),
drop_body,
)?;
let crate::request::RequestParts {
method: _,
url: new_url,
headers: new_headers,
body: new_body,
version: new_version,
timeout: _,
redirect: _,
auth: _,
auth_disabled: _,
decompress: _,
proxy_override: _,
retry: _,
transport_hints: _,
} = redirect_req.into_parts();
Ok(RedirectHop {
method: new_method,
url: new_url,
headers: new_headers,
body: new_body,
version: new_version,
})
}
struct PreparedRequest {
method: http::Method,
url: url::Url,
uri: http::Uri,
headers: Headers,
body: RequestBody,
version: http::Version,
transport_hints: crate::request::TransportHints,
#[cfg(feature = "proxy")]
effective_proxy: Option<ProxyConfig>,
decompression_enabled: bool,
timeout: Timeout,
remaining_total: Option<Duration>,
deadline: Option<std::time::Instant>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TransportRoute {
Uds,
Direct,
Proxy,
SniDirect,
H3,
Standard,
}
#[allow(
clippy::fn_params_excessive_bools,
reason = "route selection is a pure precedence predicate over five availability flags; bundling into a struct adds indirection for tests"
)]
fn select_route(
has_uds: bool,
has_direct_no_proxy: bool,
has_proxy: bool,
has_sni: bool,
use_h3: bool,
) -> TransportRoute {
if has_uds {
TransportRoute::Uds
} else if has_direct_no_proxy {
TransportRoute::Direct
} else if has_proxy {
TransportRoute::Proxy
} else if has_sni {
TransportRoute::SniDirect
} else if use_h3 {
TransportRoute::H3
} else {
TransportRoute::Standard
}
}
#[cfg(feature = "http3")]
fn h3_discovered_target(
inner: &ClientInner,
url: &url::Url,
) -> Option<crate::transport::http3::H3AltTarget> {
if url.scheme() != "https" {
return None;
}
let origin = crate::transport::alt_svc::AltSvcOrigin::from_url(url)?;
let now = std::time::Instant::now();
let (fresh, expired) = inner.alt_svc_state.cache().get_fresh_counted(&origin, now);
if expired {
inner.transport_metrics.record_altsvc_expired();
}
let entry = fresh?;
if inner
.alt_svc_state
.suppressor()
.is_suppressed(&origin, entry.generation, now)
{
inner.transport_metrics.record_h3_suppressed();
return None;
}
Some(crate::transport::http3::H3AltTarget {
alt_host: entry.alt_host,
alt_port: entry.alt_port,
sni_host: origin.host().to_owned(),
generation: Some(entry.generation),
})
}
#[cfg(feature = "http3")]
fn learn_altsvc_from_response(
inner: &ClientInner,
url: &url::Url,
headers: &http::HeaderMap,
via_proxy: bool,
route_learnable: bool,
) {
if url.scheme() != "https" || via_proxy || !route_learnable {
return;
}
let tls_authenticated = match inner.config.tls_config.as_ref() {
Some(cfg) => cfg.verify_certificate() && cfg.verify_hostname(),
None => true,
};
if inner.tls_config_error.is_some() {
inner.transport_metrics.record_altsvc_rejected();
return;
}
let ctx = crate::transport::alt_svc::AltSvcLearnContext {
is_https: true,
tls_authenticated,
via_proxy: false,
origin_matches_hop: true,
};
if !ctx.trustworthy() {
inner.transport_metrics.record_altsvc_rejected();
return;
}
let Some(origin) = crate::transport::alt_svc::AltSvcOrigin::from_url(url) else {
inner.transport_metrics.record_altsvc_rejected();
return;
};
let values: Vec<String> = headers
.get_all("alt-svc")
.iter()
.filter_map(|v| v.to_str().ok().map(str::to_owned))
.collect();
if values.is_empty() {
return;
}
let now = std::time::Instant::now();
let (outcome, had_cleared) = inner
.alt_svc_state
.cache()
.learn_counted(&origin, &values, now);
match outcome {
crate::transport::alt_svc::AltSvcLearnOutcome::Learned => {
inner.transport_metrics.record_altsvc_learned();
if let Some(entry) = inner.alt_svc_state.cache().get_fresh(&origin, now) {
inner
.alt_svc_state
.suppressor()
.note_new_advertisement(&origin, entry.generation);
}
}
crate::transport::alt_svc::AltSvcLearnOutcome::Cleared => {
if had_cleared {
inner.transport_metrics.record_altsvc_cleared();
}
}
crate::transport::alt_svc::AltSvcLearnOutcome::Rejected => {
inner.transport_metrics.record_altsvc_rejected();
}
crate::transport::alt_svc::AltSvcLearnOutcome::Absent => {}
}
}
fn build_hyper_request(
method: &http::Method,
uri: http::Uri,
version: http::Version,
headers: &Headers,
body: RequestBody,
) -> Result<http::Request<crate::transport::HyperRequestBody>> {
let mut builder = http::Request::builder()
.method(method)
.uri(uri)
.version(version);
for (name, value) in headers.iter() {
builder = builder.header(name, value);
}
builder
.body(body.into_http_body())
.map_err(|e| Error::RequestBuild(e.to_string()))
}
#[allow(clippy::too_many_lines)]
pub(crate) async fn send_with_redirects(client: &Client, request: Request) -> Result<Response> {
let crate::request::RequestParts {
method,
url,
headers: request_headers,
body,
version,
timeout: request_timeout,
redirect: request_redirect,
auth: req_auth,
auth_disabled: req_auth_disabled,
decompress: request_decompress,
proxy_override: request_proxy,
retry: _request_retry,
transport_hints: request_transport_hints,
} = request.into_parts();
#[cfg(not(feature = "proxy"))]
let _ = &request_proxy;
let mut merged_headers = client.config().default_headers.clone().into_inner();
for name in request_headers.keys() {
merged_headers.remove(name);
}
merged_headers.extend(request_headers.into_inner());
let headers = Headers::from(merged_headers);
let timeout = match client.config().timeout {
Some(client_timeout) => client_timeout.merge(request_timeout),
None => request_timeout.unwrap_or_default(),
};
let effective_redirect = request_redirect
.as_ref()
.unwrap_or(&client.config().redirect);
if !effective_redirect.follow {
let request = build_hop_request(
client,
HopBuildParams {
method,
url,
headers,
body,
version,
timeout,
decompress: request_decompress,
#[cfg(feature = "proxy")]
proxy_override: request_proxy,
transport_hints: request_transport_hints,
auth: req_auth,
auth_disabled: req_auth_disabled,
is_first_hop: true,
credentials_allowed: true,
cookie_allowed: true,
},
)?;
let response = client.send_single_request(request, &timeout).await?;
#[cfg(feature = "cookies")]
{
let set_cookie_headers: Vec<String> = response
.headers()
.get_all("set-cookie")
.iter()
.filter_map(|v| v.to_str().ok().map(str::to_owned))
.collect();
if !set_cookie_headers.is_empty() {
client
.config()
.cookie_jar
.update_from_response(response.url(), &set_cookie_headers);
}
}
return Ok(response);
}
let mut history = Vec::new();
let mut redirect_count = 0usize;
let start_time = std::time::Instant::now();
let (mut replay_body, mut cur_body) = match body {
RequestBody::Empty => (Some(Bytes::new()), RequestBody::Empty),
RequestBody::Bytes(bytes) => (Some(bytes.clone()), RequestBody::Bytes(bytes)),
stream @ RequestBody::Stream { .. } => (None, stream),
};
let mut cur_method = method;
let mut cur_url = url;
let mut cur_headers = headers;
let mut cur_version = version;
#[cfg(feature = "cookies")]
let mut cookie_header_allowed = true;
let mut prev_url: Option<url::Url> = None;
let mut credentials_allowed = true;
loop {
let hop_timeout = if let Some(total_dur) = timeout.total {
let elapsed = start_time.elapsed();
if elapsed >= total_dur {
return Err(Error::Timeout {
phase: TimeoutPhase::Total,
elapsed,
});
}
let remaining = total_dur.saturating_sub(elapsed);
let mut hop = timeout;
hop.total = Some(remaining);
hop
} else {
timeout
};
let is_first_hop = prev_url.is_none();
let is_cross_origin_redirect = prev_url
.as_ref()
.is_some_and(|prev| prev.origin() != cur_url.origin());
if is_cross_origin_redirect {
credentials_allowed = false;
#[cfg(feature = "cookies")]
{
cookie_header_allowed = false;
}
}
let hop_request = build_hop_request(
client,
HopBuildParams {
method: cur_method.clone(),
url: cur_url.clone(),
headers: cur_headers.clone(),
body: cur_body,
version: cur_version,
timeout: hop_timeout,
decompress: request_decompress,
#[cfg(feature = "proxy")]
proxy_override: request_proxy.clone(),
transport_hints: request_transport_hints.clone(),
auth: req_auth.clone(),
auth_disabled: req_auth_disabled,
is_first_hop,
credentials_allowed,
#[cfg(feature = "cookies")]
cookie_allowed: cookie_header_allowed,
#[cfg(not(feature = "cookies"))]
cookie_allowed: true,
},
)?;
let mut response = client
.send_single_request(hop_request, &hop_timeout)
.await?;
#[cfg(feature = "cookies")]
{
let set_cookie_headers: Vec<String> = response
.headers()
.get_all("set-cookie")
.iter()
.filter_map(|v| v.to_str().ok().map(str::to_owned))
.collect();
if !set_cookie_headers.is_empty() {
client
.config()
.cookie_jar
.update_from_response(response.url(), &set_cookie_headers);
}
}
if !redirect::is_redirect_status(response.status()) || !effective_redirect.follow {
response.set_history(history);
return Ok(response);
}
let location = if let Some(v) = response.headers().get("location") {
v.to_str()
.map_err(|e| Error::InvalidRedirectLocation(e.to_string()))?
.to_owned()
} else {
response.set_history(history);
return Ok(response);
};
if let Some(total) = timeout.total {
let dur = total.saturating_sub(start_time.elapsed());
if tokio::time::timeout(dur, drain_response_body(&mut response))
.await
.is_err()
{
return Err(Error::Timeout {
phase: TimeoutPhase::Total,
elapsed: start_time.elapsed(),
});
}
} else {
drain_response_body(&mut response).await;
}
redirect_count += 1;
if redirect_count > effective_redirect.max_redirects {
return Err(Error::TooManyRedirects {
followed: redirect_count - 1,
max: effective_redirect.max_redirects,
});
}
let redirect_status = response.status();
let hop = advance_redirect_hop(
&cur_method,
&cur_url,
&cur_headers,
cur_version,
&mut replay_body,
redirect_status,
&location,
)?;
history.push(HistoryEntry::from_response(&response));
prev_url = Some(cur_url);
cur_method = hop.method;
cur_url = hop.url;
cur_headers = hop.headers;
cur_body = hop.body;
cur_version = hop.version;
}
}
pub(crate) fn apply_content_length(headers: Headers, body: &RequestBody) -> Result<Headers> {
let known =
match body {
RequestBody::Empty => Some(0u64),
RequestBody::Bytes(b) => Some(u64::try_from(b.len()).map_err(|_| {
Error::RequestBuild("request body length does not fit in u64".into())
})?),
RequestBody::Stream {
length: Some(n), ..
} => Some(u64::try_from(*n).map_err(|_| {
Error::RequestBuild("request body length does not fit in u64".into())
})?),
RequestBody::Stream { length: None, .. } => None,
};
let supplied = headers.get("content-length").map(|value| {
value
.to_str()
.map_err(|e| Error::InvalidHeaderValue(format!("invalid Content-Length: {e}")))?
.parse::<u64>()
.map_err(|e| Error::InvalidHeaderValue(format!("invalid Content-Length: {e}")))
});
let supplied = supplied.transpose()?;
if let Some(known_len) = known {
if let Some(user_len) = supplied {
if user_len != known_len {
return Err(Error::RequestBuild(format!(
"Content-Length mismatch: user supplied {user_len} but body is {known_len}"
)));
}
} else {
let mut h = headers;
h.insert("content-length", &known_len.to_string())?;
return Ok(h);
}
} else if supplied.is_some() {
return Err(Error::RequestBuild(
"Content-Length cannot be supplied for an unknown-length stream body".into(),
));
}
Ok(headers)
}
pub(crate) fn apply_read_timeout_and_lease(
response: &mut Response,
guard: PoolGuard,
read_timeout: Option<Duration>,
) {
let body = std::mem::replace(&mut response.body, ResponseBody::buffered(Bytes::new()));
let new_body = match body {
ResponseBody::Streaming { mut stream, .. } => {
if let Some(dur) = read_timeout {
let inner = std::mem::replace(
&mut stream,
Box::pin(futures_util::stream::empty::<crate::error::Result<Bytes>>()),
);
stream = read_timeout_stream(inner, dur);
}
ResponseBody::streaming_with_lease(stream, Arc::new(guard))
}
ResponseBody::EncodedStreaming {
mut stream,
content_encoding,
limit,
..
} => {
if let Some(dur) = read_timeout {
let inner = std::mem::replace(
&mut stream,
Box::pin(futures_util::stream::empty::<crate::error::Result<Bytes>>()),
);
stream = read_timeout_stream(inner, dur);
}
ResponseBody::encoded_streaming_with_lease(
stream,
Arc::new(guard),
content_encoding,
limit,
)
}
other => {
drop(guard);
other
}
};
response.set_body(new_body);
}
#[cfg(feature = "proxy")]
pub(crate) fn resolve_proxy(
inner: &ClientInner,
url: &url::Url,
proxy_override: &ProxyOverride,
) -> Option<ProxyConfig> {
match proxy_override {
ProxyOverride::Override(config) => Some(config.clone()),
ProxyOverride::Direct => None,
ProxyOverride::Inherit => {
let candidates = inner
.config
.proxy
.iter()
.chain(inner.config.environment_proxies.iter());
candidates
.filter(|p| p.should_use_for_scheme(url.scheme()))
.find(|p| p.no_proxy_rules().map_or(true, |np| !np.should_bypass(url)))
.map(Proxy::config)
}
}
}
#[allow(
clippy::too_many_lines,
reason = "preparation centralizes header/body/version/proxy/pool policy in one place so transports do not reimplement it"
)]
async fn prepare_single_request(
inner: &ClientInner,
request: Request,
timeout: &Timeout,
) -> Result<(PreparedRequest, PoolGuard)> {
let crate::request::RequestParts {
method,
url,
headers,
body,
version,
timeout: _request_timeout,
redirect: _request_redirect,
auth: _,
auth_disabled: _,
decompress: request_decompress,
proxy_override,
retry: _,
transport_hints,
} = request.into_parts();
if url.scheme() == "https" {
if let Some(error) = &inner.tls_config_error {
return Err(Error::Tls(error.clone()));
}
}
let decompression_enabled = request_decompress.unwrap_or(inner.config.automatic_decompression);
let mut headers = headers;
if decompression_enabled && !headers.contains("accept-encoding") {
if let Some(value) = crate::compression::accept_encoding_value() {
headers.insert("accept-encoding", value)?;
}
}
#[cfg(feature = "proxy")]
let effective_proxy = resolve_proxy(inner, &url, &proxy_override);
#[cfg(not(feature = "proxy"))]
{
let _ = proxy_override;
}
#[cfg(feature = "proxy")]
let origin = match effective_proxy {
Some(ref proxy_config) => {
let is_tunnel = url.scheme() == "https";
OriginKey::from_url_with_proxy_scheme(
url.scheme(),
&url,
proxy_config.host(),
Some(proxy_config.port()?),
Some(proxy_config.scheme()),
is_tunnel,
)
}
None => OriginKey::from_url(url.scheme(), &url),
};
#[cfg(not(feature = "proxy"))]
let origin = OriginKey::from_url(url.scheme(), &url);
let started = std::time::Instant::now();
let pool_deadline = match (timeout.pool, timeout.total) {
(Some(pool), Some(total)) if total < pool => Some((total, TimeoutPhase::Total)),
(Some(pool), _) => Some((pool, TimeoutPhase::Pool)),
(None, Some(total)) => Some((total, TimeoutPhase::Total)),
(None, None) => None,
};
let guard = match pool_deadline {
Some((duration, phase)) => {
match tokio::time::timeout(duration, inner.pool.acquire(origin.as_ref())).await {
Ok(guard) => guard?,
Err(_) => {
return Err(Error::Timeout {
phase,
elapsed: started.elapsed(),
})
}
}
}
None => inner.pool.acquire(origin.as_ref()).await?,
};
let body = match (body, timeout.write) {
(RequestBody::Stream { stream, length }, Some(write_dur)) => {
let wrapped = write_timeout_stream(stream, write_dur);
RequestBody::Stream {
stream: wrapped,
length,
}
}
(b, _) => b,
};
let headers = apply_content_length(headers, &body)?;
let mut headers = headers;
if let Some(ref ua) = inner.config.user_agent {
if !headers.contains("user-agent") {
headers.insert(http::header::USER_AGENT.as_str(), ua.as_str())?;
}
}
let enabler = crate::http_version::HttpVersionPolicyEnabler::from_policy(
inner.config.http_version_policy,
);
if version == http::Version::HTTP_2 || (!enabler.enable_http1() && enabler.enable_http2()) {
crate::h2_headers::strip_h2_forbidden_headers(&mut headers);
}
let request_uri = resolve_request_uri(&url, &transport_hints)?;
headers.validate_request_size(&method, request_uri.to_string().as_bytes())?;
let remaining_total = timeout
.total
.map(|total| total.saturating_sub(started.elapsed()));
let deadline = timeout.total.map(|total| started + total);
let prepared = PreparedRequest {
method,
url,
uri: request_uri,
headers,
body,
version,
transport_hints,
#[cfg(feature = "proxy")]
effective_proxy,
decompression_enabled,
timeout: *timeout,
remaining_total,
deadline,
};
Ok((prepared, guard))
}
#[allow(clippy::too_many_lines)]
pub(crate) async fn send_single_request(
inner: &ClientInner,
request: Request,
timeout: &Timeout,
) -> Result<Response> {
let (prepared, guard) = prepare_single_request(inner, request, timeout).await?;
let PreparedRequest {
method,
url,
uri,
headers,
body,
version,
transport_hints,
#[cfg(feature = "proxy")]
effective_proxy,
decompression_enabled,
timeout: hop_timeout,
remaining_total,
deadline,
} = prepared;
#[cfg(not(feature = "proxy"))]
let _ = &deadline;
#[cfg(unix)]
let has_uds = inner.uds_client.is_some();
#[cfg(not(unix))]
let has_uds = false;
#[cfg(feature = "proxy")]
let has_proxy = effective_proxy.is_some();
#[cfg(not(feature = "proxy"))]
let has_proxy = false;
#[cfg(feature = "proxy")]
let has_direct_no_proxy = !has_proxy && inner.direct_client.is_some() && !has_uds;
#[cfg(not(feature = "proxy"))]
let has_direct_no_proxy = !has_uds && inner.direct_client.is_some();
let has_sni = transport_hints.sni_hostname.is_some();
#[cfg(feature = "http3")]
let (use_h3, h3_alt) = {
use crate::HttpVersionPolicy;
match inner.config.http_version_policy {
HttpVersionPolicy::Http3Only => (true, None),
HttpVersionPolicy::Auto { allow_http3: true } => {
if has_uds || has_proxy || has_sni {
(false, None)
} else if let Some(target) = h3_discovered_target(inner, &url) {
(true, Some(target))
} else {
(false, None)
}
}
_ => (false, None),
}
};
#[cfg(not(feature = "http3"))]
let use_h3 = false;
let route = select_route(has_uds, has_direct_no_proxy, has_proxy, has_sni, use_h3);
#[cfg(feature = "http3")]
if use_h3 {
inner.transport_metrics.record_h3_attempted();
}
let response = match route {
TransportRoute::Uds => {
#[cfg(unix)]
{
let uds_client = inner
.uds_client
.as_ref()
.ok_or_else(|| Error::Unsupported("UDS client not available".into()))?;
let hyper_request = build_hyper_request(&method, uri, version, &headers, body)?;
let send_future = crate::transport::uds::send_request(
uds_client,
hyper_request,
url.clone(),
transport_hints.trace.as_deref(),
);
send_with_total_timeout(send_future, remaining_total).await?
}
#[cfg(not(unix))]
{
let _ = (method, uri, headers, body, version);
return Err(Error::Unsupported(
"Unix domain sockets are not supported on this platform".into(),
));
}
}
TransportRoute::Direct => {
let direct_client = inner
.direct_client
.as_ref()
.ok_or_else(|| Error::Unsupported("direct client not available".into()))?;
let hyper_request = build_hyper_request(&method, uri, version, &headers, body)?;
let send_future = crate::transport::direct::send_direct_request(
direct_client,
hyper_request,
url.clone(),
transport_hints.trace.as_deref(),
);
send_with_total_timeout(send_future, remaining_total).await?
}
TransportRoute::Proxy => {
#[cfg(feature = "proxy")]
{
let proxy_config = effective_proxy.as_ref().ok_or_else(|| {
Error::Unsupported("proxy configuration not available".into())
})?;
if !proxy_config.is_socks()
&& headers.contains("proxy-authorization")
&& proxy_config.auth().is_some()
{
return Err(Error::ConflictingAuth(
"conflict: both request Proxy-Authorization header and proxy auth are configured; remove one".into(),
));
}
let socks_client = {
let socks_proxy = effective_proxy.as_ref().filter(|proxy| proxy.is_socks());
match socks_proxy {
Some(proxy) => Some(inner.socks_client(proxy).await?),
None => None,
}
};
Box::pin(send_proxy_request(
&url,
&method,
&headers,
body,
version,
proxy_config,
&transport_hints,
&crate::transport::proxy::ProxyRequestContext {
remaining_total,
deadline,
connect_timeout: hop_timeout.connect,
proxy_connect_timeout: hop_timeout.connect,
proxy_tls_timeout: hop_timeout.connect,
write_timeout: hop_timeout.write,
read_timeout: hop_timeout.read,
http_version_policy: inner.config.http_version_policy,
origin_tls_config: inner.config.tls_config.as_ref(),
proxy_tls_config: proxy_config.proxy_tls_config(),
socks_client,
transport_metrics: Some(inner.transport_metrics.clone()),
},
))
.await?
}
#[cfg(not(feature = "proxy"))]
{
let _ = (method, uri, headers, body, version);
return Err(Error::Unsupported("proxy support is not enabled".into()));
}
}
TransportRoute::SniDirect => {
let sni_hostname = transport_hints.sni_hostname.clone().ok_or_else(|| {
Error::RequestBuild("SNI route selected without sni_hostname".into())
})?;
let sni_client = inner.sni_client(&sni_hostname).await?;
let hyper_request = build_hyper_request(&method, uri, version, &headers, body)?;
let send_future = crate::transport::direct::send_direct_request(
&sni_client,
hyper_request,
url.clone(),
transport_hints.trace.as_deref(),
);
send_with_total_timeout(send_future, remaining_total).await?
}
TransportRoute::H3 => {
#[cfg(feature = "http3")]
{
use crate::body::RequestBody;
let h3_connector = inner.h3_connector.as_ref().ok_or_else(|| {
Error::Unsupported(
"HTTP/3 connector not available; ensure http3 feature is enabled".into(),
)
})?;
let is_explicit = h3_alt.is_none();
let fallback_body: Option<RequestBody> = if is_explicit {
None
} else {
match &body {
RequestBody::Empty => Some(RequestBody::Empty),
RequestBody::Bytes(b) => Some(RequestBody::Bytes(b.clone())),
RequestBody::Stream { .. } => None,
}
};
let mut builder = http::Request::builder()
.method(&method)
.uri(uri)
.version(version);
for (name, value) in headers.iter() {
builder = builder.header(name, value);
}
let h3_request = builder
.body(body)
.map_err(|e| Error::RequestBuild(e.to_string()))?;
let h3_alt_clone = h3_alt.clone();
let connect_budget = hop_timeout.connect;
let h3_future = Box::pin(h3_connector.send_request_with_alt(
h3_request,
url.clone(),
h3_alt_clone.clone(),
connect_budget,
));
let h3_outcome: std::result::Result<
Response,
crate::transport::http3::H3DispatchError,
> = match remaining_total {
Some(dur) => {
let started = std::time::Instant::now();
match tokio::time::timeout(dur, h3_future).await {
Ok(r) => r,
Err(_) => {
Err(crate::transport::http3::H3DispatchError::for_total_timeout(
started.elapsed(),
))
}
}
}
None => h3_future.await,
};
match h3_outcome {
Ok(resp) => {
if let Some(origin) =
crate::transport::alt_svc::AltSvcOrigin::from_url(&url)
{
inner.alt_svc_state.suppressor().record_success(&origin);
}
resp
}
Err(dispatch) => {
let suppressible = !is_explicit
&& !dispatch.draining
&& !matches!(
dispatch.failure_class,
crate::transport::alt_svc::H3FailureClass::Other
);
if suppressible {
if let Some(origin) =
crate::transport::alt_svc::AltSvcOrigin::from_url(&url)
{
let generation = h3_alt_clone
.as_ref()
.and_then(|a| a.generation)
.unwrap_or(0);
inner.alt_svc_state.suppressor().record_failure(
&origin,
generation,
std::time::Instant::now(),
dispatch.failure_class,
);
}
}
if is_explicit {
return Err(dispatch.error);
}
let can_fallback = dispatch.safe_for_fallback()
&& fallback_body.is_some()
&& !matches!(
dispatch.failure_class,
crate::transport::alt_svc::H3FailureClass::Other
);
if can_fallback {
inner.transport_metrics.record_h3_fallback();
let fb_body = fallback_body.expect("checked above");
send_hyper_request(
inner,
&method,
url.clone(),
&headers,
fb_body,
version,
remaining_total,
&transport_hints,
)
.await?
} else {
return Err(dispatch.error);
}
}
}
}
#[cfg(not(feature = "http3"))]
{
let _ = (method, uri, headers, body, version);
return Err(Error::Unsupported("HTTP/3 support is not enabled".into()));
}
}
TransportRoute::Standard => {
send_hyper_request(
inner,
&method,
url.clone(),
&headers,
body,
version,
remaining_total,
&transport_hints,
)
.await?
}
};
let mut response = response;
#[cfg(feature = "http3")]
{
let learnable = matches!(
route,
TransportRoute::Standard | TransportRoute::Direct | TransportRoute::H3
);
#[cfg(feature = "proxy")]
let via_proxy = effective_proxy.is_some();
#[cfg(not(feature = "proxy"))]
let via_proxy = false;
if learnable {
learn_altsvc_from_response(inner, &url, response.headers(), via_proxy, true);
}
}
if response
.network_stream()
.is_some_and(crate::network_stream::NetworkStream::is_upgraded)
{
inner.transport_metrics.record_upgraded();
}
if decompression_enabled {
let content_encoding = response
.headers()
.get("content-encoding")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let limit = crate::compression::DecompressionLimit {
max_decoded_body_size: inner.config.max_decoded_body_size,
max_decompression_ratio: inner.config.max_decompression_ratio,
};
response = crate::response_decode::apply_decompression(
response,
content_encoding.as_deref(),
limit,
)?;
}
if let Some(max) = inner.config.max_decoded_body_size {
response.body = response.body.limit_decoded_size(max)?;
}
apply_read_timeout_and_lease(&mut response, guard, hop_timeout.read);
Ok(response)
}
#[allow(clippy::too_many_arguments)] async fn send_hyper_request(
inner: &ClientInner,
method: &http::Method,
url: url::Url,
headers: &Headers,
body: RequestBody,
version: http::Version,
remaining_total: Option<Duration>,
transport_hints: &crate::request::TransportHints,
) -> Result<Response> {
let hyper_client = inner
.hyper_client
.as_ref()
.ok_or_else(|| Error::Unsupported("HTTP client not available for this protocol".into()))?;
let uri = resolve_request_uri(&url, transport_hints)?;
let hyper_request = build_hyper_request(method, uri, version, headers, body)?;
let send_future = crate::transport::direct::send_request(
hyper_client,
hyper_request,
url.clone(),
transport_hints.trace.as_deref(),
);
send_with_total_timeout(send_future, remaining_total).await
}
pub(crate) fn validate_target(target: &[u8]) -> Result<()> {
if target.is_empty() {
return Err(Error::RequestBuild(
"target extension must not be empty".into(),
));
}
if target.iter().any(|&b| b < 0x20 || b == 0x7f) {
return Err(Error::RequestBuild(
"target extension contains forbidden characters (C0 controls/DEL; includes CR/LF/NUL)"
.into(),
));
}
if target.iter().all(|&b| b == b' ') {
return Err(Error::RequestBuild(
"target extension must not be whitespace-only".into(),
));
}
if target.first() == Some(&b' ') || target.last() == Some(&b' ') {
return Err(Error::RequestBuild(
"target extension must not contain leading or trailing whitespace".into(),
));
}
Ok(())
}
fn resolve_request_uri(
url: &url::Url,
transport_hints: &crate::request::TransportHints,
) -> Result<http::Uri> {
if let Some(ref target) = transport_hints.target {
validate_target(target)?;
std::str::from_utf8(target)
.map_err(|_| Error::InvalidUrl("target extension is not valid UTF-8".into()))?
.parse()
.map_err(|e| Error::InvalidUrl(format!("failed to convert target to URI: {e}")))
} else {
url.as_str()
.parse()
.map_err(|e| Error::InvalidUrl(format!("failed to convert url to URI: {e}")))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::request::{RequestParts, TransportHints};
use bytes::Bytes;
use std::sync::Arc;
use std::time::Duration;
fn test_url() -> url::Url {
url::Url::parse("https://example.com/path").expect("valid test URL")
}
fn full_request() -> Request {
use crate::auth::{AuthScheme, BasicAuth};
use crate::redirect::RedirectPolicy;
use crate::retry::RetryPolicy;
let mut req = Request::new(http::Method::POST, test_url());
req.headers_mut().insert("x-custom", "keep").unwrap();
req.headers_mut()
.insert("content-type", "text/plain")
.unwrap();
req.set_body(RequestBody::Bytes(Bytes::from("payload")));
req.set_version(http::Version::HTTP_11);
req.set_timeout(Some(
Timeout::builder()
.pool(Duration::from_secs(1))
.connect(Duration::from_secs(2))
.write(Duration::from_secs(3))
.read(Duration::from_secs(4))
.total(Duration::from_secs(30))
.build(),
));
req.set_redirect(Some(RedirectPolicy::new(true, 7)));
req.set_auth(Some(AuthScheme::Basic(
BasicAuth::new("user", "pass").expect("valid auth"),
)));
req.set_auth_disabled(false);
req.set_decompress(Some(false));
#[cfg(feature = "proxy")]
req.set_proxy_override(crate::request::ProxyOverride::Direct);
req.set_retry(Some(RetryPolicy::default()));
req.set_transport_hints(TransportHints {
target: Some(Bytes::from("/override-target")),
sni_hostname: Some("sni.example".to_owned()),
trace: Some(Arc::new(crate::trace::NoopTraceObserver)),
});
req
}
#[test]
fn into_request_round_trip_preserves_every_field() {
let req = full_request();
let expected_method = req.method().clone();
let expected_url = req.url().clone();
let expected_headers = req.headers().clone();
let expected_version = req.version();
let expected_timeout = req.timeout().copied();
let expected_redirect = req.redirect().cloned();
let expected_auth = req.auth().cloned();
let expected_auth_disabled = req.is_auth_disabled();
let expected_decompress = req.decompress();
let expected_retry = req.retry().cloned();
let expected_target = req.transport_hints().target.clone();
let expected_sni = req.transport_hints().sni_hostname.clone();
let expected_has_trace = req.transport_hints().trace.is_some();
let parts = req.into_parts();
let RequestParts {
method: _,
url: _,
headers: _,
body: _,
version: _,
timeout: _,
redirect: _,
auth: _,
auth_disabled: _,
decompress: _,
proxy_override: _,
retry: _,
transport_hints: _,
} = &parts;
let rebuilt = parts.into_request();
assert_eq!(rebuilt.method(), &expected_method);
assert_eq!(rebuilt.url(), &expected_url);
assert_eq!(
rebuilt.headers().get("x-custom").unwrap().to_str().unwrap(),
"keep"
);
let _ = expected_headers;
assert_eq!(rebuilt.version(), expected_version);
match (rebuilt.timeout(), expected_timeout.as_ref()) {
(None, None) => {}
(Some(a), Some(b)) => {
assert_eq!(a.pool, b.pool);
assert_eq!(a.connect, b.connect);
assert_eq!(a.write, b.write);
assert_eq!(a.read, b.read);
assert_eq!(a.total, b.total);
}
(a, b) => panic!("timeout mismatch: {a:?} vs {b:?}"),
}
assert_eq!(
rebuilt.redirect().map(|r| (r.follow, r.max_redirects)),
expected_redirect.map(|r| (r.follow, r.max_redirects))
);
assert_eq!(
rebuilt.auth().map(|a| format!("{a:?}")),
expected_auth.map(|a| format!("{a:?}"))
);
assert_eq!(rebuilt.is_auth_disabled(), expected_auth_disabled);
assert_eq!(rebuilt.decompress(), expected_decompress);
#[cfg(feature = "proxy")]
assert!(matches!(
rebuilt.proxy_override(),
crate::request::ProxyOverride::Direct
));
assert_eq!(rebuilt.retry().is_some(), expected_retry.is_some());
assert_eq!(rebuilt.transport_hints().target, expected_target);
assert_eq!(rebuilt.transport_hints().sni_hostname, expected_sni);
assert_eq!(
rebuilt.transport_hints().trace.is_some(),
expected_has_trace
);
match rebuilt.body() {
RequestBody::Bytes(b) => assert_eq!(b, "payload"),
other => panic!("expected bytes body, got {other:?}"),
}
}
#[test]
fn retry_request_preserves_every_override_and_shrinks_total() {
let req = full_request();
let parts = req.into_parts();
let attempt_timeout = Some(
Timeout::builder()
.pool(Duration::from_secs(1))
.total(Duration::from_secs(25))
.build(),
);
let attempt = parts.retry_request(attempt_timeout).expect("replayable");
assert_eq!(attempt.method(), &http::Method::POST);
assert_eq!(attempt.url().as_str(), "https://example.com/path");
assert_eq!(
attempt.headers().get("x-custom").unwrap().to_str().unwrap(),
"keep"
);
assert_eq!(attempt.version(), http::Version::HTTP_11);
assert_eq!(
attempt.timeout().and_then(|t| t.total),
Some(Duration::from_secs(25)),
"total deadline is replaced by the shrunk attempt budget"
);
assert!(attempt.redirect().is_some());
assert!(attempt.auth().is_some());
assert!(!attempt.is_auth_disabled());
assert_eq!(attempt.decompress(), Some(false));
#[cfg(feature = "proxy")]
assert!(matches!(
attempt.proxy_override(),
crate::request::ProxyOverride::Direct
));
assert!(attempt.retry().is_some());
assert_eq!(
attempt.transport_hints().target.as_deref(),
Some(b"/override-target".as_slice())
);
assert_eq!(
attempt.transport_hints().sni_hostname.as_deref(),
Some("sni.example")
);
assert!(attempt.transport_hints().trace.is_some());
match attempt.body() {
RequestBody::Bytes(b) => assert_eq!(b, "payload"),
other => panic!("expected replayed bytes, got {other:?}"),
}
}
#[test]
fn retry_request_rejects_one_shot_stream() {
let mut req = Request::new(http::Method::POST, test_url());
req.set_body(RequestBody::from_stream(
futures_util::stream::empty::<crate::error::Result<Bytes>>(),
None,
));
let parts = req.into_parts();
let err = parts.retry_request(None).unwrap_err();
assert!(
matches!(err, Error::BodyNotReplayableForRetry),
"unexpected error: {err:?}"
);
}
#[test]
fn retry_preserves_auth_disabled_state() {
let mut req = Request::new(http::Method::GET, test_url());
req.set_auth_disabled(true);
let parts = req.into_parts();
let attempt = parts.retry_request(None).expect("empty body replays");
assert!(attempt.is_auth_disabled());
assert!(attempt.auth().is_none());
}
#[test]
fn shrink_total_deadline_subtracts_elapsed() {
let t = Timeout::builder()
.pool(Duration::from_secs(1))
.total(Duration::from_secs(10))
.build();
let shrunk = RequestParts::shrink_total_deadline(&t, Duration::from_secs(3));
assert_eq!(shrunk.total, Some(Duration::from_secs(7)));
assert_eq!(shrunk.pool, Some(Duration::from_secs(1)));
let saturated = RequestParts::shrink_total_deadline(&t, Duration::from_secs(20));
assert_eq!(saturated.total, Some(Duration::ZERO));
}
#[test]
fn select_route_precedence_matches_pipeline_order() {
assert_eq!(
select_route(true, true, true, true, true),
TransportRoute::Uds
);
assert_eq!(
select_route(false, true, false, true, true),
TransportRoute::Direct
);
assert_eq!(
select_route(false, false, true, true, true),
TransportRoute::Proxy
);
assert_eq!(
select_route(false, false, true, false, true),
TransportRoute::Proxy
);
assert_eq!(
select_route(false, false, false, true, true),
TransportRoute::SniDirect
);
assert_eq!(
select_route(false, false, false, false, true),
TransportRoute::H3
);
assert_eq!(
select_route(false, false, false, false, false),
TransportRoute::Standard
);
}
#[test]
fn hop_builder_first_hop_preserves_hints_and_applies_auth() {
let client = crate::client::Client::new();
let mut headers = Headers::new();
headers.insert("x-custom", "keep").unwrap();
let hop = build_hop_request(
&client,
HopBuildParams {
method: http::Method::GET,
url: test_url(),
headers,
body: RequestBody::Empty,
version: http::Version::HTTP_11,
timeout: Timeout::default(),
decompress: Some(true),
#[cfg(feature = "proxy")]
proxy_override: crate::request::ProxyOverride::Direct,
transport_hints: TransportHints {
target: Some(Bytes::from("/t")),
sni_hostname: Some("sni.example".to_owned()),
trace: Some(Arc::new(crate::trace::NoopTraceObserver)),
},
auth: None,
auth_disabled: false,
is_first_hop: true,
credentials_allowed: true,
cookie_allowed: true,
},
)
.expect("first hop builds");
assert_eq!(
hop.transport_hints().target.as_deref(),
Some(b"/t".as_slice())
);
assert_eq!(
hop.transport_hints().sni_hostname.as_deref(),
Some("sni.example")
);
assert!(hop.transport_hints().trace.is_some());
assert_eq!(hop.decompress(), Some(true));
assert_eq!(
hop.headers().get("x-custom").unwrap().to_str().unwrap(),
"keep"
);
}
#[test]
fn hop_builder_redirect_hop_clears_hints_and_drops_credentials() {
use crate::auth::{AuthScheme, BasicAuth};
let client = crate::client::Client::builder()
.auth(AuthScheme::basic("client", "secret").expect("valid auth"))
.build();
let mut headers = Headers::new();
headers.insert("cookie", "session=abc").unwrap();
headers.insert("x-custom", "keep").unwrap();
let hop = build_hop_request(
&client,
HopBuildParams {
method: http::Method::GET,
url: test_url(),
headers,
body: RequestBody::Empty,
version: http::Version::HTTP_11,
timeout: Timeout::default(),
decompress: None,
#[cfg(feature = "proxy")]
proxy_override: crate::request::ProxyOverride::Inherit,
transport_hints: TransportHints {
target: Some(Bytes::from("/t")),
sni_hostname: Some("sni.example".to_owned()),
trace: Some(Arc::new(crate::trace::NoopTraceObserver)),
},
auth: Some(AuthScheme::Basic(
BasicAuth::new("req", "pw").expect("valid auth"),
)),
auth_disabled: false,
is_first_hop: false,
credentials_allowed: false,
cookie_allowed: false,
},
)
.expect("redirect hop builds");
assert!(hop.transport_hints().target.is_none());
assert!(hop.transport_hints().sni_hostname.is_none());
assert!(hop.transport_hints().trace.is_none());
assert!(hop.auth().is_none());
#[cfg(feature = "cookies")]
assert!(hop.headers().get("cookie").is_none());
#[cfg(not(feature = "cookies"))]
assert!(hop.headers().get("cookie").is_some());
assert_eq!(
hop.headers().get("x-custom").unwrap().to_str().unwrap(),
"keep"
);
}
#[test]
fn no_redirect_fast_path_matches_redirect_first_hop() {
let client = crate::client::Client::new();
let mk_headers = || {
let mut h = Headers::new();
h.insert("x-custom", "keep").unwrap();
h
};
let mk_hints = || TransportHints {
target: Some(Bytes::from("/t")),
sni_hostname: None,
trace: None,
};
let fast = build_hop_request(
&client,
HopBuildParams {
method: http::Method::GET,
url: test_url(),
headers: mk_headers(),
body: RequestBody::Empty,
version: http::Version::HTTP_11,
timeout: Timeout::default(),
decompress: Some(true),
#[cfg(feature = "proxy")]
proxy_override: crate::request::ProxyOverride::Direct,
transport_hints: mk_hints(),
auth: None,
auth_disabled: false,
is_first_hop: true,
credentials_allowed: true,
cookie_allowed: true,
},
)
.unwrap();
let first_loop = build_hop_request(
&client,
HopBuildParams {
method: http::Method::GET,
url: test_url(),
headers: mk_headers(),
body: RequestBody::Empty,
version: http::Version::HTTP_11,
timeout: Timeout::default(),
decompress: Some(true),
#[cfg(feature = "proxy")]
proxy_override: crate::request::ProxyOverride::Direct,
transport_hints: mk_hints(),
auth: None,
auth_disabled: false,
is_first_hop: true,
credentials_allowed: true,
cookie_allowed: true,
},
)
.unwrap();
assert_eq!(fast.method(), first_loop.method());
assert_eq!(fast.url(), first_loop.url());
assert_eq!(fast.version(), first_loop.version());
assert_eq!(fast.decompress(), first_loop.decompress());
assert_eq!(
fast.transport_hints().target,
first_loop.transport_hints().target
);
assert_eq!(
format!("{:?}", fast.headers()),
format!("{:?}", first_loop.headers())
);
}
#[test]
fn redirect_hop_post_drops_body_and_clears_replay() {
let mut replay = Some(Bytes::from("payload"));
let mut headers = Headers::new();
headers.insert("content-length", "7").unwrap();
headers.insert("content-type", "text/plain").unwrap();
let hop = advance_redirect_hop(
&http::Method::POST,
&test_url(),
&headers,
http::Version::HTTP_11,
&mut replay,
http::StatusCode::MOVED_PERMANENTLY,
"https://example.com/other",
)
.expect("301 POST redirects");
assert_eq!(hop.method, http::Method::GET);
assert!(hop.body.is_empty());
assert!(hop.headers.get("content-length").is_none());
assert!(hop.headers.get("content-type").is_none());
assert_eq!(replay, Some(Bytes::new()));
}
#[test]
fn redirect_hop_307_preserves_replayable_body() {
let mut replay = Some(Bytes::from("payload"));
let headers = Headers::new();
let hop = advance_redirect_hop(
&http::Method::POST,
&test_url(),
&headers,
http::Version::HTTP_11,
&mut replay,
http::StatusCode::TEMPORARY_REDIRECT,
"https://example.com/other",
)
.expect("307 POST preserves body");
assert_eq!(hop.method, http::Method::POST);
match hop.body {
RequestBody::Bytes(b) => assert_eq!(b, "payload"),
other => panic!("expected bytes, got {other:?}"),
}
assert_eq!(replay, Some(Bytes::from("payload")));
}
#[test]
fn redirect_hop_rejects_one_shot_stream_before_replay() {
let mut replay: Option<Bytes> = None;
let headers = Headers::new();
let err = advance_redirect_hop(
&http::Method::POST,
&test_url(),
&headers,
http::Version::HTTP_11,
&mut replay,
http::StatusCode::TEMPORARY_REDIRECT,
"https://example.com/other",
)
.unwrap_err();
assert!(
matches!(err, Error::BodyNotReplayableForRedirect),
"unexpected error: {err:?}"
);
}
#[test]
fn build_hyper_request_carries_method_uri_version_headers() {
let mut headers = Headers::new();
headers.insert("x-custom", "keep").unwrap();
let uri: http::Uri = "https://example.com/path".parse().unwrap();
let req = build_hyper_request(
&http::Method::GET,
uri.clone(),
http::Version::HTTP_11,
&headers,
RequestBody::Empty,
)
.expect("hyper request builds");
assert_eq!(req.method(), &http::Method::GET);
assert_eq!(req.uri(), &uri);
assert_eq!(req.version(), http::Version::HTTP_11);
assert_eq!(req.headers().get("x-custom").unwrap(), "keep");
}
}