8339538: Wrong timeout computations in DnsClient

8220213: com/sun/jndi/dns/ConfigTests/Timeout.java failed intermittent

Reviewed-by: dfuchs, msheppar, djelinski

Author: AlekseiEfimov

src/jdk.naming.dns/share/classes/com/sun/jndi/dns/DnsClient.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2024, 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
@@ -46,11 +46,15 @@
 import javax.naming.OperationNotSupportedException;
 import javax.naming.ServiceUnavailableException;
 
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Map;
 import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.IntStream;
 
 import jdk.internal.ref.CleanerFactory;
 import sun.security.jca.JCAUtil;
@@ -95,7 +99,7 @@ public class DnsClient {
 
     private static final int DEFAULT_PORT = 53;
     private static final int TRANSACTION_ID_BOUND = 0x10000;
-    private static final int MIN_TIMEOUT = 50; // msec after which there are no retries.
+    private static final int MIN_TIMEOUT = 0; // msec after which there are no retries.
     private static final SecureRandom random = JCAUtil.getSecureRandom();
     private InetAddress[] servers;
     private int[] serverPorts;
@@ -223,20 +227,28 @@ ResourceRecords query(DnsName fqdn, int qclass, int qtype,
 
         Exception caughtException = null;
         boolean[] doNotRetry = new boolean[servers.length];
-
+        // Holder for unfulfilled timeouts left for each server
+        AtomicLong[] unfulfilledUdpTimeouts = IntStream.range(0, servers.length)
+                .mapToObj(_ -> new AtomicLong())
+                .toArray(AtomicLong[]::new);
         try {
             //
             // The UDP retry strategy is to try the 1st server, and then
             // each server in order. If no answer, double the timeout
             // and try each server again.
             //
-            for (int retry = 0; retry < retries; retry++) {
-
+            for (int retry = 0; retry <= retries; retry++) {
+                boolean isLastRetry = retry == retries;
                 // Try each name server.
                 for (int i = 0; i < servers.length; i++) {
                     if (doNotRetry[i]) {
                         continue;
                     }
+                    // unfulfilledServerTimeout is always >= 0
+                    AtomicLong unfulfilledServerTimeout = unfulfilledUdpTimeouts[i];
+                    if (isLastRetry && unfulfilledServerTimeout.get() == 0) {
+                        continue;
+                    }
 
                     // send the request packet and wait for a response.
                     try {
@@ -245,7 +257,7 @@ ResourceRecords query(DnsName fqdn, int qclass, int qtype,
                         }
 
                         byte[] msg = doUdpQuery(pkt, servers[i], serverPorts[i],
-                                                retry, xid);
+                                retry, xid, unfulfilledServerTimeout, isLastRetry);
                         assert msg != null;
                         Header hdr = new Header(msg, msg.length);
 
@@ -259,7 +271,12 @@ ResourceRecords query(DnsName fqdn, int qclass, int qtype,
 
                             // Try each server, starting with the one that just
                             // provided the truncated message.
-                            int retryTimeout = (timeout * (1 << retry));
+                            long retryTimeout = Math.clamp(
+                                    timeout * (1L << (isLastRetry
+                                            ? retry - 1
+                                            : retry)),
+                                    0L, Integer.MAX_VALUE);
+                            ;
                             for (int j = 0; j < servers.length; j++) {
                                 int ij = (i + j) % servers.length;
                                 if (doNotRetry[ij]) {
@@ -301,15 +318,23 @@ ResourceRecords query(DnsName fqdn, int qclass, int qtype,
                         if (debug) {
                             dprint("Caught Exception:" + ex);
                         }
-                        if (caughtException == null) {
+                        if (caughtException == null || servers.length == 1) {
+                            // If there are several servers we continue trying with other
+                            // servers, otherwise this exception will be reported
                             caughtException = ex;
+                        } else {
+                            // Best reporting effort
+                            caughtException.addSuppressed(ex);
                         }
                         doNotRetry[i] = true;
                     } catch (IOException e) {
                         if (debug) {
                             dprint("Caught IOException:" + e);
                         }
-                        if (caughtException == null) {
+                        if (caughtException instanceof CommunicationException ce) {
+                            e.addSuppressed(ce);
+                            caughtException = e;
+                        } else if (caughtException == null) {
                             caughtException = e;
                         }
                     } catch (ClosedSelectorException e) {
@@ -327,8 +352,13 @@ ResourceRecords query(DnsName fqdn, int qclass, int qtype,
                             caughtException = e;
                         }
                     } catch (NamingException e) {
-                        if (caughtException == null) {
+                        if (caughtException == null || servers.length == 1) {
+                            // If there are several servers we continue trying with other
+                            // servers, otherwise this exception will be reported
                             caughtException = e;
+                        } else {
+                            // Best reporting effort
+                            caughtException.addSuppressed(e);
                         }
                         doNotRetry[i] = true;
                     }
@@ -339,8 +369,8 @@ ResourceRecords query(DnsName fqdn, int qclass, int qtype,
             reqs.remove(xid); // cleanup
         }
 
-        if (caughtException instanceof NamingException) {
-            throw (NamingException) caughtException;
+        if (caughtException instanceof NamingException ne) {
+            throw ne;
         }
         // A network timeout or other error occurred.
         NamingException ne = new CommunicationException("DNS error");
@@ -424,10 +454,32 @@ ResourceRecords queryZone(DnsName zone, int qclass, boolean recursion)
      * is enqueued with the corresponding xid in 'resps'.
      */
     private byte[] doUdpQuery(Packet pkt, InetAddress server,
-                                     int port, int retry, int xid)
+                              int port, int retry, int xid,
+                              AtomicLong unfulfilledTimeout,
+                              boolean unfulfilledOnly)
             throws IOException, NamingException {
 
         udpChannelLock.lock();
+
+
+        // use 1L below to ensure conversion to long and avoid potential
+        // integer overflow (timeout is an int).
+        // no point in supporting timeout > Integer.MAX_VALUE, clamp if needed
+        // timeout remaining after successive 'blockingReceive()'.
+        long thisIterationTimeout = unfulfilledOnly
+                ? 0L
+                : Math.clamp(timeout * (1L << retry), 0L, Integer.MAX_VALUE);
+
+        // Compensate with server's positive unfulfilled timeout.
+        // Calling method never supplies zero 'unfulfilledTimeout' when
+        // 'unfulfilledOnly' is 'true', therefore 'thisIterationTimeout'
+        // will always be a positive number, ie infinite timeout
+        // is not possible.
+        thisIterationTimeout += unfulfilledTimeout.get();
+
+        // Track left timeout for the current retry
+        long timeoutLeft = thisIterationTimeout;
+        long start = 0;
         try {
             try (DatagramChannel udpChannel = getDatagramChannel()) {
                 ByteBuffer opkt = ByteBuffer.wrap(pkt.getData(), 0, pkt.length());
@@ -436,13 +488,11 @@ private byte[] doUdpQuery(Packet pkt, InetAddress server,
                 // Packets may only be sent to or received from this server address
                 InetSocketAddress target = new InetSocketAddress(server, port);
                 udpChannel.connect(target);
-                int pktTimeout = (timeout * (1 << retry));
                 udpChannel.write(opkt);
 
-                // timeout remaining after successive 'blockingReceive()'
-                int timeoutLeft = pktTimeout;
                 int cnt = 0;
                 boolean gotData = false;
+                start = System.nanoTime();
                 do {
                     // prepare for retry
                     if (gotData) {
@@ -456,9 +506,7 @@ private byte[] doUdpQuery(Packet pkt, InetAddress server,
                                 ") for:" + xid + "    sock-timeout:" +
                                 timeoutLeft + " ms.");
                     }
-                    long start = System.currentTimeMillis();
-                    gotData = blockingReceive(udpChannel, ipkt, timeoutLeft);
-                    long end = System.currentTimeMillis();
+                    gotData = blockingReceive(udpChannel, target, ipkt, timeoutLeft);
                     assert gotData || ipkt.position() == 0;
                     if (gotData && isMatchResponse(data, xid)) {
                         return data;
@@ -471,17 +519,23 @@ private byte[] doUdpQuery(Packet pkt, InetAddress server,
                             return cachedMsg;
                         }
                     }
-                    timeoutLeft = pktTimeout - ((int) (end - start));
+                    long elapsedMillis = TimeUnit.NANOSECONDS
+                                                 .toMillis(System.nanoTime() - start);
+                    timeoutLeft = thisIterationTimeout - elapsedMillis;
                 } while (timeoutLeft > MIN_TIMEOUT);
                 // no matching packets received within the timeout
                 throw new SocketTimeoutException();
             }
         } finally {
+            long carryoverTimeout = thisIterationTimeout -
+                    TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
+            unfulfilledTimeout.set(Math.max(0, carryoverTimeout));
             udpChannelLock.unlock();
         }
     }
 
-    boolean blockingReceive(DatagramChannel dc, ByteBuffer buffer, long timeout) throws IOException {
+    boolean blockingReceive(DatagramChannel dc, InetSocketAddress target,
+                            ByteBuffer buffer, long timeout) throws IOException {
         boolean dataReceived = false;
         // The provided datagram channel will be used by the caller only to receive data after
         // it is put to non-blocking mode
@@ -491,10 +545,15 @@ boolean blockingReceive(DatagramChannel dc, ByteBuffer buffer, long timeout) thr
             udpChannelSelector.select(timeout);
             var keys = udpChannelSelector.selectedKeys();
             if (keys.contains(selectionKey) && selectionKey.isReadable()) {
-                dc.receive(buffer);
-                dataReceived = true;
+                int before = buffer.position();
+                var senderAddress = dc.receive(buffer);
+                // Empty packets are ignored
+                dataReceived = target.equals(senderAddress) && buffer.position() > before;
+            }
+            // Avoid contention with Selector.close() if called by a clean-up thread
+            synchronized (keys) {
+                keys.clear();
             }
-            keys.clear();
         } finally {
             selectionKey.cancel();
             // Flush the canceled key out of the selected key set
@@ -750,14 +809,19 @@ class Tcp {
     private final Socket sock;
     private final java.io.InputStream in;
     final java.io.OutputStream out;
-    private int timeoutLeft;
+    private long timeoutLeft;
 
-    Tcp(InetAddress server, int port, int timeout) throws IOException {
+    Tcp(InetAddress server, int port, long timeout) throws IOException {
         sock = new Socket();
         try {
-            long start = System.currentTimeMillis();
-            sock.connect(new InetSocketAddress(server, port), timeout);
-            timeoutLeft = (int) (timeout - (System.currentTimeMillis() - start));
+            long start = System.nanoTime();
+            // It is safe to cast to int since the value is
+            // clamped by the caller
+            int intTimeout = (int) timeout;
+            sock.connect(new InetSocketAddress(server, port), intTimeout);
+            timeoutLeft = Duration.ofMillis(timeout)
+                    .minus(Duration.ofNanos((System.nanoTime() - start)))
+                    .toMillis();
             if (timeoutLeft <= 0)
                 throw new SocketTimeoutException();
 
@@ -785,14 +849,16 @@ private interface SocketReadOp {
     private int readWithTimeout(SocketReadOp reader) throws IOException {
         if (timeoutLeft <= 0)
             throw new SocketTimeoutException();
-
-        sock.setSoTimeout(timeoutLeft);
-        long start = System.currentTimeMillis();
+        // It is safe to cast to int since the value is clamped
+        int intTimeout = (int) timeoutLeft;
+        sock.setSoTimeout(intTimeout);
+        long start = System.nanoTime();
         try {
             return reader.read();
         }
         finally {
-            timeoutLeft -= (int) (System.currentTimeMillis() - start);
+            timeoutLeft -= TimeUnit.NANOSECONDS.toMillis(
+                    System.nanoTime() - start);
         }
     }
 

src/jdk.naming.dns/share/classes/com/sun/jndi/dns/DnsContext.java

@@ -176,13 +176,13 @@ public Object addToEnvironment(String propName, Object propVal)
         } else if (propName.equals(INIT_TIMEOUT)) {
             int val = Integer.parseInt((String) propVal);
             if (timeout != val) {
-                timeout = val;
+                timeout = Math.max(val, 0);
                 resolver = null;
             }
         } else if (propName.equals(RETRIES)) {
             int val = Integer.parseInt((String) propVal);
             if (retries != val) {
-                retries = val;
+                retries = Math.clamp(val, 1, 30);
                 resolver = null;
             }
         }
@@ -257,11 +257,11 @@ private void initFromEnvironment()
         val = (String) environment.get(INIT_TIMEOUT);
         timeout = (val == null)
             ? DEFAULT_INIT_TIMEOUT
-            : Integer.parseInt(val);
+            : Math.max(Integer.parseInt(val), 0);
         val = (String) environment.get(RETRIES);
         retries = (val == null)
             ? DEFAULT_RETRIES
-            : Integer.parseInt(val);
+            : Math.clamp(Integer.parseInt(val), 1, 30);
     }
 
     private CT getLookupCT(String attrId)

test/jdk/com/sun/jndi/dns/ConfigTests/Timeout.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2024, 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
@@ -29,7 +29,6 @@
 import java.net.InetSocketAddress;
 import java.net.SocketTimeoutException;
 import java.time.Duration;
-import java.time.Instant;
 
 import jdk.test.lib.net.URIBuilder;
 
@@ -40,16 +39,20 @@
  *          number of retries.
  * @library ../lib/ /test/lib
  * @modules java.base/sun.security.util
- * @run main Timeout
+ * @run main/othervm Timeout
  */
 
 public class Timeout extends DNSTestBase {
     // initial timeout = 1/4 sec
     private static final int TIMEOUT = 250;
     // try 5 times per server
     private static final int RETRIES = 5;
+    // DnsClient retries again with increased timeout if left
+    // timeout is less than this value, and max retry attempts
+    // is not reached
+    private static final int DNS_CLIENT_MIN_TIMEOUT = 0;
 
-    private Instant startTime;
+    private long startTime;
 
     public Timeout() {
         setLocalServer(false);
@@ -81,7 +84,7 @@ public void runTest() throws Exception {
             setContext(new InitialDirContext(env()));
 
             // Any request should fail after timeouts have expired.
-            startTime = Instant.now();
+            startTime = System.nanoTime();
             context().getAttributes("");
 
             throw new RuntimeException(
@@ -92,28 +95,35 @@ public void runTest() throws Exception {
     @Override
     public boolean handleException(Exception e) {
         if (e instanceof CommunicationException) {
-            Duration elapsedTime = Duration.between(startTime, Instant.now());
+            Duration elapsedTime = Duration.ofNanos(System.nanoTime() - startTime);
             if (!(((CommunicationException) e)
                     .getRootCause() instanceof SocketTimeoutException)) {
                 return false;
             }
 
-            Duration expectedTime = Duration.ofMillis(TIMEOUT)
-                    .multipliedBy((1 << RETRIES) - 1);
+            Duration minAllowedTime = Duration.ofMillis(TIMEOUT)
+                    .multipliedBy((1 << RETRIES) - 1)
+                    .minus(Duration.ofMillis(DNS_CLIENT_MIN_TIMEOUT * RETRIES));
+            Duration maxAllowedTime = Duration.ofMillis(TIMEOUT)
+                    .multipliedBy((1 << RETRIES) - 1)
+                    // max allowed timeout value is set to 2 * expected timeout
+                    .multipliedBy(2);
+
             DNSTestUtils.debug("Elapsed (ms):  " + elapsedTime.toMillis());
-            DNSTestUtils.debug("Expected (ms): " + expectedTime.toMillis());
+            String expectedRangeMsg = "%s - %s"
+                    .formatted(minAllowedTime.toMillis(), maxAllowedTime.toMillis());
+            DNSTestUtils.debug("Expected range (ms): " + expectedRangeMsg);
 
             // Check that elapsed time is as long as expected, and
-            // not more than 50% greater.
-            if (elapsedTime.compareTo(expectedTime) >= 0 &&
-                    elapsedTime.multipliedBy(2)
-                            .compareTo(expectedTime.multipliedBy(3)) <= 0) {
+            // not more than 2 times greater.
+            if (elapsedTime.compareTo(minAllowedTime) >= 0 &&
+                elapsedTime.compareTo(maxAllowedTime) <= 0) {
                 System.out.println("elapsed time is as long as expected.");
                 return true;
             }
             throw new RuntimeException(
-                    "Failed: timeout in " + elapsedTime.toMillis()
-                            + " ms, expected" + expectedTime.toMillis() + "ms");
+                    "Failed: timeout in " + elapsedTime.toMillis() +
+                    " ms, expected to be in a range (ms): " + expectedRangeMsg);
         }
 
         return super.handleException(e);

test/jdk/com/sun/jndi/dns/ConfigTests/TimeoutWithEmptyDatagrams.java

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2024, 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 jdk.test.lib.net.URIBuilder;
+
+import javax.naming.CommunicationException;
+import javax.naming.Context;
+import javax.naming.directory.InitialDirContext;
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.SocketTimeoutException;
+import java.time.Duration;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/*
+ * @test
+ * @bug 8339538
+ * @summary Tests that DnsClient correctly calculates left timeout in
+ *          presence of empty datagram packets.
+ * @library ../lib /test/lib
+ * @modules java.base/sun.security.util
+ * @run main/othervm TimeoutWithEmptyDatagrams
+ */
+
+public class TimeoutWithEmptyDatagrams extends DNSTestBase {
+    // initial timeout = 1/4 sec
+    private static final int TIMEOUT = 250;
+    // try 5 times per server
+    private static final int RETRIES = 5;
+    // DnsClient retries again with increased timeout if left
+    // timeout is less than this value, and max retry attempts
+    // is not reached
+    private static final int DNS_CLIENT_MIN_TIMEOUT = 0;
+
+    public TimeoutWithEmptyDatagrams() {
+        setLocalServer(false);
+    }
+
+    public static void main(String[] args) throws Exception {
+        new TimeoutWithEmptyDatagrams().run(args);
+    }
+
+    /*
+     * Tests that we can set the initial UDP timeout interval and the
+     * number of retries.
+     */
+    @Override
+    public void runTest() throws Exception {
+        // Create a DatagramSocket and bind it to the loopback address to simulate
+        // UDP DNS server that doesn't respond
+        try (DatagramSocket ds = new DatagramSocket(new InetSocketAddress(
+                InetAddress.getLoopbackAddress(), 0))) {
+            CountDownLatch gotClientAddress = new CountDownLatch(1);
+            AtomicReference<SocketAddress> clientAddress = new AtomicReference<>();
+            AtomicBoolean stopTestThreads = new AtomicBoolean();
+
+            String allQuietUrl = URIBuilder.newBuilder()
+                    .scheme("dns")
+                    .loopback()
+                    .port(ds.getLocalPort())
+                    .build()
+                    .toString();
+
+            // Run a virtual thread that receives client request packets and extracts
+            // sender address from them.
+            Thread receiverThread = Thread.ofVirtual().start(() -> {
+                while (!stopTestThreads.get()) {
+                    try {
+                        DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
+                        ds.receive(packet);
+                        System.err.println("Got packet from " + packet.getSocketAddress());
+                        boolean hasClientAddress = clientAddress.get() != null;
+                        clientAddress.set(packet.getSocketAddress());
+                        if (!hasClientAddress) {
+                            gotClientAddress.countDown();
+                        }
+                    } catch (IOException e) {
+                        if (!stopTestThreads.get()) {
+                            throw new RuntimeException(e);
+                        } else {
+                            return;
+                        }
+                    }
+                }
+            });
+
+            // Run a virtual thread that will send an empty packets via server socket
+            // that should wake up the selector on a client side.
+            Thread wakeupThread = Thread.ofVirtual().start(() -> {
+                try {
+                    long timeout = Math.max(1, TIMEOUT / 4);
+                    // wait for a first packet on a server socket
+                    gotClientAddress.await();
+
+                    // Now start sending empty packets until we get a notification
+                    // from client part to stop sending
+                    while (!stopTestThreads.get()) {
+                        System.err.println("Server timeout = " + timeout);
+                        TimeUnit.MILLISECONDS.sleep(timeout);
+                        System.err.println("Sending wakeup packet to " + clientAddress.get());
+                        var wakeupPacket = new DatagramPacket(new byte[0], 0);
+                        wakeupPacket.setSocketAddress(clientAddress.get());
+                        ds.send(wakeupPacket);
+                        timeout += Math.max(1, timeout / 2);
+                    }
+                } catch (IOException ioe) {
+                    throw new RuntimeException("Test machinery failure", ioe);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("Interrupted during wakeup packets sending");
+                } finally {
+                    System.err.println("Server thread exiting");
+                }
+            });
+
+            long startTime = 0;
+            try {
+                env().put(Context.PROVIDER_URL, allQuietUrl);
+                env().put("com.sun.jndi.dns.timeout.initial", String.valueOf(TIMEOUT));
+                env().put("com.sun.jndi.dns.timeout.retries", String.valueOf(RETRIES));
+                setContext(new InitialDirContext(env()));
+
+                startTime = System.nanoTime();
+                context().getAttributes("");
+
+                // Any request should fail after timeouts have expired.
+                throw new RuntimeException("Failed: getAttributes succeeded unexpectedly");
+            } catch (CommunicationException ce) {
+                // We need to catch CommunicationException outside the test framework
+                // flow because wakeupThread.join() can take some time that could
+                // increase measured timeout
+                long endTime = System.nanoTime();
+                Duration elapsedTime = Duration.ofNanos(endTime - startTime);
+                if (ce.getRootCause() instanceof SocketTimeoutException) {
+
+                    Duration minAllowedTime = Duration.ofMillis(TIMEOUT)
+                            .multipliedBy((1 << RETRIES) - 1)
+                            .minus(Duration.ofMillis(DNS_CLIENT_MIN_TIMEOUT * RETRIES));
+                    Duration maxAllowedTime = Duration.ofMillis(TIMEOUT)
+                            .multipliedBy((1 << RETRIES) - 1)
+                            // max allowed timeout value is set to 2 * expected timeout
+                            .multipliedBy(2);
+
+                    DNSTestUtils.debug("Elapsed (ms):  " + elapsedTime.toMillis());
+                    String expectedRangeMsg = "%s - %s"
+                            .formatted(minAllowedTime.toMillis(), maxAllowedTime.toMillis());
+                    DNSTestUtils.debug("Expected range (ms): " + expectedRangeMsg);
+
+                    // Check that elapsed time is as long as expected, and
+                    // not more than 2 times greater.
+                    if (elapsedTime.compareTo(minAllowedTime) >= 0 &&
+                        elapsedTime.compareTo(maxAllowedTime) <= 0) {
+                        System.out.println("elapsed time is as long as expected.");
+                    } else {
+                        throw new RuntimeException(
+                                "Failed: timeout in " + elapsedTime.toMillis() +
+                                " ms, expected to be in a range (ms): " + expectedRangeMsg);
+                    }
+                } else {
+                    throw ce;
+                }
+            } finally {
+                stopTestThreads.set(true);
+                wakeupThread.join();
+                ds.close();
+                receiverThread.join();
+            }
+        }
+    }
+}