diff --git a/src/windows/native/java/net/DualStackPlainSocketImpl.c b/src/windows/native/java/net/DualStackPlainSocketImpl.c index 374596023abf92f3463d3bf3e09bea073269e1ac..604ea9f7c3b88c6c038c6c0041457e0a1524612d 100644 --- a/src/windows/native/java/net/DualStackPlainSocketImpl.c +++ b/src/windows/native/java/net/DualStackPlainSocketImpl.c @@ -294,6 +294,8 @@ JNIEXPORT jint JNICALL Java_java_net_DualStackPlainSocketImpl_accept0 return -1; } + SetHandleInformation((HANDLE)(UINT_PTR)newfd, HANDLE_FLAG_INHERIT, 0); + ia = NET_SockaddrToInetAddress(env, (struct sockaddr *)&sa, &port); isa = (*env)->NewObject(env, isa_class, isa_ctorID, ia, port); (*env)->SetObjectArrayElement(env, isaa, 0, isa); diff --git a/src/windows/native/java/net/TwoStacksPlainSocketImpl.c b/src/windows/native/java/net/TwoStacksPlainSocketImpl.c index 2d745f1897db300677de07afd176868a496205d3..899d5dec615c638d421434dc7b7ddc4380ab2ad2 100644 --- a/src/windows/native/java/net/TwoStacksPlainSocketImpl.c +++ b/src/windows/native/java/net/TwoStacksPlainSocketImpl.c @@ -701,6 +701,7 @@ Java_java_net_TwoStacksPlainSocketImpl_socketAccept(JNIEnv *env, jobject this, } return; } + SetHandleInformation((HANDLE)(UINT_PTR)fd, HANDLE_FLAG_INHERIT, 0); (*env)->SetIntField(env, socketFdObj, IO_fd_fdID, fd); if (him.him.sa_family == AF_INET) { diff --git a/src/windows/native/sun/nio/ch/ServerSocketChannelImpl.c b/src/windows/native/sun/nio/ch/ServerSocketChannelImpl.c index 30d6d641645a54c6951356f3d5ea418b32ec96e6..8cd94eadaa9236e88f1b934c0dee283c88bc04f3 100644 --- a/src/windows/native/sun/nio/ch/ServerSocketChannelImpl.c +++ b/src/windows/native/sun/nio/ch/ServerSocketChannelImpl.c @@ -105,6 +105,7 @@ Java_sun_nio_ch_ServerSocketChannelImpl_accept0(JNIEnv *env, jobject this, return IOS_THROWN; } + SetHandleInformation((HANDLE)(UINT_PTR)newfd, HANDLE_FLAG_INHERIT, 0); (*env)->SetIntField(env, newfdo, fd_fdID, newfd); remote_ia = NET_SockaddrToInetAddress(env, (struct sockaddr *)&sa, (int *)&remote_port); CHECK_NULL_RETURN(remote_ia, IOS_THROWN); diff --git a/test/java/net/ServerSocket/AcceptInheritHandle.java b/test/java/net/ServerSocket/AcceptInheritHandle.java new file mode 100644 index 0000000000000000000000000000000000000000..ce175f2f4904d1e4c04bb5d3da53adfe5816cdf2 --- /dev/null +++ b/test/java/net/ServerSocket/AcceptInheritHandle.java @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2015, 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 8067105 + * @summary Socket returned by ServerSocket.accept() is inherited by child process on Windows + * @author Chris Hegarty + */ + +import java.io.*; +import java.net.*; +import java.nio.channels.ServerSocketChannel; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.function.Supplier; + +public class AcceptInheritHandle { + + enum ServerSocketProducer { + JAVA_NET(() -> { + try { + return new ServerSocket(); } + catch(IOException x) { + throw new UncheckedIOException(x); + } + }), + NIO_CHANNELS(() -> { + try { + return ServerSocketChannel.open().socket(); + } catch (IOException x) { + throw new UncheckedIOException(x); + } + }); + + final Supplier supplier; + ServerSocketProducer(Supplier supplier) { + this.supplier = supplier; + } + Supplier supplier () { return supplier; } + } + + static final String JAVA = System.getProperty("java.home") + + File.separator + "bin" + File.separator + "java"; + + static final String CLASSPATH = System.getProperty("java.class.path"); + + public static void main(String[] args) throws Exception { + if (args.length == 1) + server(ServerSocketProducer.valueOf(args[0])); + else + mainEntry(); + } + + static void mainEntry() throws Exception { + testJavaNetServerSocket(); + testNioServerSocketChannel(); + } + + static void testJavaNetServerSocket() throws Exception { + test(ServerSocketProducer.JAVA_NET); + test(ServerSocketProducer.JAVA_NET, "-Djava.net.preferIPv4Stack=true"); + } + static void testNioServerSocketChannel() throws Exception { + test(ServerSocketProducer.NIO_CHANNELS); + } + + static void test(ServerSocketProducer ssp, String... sysProps) throws Exception { + System.out.println("\nStarting test for " + ssp.name()); + + List commands = new ArrayList<>(); + commands.add(JAVA); + for (String prop : sysProps) + commands.add(prop); + commands.add("-cp"); + commands.add(CLASSPATH); + commands.add("AcceptInheritHandle"); + commands.add(ssp.name()); + + System.out.println("Executing: "+ commands); + ProcessBuilder pb = new ProcessBuilder(commands); + pb.redirectError(ProcessBuilder.Redirect.INHERIT); + Process serverProcess = pb.start(); + DataInputStream dis = new DataInputStream(serverProcess.getInputStream()); + + int port = dis.readInt(); + System.out.println("Server process listening on " + port + ", connecting..."); + + Socket socket = new Socket("localhost", port); + String s = dis.readUTF(); + System.out.println("Server process said " + s); + + serverProcess.destroy(); + serverProcess.waitFor(30, TimeUnit.SECONDS); + System.out.println("serverProcess exitCode:" + serverProcess.exitValue()); + + try { + socket.setSoTimeout(10 * 1000); + socket.getInputStream().read(); + } catch (SocketTimeoutException x) { + // failed + throw new RuntimeException("Failed: should get reset, not " + x); + } catch (SocketException x) { + System.out.println("Expected:" + x); + } + } + + static void server(ServerSocketProducer producer) throws Exception { + try (ServerSocket ss = producer.supplier().get()) { + ss.bind(new InetSocketAddress(0)); + int port = ss.getLocalPort(); + DataOutputStream dos = new DataOutputStream(System.out); + dos.writeInt(port); + dos.flush(); + + ss.accept(); // do not close + + Runtime.getRuntime().exec("sleep 20"); + Thread.sleep(3 * 1000); + + dos.writeUTF("kill me!"); + dos.flush(); + Thread.sleep(30 * 1000); + } + } +}