LGTM

arkahood · arkahood · commit a0286bcda39f · 2025-11-05T04:12:50.000+05:30
diff --git a/.DS_Store b/.DS_Store
diff --git a/.gitignore b/.gitignore
@@ -1 +1,2 @@
-/idea
+/idea
+.DS_Store
diff --git a/README.md b/README.md
@@ -1,21 +1,119 @@
 # RawHTTP
-HTTP 1.1 server from scratch
+A from-scratch HTTP/1.1 server implementation in Go, built directly on TCP sockets.
 
-## HTTP Message Structure
+## Project Overview
 
-According to RFC 7230, HTTP messages follow this structure:
+RawHTTP is an HTTP/1.1 server implementation that demonstrates low-level network programming concepts by building a complete HTTP server from first principles. Unlike frameworks that abstract away protocol details, this implementation provides direct insight into:
+
+- Raw TCP socket handling
+- HTTP message parsing and generation
+- State machine-based request processing
+- Buffer management and streaming
+
+explore how web servers work at the protocol level.
+
+## HTTP Protocol Deep Dive
+
+### HTTP Message Structure
+
+According to RFC 7230, HTTP messages follow this precise structure:
 
 ```
 start-line CRLF
 *( field-line CRLF )
-*( field-line CRLF )
-...
 CRLF
 [ message-body ]
 ```
 
 Where:
 - **start-line**: Request line (method, URI, version) or status line
