protected  void accept(SocketImpl s) throws IOException 
{
        acquireFD();
        try {
            socketAccept(s);
        } finally {
            releaseFD();
        }
}

Accepts connections.

 FileDescriptor acquireFD() 
{
        synchronized (fdLock) {
            fdUseCount++;
            return fd;
        }
}

 protected synchronized int available() throws IOException 
{
        if (isClosedOrPending()) {
            throw new IOException("Stream closed.");
        }
        /*
         * If connection has been reset then return 0 to indicate
         * there are no buffered bytes.
         */
        if (isConnectionReset()) {
            return 0;
        }
        /*
         * If no bytes available and we were previously notified
         * of a connection reset then we move to the reset state.
         *
         * If are notified of a connection reset then check
         * again if there are bytes buffered on the socket.
         */
        int n = 0;
        try {
            n = socketAvailable();
            if (n == 0 && isConnectionResetPending()) {
                setConnectionReset();
            }
        } catch (ConnectionResetException exc1) {
            setConnectionResetPending();
            try {
                n = socketAvailable();
                if (n == 0) {
                    setConnectionReset();
                }
            } catch (ConnectionResetException exc2) {
            }
        }
        return n;
}

Returns the number of bytes that can be read without blocking.

 protected synchronized  void bind(InetAddress address,
    int lport) throws IOException 
{
       synchronized (fdLock) {
            if (!closePending && (socket == null || !socket.isBound())) {
                NetHooks.beforeTcpBind(fd, address, lport);
            }
        }
        socketBind(address, lport);
        if (socket != null)
            socket.setBound();
        if (serverSocket != null)
            serverSocket.setBound();
}

Binds the socket to the specified address of the specified local port.

 protected  void close() throws IOException 
{
        synchronized(fdLock) {
            if (fd != null) {
                if (!stream) {
                    ResourceManager.afterUdpClose();
                }
                if (fdUseCount == 0) {
                    if (closePending) {
                        return;
                    }
                    closePending = true;
                    /*
                     * We close the FileDescriptor in two-steps - first the
                     * "pre-close" which closes the socket but doesn't
                     * release the underlying file descriptor. This operation
                     * may be lengthy due to untransmitted data and a long
                     * linger interval. Once the pre-close is done we do the
                     * actual socket to release the fd.
                     */
                    try {
                        socketPreClose();
                    } finally {
                        socketClose();
                    }
                    fd = null;
                    return;
                } else {
                    /*
                     * If a thread has acquired the fd and a close
                     * isn't pending then use a deferred close.
                     * Also decrement fdUseCount to signal the last
                     * thread that releases the fd to close it.
                     */
                    if (!closePending) {
                        closePending = true;
                        fdUseCount--;
                        socketPreClose();
                    }
                }
            }
        }
}

Closes the socket.

 protected  void connect(String host,
    int port) throws UnknownHostException, IOException 
{
        boolean connected = false;
        try {
            InetAddress address = InetAddress.getByName(host);
            this.port = port;
            this.address = address;
            connectToAddress(address, port, timeout);
            connected = true;
        } finally {
            if (!connected) {
                try {
                    close();
                } catch (IOException ioe) {
                    /* Do nothing. If connect threw an exception then
                       it will be passed up the call stack */
                }
            }
        }
}

Creates a socket and connects it to the specified port on the specified host.

 protected  void connect(InetAddress address,
    int port) throws IOException 
{
        this.port = port;
        this.address = address;
        try {
            connectToAddress(address, port, timeout);
            return;
        } catch (IOException e) {
            // everything failed
            close();
            throw e;
        }
}

Creates a socket and connects it to the specified address on the specified port.

 protected  void connect(SocketAddress address,
    int timeout) throws IOException 
{
        boolean connected = false;
        try {
            if (address == null || !(address instanceof InetSocketAddress))
                throw new IllegalArgumentException("unsupported address type");
            InetSocketAddress addr = (InetSocketAddress) address;
            if (addr.isUnresolved())
                throw new UnknownHostException(addr.getHostName());
            this.port = addr.getPort();
            this.address = addr.getAddress();
            connectToAddress(this.address, port, timeout);
            connected = true;
        } finally {
            if (!connected) {
                try {
                    close();
                } catch (IOException ioe) {
                    /* Do nothing. If connect threw an exception then
                       it will be passed up the call stack */
                }
            }
        }
}

Creates a socket and connects it to the specified address on the specified port.

 protected synchronized  void create(boolean stream) throws IOException 
{
        fd = new FileDescriptor();
        this.stream = stream;
        if (!stream) {
            ResourceManager.beforeUdpCreate();
            try {
                socketCreate(false);
            } catch (IOException ioe) {
                ResourceManager.afterUdpClose();
                fd = null;
                throw ioe;
            }
        } else {
            socketCreate(true);
        }
        if (socket != null)
            socket.setCreated();
        if (serverSocket != null)
            serverSocket.setCreated();
}

