httpd-0003/0004 + varnish-0003: 3 new defects (12x/50x/25x); count 592→595

defects/httpd/unit/HttpdProxyRouteWorkerAlgorithmTest.java

@@ -0,0 +1,155 @@
+package unit;
+
+import java.util.*;
+
+/**
+ * Models Apache httpd find_route_worker redirect chain traversal.
+ *
+ * SLOW: O(N²) — recursive linear scan of N workers per level of redirect chain.
+ * FAST: O(N)  — route→worker HashMap built at init; O(1) lookup per chain step.
+ *
+ * CWE-407: modules/proxy/mod_proxy_balancer.c:210-266
+ */
+public class HttpdProxyRouteWorkerAlgorithmTest {
+
+    static class Worker {
+        final String route;
+        final String redirect; // null if none
+        boolean usable;
+
+        Worker(String route, String redirect, boolean usable) {
+            this.route = route;
+            this.redirect = redirect;
+            this.usable = usable;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Slow — O(N²) recursive linear scan
+    // -------------------------------------------------------------------------
+
+    static class SlowBalancer {
+        final List<Worker> workers;
+        long scanOps = 0;
+
+        SlowBalancer(List<Worker> workers) { this.workers = workers; }
+
+        Worker findRouteWorker(String route, int recursion) {
+            if (recursion >= workers.size()) return null;
+            for (Worker w : workers) {
+                scanOps++;
+                if (w.route.equals(route)) {
+                    if (w.usable) return w;
+                    if (w.redirect != null) {
+                        return findRouteWorker(w.redirect, recursion + 1);
+                    }
+                    return null;
+                }
+            }
+            return null;
+        }
+
+        long resolve(String startRoute) {
+            scanOps = 0;
+            findRouteWorker(startRoute, 0);
+            return scanOps;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Fast — O(N) HashMap lookup
+    // -------------------------------------------------------------------------
+
+    static class FastBalancer {
+        final Map<String, Worker> routeMap;
+        long scanOps = 0;
+
+        FastBalancer(List<Worker> workers) {
+            routeMap = new HashMap<>();
+            for (Worker w : workers) {
+                routeMap.put(w.route, w);
+                scanOps++; // build cost counted separately, not in resolve
+            }
+        }
+
+        Worker findRouteWorker(String route, int recursion, int maxDepth) {
+            if (recursion >= maxDepth) return null;
+            scanOps++;
+            Worker w = routeMap.get(route);
+            if (w == null) return null;
+            if (w.usable) return w;
+            if (w.redirect != null) return findRouteWorker(w.redirect, recursion + 1, maxDepth);
+            return null;
+        }
+
+        long resolve(String startRoute, int maxDepth) {
+            scanOps = 0;
+            findRouteWorker(startRoute, 0, maxDepth);
+            return scanOps;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Build balancer with redirect chain: w0→w1→w2→...→wN-1(usable)
+    // All workers except last are down+redirect to next
+    // -------------------------------------------------------------------------
+
+    static List<Worker> buildChain(int n) {
+        List<Worker> workers = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            String route = "w" + i;
+            String redirect = (i < n - 1) ? "w" + (i + 1) : null;
+            boolean usable = (i == n - 1);
+            workers.add(new Worker(route, redirect, usable));
+        }
+        return workers;
+    }
+
+    public static void main(String[] args) {
+        int passed = 0, total = 0;
+
+        int[] sizes = {10, 25, 50, 100};
+        System.out.println("=== httpd-0004: find_route_worker redirect chain O(N²) ===");
+        for (int n : sizes) {
+            List<Worker> workers = buildChain(n);
+            SlowBalancer slow = new SlowBalancer(workers);
+            FastBalancer fast = new FastBalancer(workers);
+
+            long s = slow.resolve("w0");
+            long f = fast.resolve("w0", n);
+            double ratio = (double) s / f;
+
+            total++;
+            boolean ok = s > f && ratio >= 2.0;
+            System.out.printf("N=%3d  slow=%6d fast=%3d ratio=%5.1fx  %s%n",
+                n, s, f, ratio, ok ? "PASS" : "FAIL");
+            if (ok) passed++;
+        }
+
+        // Correctness: both find the final usable worker
+        List<Worker> chain20 = buildChain(20);
+        SlowBalancer slow20 = new SlowBalancer(chain20);
+        FastBalancer fast20 = new FastBalancer(chain20);
+        Worker sw = slow20.findRouteWorker("w0", 0);
+        Worker fw = fast20.findRouteWorker("w0", 0, 20);
+        total++;
+        boolean correct = sw != null && fw != null && sw.route.equals(fw.route);
+        System.out.printf("correctness (both find w19): %s%n", correct ? "PASS" : "FAIL");
+        if (correct) passed++;
+
+        // Ratio check at N=50 >= 5x
+        List<Worker> chain50 = buildChain(50);
+        SlowBalancer s50 = new SlowBalancer(chain50);
+        FastBalancer f50 = new FastBalancer(chain50);
+        long sOps = s50.resolve("w0");
+        long fOps = f50.resolve("w0", 50);
+        double ratio50 = (double) sOps / fOps;
+        total++;
+        boolean ratioOk = ratio50 >= 5.0;
+        System.out.printf("N=50 ratio=%.1fx >= 5x: %s%n", ratio50, ratioOk ? "PASS" : "FAIL");
+        if (ratioOk) passed++;
+
+        System.out.printf("%n%d/%d PASS%n", passed, total);
+        if (passed < total) System.exit(1);
+    }
+}