/*

 * 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.IOException;

import java.nio.channels.ServerSocketChannel;

import java.security.AccessController;

import java.security.PrivilegedExceptionAction;

/**

 * This class implements server sockets. A server socket waits for

 * requests to come in over the network. It performs some operation

 * based on that request, and then possibly returns a result to the requester.

 * <p>

 * The actual work of the server socket is performed by an instance

 * of the <code>SocketImpl</code> class. An application can

 * change the socket factory that creates the socket

 * implementation to configure itself to create sockets

 * appropriate to the local firewall.

 *

 * @author  unascribed

 * @see     java.net.SocketImpl

 * @see     java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)

 * @see     java.nio.channels.ServerSocketChannel

 * @since   JDK1.0

 */

public

class ServerSocket implements java.io.Closeable {

    /**

     * Various states of this socket.

     */

    private boolean created = false;

    private boolean bound = false;

    private boolean closed = false;

    private Object closeLock = new Object();

    /**

     * The implementation of this Socket.

     */

    private SocketImpl impl;

    /**

     * Are we using an older SocketImpl?

     */

    private boolean oldImpl = false;

    /**

     * Package-private constructor to create a ServerSocket associated with

     * the given SocketImpl.

     */

    ServerSocket(SocketImpl impl) {

        this.impl = impl;

        impl.setServerSocket(this);

    }

    /**

     * Creates an unbound server socket.

     *

     * @exception IOException IO error when opening the socket.

     * @revised 1.4

     */

    public ServerSocket() throws IOException {

        setImpl();

    }

    /**

     * Creates a server socket, bound to the specified port. A port number

     * of <code>0</code> means that the port number is automatically

     * allocated, typically from an ephemeral port range. This port

     * number can then be retrieved by calling {@link #getLocalPort getLocalPort}.

     * <p>

     * The maximum queue length for incoming connection indications (a

     * request to connect) is set to <code>50</code>. If a connection

     * indication arrives when the queue is full, the connection is refused.

     * <p>

     * If the application has specified a server socket factory, that

     * factory's <code>createSocketImpl</code> method is called to create

     * the actual socket implementation. Otherwise a "plain" socket is created.

     * <p>

     * If there is a security manager,

     * its <code>checkListen</code> method is called

     * with the <code>port</code> argument

     * as its argument to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     *

     * @param      port  the port number, or <code>0</code> to use a port

     *                   number that is automatically allocated.

     *

     * @exception  IOException  if an I/O error occurs when opening the socket.

     * @exception  SecurityException

     * if a security manager exists and its <code>checkListen</code>

     * 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.SocketImpl

     * @see        java.net.SocketImplFactory#createSocketImpl()

     * @see        java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)

     * @see        SecurityManager#checkListen

     */

    public ServerSocket(int port) throws IOException {

        this(port, 50, null);

    }

    /**

     * Creates a server socket and binds it to the specified local port

     * number, with the specified backlog.

     * A port number of <code>0</code> means that the port number is

     * automatically allocated, typically from an ephemeral port range.

     * This port number can then be retrieved by calling

     * {@link #getLocalPort getLocalPort}.

     * <p>

     * The maximum queue length for incoming connection indications (a

     * request to connect) is set to the <code>backlog</code> parameter. If

     * a connection indication arrives when the queue is full, the

     * connection is refused.

     * <p>

     * If the application has specified a server socket factory, that

     * factory's <code>createSocketImpl</code> method is called to create

     * the actual socket implementation. Otherwise a "plain" socket is created.

     * <p>

     * If there is a security manager,

     * its <code>checkListen</code> method is called

     * with the <code>port</code> argument

     * as its argument to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     * The <code>backlog</code> argument is the requested maximum number of

     * pending connections on the socket. Its exact semantics are implementation

     * specific. In particular, an implementation may impose a maximum length

     * or may choose to ignore the parameter altogther. The value provided

     * should be greater than <code>0</code>. If it is less than or equal to

     * <code>0</code>, then an implementation specific default will be used.

     * <P>

     *

     * @param      port     the port number, or <code>0</code> to use a port

     *                      number that is automatically allocated.

     * @param      backlog  requested maximum length of the queue of incoming

     *                      connections.

     *

     * @exception  IOException  if an I/O error occurs when opening the socket.

     * @exception  SecurityException

     * if a security manager exists and its <code>checkListen</code>

     * 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.SocketImpl

     * @see        java.net.SocketImplFactory#createSocketImpl()

     * @see        java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)

     * @see        SecurityManager#checkListen

     */

    public ServerSocket(int port, int backlog) throws IOException {

        this(port, backlog, null);

    }

