AustrianToast/http_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some refactoring

Browse Source
This commit is contained in:
AustrianToast
2025-03-20 18:42:32 +01:00
parent a9185aa868
commit 046c8d1784
1 changed files with 134 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

219
src/main.rs
View File

@ -3,7 +3,7 @@ use std::{
collections::HashMap,
error::Error,
fs::{self},
io::{BufRead, BufReader, Write},
io::{BufRead, BufReader, Read, Write},
net::{TcpListener, TcpStream},
path::PathBuf,
process::exit,
@ -18,13 +18,13 @@ enum RequestMethods {
}
#[derive(Debug)]
struct RequestLine {
struct StartLine {
method: RequestMethods,
target: String,
version: String,
}
impl RequestLine {
impl StartLine {
pub fn new() -> Self {
Self {
method: RequestMethods::NULL,
@ -113,39 +113,18 @@ impl RequestLine {
}
}
fn parse_start_line(input: &str) -> Result<RequestLine, Vec<u8>> {
fn parse_start_line(input: &str) -> Result<StartLine, Vec<u8>> {
let mut response_field_lines: HashMap<String, String> = HashMap::new();
let mut response_body: Vec<u8> = vec![];
if input.ends_with(" ") {
b"There is whitespace between the start-line and the first field-line"
.iter()
.for_each(|byte| response_body.push(*byte));
response_field_lines.insert(
String::from("Content-Length"),
response_body.len().to_string(),
);
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
return Err(response_builder(
RequestMethods::GET,
"HTTP/1.1 400 Bad Request",
response_field_lines,
Some(response_body),
));
}
let mut start_line = RequestLine::new();
let mut start_line = StartLine::new();
let vec = input.trim().split_ascii_whitespace().collect::<Vec<&str>>();
let body = format!(
if vec.len() != 3 {
format!(
"The start-line has an incorrect amount of items. Got the value: {}",
vec.len()
);
if vec.len() != 3 {
body.as_bytes()
)
.as_bytes()
.iter()
.for_each(|byte| response_body.push(*byte));
@ -157,55 +136,42 @@ fn parse_start_line(input: &str) -> Result<RequestLine, Vec<u8>> {
return Err(response_builder(
RequestMethods::GET,
"HTTP/1.1 400 Bad Request",
response_field_lines,
"HTTP/1.1 400 ",
Some(response_field_lines),
Some(response_body),
));
}
// start_line.method will remain RequestMethods::NULL if it is not supported.
let method = vec[0];
if RequestLine::is_valid_method(&method) {
// TODO: Change to a switch-case if I ever support more methods
if method == String::from("GET") {
start_line.method = RequestMethods::GET;
}
if method == String::from("HEAD") {
start_line.method = RequestMethods::HEAD;
}
} else {
b"Server only supports GET and HEAD"
.iter()
.for_each(|byte| response_body.push(*byte));
response_field_lines.insert(
String::from("Content-Length"),
response_body.len().to_string(),
);
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
return Err(response_builder(
RequestMethods::GET,
"HTTP/1.1 501 Not Implemented",
response_field_lines,
Some(response_body),
));
}
let target = vec[1];
if RequestLine::is_valid_target(&target) {
start_line.target = target.to_string();
let version = vec[2];
if StartLine::is_valid_method(&method)
&& StartLine::is_valid_target(&target)
&& StartLine::is_valid_version(&version)
{
// start_line.method will remain RequestMethods::NULL if it is not supported.
match method {
"GET" => start_line.method = RequestMethods::GET,
"HEAD" => start_line.method = RequestMethods::HEAD,
_ => start_line.method = RequestMethods::NULL,
}
let version = vec[2];
if RequestLine::is_valid_version(&version) {
start_line.target = target.to_string();
if version == "HTTP/1.1" || version == "HTTP/1.0" {
start_line.version = version.to_string();
}
} else {
return Err(response_builder(
RequestMethods::HEAD,
"HTTP/1.1 400 ",
None,
None,
));
}
return Ok(start_line);
Ok(start_line)
}
fn parse_field_lines(
@ -233,8 +199,8 @@ fn parse_field_lines(
return Err(response_builder(
RequestMethods::GET,
"HTTP/1.1 400 Bad Request",
response_field_lines,
"HTTP/1.1 400 ",
Some(response_field_lines),
Some(response_body),
));
}
@ -259,8 +225,8 @@ fn parse_field_lines(
return Err(response_builder(
RequestMethods::GET,
"HTTP/1.1 400 Bad Request",
response_field_lines,
"HTTP/1.1 400 ",
Some(response_field_lines),
Some(response_body),
));
}
@ -282,8 +248,8 @@ fn parse_field_lines(
return Err(response_builder(
RequestMethods::GET,
"HTTP/1.1 400 Bad Request",
response_field_lines,
"HTTP/1.1 400 ",
Some(response_field_lines),
Some(response_body),
));
}
@ -294,7 +260,7 @@ fn parse_field_lines(
fn response_builder(
method: RequestMethods,
status_line: &str,
field_lines: HashMap<String, String>,
field_lines: Option<HashMap<String, String>>,
body: Option<Vec<u8>>,
) -> Vec<u8> {
let mut response: Vec<u8> = vec![];
@ -306,8 +272,9 @@ fn response_builder(
response.push(b'\r');
response.push(b'\n');
if !field_lines.is_empty() {
for field_line in field_lines.iter() {
match field_lines {
Some(val) => {
for field_line in val.iter() {
field_line
.0
.as_bytes()
@ -327,6 +294,8 @@ fn response_builder(
response.push(b'\n');
}
}
None => (),
}
// Mandatory empty line between header and body
response.push(b'\r');
@ -346,51 +315,34 @@ fn response_builder(
return response;
}
fn act_upon_request(start_line: &RequestLine) -> Result<Vec<u8>, Box<dyn Error>> {
fn act_upon_request(
start_line: StartLine,
_field_lines: HashMap<String, String>,
_request_body: Vec<u8>,
) -> Result<Vec<u8>, Box<dyn Error>> {
let mut response_field_lines: HashMap<String, String> = HashMap::new();
let mut response_body: Vec<u8> = vec![];
let response: Vec<u8>;
let special_paths = ["/server-health", "/server-stats", "/server-info"];
if start_line.target == "/" {
let file = match fs::read("./www/index.html") {
Ok(val) => val,
Err(_) => {
b"The is no index.html, only you and me."
.iter()
.for_each(|byte| response_body.push(*byte));
response_field_lines.insert(
String::from("Content-Length"),
response_body.len().to_string(),
);
response_field_lines
.insert(String::from("Content-Type"), String::from("text/plain"));
response = response_builder(
start_line.method,
"HTTP/1.1 200 OK",
response_field_lines,
Some(response_body),
);
if special_paths.contains(&start_line.target.as_str()) {
match start_line.target.as_str() {
"/server-health" => {
response = response_builder(start_line.method, "HTTP/1.1 200 ", None, None);
}
_ => {
response = response_builder(start_line.method, "HTTP/1.1 404 ", None, None);
}
}
return Ok(response);
}
let path: PathBuf = match start_line.target.as_str() {
"/" => PathBuf::from("/www/index.html"),
_ => PathBuf::from(format!("/www{}", start_line.target)),
};
file.iter().for_each(|byte| response_body.push(*byte));
response_field_lines.insert(String::from("Content-Length"), file.len().to_string());
response_field_lines.insert(String::from("Content-Type"), String::from("text/html"));
response = response_builder(
start_line.method,
"HTTP/1.1 200 OK",
response_field_lines,
Some(response_body),
);
} else {
let path: PathBuf = PathBuf::from(format!("./www{}", start_line.target));
match fs::read(&path) {
Ok(val) => {
val.iter().for_each(|byte| response_body.push(*byte));
@ -407,21 +359,15 @@ fn act_upon_request(start_line: &RequestLine) -> Result<Vec<u8>, Box<dyn Error>>
response = response_builder(
start_line.method,
"HTTP/1.1 200 OK",
response_field_lines,
"HTTP/1.1 200 ",
Some(response_field_lines),
Some(response_body),
);
}
Err(_) => {
response = response_builder(
start_line.method,
"HTTP/1.1 404 Not Found",
response_field_lines,
None,
);
response = response_builder(start_line.method, "HTTP/1.1 404 ", None, None);
}
};
}
Ok(response)
}
@ -429,6 +375,8 @@ fn act_upon_request(start_line: &RequestLine) -> Result<Vec<u8>, Box<dyn Error>>
fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
let mut line = String::new();
let mut reader = BufReader::new(&mut stream);
let mut response_field_lines: HashMap<String, String> = HashMap::new();
let mut response_body: Vec<u8> = vec![];
// Request can have one or many empty lines preceding the start-line and I will ignore these
loop {
@ -437,6 +385,27 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
}
}
if line.ends_with(" ") {
b"There is whitespace between the start-line and the first field-line"
.iter()
.for_each(|byte| response_body.push(*byte));
response_field_lines.insert(
String::from("Content-Length"),
response_body.len().to_string(),
);
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
let response = response_builder(
RequestMethods::GET,
"HTTP/1.1 400 ",
Some(response_field_lines),
Some(response_body),
);
stream.write_all(&response)?;
return Ok(());
}
let start_line = match parse_start_line(&line) {
Ok(val) => val,
Err(response) => {
@ -453,15 +422,11 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
return Ok(());
}
};
dbg!(&field_lines);
// TODO: Read the body
// let mut body: Vec<u8> = vec![];
// reader.read_to_end(&mut body)?;
// dbg!(&body);
let mut body: Vec<u8> = vec![];
reader.read_to_end(&mut body)?;
// TODO: Act upon the request
let response = act_upon_request(&start_line)?;
let response = act_upon_request(start_line, field_lines, body)?;
stream.write_all(&response)?;
Ok(())