undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/jdk/java/net/httpclient/websocket/PendingOperations.java

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.io.IOException;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.function.BooleanSupplier;
+
+import static java.net.http.HttpClient.Builder.NO_PROXY;
+import static java.net.http.HttpClient.newBuilder;
+
+import org.junit.jupiter.api.AfterEach;
+
+/* Common infrastructure for tests that check pending operations */
+public class PendingOperations {
+
+    static final Class<IllegalStateException> ISE = IllegalStateException.class;
+    static final Class<IOException> IOE = IOException.class;
+    // Time after which we deem that the local send buffer and remote
+    // receive buffer must be full.
+    // At the time of writing, using anything <= 5s on Mac will make the
+    // tests fail intermittently.
+    static final long MAX_WAIT_SEC = 10; // seconds.
+    long waitSec;
+
+    DummyWebSocketServer server;
+    WebSocket webSocket;
+
+    protected HttpClient httpClient() {
+        return newBuilder().proxy(NO_PROXY).build();
+    }
+
+    @AfterEach
+    public void cleanup() {
+        // make sure we have a trace both on System.out and System.err
+        // to help with diagnosis.
+        System.out.println("cleanup: Closing server");
+        System.err.println("cleanup: Closing server");
+        server.close();
+        webSocket.abort();
+    }
+
+    /* shortcut */
+    static void assertAllHang(CompletableFuture<?> cf1,
+                              CompletableFuture<?> cf2) {
+        assertHangs(CompletableFuture.anyOf(cf1, cf2));
+    }
+
+    /* shortcut */
+    static void assertHangs(CompletionStage<?> stage) {
+        Support.assertHangs(stage);
+    }
+
+    /* shortcut */
+    static void assertFails(Class<? extends Throwable> clazz,
+                            CompletionStage<?> stage) {
+        Support.assertCompletesExceptionally(clazz, stage);
+    }
+
+    static void assertNotDone(CompletableFuture<?> future) {
+        Support.assertNotDone(future);
+    }
+
+    public static Object[][] booleans() {
+        return new Object[][]{{Boolean.TRUE}, {Boolean.FALSE}};
+    }
+
+    static boolean isMacOS() {
+        return System.getProperty("os.name").contains("OS X");
+    }
+    static boolean isWindows() {
+        return System.getProperty("os.name").toLowerCase().startsWith("win");
+    }
+
+    private static final int ITERATIONS = 3;
+
+    void repeatable(Callable<Void> callable,
+                    BooleanSupplier repeatCondition)
+        throws Exception
+    {
+        int iterations = 0;
+        do {
+            iterations++;
+            if (iterations == 1) {
+                waitSec = initialWaitSec();
+            } else {
+                waitSec = MAX_WAIT_SEC;
+            }
+            System.out.println("--- iteration " + iterations + " ---");
+            try {
+                callable.call();
+                break;
+            } catch (AssertionError e) {
+                var isMac = isMacOS();
+                var isWindows = isWindows();
+                var repeat = repeatCondition.getAsBoolean();
+                System.out.printf("repeatable: isMac=%s, isWindows=%s, repeat=%s, iterations=%d%n",
+                                  isMac, isWindows, repeat, iterations);
+                if ((isMac || isWindows) && repeat) {
+                    // ## This is loathsome, but necessary because of observed
+                    // ## automagic socket buffer resizing on recent macOS platforms
+                    try { cleanup(); } catch (Throwable x) {}
+                    continue;
+                } else {
+                    throw e;
+                }
+            } finally {
+                // gives some time to gc to cleanup any resource that might
+                // be eligible for garbage collection
+                System.gc();
+                Thread.sleep(100);
+            }
+        } while (iterations <= ITERATIONS);
+    }
+
+    long initialWaitSec() {
+        return 1;
+    }
+}