    /**

     * Create a server with the specified port, listen backlog, and

     * local IP address to bind to.  The <i>bindAddr</i> argument

     * can be used on a multi-homed host for a ServerSocket that

     * will only accept connect requests to one of its addresses.

     * If <i>bindAddr</i> is null, it will default accepting

     * connections on any/all local addresses.

     * The port must be between 0 and 65535, inclusive.

     * A port number of <code>0</code> means that the port number is

     * automatically allocated, typically from an ephemeral port range.

     * This port number can then be retrieved by calling

     * {@link #getLocalPort getLocalPort}.

     *

     * <P>If there is a security manager, this method

     * calls its <code>checkListen</code> method

     * with the <code>port</code> argument

     * as its argument to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     * The <code>backlog</code> argument is the requested maximum number of

     * pending connections on the socket. Its exact semantics are implementation

     * specific. In particular, an implementation may impose a maximum length

     * or may choose to ignore the parameter altogther. The value provided

     * should be greater than <code>0</code>. If it is less than or equal to

     * <code>0</code>, then an implementation specific default will be used.

     * <P>

     * @param port  the port number, or <code>0</code> to use a port

     *              number that is automatically allocated.

     * @param backlog requested maximum length of the queue of incoming

     *                connections.

     * @param bindAddr the local InetAddress the server will bind to

     *

     * @throws  SecurityException if a security manager exists and

     * its <code>checkListen</code> method doesn't allow the operation.

     *

     * @throws  IOException if an I/O error occurs when opening the socket.

     * @exception  IllegalArgumentException if the port parameter is outside

     *             the specified range of valid port values, which is between

     *             0 and 65535, inclusive.

     *

     * @see SocketOptions

     * @see SocketImpl

     * @see SecurityManager#checkListen

     * @since   JDK1.1

     */

    public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException {

        setImpl();

        if (port < 0 || port > 0xFFFF)

            throw new IllegalArgumentException(

                       "Port value out of range: " + port);

        if (backlog < 1)

          backlog = 50;

        try {

            bind(new InetSocketAddress(bindAddr, port), backlog);

        } catch(SecurityException e) {

            close();

            throw e;

        } catch(IOException e) {

            close();

            throw e;

        }

    }

    /**

     * Get the <code>SocketImpl</code> attached to this socket, creating

     * it if necessary.

     *

     * @return  the <code>SocketImpl</code> attached to that ServerSocket.

     * @throws SocketException if creation fails.

     * @since 1.4

     */

    SocketImpl getImpl() throws SocketException {

        if (!created)

            createImpl();

        return impl;

    }

    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

