jdk-sandbox: comparison src/java.base/share/classes/sun/nio/ch/DatagramChannelImpl.java

equal deleted inserted replaced

-:f280911d3427
+:289000934908
 private final ProtocolFamily family;
 // Our file descriptor
 private final FileDescriptor fd;
 private final int fdVal;
+// Native buffer for socket address used by receive0, protected by readLock
+private final NativeSocketAddress socketAddress;
+// Cleaner to close file descriptor and free native socket address
 private final Cleanable cleaner;
-// Cached InetAddress and port for unconnected DatagramChannels
-// used by receive0
-private InetAddress cachedSenderInetAddress;
-private int cachedSenderPort;
 // Lock held by current reading or connecting thread
 private final ReentrantLock readLock = new ReentrantLock();
 // Lock held by current writing or connecting thread
 public DatagramChannelImpl(SelectorProvider sp)
 throws IOException
 {
 super(sp);
+this.socketAddress = new NativeSocketAddress();
 ResourceManager.beforeUdpCreate();
 try {
 this.family = Net.isIPv6Available()
 ? StandardProtocolFamily.INET6
 : StandardProtocolFamily.INET;
 this.fd = Net.socket(family, false);
 this.fdVal = IOUtil.fdVal(fd);
 } catch (IOException ioe) {
 ResourceManager.afterUdpClose();
+socketAddress.free();
 throw ioe;
 }
-this.cleaner = CleanerFactory.cleaner().register(this, closerFor(fd));
+Runnable releaser = releaserFor(fd, socketAddress);
+this.cleaner = CleanerFactory.cleaner().register(this, releaser);
 }
 public DatagramChannelImpl(SelectorProvider sp, ProtocolFamily family)
 throws IOException
 {
 if (!Net.isIPv6Available()) {
 throw new UnsupportedOperationException("IPv6 not available");
 }
 }
+this.socketAddress = new NativeSocketAddress();
 ResourceManager.beforeUdpCreate();
 try {
 this.family = family;
 this.fd = Net.socket(family, false);
 this.fdVal = IOUtil.fdVal(fd);
 } catch (IOException ioe) {
 ResourceManager.afterUdpClose();
+socketAddress.free();
 throw ioe;
 }
-this.cleaner = CleanerFactory.cleaner().register(this, closerFor(fd));
+Runnable releaser = releaserFor(fd, socketAddress);
+this.cleaner = CleanerFactory.cleaner().register(this, releaser);
 }
 public DatagramChannelImpl(SelectorProvider sp, FileDescriptor fd)
 throws IOException
 {
 super(sp);
+try {
+this.socketAddress = new NativeSocketAddress();
+} catch (OutOfMemoryError e) {
+nd.close(fd);
+throw e;
+}
 // increment UDP count to match decrement when closing
 ResourceManager.beforeUdpCreate();
 this.family = Net.isIPv6Available()
 ? StandardProtocolFamily.INET6
 : StandardProtocolFamily.INET;
 this.fd = fd;
 this.fdVal = IOUtil.fdVal(fd);
-this.cleaner = CleanerFactory.cleaner().register(this, closerFor(fd));
+Runnable releaser = releaserFor(fd, socketAddress);
+this.cleaner = CleanerFactory.cleaner().register(this, releaser);
 synchronized (stateLock) {
 this.localAddress = Net.localAddress(fd);
 }
 }
 // remove hook for Thread.interrupt
 end(completed);
 }
 }
-private SocketAddress sender;       // Set by receive0 (## ugh)
 @Override
 public SocketAddress receive(ByteBuffer dst) throws IOException {
 if (dst.isReadOnly())
 throw new IllegalArgumentException("Read-only buffer");
 readLock.lock();
 try {
 boolean blocking = isBlocking();
-boolean completed = false;
+SocketAddress sender = null;
-int n = 0;
 try {
 SocketAddress remote = beginRead(blocking, false);
 boolean connected = (remote != null);
 SecurityManager sm = System.getSecurityManager();
 if (connected || (sm == null)) {
 // connected or no security manager
-n = receive(dst, connected);
+int n = receive(dst, connected);
 if (blocking) {
 while (IOStatus.okayToRetry(n) && isOpen()) {
 park(Net.POLLIN);
 n = receive(dst, connected);
 }
 }
+if (n >= 0) {
+// sender address is in socket address buffer
+sender = socketAddress.toInetSocketAddress();
+}
 } else {
 // security manager and unconnected
-n = untrustedReceive(dst);
+sender = untrustedReceive(dst);
 }
-if (n == IOStatus.UNAVAILABLE)
-return null;
-completed = (n > 0) || (n == 0 && isOpen());
 return sender;
 } finally {
-endRead(blocking, completed);
+endRead(blocking, (sender != null));
-assert IOStatus.check(n);
 }
 } finally {
 readLock.unlock();
 }
 }
 * Receives a datagram into an untrusted buffer. When there is a security
 * manager set, and the socket is not connected, datagrams have to be received
 * into a buffer that is not accessible to the user. The datagram is copied
 * into the user's buffer when the sender address is accepted by the security
 * manager.
