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

equal deleted inserted replaced

-:4070cecdb99d
+:29d6145d1097
 import java.io.IOException;
 import java.net.*;
 import java.nio.ByteBuffer;
 import java.nio.channels.*;
 import java.nio.channels.spi.*;
+import java.util.*;
 /**
 * An implementation of SocketChannels
 */
 private static final int ST_KILLPENDING = 3;
 private static final int ST_KILLED = 4;
 private int state = ST_UNINITIALIZED;
 // Binding
-private SocketAddress localAddress = null;
+private SocketAddress localAddress;
-private SocketAddress remoteAddress = null;
+private SocketAddress remoteAddress;
 // Input/Output open
 private boolean isInputOpen = true;
 private boolean isOutputOpen = true;
 private boolean readyToConnect = false;
-// Options, created on demand
-private SocketOpts.IP.TCP options = null;
 // Socket adaptor, created on demand
-private Socket socket = null;
+private Socket socket;
 // -- End of fields protected by stateLock
 // Constructor for normal connecting sockets
 {
 super(sp);
 this.fd = fd;
 this.fdVal = IOUtil.fdVal(fd);
 this.state = ST_CONNECTED;
+this.localAddress = Net.localAddress(fd);
 this.remoteAddress = remote;
 }
 public Socket socket() {
 synchronized (stateLock) {
 if (socket == null)
 socket = SocketAdaptor.create(this);
 return socket;
 }
+}
+@Override
+public SocketAddress getLocalAddress() throws IOException {
+synchronized (stateLock) {
+if (!isOpen())
+return null;
+return localAddress;
+}
+}
+@Override
+public SocketAddress getConnectedAddress() throws IOException {
+synchronized (stateLock) {
+if (!isOpen())
+return null;
+return remoteAddress;
+}
+}
+@Override
+public SocketChannel setOption(SocketOption name, Object value)
+throws IOException
+{
+if (name == null)
+throw new NullPointerException();
+if (!options().contains(name))
+throw new IllegalArgumentException("Invalid option name");
+synchronized (stateLock) {
+if (!isOpen())
+throw new ClosedChannelException();
+// special handling for IP_TOS: no-op when IPv6
+if (name == StandardSocketOption.IP_TOS) {
+if (!Net.isIPv6Available())
+Net.setSocketOption(fd, StandardProtocolFamily.INET, name, value);
+return this;
+}
+// no options that require special handling
+Net.setSocketOption(fd, Net.UNSPEC, name, value);
+return this;
+}
+}
+@Override
+@SuppressWarnings("unchecked")
+public <T> T getOption(SocketOption<T> name)
+throws IOException
+{
+if (name == null)
+throw new NullPointerException();
+if (!options().contains(name))
+throw new IllegalArgumentException("Invalid option name");
+synchronized (stateLock) {
+if (!isOpen())
+throw new ClosedChannelException();
+// special handling for IP_TOS: always return 0 when IPv6
+if (name == StandardSocketOption.IP_TOS) {
+return (Net.isIPv6Available()) ? (T) Integer.valueOf(0) :
+(T) Net.getSocketOption(fd, StandardProtocolFamily.INET, name);
+}
+// no options that require special handling
+return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
+}
+}
+private static class LazyInitialization {
+static final Set<SocketOption<?>> defaultOptions = defaultOptions();
+private static Set<SocketOption<?>> defaultOptions() {
+HashSet<SocketOption<?>> set = new HashSet<SocketOption<?>>(8);
+set.add(StandardSocketOption.SO_SNDBUF);
+set.add(StandardSocketOption.SO_RCVBUF);
+set.add(StandardSocketOption.SO_KEEPALIVE);
+set.add(StandardSocketOption.SO_REUSEADDR);
+set.add(StandardSocketOption.SO_LINGER);
+set.add(StandardSocketOption.TCP_NODELAY);
+// additional options required by socket adaptor
+set.add(StandardSocketOption.IP_TOS);
+set.add(ExtendedSocketOption.SO_OOBINLINE);
+return Collections.unmodifiableSet(set);
+}
+}
+@Override
+public final Set<SocketOption<?>> options() {
+return LazyInitialization.defaultOptions;
 }
 private boolean ensureReadOpen() throws ClosedChannelException {
 synchronized (stateLock) {
 if (!isOpen())
 protected void implConfigureBlocking(boolean block) throws IOException {
 IOUtil.configureBlocking(fd, block);
 }
-public SocketOpts options() {
-synchronized (stateLock) {
-if (options == null) {
-SocketOptsImpl.Dispatcher d
-= new SocketOptsImpl.Dispatcher() {
-int getInt(int opt) throws IOException {
-return Net.getIntOption(fd, opt);
-}
-void setInt(int opt, int arg)
-throws IOException
-{
-Net.setIntOption(fd, opt, arg);
-}
-};
-options = new SocketOptsImpl.IP.TCP(d);
-}
-return options;
-}
-}
-public boolean isBound() {
-synchronized (stateLock) {
-if (state == ST_CONNECTED)
-return true;
-return localAddress != null;
-}
-}
 public SocketAddress localAddress() {
 synchronized (stateLock) {
-if (state == ST_CONNECTED &&
-(localAddress == null ||
-((InetSocketAddress)localAddress).getAddress().isAnyLocalAddress())) {
-// Socket was not bound before connecting or
-// Socket was bound with an "anyLocalAddress"
-localAddress = Net.localAddress(fd);
-}
 return localAddress;
 }
 }
 public SocketAddress remoteAddress() {
 synchronized (stateLock) {
 return remoteAddress;
 }
 }
-public void bind(SocketAddress local) throws IOException {
+@Override
+public SocketChannel bind(SocketAddress local) throws IOException {
 synchronized (readLock) {
 synchronized (writeLock) {
 synchronized (stateLock) {
-ensureOpenAndUnconnected();
+if (!isOpen())
+throw new ClosedChannelException();
+if (state == ST_PENDING)
+throw new ConnectionPendingException();
 if (localAddress != null)
 throw new AlreadyBoundException();
-InetSocketAddress isa = Net.checkAddress(local);
+InetSocketAddress isa = (local == null) ?
+new InetSocketAddress(0) : Net.checkAddress(local);
 Net.bind(fd, isa.getAddress(), isa.getPort());
 localAddress = Net.localAddress(fd);
 }
 }
 }
+return this;
 }
 public boolean isConnected() {
 synchronized (stateLock) {
 return (state == ST_CONNECTED);
 throw new ConnectionPendingException();
 }
 }
 public boolean connect(SocketAddress sa) throws IOException {
-int trafficClass = 0;           // ## Pick up from options
 int localPort = 0;
 synchronized (readLock) {
 synchronized (writeLock) {
 ensureOpenAndUnconnected();
 InetAddress ia = isa.getAddress();
 if (ia.isAnyLocalAddress())
 ia = InetAddress.getLocalHost();
 n = Net.connect(fd,
 ia,
-isa.getPort(),
+isa.getPort());
-trafficClass);
 if (  (n == IOStatus.INTERRUPTED)
 && isOpen())
 continue;
 break;
 }
+synchronized (stateLock) {
+if (isOpen() && (localAddress == null) ||
+((InetSocketAddress)localAddress)
+.getAddress().isAnyLocalAddress())
+{
+// Socket was not bound before connecting or
+// Socket was bound with an "anyLocalAddress"
+localAddress = Net.localAddress(fd);
+}
+}
 } finally {
 readerCleanup();
 end((n > 0) || (n == IOStatus.UNAVAILABLE));
 assert IOStatus.check(n);
 }
 return false;
 }
 }
 }
