HttpServer.java

import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Pattern;

/**
 * HTTP Server with multi-threading support
 * Handles GET/POST requests and file transfers
 */
public class HttpServer {
    private static final int DEFAULT_PORT = 8080;
    private static final String DEFAULT_HOST = "127.0.0.1";
    private static final int DEFAULT_THREAD_POOL_SIZE = 10;
    private static final int MAX_REQUEST_SIZE = 8192;
    private static final int CONNECTION_TIMEOUT = 30000; // 30 sec timeout
    private static final int MAX_REQUESTS_PER_CONNECTION = 100;
    private static final String RESOURCES_DIR = "resources";
    private static final String UPLOADS_DIR = "resources/uploads";
    
    public final String host;
    public final int port;
    private final int threadPoolSize;
    private final ExecutorService threadPool;
    private final BlockingQueue<Socket> connectionQueue;
    private final AtomicInteger activeConnections;
    private final SimpleDateFormat dateFormat;
    private ServerSocket serverSocket;
    private volatile boolean running;
    
    // check for path traversal attempts
    private static final Pattern PATH_TRAVERSAL_PATTERN = Pattern.compile(".*\\.\\..*|.*//.*|.*\\./.*");
    
    public HttpServer(String host, int port, int threadPoolSize) {
        this.host = host;
        this.port = port;
        this.threadPoolSize = threadPoolSize;
        this.threadPool = Executors.newFixedThreadPool(threadPoolSize);
        this.connectionQueue = new LinkedBlockingQueue<>();
        this.activeConnections = new AtomicInteger(0);
        this.dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US);
        this.dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
    }
    
    public static void main(String[] args) {
        // get command line args
        int port = DEFAULT_PORT;
        String host = DEFAULT_HOST;
        int threadPoolSize = DEFAULT_THREAD_POOL_SIZE;
        
        if (args.length > 0) {
            try {
                port = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Invalid port number: " + args[0]);
                System.exit(1);
            }
        }
        
        if (args.length > 1) {
            host = args[1];
        }
        
        if (args.length > 2) {
            try {
                threadPoolSize = Integer.parseInt(args[2]);
            } catch (NumberFormatException e) {
                System.err.println("Invalid thread pool size: " + args[2]);
                System.exit(1);
            }
        }
        
        HttpServer server = new HttpServer(host, port, threadPoolSize);
        server.start();
    }
    
    public void start() {
        try {
            // make sure directories exist
            createDirectories();
            
            // start listening
            serverSocket = new ServerSocket(port, 50, InetAddress.getByName(host));
            running = true;
            
            log("HTTP Server started on http://" + host + ":" + port);
            log("Thread pool size: " + threadPoolSize);
            log("Serving files from '" + RESOURCES_DIR + "' directory");
            log("Press Ctrl+C to stop the server");
            
            // handle connection queue
            startConnectionProcessor();
            
            // main accept loop
            while (running) {
                try {
                    Socket clientSocket = serverSocket.accept();
                    clientSocket.setSoTimeout(CONNECTION_TIMEOUT);
                    
                    if (activeConnections.get() < threadPoolSize) {
                        activeConnections.incrementAndGet();
                        threadPool.submit(new ClientHandler(clientSocket, this));
                    } else {
                        connectionQueue.offer(clientSocket);
                        log("Warning: Thread pool saturated, queuing connection");
                    }
                } catch (SocketException e) {
                    if (running) {
                        log("Server socket error: " + e.getMessage());
                    }
                }
            }
        } catch (IOException e) {
            log("Failed to start server: " + e.getMessage());
        } finally {
            shutdown();
        }
    }
    
    private void createDirectories() {
        try {
            Files.createDirectories(Paths.get(RESOURCES_DIR));
            Files.createDirectories(Paths.get(UPLOADS_DIR));
        } catch (IOException e) {
            log("Failed to create directories: " + e.getMessage());
        }
    }
    
    private void startConnectionProcessor() {
        Thread processor = new Thread(() -> {
            while (running) {
                try {
                    Socket clientSocket = connectionQueue.take();
                    if (activeConnections.get() < threadPoolSize) {
                        activeConnections.incrementAndGet();
                        threadPool.submit(new ClientHandler(clientSocket, this));
                        log("Connection dequeued, assigned to Thread-" + Thread.currentThread().getId());
                    } else {
                        connectionQueue.offer(clientSocket);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        processor.setDaemon(true);
        processor.start();
    }
    
    public void connectionFinished() {
        activeConnections.decrementAndGet();
    }
    
    public void log(String message) {
        String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("[" + timestamp + "] " + message);
    }
    
    public void log(String threadName, String message) {
        String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("[" + timestamp + "] [" + threadName + "] " + message);
    }
    
    public void shutdown() {
        running = false;
        try {
            if (serverSocket != null && !serverSocket.isClosed()) {
                serverSocket.close();
            }
        } catch (IOException e) {
            log("Error closing server socket: " + e.getMessage());
        }
        
        threadPool.shutdown();
        try {
            if (!threadPool.awaitTermination(5, TimeUnit.SECONDS)) {
                threadPool.shutdownNow();
            }
        } catch (InterruptedException e) {
            threadPool.shutdownNow();
            Thread.currentThread().interrupt();
        }
        
        log("Server shutdown complete");
    }
    
    public String getCurrentDate() {
        return dateFormat.format(new Date());
    }
    
    public String getResourcesDir() {
        return RESOURCES_DIR;
    }
    
    public String getUploadsDir() {
        return UPLOADS_DIR;
    }
    
    public int getMaxRequestsPerConnection() {
        return MAX_REQUESTS_PER_CONNECTION;
    }
    
    public int getMaxRequestSize() {
        return MAX_REQUEST_SIZE;
    }
    
    public boolean isPathTraversal(String path) {
        return PATH_TRAVERSAL_PATTERN.matcher(path).matches();
    }
    
    public boolean isValidHost(String hostHeader, String serverHost, int serverPort) {
        if (hostHeader == null || hostHeader.trim().isEmpty()) {
            return false;
        }
        
        String expectedHost = serverHost + ":" + serverPort;
        return hostHeader.equals(expectedHost) || 
               hostHeader.equals(serverHost) ||
               (serverHost.equals("127.0.0.1") && hostHeader.equals("localhost:" + serverPort)) ||
               (serverHost.equals("localhost") && hostHeader.equals("127.0.0.1:" + serverPort));
    }
}