Merge branch 'main' into issue36

Author: Boppler12

Dockerfile

@@ -9,8 +9,8 @@ FROM eclipse-temurin:25-jre-alpine
 EXPOSE 8080
 RUN addgroup -S appgroup && adduser -S appuser -G appgroup
 WORKDIR /app/
-COPY --from=build /build/target/classes/ /
-COPY --from=build /build/target/dependency/ /dependencies/
-COPY /www/ /www/
+COPY --from=build /build/target/classes/ /app/
+COPY --from=build /build/target/dependency/ /app/dependencies/
+COPY www/ ./www/
 USER appuser
-ENTRYPOINT ["java", "-classpath", "/app:/dependencies/*", "org.example.App"]
+ENTRYPOINT ["java", "-classpath", "/app:/app/dependencies/*", "org.example.App"]

PortConfigurationGuide.md

@@ -0,0 +1,49 @@
+# Konfiguration: port (CLI → config-fil → default)
+
+Det här projektet väljer vilken port servern ska starta på enligt följande prioritet:
+
+1. **CLI-argument** (`--port <port>`) – högst prioritet
+2. **Config-fil** (`application.yml`: `server.port`)
+3. **Default** (`8080`) – används om port saknas i config eller om config-filen saknas
+
+---
+
+## 1) Default-värde
+
+Om varken CLI eller config anger port används:
+
+- **8080** (default för `server.port` i `AppConfig`)
+
+---
+
+## 2) Config-fil: `application.yml`
+
+### Var ska filen ligga?
+Standard:
+- `src/main/resources/application.yml`
+
+### Exempel
+```yaml
+server:
+port: 9090
+```
+
+---
+
+## 3) CLI-argument
+
+CLI kan användas för att override:a config:
+
+```bash
+java -cp target/classes org.example.App --port 8000
+```
+
+---
+
+## 4) Sammanfattning
+
+Prioritet:
+
+1. CLI (`--port`)
+2. `application.yml` (`server.port`)
+3. Default (`8080`)

src/main/java/org/example/App.java

@@ -6,11 +6,50 @@
 import java.nio.file.Path;
 
 public class App {
+
+    private static final String PORT_FLAG = "--port";
+
     public static void main(String[] args) {
         Path configPath = Path.of("src/main/resources/application.yml");
 
         AppConfig appConfig = ConfigLoader.loadOnce(configPath);
-        int port = appConfig.server().port();
+
+        int port = resolvePort(args, appConfig.server().port());
+
         new TcpServer(port).start();
     }
+
+    static int resolvePort(String[] args, int configPort) {
+        Integer cliPort = parsePortFromCli(args);
+        if (cliPort != null) {
+            return validatePort(cliPort, "CLI argument " + PORT_FLAG);
+        }
+        return validatePort(configPort, "configuration server.port");
+    }
+
+    static Integer parsePortFromCli(String[] args) {
+        if (args == null) return null;
+
+        for (int i = 0; i < args.length; i++) {
+            if (PORT_FLAG.equals(args[i])) {
+                int valueIndex = i + 1;
+                if (valueIndex >= args.length) {
+                    throw new IllegalArgumentException("Missing value after " + PORT_FLAG);
+                }
+                try {
+                    return Integer.parseInt(args[valueIndex]);
+                } catch (NumberFormatException e) {
+                    throw new IllegalArgumentException("Invalid port value after " + PORT_FLAG + ": " + args[valueIndex], e);
+                }
+            }
+        }
+        return null;
+    }
+
+    static int validatePort(int port, String source) {
+        if (port < 1 || port > 65535) {
+            throw new IllegalArgumentException("Port out of range (1-65535) from " + source + ": " + port);
+        }
+        return port;
+    }
 }

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

@@ -1,6 +1,15 @@
 package org.example;
 
+import org.example.config.AppConfig;
+import org.example.filter.IpFilter;
 import org.example.httpparser.HttpParser;
+import org.example.httpparser.HttpRequest;
+import java.util.ArrayList;
+import java.util.List;
+import org.example.filter.Filter;
+import org.example.filter.FilterChainImpl;
+import org.example.http.HttpResponseBuilder;
+import org.example.config.ConfigLoader;
 
 import java.io.IOException;
 import java.net.Socket;
