Refactor file resolving

src/main/java/org/example/ConnectionHandler.java

@@ -14,13 +14,16 @@
 import java.io.IOException;
 import java.net.Socket;
 
+
 public class ConnectionHandler implements AutoCloseable {
 
     Socket client;
     String uri;
     private final List<Filter> filters;
     String webRoot;
 
+
+
     public ConnectionHandler(Socket client) {
         this.client = client;
         this.filters = buildFilters();
@@ -45,6 +48,7 @@ private List<Filter> buildFilters() {
     }
 
     public void runConnectionHandler() throws IOException {
+
         StaticFileHandler sfh;
 
         if (webRoot != null) {
@@ -53,17 +57,23 @@ public void runConnectionHandler() throws IOException {
             sfh = new StaticFileHandler();
         }
 
+
         HttpParser parser = new HttpParser();
+
         parser.setReader(client.getInputStream());
         parser.parseRequest();
         parser.parseHttp();
 
+        String resolvedPath = FileResolver.resolvePath(parser.getUri());
+
         HttpRequest request = new HttpRequest(
                 parser.getMethod(),
                 parser.getUri(),
                 parser.getVersion(),
                 parser.getHeadersMap(),
-                ""
+                "",
+                resolvedPath
+
         );
 
         String clientIp = client.getInetAddress().getHostAddress();

src/main/java/org/example/FileResolver.java

@@ -0,0 +1,54 @@
+package org.example;
+
+import org.example.config.ConfigLoader;
+import org.example.filter.FilterChain;
+import org.example.http.HttpCachingHeaders;
+import org.example.http.HttpResponseBuilder;
+import org.example.httpparser.HttpRequest;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class FileResolver {
+
+
+    /**
+     * Helper class to resolve HTTP request paths to actual file system paths.
+     *  This method processes incoming HTTP request paths and converts them into
+     *  absolute file paths that can be used to locate and serve static files.
+     * @param requestPath the HTTP request path (e.g., "/", "/index.html"
+     * @return the complete file system path combining the root directory with the processed request path
+     */
+
+    public static String resolvePath(String requestPath) {
+            HttpResponseBuilder response = new HttpResponseBuilder();
+            File errorFile = new File("src/main/resources/error.html");
+
+        if (requestPath == null || requestPath.isEmpty()) {
+            requestPath = "/";
+        }
+        String path = requestPath.equals("/") ? "index.html" : requestPath.substring(1);
+        String rootDir = ConfigLoader.get().server().rootDir();
+
+        if (path.contains("..")) {
+            try {
+                response.setBody(Files.readAllBytes(errorFile.toPath()));
+            } catch (IOException e) {
+                response.setBody("Forbidden".getBytes(StandardCharsets.UTF_8));
+            }
+            response.setStatusCode(HttpResponseBuilder.SC_FORBIDDEN);
+            return null;
+        }
+
+        return rootDir + "/" + path;
+
+    }
+
+
+
+}
+
+

src/main/java/org/example/StaticFileHandler.java

@@ -1,6 +1,10 @@
 package org.example;
 
+import org.example.config.ConfigLoader;
+import org.example.filter.FilterChain;
 import org.example.http.HttpResponseBuilder;
+import org.example.httpparser.HttpRequest;
+
 import static org.example.http.HttpResponseBuilder.*;
 
 import java.io.File;
@@ -35,6 +39,7 @@ private void handleGetRequest(String uri) throws IOException {
         // Path traversal check
         File root = new File(WEB_ROOT).getCanonicalFile();
         File file = new File(root, uri).getCanonicalFile();
+
         if (!file.toPath().startsWith(root.toPath())) {
             fileBytes = "403 Forbidden".getBytes(java.nio.charset.StandardCharsets.UTF_8);
             statusCode = SC_FORBIDDEN;
@@ -56,6 +61,42 @@ private void handleGetRequest(String uri) throws IOException {
         }
     }
 
+    public void handle(HttpRequest request, HttpResponseBuilder response, FilterChain chain) throws IOException {
+
+        String rootDir = ConfigLoader.get().server().rootDir();
+        File root = new File(rootDir).getCanonicalFile();
+        File file = new File(request.getResolvedPath()).getCanonicalFile();
+
+        if (!file.toPath().startsWith(root.toPath())) {
+            response.setStatusCode(HttpResponseBuilder.SC_FORBIDDEN);
+            response.setBody("403 Forbidden");
+            return;
+        }
+
+
+        if (file.isFile()) {
+            byte[] fileBytes = Files.readAllBytes(file.toPath());
+            response.setBody(fileBytes);
+            response.setStatusCode(SC_OK);
+            response.setContentTypeFromFilename(file.getName());
+            statusCode = SC_OK;
+        }
+        else {
+            response.setStatusCode(HttpResponseBuilder.SC_NOT_FOUND);
+
+            File errorFile = new File(root, "pageNotFound.html");
+            if (errorFile.isFile()) {
+                response.setBody(Files.readAllBytes(errorFile.toPath()));
+                response.setContentTypeFromFilename(errorFile.getName());
+            } else {
+                response.setBody("404 Not Found".getBytes());
+                response.setHeader("Content-Type", "text/plain; charset=UTF-8");
+            }
+        }
+
+
+    }
+
     public void sendGetRequest(OutputStream outputStream, String uri) throws IOException {
         handleGetRequest(uri);
         HttpResponseBuilder response = new HttpResponseBuilder();

src/main/java/org/example/http/CachingFilter.java

@@ -0,0 +1,100 @@
+package org.example.http;
+
+
+import org.example.config.AppConfig;
+import org.example.config.ConfigLoader;
+import org.example.filter.Filter;
+import org.example.filter.FilterChain;
+import org.example.httpparser.HttpRequest;
+
+import java.io.File;
+import java.io.ObjectInputFilter;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
+import java.util.Map;
+
+
+public class CachingFilter implements Filter {
+
+
+    @Override
+    public void init() {
+
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+
+    @Override
+    public void doFilter(HttpRequest request, HttpResponseBuilder response, FilterChain chain) {
+
+
+        HttpCachingHeaders cachingHeaders = new HttpCachingHeaders();
+
+        String resolvedPath = request.getResolvedPath();
+        File file = new File(resolvedPath);
+        if (!file.isFile()) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+
+        Map<String, String> headers = request.getHeaders();
+
+        String modifiedSince = headers.get("If-Modified-Since");
+        String eTag = generateEtag(file);
+        String quotedEtag = "\"" + eTag + "\"";
+        Instant lastModified = Instant.ofEpochMilli(file.lastModified());
+
+        String ifNoneMatch = headers.get("If-None-Match");
+
+        cachingHeaders.addETagHeader(eTag);
+        cachingHeaders.setLastModified(Instant.ofEpochMilli(file.lastModified()));
+        cachingHeaders.setDefaultCacheControlStatic();
+
+
+        if (ifNoneMatch != null && ifNoneMatch.equals(quotedEtag)) {
+            response.setStatusCode(HttpResponseBuilder.SC_NOT_MODIFIED);
+            cachingHeaders.getHeaders().forEach(response::addHeader);
+            return;
+        }
+
+        if (modifiedSince != null) {
+            try {
+                Instant ifModifiedSinceInstant =
+                        Instant.from(DateTimeFormatter.RFC_1123_DATE_TIME.parse(modifiedSince));
+
+                if (!lastModified.isAfter(ifModifiedSinceInstant)) {
+                    response.setStatusCode(HttpResponseBuilder.SC_NOT_MODIFIED);
+                    cachingHeaders.getHeaders().forEach(response::addHeader);
+                    return;
+                }
+
+            } catch (Exception e) {
+
+                // Ignore malformed If-Modified-Since header; proceed without cache validation
+                // Consider logging: log.debug("Invalid If-Modified-Since header: {}", modifiedSince, e);
+            }
+
+        }
+
+
+
+
+
+
+        chain.doFilter(request, response);
+        cachingHeaders.getHeaders().forEach(response::addHeader);
+
+
+    }
+
+    private String generateEtag(File file) {
+        return file.lastModified() + "-" + file.length();
+
+    }
+}
+
+

src/main/java/org/example/http/HttpCachingHeaders.java

@@ -0,0 +1,108 @@
+package org.example.http;
+
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.LinkedHashMap;
+import java.util.Map;
+//
+/**
+ * Helper class for building HTTP response headers
+ * Lets the client reuse cached responses
+ * Reduces bandwidth
+ * Reduces latency
+ * Reduces load on your server
+ * Ensures webserver and proxies understand caching instructions
+ */
+public class HttpCachingHeaders {
+
+    /**
+     *  Cache Control helps manage servers and browsers by settings rules
+     *  ETag helps cache be more efficient and not needing to send a full resend assuming the content has not changed
+     *  Last-Modified
+     */
+
+    private static final String CACHE_CONTROL = "Cache-Control";
+    private static final String LAST_MODIFIED = "Last-Modified";
+    private static final String ETAG = "ETag";
+
+    private static final DateTimeFormatter HTTP_DATE_FORMATTER =
+            DateTimeFormatter.RFC_1123_DATE_TIME.withZone(ZoneOffset.UTC);
+
+
+    private final Map<String, String> headers = new LinkedHashMap<>();
+
+
+    /**
+     * Sets a header
+     * @param name Header name eg. Cache-Control
+     * @param value Header value eg. public, max-age=3600
+     */
+    public void setHeader(String name, String value) {
+        headers.put(name, value);
+    }
+
+    /**
+     * Helper method for setting ETag header value
+     * ETag values must be enclosed in double quotes "123" not 123
+     * @param etag Raw, unquoted ETag token (e.g. {`@code` abc123}); double quotes
+     * are added automatically to comply with RFC 7232.
+     */
+    public void addETagHeader(String etag) {
+        setHeader(ETAG, "\"" + etag + "\"");
+    }
+
+    /**
+     * Sets Cache-Control header value
+     * @param cacheControl sets rules eg. public, max-age=3600
+     */
+    public void setCacheControl(String cacheControl) {
+        setHeader(CACHE_CONTROL, cacheControl);
+    }
+
+    /**
+     * Helper method for setting Last-Modified header value
+     * Formates and sets Last modified based on an instant
+     * @param instant Timestamp of the last modification
+     */
+    public void setLastModified(Instant instant){
+        setHeader(LAST_MODIFIED, HTTP_DATE_FORMATTER.format(instant));
+    }
+
+
+    /**
+     * In case of errors or unexpected behaviour, the cache should be disabled and no data should be saved
+     */
+    public void setNoCache() {
+        setCacheControl("no-store, no-cache");
+    }
+
+
+    /**
+     * Copies all configured caching headers into the provided target map eg. HttpReponseBuilder.
+     * @param target Map should return generated headers
+     */
+    public void applyTo(Map<String,String> target){
+        target.putAll(headers);
+    }
+
+    /**
+     * Maps all configured caching headers into a new map
+     * @return A map which includes all caching headers
+     */
+    public Map<String,String> getHeaders() {
+        return new LinkedHashMap<>(headers);
+    }
+
+
+
+    /**
+     * Standard settings for caching, 1 hour
+     */
+    public void setDefaultCacheControlStatic(){
+        setCacheControl("public, max-age=3600");
+    }
+
+
+
+}

src/main/java/org/example/http/HttpResponseBuilder.java

@@ -103,6 +103,13 @@ public void setContentTypeFromFilename(String filename) {
         setHeader("Content-Type", mimeType);
     }
 
+
+    public void addHeader(String key, String value){
+        this.headers.put(key, value);
+    }
+
+
+
     /*
      * Builds the complete HTTP response as a byte array and preserves binary content without corruption.
      * @return Complete HTTP response (headers + body) as byte[]
@@ -147,6 +154,7 @@ public byte[] build() {
         System.arraycopy(contentBody, 0, response, headerBytes.length, contentBody.length);
 
         return response;
+
     }
 
     public Map<String, String> getHeaders() {