zoukankan      html  css  js  c++  java
  • java.net.Socket

    java.net.Socket

     * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
    
    package java.net;
    
    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     java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
     * @see     java.net.SocketImpl
     * @see     java.nio.channels.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 java.net.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 java.net.ProxySelector
         * @see java.net.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();
            if (type == Proxy.Type.SOCKS || type == Proxy.Type.HTTP) {
                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());
                }
                impl = type == Proxy.Type.SOCKS ? new SocksSocketImpl(p)
                                                : new HttpConnectSocketImpl(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 java.net.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        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
         * @see        java.net.SocketImpl
         * @see        java.net.SocketImplFactory#createSocketImpl()
         * @see        SecurityManager#checkConnect
         */
        public Socket(String host, int port)
            throws UnknownHostException, IOException
        {
            this(host != null ? new InetSocketAddress(host, port) :
                 new InetSocketAddress(InetAddress.getByName(null), 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        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
         * @see        java.net.SocketImpl
         * @see        java.net.SocketImplFactory#createSocketImpl()
         * @see        SecurityManager#checkConnect
         */
        public Socket(InetAddress address, int port) throws IOException {
            this(address != null ? new InetSocketAddress(address, port) : null,
                 (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 java.net.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 {
            this(host != null ? new InetSocketAddress(host, port) :
                   new InetSocketAddress(InetAddress.getByName(null), 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 java.net.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 {
            this(address != null ? new InetSocketAddress(address, port) : null,
                 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 java.net.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        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
         * @see        java.net.SocketImpl
         * @see        java.net.SocketImplFactory#createSocketImpl()
         * @see        SecurityManager#checkConnect
         * @deprecated Use DatagramSocket instead for UDP transport.
         */
        @Deprecated
        public Socket(String host, int port, boolean stream) throws IOException {
            this(host != null ? new InetSocketAddress(host, port) :
                   new InetSocketAddress(InetAddress.getByName(null), 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        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
         * @see        java.net.SocketImpl
         * @see        java.net.SocketImplFactory#createSocketImpl()
         * @see        SecurityManager#checkConnect
         * @deprecated Use DatagramSocket instead for UDP transport.
         */
        @Deprecated
        public Socket(InetAddress host, int port, boolean stream) throws IOException {
            this(host != null ? new InetSocketAddress(host, port) : null,
                 new InetSocketAddress(0), stream);
        }
    
        private Socket(SocketAddress address, SocketAddress localAddr,
                       boolean stream) throws IOException {
            setImpl();
    
            // backward compatibility
            if (address == null)
                throw new NullPointerException();
    
            try {
                createImpl(stream);
                if (localAddr != null)
                    bind(localAddr);
                connect(address);
            } catch (IOException | IllegalArgumentException | SecurityException e) {
                try {
                    close();
                } catch (IOException ce) {
                    e.addSuppressed(ce);
                }
                throw e;
            }
        }
    
        /**
         * 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(java.net.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 java.nio.channels.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 java.nio.channels.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 java.io.InputStream#read read}.
         *
         *   <li><p>If there are no bytes buffered on the socket, or all
         *   buffered bytes have been consumed by
         *   {@link java.io.InputStream#read read}, then all subsequent
         *   calls to {@link java.io.InputStream#read read} will throw an
         *   {@link java.io.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 java.io.InputStream#available available} will
         *   return {@code 0}.
         *
         * </ul>
         *
         * <p> Closing the returned {@link java.io.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 java.io.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  {
            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 {
            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 java.io.InputStream InputStream} and
         * {@link java.io.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 java.net.Socket#shutdownOutput()
         * @see java.net.Socket#close()
         * @see java.net.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 java.net.Socket#shutdownInput()
         * @see java.net.Socket#close()
         * @see java.net.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 {
                if (isConnected())
                    return "Socket[addr=" + 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        java.net.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 */
        }
    }
    QQ 3087438119
  • 相关阅读:
    (四)使用SecureCRTPortable 连接虚拟机 安装jdk
    (三)配置本地YUM源
    (二) 配置 centos6.7
    docker学习
    linux磁盘情况查看处理
    日志文件切割
    已有项目创建git
    微擎绑定开放平台后依然拿不到唯一id?
    php7 安装mongodb扩展
    mongodb 学习
  • 原文地址:https://www.cnblogs.com/herd/p/13874593.html
Copyright © 2011-2022 走看看