@@ -9,21 +18,66 @@ public class ConnectionHandler implements AutoCloseable {
 
     Socket client;
     String uri;
+    private final List<Filter> filters;
 
     public ConnectionHandler(Socket client) {
         this.client = client;
+        this.filters = buildFilters();
     }
+private List<Filter> buildFilters() {
+        List<Filter> list = new ArrayList<>();
+        AppConfig config = ConfigLoader.get();
+        AppConfig.IpFilterConfig ipFilterConfig = config.ipFilter();
+        if (Boolean.TRUE.equals(ipFilterConfig.enabled())) {
+            list.add(createIpFilterFromConfig(ipFilterConfig));
+        }
+        // Add more filters here...
+        return list;
+        }
+
 
     public void runConnectionHandler() throws IOException {
-        StaticFileHandler sfh = new StaticFileHandler();
         HttpParser parser = new HttpParser();
         parser.setReader(client.getInputStream());
         parser.parseRequest();
         parser.parseHttp();
+
+        HttpRequest request = new HttpRequest(
+                parser.getMethod(),
+                parser.getUri(),
+                parser.getVersion(),
+                parser.getHeadersMap(),
+                ""
+        );
+
+        String clientIp = client.getInetAddress().getHostAddress();
+        request.setAttribute("clientIp", clientIp);
+
+        HttpResponseBuilder response = applyFilters(request);
+
+        int statusCode = response.getStatusCode();
+        if (statusCode == HttpResponseBuilder.SC_FORBIDDEN ||
+                statusCode == HttpResponseBuilder.SC_BAD_REQUEST) {
+            byte[] responseBytes = response.build();
+            client.getOutputStream().write(responseBytes);
+            client.getOutputStream().flush();
+            return;
+        }
+
         resolveTargetFile(parser.getUri());
+        StaticFileHandler sfh = new StaticFileHandler();
         sfh.sendGetRequest(client.getOutputStream(), uri);
     }
 
+    private HttpResponseBuilder applyFilters(HttpRequest request) {
+        HttpResponseBuilder response = new HttpResponseBuilder();
+
+        FilterChainImpl chain = new FilterChainImpl(filters);
+        chain.doFilter(request, response);
+
+        return response;
+    }
+
     private void resolveTargetFile(String uri) {
         if (uri.matches("/$")) { //matches(/)
             this.uri = "index.html";
@@ -39,4 +93,28 @@ private void resolveTargetFile(String uri) {
     public void close() throws Exception {
         client.close();
     }
+
+    private IpFilter createIpFilterFromConfig(AppConfig.IpFilterConfig config) {
+        IpFilter filter = new IpFilter();
+
+        // Set mode
+        if ("ALLOWLIST".equalsIgnoreCase(config.mode())) {
+            filter.setMode(IpFilter.FilterMode.ALLOWLIST);
+        } else {
+            filter.setMode(IpFilter.FilterMode.BLOCKLIST);
+        }
+
+        // Add blocked IPs
+        for (String ip : config.blockedIps()) {
+            filter.addBlockedIp(ip);
+        }
+
+        // Add allowed IPs
+        for (String ip : config.allowedIps()) {
+            filter.addAllowedIp(ip);
+        }
+
+        filter.init();
+        return filter;
+    }
 }

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

@@ -1,6 +1,7 @@
 package org.example;
 
 import org.example.http.HttpResponseBuilder;
+import static org.example.http.HttpResponseBuilder.*;
 
 import java.io.File;
 import java.io.IOException;

src/main/java/org/example/config/AppConfig.java

@@ -6,16 +6,22 @@
 @JsonIgnoreProperties(ignoreUnknown = true)
 public record AppConfig(
         @JsonProperty("server") ServerConfig server,
-        @JsonProperty("logging") LoggingConfig logging
+        @JsonProperty("logging") LoggingConfig logging,
+        @JsonProperty("ipFilter") IpFilterConfig ipFilter
 ) {
     public static AppConfig defaults() {
-        return new AppConfig(ServerConfig.defaults(), LoggingConfig.defaults());
+        return new AppConfig(
+                ServerConfig.defaults(),
+                LoggingConfig.defaults(),
+                IpFilterConfig.defaults()
+        );
     }
 
     public AppConfig withDefaultsApplied() {
         ServerConfig serverConfig = (server == null ? ServerConfig.defaults() : server.withDefaultsApplied());
         LoggingConfig loggingConfig = (logging == null ? LoggingConfig.defaults() : logging.withDefaultsApplied());
-        return new AppConfig(serverConfig, loggingConfig);
+        IpFilterConfig ipFilterConfig = (ipFilter == null ? IpFilterConfig.defaults() : ipFilter.withDefaultsApplied());  // ← LÄGG TILL
+        return new AppConfig(serverConfig, loggingConfig, ipFilterConfig);  // ← UPPDATERA DENNA RAD
     }
 
     @JsonIgnoreProperties(ignoreUnknown = true)
@@ -50,4 +56,24 @@ public LoggingConfig withDefaultsApplied() {
             return new LoggingConfig(lvl);
         }
     }
+
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public record IpFilterConfig(
+            @JsonProperty("enabled") Boolean enabled,
+            @JsonProperty("mode") String mode,
+            @JsonProperty("blockedIps") java.util.List<String> blockedIps,
+            @JsonProperty("allowedIps") java.util.List<String> allowedIps
+    ) {
+        public static IpFilterConfig defaults() {
+            return new IpFilterConfig(false, "BLOCKLIST", java.util.List.of(), java.util.List.of());
+        }
+
+        public IpFilterConfig withDefaultsApplied() {
+            Boolean e = (enabled == null) ? false : enabled;
+            String m = (mode == null || mode.isBlank()) ? "BLOCKLIST" : mode;
+            java.util.List<String> blocked = (blockedIps == null) ? java.util.List.of() : blockedIps;
+            java.util.List<String> allowed = (allowedIps == null) ? java.util.List.of() : allowedIps;
+            return new IpFilterConfig(e, m, blocked, allowed);
+        }
+    }
 }

src/main/java/org/example/filter/IpFilter.java

@@ -0,0 +1,108 @@
+package org.example.filter;
+
+
+import org.example.http.HttpResponseBuilder;
+import org.example.httpparser.HttpRequest;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A filter that allows or blocks HTTP requests based on the client's IP address.
+ * The filter supports two modes:
+ * ALLOWLIST – only IP addresses in the allowlist are permitted
+ * BLOCKLIST – all IP addresses are permitted except those in the blocklist
+ */
+public class IpFilter implements Filter {
+
+    private final Set<String> blockedIps = ConcurrentHashMap.newKeySet();
+    private final Set<String> allowedIps = ConcurrentHashMap.newKeySet();
+    private volatile FilterMode mode = FilterMode.BLOCKLIST;
+
+    /**
+     * Defines the filtering mode.
+     */
+    public enum FilterMode {
+        ALLOWLIST,
+        BLOCKLIST
+    }
+
+    @Override
+    public void init() {
+        // Intentionally empty - no initialization needed
+    }
+
+    /**
+     * Filters incoming HTTP requests based on the client's IP address.
+     *
+     * @param request  the incoming HTTP request
+     * @param response the HTTP response builder used when blocking requests
+     * @param chain    the filter chain to continue if the request is allowed
+     */
+    @Override
+    public void doFilter(HttpRequest request, HttpResponseBuilder response, FilterChain chain) {
+        String clientIp = normalizeIp((String) request.getAttribute("clientIp"));
+
+        if (clientIp == null || clientIp.trim().isEmpty()) {
+            response.setStatusCode(HttpResponseBuilder.SC_BAD_REQUEST);
+            response.setBody("Bad Request: Missing client IP address");
+            return;
+        }
+
+        boolean allowed = isIpAllowed(clientIp);
+
+        if (allowed) {
+            chain.doFilter(request, response);
+        } else {
+            response.setStatusCode(HttpResponseBuilder.SC_FORBIDDEN);
+            response.setBody("Forbidden: IP address " + clientIp + " is not allowed");
+        }
+    }
+
+    @Override
+    public void destroy() {
+        // Intentionally empty - no cleanup needed
+    }
+
+    /**
+     * Determines whether an IP address is allowed based on the current filter mode.
+     *
+     * @param ip the IP address to check
+     * @return true if the IP address is allowed, otherwise false
+     */
+    private boolean isIpAllowed(String ip) {
+        if (mode == FilterMode.ALLOWLIST) {
+            return allowedIps.contains(ip);
+        } else {
+            return !blockedIps.contains(ip);
+        }
+    }
+
+    /**
+     * Trims leading and trailing whitespace from an IP address.
+     *
+     * @param ip the IP address
+     * @return the trimmed IP address, or {@code null} if the input is {@code null}
+     */
+    private String normalizeIp(String ip) {
+        return ip == null ? null : ip.trim();
+    }
+
+    public void setMode(FilterMode mode) {
+        this.mode = mode;
+    }
+
+    public void addBlockedIp(String ip) {
+        if (ip == null) {
+            throw new IllegalArgumentException("IP address cannot be null");
+        }
+        blockedIps.add(normalizeIp(ip));
+    }
+
+    public void addAllowedIp(String ip) {
+        if (ip == null) {
+            throw new IllegalArgumentException("IP address cannot be null");
+        }
+        allowedIps.add(normalizeIp(ip));
+    }
+}