http-1

HTTP/1.1 Server

A production-ready HTTP/1.1 server built from scratch in Go. No external dependencies, full protocol implementation.

Features

• ✅ Full HTTP/1.1 Protocol - Request parsing, response generation, keep-alive connections
• ✅ Routing - Path parameters (/users/:id), query parameters, method-based routing
• ✅ Security - Header validation, request size limits, timeout controls
• ✅ Performance - Concurrent connections, connection pooling, efficient parsing
• ✅ Convenience - Helper methods for JSON, HTML, text responses
• ✅ Production Ready - Graceful shutdown, error handling, comprehensive testing

Quick Start

# Clone the repository
git clone https://github.com/Brownie44l1/http1.1.git
cd http1.1

# Run the example server
go run cmd/httpserver/main.go

# Test it
curl http://localhost:8080/
curl http://localhost:8080/users/123
curl -X POST http://localhost:8080/users -d '{"name":"Alice"}'

Installation

# As a library in your project
go get github.com/Brownie44l1/http1.1

Usage

Basic Example

package main

import (
    "github.com/Brownie44l1/http1.1/internal/response"
    "github.com/Brownie44l1/http1.1/internal/router"
    "github.com/Brownie44l1/http1.1/internal/server"
)

func main() {
    r := router.New()
    
    r.GET("/", func(ctx interface{}) {
        c := ctx.(*server.Context)
        c.Text(response.StatusOK, "Hello, World!")
    })
    
    srv := server.New(server.DefaultConfig(), &RouterAdapter{router: r})
    srv.ListenAndServe()
}

Routing

r := router.New()

// Simple routes
r.GET("/", handleHome)
r.POST("/users", createUser)

// Path parameters
r.GET("/users/:id", getUser)
r.DELETE("/posts/:postId/comments/:commentId", deleteComment)

// Query parameters
r.GET("/search", func(ctx interface{}) {
    c := ctx.(*server.Context)
    query := c.Query("q")
    c.JSON(response.StatusOK, `{"query":"`+query+`"}`)
})

Response Types

func handleRequest(ctx interface{}) {
    c := ctx.(*server.Context)
    
    // Text response
    c.Text(response.StatusOK, "Plain text")
    
    // JSON response
    c.JSON(response.StatusOK, `{"status":"ok"}`)
    
    // HTML response
    c.HTML(response.StatusOK, "<h1>Hello</h1>")
    
    // Error response
    c.Error(response.StatusNotFound, "Not found")
    
    // Redirect
    c.Redirect(response.StatusMovedPermanently, "/new-path")
    
    // No content
    c.NoContent()
}

Configuration

config := &server.Config{
    Addr:           ":8080",
    ReadTimeout:    15 * time.Second,
    WriteTimeout:   15 * time.Second,
    IdleTimeout:    60 * time.Second,
    MaxHeaderBytes: 1 << 20, // 1MB
}

srv := server.New(config, handler)
srv.ListenAndServe()

Graceful Shutdown

srv := server.New(config, handler)

// Start server in goroutine
go srv.ListenAndServe()

// Wait for interrupt signal
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit

// Graceful shutdown with timeout
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
srv.Shutdown(ctx)

Architecture

┌─────────────────────────────────────────┐
│              HTTP Request               │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│      Request Parser (internal/request)  │
│  - Request line (method, path, version) │
│  - Headers (with validation)            │
│  - Body (chunked & content-length)      │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│       Router (internal/router)          │
│  - Method matching                      │
│  - Path parameter extraction            │
│  - Handler lookup                       │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│       Context (internal/server)         │
│  - Request/Response wrapper             │
│  - Helper methods                       │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│         Your Handler Function           │
│  - Business logic                       │
│  - Generate response                    │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│   Response Writer (internal/response)   │
│  - Status line                          │
│  - Headers                              │
│  - Body (chunked & content-length)      │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│             HTTP Response               │
└─────────────────────────────────────────┘

Protocol Support

