/*

 * Copyright (c) 2002, 2012, 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 sun.security.ssl;

import java.io.*;

import java.nio.channels.SocketChannel;

import java.net.*;

import javax.net.ssl.*;

/**

 * Abstract base class for SSLSocketImpl. Its purpose is to house code with

 * no SSL related logic (or no logic at all). This makes SSLSocketImpl shorter

 * and easier to read. It contains a few constants and static methods plus

 * overridden java.net.Socket methods.

 *

 * Methods are defined final to ensure that they are not accidentally

 * overridden in SSLSocketImpl.

 *

 * @see javax.net.ssl.SSLSocket

 * @see SSLSocketImpl

 *

 */

abstract class BaseSSLSocketImpl extends SSLSocket {

    /*

     * Normally "self" is "this" ... but not when this connection is

     * layered over a preexisting socket.  If we're using an existing

     * socket, we delegate some actions to it.  Else, we delegate

     * instead to "super".  This is important to ensure that we don't

     * recurse infinitely ... e.g. close() calling itself, or doing

     * I/O in terms of our own streams.

     */

    final private Socket self;

    final private InputStream consumedInput;

    BaseSSLSocketImpl() {

        super();

        this.self = this;

        this.consumedInput = null;

    }

    BaseSSLSocketImpl(Socket socket) {

        super();

        this.self = socket;

        this.consumedInput = null;

    }

    BaseSSLSocketImpl(Socket socket, InputStream consumed) {

        super();

        this.self = socket;

        this.consumedInput = consumed;

    }

    //

    // CONSTANTS AND STATIC METHODS

    //

    /**

     * TLS requires that a close_notify warning alert is sent before the

     * connection is closed in order to avoid truncation attacks. Some

     * implementations (MS IIS and others) don't do that. The property

     * below controls whether we accept that or treat it as an error.

     *

     * The default is "false", i.e. tolerate the broken behavior.

     */

    private final static String PROP_NAME =

                                "com.sun.net.ssl.requireCloseNotify";

    final static boolean requireCloseNotify =

                                Debug.getBooleanProperty(PROP_NAME, false);

    //

    // MISC SOCKET METHODS

    //

    /**

     * Returns the unique {@link java.nio.SocketChannel SocketChannel} object

     * associated with this socket, if any.

     * @see java.net.Socket#getChannel

     */

    public final SocketChannel getChannel() {

        if (self == this) {

            return super.getChannel();

        } else {

            return self.getChannel();

        }

    }

    /**

     * Binds the address to the socket.

     * @see java.net.Socket#bind

     */

    public void bind(SocketAddress bindpoint) throws IOException {

        /*

         * Bind to this socket

         */

        if (self == this) {

            super.bind(bindpoint);

        } else {

            // If we're binding on a layered socket...

            throw new IOException(

                "Underlying socket should already be connected");

        }

    }

    /**

     * Returns the address of the endpoint this socket is connected to

     * @see java.net.Socket#getLocalSocketAddress

     */

    public SocketAddress getLocalSocketAddress() {

        if (self == this) {

            return super.getLocalSocketAddress();

        } else {

            return self.getLocalSocketAddress();

        }

    }

    /**

     * Returns the address of the endpoint this socket is connected to

     * @see java.net.Socket#getRemoteSocketAddress

     */

    public SocketAddress getRemoteSocketAddress() {

        if (self == this) {

            return super.getRemoteSocketAddress();

        } else {

            return self.getRemoteSocketAddress();

        }

    }

    /**

     * Connects this socket to the server.

     *

     * This method is either called on an unconnected SSLSocketImpl by the

     * application, or it is called in the constructor of a regular

     * SSLSocketImpl. If we are layering on top on another socket, then

     * this method should not be called, because we assume that the

     * underlying socket is already connected by the time it is passed to

     * us.

     *

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

     * @throws  IOException if an error occurs during the connection

     */

    public final void connect(SocketAddress endpoint) throws IOException {

        connect(endpoint, 0);

    }

    /**

     * Returns the connection state of the socket.

     * @see java.net.Socket#isConnected

     */

    public final boolean isConnected() {

        if (self == this) {

            return super.isConnected();

        } else {

            return self.isConnected();

        }

    }

    /**

     * Returns the binding state of the socket.

     * @see java.net.Socket#isBound

     */

