Custom HTTP Web Server (C# Console Application)

Systems Programmer | Individual Project
Duration: Academic Project
Institution: Independent Development

A fully functional single-threaded web server built from scratch implementing complete HTTP/1.1 protocol compliance for serving web content including HTML, images, and static files.

🌐 Project Overview

This custom HTTP web server demonstrates low-level network programming and protocol implementation expertise. Built without relying on high-level HTTP helper classes, the server provides a deep understanding of web communication protocols and TCP/IP networking fundamentals.

🛠️ Technologies Used

Core Technologies:

• C# Programming Language - System implementation and logic
• .NET Framework - Runtime environment and base class libraries
• TCP/IP Networking - Low-level socket communication
• HTTP/1.1 Protocol - Web communication standard implementation
• Socket Programming - Network connection management

🎯 Key Features

🔌 HTTP Protocol Implementation

• Complete HTTP/1.1 Compliance - RFC-compliant request parsing and response generation
• GET Method Support - Full implementation of HTTP GET requests
• Status Code Handling - Proper HTTP status codes (200, 404, etc.)
• Header Management - Custom header parsing and response header construction
• MIME Type Detection - Automatic content-type identification and assignment

🌐 Network Programming

• TCP Socket Communication - Low-level socket implementation using System.Net classes
• TCPListener Integration - Custom request/response processing architecture
• Connection Management - Proper connection lifecycle handling and cleanup
• Single-Threaded Architecture - Efficient sequential request processing
• Port Configuration - Dynamic port binding and network interface management

📁 Content Delivery System

• Multi-Format Support - HTML, plain text (.txt), JPEG images, and GIF files
• Content-Type Headers - Accurate MIME type detection and header generation
• Content-Length Calculation - Proper response size calculation and headers
• Static File Serving - Efficient file system integration and content delivery
• Resource Management - Optimized file I/O operations and memory handling

⚙️ Command-Line Architecture

• Configurable Server - Dynamic webRoot directory configuration
• IP Address Binding - Flexible IP address and network interface selection
• Port Configuration - Custom port assignment for deployment flexibility
• Runtime Parameters - Command-line argument parsing and validation
• Environment Adaptation - Cross-platform compatibility considerations

📊 Comprehensive Logging System

• Detailed Activity Logging - Complete request/response cycle tracking
• Timestamped Entries - Precise logging with date and time information
• Server Lifecycle Events - Startup, shutdown, and configuration logging
• Request Tracking - Incoming request details and processing information
• Response Monitoring - Outgoing response status and content information

🏗️ Technical Architecture

Core Implementation

// Server Architecture Overview
TCPListener → Request Parser → Content Handler → Response Generator → Client

HTTP Request Processing

• Request Line Parsing - Method, URI, and HTTP version extraction
• Header Processing - Complete header parsing and validation
• URI Resolution - Path mapping to filesystem resources
• Method Validation - HTTP method support and error handling

Response Generation

• Status Line Construction - HTTP version and status code formatting
• Header Generation - Server identification, date stamps, and content metadata
• Body Preparation - Content reading and response body assembly
• MIME Type Detection - File extension to content-type mapping

🚀 Technical Achievements

Protocol Compliance

• RFC Standards Adherence - Complete HTTP/1.1 protocol implementation
• Manual Request Parsing - Low-level HTTP message processing
• Custom Response Construction - Header and body generation without helper libraries
• Standard Compliance Testing - Validation against HTTP specifications

Network Programming Excellence

• Socket Management - Efficient TCP connection handling
• Resource Optimization - Memory management and connection lifecycle
• Error Recovery - Graceful exception handling and server stability
• Performance Optimization - Efficient I/O operations and request processing

Browser Compatibility

• Microsoft Edge Support - Full functionality testing and validation
• Google Chrome Compatibility - Cross-browser request handling
• Custom Port Configuration - Flexible deployment and testing capabilities
• Standards Compliance - Universal browser compatibility through protocol adherence

🔧 Installation & Setup

Prerequisites

# .NET Framework 4.7.2 or higher
# Visual Studio 2019+ or .NET CLI
# Windows 10/11 or compatible OS

Build and Run

# Clone repository
git clone https://github.com/yourusername/custom-http-server.git
cd custom-http-server

# Build application
dotnet build

# Run with default settings
dotnet run

# Run with custom configuration
dotnet run -- --port 8080 --webroot "./wwwroot" --ip "127.0.0.1"

Configuration Options

# Command-line parameters
--port <port_number>        # Server port (default: 8080)
--webroot <directory_path>  # Web root directory (default: ./wwwroot)
--ip <ip_address>          # Bind IP address (default: localhost)
--verbose                  # Enable detailed logging

📁 Project Structure

CustomHttpServer/
├── Program.cs              # Main application entry point
├── HttpServer.cs          # Core server implementation
├── HttpRequest.cs         # Request parsing and handling
├── HttpResponse.cs        # Response generation and formatting
├── ContentTypeMapper.cs   # MIME type detection and mapping
├── Logger.cs              # Logging system implementation
├── wwwroot/               # Default web content directory
│   ├── index.html         # Default homepage
│   ├── images/            # Image resources
│   └── styles/            # CSS and static files
└── README.md              # Project documentation

🎯 Core Modules

HTTP Server Core

public class HttpServer
{
    private TcpListener _listener;
    private string _webRoot;
    private bool _isRunning;
    
    public void Start(IPAddress ipAddress, int port)
    public void Stop()
    private void ProcessRequest(TcpClient client)
}

Request Processing

public class HttpRequest
{
    public string Method { get; set; }
    public string Uri { get; set; }
    public string HttpVersion { get; set; }
    public Dictionary<string, string> Headers { get; set; }
}

Response Generation

public class HttpResponse
{
    public int StatusCode { get; set; }
    public Dictionary<string, string> Headers { get; set; }
    public byte[] Content { get; set; }
    
    public byte[] ToByteArray()
}

📊 Performance Metrics

Server Capabilities

• Concurrent Connections: Single-threaded sequential processing
• File Size Support: Limited by available system memory
• Response Time: Sub-millisecond for static content
• Supported Formats: HTML, TXT, JPEG, GIF
• Memory Usage: Optimized for minimal resource consumption

Testing Results

• Browser Compatibility: 100% success rate (Edge, Chrome)
• Protocol Compliance: Full HTTP/1.1 standard adherence
• Error Handling: Graceful degradation and recovery
• Logging Accuracy: Complete request/response cycle tracking

🎯 Skills Demonstrated

Systems Programming

• Low-Level Network Programming - Direct socket manipulation and management
• Protocol Implementation - HTTP/1.1 standard compliance and interpretation
• Memory Management - Efficient resource allocation and cleanup
• Error Handling - Comprehensive exception management and recovery

Network Programming

• TCP/IP Communication - Socket-level network communication
• Connection Management - Client connection lifecycle handling
• Data Serialization - HTTP message formatting and parsing
• Network Security - Basic security considerations and implementations

Software Architecture

• Modular Design - Separation of concerns and component organization
• Command-Line Interface - User-friendly configuration and operation
• Logging System - Comprehensive activity monitoring and debugging
• Cross-Platform Considerations - .NET Framework compatibility

🔍 Learning Outcomes

• Deep Protocol Understanding - Comprehensive knowledge of HTTP/1.1 specification
• Network Programming Mastery - Low-level socket programming expertise
• Systems Programming Skills - Console application development and deployment
• Debugging and Testing - Network application debugging and validation techniques

---

Project Status: Completed
Development Type: Individual Academic Project
Architecture: Single-Threaded Console Application
Role: Systems Programmer