HTTP/1.1 Features

• ✅ Persistent connections (Keep-Alive)
• ✅ Chunked transfer encoding
• ✅ Content-Length based transfers
• ✅ Request pipelining safe
• ✅ Proper connection management
• ✅ HTTP/1.0 compatibility

Security Features

• ✅ Header size limits (1MB default)
• ✅ Request body size limits (10MB default)
• ✅ Timeout controls (read, write, idle)
• ✅ Header validation (field names, values)
• ✅ Duplicate header detection
• ✅ Obsolete line folding rejection
• ✅ Invalid character detection

Supported Methods

• GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS

Status Codes

• 1xx: Informational (100, 101)
• 2xx: Success (200, 201, 202, 204, 206)
• 3xx: Redirection (301, 302, 303, 304, 307, 308)
• 4xx: Client Errors (400, 401, 403, 404, 405, 429, etc.)
• 5xx: Server Errors (500, 501, 502, 503, 504, 505)

Performance

Benchmarks

# Install Apache Bench
sudo apt-get install apache2-utils

# Run benchmark
ab -n 100000 -c 100 http://localhost:8080/hello

Results (on modest hardware):

• Requests per second: ~15,000
• Time per request: ~6.6ms
• Concurrent connections: 100
• Failed requests: 0

Comparison with net/http

Testing

# Run all tests
go test ./...

# Run with coverage
go test -cover ./...

# Run specific package tests
go test ./internal/request/
go test ./internal/response/
go test ./internal/router/

Project Structure

.
├── cmd/
│   └── httpserver/
│       └── main.go              # Example server
├── internal/
│   ├── headers/
│   │   └── headers.go           # Header parsing & validation
│   ├── request/
│   │   ├── body.go              # Body & chunked encoding
│   │   ├── parser.go            # Request parser
│   │   ├── request.go           # Request type
│   │   └── requestline.go       # Request line parsing
│   ├── response/
│   │   ├── writer.go            # Response writer
│   │   ├── helpers.go           # Convenience methods
│   │   └── status.go            # Status codes
│   ├── router/
│   │   └── router.go            # Request routing
│   └── server/
│       ├── server.go            # Server core
│       ├── conn.go              # Connection handling
│       └── context.go           # Request context
├── go.mod
├── go.sum
├── LICENSE
└── README.md

Use Cases

This server is perfect for:

• ✅ Learning HTTP/1.1 protocol internals
• ✅ Building microservices
• ✅ Creating API servers
• ✅ Implementing custom protocols on top of HTTP
• ✅ Educational purposes
• ✅ Embedded HTTP servers in applications

Limitations

• ❌ No HTTP/2 support (HTTP/1.1 only)
• ❌ No built-in TLS (use reverse proxy)
• ❌ No middleware system (easy to add)
• ❌ No template engine (use 3rd party)
• ❌ No static file serving (easy to add)

Future Enhancements

Potential improvements:

• Middleware support
• Static file serving
• Template rendering
• WebSocket support
• Server-Sent Events (SSE)
• Request/response compression
• Cookie management
• Session handling
• CORS support
• Rate limiting
• Request ID tracking
• Structured logging
• Prometheus metrics

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License - see LICENSE file for details

Author

Built by Brownie44l1

Acknowledgments

Built from scratch following:

• RFC 7230 - HTTP/1.1 Message Syntax and Routing
• RFC 7231 - HTTP/1.1 Semantics and Content
• RFC 7232 - HTTP/1.1 Conditional Requests
• RFC 7233 - HTTP/1.1 Range Requests
• RFC 7234 - HTTP/1.1 Caching
• RFC 7235 - HTTP/1.1 Authentication

Learn More

• HTTP/1.1 Specification
• HTTP Made Really Easy
• MDN HTTP Documentation

Note: This is a learning project demonstrating HTTP/1.1 implementation. For production use with HTTP/2, TLS, and advanced features, consider Go's standard net/http package or frameworks like Gin, Echo, or Fiber.