    public final boolean isBound() {

        if (self == this) {

            return super.isBound();

        } else {

            return self.isBound();

        }

    }

    //

    // CLOSE RELATED METHODS

    //

    /**

     * The semantics of shutdownInput is not supported in TLS 1.0

     * spec. Thus when the method is called on an SSL socket, an

     * UnsupportedOperationException will be thrown.

     *

     * @throws UnsupportedOperationException

     */

    public final void shutdownInput() throws IOException {

        throw new UnsupportedOperationException("The method shutdownInput()" +

                   " is not supported in SSLSocket");

    }

    /**

     * The semantics of shutdownOutput is not supported in TLS 1.0

     * spec. Thus when the method is called on an SSL socket, an

     * UnsupportedOperationException will be thrown.

     *

     * @throws UnsupportedOperationException

     */

    public final void shutdownOutput() throws IOException {

        throw new UnsupportedOperationException("The method shutdownOutput()" +

                   " is not supported in SSLSocket");

    }

    /**

     * Returns the input state of the socket

     * @see java.net.Socket#isInputShutdown

     */

    public final boolean isInputShutdown() {

        if (self == this) {

            return super.isInputShutdown();

        } else {

            return self.isInputShutdown();

        }

    }

    /**

     * Returns the output state of the socket

     * @see java.net.Socket#isOutputShutdown

     */

    public final boolean isOutputShutdown() {

        if (self == this) {

            return super.isOutputShutdown();

        } else {

            return self.isOutputShutdown();

        }

    }

    /**

     * Ensures that the SSL connection is closed down as cleanly

     * as possible, in case the application forgets to do so.

     * This allows SSL connections to be implicitly reclaimed,

     * rather than forcing them to be explicitly reclaimed at

     * the penalty of prematurly killing SSL sessions.

     */

    protected final void finalize() throws Throwable {

        try {

            close();

        } catch (IOException e1) {

            try {

                if (self == this) {

                    super.close();

                }

            } catch (IOException e2) {

                // ignore

            }

        } finally {

            // We called close on the underlying socket above to

            // make doubly sure all resources got released.  We

            // don't finalize self in the case of overlain sockets,

            // that's a different object which the GC will finalize

            // separately.

            super.finalize();

        }

    }

    //

    // GET ADDRESS METHODS

    //

    /**

     * Returns the address of the remote peer for this connection.

     */

    public final InetAddress getInetAddress() {

        if (self == this) {

            return super.getInetAddress();

        } else {

            return self.getInetAddress();

        }

    }

    /**

     * Gets the local address to which the socket is bound.

     *

     * @return the local address to which the socket is bound.

     * @since   JDK1.1

     */

    public final InetAddress getLocalAddress() {

        if (self == this) {

            return super.getLocalAddress();

        } else {

            return self.getLocalAddress();

        }

    }

    /**

     * Returns the number of the remote port that this connection uses.

     */

    public final int getPort() {

        if (self == this) {

            return super.getPort();

        } else {

            return self.getPort();

        }

    }

    /**

     * Returns the number of the local port that this connection uses.

     */

    public final int getLocalPort() {

        if (self == this) {

            return super.getLocalPort();

        } else {

            return self.getLocalPort();

        }

    }

    //

    // SOCKET OPTION METHODS

    //

    /**

     * Enables or disables the Nagle optimization.

     * @see java.net.Socket#setTcpNoDelay

     */

    public final void setTcpNoDelay(boolean value) throws SocketException {

        if (self == this) {

            super.setTcpNoDelay(value);

        } else {

            self.setTcpNoDelay(value);

        }

    }

    /**

     * Returns true if the Nagle optimization is disabled.  This

     * relates to low-level buffering of TCP traffic, delaying the

     * traffic to promote better throughput.

     *

     * @see java.net.Socket#getTcpNoDelay

     */

    public final boolean getTcpNoDelay() throws SocketException {

        if (self == this) {

            return super.getTcpNoDelay();

        } else {

            return self.getTcpNoDelay();

        }

    }

    /**

     * Assigns the socket's linger timeout.

     * @see java.net.Socket#setSoLinger

     */

    public final void setSoLinger(boolean flag, int linger)

