Add public folder and path resolution logic

CharryWu · CharryWu · commit 6ad1c327d649 · 2025-06-15T00:41:11.000-07:00
diff --git a/public/hello.html b/public/hello.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Rust Web Server</title>
+  </head>
+  <body>
+    <h1>Hello World</h1>
+  </body>
+</html>
diff --git a/public/index.html b/public/index.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Rust Web Server</title>
+    <link rel="stylesheet" href="style.css" />
+  </head>
+  <body>
+    <h1>Rust Web Server</h1>
+    <p>This is a simple web server written in Rust.</p>
+    <p>It is a work in progress and is not yet ready for production.</p>
+    <p>
+      <a href="/hello">Click here to see the "Hello World" page</a>
+    </p>
+  </body>
+</html>
diff --git a/public/style.css b/public/style.css
@@ -0,0 +1,3 @@
+h1 {
+  color: red;
+}
diff --git a/src/http/request.rs b/src/http/request.rs
@@ -87,6 +87,20 @@ pub struct Request<'buf> {
     path: &'buf str,
 }
 impl<'buf> Request<'buf> {
+    pub fn method(&self) -> &Method {
+        &self.method
+    }
+
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
+    /// Returns a reference to the query string if it exists, otherwise returns None
+    /// NOTE: instead of returning &Option<QueryString>, we return Option<&QueryString>
+    /// which is more flexible and easier to use in the caller.
+    pub fn query_string(&self) -> Option<&QueryString> {
+        self.query_string.as_ref() // as_ref() converts &Option<QueryString> to Option<&QueryString>
+    }
     // don't need to implement convert method on own own, just use std::convert::TryFrom in idiomatic Rust (see below)
     // NOT NEEDED: fn from_byte_array(byte_array: &[u8]) -> Result<Self, String>
 }
