server.py

import os
import sys
import json
import time
import queue
import socket
import traceback
import mimetypes
import argparse
import threading
from datetime import datetime
from urllib.parse import parse_qs, unquote_plus


#  Logger Utility
class Logger:
    """Simple timestamped logger for thread-safe console output."""

    @staticmethod
    def log(message: str):
        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{now}] {message}", flush=True)



#  File & Security Utilities
class FileUtils:
    @staticmethod
    def get_mime_type(path: str) -> str:
        """Guess the MIME type based on file extension."""
        mime, _ = mimetypes.guess_type(path)
        return mime or "application/octet-stream"

    @staticmethod
    def safe_join(base: str, *paths: str) -> str:
        """Prevent directory traversal attacks."""
        final_path = os.path.abspath(os.path.join(base, *paths))
        if not final_path.startswith(os.path.abspath(base)):
            raise PermissionError("Path traversal attempt detected")
        return final_path



#  HTTP Response Builder
class HttpResponse:
    """Helper for constructing HTTP responses."""

    STATUS_MESSAGES = {
        200: "OK",
        201: "Created",
        400: "Bad Request",
        403: "Forbidden",
        404: "Not Found",
        405: "Method Not Allowed",
        500: "Internal Server Error",
    }

    @staticmethod
    def build(status_code, body="", headers=None, content_type="text/html"):
        reason = HttpResponse.STATUS_MESSAGES.get(status_code, "OK")
        response = f"HTTP/1.1 {status_code} {reason}\r\n"
        if isinstance(body, str):
            body_bytes = body.encode()
        else:
            body_bytes = body

        base_headers = {
            "Server": "Python-MTServer/2.0",
            "Content-Type": content_type,
            "Content-Length": str(len(body_bytes)),
            "Connection": "close",
        }

        if headers:
            base_headers.update(headers)

        for k, v in base_headers.items():
            response += f"{k}: {v}\r\n"
        response += "\r\n"

        return response.encode() + body_bytes



#  Thread Pool
class ThreadPool:
    """A basic fixed-size thread pool."""

    def __init__(self, num_threads: int):
        self.tasks = queue.Queue()
        self.threads = []
        for _ in range(num_threads):
            t = threading.Thread(target=self.worker, daemon=True)
            t.start()
            self.threads.append(t)

    def worker(self):
        while True:
            func, args = self.tasks.get()
            try:
                func(*args)
            except Exception:
                Logger.log("Worker thread error:")
                traceback.print_exc()
            finally:
                self.tasks.task_done()

    def submit(self, func, *args):
        self.tasks.put((func, args))