-public final static int SHUT_RD = 0;
+@Override
-public final static int SHUT_WR = 1;
+public SocketChannel shutdownInput() throws IOException {
-public final static int SHUT_RDWR = 2;
-public void shutdownInput() throws IOException {
 synchronized (stateLock) {
 if (!isOpen())
 throw new ClosedChannelException();
-isInputOpen = false;
+if (!isConnected())
-shutdown(fd, SHUT_RD);
+throw new NotYetConnectedException();
-if (readerThread != 0)
+if (isInputOpen) {
-NativeThread.signal(readerThread);
+Net.shutdown(fd, Net.SHUT_RD);
-}
+if (readerThread != 0)
-}
+NativeThread.signal(readerThread);
+isInputOpen = false;
-public void shutdownOutput() throws IOException {
+}
+return this;
+}
+}
+@Override
+public SocketChannel shutdownOutput() throws IOException {
 synchronized (stateLock) {
 if (!isOpen())
 throw new ClosedChannelException();
-isOutputOpen = false;
+if (!isConnected())
-shutdown(fd, SHUT_WR);
+throw new NotYetConnectedException();
-if (writerThread != 0)
+if (isOutputOpen) {
-NativeThread.signal(writerThread);
+Net.shutdown(fd, Net.SHUT_WR);
+if (writerThread != 0)
+NativeThread.signal(writerThread);
+isOutputOpen = false;
+}
+return this;
 }
 }
 public boolean isInputOpen() {
 synchronized (stateLock) {
 private static native int checkConnect(FileDescriptor fd,
 boolean block, boolean ready)
 throws IOException;
-private static native void shutdown(FileDescriptor fd, int how)
-throws IOException;
 static {
 Util.load();
 nd = new SocketDispatcher();
 }

changeset 1152	29d6145d1097
parent 2	90ce3da70b43
child 1247	b4c26443dee5