start of internal html files

compare mime-type with accept header
new but basic parse_field_line function
2025-03-28 10:53:38 +01:00 · 2025-03-28 10:21:32 +01:00 · 2025-03-27 12:23:11 +01:00 · 2025-03-27 09:51:44 +01:00
3 changed files with 198 additions and 55 deletions
--- a/1
+++ b/1
@ -29,6 +29,7 @@ FROM scratch
 # copy the build artifact from the build stage
 COPY --from=build /http_server/target/x86_64-unknown-linux-musl/release/http_server /
 COPY ./www /www
+COPY ./internal /internal

 EXPOSE 8080

--- a/internal/server-info.html
+++ b/internal/server-info.html
@ -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>
--- a/src/main.rs
+++ b/src/main.rs
@ -110,7 +110,7 @@ impl StartLine {
 }

 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 start_line = StartLine::new();
    let vec = input.trim().split_ascii_whitespace().collect::<Vec<&str>>();
@ -125,10 +125,13 @@ fn parse_start_line(input: &str) -> Result<StartLine, Vec<u8>> {
        .for_each(|byte| response_body.push(*byte));

        response_field_lines.insert(
-            String::from("Content-Length"),
-            response_body.len().to_string(),
+            String::from("content-length"),
+            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(
            RequestMethods::Get,
@ -165,10 +168,13 @@ fn parse_start_line(input: &str) -> Result<StartLine, Vec<u8>> {
            .for_each(|byte| response_body.push(*byte));

        response_field_lines.insert(
-            String::from("Content-Length"),
-            response_body.len().to_string(),
+            String::from("content-length"),
+            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(
            RequestMethods::Head,
@ -198,12 +204,79 @@ fn parse_start_line(input: &str) -> Result<StartLine, Vec<u8>> {
    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(
    reader: &mut BufReader<&mut TcpStream>,
-) -> Result<HashMap<String, String>, Vec<u8>> {
-    let mut response_field_lines: HashMap<String, String> = HashMap::new();
+) -> Result<HashMap<String, Vec<String>>, Vec<u8>> {
+    let mut response_field_lines: HashMap<String, Vec<String>> = HashMap::new();
    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
    loop {
@ -217,10 +290,13 @@ fn parse_field_lines(
                .for_each(|byte| response_body.push(*byte));

            response_field_lines.insert(
-                String::from("Content-Length"),
-                response_body.len().to_string(),
+                String::from("content-length"),
+                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(
                RequestMethods::Get,
@ -234,8 +310,8 @@ fn parse_field_lines(
            break;
        }

-        let field_line = match line.split_once(":") {
-            Some(val) => val,
+        let field_line: (String, Vec<String>) = match line.split_once(":") {
+            Some(val) => parse_field_line(val),
            None => {
                "Invalid field-line"
                    .as_bytes()
@ -243,11 +319,13 @@ fn parse_field_lines(
                    .for_each(|byte| response_body.push(*byte));

                response_field_lines.insert(
-                    String::from("Content-Length"),
-                    response_body.len().to_string(),
+                    String::from("content-length"),
+                    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(
                    RequestMethods::Get,
@ -258,20 +336,23 @@ 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")) {
-        "field-line with key HOST is missing"
+    if !field_lines.contains_key(&String::from("host")) {
+        "field-line with field-name -> host is missing"
            .as_bytes()
            .iter()
            .for_each(|byte| response_body.push(*byte));

        response_field_lines.insert(
-            String::from("Content-Length"),
-            response_body.len().to_string(),
+            String::from("content-length"),
+            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(
            RequestMethods::Get,
@ -287,7 +368,7 @@ fn parse_field_lines(
 fn response_builder(
    method: RequestMethods,
    status_line: &str,
-    field_lines: Option<HashMap<String, String>>,
+    field_lines: Option<HashMap<String, Vec<String>>>,
    body: Option<Vec<u8>>,
 ) -> Vec<u8> {
    let mut response: Vec<u8> = vec![];
@ -310,11 +391,9 @@ fn response_builder(
            response.push(b':');
            response.push(b' ');

-            field_line
-                .1
-                .as_bytes()
-                .iter()
-                .for_each(|byte| response.push(*byte));
+            for val in field_line.1 {
+                val.as_bytes().iter().for_each(|byte| response.push(*byte));
+            }

            response.push(b'\r');
            response.push(b'\n');
@ -336,37 +415,84 @@ fn response_builder(
    response
 }

-fn try_get_file(start_line: &StartLine, _field_lines: &HashMap<String, String>) -> Vec<u8> {
-    let mut response_field_lines: HashMap<String, String> = HashMap::new();
+fn try_get_file(start_line: &StartLine, field_lines: &HashMap<String, Vec<String>>) -> Vec<u8> {
+    let mut response_field_lines: HashMap<String, Vec<String>> = HashMap::new();
    let mut response_body: Vec<u8> = vec![];
-
    let path: PathBuf = match start_line.target.as_str() {
        "/" => PathBuf::from("/www/index.html"),
        _ => PathBuf::from(format!("/www{}", start_line.target)),
    };

-    // TODO: Check if wanted file is contained in the optional Accept field-line
-    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept for reference
-    // let mime_type = match MimeGuess::from_path(&path).first_raw() {
-    //     Some(val) => val,
-    //     _ => {
-    //         return response_builder(RequestMethods::HEAD, "HTTP/1.1 500 ", None, None);
-    //     }
-    // }
-
    match fs::read(&path) {
        Ok(val) => {
            val.iter().for_each(|byte| response_body.push(*byte));

            response_field_lines.insert(
-                String::from("Content-Length"),
-                response_body.len().to_string(),
+                String::from("content-length"),
+                vec![response_body.len().to_string()],
            );

            let mime_type = mime_guess::from_path(&path)
-                .first_raw()
+                .first()
                .expect("Could not guess mime-type from path");
-            response_field_lines.insert(String::from("Content-Type"), mime_type.to_string());
+
+            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,
+                "HTTP/1.1 200 ",
+                Some(response_field_lines),
+                Some(response_body),
+            )
+        }
+        Err(_) => response_builder(start_line.method, "HTTP/1.1 404 ", None, None),
+    }
+}
+
+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,
@ -382,7 +508,7 @@ fn try_get_file(start_line: &StartLine, _field_lines: &HashMap<String, String>)
 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_field_lines: HashMap<String, Vec<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
@ -399,10 +525,13 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
            .for_each(|byte| response_body.push(*byte));

        response_field_lines.insert(
-            String::from("Content-Length"),
-            response_body.len().to_string(),
+            String::from("content-length"),
+            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(
            RequestMethods::Get,
@ -421,7 +550,7 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
            return Ok(());
        }
    };
-    dbg!(&start_line);
+    // dbg!(&start_line);

    let field_lines = match parse_field_lines(&mut reader) {
        Ok(val) => val,
@ -430,7 +559,7 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
            return Ok(());
        }
    };
-    dbg!(&field_lines);
+    // dbg!(&field_lines);

    // let mut request_body: Vec<u8> = vec![];
    // reader.read_to_end(&mut request_body)?;
@ -438,8 +567,8 @@ fn handle_request(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
    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" => response_builder(start_line.method, "HTTP/1.1 404 ", None, None),
-        "/server-info" => response_builder(start_line.method, "HTTP/1.1 404 ", 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)?;
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