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/awt/Focus/InactiveFocusRace.java

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2002, 2025, 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.
+ */
+
+/*
+ * @test
+ * @bug 4697451
+ * @summary Test that there is no race between focus component in inactive window and window activation
+ * @key headful
+ * @run main InactiveFocusRace
+*/
+
+import java.awt.Button;
+import java.awt.EventQueue;
+import java.awt.FlowLayout;
+import java.awt.Frame;
+import java.awt.KeyboardFocusManager;
+import java.awt.Point;
+import java.awt.Robot;
+import java.awt.Toolkit;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.event.InputEvent;
+
+public class InactiveFocusRace {
+
+    static Frame activeFrame, inactiveFrame;
+    Button activeButton, inactiveButton1, inactiveButton2;
+    Semaphore sema;
+    final static int TIMEOUT = 10000;
+    private static Robot robot;
+
+    public static void main(String[] args) throws Exception {
+        try {
+            robot = new Robot();
+            InactiveFocusRace test = new InactiveFocusRace();
+            EventQueue.invokeAndWait(() -> {
+                test.init();
+            });
+            robot.waitForIdle();
+            robot.delay(1000);
+            test.start();
+        } finally {
+            EventQueue.invokeAndWait(() -> {
+                if (activeFrame != null) {
+                    activeFrame.dispose();
+                }
+                if (inactiveFrame != null) {
+                    inactiveFrame.dispose();
+                }
+            });
+        }
+    }
+
+    public void init() {
+        activeButton = new Button("active button");
+        inactiveButton1 = new Button("inactive button1");
+        inactiveButton2 = new Button("inactive button2");
+        activeFrame = new Frame("Active frame");
+        inactiveFrame = new Frame("Inactive frame");
+        inactiveFrame.setLayout(new FlowLayout());
+        activeFrame.add(activeButton);
+        inactiveFrame.add(inactiveButton1);
+        inactiveFrame.add(inactiveButton2);
+        activeFrame.pack();
+        activeFrame.setLocation(300, 10);
+        inactiveFrame.pack();
+        inactiveFrame.setLocation(300, 300);
+        sema = new Semaphore();
+
+        inactiveButton1.addFocusListener(new FocusAdapter() {
+            public void focusGained(FocusEvent e) {
+                System.err.println("Button 1 got focus");
+            }
+        });
+        inactiveButton2.addFocusListener(new FocusAdapter() {
+            public void focusGained(FocusEvent e) {
+                System.err.println("Button2 got focus");
+                sema.raise();
+            }
+        });
+        inactiveFrame.addWindowListener(new WindowAdapter() {
+            public void windowActivated(WindowEvent e) {
+                System.err.println("inactive Window activated");
+                sema.raise();
+            }
+        });
+        activeFrame.addWindowListener(new WindowAdapter() {
+            public void windowActivated(WindowEvent e) {
+                System.err.println("Window activated");
+                sema.raise();
+            }
+        });
+        inactiveFrame.setVisible(true);
+    }
+
+    public void start() {
+
+
+        // Wait for inactive frame to become active
+        try {
+            sema.doWait(TIMEOUT);
+        } catch (InterruptedException ie) {
+            throw new RuntimeException("Wait was interrupted");
+        }
+        if (!sema.getState()) {
+            throw new RuntimeException("Frame doesn't become active on show");
+        }
+        sema.setState(false);
+
+        try {
+            EventQueue.invokeAndWait(() -> activeFrame.setVisible(true));
+        } catch (Exception e) {
+            throw new RuntimeException("Interrupted active frame rendering");
+        }
+
+        // Wait for active frame to become active
+        try {
+            sema.doWait(TIMEOUT);
+        } catch (InterruptedException ie) {
+            throw new RuntimeException("Wait was interrupted");
+        }
+        if (!sema.getState()) {
+            throw new RuntimeException("Frame doesn't become active on show");
+        }
+        sema.setState(false);
+
+        // press on second button in inactive frame
+        Point loc = inactiveButton2.getLocationOnScreen();
+        robot.mouseMove(loc.x+5, loc.y+5);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+
+        // after all second button should be focus owner.
+        try {
+            sema.doWait(TIMEOUT);
+        } catch (InterruptedException ie) {
+            throw new RuntimeException("Wait was interrupted");
+        }
+        if (!sema.getState()) {
+            throw new RuntimeException("Button2 didn't become focus owner");
+        }
+        Toolkit.getDefaultToolkit().sync();
+        robot.waitForIdle();
+        if (!(KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() == inactiveButton2)) {
+            throw new RuntimeException("Button2 should be the focus owner after all");
+        }
+
+    }
+
+}
+
+class Semaphore {
+    boolean state = false;
+    int waiting = 0;
+    public Semaphore() {
+    }
+    public void doWait() throws InterruptedException {
+        synchronized(this) {
+            if (state) return;
+            waiting++;
+            wait();
+            waiting--;
+        }
+    }
+    public void doWait(int timeout) throws InterruptedException {
+        synchronized(this) {
+            if (state) return;
+            waiting++;
+            wait(timeout);
+            waiting--;
+        }
+    }
+    public void raise() {
+        synchronized(this) {
+            state = true;
+            if (waiting > 0) {
+                notifyAll();
+            }
+        }
+    }
+    public boolean getState() {
+        synchronized(this) {
+            return state;
+        }
+    }
+    public void setState(boolean newState) {
+        synchronized(this) {
+            state = newState;
+        }
+    }
+}