use std::io::{BufRead, Read};
use std::net::SocketAddr;
use crate::body::Body;
use crate::error::{Error, Result};
use crate::headers::Headers;
use crate::json::Json;
use crate::method::Method;
const MAX_LINE: usize = 8 * 1024;
const MAX_HEADERS: usize = 100;
#[derive(Debug)]
pub struct Request {
pub method: Method,
pub target: String,
pub path: String,
pub query: String,
pub version: String,
pub headers: Headers,
pub peer: Option<SocketAddr>,
body: Body,
params: Vec<(String, String)>,
}
impl Request {
pub fn new(method: Method, target: &str) -> Request {
let (raw_path, query) = match target.split_once('?') {
Some((path, query)) => (path, query),
None => (target, ""),
};
Request {
method,
target: target.to_string(),
path: percent_decode(raw_path),
query: query.to_string(),
version: "HTTP/1.1".to_string(),
headers: Headers::new(),
peer: None,
body: Body::empty(),
params: Vec::new(),
}
}
pub fn with_header(mut self, name: &str, value: &str) -> Request {
self.headers.append(name, value);
self
}
pub fn with_body<B: Into<Body>>(mut self, body: B) -> Request {
self.body = body.into();
self
}
pub fn with_param(mut self, name: &str, value: &str) -> Request {
self.params.push((name.to_string(), value.to_string()));
self
}
pub fn with_version(mut self, version: &str) -> Request {
self.version = version.to_string();
self
}
pub fn with_peer(mut self, peer: SocketAddr) -> Request {
self.peer = Some(peer);
self
}
pub fn body(&self) -> &Body {
&self.body
}
pub fn into_body(self) -> Body {
self.body
}
pub fn param(&self, name: &str) -> Option<&str> {
self.params
.iter()
.find(|(k, _)| k == name)
.map(|(_, v)| v.as_str())
}
pub fn params(&self) -> impl Iterator<Item = (&str, &str)> {
self.params.iter().map(|(k, v)| (k.as_str(), v.as_str()))
}
pub(crate) fn set_params(&mut self, params: Vec<(String, String)>) {
self.params = params;
}
pub fn query_param(&self, name: &str) -> Option<String> {
for pair in self.query.split('&') {
if pair.is_empty() {
continue;
}
let (raw_key, raw_value) = match pair.split_once('=') {
Some((k, v)) => (k, v),
None => (pair, ""),
};
if percent_decode(raw_key) == name {
return Some(percent_decode(raw_value));
}
}
None
}
pub fn content_type(&self) -> Option<&str> {
self.headers.get("Content-Type")
}
pub fn body_str(&self) -> Result<&str> {
let bytes = self
.body
.as_bytes()
.ok_or(Error::Unsupported("reading a streaming body as text"))?;
std::str::from_utf8(bytes)
.map_err(|_| Error::BadRequest("request body is not valid utf-8".into()))
}
pub fn json(&self) -> Result<Json> {
Json::parse(self.body_str()?)
}
pub fn keep_alive(&self) -> bool {
match self.headers.get("Connection") {
Some(v) if v.eq_ignore_ascii_case("close") => false,
Some(v) if v.eq_ignore_ascii_case("keep-alive") => true,
_ => self.version != "HTTP/1.0",
}
}
pub fn read_from<R: BufRead>(reader: &mut R, max_body: usize) -> Result<Option<Request>> {
let mut line = Vec::new();
if read_line(reader, &mut line)? == 0 {
return Ok(None);
}
let (method, target, version) = {
let start = trim_line(&line);
if start.is_empty() {
return Err(Error::BadRequest("empty request line".into()));
}
let text = std::str::from_utf8(start)
.map_err(|_| Error::BadRequest("request line is not valid utf-8".into()))?;
let mut parts = text.split(' ').filter(|p| !p.is_empty());
let method_token = parts
.next()
.ok_or_else(|| Error::BadRequest("missing method".into()))?;
let target = parts
.next()
.ok_or_else(|| Error::BadRequest("missing request target".into()))?;
let version = parts.next().unwrap_or("HTTP/1.1");
if parts.next().is_some() {
return Err(Error::BadRequest("malformed request line".into()));
}
let method = Method::parse(method_token)
.ok_or_else(|| Error::BadRequest(format!("unknown method {method_token}")))?;
(method, target.to_string(), version.to_string())
};
let mut headers = Headers::new();
loop {
if read_line(reader, &mut line)? == 0 {
return Err(Error::BadRequest("connection closed inside headers".into()));
}
let field = trim_line(&line);
if field.is_empty() {
break;
}
if headers.len() >= MAX_HEADERS {
return Err(Error::BadRequest("too many header fields".into()));
}
let field = std::str::from_utf8(field)
.map_err(|_| Error::BadRequest("header is not valid utf-8".into()))?;
let (name, value) = field
.split_once(':')
.ok_or_else(|| Error::BadRequest("header without a colon".into()))?;
if name.is_empty() || name.contains(' ') {
return Err(Error::BadRequest("malformed header name".into()));
}
headers.append(name, value.trim());
}
if let Some(te) = headers.get("Transfer-Encoding") {
if te.to_ascii_lowercase().contains("chunked") {
return Err(Error::Unsupported("chunked request bodies"));
}
}
let length = match headers.get("Content-Length") {
Some(v) => v
.trim()
.parse::<usize>()
.map_err(|_| Error::BadRequest("invalid Content-Length".into()))?,
None => 0,
};
if length > max_body {
return Err(Error::BodyTooLarge { limit: max_body });
}
let mut body = vec![0u8; length];
if length > 0 {
std::io::Read::read_exact(reader, &mut body)?;
}
let (raw_path, query) = match target.split_once('?') {
Some((p, q)) => (p.to_string(), q.to_string()),
None => (target.clone(), String::new()),
};
Ok(Some(Request {
method,
target,
path: percent_decode(&raw_path),
query,
version,
headers,
peer: None,
body: Body::from(body),
params: Vec::new(),
}))
}
}
fn read_line<R: BufRead>(reader: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
buf.clear();
let n = reader
.by_ref()
.take(MAX_LINE as u64 + 1)
.read_until(b'\n', buf)?;
if n > MAX_LINE {
return Err(Error::BadRequest("line too long".into()));
}
Ok(n)
}
fn trim_line(line: &[u8]) -> &[u8] {
let mut end = line.len();
while end > 0 && (line[end - 1] == b'\n' || line[end - 1] == b'\r') {
end -= 1;
}
&line[..end]
}
pub fn percent_decode(input: &str) -> String {
let bytes = input.as_bytes();
let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
let mut i = 0;
while i < bytes.len() {
match bytes[i] {
b'%' if i + 2 < bytes.len() => {
let hi = hex_value(bytes[i + 1]);
let lo = hex_value(bytes[i + 2]);
match (hi, lo) {
(Some(h), Some(l)) => {
out.push(h * 16 + l);
i += 3;
}
_ => {
out.push(bytes[i]);
i += 1;
}
}
}
b'+' => {
out.push(b' ');
i += 1;
}
b => {
out.push(b);
i += 1;
}
}
}
String::from_utf8_lossy(&out).into_owned()
}
fn hex_value(b: u8) -> Option<u8> {
match b {
b'0'..=b'9' => Some(b - b'0'),
b'a'..=b'f' => Some(b - b'a' + 10),
b'A'..=b'F' => Some(b - b'A' + 10),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::BufReader;
fn parse(raw: &str) -> Result<Option<Request>> {
let mut reader = BufReader::new(raw.as_bytes());
Request::read_from(&mut reader, 64 * 1024)
}
#[test]
fn parses_a_simple_get() {
let req = parse("GET /users?page=2 HTTP/1.1\r\nHost: example.com\r\n\r\n")
.unwrap()
.unwrap();
assert_eq!(req.method, Method::Get);
assert_eq!(req.path, "/users");
assert_eq!(req.query, "page=2");
assert_eq!(req.headers.get("host"), Some("example.com"));
assert_eq!(req.body().is_empty(), Some(true));
}
#[test]
fn reads_a_body_of_the_declared_length() {
let req = parse("POST /x HTTP/1.1\r\nContent-Length: 5\r\n\r\nhello")
.unwrap()
.unwrap();
assert_eq!(req.body_str().unwrap(), "hello");
}
#[test]
fn body_beyond_content_length_is_not_consumed() {
let req = parse("POST /x HTTP/1.1\r\nContent-Length: 2\r\n\r\nhiEXTRA")
.unwrap()
.unwrap();
assert_eq!(req.body_str().unwrap(), "hi");
}
#[test]
fn clean_eof_is_not_an_error() {
assert!(parse("").unwrap().is_none());
}
#[test]
fn decodes_percent_escapes_in_the_path() {
let req = parse("GET /a%20b/c%2Fd HTTP/1.1\r\n\r\n").unwrap().unwrap();
assert_eq!(req.path, "/a b/c/d");
}
#[test]
fn decodes_query_parameters() {
let req = parse("GET /s?q=hello+world&n=%41 HTTP/1.1\r\n\r\n")
.unwrap()
.unwrap();
assert_eq!(req.query_param("q").as_deref(), Some("hello world"));
assert_eq!(req.query_param("n").as_deref(), Some("A"));
assert_eq!(req.query_param("missing"), None);
}
#[test]
fn rejects_bad_input() {
assert!(parse("BREW /coffee HTTP/1.1\r\n\r\n").is_err());
assert!(parse("GET\r\n\r\n").is_err());
assert!(parse("GET / HTTP/1.1\r\nNoColonHere\r\n\r\n").is_err());
assert!(parse("POST /x HTTP/1.1\r\nContent-Length: abc\r\n\r\n").is_err());
}
#[test]
fn rejects_chunked_rather_than_mangling_it() {
let err = parse("POST /x HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n").unwrap_err();
assert!(matches!(err, Error::Unsupported(_)));
}
#[test]
fn enforces_the_body_limit() {
let mut reader = BufReader::new(&b"POST /x HTTP/1.1\r\nContent-Length: 100\r\n\r\n"[..]);
let err = Request::read_from(&mut reader, 10).unwrap_err();
assert!(matches!(err, Error::BodyTooLarge { limit: 10 }));
}
#[test]
fn keep_alive_defaults_by_version() {
let one_one = parse("GET / HTTP/1.1\r\n\r\n").unwrap().unwrap();
assert!(one_one.keep_alive());
let one_zero = parse("GET / HTTP/1.0\r\n\r\n").unwrap().unwrap();
assert!(!one_zero.keep_alive());
let closing = parse("GET / HTTP/1.1\r\nConnection: close\r\n\r\n")
.unwrap()
.unwrap();
assert!(!closing.keep_alive());
}
#[test]
fn a_line_that_never_ends_is_capped_rather_than_buffered() {
let source = std::io::repeat(b'a').take(1024 * 1024);
let mut reader = BufReader::new(source);
let mut line = Vec::new();
let err = read_line(&mut reader, &mut line).unwrap_err();
assert!(matches!(err, Error::BadRequest(_)), "got {err:?}");
assert!(
line.len() <= MAX_LINE + 1,
"buffered {} bytes for an {MAX_LINE} byte cap",
line.len()
);
}
#[test]
fn a_request_can_be_built_without_a_socket() {
let req = Request::new(Method::Post, "/users/42?verbose=1")
.with_header("Content-Type", "application/json")
.with_param("id", "42")
.with_body(r#"{"name":"joist"}"#);
assert_eq!(req.method, Method::Post);
assert_eq!(req.path, "/users/42");
assert_eq!(req.query, "verbose=1");
assert_eq!(req.query_param("verbose").as_deref(), Some("1"));
assert_eq!(req.param("id"), Some("42"));
assert_eq!(req.content_type(), Some("application/json"));
assert_eq!(
req.json().unwrap().get("name").and_then(Json::as_str),
Some("joist")
);
}
#[test]
fn a_built_request_decodes_its_path_like_the_parser_does() {
let req = Request::new(Method::Get, "/a%20b/c");
assert_eq!(req.path, "/a b/c");
assert_eq!(req.target, "/a%20b/c");
assert_eq!(req.version, "HTTP/1.1");
assert!(req.keep_alive());
}
#[test]
fn debug_does_not_print_the_body() {
let req = Request::new(Method::Post, "/login").with_body("password=hunter2");
let text = format!("{req:?}");
assert!(text.contains("Body(16 bytes)"), "got {text}");
assert!(!text.contains("hunter2"), "got {text}");
}
#[test]
fn parses_a_json_body() {
let req = parse("POST /x HTTP/1.1\r\nContent-Length: 13\r\n\r\n{\"ok\":true}\r\n")
.unwrap()
.unwrap();
let value = Json::parse(req.body_str().unwrap().trim()).unwrap();
assert_eq!(value.get("ok").and_then(Json::as_bool), Some(true));
}
}