Simple HTTP Server

A Simple HTTP Server is a fundamental network application that listens for incoming HTTP requests from clients (like web browsers), processes these requests, and sends back appropriate HTTP responses. At its core, an HTTP server operates on the application layer of the TCP/IP model, using TCP to establish connections.

Here's a breakdown of how a simple HTTP server works:

1. Binding and Listening: The server first binds to a specific IP address and port number (e.g., 127.0.0.1:8080). Once bound, it starts listening for incoming TCP connection requests on that port.
2. Accepting Connections: When a client attempts to connect, the server accepts the connection, establishing a dedicated communication channel (a TCP stream) between the client and the server.
3. Reading Requests: After a connection is established, the server reads the data sent by the client. This data is an HTTP request, which typically includes:
* Request Line: Method (GET, POST, etc.), Path (e.g., '/', '/about'), and HTTP version (e.g., HTTP/1.1).
* Headers: Additional information like Host, User-Agent, Content-Type, Content-Length.
* Body (optional): Data sent with methods like POST or PUT.
4. Processing Requests: The server then processes the request. For a simple server, this might involve checking the requested path and preparing a static response. In more complex scenarios, it could involve database queries, file operations, or executing application logic.
5. Sending Responses: After processing, the server constructs an HTTP response and sends it back to the client over the same TCP stream. An HTTP response typically includes:
* Status Line: HTTP version (e.g., HTTP/1.1), Status Code (e.g., 200 OK, 404 Not Found), and Status Text.
* Headers: Information like Content-Type, Content-Length, Date, Server.
* Body (optional): The actual data being sent back, such as an HTML page, JSON data, or an image.
6. Closing Connection (or keeping alive): For HTTP/1.0, connections were typically closed after each request-response cycle. With HTTP/1.1 and later, connections can be kept alive for multiple requests, improving efficiency.

Implementing a simple HTTP server from scratch using Rust's standard library (specifically `std::net` and `std::io`) provides a deep understanding of network programming concepts without relying on external web frameworks. It demonstrates how to handle TCP streams, read client input, and write back structured HTTP responses.

Example Code

```rust
use std::io::prelude::*;
use std::net::{TcpListener, TcpStream};
use std::fs;

fn main() -> std::io::Result<()> {
    // Bind the TcpListener to an IP address and port
    // 127.0.0.1 is the loopback address, and 7878 is a common port for examples.
    let listener = TcpListener::bind("127.0.0.1:7878")?;
    println!("Server listening on http://127.0.0.1:7878");

    // Iterate over incoming connections
    for stream in listener.incoming() {
        let stream = stream?;
        println!("Connection established!");
        // Handle each connection in a separate function
        // In a real application, you'd likely use threads for concurrency.
        handle_connection(stream)?;
    }
    Ok(())
}

fn handle_connection(mut stream: TcpStream) -> std::io::Result<()> {
    // Create a buffer to store the incoming request data
    let mut buffer = [0; 1024]; // 1KB buffer

    // Read data from the stream into the buffer
    stream.read(&mut buffer)?;

    // Convert the buffer to a string for easier inspection.
    // Note: This assumes UTF-8 and might panic or produce garbage for non-UTF-8 data.
    // For a real server, more robust parsing is needed.
    let request = String::from_utf8_lossy(&buffer[..]);
    println!("Request: {}\n", request);

    // Simple request parsing:
    // Check if the request starts with "GET / HTTP/1.1"
    let get_root = b"GET / HTTP/1.1\r\n";
    let get_hello = b"GET /hello HTTP/1.1\r\n";

    let (status_line, filename) = if buffer.starts_with(get_root) {
        ("HTTP/1.1 200 OK", "hello.html")
    } else if buffer.starts_with(get_hello) {
        ("HTTP/1.1 200 OK", "hello.html")
    } else {
        // Handle 404 Not Found for any other request
        ("HTTP/1.1 404 NOT FOUND", "404.html")
    };

    // Read the content of the file based on the determined filename
    let contents = fs::read_to_string(filename)?;
    let content_length = contents.len();

    // Construct the HTTP response
    let response = format!(
        "{}\r\nContent-Length: {}\r\nContent-Type: text/html\r\n\r\n{}",
        status_line,
        content_length,
        contents
    );

    // Write the response back to the stream
    stream.write_all(response.as_bytes())?;

    // Ensure all buffered data is sent immediately
    stream.flush()?;

    Ok(())
}
```

To run this code:

1.  Save it as `src/main.rs` in a new Rust project (`cargo new simple-http-server`).
2.  Create two HTML files in the project root directory:
    *   `hello.html`:
        ```html
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="utf-8">
            <title>Hello!</title>
        </head>
        <body>
            <h1>Hello from Rust!</h1>
            <p>This is a simple web page served by a Rust HTTP server.</p>
        </body>
        </html>
        ```
    *   `404.html`:
        ```html
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="utf-8">
            <title>404 Not Found</title>
        </head>
        <body>
            <h1>Oops!</h1>
            <p>The page you requested could not be found.</p>
        </body>
        </html>
        ```
3.  Run the server from your terminal: `cargo run`
4.  Open your web browser and navigate to `http://127.0.0.1:7878/` or `http://127.0.0.1:7878/hello`. You should see the content of `hello.html`. If you go to any other path (e.g., `http://127.0.0.1:7878/invalid`), you'll see the `404.html` page.

Example Code

Related Topics