use std::{collections::HashSet, fmt, time::Duration};
use http::{
HeaderMap, HeaderName, HeaderValue, Method,
header::{
AUTHORIZATION, CONNECTION, CONTENT_ENCODING, CONTENT_LANGUAGE, CONTENT_LENGTH,
CONTENT_LOCATION, CONTENT_TYPE, COOKIE, HOST, ORIGIN, PROXY_AUTHENTICATE,
PROXY_AUTHORIZATION, REFERER, TE, TRAILER, TRANSFER_ENCODING, UPGRADE,
},
};
use serde::Serialize;
use url::Url;
#[cfg(feature = "multipart")]
use crate::Multipart;
use crate::{Auth, Body, Error, Result, body::is_forbidden_trailer_name, redact::SanitizedUrl};
pub(crate) fn query_method() -> Method {
Method::from_bytes(b"QUERY").expect("QUERY is a valid HTTP method")
}
pub struct Request {
method: Method,
url: Url,
headers: HeaderMap,
body: Body,
timeout: Option<Duration>,
explicitly_idempotent: bool,
client_generated: HashSet<HeaderName>,
body_present: bool,
}
pub struct RequestBuilder {
method: Option<Method>,
url: Option<String>,
headers: HeaderMap,
auth: Vec<Auth>,
query: Vec<(String, String)>,
body: Body,
timeout: Option<Duration>,
explicitly_idempotent: bool,
content_type_origin: ContentTypeOrigin,
}
#[derive(Clone, Copy, Default, Eq, PartialEq)]
enum ContentTypeOrigin {
#[default]
None,
Caller,
Generated,
}
impl ContentTypeOrigin {
fn is_generated(self) -> bool {
self == Self::Generated
}
}
impl Default for RequestBuilder {
fn default() -> Self {
Self {
method: None,
url: None,
headers: HeaderMap::new(),
auth: Vec::new(),
query: Vec::new(),
body: Body::default(),
timeout: None,
explicitly_idempotent: false,
content_type_origin: ContentTypeOrigin::None,
}
}
}
impl Request {
#[must_use]
pub fn builder() -> RequestBuilder {
RequestBuilder::default()
}
#[must_use]
pub fn get(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::GET)
.url(url.as_ref())
}
#[must_use]
pub fn post(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::POST)
.url(url.as_ref())
}
#[must_use]
pub fn put(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::PUT)
.url(url.as_ref())
}
#[must_use]
pub fn patch(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::PATCH)
.url(url.as_ref())
}
#[must_use]
pub fn delete(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::DELETE)
.url(url.as_ref())
}
#[must_use]
pub fn head(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::HEAD)
.url(url.as_ref())
}
#[must_use]
pub fn options(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::OPTIONS)
.url(url.as_ref())
}
#[must_use]
pub fn trace(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(Method::TRACE)
.url(url.as_ref())
}
#[must_use]
pub fn query(url: impl AsRef<str>) -> RequestBuilder {
RequestBuilder::default()
.method(query_method())
.url(url.as_ref())
}
#[must_use]
pub fn method(&self) -> &Method {
&self.method
}
#[must_use]
pub fn url(&self) -> &Url {
&self.url
}
#[must_use]
pub fn headers(&self) -> &HeaderMap {
&self.headers
}
#[must_use]
pub fn headers_mut(&mut self) -> &mut HeaderMap {
&mut self.headers
}
#[must_use]
pub fn body(&self) -> &Body {
&self.body
}
#[must_use]
pub fn timeout(&self) -> Option<Duration> {
self.timeout
}
#[must_use]
pub fn is_idempotent(&self) -> bool {
self.explicitly_idempotent
|| self.method == query_method()
|| matches!(
self.method,
Method::GET
| Method::HEAD
| Method::PUT
| Method::DELETE
| Method::OPTIONS
| Method::TRACE
)
}
#[must_use]
pub fn try_clone(&self) -> Option<Self> {
Some(Self {
method: self.method.clone(),
url: self.url.clone(),
headers: self.headers.clone(),
body: self.body.try_clone()?,
timeout: self.timeout,
explicitly_idempotent: self.explicitly_idempotent,
client_generated: self.client_generated.clone(),
body_present: self.body_present,
})
}
pub(crate) fn into_parts(self) -> (Method, Url, HeaderMap, Body, Option<Duration>) {
(self.method, self.url, self.headers, self.body, self.timeout)
}
pub(crate) fn apply_default_auth(&mut self, auth: &Auth) -> Result<()> {
let before = self.headers.keys().cloned().collect::<HashSet<_>>();
auth.apply_default(&mut self.headers, Some(&mut self.url))?;
self.client_generated.extend(
self.headers
.keys()
.filter(|name| !before.contains(*name))
.cloned(),
);
Ok(())
}
pub(crate) fn insert_client_header(&mut self, name: HeaderName, value: HeaderValue) {
self.headers.append(name.clone(), value);
self.client_generated.insert(name);
}
#[cfg(feature = "cookies")]
pub(crate) fn remove_client_header(&mut self, name: &HeaderName) {
if self.client_generated.remove(name) {
self.headers.remove(name);
}
}
pub(crate) fn validate_for_send(&mut self) -> Result<()> {
validate_url(&self.url)?;
validate_method_and_headers(&self.method, &self.headers, &self.body)?;
apply_framing(&mut self.headers, &self.body)
}
pub(crate) fn set_url(&mut self, url: Url) {
self.url = url;
}
pub(crate) fn set_timeout(&mut self, timeout: Duration) {
self.timeout = Some(timeout);
}
pub(crate) fn set_method(&mut self, method: Method) {
self.method = method;
}
pub(crate) fn replace_body(&mut self, body: Body) {
self.body_present = !body.is_absent();
self.body = body;
clear_framing(&mut self.headers);
}
pub(crate) fn clone_without_body(&self) -> Self {
let mut headers = self.headers.clone();
clear_content_fields(&mut headers);
Self {
method: self.method.clone(),
url: self.url.clone(),
headers,
body: Body::default(),
timeout: self.timeout,
explicitly_idempotent: self.explicitly_idempotent,
client_generated: self.client_generated.clone(),
body_present: self.body_present,
}
}
pub(crate) fn remove_routing_headers(&mut self) {
self.headers.remove(HOST);
self.headers.remove(CONNECTION);
}
pub(crate) fn body_was_present(&self) -> bool {
self.body_present
}
pub(crate) fn remove_content_fields(&mut self) {
clear_content_fields(&mut self.headers);
}
pub(crate) fn strip_cross_origin_headers(&mut self) {
let names = self.headers.keys().cloned().collect::<Vec<_>>();
for name in names {
let marked_sensitive = self
.headers
.get_all(&name)
.iter()
.any(HeaderValue::is_sensitive);
if marked_sensitive
|| self.client_generated.contains(&name)
|| is_cross_origin_sensitive(&name)
{
self.headers.remove(name);
}
}
self.client_generated.clear();
}
}
impl RequestBuilder {
#[must_use]
pub fn method(mut self, method: Method) -> Self {
self.method = Some(method);
self
}
#[must_use]
pub fn url(mut self, url: impl Into<String>) -> Self {
self.url = Some(url.into());
self
}
pub(crate) fn url_str(&self) -> Option<&str> {
self.url.as_deref()
}
pub fn header<K, V>(mut self, name: K, value: V) -> Result<Self>
where
K: TryInto<HeaderName>,
K::Error: Into<Error>,
V: TryInto<HeaderValue>,
V::Error: Into<Error>,
{
let name = name.try_into().map_err(Into::into)?;
let value = value.try_into().map_err(Into::into)?;
if name == CONTENT_TYPE {
self.content_type_origin = ContentTypeOrigin::Caller;
}
self.headers.insert(name, value);
Ok(self)
}
pub fn append_header<K, V>(mut self, name: K, value: V) -> Result<Self>
where
K: TryInto<HeaderName>,
K::Error: Into<Error>,
V: TryInto<HeaderValue>,
V::Error: Into<Error>,
{
let name = name.try_into().map_err(Into::into)?;
let value = value.try_into().map_err(Into::into)?;
if name == CONTENT_TYPE {
self.content_type_origin = ContentTypeOrigin::Caller;
}
self.headers.append(name, value);
Ok(self)
}
#[must_use]
pub fn auth(mut self, auth: impl Into<Auth>) -> Self {
self.auth.push(auth.into());
self
}
#[must_use]
pub fn headers(mut self, headers: HeaderMap) -> Self {
if headers.contains_key(CONTENT_TYPE) {
self.content_type_origin = ContentTypeOrigin::Caller;
}
self.headers.extend(headers);
self
}
#[must_use]
pub fn body(mut self, body: impl Into<Body>) -> Self {
if self.content_type_origin.is_generated() {
self.headers.remove(CONTENT_TYPE);
self.content_type_origin = ContentTypeOrigin::None;
}
clear_framing(&mut self.headers);
self.body = body.into();
self
}
pub fn query<T>(mut self, query: &T) -> Result<Self>
where
T: Serialize + ?Sized,
{
let query = serde_urlencoded::to_string(query)?;
self.query.extend(
url::form_urlencoded::parse(query.as_bytes())
.map(|(name, value)| (name.into_owned(), value.into_owned())),
);
Ok(self)
}
#[must_use]
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
#[must_use]
pub fn idempotent(mut self) -> Self {
self.explicitly_idempotent = true;
self
}
#[cfg(feature = "json")]
pub fn json<T>(mut self, value: &T) -> Result<Self>
where
T: Serialize + ?Sized,
{
if self.content_type_origin != ContentTypeOrigin::Caller {
self.headers
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
self.content_type_origin = ContentTypeOrigin::Generated;
}
clear_framing(&mut self.headers);
self.body = Body::json(value)?;
Ok(self)
}
pub fn form<T>(mut self, value: &T) -> Result<Self>
where
T: Serialize + ?Sized,
{
if self.content_type_origin != ContentTypeOrigin::Caller {
self.headers.insert(
CONTENT_TYPE,
HeaderValue::from_static("application/x-www-form-urlencoded"),
);
self.content_type_origin = ContentTypeOrigin::Generated;
}
clear_framing(&mut self.headers);
self.body = Body::form(value)?;
Ok(self)
}
#[cfg(feature = "multipart")]
pub fn multipart(mut self, multipart: Multipart) -> Result<Self> {
let (content_type, body) = multipart.encode()?;
self.headers.insert(CONTENT_TYPE, content_type);
self.content_type_origin = ContentTypeOrigin::Generated;
clear_framing(&mut self.headers);
self.body = body;
Ok(self)
}
pub fn build(self) -> Result<Request> {
let method = self
.method
.ok_or(Error::invalid_request("request method is required"))?;
if method == Method::TRACE && !self.auth.is_empty() {
return Err(Error::invalid_request(
"TRACE requests cannot use request authentication",
));
}
if self.timeout.is_some_and(|timeout| timeout.is_zero()) {
return Err(Error::invalid_request(
"request timeout must be greater than zero",
));
}
let raw_url = self
.url
.ok_or(Error::invalid_request("request URL is required"))?;
validate_http_authority_syntax(&raw_url)?;
let mut url = Url::parse(&raw_url)?;
validate_url(&url)?;
if !self.query.is_empty() {
let mut pairs = url.query_pairs_mut();
for (name, value) in self.query {
pairs.append_pair(&name, &value);
}
}
let mut headers = self.headers;
for auth in self.auth {
auth.apply(&mut headers, Some(&mut url))?;
}
if let Some("") = url.query() {
url.set_query(None);
}
validate_method_and_headers(&method, &headers, &self.body)?;
apply_framing(&mut headers, &self.body)?;
let body_present = !self.body.is_absent();
Ok(Request {
method,
url,
headers,
body: self.body,
timeout: self.timeout,
explicitly_idempotent: self.explicitly_idempotent,
client_generated: HashSet::new(),
body_present,
})
}
}
impl fmt::Debug for Request {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Request")
.field("method", &self.method)
.field("url", &SanitizedUrl(&self.url))
.field("header_count", &self.headers.len())
.field("body", &self.body)
.field("timeout", &self.timeout)
.field("explicitly_idempotent", &self.explicitly_idempotent)
.finish()
}
}
impl fmt::Debug for RequestBuilder {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("RequestBuilder")
.field("method", &self.method)
.field("has_url", &self.url.is_some())
.field("header_count", &self.headers.len())
.field("body", &self.body)
.field("timeout", &self.timeout)
.field("auth_count", &self.auth.len())
.field("query_count", &self.query.len())
.finish()
}
}
impl From<&str> for RequestBuilder {
fn from(url: &str) -> Self {
Self::default().url(url)
}
}
impl From<String> for RequestBuilder {
fn from(url: String) -> Self {
Self::default().url(url)
}
}
impl From<&String> for RequestBuilder {
fn from(url: &String) -> Self {
Self::default().url(url.clone())
}
}
impl From<Url> for RequestBuilder {
fn from(url: Url) -> Self {
Self::default().url(url.to_string())
}
}
impl From<&Url> for RequestBuilder {
fn from(url: &Url) -> Self {
Self::default().url(url.to_string())
}
}
pub(crate) fn same_origin(left: &Url, right: &Url) -> bool {
left.scheme() == right.scheme()
&& left.host_str().map(str::to_ascii_lowercase)
== right.host_str().map(str::to_ascii_lowercase)
&& left.port_or_known_default() == right.port_or_known_default()
}
pub(crate) fn reference_scheme(reference: &str) -> Option<(&str, &str)> {
let colon = reference.find(':')?;
let scheme = &reference[..colon];
if scheme.is_empty()
|| !scheme.as_bytes()[0].is_ascii_alphabetic()
|| !scheme
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'-' | b'.'))
{
return None;
}
Some((scheme, &reference[colon + 1..]))
}
pub(crate) fn validate_http_authority_syntax(reference: &str) -> Result<()> {
let Some((scheme, remainder)) = reference_scheme(reference) else {
return Ok(());
};
if !scheme.eq_ignore_ascii_case("http") && !scheme.eq_ignore_ascii_case("https") {
return Ok(());
}
let Some(authority_and_path) = remainder.strip_prefix("//") else {
return Err(Error::url(
"absolute HTTP and HTTPS references require an authority",
));
};
let authority_end = authority_and_path
.find(['/', '?', '#'])
.unwrap_or(authority_and_path.len());
if authority_end == 0 {
return Err(Error::url(
"absolute HTTP and HTTPS references require a non-empty authority",
));
}
Ok(())
}
fn validate_url(url: &Url) -> Result<()> {
if !matches!(url.scheme(), "http" | "https") {
return Err(Error::url("only HTTP and HTTPS URLs are supported"));
}
if url.host_str().is_none() {
return Err(Error::url("request URL requires a host"));
}
if !url.username().is_empty() || url.password().is_some() {
return Err(Error::url("request URL cannot contain userinfo"));
}
if url.fragment().is_some() {
return Err(Error::url("request URL cannot contain a fragment"));
}
Ok(())
}
fn validate_method_and_headers(method: &Method, headers: &HeaderMap, body: &Body) -> Result<()> {
if method == Method::CONNECT {
return Err(Error::invalid_request(
"CONNECT requires an owned tunnel API and is not supported",
));
}
if headers.contains_key(UPGRADE) {
return Err(Error::invalid_request(
"protocol upgrades are not supported without an owned connection API",
));
}
if headers.contains_key(CONNECTION)
|| headers.contains_key(TE)
|| headers.contains_key(HOST)
|| headers.contains_key("keep-alive")
|| headers.contains_key("proxy-connection")
|| headers.contains_key(PROXY_AUTHENTICATE)
|| headers.contains_key(PROXY_AUTHORIZATION)
{
return Err(Error::invalid_request(
"routing, hop-by-hop, and proxy authentication headers are managed by tez",
));
}
if method == Method::TRACE {
if !body.is_absent() {
return Err(Error::invalid_request(
"TRACE requests cannot contain content",
));
}
if headers
.iter()
.any(|(name, value)| value.is_sensitive() || is_credential_header(name))
{
return Err(Error::invalid_request(
"TRACE requests cannot contain credentials or sensitive fields",
));
}
}
if method == query_method() {
if body.len().is_none_or(|length| length == 0) {
return Err(Error::invalid_request(
"QUERY requests require non-empty content",
));
}
let content_types = headers.get_all(CONTENT_TYPE).iter().collect::<Vec<_>>();
if content_types.len() != 1 || !is_valid_media_type(content_types[0].as_bytes()) {
return Err(Error::invalid_request(
"QUERY requests require exactly one valid Content-Type",
));
}
}
if headers.contains_key(CONTENT_LENGTH) && headers.contains_key(TRANSFER_ENCODING) {
return Err(Error::invalid_request(
"Content-Length and Transfer-Encoding cannot both be set",
));
}
if headers.contains_key(TRANSFER_ENCODING) {
return Err(Error::invalid_request(
"Transfer-Encoding is managed by the transport",
));
}
Ok(())
}
fn apply_framing(headers: &mut HeaderMap, body: &Body) -> Result<()> {
let supplied = headers.get_all(CONTENT_LENGTH).iter().collect::<Vec<_>>();
if supplied.len() > 1 {
return Err(Error::invalid_request(
"multiple Content-Length values are not allowed",
));
}
if body.may_have_trailers() {
if !supplied.is_empty() {
return Err(Error::invalid_request(
"Content-Length cannot frame a body that may contain trailers",
));
}
if body.trailers().is_some_and(|trailers| {
trailers
.keys()
.any(|name| trailers.get_all(name).iter().count() > 1)
}) {
return Err(Error::invalid_request(
"outgoing trailers support only one value per field name",
));
}
let mut names = Vec::new();
for name in body.trailer_names() {
if !names.contains(&name) {
names.push(name);
}
}
if names.iter().any(is_forbidden_trailer_name) {
return Err(Error::invalid_request(
"a declared trailer name is forbidden by HTTP framing rules",
));
}
if names.is_empty() {
headers.remove(TRAILER);
} else {
let value = names
.iter()
.map(HeaderName::as_str)
.collect::<Vec<_>>()
.join(", ");
headers.insert(TRAILER, HeaderValue::from_str(&value)?);
}
return Ok(());
}
if headers.contains_key(TRAILER) {
return Err(Error::invalid_request(
"Trailer requires a trailer-capable body source",
));
}
match body.len() {
Some(length) => {
if let Some(value) = supplied.first() {
let parsed = value
.to_str()
.ok()
.and_then(|value| value.parse::<u64>().ok())
.ok_or(Error::invalid_request(
"Content-Length must be a decimal integer",
))?;
if parsed != length {
return Err(Error::invalid_request(
"Content-Length does not match the request body",
));
}
}
headers.insert(CONTENT_LENGTH, HeaderValue::from_str(&length.to_string())?);
}
None => {
if body.is_absent() {
if headers.contains_key(CONTENT_LENGTH) {
return Err(Error::invalid_request(
"Content-Length cannot be set for an absent body",
));
}
} else if headers.contains_key(CONTENT_LENGTH) {
return Err(Error::invalid_request(
"Content-Length requires a body with a trustworthy length",
));
}
}
}
Ok(())
}
fn is_valid_media_type(value: &[u8]) -> bool {
let mut position = 0;
if !consume_token(value, &mut position) || value.get(position) != Some(&b'/') {
return false;
}
position += 1;
if !consume_token(value, &mut position) {
return false;
}
loop {
consume_optional_whitespace(value, &mut position);
if position == value.len() {
return true;
}
if value.get(position) != Some(&b';') {
return false;
}
position += 1;
consume_optional_whitespace(value, &mut position);
if !consume_token(value, &mut position) || value.get(position) != Some(&b'=') {
return false;
}
position += 1;
if !consume_token(value, &mut position) && !consume_quoted_string(value, &mut position) {
return false;
}
}
}
fn consume_token(value: &[u8], position: &mut usize) -> bool {
let start = *position;
while value.get(*position).is_some_and(|byte| {
byte.is_ascii_alphanumeric()
|| matches!(
byte,
b'!' | b'#'
| b'$'
| b'%'
| b'&'
| b'\''
| b'*'
| b'+'
| b'-'
| b'.'
| b'^'
| b'_'
| b'`'
| b'|'
| b'~'
)
}) {
*position += 1;
}
*position > start
}
fn consume_optional_whitespace(value: &[u8], position: &mut usize) {
while matches!(value.get(*position), Some(b' ' | b'\t')) {
*position += 1;
}
}
fn consume_quoted_string(value: &[u8], position: &mut usize) -> bool {
if value.get(*position) != Some(&b'"') {
return false;
}
*position += 1;
while let Some(byte) = value.get(*position).copied() {
match byte {
b'"' => {
*position += 1;
return true;
}
b'\\' => {
*position += 1;
let Some(escaped) = value.get(*position).copied() else {
return false;
};
if !matches!(escaped, b'\t' | b' ' | 0x21..=0x7e | 0x80..=0xff) {
return false;
}
*position += 1;
}
b'\t' | b' ' | b'!' | 0x23..=0x5b | 0x5d..=0x7e | 0x80..=0xff => {
*position += 1;
}
_ => return false,
}
}
false
}
fn clear_framing(headers: &mut HeaderMap) {
headers.remove(CONTENT_LENGTH);
headers.remove(TRANSFER_ENCODING);
headers.remove(TRAILER);
}
fn clear_content_fields(headers: &mut HeaderMap) {
for name in [
CONTENT_ENCODING,
CONTENT_LANGUAGE,
CONTENT_LOCATION,
CONTENT_TYPE,
CONTENT_LENGTH,
TRANSFER_ENCODING,
TRAILER,
] {
headers.remove(name);
}
}
fn is_cross_origin_sensitive(name: &HeaderName) -> bool {
if matches!(name, &HOST | &ORIGIN | &REFERER | &CONNECTION) {
return true;
}
is_credential_header(name)
}
pub(crate) fn is_credential_header(name: &HeaderName) -> bool {
if matches!(name, &AUTHORIZATION | &PROXY_AUTHORIZATION | &COOKIE) {
return true;
}
let name = name.as_str();
["credential", "secret", "token", "api-key", "apikey"]
.iter()
.any(|needle| name.contains(needle))
}
#[cfg(test)]
mod describe_request {
use super::*;
#[test]
fn it_header_replaces_and_append_header_preserves_repeated_values() {
let request = Request::get("https://example.com")
.header("x-mode", "first")
.unwrap()
.header("x-mode", "replacement")
.unwrap()
.append_header("x-mode", "second")
.unwrap()
.build()
.unwrap();
let values = request
.headers()
.get_all("x-mode")
.iter()
.map(|value| value.to_str().unwrap())
.collect::<Vec<_>>();
assert_eq!(values, ["replacement", "second"]);
}
#[test]
fn it_body_replacement_recomputes_framing_and_helper_content_type() {
let request = Request::post("https://example.com")
.form(&[("name", "nous")])
.unwrap()
.body("raw")
.build()
.unwrap();
assert_eq!(request.headers().get(CONTENT_LENGTH).unwrap(), "3");
assert!(!request.headers().contains_key(CONTENT_TYPE));
}
#[test]
fn it_trace_rejects_content() {
let error = Request::trace("https://example.com")
.body("secret")
.build()
.unwrap_err();
assert!(error.to_string().contains("TRACE"));
}
#[test]
fn it_query_requires_non_empty_content_and_content_type() {
assert!(Request::query("https://example.com").build().is_err());
assert!(
Request::query("https://example.com")
.body("query")
.build()
.is_err()
);
let query = Request::query("https://example.com")
.header(CONTENT_TYPE, "application/query")
.unwrap()
.body("query")
.build()
.unwrap();
assert!(query.is_idempotent());
{
struct UnknownLength;
impl crate::BodySource for UnknownLength {
fn poll_frame(
self: std::pin::Pin<&mut Self>,
_context: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<Option<crate::BodyFrame>>> {
let _ = self;
std::task::Poll::Ready(Ok(None))
}
}
assert!(
Request::query("https://example.com")
.header(CONTENT_TYPE, "application/query")
.unwrap()
.body(Body::stream(UnknownLength))
.build()
.is_err()
);
}
}
#[test]
fn it_query_requires_exactly_one_valid_content_type() {
for content_type in [
"",
" ",
"application",
"/query",
"application/",
"application/query, text/plain",
"application/query; charset",
"application/query; charset=",
"application/query; profile=\"unterminated",
"application/query; profile=\"trailing\\",
] {
let error = Request::query("https://example.com")
.header(CONTENT_TYPE, content_type)
.unwrap()
.body("query")
.build()
.unwrap_err();
assert_eq!(
error.to_string(),
"invalid request: QUERY requests require exactly one valid Content-Type",
"accepted {content_type:?}"
);
}
for content_type in [
"application/query",
"application/query; charset=utf-8",
"application/query; profile=\"https://example.com/a;b\"",
"application/vnd.example+json; mode=\"escaped\\\"quote\"",
] {
Request::query("https://example.com")
.header(CONTENT_TYPE, content_type)
.unwrap()
.body("query")
.build()
.unwrap_or_else(|error| panic!("rejected {content_type:?}: {error}"));
}
let error = Request::query("https://example.com")
.header(CONTENT_TYPE, "application/query")
.unwrap()
.append_header(CONTENT_TYPE, "text/plain")
.unwrap()
.body("query")
.build()
.unwrap_err();
assert_eq!(
error.to_string(),
"invalid request: QUERY requests require exactly one valid Content-Type"
);
}
#[test]
fn it_rejects_non_http_userinfo_fragments_connect_and_upgrades() {
for url in [
"file:///tmp/value",
"http:g",
"HTTP:g",
"http:///g",
"https://user:pass@example.com/",
"https://example.com/#fragment",
] {
let error = Request::get(url).build().unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Url, "accepted {url}");
}
assert!(
Request::builder()
.method(Method::CONNECT)
.url("https://example.com")
.build()
.is_err()
);
assert!(
Request::get("https://example.com")
.header(UPGRADE, "websocket")
.unwrap()
.build()
.is_err()
);
for name in ["host", "connection", "te", "proxy-authorization"] {
assert!(
Request::get("https://example.com")
.header(name, "managed")
.unwrap()
.build()
.is_err(),
"accepted managed field {name}"
);
}
}
#[test]
fn it_trace_rejects_sensitive_fields_and_typed_auth() {
let mut sensitive = HeaderValue::from_static("secret");
sensitive.set_sensitive(true);
assert!(
Request::trace("https://example.com")
.header("x-secret", sensitive)
.unwrap()
.build()
.is_err()
);
assert!(
Request::trace("https://example.com")
.header(AUTHORIZATION, "Bearer secret")
.unwrap()
.build()
.is_err()
);
assert!(
Request::trace("https://example.com")
.auth(crate::ApiKey::query("api_key", "secret").unwrap())
.build()
.is_err()
);
}
#[test]
fn it_request_debug_redacts_url_headers_and_body() {
let request = Request::post("https://example.com/path?token=query-secret")
.header(AUTHORIZATION, "header-secret")
.unwrap()
.body("body-secret")
.build()
.unwrap();
let debug = format!("{request:?}");
for secret in ["query-secret", "header-secret", "body-secret"] {
assert!(!debug.contains(secret), "debug leaked {secret}: {debug}");
}
}
#[test]
fn it_into_parts_preserves_timeout() {
let request = Request::get("https://example.com")
.timeout(Duration::from_secs(3))
.build()
.unwrap();
let (_, _, _, _, timeout) = request.into_parts();
assert_eq!(timeout, Some(Duration::from_secs(3)));
}
#[test]
fn it_rejects_duplicate_manual_content_length_values() {
let error = Request::post("https://example.com")
.body("abc")
.append_header(CONTENT_LENGTH, "3")
.unwrap()
.append_header(CONTENT_LENGTH, "3")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: multiple Content-Length values are not allowed"
);
}
#[test]
fn it_rejects_malformed_manual_content_length() {
let error = Request::post("https://example.com")
.body("abc")
.header(CONTENT_LENGTH, "not-a-decimal")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Content-Length must be a decimal integer"
);
}
#[test]
fn it_rejects_manual_content_length_that_disagrees_with_the_body() {
let error = Request::post("https://example.com")
.body("abc")
.header(CONTENT_LENGTH, "4")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Content-Length does not match the request body"
);
}
#[test]
fn it_rejects_content_length_for_an_absent_body() {
let error = Request::post("https://example.com")
.header(CONTENT_LENGTH, "0")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Content-Length cannot be set for an absent body"
);
}
#[test]
fn it_rejects_content_length_for_an_unknown_length_body() {
struct UnknownLength;
impl crate::BodySource for UnknownLength {
fn poll_frame(
self: std::pin::Pin<&mut Self>,
_context: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<Option<crate::BodyFrame>>> {
let _ = self;
std::task::Poll::Ready(Ok(None))
}
}
let error = Request::post("https://example.com")
.body(Body::stream(UnknownLength))
.header(CONTENT_LENGTH, "1")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Content-Length requires a body with a trustworthy length"
);
}
#[test]
fn it_rejects_manual_transfer_encoding() {
let error = Request::post("https://example.com")
.body("abc")
.header(TRANSFER_ENCODING, "chunked")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Transfer-Encoding is managed by the transport"
);
}
#[test]
fn it_rejects_content_length_with_transfer_encoding() {
let error = Request::post("https://example.com")
.body("abc")
.header(CONTENT_LENGTH, "3")
.unwrap()
.header(TRANSFER_ENCODING, "chunked")
.unwrap()
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Content-Length and Transfer-Encoding cannot both be set"
);
}
#[test]
fn it_mutated_request_framing_is_revalidated_before_transport() {
let mut request = Request::post("https://example.com")
.body("abc")
.build()
.unwrap();
request
.headers_mut()
.insert(CONTENT_LENGTH, HeaderValue::from_static("4"));
let error = request.validate_for_send().unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
assert_eq!(
error.to_string(),
"invalid request: Content-Length does not match the request body"
);
}
#[test]
fn it_origin_includes_scheme_host_and_effective_port() {
let a = Url::parse("https://EXAMPLE.com/path").unwrap();
let b = Url::parse("https://example.com:443/other").unwrap();
let c = Url::parse("https://example.com:8443/").unwrap();
let d = Url::parse("http://example.com/").unwrap();
assert!(same_origin(&a, &b));
assert!(!same_origin(&a, &c));
assert!(!same_origin(&a, &d));
}
#[test]
fn it_trailer_capable_bodies_do_not_use_content_length_framing() {
struct TrailerCapable;
impl crate::BodySource for TrailerCapable {
fn poll_frame(
self: std::pin::Pin<&mut Self>,
_context: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<Option<crate::BodyFrame>>> {
let _ = self;
std::task::Poll::Ready(Ok(None))
}
fn len(&self) -> Option<u64> {
Some(0)
}
fn may_have_trailers(&self) -> bool {
true
}
}
let request = Request::post("https://example.com")
.body(Body::stream(TrailerCapable))
.build()
.unwrap();
assert!(!request.headers().contains_key(CONTENT_LENGTH));
}
#[tokio::test]
async fn it_collected_repeated_trailers_fail_before_transport() {
struct RepeatedTrailers(std::collections::VecDeque<crate::BodyFrame>);
impl crate::BodySource for RepeatedTrailers {
fn poll_frame(
mut self: std::pin::Pin<&mut Self>,
_context: &mut std::task::Context<'_>,
) -> std::task::Poll<Result<Option<crate::BodyFrame>>> {
std::task::Poll::Ready(Ok(self.0.pop_front()))
}
fn may_have_trailers(&self) -> bool {
true
}
fn trailer_names(&self) -> Vec<HeaderName> {
vec![HeaderName::from_static("x-checksum")]
}
}
let mut trailers = HeaderMap::new();
trailers.append("x-checksum", HeaderValue::from_static("first"));
trailers.append("x-checksum", HeaderValue::from_static("second"));
let body = Body::from_source(RepeatedTrailers(
[
crate::BodyFrame::Data(crate::BodyChunk::new("payload")),
crate::BodyFrame::Trailers(trailers),
]
.into(),
))
.collect_limited(1024)
.await
.unwrap();
let error = Request::post("https://example.com")
.body(body)
.build()
.unwrap_err();
assert_eq!(error.kind(), crate::ErrorKind::Request);
}
}