content: /*
   * Copyright (C) 2014 The Android Open Source Project
   * Copyright (c) 1995, 2013, 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.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * 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.
   */
  
  package java.net;
  
  import java.io.FileDescriptor;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.IOException;
  import java.nio.channels.SocketChannel;
  import java.security.AccessController;
  import java.security.PrivilegedExceptionAction;
  import java.security.PrivilegedAction;
  
  /**
   * This class implements client sockets (also called just
   * "sockets"). A socket is an endpoint for communication
   * between two machines.
   * <p>
   * The actual work of the socket is performed by an instance of the
   * {@code SocketImpl} class. An application, by changing
   * the socket factory that creates the socket implementation,
   * can configure itself to create sockets appropriate to the local
   * firewall.
   *
   * @author  unascribed
   * @see     Socket#setSocketImplFactory(SocketImplFactory)
   * @see     SocketImpl
   * @see     SocketChannel
   * @since   JDK1.0
   */
  public
  class Socket implements java.io.Closeable {
      /**
       * Various states of this socket.
       */
      private boolean created = false;
      private boolean bound = false;
      private boolean connected = false;
      private boolean closed = false;
      private Object closeLock = new Object();
      private boolean shutIn = false;
      private boolean shutOut = false;
  
      /**
       * The implementation of this Socket.
       */
      SocketImpl impl;
  
      /**
       * Are we using an older SocketImpl?
       */
      private boolean oldImpl = false;
  
      /**
       * Creates an unconnected socket, with the
       * system-default type of SocketImpl.
       *
       * @since   JDK1.1
       * @revised 1.4
       */
      public Socket() {
          setImpl();
      }
  
      /**
       * Creates an unconnected socket, specifying the type of proxy, if any,
       * that should be used regardless of any other settings.
       * <P>
       * If there is a security manager, its {@code checkConnect} method
       * is called with the proxy host address and port number
       * as its arguments. This could result in a SecurityException.
       * <P>
       * Examples:
       * <UL> <LI>{@code Socket s = new Socket(Proxy.NO_PROXY);} will create
       * a plain socket ignoring any other proxy configuration.</LI>
       * <LI>{@code Socket s = new Socket(new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("socks.mydom.com", 1080)));}
       * will create a socket connecting through the specified SOCKS proxy
       * server.</LI>
       * </UL>
       *
       * @param proxy a {@link Proxy Proxy} object specifying what kind
       *              of proxying should be used.
       * @throws IllegalArgumentException if the proxy is of an invalid type
       *          or {@code null}.
       * @throws SecurityException if a security manager is present and
       *                           permission to connect to the proxy is
       *                           denied.
       * @see ProxySelector
       * @see Proxy
       *
       * @since   1.5
       */
      public Socket(Proxy proxy) {
          // Create a copy of Proxy as a security measure
          if (proxy == null) {
              throw new IllegalArgumentException("Invalid Proxy");
          }
          Proxy p = proxy == Proxy.NO_PROXY ? Proxy.NO_PROXY
                                            : sun.net.ApplicationProxy.create(proxy);
          Proxy.Type type = p.type();
          // Android-changed: Removed HTTP proxy support.
          // if (type == Proxy.Type.SOCKS || type == Proxy.Type.HTTP) {
          if (type == Proxy.Type.SOCKS) {
              SecurityManager security = System.getSecurityManager();
              InetSocketAddress epoint = (InetSocketAddress) p.address();
              if (epoint.getAddress() != null) {
                  checkAddress (epoint.getAddress(), "Socket");
              }
              if (security != null) {
                  if (epoint.isUnresolved())
                      epoint = new InetSocketAddress(epoint.getHostName(), epoint.getPort());
                  if (epoint.isUnresolved())
                      security.checkConnect(epoint.getHostName(), epoint.getPort());
                  else
                      security.checkConnect(epoint.getAddress().getHostAddress(),
                                    epoint.getPort());
              }
              // Android-changed: Removed HTTP proxy support.
              // impl = type == Proxy.Type.SOCKS ? new SocksSocketImpl(p)
              //                                : new HttpConnectSocketImpl(p);
              impl = new SocksSocketImpl(p);
              impl.setSocket(this);
          } else {
              if (p == Proxy.NO_PROXY) {
                  if (factory == null) {
                      impl = new PlainSocketImpl();
                      impl.setSocket(this);
                  } else
                      setImpl();
              } else
                  throw new IllegalArgumentException("Invalid Proxy");
          }
      }
  
      /**
       * Creates an unconnected Socket with a user-specified
       * SocketImpl.
       * <P>
       * @param impl an instance of a <B>SocketImpl</B>
       * the subclass wishes to use on the Socket.
       *
       * @exception SocketException if there is an error in the underlying protocol,
       * such as a TCP error.
       * @since   JDK1.1
       */
      protected Socket(SocketImpl impl) throws SocketException {
          this.impl = impl;
          if (impl != null) {
              checkOldImpl();
              this.impl.setSocket(this);
          }
      }
  
      /**
       * Creates a stream socket and connects it to the specified port
       * number on the named host.
       * <p>
       * If the specified host is {@code null} it is the equivalent of
       * specifying the address as
       * {@link InetAddress#getByName InetAddress.getByName}{@code (null)}.
       * In other words, it is equivalent to specifying an address of the
       * loopback interface. </p>
       * <p>
       * If the application has specified a server socket factory, that
       * factory's {@code createSocketImpl} method is called to create
       * the actual socket implementation. Otherwise a "plain" socket is created.
       * <p>
       * If there is a security manager, its
       * {@code checkConnect} method is called
       * with the host address and {@code port}
       * as its arguments. This could result in a SecurityException.
       *
       * @param      host   the host name, or {@code null} for the loopback address.
       * @param      port   the port number.
       *
       * @exception  UnknownHostException if the IP address of
       * the host could not be determined.
       *
       * @exception  IOException  if an I/O error occurs when creating the socket.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkConnect} method doesn't allow the operation.
       * @exception  IllegalArgumentException if the port parameter is outside
       *             the specified range of valid port values, which is between
       *             0 and 65535, inclusive.
       * @see        Socket#setSocketImplFactory(SocketImplFactory)
       * @see        SocketImpl
       * @see        SocketImplFactory#createSocketImpl()
       * @see        SecurityManager#checkConnect
       */
      public Socket(String host, int port)
          throws UnknownHostException, IOException
      {
          // Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
          this(InetAddress.getAllByName(host), port, (SocketAddress) null, true);
      }
  
      /**
       * Creates a stream socket and connects it to the specified port
       * number at the specified IP address.
       * <p>
       * If the application has specified a socket factory, that factory's
       * {@code createSocketImpl} method is called to create the
       * actual socket implementation. Otherwise a "plain" socket is created.
       * <p>
       * If there is a security manager, its
       * {@code checkConnect} method is called
       * with the host address and {@code port}
       * as its arguments. This could result in a SecurityException.
       *
       * @param      address   the IP address.
       * @param      port      the port number.
       * @exception  IOException  if an I/O error occurs when creating the socket.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkConnect} method doesn't allow the operation.
       * @exception  IllegalArgumentException if the port parameter is outside
       *             the specified range of valid port values, which is between
       *             0 and 65535, inclusive.
       * @exception  NullPointerException if {@code address} is null.
       * @see        Socket#setSocketImplFactory(SocketImplFactory)
       * @see        SocketImpl
       * @see        SocketImplFactory#createSocketImpl()
       * @see        SecurityManager#checkConnect
       */
      public Socket(InetAddress address, int port) throws IOException {
          // Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
          this(nonNullAddress(address), port, (SocketAddress) null, true);
      }
  
      /**
       * Creates a socket and connects it to the specified remote host on
       * the specified remote port. The Socket will also bind() to the local
       * address and port supplied.
       * <p>
       * If the specified host is {@code null} it is the equivalent of
       * specifying the address as
       * {@link InetAddress#getByName InetAddress.getByName}{@code (null)}.
       * In other words, it is equivalent to specifying an address of the
       * loopback interface. </p>
       * <p>
       * A local port number of {@code zero} will let the system pick up a
       * free port in the {@code bind} operation.</p>
       * <p>
       * If there is a security manager, its
       * {@code checkConnect} method is called
       * with the host address and {@code port}
       * as its arguments. This could result in a SecurityException.
       *
       * @param host the name of the remote host, or {@code null} for the loopback address.
       * @param port the remote port
       * @param localAddr the local address the socket is bound to, or
       *        {@code null} for the {@code anyLocal} address.
       * @param localPort the local port the socket is bound to, or
       *        {@code zero} for a system selected free port.
       * @exception  IOException  if an I/O error occurs when creating the socket.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkConnect} method doesn't allow the connection
       *             to the destination, or if its {@code checkListen} method
       *             doesn't allow the bind to the local port.
       * @exception  IllegalArgumentException if the port parameter or localPort
       *             parameter is outside the specified range of valid port values,
       *             which is between 0 and 65535, inclusive.
       * @see        SecurityManager#checkConnect
       * @since   JDK1.1
       */
      public Socket(String host, int port, InetAddress localAddr,
                    int localPort) throws IOException {
          // Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
          this(InetAddress.getAllByName(host), port,
               new InetSocketAddress(localAddr, localPort), true);
      }
  
      /**
       * Creates a socket and connects it to the specified remote address on
       * the specified remote port. The Socket will also bind() to the local
       * address and port supplied.
       * <p>
       * If the specified local address is {@code null} it is the equivalent of
       * specifying the address as the AnyLocal address
       * (see {@link InetAddress#isAnyLocalAddress InetAddress.isAnyLocalAddress}{@code ()}).
       * <p>
       * A local port number of {@code zero} will let the system pick up a
       * free port in the {@code bind} operation.</p>
       * <p>
       * If there is a security manager, its
       * {@code checkConnect} method is called
       * with the host address and {@code port}
       * as its arguments. This could result in a SecurityException.
       *
       * @param address the remote address
       * @param port the remote port
       * @param localAddr the local address the socket is bound to, or
       *        {@code null} for the {@code anyLocal} address.
       * @param localPort the local port the socket is bound to or
       *        {@code zero} for a system selected free port.
       * @exception  IOException  if an I/O error occurs when creating the socket.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkConnect} method doesn't allow the connection
       *             to the destination, or if its {@code checkListen} method
       *             doesn't allow the bind to the local port.
       * @exception  IllegalArgumentException if the port parameter or localPort
       *             parameter is outside the specified range of valid port values,
       *             which is between 0 and 65535, inclusive.
       * @exception  NullPointerException if {@code address} is null.
       * @see        SecurityManager#checkConnect
       * @since   JDK1.1
       */
      public Socket(InetAddress address, int port, InetAddress localAddr,
                    int localPort) throws IOException {
          // Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
          this(nonNullAddress(address), port,
               new InetSocketAddress(localAddr, localPort), true);
      }
  
      /**
       * Creates a stream socket and connects it to the specified port
       * number on the named host.
       * <p>
       * If the specified host is {@code null} it is the equivalent of
       * specifying the address as
       * {@link InetAddress#getByName InetAddress.getByName}{@code (null)}.
       * In other words, it is equivalent to specifying an address of the
       * loopback interface. </p>
       * <p>
       * If the stream argument is {@code true}, this creates a
       * stream socket. If the stream argument is {@code false}, it
       * creates a datagram socket.
       * <p>
       * If the application has specified a server socket factory, that
       * factory's {@code createSocketImpl} method is called to create
       * the actual socket implementation. Otherwise a "plain" socket is created.
       * <p>
       * If there is a security manager, its
       * {@code checkConnect} method is called
       * with the host address and {@code port}
       * as its arguments. This could result in a SecurityException.
       * <p>
       * If a UDP socket is used, TCP/IP related socket options will not apply.
       *
       * @param      host     the host name, or {@code null} for the loopback address.
       * @param      port     the port number.
       * @param      stream   a {@code boolean} indicating whether this is
       *                      a stream socket or a datagram socket.
       * @exception  IOException  if an I/O error occurs when creating the socket.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkConnect} method doesn't allow the operation.
       * @exception  IllegalArgumentException if the port parameter is outside
       *             the specified range of valid port values, which is between
       *             0 and 65535, inclusive.
       * @see        Socket#setSocketImplFactory(SocketImplFactory)
       * @see        SocketImpl
       * @see        SocketImplFactory#createSocketImpl()
       * @see        SecurityManager#checkConnect
       * @deprecated Use DatagramSocket instead for UDP transport.
       */
      @Deprecated
      public Socket(String host, int port, boolean stream) throws IOException {
          // Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
          this(InetAddress.getAllByName(host), port, (SocketAddress) null, stream);
      }
  
      /**
       * Creates a socket and connects it to the specified port number at
       * the specified IP address.
       * <p>
       * If the stream argument is {@code true}, this creates a
       * stream socket. If the stream argument is {@code false}, it
       * creates a datagram socket.
       * <p>
       * If the application has specified a server socket factory, that
       * factory's {@code createSocketImpl} method is called to create
       * the actual socket implementation. Otherwise a "plain" socket is created.
       *
       * <p>If there is a security manager, its
       * {@code checkConnect} method is called
       * with {@code host.getHostAddress()} and {@code port}
       * as its arguments. This could result in a SecurityException.
       * <p>
       * If UDP socket is used, TCP/IP related socket options will not apply.
       *
       * @param      host     the IP address.
       * @param      port      the port number.
       * @param      stream    if {@code true}, create a stream socket;
       *                       otherwise, create a datagram socket.
       * @exception  IOException  if an I/O error occurs when creating the socket.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkConnect} method doesn't allow the operation.
       * @exception  IllegalArgumentException if the port parameter is outside
       *             the specified range of valid port values, which is between
       *             0 and 65535, inclusive.
       * @exception  NullPointerException if {@code host} is null.
       * @see        Socket#setSocketImplFactory(SocketImplFactory)
       * @see        SocketImpl
       * @see        SocketImplFactory#createSocketImpl()
       * @see        SecurityManager#checkConnect
       * @deprecated Use DatagramSocket instead for UDP transport.
       */
      @Deprecated
      public Socket(InetAddress host, int port, boolean stream) throws IOException {
          // Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
          this(nonNullAddress(host), port, new InetSocketAddress(0), stream);
      }
  
      // BEGIN Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
      private static InetAddress[] nonNullAddress(InetAddress address) {
          // backward compatibility
          if (address == null)
              throw new NullPointerException();
  
          return new InetAddress[] { address };
      }
  
      private Socket(InetAddress[] addresses, int port, SocketAddress localAddr,
              boolean stream) throws IOException {
          if (addresses == null || addresses.length == 0) {
              throw new SocketException("Impossible: empty address list");
          }
  
          for (int i = 0; i < addresses.length; i++) {
              setImpl();
              try {
                  InetSocketAddress address = new InetSocketAddress(addresses[i], port);
                  createImpl(stream);
                  if (localAddr != null) {
                      bind(localAddr);
                  }
                  connect(address);
                  break;
              } catch (IOException | IllegalArgumentException | SecurityException e) {
                  try {
                      // Android-changed: Let ctor call impl.close() instead of overridable close().
                      // Subclasses may not expect a call to close() coming from this constructor.
                      impl.close();
                      closed = true;
                  } catch (IOException ce) {
                      e.addSuppressed(ce);
                  }
  
                  // Only stop on the last address.
                  if (i == addresses.length - 1) {
                      throw e;
                  }
              }
  
              // Discard the connection state and try again.
              impl = null;
              created = false;
              bound = false;
              closed = false;
          }
      }
      // END Android-changed: App compat. Socket ctor should try all addresses. http://b/30007735
  
      /**
       * Creates the socket implementation.
       *
       * @param stream a {@code boolean} value : {@code true} for a TCP socket,
       *               {@code false} for UDP.
       * @throws IOException if creation fails
       * @since 1.4
       */
       void createImpl(boolean stream) throws SocketException {
          if (impl == null)
              setImpl();
          try {
              impl.create(stream);
              created = true;
          } catch (IOException e) {
              throw new SocketException(e.getMessage());
          }
      }
  
      private void checkOldImpl() {
          if (impl == null)
              return;
          // SocketImpl.connect() is a protected method, therefore we need to use
          // getDeclaredMethod, therefore we need permission to access the member
  
          oldImpl = AccessController.doPrivileged
                                  (new PrivilegedAction<Boolean>() {
              public Boolean run() {
                  Class<?> clazz = impl.getClass();
                  while (true) {
                      try {
                          clazz.getDeclaredMethod("connect", SocketAddress.class, int.class);
                          return Boolean.FALSE;
                      } catch (NoSuchMethodException e) {
                          clazz = clazz.getSuperclass();
                          // java.net.SocketImpl class will always have this abstract method.
                          // If we have not found it by now in the hierarchy then it does not
                          // exist, we are an old style impl.
                          if (clazz.equals(SocketImpl.class)) {
                              return Boolean.TRUE;
                          }
                      }
                  }
              }
          });
      }
  
      /**
       * Sets impl to the system-default type of SocketImpl.
       * @since 1.4
       */
      void setImpl() {
          if (factory != null) {
              impl = factory.createSocketImpl();
              checkOldImpl();
          } else {
              // No need to do a checkOldImpl() here, we know it's an up to date
              // SocketImpl!
              impl = new SocksSocketImpl();
          }
          if (impl != null)
              impl.setSocket(this);
      }
  
  
      /**
       * Get the {@code SocketImpl} attached to this socket, creating
       * it if necessary.
       *
       * @return  the {@code SocketImpl} attached to that ServerSocket.
       * @throws SocketException if creation fails
       * @since 1.4
       */
      SocketImpl getImpl() throws SocketException {
          if (!created)
              createImpl(true);
          return impl;
      }
  
      /**
       * Connects this socket to the server.
       *
       * @param   endpoint the {@code SocketAddress}
       * @throws  IOException if an error occurs during the connection
       * @throws  java.nio.channels.IllegalBlockingModeException
       *          if this socket has an associated channel,
       *          and the channel is in non-blocking mode
       * @throws  IllegalArgumentException if endpoint is null or is a
       *          SocketAddress subclass not supported by this socket
       * @since 1.4
       * @spec JSR-51
       */
      public void connect(SocketAddress endpoint) throws IOException {
          connect(endpoint, 0);
      }
  
      /**
       * Connects this socket to the server with a specified timeout value.
       * A timeout of zero is interpreted as an infinite timeout. The connection
       * will then block until established or an error occurs.
       *
       * @param   endpoint the {@code SocketAddress}
       * @param   timeout  the timeout value to be used in milliseconds.
       * @throws  IOException if an error occurs during the connection
       * @throws  SocketTimeoutException if timeout expires before connecting
       * @throws  java.nio.channels.IllegalBlockingModeException
       *          if this socket has an associated channel,
       *          and the channel is in non-blocking mode
       * @throws  IllegalArgumentException if endpoint is null or is a
       *          SocketAddress subclass not supported by this socket
       * @since 1.4
       * @spec JSR-51
       */
      public void connect(SocketAddress endpoint, int timeout) throws IOException {
          if (endpoint == null)
              throw new IllegalArgumentException("connect: The address can't be null");
  
          if (timeout < 0)
            throw new IllegalArgumentException("connect: timeout can't be negative");
  
          if (isClosed())
              throw new SocketException("Socket is closed");
  
          if (!oldImpl && isConnected())
              throw new SocketException("already connected");
  
          if (!(endpoint instanceof InetSocketAddress))
              throw new IllegalArgumentException("Unsupported address type");
  
          InetSocketAddress epoint = (InetSocketAddress) endpoint;
          InetAddress addr = epoint.getAddress ();
          int port = epoint.getPort();
          checkAddress(addr, "connect");
  
          SecurityManager security = System.getSecurityManager();
          if (security != null) {
              if (epoint.isUnresolved())
                  security.checkConnect(epoint.getHostName(), port);
              else
                  security.checkConnect(addr.getHostAddress(), port);
          }
          if (!created)
              createImpl(true);
          if (!oldImpl)
              impl.connect(epoint, timeout);
          else if (timeout == 0) {
              if (epoint.isUnresolved())
                  impl.connect(addr.getHostName(), port);
              else
                  impl.connect(addr, port);
          } else
              throw new UnsupportedOperationException("SocketImpl.connect(addr, timeout)");
          connected = true;
          /*
           * If the socket was not bound before the connect, it is now because
           * the kernel will have picked an ephemeral port & a local address
           */
          bound = true;
      }
  
      /**
       * Binds the socket to a local address.
       * <P>
       * If the address is {@code null}, then the system will pick up
       * an ephemeral port and a valid local address to bind the socket.
       *
       * @param   bindpoint the {@code SocketAddress} to bind to
       * @throws  IOException if the bind operation fails, or if the socket
       *                     is already bound.
       * @throws  IllegalArgumentException if bindpoint is a
       *          SocketAddress subclass not supported by this socket
       * @throws  SecurityException  if a security manager exists and its
       *          {@code checkListen} method doesn't allow the bind
       *          to the local port.
       *
       * @since   1.4
       * @see #isBound
       */
      public void bind(SocketAddress bindpoint) throws IOException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (!oldImpl && isBound())
              throw new SocketException("Already bound");
  
          if (bindpoint != null && (!(bindpoint instanceof InetSocketAddress)))
              throw new IllegalArgumentException("Unsupported address type");
          InetSocketAddress epoint = (InetSocketAddress) bindpoint;
          if (epoint != null && epoint.isUnresolved())
              throw new SocketException("Unresolved address");
          if (epoint == null) {
              epoint = new InetSocketAddress(0);
          }
          InetAddress addr = epoint.getAddress();
          int port = epoint.getPort();
          checkAddress (addr, "bind");
          SecurityManager security = System.getSecurityManager();
          if (security != null) {
              security.checkListen(port);
          }
          getImpl().bind (addr, port);
          bound = true;
      }
  
      private void checkAddress (InetAddress addr, String op) {
          if (addr == null) {
              return;
          }
          if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) {
              throw new IllegalArgumentException(op + ": invalid address type");
          }
      }
  
      /**
       * set the flags after an accept() call.
       */
      final void postAccept() {
          connected = true;
          created = true;
          bound = true;
      }
  
      void setCreated() {
          created = true;
      }
  
      void setBound() {
          bound = true;
      }
  
      void setConnected() {
          connected = true;
      }
  
      /**
       * Returns the address to which the socket is connected.
       * <p>
       * If the socket was connected prior to being {@link #close closed},
       * then this method will continue to return the connected address
       * after the socket is closed.
       *
       * @return  the remote IP address to which this socket is connected,
       *          or {@code null} if the socket is not connected.
       */
      public InetAddress getInetAddress() {
          if (!isConnected())
              return null;
          try {
              return getImpl().getInetAddress();
          } catch (SocketException e) {
          }
          return null;
      }
  
      /**
       * Gets the local address to which the socket is bound.
       * <p>
       * If there is a security manager set, its {@code checkConnect} method is
       * called with the local address and {@code -1} as its arguments to see
       * if the operation is allowed. If the operation is not allowed,
       * the {@link InetAddress#getLoopbackAddress loopback} address is returned.
       *
       * @return the local address to which the socket is bound,
       *         the loopback address if denied by the security manager, or
       *         the wildcard address if the socket is closed or not bound yet.
       * @since   JDK1.1
       *
       * @see SecurityManager#checkConnect
       */
      public InetAddress getLocalAddress() {
          // This is for backward compatibility
          if (!isBound())
              return InetAddress.anyLocalAddress();
          InetAddress in = null;
          try {
              in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
              SecurityManager sm = System.getSecurityManager();
              if (sm != null)
                  sm.checkConnect(in.getHostAddress(), -1);
              if (in.isAnyLocalAddress()) {
                  in = InetAddress.anyLocalAddress();
              }
          } catch (SecurityException e) {
              in = InetAddress.getLoopbackAddress();
          } catch (Exception e) {
              in = InetAddress.anyLocalAddress(); // "0.0.0.0"
          }
          return in;
      }
  
      /**
       * Returns the remote port number to which this socket is connected.
       * <p>
       * If the socket was connected prior to being {@link #close closed},
       * then this method will continue to return the connected port number
       * after the socket is closed.
       *
       * @return  the remote port number to which this socket is connected, or
       *          0 if the socket is not connected yet.
       */
      public int getPort() {
          if (!isConnected())
              return 0;
          try {
              return getImpl().getPort();
          } catch (SocketException e) {
              // Shouldn't happen as we're connected
          }
          return -1;
      }
  
      /**
       * Returns the local port number to which this socket is bound.
       * <p>
       * If the socket was bound prior to being {@link #close closed},
       * then this method will continue to return the local port number
       * after the socket is closed.
       *
       * @return  the local port number to which this socket is bound or -1
       *          if the socket is not bound yet.
       */
      public int getLocalPort() {
          if (!isBound())
              return -1;
          try {
              return getImpl().getLocalPort();
          } catch(SocketException e) {
              // shouldn't happen as we're bound
          }
          return -1;
      }
  
      /**
       * Returns the address of the endpoint this socket is connected to, or
       * {@code null} if it is unconnected.
       * <p>
       * If the socket was connected prior to being {@link #close closed},
       * then this method will continue to return the connected address
       * after the socket is closed.
       *
  
       * @return a {@code SocketAddress} representing the remote endpoint of this
       *         socket, or {@code null} if it is not connected yet.
       * @see #getInetAddress()
       * @see #getPort()
       * @see #connect(SocketAddress, int)
       * @see #connect(SocketAddress)
       * @since 1.4
       */
      public SocketAddress getRemoteSocketAddress() {
          if (!isConnected())
              return null;
          return new InetSocketAddress(getInetAddress(), getPort());
      }
  
      /**
       * Returns the address of the endpoint this socket is bound to.
       * <p>
       * If a socket bound to an endpoint represented by an
       * {@code InetSocketAddress } is {@link #close closed},
       * then this method will continue to return an {@code InetSocketAddress}
       * after the socket is closed. In that case the returned
       * {@code InetSocketAddress}'s address is the
       * {@link InetAddress#isAnyLocalAddress wildcard} address
       * and its port is the local port that it was bound to.
       * <p>
       * If there is a security manager set, its {@code checkConnect} method is
       * called with the local address and {@code -1} as its arguments to see
       * if the operation is allowed. If the operation is not allowed,
       * a {@code SocketAddress} representing the
       * {@link InetAddress#getLoopbackAddress loopback} address and the local
       * port to which this socket is bound is returned.
       *
       * @return a {@code SocketAddress} representing the local endpoint of
       *         this socket, or a {@code SocketAddress} representing the
       *         loopback address if denied by the security manager, or
       *         {@code null} if the socket is not bound yet.
       *
       * @see #getLocalAddress()
       * @see #getLocalPort()
       * @see #bind(SocketAddress)
       * @see SecurityManager#checkConnect
       * @since 1.4
       */
  
      public SocketAddress getLocalSocketAddress() {
          if (!isBound())
              return null;
          return new InetSocketAddress(getLocalAddress(), getLocalPort());
      }
  
      /**
       * Returns the unique {@link SocketChannel SocketChannel}
       * object associated with this socket, if any.
       *
       * <p> A socket will have a channel if, and only if, the channel itself was
       * created via the {@link SocketChannel#open
       * SocketChannel.open} or {@link
       * java.nio.channels.ServerSocketChannel#accept ServerSocketChannel.accept}
       * methods.
       *
       * @return  the socket channel associated with this socket,
       *          or {@code null} if this socket was not created
       *          for a channel
       *
       * @since 1.4
       * @spec JSR-51
       */
      public SocketChannel getChannel() {
          return null;
      }
  
      /**
       * Returns an input stream for this socket.
       *
       * <p> If this socket has an associated channel then the resulting input
       * stream delegates all of its operations to the channel.  If the channel
       * is in non-blocking mode then the input stream's {@code read} operations
       * will throw an {@link java.nio.channels.IllegalBlockingModeException}.
       *
       * <p>Under abnormal conditions the underlying connection may be
       * broken by the remote host or the network software (for example
       * a connection reset in the case of TCP connections). When a
       * broken connection is detected by the network software the
       * following applies to the returned input stream :-
       *
       * <ul>
       *
       *   <li><p>The network software may discard bytes that are buffered
       *   by the socket. Bytes that aren't discarded by the network
       *   software can be read using {@link InputStream#read read}.
       *
       *   <li><p>If there are no bytes buffered on the socket, or all
       *   buffered bytes have been consumed by
       *   {@link InputStream#read read}, then all subsequent
       *   calls to {@link InputStream#read read} will throw an
       *   {@link IOException IOException}.
       *
       *   <li><p>If there are no bytes buffered on the socket, and the
       *   socket has not been closed using {@link #close close}, then
       *   {@link InputStream#available available} will
       *   return {@code 0}.
       *
       * </ul>
       *
       * <p> Closing the returned {@link InputStream InputStream}
       * will close the associated socket.
       *
       * @return     an input stream for reading bytes from this socket.
       * @exception  IOException  if an I/O error occurs when creating the
       *             input stream, the socket is closed, the socket is
       *             not connected, or the socket input has been shutdown
       *             using {@link #shutdownInput()}
       *
       * @revised 1.4
       * @spec JSR-51
       */
      public InputStream getInputStream() throws IOException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (!isConnected())
              throw new SocketException("Socket is not connected");
          if (isInputShutdown())
              throw new SocketException("Socket input is shutdown");
          final Socket s = this;
          InputStream is = null;
          try {
              is = AccessController.doPrivileged(
                  new PrivilegedExceptionAction<InputStream>() {
                      public InputStream run() throws IOException {
                          return impl.getInputStream();
                      }
                  });
          } catch (java.security.PrivilegedActionException e) {
              throw (IOException) e.getException();
          }
          return is;
      }
  
      /**
       * Returns an output stream for this socket.
       *
       * <p> If this socket has an associated channel then the resulting output
       * stream delegates all of its operations to the channel.  If the channel
       * is in non-blocking mode then the output stream's {@code write}
       * operations will throw an {@link
       * java.nio.channels.IllegalBlockingModeException}.
       *
       * <p> Closing the returned {@link OutputStream OutputStream}
       * will close the associated socket.
       *
       * @return     an output stream for writing bytes to this socket.
       * @exception  IOException  if an I/O error occurs when creating the
       *               output stream or if the socket is not connected.
       * @revised 1.4
       * @spec JSR-51
       */
      public OutputStream getOutputStream() throws IOException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (!isConnected())
              throw new SocketException("Socket is not connected");
          if (isOutputShutdown())
              throw new SocketException("Socket output is shutdown");
          final Socket s = this;
          OutputStream os = null;
          try {
              os = AccessController.doPrivileged(
                  new PrivilegedExceptionAction<OutputStream>() {
                      public OutputStream run() throws IOException {
                          return impl.getOutputStream();
                      }
                  });
          } catch (java.security.PrivilegedActionException e) {
              throw (IOException) e.getException();
          }
          return os;
      }
  
      /**
       * Enable/disable {@link SocketOptions#TCP_NODELAY TCP_NODELAY}
       * (disable/enable Nagle's algorithm).
       *
       * @param on {@code true} to enable TCP_NODELAY,
       * {@code false} to disable.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @since   JDK1.1
       *
       * @see #getTcpNoDelay()
       */
      public void setTcpNoDelay(boolean on) throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));
      }
  
      /**
       * Tests if {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled.
       *
       * @return a {@code boolean} indicating whether or not
       *         {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK1.1
       * @see #setTcpNoDelay(boolean)
       */
      public boolean getTcpNoDelay() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue();
      }
  
      /**
       * Enable/disable {@link SocketOptions#SO_LINGER SO_LINGER} with the
       * specified linger time in seconds. The maximum timeout value is platform
       * specific.
       *
       * The setting only affects socket close.
       *
       * @param on     whether or not to linger on.
       * @param linger how long to linger for, if on is true.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @exception IllegalArgumentException if the linger value is negative.
       * @since JDK1.1
       * @see #getSoLinger()
       */
      public void setSoLinger(boolean on, int linger) throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (!on) {
              getImpl().setOption(SocketOptions.SO_LINGER, new Boolean(on));
          } else {
              if (linger < 0) {
                  throw new IllegalArgumentException("invalid value for SO_LINGER");
              }
              if (linger > 65535)
                  linger = 65535;
              getImpl().setOption(SocketOptions.SO_LINGER, new Integer(linger));
          }
      }
  
      /**
       * Returns setting for {@link SocketOptions#SO_LINGER SO_LINGER}.
       * -1 returns implies that the
       * option is disabled.
       *
       * The setting only affects socket close.
       *
       * @return the setting for {@link SocketOptions#SO_LINGER SO_LINGER}.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK1.1
       * @see #setSoLinger(boolean, int)
       */
      public int getSoLinger() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          Object o = getImpl().getOption(SocketOptions.SO_LINGER);
          if (o instanceof Integer) {
              return ((Integer) o).intValue();
          } else {
              return -1;
          }
      }
  
      /**
       * Send one byte of urgent data on the socket. The byte to be sent is the lowest eight
       * bits of the data parameter. The urgent byte is
       * sent after any preceding writes to the socket OutputStream
       * and before any future writes to the OutputStream.
       * @param data The byte of data to send
       * @exception IOException if there is an error
       *  sending the data.
       * @since 1.4
       */
      public void sendUrgentData (int data) throws IOException  {
          // Android-changed: If the socket is closed, sendUrgentData should not create a new impl.
          // Fail early to avoid leaking resources.
          // http://b/31818400
          if (isClosed()) {
              throw new SocketException("Socket is closed");
          }
  
          if (!getImpl().supportsUrgentData ()) {
              throw new SocketException ("Urgent data not supported");
          }
          getImpl().sendUrgentData (data);
      }
  
      /**
       * Enable/disable {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE}
       * (receipt of TCP urgent data)
       *
       * By default, this option is disabled and TCP urgent data received on a
       * socket is silently discarded. If the user wishes to receive urgent data, then
       * this option must be enabled. When enabled, urgent data is received
       * inline with normal data.
       * <p>
       * Note, only limited support is provided for handling incoming urgent
       * data. In particular, no notification of incoming urgent data is provided
       * and there is no capability to distinguish between normal data and urgent
       * data unless provided by a higher level protocol.
       *
       * @param on {@code true} to enable
       *           {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE},
       *           {@code false} to disable.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @since   1.4
       *
       * @see #getOOBInline()
       */
      public void setOOBInline(boolean on) throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          getImpl().setOption(SocketOptions.SO_OOBINLINE, Boolean.valueOf(on));
      }
  
      /**
       * Tests if {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE} is enabled.
       *
       * @return a {@code boolean} indicating whether or not
       *         {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE}is enabled.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   1.4
       * @see #setOOBInline(boolean)
       */
      public boolean getOOBInline() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          return ((Boolean) getImpl().getOption(SocketOptions.SO_OOBINLINE)).booleanValue();
      }
  
      /**
       *  Enable/disable {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}
       *  with the specified timeout, in milliseconds. With this option set
       *  to a non-zero timeout, a read() call on the InputStream associated with
       *  this Socket will block for only this amount of time.  If the timeout
       *  expires, a <B>java.net.SocketTimeoutException</B> is raised, though the
       *  Socket is still valid. The option <B>must</B> be enabled
       *  prior to entering the blocking operation to have effect. The
       *  timeout must be {@code > 0}.
       *  A timeout of zero is interpreted as an infinite timeout.
       *
       * @param timeout the specified timeout, in milliseconds.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK 1.1
       * @see #getSoTimeout()
       */
      public synchronized void setSoTimeout(int timeout) throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (timeout < 0)
            throw new IllegalArgumentException("timeout can't be negative");
  
          getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
      }
  
      /**
       * Returns setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}.
       * 0 returns implies that the option is disabled (i.e., timeout of infinity).
       *
       * @return the setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @since   JDK1.1
       * @see #setSoTimeout(int)
       */
      public synchronized int getSoTimeout() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
          /* extra type safety */
          if (o instanceof Integer) {
              return ((Integer) o).intValue();
          } else {
              return 0;
          }
      }
  
      /**
       * Sets the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option to the
       * specified value for this {@code Socket}.
       * The {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option is used by the
       * platform's networking code as a hint for the size to set the underlying
       * network I/O buffers.
       *
       * <p>Because {@link SocketOptions#SO_SNDBUF SO_SNDBUF} is a hint,
       * applications that want to verify what size the buffers were set to
       * should call {@link #getSendBufferSize()}.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @param size the size to which to set the send buffer
       * size. This value must be greater than 0.
       *
       * @exception IllegalArgumentException if the
       * value is 0 or is negative.
       *
       * @see #getSendBufferSize()
       * @since 1.2
       */
      public synchronized void setSendBufferSize(int size)
      throws SocketException{
          if (!(size > 0)) {
              throw new IllegalArgumentException("negative send size");
          }
          if (isClosed())
              throw new SocketException("Socket is closed");
          getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
      }
  
      /**
       * Get value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option
       * for this {@code Socket}, that is the buffer size used by the platform
       * for output on this {@code Socket}.
       * @return the value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF}
       *         option for this {@code Socket}.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @see #setSendBufferSize(int)
       * @since 1.2
       */
      public synchronized int getSendBufferSize() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          int result = 0;
          Object o = getImpl().getOption(SocketOptions.SO_SNDBUF);
          if (o instanceof Integer) {
              result = ((Integer)o).intValue();
          }
          return result;
      }
  
      /**
       * Sets the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option to the
       * specified value for this {@code Socket}. The
       * {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option is
       * used by the platform's networking code as a hint for the size to set
       * the underlying network I/O buffers.
       *
       * <p>Increasing the receive buffer size can increase the performance of
       * network I/O for high-volume connection, while decreasing it can
       * help reduce the backlog of incoming data.
       *
       * <p>Because {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is a hint,
       * applications that want to verify what size the buffers were set to
       * should call {@link #getReceiveBufferSize()}.
       *
       * <p>The value of {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is also used
       * to set the TCP receive window that is advertized to the remote peer.
       * Generally, the window size can be modified at any time when a socket is
       * connected. However, if a receive window larger than 64K is required then
       * this must be requested <B>before</B> the socket is connected to the
       * remote peer. There are two cases to be aware of:
       * <ol>
       * <li>For sockets accepted from a ServerSocket, this must be done by calling
       * {@link ServerSocket#setReceiveBufferSize(int)} before the ServerSocket
       * is bound to a local address.<p></li>
       * <li>For client sockets, setReceiveBufferSize() must be called before
       * connecting the socket to its remote peer.</li></ol>
       * @param size the size to which to set the receive buffer
       * size. This value must be greater than 0.
       *
       * @exception IllegalArgumentException if the value is 0 or is
       * negative.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @see #getReceiveBufferSize()
       * @see ServerSocket#setReceiveBufferSize(int)
       * @since 1.2
       */
      public synchronized void setReceiveBufferSize(int size)
      throws SocketException{
          if (size <= 0) {
              throw new IllegalArgumentException("invalid receive size");
          }
          if (isClosed())
              throw new SocketException("Socket is closed");
          getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
      }
  
      /**
       * Gets the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option
       * for this {@code Socket}, that is the buffer size used by the platform
       * for input on this {@code Socket}.
       *
       * @return the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF}
       *         option for this {@code Socket}.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @see #setReceiveBufferSize(int)
       * @since 1.2
       */
      public synchronized int getReceiveBufferSize()
      throws SocketException{
          if (isClosed())
              throw new SocketException("Socket is closed");
          int result = 0;
          Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
          if (o instanceof Integer) {
              result = ((Integer)o).intValue();
          }
          return result;
      }
  
      /**
       * Enable/disable {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE}.
       *
       * @param on  whether or not to have socket keep alive turned on.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since 1.3
       * @see #getKeepAlive()
       */
      public void setKeepAlive(boolean on) throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          getImpl().setOption(SocketOptions.SO_KEEPALIVE, Boolean.valueOf(on));
      }
  
      /**
       * Tests if {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE} is enabled.
       *
       * @return a {@code boolean} indicating whether or not
       *         {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE} is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   1.3
       * @see #setKeepAlive(boolean)
       */
      public boolean getKeepAlive() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          return ((Boolean) getImpl().getOption(SocketOptions.SO_KEEPALIVE)).booleanValue();
      }
  
      /**
       * Sets traffic class or type-of-service octet in the IP
       * header for packets sent from this Socket.
       * As the underlying network implementation may ignore this
       * value applications should consider it a hint.
       *
       * <P> The tc <B>must</B> be in the range {@code 0 <= tc <=
       * 255} or an IllegalArgumentException will be thrown.
       * <p>Notes:
       * <p>For Internet Protocol v4 the value consists of an
       * {@code integer}, the least significant 8 bits of which
       * represent the value of the TOS octet in IP packets sent by
       * the socket.
       * RFC 1349 defines the TOS values as follows:
       *
       * <UL>
       * <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
       * <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
       * <LI><CODE>IPTOS_THROUGHPUT (0x08)</CODE></LI>
       * <LI><CODE>IPTOS_LOWDELAY (0x10)</CODE></LI>
       * </UL>
       * The last low order bit is always ignored as this
       * corresponds to the MBZ (must be zero) bit.
       * <p>
       * Setting bits in the precedence field may result in a
       * SocketException indicating that the operation is not
       * permitted.
       * <p>
       * As RFC 1122 section 4.2.4.2 indicates, a compliant TCP
       * implementation should, but is not required to, let application
       * change the TOS field during the lifetime of a connection.
       * So whether the type-of-service field can be changed after the
       * TCP connection has been established depends on the implementation
       * in the underlying platform. Applications should not assume that
       * they can change the TOS field after the connection.
       * <p>
       * For Internet Protocol v6 {@code tc} is the value that
       * would be placed into the sin6_flowinfo field of the IP header.
       *
       * @param tc        an {@code int} value for the bitset.
       * @throws SocketException if there is an error setting the
       * traffic class or type-of-service
       * @since 1.4
       * @see #getTrafficClass
       * @see SocketOptions#IP_TOS
       */
      public void setTrafficClass(int tc) throws SocketException {
          if (tc < 0 || tc > 255)
              throw new IllegalArgumentException("tc is not in range 0 -- 255");
  
          if (isClosed())
              throw new SocketException("Socket is closed");
          try {
              getImpl().setOption(SocketOptions.IP_TOS, tc);
          } catch (SocketException se) {
              // not supported if socket already connected
              // Solaris returns error in such cases
              if(!isConnected())
                  throw se;
          }
      }
  
      /**
       * Gets traffic class or type-of-service in the IP header
       * for packets sent from this Socket
       * <p>
       * As the underlying network implementation may ignore the
       * traffic class or type-of-service set using {@link #setTrafficClass(int)}
       * this method may return a different value than was previously
       * set using the {@link #setTrafficClass(int)} method on this Socket.
       *
       * @return the traffic class or type-of-service already set
       * @throws SocketException if there is an error obtaining the
       * traffic class or type-of-service value.
       * @since 1.4
       * @see #setTrafficClass(int)
       * @see SocketOptions#IP_TOS
       */
      public int getTrafficClass() throws SocketException {
          // Android-changed: throw SocketException if the socket is already closed. http://b/31818400
          if (isClosed()) {
              throw new SocketException("Socket is closed");
          }
  
          return ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue();
      }
  
      /**
       * Enable/disable the {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
       * socket option.
       * <p>
       * When a TCP connection is closed the connection may remain
       * in a timeout state for a period of time after the connection
       * is closed (typically known as the {@code TIME_WAIT} state
       * or {@code 2MSL} wait state).
       * For applications using a well known socket address or port
       * it may not be possible to bind a socket to the required
       * {@code SocketAddress} if there is a connection in the
       * timeout state involving the socket address or port.
       * <p>
       * Enabling {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
       * prior to binding the socket using {@link #bind(SocketAddress)} allows
       * the socket to be bound even though a previous connection is in a timeout
       * state.
       * <p>
       * When a {@code Socket} is created the initial setting
       * of {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is disabled.
       * <p>
       * The behaviour when {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is
       * enabled or disabled after a socket is bound (See {@link #isBound()})
       * is not defined.
       *
       * @param on  whether to enable or disable the socket option
       * @exception SocketException if an error occurs enabling or
       *            disabling the {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
       *            socket option, or the socket is closed.
       * @since 1.4
       * @see #getReuseAddress()
       * @see #bind(SocketAddress)
       * @see #isClosed()
       * @see #isBound()
       */
      public void setReuseAddress(boolean on) throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
      }
  
      /**
       * Tests if {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
       *
       * @return a {@code boolean} indicating whether or not
       *         {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   1.4
       * @see #setReuseAddress(boolean)
       */
      public boolean getReuseAddress() throws SocketException {
          if (isClosed())
              throw new SocketException("Socket is closed");
          return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
      }
  
      /**
       * Closes this socket.
       * <p>
       * Any thread currently blocked in an I/O operation upon this socket
       * will throw a {@link SocketException}.
       * <p>
       * Once a socket has been closed, it is not available for further networking
       * use (i.e. can't be reconnected or rebound). A new socket needs to be
       * created.
       *
       * <p> Closing this socket will also close the socket's
       * {@link InputStream InputStream} and
       * {@link OutputStream OutputStream}.
       *
       * <p> If this socket has an associated channel then the channel is closed
       * as well.
       *
       * @exception  IOException  if an I/O error occurs when closing this socket.
       * @revised 1.4
       * @spec JSR-51
       * @see #isClosed
       */
      public synchronized void close() throws IOException {
          synchronized(closeLock) {
              if (isClosed())
                  return;
              if (created)
                  impl.close();
              closed = true;
          }
      }
  
      /**
       * Places the input stream for this socket at "end of stream".
       * Any data sent to the input stream side of the socket is acknowledged
       * and then silently discarded.
       * <p>
       * If you read from a socket input stream after invoking this method on the
       * socket, the stream's {@code available} method will return 0, and its
       * {@code read} methods will return {@code -1} (end of stream).
       *
       * @exception IOException if an I/O error occurs when shutting down this
       * socket.
       *
       * @since 1.3
       * @see Socket#shutdownOutput()
       * @see Socket#close()
       * @see Socket#setSoLinger(boolean, int)
       * @see #isInputShutdown
       */
      public void shutdownInput() throws IOException
      {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (!isConnected())
              throw new SocketException("Socket is not connected");
          if (isInputShutdown())
              throw new SocketException("Socket input is already shutdown");
          getImpl().shutdownInput();
          shutIn = true;
      }
  
      /**
       * Disables the output stream for this socket.
       * For a TCP socket, any previously written data will be sent
       * followed by TCP's normal connection termination sequence.
       *
       * If you write to a socket output stream after invoking
       * shutdownOutput() on the socket, the stream will throw
       * an IOException.
       *
       * @exception IOException if an I/O error occurs when shutting down this
       * socket.
       *
       * @since 1.3
       * @see Socket#shutdownInput()
       * @see Socket#close()
       * @see Socket#setSoLinger(boolean, int)
       * @see #isOutputShutdown
       */
      public void shutdownOutput() throws IOException
      {
          if (isClosed())
              throw new SocketException("Socket is closed");
          if (!isConnected())
              throw new SocketException("Socket is not connected");
          if (isOutputShutdown())
              throw new SocketException("Socket output is already shutdown");
          getImpl().shutdownOutput();
          shutOut = true;
      }
  
      /**
       * Converts this socket to a {@code String}.
       *
       * @return  a string representation of this socket.
       */
      public String toString() {
          try {
              // Android-changed: change localport to localPort, and addr to address.
              if (isConnected())
                  return "Socket[address=" + getImpl().getInetAddress() +
                      ",port=" + getImpl().getPort() +
                      ",localPort=" + getImpl().getLocalPort() + "]";
          } catch (SocketException e) {
          }
          return "Socket[unconnected]";
      }
  
      /**
       * Returns the connection state of the socket.
       * <p>
       * Note: Closing a socket doesn't clear its connection state, which means
       * this method will return {@code true} for a closed socket
       * (see {@link #isClosed()}) if it was successfuly connected prior
       * to being closed.
       *
       * @return true if the socket was successfuly connected to a server
       * @since 1.4
       */
      public boolean isConnected() {
          // Before 1.3 Sockets were always connected during creation
          return connected || oldImpl;
      }
  
      /**
       * Returns the binding state of the socket.
       * <p>
       * Note: Closing a socket doesn't clear its binding state, which means
       * this method will return {@code true} for a closed socket
       * (see {@link #isClosed()}) if it was successfuly bound prior
       * to being closed.
       *
       * @return true if the socket was successfuly bound to an address
       * @since 1.4
       * @see #bind
       */
      public boolean isBound() {
          // Before 1.3 Sockets were always bound during creation
          return bound || oldImpl;
      }
  
      /**
       * Returns the closed state of the socket.
       *
       * @return true if the socket has been closed
       * @since 1.4
       * @see #close
       */
      public boolean isClosed() {
          synchronized(closeLock) {
              return closed;
          }
      }
  
      /**
       * Returns whether the read-half of the socket connection is closed.
       *
       * @return true if the input of the socket has been shutdown
       * @since 1.4
       * @see #shutdownInput
       */
      public boolean isInputShutdown() {
          return shutIn;
      }
  
      /**
       * Returns whether the write-half of the socket connection is closed.
       *
       * @return true if the output of the socket has been shutdown
       * @since 1.4
       * @see #shutdownOutput
       */
      public boolean isOutputShutdown() {
          return shutOut;
      }
  
      /**
       * The factory for all client sockets.
       */
      private static SocketImplFactory factory = null;
  
      /**
       * Sets the client socket implementation factory for the
       * application. The factory can be specified only once.
       * <p>
       * When an application creates a new client socket, the socket
       * implementation factory's {@code createSocketImpl} method is
       * called to create the actual socket implementation.
       * <p>
       * Passing {@code null} to the method is a no-op unless the factory
       * was already set.
       * <p>If there is a security manager, this method first calls
       * the security manager's {@code checkSetFactory} method
       * to ensure the operation is allowed.
       * This could result in a SecurityException.
       *
       * @param      fac   the desired factory.
       * @exception  IOException  if an I/O error occurs when setting the
       *               socket factory.
       * @exception  SocketException  if the factory is already defined.
       * @exception  SecurityException  if a security manager exists and its
       *             {@code checkSetFactory} method doesn't allow the operation.
       * @see        SocketImplFactory#createSocketImpl()
       * @see        SecurityManager#checkSetFactory
       */
      public static synchronized void setSocketImplFactory(SocketImplFactory fac)
          throws IOException
      {
          if (factory != null) {
              throw new SocketException("factory already defined");
          }
          SecurityManager security = System.getSecurityManager();
          if (security != null) {
              security.checkSetFactory();
          }
          factory = fac;
      }
  
      /**
       * Sets performance preferences for this socket.
       *
       * <p> Sockets use the TCP/IP protocol by default.  Some implementations
       * may offer alternative protocols which have different performance
       * characteristics than TCP/IP.  This method allows the application to
       * express its own preferences as to how these tradeoffs should be made
       * when the implementation chooses from the available protocols.
       *
       * <p> Performance preferences are described by three integers
       * whose values indicate the relative importance of short connection time,
       * low latency, and high bandwidth.  The absolute values of the integers
       * are irrelevant; in order to choose a protocol the values are simply
       * compared, with larger values indicating stronger preferences. Negative
       * values represent a lower priority than positive values. If the
       * application prefers short connection time over both low latency and high
       * bandwidth, for example, then it could invoke this method with the values
       * {@code (1, 0, 0)}.  If the application prefers high bandwidth above low
       * latency, and low latency above short connection time, then it could
       * invoke this method with the values {@code (0, 1, 2)}.
       *
       * <p> Invoking this method after this socket has been connected
       * will have no effect.
       *
       * @param  connectionTime
       *         An {@code int} expressing the relative importance of a short
       *         connection time
       *
       * @param  latency
       *         An {@code int} expressing the relative importance of low
       *         latency
       *
       * @param  bandwidth
       *         An {@code int} expressing the relative importance of high
       *         bandwidth
       *
       * @since 1.5
       */
      public void setPerformancePreferences(int connectionTime,
                                            int latency,
                                            int bandwidth)
      {
          /* Not implemented yet */
      }
  
      // Android-added: getFileDescriptor$() method for testing and internal use.
      /**
       * @hide internal use only
       */
      public FileDescriptor getFileDescriptor$() {
          return impl.getFileDescriptor();
      }
  }
  