Creates a socket with a boolean that specifies whether this is a stream socket (true) or an unconnected UDP socket (false).

 synchronized  void doConnect(InetAddress address,
    int port,
    int timeout) throws IOException 
{
        synchronized (fdLock) {
            if (!closePending && (socket == null || !socket.isBound())) {
                NetHooks.beforeTcpConnect(fd, address, port);
            }
        }
        try {
            acquireFD();
            try {
                socketConnect(address, port, timeout);
                /* socket may have been closed during poll/select */
                synchronized (fdLock) {
                    if (closePending) {
                        throw new SocketException ("Socket closed");
                    }
                }
                // If we have a ref. to the Socket, then sets the flags
                // created, bound & connected to true.
                // This is normally done in Socket.connect() but some
                // subclasses of Socket may call impl.connect() directly!
                if (socket != null) {
                    socket.setBound();
                    socket.setConnected();
                }
            } finally {
                releaseFD();
            }
        } catch (IOException e) {
            close();
            throw e;
        }
}

The workhorse of the connection operation. Tries several times to establish a connection to the given . If unsuccessful, throws an IOException indicating what went wrong.

 protected  void finalize() throws IOException 
{
        close();
}

Cleans up if the user forgets to close it.

 protected synchronized InputStream getInputStream() throws IOException 
{
        if (isClosedOrPending()) {
            throw new IOException("Socket Closed");
        }
        if (shut_rd) {
            throw new IOException("Socket input is shutdown");
        }
        if (socketInputStream == null) {
            socketInputStream = new SocketInputStream(this);
        }
        return socketInputStream;
}

Gets an InputStream for this socket.

 public Object getOption(int opt) throws SocketException 
{
        if (isClosedOrPending()) {
            throw new SocketException("Socket Closed");
        }
        if (opt == SO_TIMEOUT) {
            return new Integer(timeout);
        }
        int ret = 0;
        /*
         * The native socketGetOption() knows about 3 options.
         * The 32 bit value it returns will be interpreted according
         * to what we're asking.  A return of -1 means it understands
         * the option but its turned off.  It will raise a SocketException
         * if "opt" isn't one it understands.
         */
        switch (opt) {
        case TCP_NODELAY:
            ret = socketGetOption(opt, null);
            return Boolean.valueOf(ret != -1);
        case SO_OOBINLINE:
            ret = socketGetOption(opt, null);
            return Boolean.valueOf(ret != -1);
        case SO_LINGER:
            ret = socketGetOption(opt, null);
            return (ret == -1) ? Boolean.FALSE: (Object)(new Integer(ret));
        case SO_REUSEADDR:
            ret = socketGetOption(opt, null);
            return Boolean.valueOf(ret != -1);
        case SO_BINDADDR:
            InetAddressContainer in = new InetAddressContainer();
            ret = socketGetOption(opt, in);
            return in.addr;
        case SO_SNDBUF:
        case SO_RCVBUF:
            ret = socketGetOption(opt, null);
            return new Integer(ret);
        case IP_TOS:
            ret = socketGetOption(opt, null);
            if (ret == -1) { // ipv6 tos
                return new Integer(trafficClass);
            } else {
                return new Integer(ret);
            }
        case SO_KEEPALIVE:
            ret = socketGetOption(opt, null);
            return Boolean.valueOf(ret != -1);
        // should never get here
        default:
            return null;
        }
}

 protected synchronized OutputStream getOutputStream() throws IOException 
{
        if (isClosedOrPending()) {
            throw new IOException("Socket Closed");
        }
        if (shut_wr) {
            throw new IOException("Socket output is shutdown");
        }
        return new SocketOutputStream(this);
}

Gets an OutputStream for this socket.

 public int getTimeout() 
{
        return timeout;
}

 public boolean isClosedOrPending() 
{
        /*
         * Lock on fdLock to ensure that we wait if a
         * close is in progress.
         */
        synchronized (fdLock) {
            if (closePending || (fd == null)) {
                return true;
            } else {
                return false;
            }
        }
}

 public boolean isConnectionReset() 
{
        synchronized (resetLock) {
            return (resetState == CONNECTION_RESET);
        }
}

 public boolean isConnectionResetPending() 
{
        synchronized (resetLock) {
            return (resetState == CONNECTION_RESET_PENDING);
        }
}

 protected synchronized  void listen(int count) throws IOException 
{
        socketListen(count);
}