            throws SocketException {

        if (self == this) {

            super.setSoLinger(flag, linger);

        } else {

            self.setSoLinger(flag, linger);

        }

    }

    /**

     * Returns the socket's linger timeout.

     * @see java.net.Socket#getSoLinger

     */

    public final int getSoLinger() throws SocketException {

        if (self == this) {

            return super.getSoLinger();

        } else {

            return self.getSoLinger();

        }

    }

    /**

     * Send one byte of urgent data on the socket.

     * @see java.net.Socket#sendUrgentData

     * At this point, there seems to be no specific requirement to support

     * this for an SSLSocket. An implementation can be provided if a need

     * arises in future.

     */

    public final void sendUrgentData(int data) throws SocketException {

        throw new SocketException("This method is not supported "

                        + "by SSLSockets");

    }

    /**

     * Enable/disable OOBINLINE (receipt of TCP urgent data) By default, this

     * option is disabled and TCP urgent data received on a socket is silently

     * discarded.

     * @see java.net.Socket#setOOBInline

     * Setting OOBInline does not have any effect on SSLSocket,

     * since currently we don't support sending urgent data.

     */

    public final void setOOBInline(boolean on) throws SocketException {

        throw new SocketException("This method is ineffective, since"

                + " sending urgent data is not supported by SSLSockets");

    }

    /**

     * Tests if OOBINLINE is enabled.

     * @see java.net.Socket#getOOBInline

     */

    public final boolean getOOBInline() throws SocketException {

        throw new SocketException("This method is ineffective, since"

                + " sending urgent data is not supported by SSLSockets");

    }

    /**

     * Returns the socket timeout.

     * @see java.net.Socket#getSoTimeout

     */

    public final int getSoTimeout() throws SocketException {

        if (self == this) {

            return super.getSoTimeout();

        } else {

            return self.getSoTimeout();

        }

    }

    public final void setSendBufferSize(int size) throws SocketException {

        if (self == this) {

            super.setSendBufferSize(size);

        } else {

            self.setSendBufferSize(size);

        }

    }

    public final int getSendBufferSize() throws SocketException {

        if (self == this) {

            return super.getSendBufferSize();

        } else {

            return self.getSendBufferSize();

        }

    }

    public final void setReceiveBufferSize(int size) throws SocketException {

        if (self == this) {

            super.setReceiveBufferSize(size);

        } else {

            self.setReceiveBufferSize(size);

        }

    }

    public final int getReceiveBufferSize() throws SocketException {

        if (self == this) {

            return super.getReceiveBufferSize();

        } else {

            return self.getReceiveBufferSize();

        }

    }

    /**

     * Enable/disable SO_KEEPALIVE.

     * @see java.net.Socket#setKeepAlive

     */

    public final void setKeepAlive(boolean on) throws SocketException {

        if (self == this) {

            super.setKeepAlive(on);

        } else {

            self.setKeepAlive(on);

        }

    }

    /**

     * Tests if SO_KEEPALIVE is enabled.

     * @see java.net.Socket#getKeepAlive

     */

    public final boolean getKeepAlive() throws SocketException {

        if (self == this) {

            return super.getKeepAlive();

        } else {

            return self.getKeepAlive();

        }

    }

    /**

     * Sets traffic class or type-of-service octet in the IP header for

     * packets sent from this Socket.

     * @see java.net.Socket#setTrafficClass

     */

    public final void setTrafficClass(int tc) throws SocketException {

        if (self == this) {

            super.setTrafficClass(tc);

        } else {

            self.setTrafficClass(tc);

        }

    }

    /**

     * Gets traffic class or type-of-service in the IP header for packets

     * sent from this Socket.

     * @see java.net.Socket#getTrafficClass

     */

    public final int getTrafficClass() throws SocketException {

        if (self == this) {

            return super.getTrafficClass();

        } else {

            return self.getTrafficClass();

        }

    }

    /**

     * Enable/disable SO_REUSEADDR.

     * @see java.net.Socket#setReuseAddress

     */

    public final void setReuseAddress(boolean on) throws SocketException {

        if (self == this) {

            super.setReuseAddress(on);

        } else {

            self.setReuseAddress(on);

        }

    }

    /**

     * Tests if SO_REUSEADDR is enabled.

     * @see java.net.Socket#getReuseAddress