363 lines
11 KiB
Rust
363 lines
11 KiB
Rust
use crate::http;
|
|
use crate::http::Status;
|
|
|
|
pub fn parse_request(stream: &mut http::Stream) -> Result<Option<http::Request>, String> {
|
|
let mut buf = [0; 4096];
|
|
let size = stream.peek(&mut buf).unwrap();
|
|
if size == 0 {
|
|
return Ok(None);
|
|
}
|
|
|
|
let mut parser = Parser::new_request_parser(&buf[..size]);
|
|
let header_size = parser.parse()?;
|
|
|
|
let mut header_fields = Vec::new();
|
|
for (name, value) in parser.headers {
|
|
header_fields.push(http::HeaderField {
|
|
name: String::from(name),
|
|
value: String::from(value),
|
|
});
|
|
}
|
|
|
|
let request = http::Request {
|
|
version: String::from(parser.http_version.unwrap()),
|
|
method: http::Method::from_str(parser.method.unwrap()),
|
|
uri: String::from(parser.uri.unwrap()),
|
|
header_fields,
|
|
};
|
|
|
|
stream.read_exact(&mut buf[..header_size]).unwrap();
|
|
|
|
Ok(Some(request))
|
|
}
|
|
|
|
pub fn parse_response(stream: &mut http::Stream) -> Result<http::Response, String> {
|
|
let mut buf = [0; 4096];
|
|
let size = stream.peek(&mut buf).unwrap();
|
|
|
|
let mut parser = Parser::new_request_parser(&buf[..size]);
|
|
let header_size = parser.parse().unwrap();
|
|
|
|
let status_code = parser.status_code.unwrap();
|
|
let status_code = match status_code.parse() {
|
|
Ok(v) => v,
|
|
Err(e) => return Err(format!("{}", e)),
|
|
};
|
|
|
|
let mut header_fields = Vec::new();
|
|
for (name, value) in parser.headers {
|
|
header_fields.push(http::HeaderField {
|
|
name: String::from(name),
|
|
value: String::from(value),
|
|
});
|
|
}
|
|
|
|
let response = http::Response {
|
|
version: String::from(parser.http_version.unwrap()),
|
|
status: Status::new_custom(status_code, parser.status_message.unwrap()),
|
|
header_fields,
|
|
};
|
|
|
|
stream.read_exact(&mut buf[..header_size]).unwrap();
|
|
|
|
Ok(response)
|
|
}
|
|
|
|
#[derive(Copy, Clone)]
|
|
enum State<'a> {
|
|
Method,
|
|
Uri,
|
|
Http(&'a State<'a>),
|
|
HttpVersion(&'a State<'a>),
|
|
StatusCode,
|
|
StatusMessage,
|
|
HeaderName,
|
|
HeaderValue,
|
|
Finish,
|
|
CRLF(&'a State<'a>),
|
|
Error,
|
|
}
|
|
|
|
struct Parser<'a> {
|
|
state: State<'a>,
|
|
buf: &'a [u8],
|
|
str_start: usize,
|
|
header_size: usize,
|
|
method: Option<&'a str>,
|
|
uri: Option<&'a str>,
|
|
http_version: Option<&'a str>,
|
|
status_code: Option<&'a str>,
|
|
status_message: Option<&'a str>,
|
|
headers: Vec<(&'a str, &'a str)>,
|
|
}
|
|
|
|
impl Parser<'_> {
|
|
fn new_request_parser(buf: &[u8]) -> Parser {
|
|
Parser {
|
|
state: State::Method,
|
|
buf,
|
|
str_start: 0,
|
|
header_size: 0,
|
|
method: None,
|
|
uri: None,
|
|
http_version: None,
|
|
status_code: None,
|
|
status_message: None,
|
|
headers: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn new_response_parser(buf: &[u8]) -> Parser {
|
|
Parser {
|
|
state: State::Http(&State::StatusCode),
|
|
buf,
|
|
str_start: 0,
|
|
header_size: 0,
|
|
method: None,
|
|
uri: None,
|
|
http_version: None,
|
|
status_code: None,
|
|
status_message: None,
|
|
headers: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn parse(&mut self) -> Result<usize, String> {
|
|
for char in self.buf {
|
|
self.next(*char);
|
|
match self.state {
|
|
State::Finish => return Ok(self.header_size),
|
|
State::Error => {
|
|
return Err(format!(
|
|
"invalid character at position {}",
|
|
self.header_size - 1
|
|
))
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
return Err(String::from("input too short"));
|
|
}
|
|
|
|
fn next(&mut self, char: u8) {
|
|
self.header_size += 1;
|
|
let get_str =
|
|
|| std::str::from_utf8(&self.buf[self.str_start..self.header_size - 1]).unwrap();
|
|
self.state = match &self.state {
|
|
State::Error => State::Error,
|
|
State::Finish => State::Error,
|
|
State::Method => match char {
|
|
0x41..=0x5A => State::Method,
|
|
0x20 => {
|
|
self.method = Some(get_str());
|
|
self.str_start = self.header_size;
|
|
State::Uri
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
State::Uri => match char {
|
|
0x21..=0x7E => State::Uri,
|
|
0x20 => {
|
|
self.uri = Some(get_str());
|
|
self.str_start = self.header_size;
|
|
State::Http(&State::HeaderName)
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
State::Http(next) => match char {
|
|
0x48 | 0x54 | 0x50 => State::Http(next),
|
|
0x2F => {
|
|
let http = get_str();
|
|
self.str_start = self.header_size;
|
|
if http != "HTTP" {
|
|
State::Error
|
|
} else {
|
|
State::HttpVersion(next)
|
|
}
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
State::HttpVersion(next) => match char {
|
|
0x30..=0x39 | 0x2E => State::HttpVersion(next),
|
|
0x0D => match next {
|
|
State::HeaderName => {
|
|
self.http_version = Some(get_str());
|
|
State::CRLF(next)
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
0x20 => match next {
|
|
State::StatusCode => {
|
|
self.http_version = Some(get_str());
|
|
self.str_start = self.header_size;
|
|
State::StatusCode
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
_ => State::Error,
|
|
},
|
|
State::StatusCode => match char {
|
|
0x30..=0x39 => State::StatusCode,
|
|
0x20 => {
|
|
self.status_code = Some(get_str());
|
|
self.str_start = self.header_size;
|
|
State::StatusMessage
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
State::StatusMessage => match char {
|
|
0x20..=0x7E => State::StatusMessage,
|
|
0x0D => {
|
|
self.status_message = Some(get_str());
|
|
State::CRLF(&State::HeaderName)
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
State::HeaderName => match char {
|
|
0x0D => {
|
|
if self.header_size == self.str_start + 1 {
|
|
State::CRLF(&State::Finish)
|
|
} else {
|
|
State::Error
|
|
}
|
|
}
|
|
0x3A => {
|
|
let header_name = get_str();
|
|
self.headers.push((header_name, ""));
|
|
self.str_start = self.header_size;
|
|
State::HeaderValue
|
|
}
|
|
0x00..=0x1F
|
|
| 0x7F
|
|
| 0x80..=0xFF
|
|
| 0x20
|
|
| 0x28
|
|
| 0x29
|
|
| 0x2C
|
|
| 0x2F
|
|
| 0x3A..=0x40
|
|
| 0x5B..=0x5D
|
|
| 0x7B
|
|
| 0x7D => State::Error,
|
|
_ => State::HeaderName,
|
|
},
|
|
State::HeaderValue => match char {
|
|
0x20..=0x7E | 0x09 => State::HeaderValue,
|
|
0x0D => {
|
|
self.headers.last_mut().unwrap().1 = get_str().trim();
|
|
State::CRLF(&State::HeaderName)
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
State::CRLF(next) => match char {
|
|
0x0A => {
|
|
self.str_start = self.header_size;
|
|
*next.clone()
|
|
}
|
|
_ => State::Error,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#[test]
|
|
fn simple_request() {
|
|
let request: &str = "GET /index.html HTTP/1.1\r\n\
|
|
Host: www.example.com\r\n\
|
|
\r\n";
|
|
|
|
let mut parser = super::Parser::new_request_parser(request.as_bytes());
|
|
let size = parser.parse().unwrap();
|
|
|
|
assert_eq!(51, size);
|
|
assert_eq!("GET", parser.method.unwrap());
|
|
assert_eq!("/index.html", parser.uri.unwrap());
|
|
assert_eq!("1.1", parser.http_version.unwrap());
|
|
assert_eq!(None, parser.status_code);
|
|
assert_eq!(None, parser.status_message);
|
|
|
|
assert_eq!(1, parser.headers.len());
|
|
assert_eq!(("Host", "www.example.com"), parser.headers[0]);
|
|
}
|
|
|
|
#[test]
|
|
fn complex_request() {
|
|
let request: &str = "POST /upload/file.txt HTTP/1.3\r\n\
|
|
Host: www.example.com \r\n\
|
|
Content-Length: 13 \r\n\
|
|
User-Agent: Mozilla/5.0 (X11; Linux x86_64) \r\n\
|
|
\r\n\
|
|
username=test";
|
|
|
|
let mut parser = super::Parser::new_request_parser(request.as_bytes());
|
|
let size = parser.parse().unwrap();
|
|
|
|
assert_eq!(129, size);
|
|
assert_eq!("POST", parser.method.unwrap());
|
|
assert_eq!("/upload/file.txt", parser.uri.unwrap());
|
|
assert_eq!("1.3", parser.http_version.unwrap());
|
|
assert_eq!(None, parser.status_code);
|
|
assert_eq!(None, parser.status_message);
|
|
|
|
assert_eq!(3, parser.headers.len());
|
|
assert_eq!(("Host", "www.example.com"), parser.headers[0]);
|
|
assert_eq!(("Content-Length", "13"), parser.headers[1]);
|
|
assert_eq!(
|
|
("User-Agent", "Mozilla/5.0 (X11; Linux x86_64)"),
|
|
parser.headers[2]
|
|
);
|
|
|
|
assert_eq!("username=test", &request[size..]);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_request_1() {
|
|
let request: &str = "GET /files/größe.txt HTTP/1.1\r\n\r\n";
|
|
let mut parser = super::Parser::new_request_parser(request.as_bytes());
|
|
match parser.parse() {
|
|
Ok(_v) => panic!("should fail"),
|
|
Err(e) => assert_eq!("invalid character at position 13", e),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_request_2() {
|
|
let request: &str = "GET /index.html HTT";
|
|
let mut parser = super::Parser::new_request_parser(request.as_bytes());
|
|
match parser.parse() {
|
|
Ok(_v) => panic!("should fail"),
|
|
Err(e) => assert_eq!("input too short", e),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn simple_response() {
|
|
let response: &str = "HTTP/1.1 200 OK\r\n\
|
|
Content-Length: 12\r\n\
|
|
Content-Type: text/plain; charset=us-ascii\r\n\
|
|
\r\n\
|
|
Hello world!";
|
|
|
|
let mut parser = super::Parser::new_response_parser(response.as_bytes());
|
|
let size = parser.parse().unwrap();
|
|
|
|
assert_eq!(83, size);
|
|
assert_eq!("200", parser.status_code.unwrap());
|
|
assert_eq!("OK", parser.status_message.unwrap());
|
|
assert_eq!("1.1", parser.http_version.unwrap());
|
|
assert_eq!(None, parser.method);
|
|
assert_eq!(None, parser.uri);
|
|
|
|
assert_eq!(2, parser.headers.len());
|
|
assert_eq!(("Content-Length", "12"), parser.headers[0]);
|
|
assert_eq!(
|
|
("Content-Type", "text/plain; charset=us-ascii"),
|
|
parser.headers[1]
|
|
);
|
|
|
|
assert_eq!("Hello world!", &response[size..]);
|
|
}
|
|
}
|