use std::path::PathBuf;
use crate::error::{Error, Result};
const EMPTY_NAME: &str = "request item name cannot be empty";
const EMPTY_PATH: &str = "request item file path cannot be empty";
const INVALID_ITEM: &str = "request item is malformed";
const INVALID_MEDIA_TYPE: &str = "upload media type is invalid";
const MULTIPLE_BODY_FILES: &str = "only one request body file can be sent";
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct Items {
pub(crate) entries: Vec<Item>,
pub(crate) body_file: Option<PathBuf>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum Item {
Header { name: String, value: HeaderValue },
Query { name: String, value: Value },
Field { name: String, value: Value },
Json { name: String, value: Value },
Upload(Upload),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum HeaderValue {
Value(Value),
Unset,
Empty,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum Value {
Text(String),
File(PathBuf),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct Upload {
pub(crate) name: String,
pub(crate) path: PathBuf,
pub(crate) media_type: Option<String>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum Operator {
Header,
Query,
Field,
Json,
Upload,
}
impl Items {
pub(crate) fn parse(values: &[String]) -> Result<Self> {
let mut items = Self {
entries: Vec::with_capacity(values.len()),
body_file: None,
};
for value in values {
match parse_item(value)? {
Parsed::Item(item) => items.entries.push(item),
Parsed::BodyFile(path) if items.body_file.is_none() => {
items.body_file = Some(path);
}
Parsed::BodyFile(_) => return Err(Error::usage(MULTIPLE_BODY_FILES)),
}
}
Ok(items)
}
}
enum Parsed {
Item(Item),
BodyFile(PathBuf),
}
fn parse_item(value: &str) -> Result<Parsed> {
if let Some(name) = empty_header_name(value)? {
return Ok(Parsed::Item(Item::Header {
name,
value: HeaderValue::Empty,
}));
}
let Some((index, operator, width)) = find_operator(value) else {
return Err(Error::usage(INVALID_ITEM));
};
let raw_name = &value[..index];
let raw_value = &value[(index + width)..];
if operator == Operator::Upload && raw_name.is_empty() {
return Ok(Parsed::BodyFile(file_path(raw_value)?));
}
if raw_name.is_empty() {
return Err(Error::usage(EMPTY_NAME));
}
let name = unescape(raw_name);
if name.is_empty() {
return Err(Error::usage(EMPTY_NAME));
}
let item = match operator {
Operator::Header => Item::Header {
name,
value: if raw_value.is_empty() {
HeaderValue::Unset
} else {
HeaderValue::Value(parse_value(raw_value)?)
},
},
Operator::Query => Item::Query {
name,
value: parse_value(raw_value)?,
},
Operator::Field => Item::Field {
name,
value: parse_value(raw_value)?,
},
Operator::Json => Item::Json {
name,
value: parse_value(raw_value)?,
},
Operator::Upload => Item::Upload(parse_upload(name, raw_value)?),
};
Ok(Parsed::Item(item))
}
fn parse_value(value: &str) -> Result<Value> {
if let Some(path) = value.strip_prefix('@') {
return file_path(path).map(Value::File);
}
Ok(Value::Text(unescape(value)))
}
fn parse_upload(name: String, value: &str) -> Result<Upload> {
let (path, media_type) = match find_unescaped(value, ";type=") {
Some(index) => {
let raw_media_type = &value[(index + ";type=".len())..];
let media_type = unescape(raw_media_type);
if media_type.is_empty() || media_type.parse::<mime_guess::Mime>().is_err() {
return Err(Error::usage(INVALID_MEDIA_TYPE));
}
(&value[..index], Some(media_type))
}
None => (value, None),
};
Ok(Upload {
name,
path: file_path(path)?,
media_type,
})
}
fn file_path(value: &str) -> Result<PathBuf> {
if value.is_empty() {
return Err(Error::usage(EMPTY_PATH));
}
Ok(PathBuf::from(value))
}
fn empty_header_name(value: &str) -> Result<Option<String>> {
let Some(index) = trailing_unescaped_semicolon(value) else {
return Ok(None);
};
if find_operator(&value[..index]).is_some() {
return Ok(None);
}
let name = unescape(&value[..index]);
if name.is_empty() {
return Err(Error::usage(EMPTY_NAME));
}
Ok(Some(name))
}
fn trailing_unescaped_semicolon(value: &str) -> Option<usize> {
let index = value.len().checked_sub(1)?;
(value.as_bytes()[index] == b';' && !is_escaped(value.as_bytes(), index)).then_some(index)
}
fn find_operator(value: &str) -> Option<(usize, Operator, usize)> {
let bytes = value.as_bytes();
let mut index = 0;
while index < bytes.len() {
if bytes[index] == b'\\' {
index += if index + 1 < bytes.len() { 2 } else { 1 };
continue;
}
let found = match bytes[index] {
b':' if bytes.get(index + 1) == Some(&b'=') => Some((Operator::Json, 2)),
b'=' if bytes.get(index + 1) == Some(&b'=') => Some((Operator::Query, 2)),
b'@' => Some((Operator::Upload, 1)),
b'=' => Some((Operator::Field, 1)),
b':' => Some((Operator::Header, 1)),
_ => None,
};
if let Some((operator, width)) = found {
return Some((index, operator, width));
}
index += 1;
}
None
}
fn find_unescaped(value: &str, needle: &str) -> Option<usize> {
let bytes = value.as_bytes();
let needle = needle.as_bytes();
let mut index = 0;
while index + needle.len() <= bytes.len() {
if bytes[index] == b'\\' {
index += if index + 1 < bytes.len() { 2 } else { 1 };
continue;
}
if &bytes[index..(index + needle.len())] == needle {
return Some(index);
}
index += 1;
}
None
}
fn is_escaped(bytes: &[u8], index: usize) -> bool {
let mut preceding = 0;
let mut cursor = index;
while cursor > 0 && bytes[cursor - 1] == b'\\' {
preceding += 1;
cursor -= 1;
}
preceding % 2 == 1
}
fn unescape(value: &str) -> String {
let mut output = String::with_capacity(value.len());
let mut characters = value.chars().peekable();
while let Some(character) = characters.next() {
if character == '\\'
&& characters
.peek()
.is_some_and(|next| matches!(next, '\\' | ':' | ';' | '=' | '@'))
{
output.push(characters.next().expect("peeked character must exist"));
} else {
output.push(character);
}
}
output
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(values: &[&str]) -> Items {
let values = values.iter().map(ToString::to_string).collect::<Vec<_>>();
Items::parse(&values).unwrap()
}
#[test]
fn parses_every_top_level_operator_in_order() {
let items = parse(&[
"X-Trace:one",
"page==2",
"name=Tez",
"active:=true",
"avatar@photo.png",
"X-Trace:two",
]);
assert_eq!(
items.entries,
[
Item::Header {
name: "X-Trace".to_owned(),
value: HeaderValue::Value(Value::Text("one".to_owned())),
},
Item::Query {
name: "page".to_owned(),
value: Value::Text("2".to_owned()),
},
Item::Field {
name: "name".to_owned(),
value: Value::Text("Tez".to_owned()),
},
Item::Json {
name: "active".to_owned(),
value: Value::Text("true".to_owned()),
},
Item::Upload(Upload {
name: "avatar".to_owned(),
path: PathBuf::from("photo.png"),
media_type: None,
}),
Item::Header {
name: "X-Trace".to_owned(),
value: HeaderValue::Value(Value::Text("two".to_owned())),
},
]
);
}
#[test]
fn longest_operator_wins_at_the_earliest_position() {
let items = parse(&["a:=1==2", "b==3=4", "X-Value:a:=b"]);
assert!(matches!(&items.entries[0], Item::Json { name, .. } if name == "a"));
assert!(matches!(&items.entries[1], Item::Query { name, .. } if name == "b"));
assert_eq!(
items.entries[2],
Item::Header {
name: "X-Value".to_owned(),
value: HeaderValue::Value(Value::Text("a:=b".to_owned())),
}
);
}
#[test]
fn escaped_operators_are_data() {
let items = parse(&[
r"name\=part=value\=with\:operators",
r"X\-Name:one\;two",
r"q\==value",
]);
assert_eq!(
items.entries,
[
Item::Field {
name: "name=part".to_owned(),
value: Value::Text("value=with:operators".to_owned()),
},
Item::Header {
name: r"X\-Name".to_owned(),
value: HeaderValue::Value(Value::Text("one;two".to_owned())),
},
Item::Field {
name: "q=".to_owned(),
value: Value::Text("value".to_owned()),
},
]
);
}
#[test]
fn distinguishes_unset_and_empty_headers() {
let items = parse(&["Accept-Encoding:", "X-Empty;"]);
assert_eq!(
items.entries,
[
Item::Header {
name: "Accept-Encoding".to_owned(),
value: HeaderValue::Unset,
},
Item::Header {
name: "X-Empty".to_owned(),
value: HeaderValue::Empty,
},
]
);
}
#[test]
fn a_valued_header_may_end_in_a_semicolon() {
let items = parse(&["Cookie:a=b;"]);
assert_eq!(
items.entries,
[Item::Header {
name: "Cookie".to_owned(),
value: HeaderValue::Value(Value::Text("a=b;".to_owned())),
}]
);
}
#[test]
fn parses_every_file_value_variant() {
let items = parse(&[
"X-Data:@header.txt",
"query==@query.txt",
"name=@field.txt",
"config:=@config.json",
"@body.bin",
]);
assert_eq!(
items.entries,
[
Item::Header {
name: "X-Data".to_owned(),
value: HeaderValue::Value(Value::File(PathBuf::from("header.txt"))),
},
Item::Query {
name: "query".to_owned(),
value: Value::File(PathBuf::from("query.txt")),
},
Item::Field {
name: "name".to_owned(),
value: Value::File(PathBuf::from("field.txt")),
},
Item::Json {
name: "config".to_owned(),
value: Value::File(PathBuf::from("config.json")),
},
]
);
assert_eq!(items.body_file, Some(PathBuf::from("body.bin")));
}
#[test]
fn parses_upload_media_type_and_keeps_windows_backslashes() {
let items = parse(&[r"archive@C:\tmp\data.bin;type=application/octet-stream"]);
assert_eq!(
items.entries,
[Item::Upload(Upload {
name: "archive".to_owned(),
path: PathBuf::from(r"C:\tmp\data.bin"),
media_type: Some("application/octet-stream".to_owned()),
})]
);
}
#[test]
fn file_paths_keep_backslashes_literal() {
let items = parse(&[
r"drive@C:\@dir\data.bin",
r"unc@\\server\share\body.bin",
r"relative@..\@dir\body.bin",
r"dot@.\=dir\body.bin",
]);
assert_eq!(
items.entries,
[
Item::Upload(Upload {
name: "drive".to_owned(),
path: PathBuf::from(r"C:\@dir\data.bin"),
media_type: None,
}),
Item::Upload(Upload {
name: "unc".to_owned(),
path: PathBuf::from(r"\\server\share\body.bin"),
media_type: None,
}),
Item::Upload(Upload {
name: "relative".to_owned(),
path: PathBuf::from(r"..\@dir\body.bin"),
media_type: None,
}),
Item::Upload(Upload {
name: "dot".to_owned(),
path: PathBuf::from(r".\=dir\body.bin"),
media_type: None,
}),
]
);
}
#[test]
fn backslashes_in_upload_paths_are_not_escape_characters() {
let items = parse(&[r"file@data\;type\=notes.txt"]);
assert_eq!(
items.entries,
[Item::Upload(Upload {
name: "file".to_owned(),
path: PathBuf::from(r"data\;type\=notes.txt"),
media_type: None,
})]
);
}
#[test]
fn rejects_multiple_body_files() {
let values = ["@one", "@top-secret"]
.into_iter()
.map(ToOwned::to_owned)
.collect::<Vec<_>>();
let error = Items::parse(&values).unwrap_err();
assert_eq!(error.to_string(), MULTIPLE_BODY_FILES);
assert!(!error.to_string().contains("secret"));
}
#[test]
fn rejects_empty_names_and_paths_without_echoing_values() {
for (value, expected) in [
("=secret", EMPTY_NAME),
("@", EMPTY_PATH),
("name@", EMPTY_PATH),
("secret", INVALID_ITEM),
] {
let values = [value.to_owned()];
let error = Items::parse(&values).unwrap_err();
assert_eq!(error.to_string(), expected);
assert!(!error.to_string().contains("secret"));
}
}
#[test]
fn rejects_invalid_upload_media_types_without_echoing_them() {
let values = ["file@secret.txt;type=not a media type".to_owned()];
let error = Items::parse(&values).unwrap_err();
assert_eq!(error.to_string(), INVALID_MEDIA_TYPE);
assert!(!error.to_string().contains("secret"));
}
}