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

equal deleted inserted replaced

-:c775204f9dbe
+:e613cc3bc9d4
 * blocking. If a connect, accept or read is attempted with a timeout then the
 * socket is changed to non-blocking mode. When in non-blocking mode, operations
 * that don't complete immediately will poll the socket.
 *
 * Behavior differences to examine:
-* - "Connection reset" handling differs to PlainSocketImpl for cases where
+* "Connection reset" handling differs to PlainSocketImpl for cases where
 * an application continues to call read or available after a reset.
-* - SocketInputStream extends FileInputStream so can cast to FIS and access FD.
 */
 public class NioSocketImpl extends SocketImpl {
 private static final NativeDispatcher nd = new SocketDispatcher();
 return IOStatus.EOF;
 }
 int timeout = this.timeout;
 maybeConfigureNonBlocking(fd, timeout);
 n = IOUtil.read(fd, dst, -1, nd);
-if (statusImpliesRetry(n) && isOpen()) {
+if (IOStatus.okayToRetry(n) && isOpen()) {
 if (timeout > 0) {
 // read with timeout
 assert nonBlocking;
 long nanos = NANOSECONDS.convert(timeout, TimeUnit.MILLISECONDS);
 do {
 } else {
 // read, no timeout
 do {
 park(Net.POLLIN);
 n = IOUtil.read(fd, dst, -1, nd);
-} while (statusImpliesRetry(n) && isOpen());
+} while (IOStatus.okayToRetry(n) && isOpen());
 }
 }
 return n;
 } finally {
 endRead(n > 0);
 try {
 int n = 0;
 FileDescriptor fd = beginWrite();
 try {
 n = IOUtil.write(fd, dst, -1, nd);
-while (statusImpliesRetry(n) && isOpen()) {
+while (IOStatus.okayToRetry(n) && isOpen()) {
 park(Net.POLLOUT);
 n = IOUtil.write(fd, dst, -1, nd);
 }
 return n;
 } finally {
 private FileDescriptor beginConnect(InetAddress address, int port)
 throws IOException
 {
 synchronized (stateLock) {
 int state = this.state;
-if (state >= ST_CLOSING)
+if (state != ST_UNCONNECTED) {
-throw new SocketException("Socket closed");
+if (state == ST_CONNECTING)
-if (state == ST_CONNECTED)
+throw new SocketException("Connection in progress");
-throw new SocketException("Already connected");
+if (state == ST_CONNECTED)
-assert state == ST_UNCONNECTED;
+throw new SocketException("Already connected");
+if (state >= ST_CLOSING)
+throw new SocketException("Socket closed");
+assert false;
+}
 this.state = ST_CONNECTING;
 // invoke beforeTcpConnect hook if not already bound
 if (localport == 0) {
 NetHooks.beforeTcpConnect(fd, address, port);
 InetAddress address = isa.getAddress();
 if (address.isAnyLocalAddress())
 address = InetAddress.getLocalHost();
 int port = isa.getPort();
+ReentrantLock connectLock = readLock;
 try {
-readLock.lock();
+connectLock.lock();
 try {
 boolean connected = false;
 FileDescriptor fd = beginConnect(address, port);
 try {
 maybeConfigureNonBlocking(fd, millis);
 int n = Net.connect(fd, address, port);
-if (statusImpliesRetry(n) && isOpen()) {
+if (IOStatus.okayToRetry(n) && isOpen()) {
 if (millis > 0) {
 // connect with timeout
 assert nonBlocking;
 long nanos = NANOSECONDS.convert(millis, MILLISECONDS);
 do {
 long startTime = System.nanoTime();
 park(Net.POLLOUT, nanos);
-n = Net.polConnectlNow(fd);
+n = Net.pollConnectNow(fd);
 if (n == 0) {
 nanos -= System.nanoTime() - startTime;
 if (nanos <= 0)
 throw new SocketTimeoutException("connect timeout");
 }
 } while (n == 0 && isOpen());
 } else {
 // connect, no timeout
 do {
 park(Net.POLLOUT);
-n = Net.polConnectlNow(fd);
+n = Net.pollConnectNow(fd);
-} while ((n == 0 || n == IOStatus.INTERRUPTED) && isOpen());
+} while (n == 0 && isOpen());
 }
 }
 connected = (n > 0) && isOpen();
 } finally {
 endConnect(connected);
 }
 } finally {
-readLock.unlock();
+connectLock.unlock();
 }
 } catch (IOException ioe) {
 close();
 throw SocketExceptions.of(ioe, isa);
 }
 @Override
 protected void accept(SocketImpl si) throws IOException {
 // accept a connection
 FileDescriptor newfd = new FileDescriptor();
 InetSocketAddress[] isaa = new InetSocketAddress[1];
-readLock.lock();
+ReentrantLock acceptLock = readLock;
+acceptLock.lock();
 try {
 int n = 0;
 FileDescriptor fd = beginAccept();
 try {
 int timeout = this.timeout;
 maybeConfigureNonBlocking(fd, timeout);
 n = ServerSocketChannelImpl.accept0(fd, newfd, isaa);
-if (statusImpliesRetry(n) && isOpen()) {
+if (IOStatus.okayToRetry(n) && isOpen()) {
 if (timeout > 0) {
 // accept with timeout
 assert nonBlocking;
 long nanos = NANOSECONDS.convert(timeout, TimeUnit.MILLISECONDS);
 do {
 } else {
 // accept, no timeout
 do {
 park(Net.POLLIN);
 n = ServerSocketChannelImpl.accept0(fd, newfd, isaa);
-} while (statusImpliesRetry(n) && isOpen());
+} while (IOStatus.okayToRetry(n) && isOpen());
 }
 }
 } finally {
 endAccept(n > 0);
 assert IOStatus.check(n);
 }
 } finally {
-readLock.unlock();
+acceptLock.unlock();
 }
 // get local address and configure accepted socket to blocking mode
 InetSocketAddress localAddress;
 try {
 return CLOSED.compareAndSet(this, false, true);
 }
 }
 /**
-* Returns true if the error code is UNAVAILABLE or INTERRUPTED, the
-* error codes to indicate that an I/O operation should be retried.
-*/
-private static boolean statusImpliesRetry(int n) {
-return n == IOStatus.UNAVAILABLE || n == IOStatus.INTERRUPTED;
-}
-/**
 * Returns the socket protocol family
 */
 private static ProtocolFamily family() {
 if (Net.isIPv6Available()) {
 return StandardProtocolFamily.INET6;

branch	niosocketimpl-branch
changeset 57114	e613cc3bc9d4
parent 57111	a57c4dc7e2fe
child 57124	8bb7df86576a