#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Response {
pub version: String,
pub status: u16,
pub reason: String,
pub headers: Vec<(String, String)>,
pub body: Vec<u8>,
}
#[cfg(test)]
impl Response {
fn header(&self, name: &str) -> Option<&str> {
self.headers
.iter()
.find(|(key, _)| key == name)
.map(|(_, value)| value.as_str())
}
}
pub(crate) fn parse_response(raw: &[u8]) -> Option<Response> {
let (head, body) = split_head(raw);
let head = latin1(head);
let mut lines = head.split("\r\n").flat_map(|line| line.split('\n'));
let status_line = lines.next()?;
let (version, status, reason) = parse_status_line(status_line)?;
let headers: Vec<(String, String)> = lines
.filter(|line| !line.is_empty())
.filter_map(parse_header)
.collect();
let body = decode_body(&headers, body);
Some(Response {
version,
status,
reason,
headers,
body,
})
}
pub(crate) fn build_request(
method: &str,
path: &str,
host: &str,
headers: &[(String, String)],
body: &[u8],
) -> Vec<u8> {
let mut out = String::new();
out.push_str(&format!("{method} {path} HTTP/1.1\r\n"));
out.push_str(&format!("Host: {host}\r\n"));
for (name, value) in headers {
out.push_str(&format!("{name}: {value}\r\n"));
}
if !body.is_empty() {
out.push_str(&format!("Content-Length: {}\r\n", body.len()));
}
out.push_str("\r\n");
let mut bytes = out.into_bytes();
bytes.extend_from_slice(body);
bytes
}
fn split_head(raw: &[u8]) -> (&[u8], &[u8]) {
if let Some(at) = find(raw, b"\r\n\r\n") {
(&raw[..at], &raw[at + 4..])
} else if let Some(at) = find(raw, b"\n\n") {
(&raw[..at], &raw[at + 2..])
} else {
(raw, &[])
}
}
fn parse_status_line(line: &str) -> Option<(String, u16, String)> {
let mut parts = line.splitn(3, ' ');
let version = parts.next()?;
if !version.starts_with("HTTP/") {
return None;
}
let status = parts.next()?.parse::<u16>().ok()?;
let reason = parts.next().unwrap_or("").trim().to_string();
Some((version.to_string(), status, reason))
}
fn parse_header(line: &str) -> Option<(String, String)> {
let (name, value) = line.split_once(':')?;
let name = name.trim();
if name.is_empty() {
return None;
}
Some((name.to_ascii_lowercase(), value.trim().to_string()))
}
fn decode_body(headers: &[(String, String)], body: &[u8]) -> Vec<u8> {
let header = |name: &str| {
headers
.iter()
.find(|(key, _)| key == name)
.map(|(_, value)| value.as_str())
};
if header("transfer-encoding").is_some_and(|value| {
value
.split(',')
.any(|token| token.trim().eq_ignore_ascii_case("chunked"))
}) {
return dechunk(body);
}
if let Some(length) =
header("content-length").and_then(|value| value.trim().parse::<usize>().ok())
{
return body[..length.min(body.len())].to_vec();
}
body.to_vec()
}
fn dechunk(mut data: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
while let Some(eol) = find(data, b"\r\n") {
let size_token = latin1(&data[..eol]);
let size_token = size_token.split(';').next().unwrap_or("").trim();
let Ok(size) = usize::from_str_radix(size_token, 16) else {
break;
};
if size == 0 {
break;
}
let start = eol + 2;
let end = start + size;
if end > data.len() {
out.extend_from_slice(&data[start..]);
break;
}
out.extend_from_slice(&data[start..end]);
data = &data[(end + 2).min(data.len())..];
}
out
}
fn find(haystack: &[u8], needle: &[u8]) -> Option<usize> {
haystack
.windows(needle.len())
.position(|window| window == needle)
}
fn latin1(bytes: &[u8]) -> String {
bytes.iter().map(|&byte| byte as char).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_content_length_response_parses_status_headers_and_body() {
let raw = b"HTTP/1.1 200 OK\r\n\
Server: nginx/1.25.3\r\n\
Content-Type: text/html\r\n\
Content-Length: 5\r\n\r\n\
helloTRAILING";
let response = parse_response(raw).expect("a well-formed response parses");
assert_eq!(response.version, "HTTP/1.1");
assert_eq!(response.status, 200);
assert_eq!(response.reason, "OK");
assert_eq!(response.header("server"), Some("nginx/1.25.3"));
assert_eq!(response.header("content-type"), Some("text/html"));
assert_eq!(response.body, b"hello");
}
#[test]
fn a_chunked_body_is_reassembled() {
let raw = b"HTTP/1.1 200 OK\r\n\
Transfer-Encoding: chunked\r\n\r\n\
5\r\nhello\r\n7\r\n, world\r\n0\r\n\r\n";
let response = parse_response(raw).expect("a chunked response parses");
assert_eq!(response.body, b"hello, world");
}
#[test]
fn a_redirect_status_line_reads_its_code() {
let raw = b"HTTP/1.1 308 Permanent Redirect\r\nLocation: https://example.com/\r\n\r\n";
let response = parse_response(raw).expect("a redirect parses");
assert_eq!(response.status, 308);
assert_eq!(response.header("location"), Some("https://example.com/"));
assert!(response.body.is_empty());
}
#[test]
fn a_non_http_reply_does_not_parse() {
assert!(parse_response(b"SSH-2.0-OpenSSH_9.6p1\r\n").is_none());
assert!(parse_response(b"").is_none());
assert!(parse_response(b"+PONG\r\n").is_none());
}
#[test]
fn a_truncated_chunk_yields_what_arrived_rather_than_reading_past_it() {
let raw = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n8\r\nabcd";
let response = parse_response(raw).expect("a truncated chunked response still parses");
assert_eq!(response.body, b"abcd");
}
#[test]
fn a_built_request_is_well_formed_and_counts_its_body() {
let request = build_request(
"POST",
"/login",
"example.com",
&[("Content-Type".to_string(), "application/json".to_string())],
b"{}",
);
let text = latin1(&request);
assert_eq!(
text,
"POST /login HTTP/1.1\r\n\
Host: example.com\r\n\
Content-Type: application/json\r\n\
Content-Length: 2\r\n\r\n\
{}"
);
}
#[test]
fn a_bodyless_request_sets_no_content_length() {
let request = build_request("GET", "/", "example.com", &[], b"");
let text = latin1(&request);
assert_eq!(text, "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");
}
}