/*

 * Copyright (c) 1995, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.net;

import java.io.FileDescriptor;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.nio.channels.ServerSocketChannel;

import java.security.AccessController;

import java.security.PrivilegedExceptionAction;

import java.util.Set;

import java.util.Collections;

import jdk.internal.access.JavaNetSocketAccess;

import jdk.internal.access.SharedSecrets;

import sun.net.PlatformSocketImpl;

/**

 * 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} 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   1.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;

    /**

     * Creates a server socket with a user-specified {@code SocketImpl}.

     *

     * @param      impl an instance of a SocketImpl to use on the ServerSocket.

     *

     * @throws     NullPointerException if impl is {@code null}.

     *

     * @since 12

     */

    protected ServerSocket(SocketImpl impl) {

        this.impl = impl;

    }

    /**

     * 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} 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}. 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} 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} method is called

     * with the {@code port} argument

     * as its argument to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     *

     * @param      port  the port number, or {@code 0} 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}

     * 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} 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} 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} 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} method is called

     * with the {@code port} argument

     * as its argument to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     * The {@code backlog} 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 altogether. The value provided

     * should be greater than {@code 0}. If it is less than or equal to

     * {@code 0}, then an implementation specific default will be used.

     *

     * @param      port     the port number, or {@code 0} 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}

     * 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} 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} method

     * with the {@code port} argument

     * as its argument to ensure the operation is allowed.

     * This could result in a SecurityException.

     *

     * The {@code backlog} 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 altogether. The value provided

     * should be greater than {@code 0}. If it is less than or equal to

     * {@code 0}, then an implementation specific default will be used.

     *

     * @param port  the port number, or {@code 0} 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} 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   1.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} 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();

        return impl;

    }

    private void setImpl() {

        SocketImplFactory factory = ServerSocket.factory;

        if (factory != null) {

            impl = factory.createSocketImpl();

        } else {

            impl = SocketImpl.createPlatformSocketImpl(true);

        }

    }

    /**

     * 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} to a specific address

     * (IP address and port number).

     * <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   endpoint        The IP address and 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} is present and

     * its {@code checkListen} 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} to a specific address

     * (IP address and port number).

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

     * <P>

     * The {@code backlog} 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 altogether. The value provided

     * should be greater than {@code 0}. If it is less than or equal to

     * {@code 0}, then an implementation specific default will be used.

     * @param   endpoint        The IP address and 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} is present and

     * its {@code checkListen} 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");

            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.

     * <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 address to which this socket is bound,

     *          or the loopback address if denied by the security manager,

     *          or {@code null} if the socket is unbound.

     *

     * @see SecurityManager#checkConnect

     */

    public InetAddress getInetAddress() {

        if (!isBound())

            return null;

        try {

            InetAddress in = getImpl().getInetAddress();

            SecurityManager sm = System.getSecurityManager();

            if (sm != null)

                sm.checkConnect(in.getHostAddress(), -1);

            return in;

        } catch (SecurityException e) {

            return InetAddress.getLoopbackAddress();

        } 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.

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

     * <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 the 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 #getInetAddress()

     * @see #getLocalPort()

     * @see #bind(SocketAddress)

     * @see SecurityManager#checkConnect

     * @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} is created and, if there

     * is a security manager,

     * the security manager's {@code checkAccept} method is called

     * with {@code s.getInetAddress().getHostAddress()} and

     * {@code s.getPort()}

     * 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} 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   1.1