/*

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

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

package java.net;

import java.io.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;

import java.util.Set;

import java.util.Collections;

/**

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

     *

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