/*

 * Copyright 1995-2007 Sun Microsystems, Inc.  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.  Sun designates this

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

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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.io.InterruptedIOException;

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</code> 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</code> 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);</code> 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)));</code>

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

     * @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) {

        if (proxy != null && proxy.type() == Proxy.Type.SOCKS) {

            SecurityManager security = System.getSecurityManager();

            InetSocketAddress epoint = (InetSocketAddress) proxy.address();

            if (security != null) {

                if (epoint.isUnresolved())

                    security.checkConnect(epoint.getHostName(),

                                          epoint.getPort());

                else

                    security.checkConnect(epoint.getAddress().getHostAddress(),

                                          epoint.getPort());

            }

            impl = new SocksSocketImpl(proxy);

            impl.setSocket(this);

        } else {

            if (proxy == 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 <tt>null</tt> it is the equivalent of

     * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.

     * 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</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>checkConnect</code> method is called

     * with the host address and <code>port</code>

     * as its arguments. This could result in a SecurityException.

     *

     * @param      host   the host name, or <code>null</code> 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</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.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</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>checkConnect</code> method is called

     * with the host address and <code>port</code>

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

     * @exception  NullPointerException if <code>address</code> 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 <tt>null</tt> it is the equivalent of

     * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.

     * In other words, it is equivalent to specifying an address of the

     * loopback interface. </p>

     * <p>

     * A local port number of <code>zero</code> will let the system pick up a

     * free port in the <code>bind</code> operation.</p>

     * <p>

     * If there is a security manager, its

     * <code>checkConnect</code> method is called

     * with the host address and <code>port</code>

     * as its arguments. This could result in a SecurityException.

     *

     * @param host the name of the remote host, or <code>null</code> for the loopback address.

     * @param port the remote port

     * @param localAddr the local address the socket is bound to

     * @param localPort the local port the socket is bound to, or

     *        <code>zero</code> 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</code> method doesn't allow the operation.

     * @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 <tt>null</tt> it is the equivalent of

     * specifying the address as the AnyLocal address (see <tt>{@link java.net.InetAddress#isAnyLocalAddress InetAddress.isAnyLocalAddress}()</tt>).

     * <p>

     * A local port number of <code>zero</code> will let the system pick up a

     * free port in the <code>bind</code> operation.</p>

     * <p>

     * If there is a security manager, its

     * <code>checkConnect</code> method is called

     * with the host address and <code>port</code>

     * 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</code> for the <code>anyLocal</code> address.

     * @param localPort the local port the socket is bound to or

     *        <code>zero</code> 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</code> method doesn't allow the operation.

     * @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</code> 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 <tt>null</tt> it is the equivalent of

     * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.

     * In other words, it is equivalent to specifying an address of the

     * loopback interface. </p>

     * <p>

     * If the stream argument is <code>true</code>, this creates a

     * stream socket. If the stream argument is <code>false</code>, it

     * creates a datagram socket.

     * <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>checkConnect</code> method is called

     * with the host address and <code>port</code>

     * 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</code> for the loopback address.

     * @param      port     the port number.

     * @param      stream   a <code>boolean</code> 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</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.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</code>, this creates a

     * stream socket. If the stream argument is <code>false</code>, it

     * creates a datagram socket.

     * <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>checkConnect</code> method is called

     * with <code>host.getHostAddress()</code> and <code>port</code>

     * 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</code>, 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</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.

     * @exception  NullPointerException if <code>host</code> 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);

            if (address != null)

                connect(address);

        } catch (IOException e) {

            close();

            throw e;

        }

    }

    /**

     * Creates the socket implementation.

     *

     * @param stream a <code>boolean</code> value : <code>true</code> for a TCP socket,

     *               <code>false</code> 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[] cl = new Class[2];

                cl[0] = SocketAddress.class;

                cl[1] = Integer.TYPE;

                Class clazz = impl.getClass();

                while (true) {

                    try {

                        clazz.getDeclaredMethod("connect", cl);

                        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</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(true);

        return impl;

    }

    /**

     * Connects this socket to the server.

     *

     * @param   endpoint the <code>SocketAddress</code>

     * @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</code>

     * @param   timeout  the timeout value to be used in milliseconds.

     * @throws  IOException if an error occurs during the connection