ClientHandler.java

import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Client connection handler
 */
public class ClientHandler implements Runnable {
    private final Socket clientSocket;
    private final HttpServer server;
    private final String threadName;
    private int requestCount = 0;
    
    public ClientHandler(Socket clientSocket, HttpServer server) {
        this.clientSocket = clientSocket;
        this.server = server;
        this.threadName = "Thread-" + Thread.currentThread().getId();
    }
    
    @Override
    public void run() {
        try {
            handleClient();
        } catch (Exception e) {
            server.log(threadName, "Error handling client: " + e.getMessage());
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                server.log(threadName, "Error closing client socket: " + e.getMessage());
            }
            server.connectionFinished();
        }
    }
    
    private void handleClient() throws IOException {
        String clientAddress = clientSocket.getInetAddress().getHostAddress() + ":" + clientSocket.getPort();
        server.log(threadName, "Connection from " + clientAddress);
        
        BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        OutputStream outputStream = clientSocket.getOutputStream();
        
        boolean keepAlive = true;
        
        while (keepAlive && requestCount < server.getMaxRequestsPerConnection()) {
            try {
                HttpRequest request = parseRequest(reader);
                if (request == null) {
                    break; // Connection closed or invalid request
                }
                
                requestCount++;
                server.log(threadName, "Request: " + request.getMethod() + " " + request.getPath() + " " + request.getVersion());
                
                // check host header
                if (!server.isValidHost(request.getHeader("Host"), server.host, server.port)) {
                    if (request.getHeader("Host") == null) {
                        sendErrorResponse(outputStream, 400, "Bad Request", "Missing Host header");
                    } else {
                        server.log(threadName, "Host validation failed: " + request.getHeader("Host"));
                        sendErrorResponse(outputStream, 403, "Forbidden", "Host header mismatch");
                    }
                    break;
                }
                
                server.log(threadName, "Host validation: " + request.getHeader("Host") + " ✓");
                
                // handle the request
                HttpResponse response = processRequest(request);
                sendResponse(outputStream, response);
                
                // check if we should keep connection alive
                String connectionHeader = request.getHeader("Connection");
                if ("close".equalsIgnoreCase(connectionHeader)) {
                    keepAlive = false;
                    server.log(threadName, "Connection: close");
                } else {
                    keepAlive = true;
                    server.log(threadName, "Connection: keep-alive");
                }
                
            } catch (SocketTimeoutException e) {
                server.log(threadName, "Connection timeout");
                break;
            } catch (IOException e) {
                server.log(threadName, "IO error: " + e.getMessage());
                break;
            }
        }
        
        if (requestCount >= server.getMaxRequestsPerConnection()) {
            server.log(threadName, "Connection closed: max requests reached (" + requestCount + ")");
        }
    }
    
    private HttpRequest parseRequest(BufferedReader reader) throws IOException {
        String requestLine = reader.readLine();
        if (requestLine == null || requestLine.trim().isEmpty()) {
            return null;
        }
        
        // Parse request line
        String[] parts = requestLine.split(" ");
        if (parts.length != 3) {
            return null;
        }
        
        String method = parts[0];
        String path = parts[1];
        String version = parts[2];
        
        // Parse headers
        Map<String, String> headers = new HashMap<>();
        String line;
        while ((line = reader.readLine()) != null && !line.trim().isEmpty()) {
            int colonIndex = line.indexOf(':');
            if (colonIndex > 0) {
                String headerName = line.substring(0, colonIndex).trim();
                String headerValue = line.substring(colonIndex + 1).trim();
                headers.put(headerName, headerValue);
            }
        }
        
        // Parse body for POST requests
        String body = null;
        if ("POST".equals(method)) {
            String contentLengthStr = headers.get("Content-Length");
            if (contentLengthStr != null) {
                try {
                    int contentLength = Integer.parseInt(contentLengthStr);
                    if (contentLength > 0 && contentLength <= server.getMaxRequestSize()) {
                        char[] bodyChars = new char[contentLength];
                        int totalRead = 0;
                        while (totalRead < contentLength) {
                            int read = reader.read(bodyChars, totalRead, contentLength - totalRead);
                            if (read == -1) break;
                            totalRead += read;
                        }
                        body = new String(bodyChars, 0, totalRead);
                    }
                } catch (NumberFormatException e) {
                    // Invalid content length
                }
            }
        }
        
        return new HttpRequest(method, path, version, headers, body);
    }
    
    private HttpResponse processRequest(HttpRequest request) {
        // check for path traversal
        if (server.isPathTraversal(request.getPath())) {
            server.log(threadName, "Path traversal attempt blocked: " + request.getPath());
            return new HttpResponse(403, "Forbidden", "Path traversal not allowed", "text/plain");
        }
        
        // clean up the path
        String path = request.getPath();
        if (path.equals("/")) {
            path = "/index.html";
        }
        
        // remove leading slash
        if (path.startsWith("/")) {
            path = path.substring(1);
        }
        
        // make sure we stay in resources dir
        Path resourcePath = Paths.get(server.getResourcesDir(), path).normalize();
        Path resourcesDir = Paths.get(server.getResourcesDir()).normalize();
        
        if (!resourcePath.startsWith(resourcesDir)) {
            server.log(threadName, "Unauthorized path access attempt: " + request.getPath());
            return new HttpResponse(403, "Forbidden", "Unauthorized path access", "text/plain");
        }
        
        switch (request.getMethod()) {
            case "GET":
                return handleGetRequest(resourcePath.toString());
            case "POST":
                return handlePostRequest(request);
            default:
                return new HttpResponse(405, "Method Not Allowed", "Method not allowed", "text/plain");
        }
    }
    
    private HttpResponse handleGetRequest(String filePath) {
        File file = new File(filePath);
        
        if (!file.exists() || !file.isFile()) {
            return new HttpResponse(404, "Not Found", "File not found", "text/plain");
        }
        
        String fileName = file.getName();
        String extension = getFileExtension(fileName);
        
        try {
            if (isHtmlFile(extension)) {
                return serveHtmlFile(file);
            } else if (isBinaryFile(extension)) {
                return serveBinaryFile(file);
            } else {
                return new HttpResponse(415, "Unsupported Media Type", "File type not supported", "text/plain");
            }
        } catch (IOException e) {
            server.log(threadName, "Error serving file: " + e.getMessage());
            return new HttpResponse(500, "Internal Server Error", "Error reading file", "text/plain");
        }
    }
    
    private HttpResponse handlePostRequest(HttpRequest request) {
        String contentType = request.getHeader("Content-Type");
        if (contentType == null || !contentType.toLowerCase().contains("application/json")) {
            return new HttpResponse(415, "Unsupported Media Type", "Only application/json is supported", "text/plain");
        }
        
        String body = request.getBody();
        if (body == null || body.trim().isEmpty()) {
            return new HttpResponse(400, "Bad Request", "Empty request body", "text/plain");
        }
        
        // basic json check
        if (!isValidJson(body)) {
            return new HttpResponse(400, "Bad Request", "Invalid JSON format", "text/plain");
        }
        
        try {
            // create upload file
            String timestamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
            String randomId = UUID.randomUUID().toString().substring(0, 8);
            String fileName = "upload_" + timestamp + "_" + randomId + ".json";
            String filePath = server.getUploadsDir() + "/" + fileName;
            
            // write the json
            try (FileWriter writer = new FileWriter(filePath)) {
                writer.write(body);
            }
            
            // build response
            String responseBody = String.format(
                "{\n" +
                "  \"status\": \"success\",\n" +
                "  \"message\": \"File created successfully\",\n" +
                "  \"filepath\": \"/uploads/%s\"\n" +
                "}", fileName
            );
            
            server.log(threadName, "File created: " + fileName);
            return new HttpResponse(201, "Created", responseBody, "application/json");
            
        } catch (IOException e) {
            server.log(threadName, "Error creating upload file: " + e.getMessage());
            return new HttpResponse(500, "Internal Server Error", "Error creating file", "text/plain");
        }
    }
    
    private HttpResponse serveHtmlFile(File file) throws IOException {
        String content = new String(Files.readAllBytes(file.toPath()), "UTF-8");
        server.log(threadName, "Sending HTML file: " + file.getName() + " (" + content.length() + " bytes)");
        return new HttpResponse(200, "OK", content, "text/html; charset=utf-8");
    }
    
    private HttpResponse serveBinaryFile(File file) throws IOException {
        byte[] content = Files.readAllBytes(file.toPath());
        server.log(threadName, "Sending binary file: " + file.getName() + " (" + content.length + " bytes)");
        
        HttpResponse response = new HttpResponse(200, "OK", content, "application/octet-stream");
        response.addHeader("Content-Disposition", "attachment; filename=\"" + file.getName() + "\"");
        return response;
    }
    
    private void sendResponse(OutputStream outputStream, HttpResponse response) throws IOException {
        StringBuilder responseBuilder = new StringBuilder();
        
        // status line
        responseBuilder.append("HTTP/1.1 ").append(response.getStatusCode())
                      .append(" ").append(response.getStatusMessage()).append("\r\n");
        
        // headers
        responseBuilder.append("Content-Type: ").append(response.getContentType()).append("\r\n");
        responseBuilder.append("Content-Length: ").append(response.getContentLength()).append("\r\n");
        responseBuilder.append("Date: ").append(server.getCurrentDate()).append("\r\n");
        responseBuilder.append("Server: Multi-threaded HTTP Server\r\n");
        responseBuilder.append("Connection: keep-alive\r\n");
        responseBuilder.append("Keep-Alive: timeout=30, max=100\r\n");
        
        // extra headers
        for (Map.Entry<String, String> header : response.getHeaders().entrySet()) {
            responseBuilder.append(header.getKey()).append(": ").append(header.getValue()).append("\r\n");
        }
        
        responseBuilder.append("\r\n");
        
        // send headers
        outputStream.write(responseBuilder.toString().getBytes("UTF-8"));
        
        // send body
        if (response.getContent() != null) {
            outputStream.write(response.getContent());
        }
        
        outputStream.flush();
        
        server.log(threadName, "Response: " + response.getStatusCode() + " " + response.getStatusMessage() + 
                  " (" + response.getContentLength() + " bytes transferred)");
    }
    
    private void sendErrorResponse(OutputStream outputStream, int statusCode, String statusMessage, String body) throws IOException {
        HttpResponse response = new HttpResponse(statusCode, statusMessage, body, "text/plain");
        sendResponse(outputStream, response);
    }
    
    private String getFileExtension(String fileName) {
        int lastDot = fileName.lastIndexOf('.');
        return lastDot > 0 ? fileName.substring(lastDot + 1).toLowerCase() : "";
    }
    
    private boolean isHtmlFile(String extension) {
        return "html".equals(extension) || "htm".equals(extension);
    }
    
    private boolean isBinaryFile(String extension) {
        return "png".equals(extension) || "jpg".equals(extension) || 
               "jpeg".equals(extension) || "txt".equals(extension);
    }
    
    private boolean isValidJson(String json) {
        // simple json validation
        json = json.trim();
        if (!json.startsWith("{") || !json.endsWith("}")) {
            return false;
        }
        
        int braceCount = 0;
        boolean inString = false;
        boolean escaped = false;
        
        for (char c : json.toCharArray()) {
            if (escaped) {
                escaped = false;
                continue;
            }
            
            if (c == '\\') {
                escaped = true;
                continue;
            }
            
            if (c == '"') {
                inString = !inString;
                continue;
            }
            
            if (!inString) {
                if (c == '{') {
                    braceCount++;
                } else if (c == '}') {
                    braceCount--;
                }
            }
        }
        
        return braceCount == 0;
    }
}