tvl-depot/users/Profpatsch/read-http.rs
Vincent Ambo 3d8ee62087 style(rust): Format all Rust code with rustfmt
Change-Id: Iab7e00cc26a4f9727d3ab98691ef379921a33052
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5240
Tested-by: BuildkiteCI
Reviewed-by: kanepyork <rikingcoding@gmail.com>
Reviewed-by: Profpatsch <mail@profpatsch.de>
Reviewed-by: grfn <grfn@gws.fyi>
Reviewed-by: tazjin <tazjin@tvl.su>
2022-02-08 12:06:39 +00:00

249 lines
8.4 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

extern crate arglib_netencode;
extern crate ascii;
extern crate exec_helpers;
extern crate httparse;
extern crate netencode;
use exec_helpers::{die_expected_error, die_temporary, die_user_error};
use std::collections::HashMap;
use std::io::{Read, Write};
use std::os::unix::io::FromRawFd;
use netencode::dec::Decoder;
use netencode::{dec, T, U};
enum What {
Request,
Response,
}
// reads a http request (stdin), and writes all headers to stdout, as netencoded record.
// The keys are text, but can be lists of text iff headers appear multiple times, so beware.
fn main() -> std::io::Result<()> {
exec_helpers::no_args("read-http");
let args = dec::RecordDot {
field: "what",
inner: dec::OneOf {
list: vec!["request", "response"],
inner: dec::Text,
},
};
let what: What = match args.dec(arglib_netencode::arglib_netencode("read-http", None).to_u()) {
Ok("request") => What::Request,
Ok("response") => What::Response,
Ok(v) => panic!("shouldnt happen!, value was: {}", v),
Err(dec::DecodeError(err)) => die_user_error("read-http", err),
};
fn read_stdin_to_complete<F>(mut parse: F) -> ()
where
F: FnMut(&[u8]) -> httparse::Result<usize>,
{
let mut res = httparse::Status::Partial;
loop {
if let httparse::Status::Complete(_) = res {
return;
}
let mut buf = [0; 2048];
match std::io::stdin().read(&mut buf[..]) {
Ok(size) => {
if size == 0 {
break;
}
}
Err(err) => {
die_temporary("read-http", format!("could not read from stdin, {:?}", err))
}
}
match parse(&buf) {
Ok(status) => {
res = status;
}
Err(err) => {
die_temporary("read-http", format!("httparse parsing failed: {:#?}", err))
}
}
}
}
fn normalize_headers<'a>(headers: &'a [httparse::Header]) -> HashMap<String, U<'a>> {
let mut res = HashMap::new();
for httparse::Header { name, value } in headers {
let val = ascii::AsciiStr::from_ascii(*value)
.expect(&format!(
"read-http: we require header values to be ASCII, but the header {} was {:?}",
name, value
))
.as_str();
// lowercase the header names, since the standard doesnt care
// and we want unique strings to match against
let name_lower = name.to_lowercase();
match res.insert(name_lower, U::Text(val)) {
None => (),
Some(U::Text(t)) => {
let name_lower = name.to_lowercase();
let _ = res.insert(name_lower, U::List(vec![U::Text(t), U::Text(val)]));
()
}
Some(U::List(mut l)) => {
let name_lower = name.to_lowercase();
l.push(U::Text(val));
let _ = res.insert(name_lower, U::List(l));
()
}
Some(o) => panic!("read-http: header not text nor list: {:?}", o),
}
}
res
}
// tries to read until the end of the http header (deliniated by two newlines "\r\n\r\n")
fn read_till_end_of_header<R: Read>(buf: &mut Vec<u8>, reader: R) -> Option<()> {
let mut chonker = Chunkyboi::new(reader, 4096);
loop {
// TODO: attacker can send looooong input, set upper maximum
match chonker.next() {
Some(Ok(chunk)) => {
buf.extend_from_slice(&chunk);
if chunk.windows(4).any(|c| c == b"\r\n\r\n") {
return Some(());
}
}
Some(Err(err)) => {
die_temporary("read-http", format!("error reading from stdin: {:?}", err))
}
None => return None,
}
}
}
// max header size chosen arbitrarily
let mut headers = [httparse::EMPTY_HEADER; 128];
let stdin = std::io::stdin();
match what {
Request => {
let mut req = httparse::Request::new(&mut headers);
let mut buf: Vec<u8> = vec![];
match read_till_end_of_header(&mut buf, stdin.lock()) {
Some(()) => match req.parse(&buf) {
Ok(httparse::Status::Complete(_body_start)) => {}
Ok(httparse::Status::Partial) => {
die_expected_error("read-http", "httparse should have gotten a full header")
}
Err(err) => die_expected_error(
"read-http",
format!("httparse response parsing failed: {:#?}", err),
),
},
None => die_expected_error(
"read-http",
format!("httparse end of stdin reached before able to parse request headers"),
),
}
let method = req.method.expect("method must be filled on complete parse");
let path = req.path.expect("path must be filled on complete parse");
write_dict_req(method, path, &normalize_headers(req.headers))
}
Response => {
let mut resp = httparse::Response::new(&mut headers);
let mut buf: Vec<u8> = vec![];
match read_till_end_of_header(&mut buf, stdin.lock()) {
Some(()) => match resp.parse(&buf) {
Ok(httparse::Status::Complete(_body_start)) => {}
Ok(httparse::Status::Partial) => {
die_expected_error("read-http", "httparse should have gotten a full header")
}
Err(err) => die_expected_error(
"read-http",
format!("httparse response parsing failed: {:#?}", err),
),
},
None => die_expected_error(
"read-http",
format!("httparse end of stdin reached before able to parse response headers"),
),
}
let code = resp.code.expect("code must be filled on complete parse");
let reason = resp
.reason
.expect("reason must be filled on complete parse");
write_dict_resp(code, reason, &normalize_headers(resp.headers))
}
}
}
fn write_dict_req<'a, 'buf>(
method: &'buf str,
path: &'buf str,
headers: &'a HashMap<String, U<'a>>,
) -> std::io::Result<()> {
let mut http = vec![("method", U::Text(method)), ("path", U::Text(path))]
.into_iter()
.collect();
write_dict(http, headers)
}
fn write_dict_resp<'a, 'buf>(
code: u16,
reason: &'buf str,
headers: &'a HashMap<String, U<'a>>,
) -> std::io::Result<()> {
let mut http = vec![
("status", U::N6(code as u64)),
("status-text", U::Text(reason)),
]
.into_iter()
.collect();
write_dict(http, headers)
}
fn write_dict<'buf, 'a>(
mut http: HashMap<&str, U<'a>>,
headers: &'a HashMap<String, U<'a>>,
) -> std::io::Result<()> {
match http.insert(
"headers",
U::Record(
headers
.iter()
.map(|(k, v)| (k.as_str(), v.clone()))
.collect(),
),
) {
None => (),
Some(_) => panic!("read-http: headers already in dict"),
};
netencode::encode(&mut std::io::stdout(), &U::Record(http))?;
Ok(())
}
// iter helper
struct Chunkyboi<T> {
inner: T,
buf: Vec<u8>,
}
impl<R: Read> Chunkyboi<R> {
fn new(inner: R, chunksize: usize) -> Self {
let buf = vec![0; chunksize];
Chunkyboi { inner, buf }
}
}
impl<R: Read> Iterator for Chunkyboi<R> {
type Item = std::io::Result<Vec<u8>>;
fn next(&mut self) -> Option<std::io::Result<Vec<u8>>> {
match self.inner.read(&mut self.buf) {
Ok(0) => None,
Ok(read) => {
// clone a new buffer so we can reuse the internal one
Some(Ok(self.buf[..read].to_owned()))
}
Err(err) => Some(Err(err)),
}
}
}