        try {

            AccessController.doPrivileged(

                new PrivilegedExceptionAction<Void>() {

                    public Void run() throws NoSuchMethodException {

                        impl.getClass().getDeclaredMethod("connect",

                                                          SocketAddress.class,

                                                          int.class);

                        return null;

                    }

                });

        } catch (java.security.PrivilegedActionException e) {

            oldImpl = true;

        }

    }

    private 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.setServerSocket(this);

    }

    /**

     * Creates the socket implementation.

     *

     * @throws IOException if creation fails

     * @since 1.4

     */

    void createImpl() throws SocketException {

        if (impl == null)

            setImpl();

        try {

            impl.create(true);

            created = true;

        } catch (IOException e) {

            throw new SocketException(e.getMessage());

        }

    }

    /**

     *

     * Binds the <code>ServerSocket</code> to a specific address

     * (IP address and port number).

     * <p>

     * If the address is <code>null</code>, then the system will pick up

     * an ephemeral port and a valid local address to bind the socket.

     * <p>

     * @param   endpoint        The IP address & port number to bind to.

     * @throws  IOException if the bind operation fails, or if the socket

     *                     is already bound.

     * @throws  SecurityException       if a <code>SecurityManager</code> is present and

     * its <code>checkListen</code> method doesn't allow the operation.

     * @throws  IllegalArgumentException if endpoint is a

     *          SocketAddress subclass not supported by this socket

     * @since 1.4

     */

    public void bind(SocketAddress endpoint) throws IOException {

        bind(endpoint, 50);

    }

    /**

     *

     * Binds the <code>ServerSocket</code> to a specific address

     * (IP address and port number).

     * <p>

     * If the address is <code>null</code>, then the system will pick up

     * an ephemeral port and a valid local address to bind the socket.

     * <P>

     * The <code>backlog</code> argument is the requested maximum number of

     * pending connections on the socket. Its exact semantics are implementation

     * specific. In particular, an implementation may impose a maximum length

     * or may choose to ignore the parameter altogther. The value provided

     * should be greater than <code>0</code>. If it is less than or equal to

     * <code>0</code>, then an implementation specific default will be used.

     * @param   endpoint        The IP address & port number to bind to.

     * @param   backlog         requested maximum length of the queue of

     *                          incoming connections.

     * @throws  IOException if the bind operation fails, or if the socket

     *                     is already bound.

     * @throws  SecurityException       if a <code>SecurityManager</code> is present and

     * its <code>checkListen</code> method doesn't allow the operation.

     * @throws  IllegalArgumentException if endpoint is a

     *          SocketAddress subclass not supported by this socket

     * @since 1.4

     */

    public void bind(SocketAddress endpoint, int backlog) throws IOException {

        if (isClosed())

            throw new SocketException("Socket is closed");

        if (!oldImpl && isBound())

            throw new SocketException("Already bound");

        if (endpoint == null)

            endpoint = new InetSocketAddress(0);

        if (!(endpoint instanceof InetSocketAddress))

            throw new IllegalArgumentException("Unsupported address type");

        InetSocketAddress epoint = (InetSocketAddress) endpoint;

        if (epoint.isUnresolved())

            throw new SocketException("Unresolved address");

        if (backlog < 1)

          backlog = 50;

        try {

            SecurityManager security = System.getSecurityManager();

            if (security != null)

                security.checkListen(epoint.getPort());

            getImpl().bind(epoint.getAddress(), epoint.getPort());

            getImpl().listen(backlog);

            bound = true;

        } catch(SecurityException e) {

            bound = false;

            throw e;

        } catch(IOException e) {

            bound = false;

            throw e;

        }

    }

    /**

     * Returns the local address of this server socket.

     * <p>

     * If the socket was bound prior to being {@link #close closed},

     * then this method will continue to return the local address

     * after the socket is closed.

     *

     * @return  the address to which this socket is bound,

     *          or <code>null</code> if the socket is unbound.

     */

    public InetAddress getInetAddress() {

        if (!isBound())

            return null;

        try {

            return getImpl().getInetAddress();

        } catch (SocketException e) {

            // nothing

            // If we're bound, the impl has been created

            // so we shouldn't get here

        }

        return null;

    }

    /**

     * Returns the port number on which this socket is listening.

     * <p>

     * If the socket was bound prior to being {@link #close closed},

     * then this method will continue to return the port number

     * after the socket is closed.

     *

     * @return  the port number to which this socket is listening or

     *          -1 if the socket is not bound yet.

     */

    public int getLocalPort() {

        if (!isBound())

            return -1;

        try {

            return getImpl().getLocalPort();

        } catch (SocketException e) {

            // nothing

            // If we're bound, the impl has been created

            // so we shouldn't get here

        }

        return -1;

    }

    /**

     * Returns the address of the endpoint this socket is bound to, or

     * <code>null</code> if it is not bound yet.

     * <p>

     * If the socket was bound prior to being {@link #close closed},

     * then this method will continue to return the address of the endpoint

     * after the socket is closed.

     *

     * @return a <code>SocketAddress</code> representing the local endpoint of this

     *         socket, or <code>null</code> if it is not bound yet.

     * @see #getInetAddress()

     * @see #getLocalPort()

     * @see #bind(SocketAddress)

     * @since 1.4

     */

    public SocketAddress getLocalSocketAddress() {

        if (!isBound())

            return null;

        return new InetSocketAddress(getInetAddress(), getLocalPort());

    }

    /**

     * Listens for a connection to be made to this socket and accepts

     * it. The method blocks until a connection is made.

     *

     * <p>A new Socket <code>s</code> is created and, if there

     * is a security manager,

     * the security manager's <code>checkAccept</code> method is called

     * with <code>s.getInetAddress().getHostAddress()</code> and

     * <code>s.getPort()</code>

     * as its arguments to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     * @exception  IOException  if an I/O error occurs when waiting for a

     *               connection.

     * @exception  SecurityException  if a security manager exists and its

     *             <code>checkAccept</code> method doesn't allow the operation.

     * @exception  SocketTimeoutException if a timeout was previously set with setSoTimeout and

     *             the timeout has been reached.

     * @exception  java.nio.channels.IllegalBlockingModeException

     *             if this socket has an associated channel, the channel is in

     *             non-blocking mode, and there is no connection ready to be

     *             accepted

     *

     * @return the new Socket

     * @see SecurityManager#checkAccept

     * @revised 1.4

     * @spec JSR-51

     */

    public Socket accept() throws IOException {

        if (isClosed())

            throw new SocketException("Socket is closed");

        if (!isBound())

            throw new SocketException("Socket is not bound yet");

        Socket s = new Socket((SocketImpl) null);

        implAccept(s);

        return s;

    }

    /**

     * Subclasses of ServerSocket use this method to override accept()

     * to return their own subclass of socket.  So a FooServerSocket

     * will typically hand this method an <i>empty</i> FooSocket.  On

     * return from implAccept the FooSocket will be connected to a client.

     *

     * @param s the Socket

     * @throws java.nio.channels.IllegalBlockingModeException

     *         if this socket has an associated channel,

     *         and the channel is in non-blocking mode

     * @throws IOException if an I/O error occurs when waiting

     * for a connection.

     * @since   JDK1.1

     * @revised 1.4

     * @spec JSR-51

     */

    protected final void implAccept(Socket s) throws IOException {

        SocketImpl si = null;

        try {

            if (s.impl == null)

              s.setImpl();

            else {

                s.impl.reset();

            }

            si = s.impl;

            s.impl = null;

            si.address = new InetAddress();

            si.fd = new FileDescriptor();

            getImpl().accept(si);

            SecurityManager security = System.getSecurityManager();

            if (security != null) {