Listens, for a specified amount of time, for connections.

  void releaseFD() 
{
        synchronized (fdLock) {
            fdUseCount--;
            if (fdUseCount == -1) {
                if (fd != null) {
                    try {
                        socketClose();
                    } catch (IOException e) {
                    } finally {
                        fd = null;
                    }
                }
            }
        }
}

  void reset() throws IOException 
{
        if (fd != null) {
            socketClose();
        }
        fd = null;
        super.reset();
}

 protected  void sendUrgentData(int data) throws IOException 
{
        if (fd == null) {
            throw new IOException("Socket Closed");
        }
        socketSendUrgentData (data);
}

  void setAddress(InetAddress address) 
{
        this.address = address;
}

 public  void setConnectionReset() 
{
        synchronized (resetLock) {
            resetState = CONNECTION_RESET;
        }
}

 public  void setConnectionResetPending() 
{
        synchronized (resetLock) {
            if (resetState == CONNECTION_NOT_RESET) {
                resetState = CONNECTION_RESET_PENDING;
            }
        }
}

  void setFileDescriptor(FileDescriptor fd) 
{
        this.fd = fd;
}

  void setInputStream(SocketInputStream in) 
{
        socketInputStream = in;
}

  void setLocalPort(int localport) 
{
        this.localport = localport;
}

 public  void setOption(int opt,
    Object val) throws SocketException 
{
        if (isClosedOrPending()) {
            throw new SocketException("Socket Closed");
        }
        boolean on = true;
        switch (opt) {
            /* check type safety b4 going native.  These should never
             * fail, since only java.Socket* has access to
             * PlainSocketImpl.setOption().
             */
        case SO_LINGER:
            if (val == null || (!(val instanceof Integer) && !(val instanceof Boolean)))
                throw new SocketException("Bad parameter for option");
            if (val instanceof Boolean) {
                /* true only if disabling - enabling should be Integer */
                on = false;
            }
            break;
        case SO_TIMEOUT:
            if (val == null || (!(val instanceof Integer)))
                throw new SocketException("Bad parameter for SO_TIMEOUT");
            int tmp = ((Integer) val).intValue();
            if (tmp <  0)
                throw new IllegalArgumentException("timeout <  0");
            timeout = tmp;
            break;
        case IP_TOS:
             if (val == null || !(val instanceof Integer)) {
                 throw new SocketException("bad argument for IP_TOS");
             }
             trafficClass = ((Integer)val).intValue();
             break;
        case SO_BINDADDR:
            throw new SocketException("Cannot re-bind socket");
        case TCP_NODELAY:
            if (val == null || !(val instanceof Boolean))
                throw new SocketException("bad parameter for TCP_NODELAY");
            on = ((Boolean)val).booleanValue();
            break;
        case SO_SNDBUF:
        case SO_RCVBUF:
            if (val == null || !(val instanceof Integer) ||
                !(((Integer)val).intValue()  > 0)) {
                throw new SocketException("bad parameter for SO_SNDBUF " +
                                          "or SO_RCVBUF");
            }
            break;
        case SO_KEEPALIVE:
            if (val == null || !(val instanceof Boolean))
                throw new SocketException("bad parameter for SO_KEEPALIVE");
            on = ((Boolean)val).booleanValue();
            break;
        case SO_OOBINLINE:
            if (val == null || !(val instanceof Boolean))
                throw new SocketException("bad parameter for SO_OOBINLINE");
            on = ((Boolean)val).booleanValue();
            break;
        case SO_REUSEADDR:
            if (val == null || !(val instanceof Boolean))
                throw new SocketException("bad parameter for SO_REUSEADDR");
            on = ((Boolean)val).booleanValue();
            break;
        default:
            throw new SocketException("unrecognized TCP option: " + opt);
        }
        socketSetOption(opt, on, val);
}

  void setPort(int port) 
{
        this.port = port;
}

 protected  void shutdownInput() throws IOException 
{
      if (fd != null) {
          socketShutdown(SHUT_RD);
          if (socketInputStream != null) {
              socketInputStream.setEOF(true);
          }
          shut_rd = true;
      }
}

Shutdown read-half of the socket connection;

 protected  void shutdownOutput() throws IOException 
{
      if (fd != null) {
          socketShutdown(SHUT_WR);
          shut_wr = true;
      }
}

Shutdown write-half of the socket connection;

 abstract  void socketAccept(SocketImpl s) throws IOException

 abstract int socketAvailable() throws IOException

 abstract  void socketBind(InetAddress address,
    int port) throws IOException

 protected  void socketClose() throws IOException 
{
        socketClose0(false);
}

 abstract  void socketClose0(boolean useDeferredClose) throws IOException

 abstract  void socketConnect(InetAddress address,
    int port,
    int timeout) throws IOException

 abstract  void socketCreate(boolean isServer) throws IOException

 abstract int socketGetOption(int opt,
    Object iaContainerObj) throws SocketException

 abstract  void socketListen(int count) throws IOException

 abstract  void socketSendUrgentData(int data) throws IOException

 abstract  void socketSetOption(int cmd,
    boolean on,
    Object value) throws SocketException

 abstract  void socketShutdown(int howto) throws IOException

 protected boolean supportsUrgentData() 
{
        return true;
}