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

Compare commits

base: AustrianToast:046c8d17849b8cdfe9267f7c367b487e23108517
Branches Tags
AustrianToast:main AustrianToast:c_rewrite
..
compare: AustrianToast:main
Branches Tags
AustrianToast:c_rewrite AustrianToast:main

10 Commits
046c8d1784 ... main

Author SHA1 Message Date
AustrianToast
1f467994f7 start of internal html files 2025-03-28 10:53:38 +01:00
AustrianToast
7853b4d2df compare mime-type with accept header 2025-03-28 10:21:32 +01:00
AustrianToast
cf48dc3e1c new but basic parse_field_line function 2025-03-27 12:23:11 +01:00
AustrianToast
d5b4dcedd6 change signature of Hashmap 2025-03-27 09:51:44 +01:00
AustrianToast
0fd7795ace reorder code 2025-03-23 20:09:39 +01:00
AustrianToast
6472b0a278 cargo clippy and proper HTTP codes in parse_start_line 2025-03-21 10:17:06 +01:00
AustrianToast
bb2e683f20 use as_bytes() instead of b 2025-03-20 23:28:15 +01:00
AustrianToast
26712c8433 reading the body causes an infinite loop 2025-03-20 22:47:52 +01:00
AustrianToast
30508bd5a9 refactoring and the beginnings of special paths 2025-03-20 21:19:27 +01:00
AustrianToast
b71743ff3f switch to musl for smaller artifacts 2025-03-20 21:17:41 +01:00
3 changed files with 300 additions and 138 deletions
Expand all files Collapse all files

9
Dockerfile
View File

@ -1,5 +1,8 @@
FROM rust:1.85-slim-bookworm AS build FROM rust:1.85-slim-bookworm AS build
# get x86_64-unknown-linux-musl as a build target
RUN rustup target add x86_64-unknown-linux-musl
# create a new empty shell project # create a new empty shell project
RUN USER=root cargo new --bin http_server RUN USER=root cargo new --bin http_server
WORKDIR /http_server WORKDIR /http_server
@ -18,13 +21,15 @@ COPY ./src ./src
# build for release as a static-pie linked binary # build for release as a static-pie linked binary
RUN rm ./target/release/deps/http_server* RUN rm ./target/release/deps/http_server*
ENV RUSTFLAGS='-C target-feature=+crt-static' ENV RUSTFLAGS='-C target-feature=+crt-static'
RUN cargo build --release --target x86_64-unknown-linux-gnu RUN cargo build --release --target x86_64-unknown-linux-musl
RUN strip /http_server/target/x86_64-unknown-linux-musl/release/http_server
FROM scratch FROM scratch
# copy the build artifact from the build stage # copy the build artifact from the build stage
COPY --from=build /http_server/target/x86_64-unknown-linux-gnu/release/http_server / COPY --from=build /http_server/target/x86_64-unknown-linux-musl/release/http_server /
COPY ./www /www COPY ./www /www
COPY ./internal /internal
EXPOSE 8080 EXPOSE 8080

13
internal/server-info.html Normal file
View File

@ -0,0 +1,13 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>server-info</title>
</head>
<body>
<h1>Server written by AustrianToast</h1>
<a href="https://gitea.hopeless-cloud.xyz/AustrianToast/http_server">Source code</a>
<br>
<a href="mailto:austriantoast@hopeless-cloud.xyz">AustrianToasts e-mail</a>
</body>
</html>

416
src/main.rs
View File

