use crate::{Error, Result};
const DENIED_HEADERS: &[&str] = &[
"authorization",
"connection",
"content-length",
"cookie",
"host",
"keep-alive",
"proxy-authenticate",
"proxy-authorization",
"set-cookie",
"te",
"trailer",
"transfer-encoding",
"upgrade",
];
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Header {
name: String,
value: String,
}
impl Header {
pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
Self {
name: name.into(),
value: value.into(),
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn value(&self) -> &str {
&self.value
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct HeaderPolicy {
mutations: Vec<Header>,
}
impl HeaderPolicy {
pub fn builder() -> HeaderPolicyBuilder {
HeaderPolicyBuilder::default()
}
pub fn is_empty(&self) -> bool {
self.mutations.is_empty()
}
pub fn apply(&self, original: &[Header]) -> Result<Vec<Header>> {
let mut result = original.to_vec();
for mutation in &self.mutations {
let matches = result
.iter()
.enumerate()
.filter(|(_, header)| header.name.eq_ignore_ascii_case(&mutation.name))
.map(|(index, _)| index)
.collect::<Vec<_>>();
match matches.as_slice() {
[] => result.push(mutation.clone()),
[index] => result[*index].value.clone_from(&mutation.value),
_ => {
return Err(Error::invalid_interceptor_header(format!(
"cannot safely replace duplicate header {:?}",
mutation.name
)));
}
}
}
Ok(result)
}
}
#[derive(Clone, Debug, Default)]
pub struct HeaderPolicyBuilder {
mutations: Vec<Header>,
}
impl HeaderPolicyBuilder {
pub fn set_header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
let mutation = Header::new(name, value);
if let Some(existing) = self
.mutations
.iter_mut()
.find(|existing| existing.name.eq_ignore_ascii_case(&mutation.name))
{
*existing = mutation;
} else {
self.mutations.push(mutation);
}
self
}
pub fn build(self) -> Result<HeaderPolicy> {
for mutation in &self.mutations {
validate_mutation(mutation)?;
}
Ok(HeaderPolicy {
mutations: self.mutations,
})
}
}
fn validate_mutation(header: &Header) -> Result<()> {
if !is_http_token(&header.name) {
return Err(Error::invalid_interceptor_header(format!(
"header name {:?} is not a valid HTTP token",
header.name
)));
}
if DENIED_HEADERS
.iter()
.any(|denied| header.name.eq_ignore_ascii_case(denied))
{
return Err(Error::invalid_interceptor_header(format!(
"header {:?} is reserved and cannot be overridden",
header.name
)));
}
if header.value.bytes().any(|byte| {
byte == b'\r'
|| byte == b'\n'
|| byte == 0
|| (byte < 0x20 && byte != b'\t')
|| byte == 0x7f
}) {
return Err(Error::invalid_interceptor_header(format!(
"header {:?} contains an unsafe control character",
header.name
)));
}
Ok(())
}
fn is_http_token(name: &str) -> bool {
!name.is_empty()
&& name.bytes().all(|byte| {
byte.is_ascii_alphanumeric()
|| matches!(
byte,
b'!' | b'#'
| b'$'
| b'%'
| b'&'
| b'\''
| b'*'
| b'+'
| b'-'
| b'.'
| b'^'
| b'_'
| b'`'
| b'|'
| b'~'
)
})
}