#  HTTP Request Handler
class HttpRequestHandler:
    """Handles HTTP GET and POST requests."""

    def __init__(self, base_dir: str):
        self.base_dir = base_dir
        self.upload_dir = os.path.join(base_dir, "uploads")
        self.contact_dir = os.path.join(self.upload_dir, "contacts")
        os.makedirs(self.upload_dir, exist_ok=True)
        os.makedirs(self.contact_dir, exist_ok=True)

    def handle_request(self, client_socket, client_addr, request_text: str):
        try:
            lines = request_text.split("\r\n")
            request_line = lines[0].split()
            if len(request_line) < 2:
                raise ValueError("Malformed request line")

            method, path = request_line[0], request_line[1]
            Logger.log(f"{client_addr} → {method} {path}")

            # Validate Host header
            host_header = next((l for l in lines if l.lower().startswith("host:")), None)
            if not host_header:
                client_socket.sendall(HttpResponse.build(400, "<h1>400 Bad Request</h1>"))
                return

            if method == "GET":
                self._handle_get(client_socket, path)
            elif method == "POST":
                clean_path = path.rstrip("/").lower()
                if clean_path in ["/contact", "/contact.html"]:
                    self._handle_contact_post(client_socket, request_text)
                else:
                    self._handle_post_json(client_socket, request_text)
            else:
                client_socket.sendall(HttpResponse.build(405, "<h1>405 Method Not Allowed</h1>"))

        except PermissionError:
            client_socket.sendall(HttpResponse.build(403, "<h1>403 Forbidden</h1>"))
        except FileNotFoundError:
            client_socket.sendall(HttpResponse.build(404, "<h1>404 Not Found</h1>"))
        except Exception as e:
            Logger.log(f"Error handling request: {e}")
            traceback.print_exc()
            client_socket.sendall(HttpResponse.build(500, "<h1>500 Internal Server Error</h1>"))
        finally:
            client_socket.close()

    def _handle_get(self, client_socket, path: str):
        """Serve static files from /resources directory."""
        if path == "/":
            path = "/index.html"
        file_path = FileUtils.safe_join(self.base_dir, path.lstrip("/"))
        if not os.path.exists(file_path):
            raise FileNotFoundError

        mime = FileUtils.get_mime_type(file_path)
        with open(file_path, "rb") as f:
            body = f.read()
        client_socket.sendall(HttpResponse.build(200, body, content_type=mime))

    def _handle_post_json(self, client_socket, request_text: str):
        """Handle simple JSON uploads."""
        try:
            headers, body = request_text.split("\r\n\r\n", 1)
            data = json.loads(body.strip())
            filename = data.get("filename", "upload.txt")
            content = data.get("content", "")
            save_path = FileUtils.safe_join(self.upload_dir, filename)

            with open(save_path, "w") as f:
                f.write(content)

            Logger.log(f"Uploaded: {filename}")
            client_socket.sendall(HttpResponse.build(201, f"<h1>File '{filename}' uploaded</h1>"))
        except json.JSONDecodeError:
            client_socket.sendall(HttpResponse.build(400, "<h1>400 Invalid JSON</h1>"))

    def _handle_contact_post(self, client_socket, request_text: str):
        """Handle POST form submissions from contact.html."""
        try:
            headers, body = request_text.split("\r\n\r\n", 1)
            form_data = parse_qs(body)

            name = unquote_plus(form_data.get("name", ["Anonymous"])[0])
            email = unquote_plus(form_data.get("email", ["unknown@example.com"])[0])
            message = unquote_plus(form_data.get("message", [""])[0])

            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            file_path = os.path.join(self.contact_dir, f"contact_{timestamp}.json")

            with open(file_path, "w", encoding="utf-8") as f:
                json.dump({
                    "name": name,
                    "email": email,
                    "message": message,
                    "timestamp": timestamp
                }, f, indent=2)

            Logger.log(f"New contact message saved: {file_path}")

            response_html = f"""
            <html>
            <head>
                <meta http-equiv="refresh" content="5;url=/index.html">
                <title>Message Sent</title>
            </head>
            <body style='font-family:Poppins,sans-serif;text-align:center;margin-top:50px;'>
                <h1>Thank you, {name}!</h1>
                <p>Your message has been received. We’ll reply soon at <b>{email}</b>.</p>
                <p>You will be redirected to the homepage in 5 seconds.</p>
                <a href="/index.html" style="color:#007bff;text-decoration:none;">Return Home</a>
            </body>
            </html>
            """
            client_socket.sendall(HttpResponse.build(200, response_html))

        except Exception as e:
            Logger.log(f"Contact POST error: {e}")
            client_socket.sendall(HttpResponse.build(500, "<h1>500 Internal Server Error</h1>"))


#--http-server--#
class HTTPServer:
    """The core HTTP server managing socket and workers."""

    def __init__(self, host: str, port: int, thread_count: int):
        self.host = host
        self.port = port
        self.thread_pool = ThreadPool(thread_count)
        self.base_dir = os.path.join(os.getcwd(), "resources")
        self.handler = HttpRequestHandler(self.base_dir)

    def start(self):
        """Start listening for incoming connections."""
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            s.bind((self.host, self.port))
            s.listen(5)
            Logger.log(f"HTTP Server started at http://{self.host}:{self.port}")
            Logger.log(f"Serving files from: {self.base_dir}")
            while True:
                client_socket, addr = s.accept()
                self.thread_pool.submit(self.handle_client, client_socket, addr)

    def handle_client(self, client_socket, addr):
        """Read request and delegate to handler."""
        try:
            request = client_socket.recv(8192).decode(errors="ignore")
            if request:
                self.handler.handle_request(client_socket, addr, request)
        except Exception as e:
            Logger.log(f"Client handling error: {e}")
            traceback.print_exc()
            client_socket.close()


#---main-function---/
def main():
    parser = argparse.ArgumentParser(description="Multi-threaded Modular HTTP Server")
    parser.add_argument("port", nargs="?", type=int, default=8080)
    parser.add_argument("host", nargs="?", type=str, default="127.0.0.1")
    parser.add_argument("threads", nargs="?", type=int, default=10)
    args = parser.parse_args()

    server = HTTPServer(args.host, args.port, args.threads)
    try:
        server.start()
    except KeyboardInterrupt:
        Logger.log("Server shutting down gracefully...")
        sys.exit(0)


if __name__ == "__main__":
    main()