server.py

import socket
import logging
import signal
import sys
import os
import random
import string
import json
import datetime
from urllib.parse import unquote
from email.utils import formatdate
import time
import threading
from queue import Queue, Full

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] [%(threadName)s] %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)


# Folder from which files will be served
ROOT_DIR = os.path.join(os.getcwd(), "resources")
MAX_THREADS = 
CONNECTION_QUEUE = Queue(maxsize=50)


# Function to get proper HTTP Date header
def http_date():
    return formatdate(time.time(), usegmt=True)

# Handle each client connection
def handle_client(conn, addr):
    try:
        data = conn.recv(8192)
        if not data:
            return

        lines = data.decode('utf-8', errors='ignore').split('\r\n')
        request_line = lines[0]
        logging.info(f"Connection from {addr}")
        logging.info(f"Request: {request_line}")

        # --- Parse headers ---
        headers_dict = {}
        for line in lines[1:]:
            if ': ' in line:
                k, v = line.split(': ', 1)
                headers_dict[k.lower()] = v

        host_header = headers_dict.get("host", "").strip()

        # --- Security: Host header validation ---
        if not host_header:
            conn.sendall(b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\nMissing Host header")
            logging.info("Blocked request with missing Host header")
            return

        if host_header.lower() not in ("localhost", "127.0.0.1", f"localhost:{PORT}", f"127.0.0.1:{PORT}"):
            conn.sendall(b"HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\nForbidden Host")
            logging.info(f"Blocked request with invalid Host: {host_header}")
            return

        parts = request_line.split()
        if len(parts) < 3:
            conn.sendall(b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n")
            return

        method, path, version = parts
        path = unquote(path.split('?', 1)[0])

        # --- GET handling ---
        if method == 'GET':

            # Reject requests without Host header
            if not host_header:
                conn.sendall(b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\nMissing Host header")
                logging.info("Blocked request with missing Host header")
                return
            
            # Reject requests with invalid Host
            if host_header.lower() not in ("localhost", "127.0.0.1", f"localhost:{PORT}", f"127.0.0.1:{PORT}"):
                conn.sendall(b"HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\nForbidden Host")
                logging.info(f"Blocked request with invalid Host: {host_header}")
                return
            
            # Resolve file path
            if path == '/':
                file_path = os.path.join(ROOT_DIR, "index.html")
            else:
                file_path = os.path.join(ROOT_DIR, path.lstrip('/'))

            # Normalize and get absolute path
            normalized_path = os.path.realpath(file_path)

            # --- Security: Path Traversal Protection ---
            root_abs = os.path.realpath(ROOT_DIR)
            if os.path.commonpath([normalized_path, root_abs]) != root_abs:
                conn.sendall(b"HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\nForbidden")
                logging.info(f"Blocked path traversal attempt: {path}")
                return

            # Check if file exists
            if not os.path.isfile(normalized_path):
                conn.sendall(b"HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\nFile Not Found")
                return

            file_path = normalized_path

            # Determine file type
            ext = os.path.splitext(file_path)[1].lower()
            if ext in ['.html']:
                filename = os.path.basename(file_path)
                content_type = "text/html; charset=utf-8"
                with open(file_path, 'rb') as f:
                    body = f.read()

                headers = (
                    "HTTP/1.1 200 OK\r\n"
                    f"Content-Type: {content_type}\r\n"
                    f"Content-Length: {len(body)}\r\n"
                    f"Content-Disposition: attachment; filename=\"{filename}\"\r\n"
                    f"Date: {http_date()}\r\n"
                    "Server: Multi-threaded HTTP Server\r\n"
                    "Connection: close\r\n"
                    "\r\n"
                ).encode('utf-8')
                conn.sendall(headers + body)

            elif ext in ['.txt', '.png', '.jpg', '.jpeg']:
                content_type = "application/octet-stream"
                filename = os.path.basename(file_path)
                with open(file_path, 'rb') as f:
                    body = f.read()

                logging.info(f"Sending binary file: {filename} ({len(body)} bytes)")
                headers = (
                    "HTTP/1.1 200 OK\r\n"
                    f"Content-Type: {content_type}\r\n"
                    f"Content-Length: {len(body)}\r\n"
                    f"Content-Disposition: attachment; filename=\"{filename}\"\r\n"
                    f"Date: {http_date()}\r\n"
                    "Server: Multi-threaded HTTP Server\r\n"
                    "Connection: close\r\n"
                    "\r\n"
                ).encode('utf-8')
                conn.sendall(headers + body)
                logging.info(f"Response: 200 OK ({len(body)} bytes transferred)")
                logging.info("Connection: close")

            else:
                conn.sendall(b"HTTP/1.1 415 Unsupported Media Type\r\nConnection: close\r\n\r\nUnsupported file type")

        # --- POST /upload handling ---
        elif method == 'POST':
            content_type = headers_dict.get('content-type', '')
            if content_type != 'application/json':
                conn.sendall(b"HTTP/1.1 415 Unsupported Media Type\r\nConnection: close\r\n\r\nOnly application/json allowed")
                return

            content_length = int(headers_dict.get('content-length', 0))
            body_data = data.split(b'\r\n\r\n', 1)[1]

            while len(body_data) < content_length:
                body_data += conn.recv(8192)

            try:
                json_data = json.loads(body_data.decode('utf-8'))
            except json.JSONDecodeError:
                conn.sendall(b"HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\nInvalid JSON")
                return

            # Create uploads directory if not exists
            upload_dir = os.path.join(ROOT_DIR, "uploads")
            os.makedirs(upload_dir, exist_ok=True)

            # Generate filename
            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            random_id = ''.join(random.choices(string.ascii_lowercase + string.digits, k=4))
            filename = f"upload_{timestamp}_{random_id}.json"
            file_path = os.path.join(upload_dir, filename)

            with open(file_path, 'w') as f:
                json.dump(json_data, f, indent=2)

            # Respond 201 Created
            response_body = json.dumps({
                "status": "success",
                "message": "File created successfully",
                "filepath": f"/uploads/{filename}"
            }).encode('utf-8')

            headers = (
                "HTTP/1.1 201 Created\r\n"
                "Content-Type: application/json\r\n"
                f"Content-Length: {len(response_body)}\r\n"
                f"Date: {http_date()}\r\n"
                "Server: Multi-threaded HTTP Server\r\n"
                "Connection: close\r\n"
                "\r\n"
            ).encode('utf-8')
            conn.sendall(headers + response_body)

        else:
            conn.sendall(b"HTTP/1.1 405 Method Not Allowed\r\nConnection: close\r\n\r\n")
            return

    except Exception as e:
        logging.error(f"Error handling request: {e}")
    finally:
        conn.close()

# Worker thread for thread pool
def worker():
    while True:
        conn, addr = CONNECTION_QUEUE.get()

        # Log when a connection is dequeued and assigned to this thread
        if conn is not None:
            logging.info(f"Connection dequeued, assigned to {threading.current_thread().name}")

        if conn is None:
            break

        handle_client(conn, addr)
        CONNECTION_QUEUE.task_done()


# Run server
def run(host, port):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind((host, port))
    server.listen(50)
    logging.info(f"Server started on http://{host}:{port}")
    logging.info(f"Thread pool size: {MAX_THREADS}")
    logging.info(f"Serving files from '{ROOT_DIR}' directory")
    logging.info("Press Ctrl+C to stop the server")

    # Start thread pool
    threads = []
    for _ in range(MAX_THREADS):
        t = threading.Thread(target=worker, daemon=True)
        t.start()
        threads.append(t)

    # Graceful shutdown
    def shutdown(sig, frame):
        logging.info("Shutting down gracefully...")
        server.close()
        for _ in range(MAX_THREADS):
            CONNECTION_QUEUE.put((None, None))
        sys.exit(0)

    signal.signal(signal.SIGINT, shutdown)

    while True:
        try:
            conn, addr = server.accept()
            try:
                CONNECTION_QUEUE.put_nowait((conn, addr))
            except Full:
                logging.warning("Thread pool saturated, queuing connection") # Log when the queue is full
                conn.sendall(
                    b"HTTP/1.1 503 Service Unavailable\r\nRetry-After: 5\r\nConnection: close\r\n\r\nServer busy"
                )
                conn.close()
        except Exception as e:
            logging.error(f"Accept error: {e}")

# Entry point
if __name__ == "__main__":
    HOST = "127.0.0.1"
    PORT = 8080
    run(HOST, PORT)