C++ HTTP Server Fundamentals

Navigate and manage a C++ project tree using Ubuntu shell commands.

Use shell redirection and pipelines to inspect program output and log files.

Compile a C++20 translation unit with GCC using strict warning flags.

Build a multi-file C++ program and distinguish compilation errors from linker errors.

Define and build a multi-source executable with CMake.

Track the evolving server in Git using a C++ .gitignore, focused commits, and milestone branches.

Inspect variables, stack frames, and control flow with GDB breakpoints.

Detect memory and undefined-behavior defects with AddressSanitizer and UndefinedBehaviorSanitizer.

Trace the construction and destruction order of automatic, dynamic, and member objects.

Refactor manually managed cleanup into deterministic cleanup using RAII.

Distinguish copying from moving for an object that owns a resource.

Implement correct move construction and move assignment for a move-only resource owner.

Transfer exclusive heap ownership with std::unique_ptr without leaking or double-deleting.

Use std::vector and std::string while accounting for iterator, pointer, and reference invalidation.

Use std::string_view without creating dangling views.

Represent operating-system failures with std::error_code and std::system_error.

Identify the client, server, endpoint, address, and port in a network exchange.

Explain how the IPv4 loopback interface and TCP ports deliver traffic to a local process.

Explain why TCP is a reliable byte stream rather than a sequence of application messages.

Convert integer fields between host and network byte order.

Order the socket, bind, listen, accept, receive, send, and close operations in a TCP server lifecycle.

Observe local connections and manually probe a service using ip, ss, netcat, and curl.

Create an IPv4 TCP socket and report socket-creation failures.

Construct a loopback socket address and bind it to a configurable port.

Put a bound socket into listening mode with an explicit backlog.

Accept one client and inspect its peer address.

Receive and display raw request bytes from a connected client.

Send a syntactically valid hard-coded HTTP response over a connected socket.

Run a sequential accept loop and verify repeated requests with curl.

Implement an RAII wrapper that closes an owned file descriptor exactly once.

Make a file-descriptor wrapper move-only while preserving a valid empty state.

Translate failed socket operations and errno values into contextual C++ errors.

Separate listening-socket responsibilities from connected-socket responsibilities.

Organize the server into focused headers, implementation files, and namespaces.

Test file-descriptor destruction and ownership transfer without using a live network connection.

Identify the request line, header section, terminating blank line, and optional body in an HTTP request.

Model an HTTP request with explicit method, target, version, and header fields.

Parse a request line into method, request target, and protocol version.

Parse one HTTP header while handling optional whitespace and case-insensitive field names.

Locate the end of an HTTP header section within a byte buffer.

Return distinct incomplete, complete, and malformed results from a request parser.

Validate the HTTP version and required Host header for the supported protocol subset.

Reject unsupported methods, request bodies, and requests that exceed configured limits.

Model an HTTP response with status, headers, and body fields.

Serialize an HTTP status line and headers with correct CRLF delimiters.

Derive Content-Length and connection headers from a response model.

Dispatch an exact request path to a handler stored as a C++ callable.

Implement a dynamic GET route that constructs a response from application data.

Implement HEAD by preserving GET metadata while omitting transmitted body bytes.

Generate consistent responses for malformed requests, missing routes, and unsupported methods.

Explain how partial reads and writes arise on a TCP byte stream.

Accumulate bounded receive chunks until one complete HTTP header section is available.

Implement a send-all operation that advances correctly after partial writes.

Handle interrupted calls, peer disconnection, and broken-pipe conditions without leaking resources.

Configure and handle a finite receive timeout on a connected socket.

Process exactly one bounded request per connection and close it predictably.

Verify incremental parsing by sending a request in deliberately fragmented chunks.

Separate the path and query components of an HTTP request target.

Map a designated route prefix to a document root with std::filesystem.

Normalize requested paths and reject attempts to escape the document root.

Read a regular file in binary mode without corrupting its contents.

Select a basic Content-Type from a file extension with a defined fallback.

Apply HEAD semantics to static-file responses without reading unnecessary body data.

Map missing, non-regular, and unreadable files to deliberate HTTP error responses.

Create dependency-free test executables and register them with CTest.

Write table-driven tests for valid, incomplete, and malformed HTTP requests.

Verify response serialization byte-for-byte against expected HTTP messages.

Test routing and method handling without opening network sockets.

Test static-file containment and error cases using a temporary document tree.

Run an end-to-end server check with curl and diagnose failures using logs, GDB, and sanitizers.

Measure basic local behavior and explain why it does not constitute a production benchmark.

Identify shared mutable state that can cause data races in a concurrent server.

Manage worker lifetime with std::jthread and deterministic joining.

Protect a task queue with std::mutex and scoped locking.

Coordinate producers and consumers with a predicate-based std::condition_variable wait.

Assemble a fixed-size worker pool from a synchronized queue and worker threads.

Transfer ownership of each accepted connection into a worker task.

Emit coherent concurrent diagnostics with synchronized output.

Use concurrent clients and ThreadSanitizer to detect concurrency defects.

Parse command-line settings for port, document root, and worker count.

Validate server configuration before acquiring network resources.

Structure CMake targets so the server core is shared by the application and tests.

Stop accepting new work on an interrupt signal and shut down worker threads in order.

Run an acceptance checklist covering dynamic routes, static files, errors, timeouts, and concurrent clients.

Document the supported HTTP subset, resource-ownership design, known limitations, and features intentionally delegated to production libraries.

Publish the completed repository to GitHub and tag a stable project release.

Write a portfolio-ready README containing project goals, features, build and test instructions, architecture, example requests, and deliberate limitations.