@ -3,7 +3,7 @@ use std::{
collections::HashMap, collections::HashMap,
error::Error, error::Error,
fs::{self}, fs::{self},
io::{BufRead, BufReader, Read, Write}, io::{BufRead, BufReader, Write},
net::{TcpListener, TcpStream}, net::{TcpListener, TcpStream},
path::PathBuf, path::PathBuf,
process::exit, process::exit,
@ -12,9 +12,9 @@ use std::{
#[derive(PartialEq, Eq, Debug, Copy, Clone)] #[derive(PartialEq, Eq, Debug, Copy, Clone)]
enum RequestMethods { enum RequestMethods {
NULL = -1, // This is only to initialise the struct Null = -1, // This is only to initialise the struct
GET, Get,
HEAD, Head,
} }
#[derive(Debug)] #[derive(Debug)]
@ -27,7 +27,7 @@ struct StartLine {
impl StartLine { impl StartLine {
pub fn new() -> Self { pub fn new() -> Self {
Self { Self {
method: RequestMethods::NULL, method: RequestMethods::Null,
target: String::new(), target: String::new(),
version: String::new(), version: String::new(),
} }
@ -73,7 +73,7 @@ impl StartLine {
return true; return true;
} }
return false; false
} }
pub fn is_valid_version(version: &str) -> bool { pub fn is_valid_version(version: &str) -> bool {
@ -102,19 +102,15 @@ impl StartLine {
} }
}; };
if major <= 9 && minor <= 9 { return major <= 9 && minor <= 9;
return true;
} else {
return false;
}
} else {
return false;
} }
false
} }
} }
fn parse_start_line(input: &str) -> Result<StartLine, 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_field_lines: HashMap<String, Vec<String>> = HashMap::new();
let mut response_body: Vec<u8> = vec![]; let mut response_body: Vec<u8> = vec![];
let mut start_line = StartLine::new(); let mut start_line = StartLine::new();
let vec = input.trim().split_ascii_whitespace().collect::<Vec<&str>>(); let vec = input.trim().split_ascii_whitespace().collect::<Vec<&str>>();
@ -129,13 +125,16 @@ fn parse_start_line(input: &str) -> Result<StartLine, Vec<u8>> {
.for_each(|byte| response_body.push(*byte)); .for_each(|byte| response_body.push(*byte));
response_field_lines.insert( response_field_lines.insert(
String::from("Content-Length"), String::from("content-length"),
response_body.len().to_string(), vec![response_body.len().to_string()],
);
response_field_lines.insert(
String::from("content-type"),
vec![String::from("text/plain")],
); );
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
return Err(response_builder( return Err(response_builder(
RequestMethods::GET, RequestMethods::Get,
"HTTP/1.1 400 ", "HTTP/1.1 400 ",
Some(response_field_lines), Some(response_field_lines),
Some(response_body), Some(response_body),
@ -146,40 +145,138 @@ fn parse_start_line(input: &str) -> Result<StartLine, Vec<u8>> {
let target = vec[1]; let target = vec[1];
let version = vec[2]; let version = vec[2];
if StartLine::is_valid_method(&method) 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,
}
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( return Err(response_builder(
RequestMethods::HEAD, RequestMethods::Head,
"HTTP/1.1 501 ",
None,
None,
));
}
if !StartLine::is_valid_version(version) {
return Err(response_builder(
RequestMethods::Head,
"HTTP/1.1 400 ",
None,
None,
));
}
if version != "HTTP/1.1" && version != "HTTP/1.0" {
"Server only supports major version 1 of HTTP"
.as_bytes()
.iter()
.for_each(|byte| response_body.push(*byte));
response_field_lines.insert(
String::from("content-length"),
vec![response_body.len().to_string()],
);
response_field_lines.insert(
String::from("content-type"),
vec![String::from("text/plain")],
);
return Err(response_builder(
RequestMethods::Head,
"HTTP/1.1 505 ",
Some(response_field_lines),
Some(response_body),
));
}
if !StartLine::is_valid_target(target) {
return Err(response_builder(
RequestMethods::Head,
"HTTP/1.1 400 ", "HTTP/1.1 400 ",
None, None,
None, None,
)); ));
} }
// 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,
}
start_line.version = version.to_string();
start_line.target = target.to_string();
Ok(start_line) Ok(start_line)
} }
// Example -> Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8
// Be careful of optional whitespace (OWS) and CRLF
// q=x.yyy is basically a value which says, what the client wants most.
// The closer to 1 the better. If no q=x.yyy was specified, then q=1 is implied.
// This basically mean I should sort the vector by qvalue. So that the one it wants most, is at the beginning.
fn parse_field_line(field_line: (&str, &str)) -> (String, Vec<String>) {
let field_name = field_line.0.to_ascii_lowercase();
let mut fuck: HashMap<String, Vec<String>> = HashMap::new();
if !field_line.1.contains(",") {
return (field_name, vec![field_line.1.trim().to_owned()]);
}
let temp_field_values = field_line.1.split(",").collect::<Vec<&str>>();
for field_value in temp_field_values {
if field_value.contains(";") {
let temp_field_value = field_value.split(";").collect::<Vec<&str>>();
if temp_field_value.len() != 2 {
// TODO: return with an http_response
continue;
}
if !temp_field_value[1].starts_with("q=") && !temp_field_value[1].starts_with("Q=") {
// TODO: return with an http_response
continue;
}
let qvalue = temp_field_value[1]
.trim()
.trim_start_matches("q=")
.trim_start_matches("Q=");
if qvalue == "0" {
continue;
}
if let Some(val) = fuck.get_mut(qvalue) {
val.push(temp_field_value[0].trim().to_owned());
continue;
}
fuck.insert(
qvalue.to_owned(),
vec![temp_field_value[0].trim().to_owned()],
);
} else {
if let Some(val) = fuck.get_mut("1") {
val.push(field_value.trim().to_owned());
continue;
}
fuck.insert("1".to_owned(), vec![field_value.trim().to_owned()]);
}
}
let fuck_keys = fuck.keys();
let mut keys = fuck_keys.collect::<Vec<&String>>();
keys.sort_by(|a, b| b.cmp(a));
let mut field_values: Vec<String> = vec![];
for key in keys {
if let Some(value) = fuck.get(key) {
value.iter().for_each(|val| field_values.push(val.clone()));
}
}
(field_name, field_values)
}
fn parse_field_lines( fn parse_field_lines(
reader: &mut BufReader<&mut TcpStream>, reader: &mut BufReader<&mut TcpStream>,
) -> Result<HashMap<String, String>, Vec<u8>> { ) -> Result<HashMap<String, Vec<String>>, Vec<u8>> {
let mut response_field_lines: HashMap<String, String> = HashMap::new(); let mut response_field_lines: HashMap<String, Vec<String>> = HashMap::new();
let mut response_body: Vec<u8> = vec![]; let mut response_body: Vec<u8> = vec![];
let mut field_lines: HashMap<String, String> = HashMap::new(); let mut field_lines: HashMap<String, Vec<String>> = HashMap::new();
// Read field-lines till I hit an empty line // Read field-lines till I hit an empty line
loop { loop {
@ -187,18 +284,22 @@ fn parse_field_lines(
reader.read_line(&mut line).unwrap(); reader.read_line(&mut line).unwrap();
if !line.ends_with("\r\n") { if !line.ends_with("\r\n") {
b"Lines need to end with a CRLF" "Lines need to end with a CRLF"
.as_bytes()
.iter() .iter()
.for_each(|byte| response_body.push(*byte)); .for_each(|byte| response_body.push(*byte));
response_field_lines.insert( response_field_lines.insert(
String::from("Content-Length"), String::from("content-length"),
response_body.len().to_string(), vec![response_body.len().to_string()],
);
response_field_lines.insert(
String::from("content-type"),
vec![String::from("text/plain")],
); );
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
return Err(response_builder( return Err(response_builder(
RequestMethods::GET, RequestMethods::Get,
"HTTP/1.1 400 ", "HTTP/1.1 400 ",
Some(response_field_lines), Some(response_field_lines),
Some(response_body), Some(response_body),
@ -209,22 +310,25 @@ fn parse_field_lines(
break; break;
} }
let field_line = match line.split_once(":") { let field_line: (String, Vec<String>) = match line.split_once(":") {
Some(val) => val, Some(val) => parse_field_line(val),
None => { None => {
b"Invalid field-line" "Invalid field-line"
.as_bytes()
.iter() .iter()
.for_each(|byte| response_body.push(*byte)); .for_each(|byte| response_body.push(*byte));
response_field_lines.insert( response_field_lines.insert(
String::from("Content-Length"), String::from("content-length"),
response_body.len().to_string(), vec![response_body.len().to_string()],
);
response_field_lines.insert(
String::from("content-type"),
vec![String::from("text/plain")],
); );
response_field_lines
.insert(String::from("Content-Type"), String::from("text/plain"));
return Err(response_builder( return Err(response_builder(
RequestMethods::GET, RequestMethods::Get,
"HTTP/1.1 400 ", "HTTP/1.1 400 ",
Some(response_field_lines), Some(response_field_lines),
Some(response_body), Some(response_body),
@ -232,35 +336,39 @@ fn parse_field_lines(
} }
}; };
field_lines.insert(field_line.0.to_owned(), field_line.1.trim().to_owned()); field_lines.insert(field_line.0, field_line.1);
} }
if !field_lines.contains_key(&String::from("Host")) { if !field_lines.contains_key(&String::from("host")) {
b"field-line with key HOST is missing" "field-line with field-name -> host is missing"
.as_bytes()
.iter() .iter()
.for_each(|byte| response_body.push(*byte)); .for_each(|byte| response_body.push(*byte));
response_field_lines.insert( response_field_lines.insert(
String::from("Content-Length"), String::from("content-length"),
response_body.len().to_string(), vec![response_body.len().to_string()],
);
response_field_lines.insert(
String::from("content-type"),
vec![String::from("text/plain")],
); );
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
return Err(response_builder( return Err(response_builder(
RequestMethods::GET, RequestMethods::Get,
"HTTP/1.1 400 ", "HTTP/1.1 400 ",
Some(response_field_lines), Some(response_field_lines),
Some(response_body), Some(response_body),
)); ));
} }
return Ok(field_lines); Ok(field_lines)
} }
fn response_builder( fn response_builder(
method: RequestMethods, method: RequestMethods,
status_line: &str, status_line: &str,
field_lines: Option<HashMap<String, String>>, field_lines: Option<HashMap<String, Vec<String>>>,
body: Option<Vec<u8>>, body: Option<Vec<u8>>,
) -> Vec<u8> { ) -> Vec<u8> {
let mut response: Vec<u8> = vec![]; let mut response: Vec<u8> = vec![];
@ -272,72 +380,44 @@ fn response_builder(
response.push(b'\r'); response.push(b'\r');
response.push(b'\n'); response.push(b'\n');
match field_lines { if let Some(val) = field_lines {
Some(val) => { for field_line in val.iter() {
for field_line in val.iter() { field_line
field_line .0
.0 .as_bytes()
.as_bytes() .iter()
.iter() .for_each(|byte| response.push(*byte));
.for_each(|byte| response.push(*byte));
response.push(b':'); response.push(b':');
response.push(b' '); response.push(b' ');
field_line for val in field_line.1 {
.1 val.as_bytes().iter().for_each(|byte| response.push(*byte));
.as_bytes()
.iter()
.for_each(|byte| response.push(*byte));
response.push(b'\r');
response.push(b'\n');
} }
response.push(b'\r');
response.push(b'\n');
} }
None => (),
} }
// Mandatory empty line between header and body // Mandatory empty line between header and body
response.push(b'\r'); response.push(b'\r');
response.push(b'\n'); response.push(b'\n');
if method != RequestMethods::HEAD { if method != RequestMethods::Head {
match body { if let Some(val) = body {
Some(val) => { val.iter().for_each(|byte| response.push(*byte));
val.iter().for_each(|byte| response.push(*byte)); response.push(b'\r');
response.push(b'\r'); response.push(b'\n');
response.push(b'\n');
}
None => (),
} }
} }
return response; response
} }
fn act_upon_request( fn try_get_file(start_line: &StartLine, field_lines: &HashMap<String, Vec<String>>) -> Vec<u8> {
start_line: StartLine, let mut response_field_lines: HashMap<String, Vec<String>> = HashMap::new();
_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 mut response_body: Vec<u8> = vec![];
let response: Vec<u8>;
let special_paths = ["/server-health", "/server-stats", "/server-info"];
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() { let path: PathBuf = match start_line.target.as_str() {
"/" => PathBuf::from("/www/index.html"), "/" => PathBuf::from("/www/index.html"),
_ => PathBuf::from(format!("/www{}", start_line.target)), _ => PathBuf::from(format!("/www{}", start_line.target)),
@ -348,34 +428,87 @@ fn act_upon_request(
val.iter().for_each(|byte| response_body.push(*byte)); val.iter().for_each(|byte| response_body.push(*byte));
response_field_lines.insert( response_field_lines.insert(
String::from("Content-Length"), String::from("content-length"),
response_body.len().to_string(), vec![response_body.len().to_string()],
); );
// TODO: get mime-type of file and use that here
let mime_type = mime_guess::from_path(&path)
.first_raw()
.expect("Could not guess mime-type from path");
response_field_lines.insert(String::from("Content-Type"), mime_type.to_string());
response = response_builder( let mime_type = mime_guess::from_path(&path)
.first()
.expect("Could not guess mime-type from path");
if let Some(vector) = field_lines.get("accept") {
for value in vector {
if mime_type.to_string() == *value {
response_field_lines
.insert(String::from("content-type"), vec![mime_type.to_string()]);
}
if format!("{}/*", mime_type.type_()) == *value {
response_field_lines
.insert(String::from("content-type"), vec![mime_type.to_string()]);
}
if "*/*" == *value {
response_field_lines
.insert(String::from("content-type"), vec![mime_type.to_string()]);
}
}
} else {
response_field_lines
.insert(String::from("content-type"), vec![mime_type.to_string()]);
}
if !response_field_lines.contains_key("content-type") {
// TODO: make better according to https://datatracker.ietf.org/doc/html/rfc9110#status.406
return response_builder(start_line.method, "HTTP/1.1 406 ", None, None);
}
response_builder(
start_line.method, start_line.method,
"HTTP/1.1 200 ", "HTTP/1.1 200 ",
Some(response_field_lines), Some(response_field_lines),
Some(response_body), Some(response_body),
); )
} }
Err(_) => { Err(_) => response_builder(start_line.method, "HTTP/1.1 404 ", None, None),
response = response_builder(start_line.method, "HTTP/1.1 404 ", None, None); }
} }
};
Ok(response) fn try_get_file_internal(start_line: &StartLine) -> Vec<u8> {
let mut response_field_lines: HashMap<String, Vec<String>> = HashMap::new();
let mut response_body: Vec<u8> = vec![];
let path: PathBuf = PathBuf::from(format!("/internal{}.html", start_line.target));
match fs::read(&path) {
Ok(val) => {
val.iter().for_each(|byte| response_body.push(*byte));
response_field_lines.insert(
String::from("content-length"),
vec![response_body.len().to_string()],
);
let mime_type = mime_guess::from_path(&path)
.first()
.expect("Could not guess mime-type from path");
response_field_lines.insert(String::from("content-type"), vec![mime_type.to_string()]);
response_builder(
start_line.method,
"HTTP/1.1 200 ",
Some(response_field_lines),
Some(response_body),
)
}
Err(_) => response_builder(start_line.method, "HTTP/1.1 404 ", None, None),
}
} }
fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> { fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
let mut line = String::new(); let mut line = String::new();
let mut reader = BufReader::new(&mut stream); let mut reader = BufReader::new(&mut stream);
let mut response_field_lines: HashMap<String, String> = HashMap::new(); let mut response_field_lines: HashMap<String, Vec<String>> = HashMap::new();
let mut response_body: Vec<u8> = vec![]; let mut response_body: Vec<u8> = vec![];
// Request can have one or many empty lines preceding the start-line and I will ignore these // Request can have one or many empty lines preceding the start-line and I will ignore these
@ -386,18 +519,22 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
} }
if line.ends_with(" ") { if line.ends_with(" ") {
b"There is whitespace between the start-line and the first field-line" "There is whitespace between the start-line and the first field-line"
.as_bytes()
.iter() .iter()
.for_each(|byte| response_body.push(*byte)); .for_each(|byte| response_body.push(*byte));
response_field_lines.insert( response_field_lines.insert(
String::from("Content-Length"), String::from("content-length"),
response_body.len().to_string(), vec![response_body.len().to_string()],
);
response_field_lines.insert(
String::from("content-type"),
vec![String::from("text/plain")],
); );
response_field_lines.insert(String::from("Content-Type"), String::from("text/plain"));
let response = response_builder( let response = response_builder(
RequestMethods::GET, RequestMethods::Get,
"HTTP/1.1 400 ", "HTTP/1.1 400 ",
Some(response_field_lines), Some(response_field_lines),
Some(response_body), Some(response_body),
@ -413,7 +550,7 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
return Ok(()); return Ok(());
} }
}; };
dbg!(&start_line); // dbg!(&start_line);
let field_lines = match parse_field_lines(&mut reader) { let field_lines = match parse_field_lines(&mut reader) {
Ok(val) => val, Ok(val) => val,
@ -422,11 +559,18 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
return Ok(()); return Ok(());
} }
}; };
// dbg!(&field_lines);
let mut body: Vec<u8> = vec![]; // let mut request_body: Vec<u8> = vec![];
reader.read_to_end(&mut body)?; // reader.read_to_end(&mut request_body)?;
let response = act_upon_request(start_line, field_lines, body)?; let response = match start_line.target.as_str() {
// For docker healtcheck. If the server can properly respond, then it must be healthy.
"/server-health" => response_builder(RequestMethods::Head, "HTTP/1.1 200 ", None, None),
"/server-stats" => try_get_file_internal(&start_line),
"/server-info" => try_get_file_internal(&start_line),
_ => try_get_file(&start_line, &field_lines),
};
stream.write_all(&response)?; stream.write_all(&response)?;
Ok(()) Ok(())
@ -437,7 +581,7 @@ fn main() -> Result<(), Box<dyn Error>> {
// TODO: Gracefully shutdown server // TODO: Gracefully shutdown server
thread::spawn(move || { thread::spawn(move || {
for sig in signals.forever() { if let Some(sig) = signals.forever().next() {
println!("Received signal {:?}", sig); println!("Received signal {:?}", sig);
println!("Shutting down"); println!("Shutting down");
exit(1); exit(1);