-*
+*/
-* @return the size of the datagram or IOStatus.UNAVAILABLE
+private SocketAddress untrustedReceive(ByteBuffer dst) throws IOException {
-*/
-private int untrustedReceive(ByteBuffer dst) throws IOException {
 SecurityManager sm = System.getSecurityManager();
 assert readLock.isHeldByCurrentThread()
 && sm != null && remoteAddress == null;
 ByteBuffer bb = Util.getTemporaryDirectBuffer(dst.remaining());
 if (blocking) {
 while (IOStatus.okayToRetry(n) && isOpen()) {
 park(Net.POLLIN);
 n = receive(bb, false);
 }
-} else if (n == IOStatus.UNAVAILABLE) {
+}
-return n;
+if (n >= 0) {
-}
+// sender address is in socket address buffer
-InetSocketAddress isa = (InetSocketAddress) sender;
+InetSocketAddress isa = socketAddress.toInetSocketAddress();
 try {
 sm.checkAccept(isa.getAddress().getHostAddress(), isa.getPort());
 bb.flip();
 dst.put(bb);
-return n;
+return isa;
 } catch (SecurityException se) {
 // ignore datagram
 bb.clear();
+}
+} else {
+return null;
 }
 }
 } finally {
 Util.releaseTemporaryDirectBuffer(bb);
 }
 */
 private SocketAddress trustedBlockingReceive(ByteBuffer dst)
 throws IOException
 {
 assert readLock.isHeldByCurrentThread() && isBlocking();
-boolean completed = false;
+SocketAddress sender = null;
-int n = 0;
 try {
 SocketAddress remote = beginRead(true, false);
 boolean connected = (remote != null);
-n = receive(dst, connected);
+int n = receive(dst, connected);
-while (n == IOStatus.UNAVAILABLE && isOpen()) {
+while (IOStatus.okayToRetry(n) && isOpen()) {
 park(Net.POLLIN);
 n = receive(dst, connected);
 }
-completed = (n > 0) || (n == 0 && isOpen());
+if (n >= 0) {
+// sender address is in socket address buffer
+sender = socketAddress.toInetSocketAddress();
+}
 return sender;
 } finally {
-endRead(true, completed);
+endRead(true, (sender != null));
-assert IOStatus.check(n);
 }
 }
 /**
 * Receives a datagram into given buffer with a timeout. This method is
 */
 private SocketAddress trustedBlockingReceive(ByteBuffer dst, long nanos)
 throws IOException
 {
 assert readLock.isHeldByCurrentThread() && isBlocking();
-boolean completed = false;
+SocketAddress sender = null;
-int n = 0;
 try {
 SocketAddress remote = beginRead(true, false);
 boolean connected = (remote != null);
 // change socket to non-blocking
 lockedConfigureBlocking(false);
 try {
 long startNanos = System.nanoTime();
-n = receive(dst, connected);
+int n = receive(dst, connected);
 while (n == IOStatus.UNAVAILABLE && isOpen()) {
 long remainingNanos = nanos - (System.nanoTime() - startNanos);
 if (remainingNanos <= 0) {
 throw new SocketTimeoutException("Receive timed out");
 }
 park(Net.POLLIN, remainingNanos);
 n = receive(dst, connected);
 }
-completed = (n > 0) || (n == 0 && isOpen());
+if (n >= 0) {
+// sender address is in socket address buffer
+sender = socketAddress.toInetSocketAddress();
+}
 return sender;
 } finally {
 // restore socket to blocking mode (if channel is open)
 tryLockedConfigureBlocking(true);
 }
 } finally {
-endRead(true, completed);
+endRead(true, (sender != null));
-assert IOStatus.check(n);
 }
 }
 private int receive(ByteBuffer dst, boolean connected) throws IOException {
 int pos = dst.position();
 private int receiveIntoNativeBuffer(ByteBuffer bb, int rem, int pos,
 boolean connected)
 throws IOException
 {
-int n = receive0(fd, ((DirectBuffer)bb).address() + pos, rem, connected);
+int n = receive0(fd,
+((DirectBuffer)bb).address() + pos, rem,
+socketAddress.address(),
+connected);
 if (n > 0)
 bb.position(pos + n);
 return n;
 }
 public int getFDVal() {
 return fdVal;
 }
 /**
-* Returns an action to close the given file descriptor.
+* Returns an action to release a the given file descriptor and free the
-*/
+* given native socket address.
-private static Runnable closerFor(FileDescriptor fd) {
+*/
+private static Runnable releaserFor(FileDescriptor fd, NativeSocketAddress sa) {
 return () -> {
 try {
 nd.close(fd);
 } catch (IOException ioe) {
 throw new UncheckedIOException(ioe);
 } finally {
-// decrement
+// decrement socket count and release memory
 ResourceManager.afterUdpClose();
+sa.free();
 }
 };
 }
 // -- Native methods --
-private static native void initIDs();
 private static native void disconnect0(FileDescriptor fd, boolean isIPv6)
 throws IOException;
-private native int receive0(FileDescriptor fd, long address, int len,
+private static native int receive0(FileDescriptor fd, long address, int len,
-boolean connected)
+long senderAddress, boolean connected)
 throws IOException;
-private native int send0(boolean preferIPv6, FileDescriptor fd, long address,
+private static native int send0(boolean preferIPv6, FileDescriptor fd,
-int len, InetAddress addr, int port)
+long address, int len, InetAddress addr, int port)
 throws IOException;
 static {
 IOUtil.load();
-initIDs();
 }
 }

changeset 59329	289000934908
parent 59146	455612b3161a