diff --git a/src/http/response.rs b/src/http/response.rs
@@ -22,6 +22,9 @@ impl Response {
     ///
     /// This method is more efficient than using `Display` because it avoids the overhead of creating a new string.
     /// Especially when the response body is large (e.g. HTML pages with megabytes size of HTML content).
+    /// It uses `write!` macro directly, instead of returning a copy of the response string.
+    /// It also uses static dispatch, instead of dynamic dispatch,
+    /// which resolves to the correct method of types implementing `Write` trait at compile time.
     ///
     /// # Example
     ///
@@ -32,7 +35,7 @@ impl Response {
     ///
     /// # Arguments
     ///
-    /// * `stream` - The stream to write the response to.
+    /// * `stream` - The stream to write the response to. It can be any type that implements `Write` trait.
     ///
     /// # Returns
     /// * `IoResult<()>` - The result of the write operation.
diff --git a/src/main.rs b/src/main.rs
@@ -1,15 +1,25 @@
 #![allow(dead_code)]
-#![allow(unused_imports)]
-#![allow(unused_variables)]
 mod http;
 mod server;
-
-use http::Method;
+mod website_handler;
 use server::Server;
+use std::env;
+use std::path::{Path, absolute};
+use website_handler::WebsiteHandler;
 
 fn main() {
-    let string = String::from("127.0.0.1:8080");
-    let server = Server::new(string);
-    println!("========== Server is running on {} ==========", server.addr);
-    server.run();
+    let default_path = format!("{}/public", env!("CARGO_MANIFEST_DIR"));
+    // you can also ues String::from("./public") as default value
+    let public_path = env::var("PUBLIC_PATH").unwrap_or(default_path);
+    let host = env::var("HOST").unwrap_or(String::from("127.0.0.1"));
+    let port = env::var("PORT").unwrap_or(String::from("8080"));
+    let server = Server::new(format!("{}:{}", host, port));
+    println!("================================================");
+    println!("Server is running on http://{}", server.addr);
+    println!(
+        "Serving files from public path: {}",
+        absolute(Path::new(&public_path)).unwrap().display()
+    );
+    println!("================================================");
+    server.run(WebsiteHandler::new(public_path));
 }
diff --git a/src/server.rs b/src/server.rs
@@ -10,11 +10,22 @@
 /// let server = Server::new("127.0.0.1:8080".to_string());
 /// server.run();
 /// ```
-use crate::http::{Request, Response, StatusCode};
+use crate::http::{ParseError, Request, Response, StatusCode};
 use std::io::{Read, Write}; // For reading from the TCP stream
 use std::net::TcpListener; // For listening to TCP connections
 
-const DEFAULT_BODY: &str = "<html><body><h1>Hello</h1></body></html>";
+/// A trait for handling HTTP requests. Instead of implementing handling logic over
+/// and over in the `Server` struct, we can implement it in a separate struct
+/// and pass it to the `Server` as a parameter, in order to reduce repetition.
+/// This is useful for testing and for implementing different handlers for different routes.
+pub trait Handler {
+    fn handle_request(&mut self, request: &Request) -> Response;
+    fn handle_bad_request(&mut self, e: &ParseError) -> Response {
+        println!("Error: parsing request\n{}", e);
+        Response::new(StatusCode::BadRequest, None)
+    }
+}
+
 #[derive(Debug)]
 pub struct Server {
     pub addr: String, // Address to bind the server to (e.g., "127.0.0.1:8080")
@@ -30,7 +41,7 @@ impl Server {
     }
 
     /// Runs the server, listening for incoming TCP connections and handling requests.
-    pub fn run(&self) {
+    pub fn run(&self, mut handler: impl Handler) {
         println!("Listening on {}", self.addr);
         // Bind the TCP listener to the specified address
         let listener = TcpListener::bind(&self.addr).unwrap();
@@ -53,29 +64,17 @@ impl Server {
                                 String::from_utf8_lossy(&buffer[..bytes_read])
                             );
                             // Attempt to parse the HTTP request from the buffer
-                            match Request::try_from(&buffer[..bytes_read]) {
-                                Ok(request) => {
-                                    // Debug print the parsed request
-                                    dbg!(request);
-                                    // Create a response with a status code of 200 OK and a body of "Hello"
-                                    let response = Response::new(
-                                        StatusCode::Ok,
-                                        Some(DEFAULT_BODY.to_string()),
-                                    );
-                                    // Write the response to the client
-                                    if let Err(e) = response.send(&mut sock_stream) {
-                                        // If there's an error writing to the client, print the error
-                                        println!(
-                                            "========== Error: Failed to write response to client ==========\n{}",
-                                            e
-                                        );
-                                    }
-                                }
-                                Err(e) => {
-                                    // Print any parsing errors
-                                    println!("========== Error ==========\n{}", e);
-                                }
+                            let response = match Request::try_from(&buffer[..bytes_read]) {
+                                Ok(request) => handler.handle_request(&request),
+                                Err(e) => handler.handle_bad_request(&e),
+                            };
+
+                            // Write the response to the client
+                            if let Err(e) = response.send(&mut sock_stream) {
+                                // If there's an error writing to the client, print the error
+                                println!("Error: Failed to write response\n{}", e);
                             }
+
                             // 2 ways to convert between Request and &[u8] using TryFrom and TryInto:
                             // Request::try_from(&buffer[..bytes_read]);
                             // let res: &Result<Request, _> = &buffer[..].try_into();
diff --git a/src/website_handler.rs b/src/website_handler.rs
@@ -0,0 +1,88 @@
+use super::server::Handler;
+use crate::http::{Method, Request, Response, StatusCode};
+use std::fs;
+
+pub struct WebsiteHandler {
+    public_path: String, // path to the public directory
+}
+
+impl WebsiteHandler {
+    /// Creates a new `WebsiteHandler` with the given public path.
+    ///
+    /// # Arguments
+    ///
+    /// * `public_path` - The path to the public directory. Usually comes from the command line arguments.
+    ///
+    /// # Returns
+    ///
+    /// A `WebsiteHandler` object.
+    pub fn new(public_path: String) -> Self {
+        Self { public_path }
+    }
+
+    /// Reads a file from the public directory and returns its contents as a string.
+    /// This method provides a basic level of security by checking for directory traversal attacks.
+    ///
+    /// # Arguments
+    ///
+    /// * `file_path` - The path to the file to read.
+    ///
+    /// # Returns
+    ///
+    /// A `String` containing the contents of the file if it exists, otherwise `None`.
+    fn read_file(&self, file_path: &str) -> Option<String> {
+        let raw_path = format!("{}/{}", self.public_path, file_path);
+        // For security reasons, we need to check if the requested path is under the public path
+        match fs::canonicalize(&raw_path) {
+            Ok(path) => {
+                if path.starts_with(&self.public_path) {
+                    // ok() returns an Option<String>
+                    // if the file is not found, ok() returns None
+                    // if the file is found, ok() returns Some(String)
+                    fs::read_to_string(path).ok()
+                } else {
+                    println!("Directory Traversal Attack Attempted: {}", file_path);
+                    None
+                }
+            }
+            Err(e) => {
+                println!("Error resolving path: {}, error: {}", &raw_path, e);
+                None
+            }
+        }
+    }
+}
+
+impl Handler for WebsiteHandler {
+    /// Handles HTTP requests for the website.
+    ///
+    /// # Note
+    ///
+    /// This method is called by the `Server` when a request is received.
+    /// It handles GET requests for the root path ("/") and returns a default body.
+    /// For other paths, it returns a 404 Not Found response.
+    ///
+    /// # Arguments
+    ///
+    /// * `request` - A reference to the HTTP request.
+    ///
+    /// # Returns
+    ///
+    /// A `Response` object containing the HTTP response.
+    fn handle_request(&mut self, request: &Request) -> Response {
+        // Use double nested match to handle both the method and the path
+        match request.method() {
+            Method::GET => match request.path() {
+                "/" => Response::new(StatusCode::Ok, self.read_file("index.html")),
+                "/hello" => Response::new(StatusCode::Ok, self.read_file("hello.html")),
+                path => match self.read_file(path) {
+                    // if the file exists, read the contents and return a 200 OK response
+                    Some(contents) => Response::new(StatusCode::Ok, Some(contents)),
+                    // if the file does not exist, return a 404 Not Found response
+                    None => Response::new(StatusCode::NotFound, None),
+                },
+            },
+            _ => Response::new(StatusCode::NotFound, None),
+        }
+    }
+}