-- **field-line**: HTTP headers (key-value pairs) (The RFC uses the term)
-- **CRLF**: Carriage return + line feed (`\r\n`)
-- **message-body**: Optional request/response body
+- **field-line**: HTTP headers (key-value pairs)
+- **CRLF**: Carriage return + line feed (`\r\n`) - critical for protocol compliance
+- **message-body**: Optional request/response body
+
+### Request Message Anatomy
+
+```
+GET /api/users HTTP/1.1\r\n          ← Request Line
+Host: example.com\r\n                ← Header Field
+User-Agent: RawHTTP/1.0\r\n          ← Header Field
+Accept: application/json\r\n          ← Header Field
+\r\n                                  ← Header/Body Separator
+[optional message body]               ← Body (for POST, PUT, etc.)
+```
+
+#### Request Line Components
+
+1. **HTTP Method**: Defines the action to be performed
+   - `GET`: Retrieve data
+   - `POST`: Submit data
+   - `PUT`: Update/create resource
+   - `DELETE`: Remove resource
+
+2. **Request Target**: Identifies the resource
+   - **origin-form**: `/path/to/resource?query=value`
+   - **absolute-form**: `http://example.com/path`
+   - **authority-form**: `example.com:80` (CONNECT only)
+   - **asterisk-form**: `*` (OPTIONS only)
+
+3. **HTTP Version**: Currently `HTTP/1.1`
+
+### Response Message Anatomy
+
+```
+HTTP/1.1 200 OK\r\n                  ← Status Line
+Content-Type: text/html\r\n          ← Header Field
+Content-Length: 1234\r\n             ← Header Field
+Connection: close\r\n                ← Header Field
+\r\n                                  ← Header/Body Separator
+<html>...</html>                      ← Body
+```
+
+
+### Header Field Theory
+
+#### Field Name Constraints
+- **tchar**: `!#$%&'*+-.^_`|~` plus ALPHA and DIGIT
+- Case-insensitive (normalized to lowercase in our implementation)
+- No whitespace between field-name and colon
+
+#### Field Value Processing
+- Leading/trailing whitespace is removed
+- Multiple values can be comma-separated
+
+#### Critical Headers
+- **Host**: Required in HTTP/1.1, enables virtual hosting
+- **Content-Length**: **Byte count of message body**
+
+## Running the Server
+
+### Quick Start
+```bash
+# Clone the repository
+git clone https://github.com/arkahood/RawHTTP.git
+cd RawHTTP
+
+# Run the HTTP server
+go run ./cmd/httpserver/main.go
+
+# Server starts on port 8080
+# Visit http://localhost:8080 in your browser
+```
+
+### Testing with curl
+```bash
+# Basic GET request
+curl -v http://localhost:8080/
+```
+
+### Development Commands
+```bash
+# Run tests
+go test ./...
+
+# Build binary
+go build -o httpserver cmd/httpserver/main.go
+
+# View test coverage
+go test -cover ./...
+```
diff --git a/cmd/httpserver/main.go b/cmd/httpserver/main.go
@@ -1,47 +1,34 @@
 package main
 
 import (
-	"RAWHTTP/internal/request"
-	"RAWHTTP/internal/server"
 	"io"
 	"log"
 	"os"
 	"os/signal"
 	"syscall"
+
+	"RAWHTTP/internal/request"
+	"RAWHTTP/pkg/server"
 )
 
 const port = 8080
 
-func handler(w io.Writer, req *request.Request) *server.HandlerError {
-	// Check if the request target is /yourproblem
-	if req.RequestLine.RequestTarget == "/yourproblem" {
-		return &server.HandlerError{
-			StatusCode: 400,
-			Message:    "Your problem is not my problem\n",
-		}
-	}
-
-	if req.RequestLine.RequestTarget == "/myproblem" {
+func handler1(w io.Writer, req *request.Request) *server.HandlerError {
+	// Write a simple response
+	message := "Hello World!\n"
+	_, err := w.Write([]byte(message))
+	if err != nil {
 		return &server.HandlerError{
 			StatusCode: 500,
-			Message:    "My problem is not my problem\n",
-		}
-	}
-
-	if req.RequestLine.RequestTarget == "/route1" {
-		message := "This is Route1\n"
-		_, err := w.Write([]byte(message))
-		if err != nil {
-			return &server.HandlerError{
-				StatusCode: 500,
-				Message:    "Internal Server Error: failed to write response",
-			}
+			Message:    "Internal Server Error: failed to write response",
 		}
-		return nil
 	}
+	return nil
+}
 
+func handler2(w io.Writer, req *request.Request) *server.HandlerError {
 	// Write a simple response
-	message := "Hello World!\n"
+	message := "Hello World2!\n"
 	_, err := w.Write([]byte(message))
 	if err != nil {
 		return &server.HandlerError{
@@ -53,7 +40,12 @@ func handler(w io.Writer, req *request.Request) *server.HandlerError {
 }
 
 func main() {
-	server, err := server.Serve(handler, port)
+	r := server.NewRouter()
+	server, err := server.Serve(r, port)
+
+	r.AddRoute("/", handler1)
+	r.AddRoute("/second-route", handler2)
+
 	if err != nil {
 		log.Fatalf("Error starting server: %v", err)
 	}
diff --git a/pkg/server/server.go b/pkg/server/server.go
@@ -1,20 +1,35 @@
 package server
 
 import (
-	"RAWHTTP/internal/request"
-	"RAWHTTP/internal/response"
 	"bytes"
 	"errors"
 	"fmt"
 	"io"
 	"net"
 	"sync/atomic"
+
+	"RAWHTTP/internal/request"
+	"RAWHTTP/internal/response"
 )
 
 type Server struct {
 	listener       net.Listener
 	serverIsClosed atomic.Bool
-	handler        Handler
+	handler        *Router
+}
+
+type Router struct {
+	routes map[string]Handler
+}
+
+func (r *Router) AddRoute(route string, fn Handler) {
+	r.routes[route] = fn
+}
+
+func NewRouter() *Router {
+	return &Router{
+		routes: make(map[string]Handler),
+	}
 }
 
 type HandlerError struct {
@@ -58,14 +73,14 @@ func (hErr *HandlerError) WriteHandlerError(w io.Writer) error {
 	return err
 }
 
-func Serve(h Handler, port int) (*Server, error) {
+func Serve(r *Router, port int) (*Server, error) {
 	lstnr, err := net.Listen("tcp", fmt.Sprint(":", port))
 	if err != nil {
 		return nil, errors.New("tcp error happened")
 	}
 	server := Server{
 		listener: lstnr,
-		handler:  h,
+		handler:  r,
 	}
 
 	go server.listen()
@@ -109,7 +124,17 @@ func (s *Server) handle(conn net.Conn) {
 	buf := bytes.NewBuffer([]byte{})
 
 	// Call the handler function
-	handlerErr := s.handler(buf, req)
+	handler, exists := s.handler.routes[req.RequestLine.RequestTarget]
+	if !exists {
+		handlerErr := &HandlerError{
+			StatusCode: 404,
+			Message:    "Not Found: " + req.RequestLine.RequestTarget,
+		}
+		handlerErr.WriteHandlerError(conn)
+		return
+	}
+
+	handlerErr := handler(buf, req)
 
 	// If the handler errors, write the error to the connection
 	if handlerErr != nil {
