8372958: SocketInputStream.read throws SocketException instead of returning -1 when input shutdown

Reviewed-by: djelinski, michaelm

Author: Alan Bateman

src/java.base/share/classes/sun/nio/ch/NioSocketImpl.java

@@ -289,6 +289,7 @@ private int timedRead(FileDescriptor fd, byte[] b, int off, int len, long nanos)
      */
     private int implRead(byte[] b, int off, int len, long remainingNanos) throws IOException {
         int n = 0;
+        SocketException ex = null;
         FileDescriptor fd = beginRead();
         try {
             if (connectionReset)
@@ -307,18 +308,24 @@ private int implRead(byte[] b, int off, int len, long remainingNanos) throws IOE
                     n = tryRead(fd, b, off, len);
                 }
             }
-            return n;
         } catch (InterruptedIOException e) {
             throw e;
         } catch (ConnectionResetException e) {
             connectionReset = true;
             throw new SocketException("Connection reset");
         } catch (IOException ioe) {
-            // throw SocketException to maintain compatibility
-            throw asSocketException(ioe);
+            // translate to SocketException to maintain compatibility
+            ex = asSocketException(ioe);
         } finally {
             endRead(n > 0);
         }
+        if (n <= 0 && isInputClosed) {
+            return -1;
+        }
+        if (ex != null) {
+            throw ex;
+        }
+        return n;
     }
 
     /**
@@ -411,6 +418,7 @@ private int tryWrite(FileDescriptor fd, byte[] b, int off, int len)
      */
     private int implWrite(byte[] b, int off, int len) throws IOException {
         int n = 0;
+        SocketException ex = null;
         FileDescriptor fd = beginWrite();
         try {
             configureNonBlockingIfNeeded(fd, false);
@@ -419,15 +427,18 @@ private int implWrite(byte[] b, int off, int len) throws IOException {
                 park(fd, Net.POLLOUT);
                 n = tryWrite(fd, b, off, len);
             }
-            return n;
         } catch (InterruptedIOException e) {
             throw e;
         } catch (IOException ioe) {
-            // throw SocketException to maintain compatibility
-            throw asSocketException(ioe);
+            // translate to SocketException to maintain compatibility
+            ex = asSocketException(ioe);
         } finally {
             endWrite(n > 0);
         }
+        if (ex != null) {
+            throw ex;
+        }
+        return n;
     }
 
     /**

test/jdk/java/net/Socket/AsyncShutdown.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 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
@@ -24,11 +24,13 @@
 /*
  * @test
  * @requires (os.family == "linux" | os.family == "mac")
- * @run testng AsyncShutdown
  * @summary Test shutdownInput/shutdownOutput with threads blocked in read/write
+ * @run junit AsyncShutdown
  */
 
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
@@ -38,54 +40,56 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
-import org.testng.annotations.Test;
-import static org.testng.Assert.*;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import static org.junit.jupiter.api.Assertions.*;
 
-@Test
-public class AsyncShutdown {
+class AsyncShutdown {
 
-    public void testShutdownInput1() throws IOException {
+    @ParameterizedTest
+    @ValueSource(booleans = { false, true })
+    void testShutdownInput(boolean timed) throws IOException {
         withConnection((s1, s2) -> {
+            InputStream in = s1.getInputStream();
             scheduleShutdownInput(s1, 2000);
-            int n = s1.getInputStream().read();
-            assertTrue(n == -1);
+            if (timed) {
+                s1.setSoTimeout(30*1000);
+            }
+            assertEquals(-1, in.read());
+            assertEquals(0, in.available());
         });
     }
 
-    public void testShutdownInput2() throws IOException {
-        withConnection((s1, s2) -> {
-            scheduleShutdownInput(s1, 2000);
-            s1.setSoTimeout(30*1000);
-            int n = s1.getInputStream().read();
-            assertTrue(n == -1);
-        });
-    }
-
-    public void testShutdownOutput1() throws IOException {
+    @Test
+    void testShutdownOutput1() throws IOException {
         withConnection((s1, s2) -> {
+            OutputStream out = s1.getOutputStream();
             scheduleShutdownOutput(s1, 2000);
             byte[] data = new byte[128*1024];
             try {
                 while (true) {
-                    s1.getOutputStream().write(data);
+                    out.write(data);
                 }
             } catch (IOException expected) { }
         });
     }
 
-    public void testShutdownOutput2() throws IOException {
+    @Test
+    void testShutdownOutput2() throws IOException {
         withConnection((s1, s2) -> {
             s1.setSoTimeout(100);
             try {
                 s1.getInputStream().read();
-                assertTrue(false);
+                fail();
             } catch (SocketTimeoutException e) { }
 
+            OutputStream out = s1.getOutputStream();
             scheduleShutdownOutput(s1, 2000);
             byte[] data = new byte[128*1024];
             try {
                 while (true) {
-                    s1.getOutputStream().write(data);
+                    out.write(data);
                 }
             } catch (IOException expected) { }
         });