/*

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

import java.io.FileDescriptor;

import sun.net.ResourceManager;

/*

 * This class defines the plain SocketImpl that is used for all

 * Windows version lower than Vista. It adds support for IPv6 on

 * these platforms where available.

 *

 * For backward compatibility Windows platforms that do not have IPv6

 * support also use this implementation, and fd1 gets set to null

 * during socket creation.

 *

 * @author Chris Hegarty

 */

class TwoStacksPlainSocketImpl extends AbstractPlainSocketImpl

{

    /* second fd, used for ipv6 on windows only.

     * fd1 is used for listeners and for client sockets at initialization

     * until the socket is connected. Up to this point fd always refers

     * to the ipv4 socket and fd1 to the ipv6 socket. After the socket

     * becomes connected, fd always refers to the connected socket

     * (either v4 or v6) and fd1 is closed.

     *

     * For ServerSockets, fd always refers to the v4 listener and

     * fd1 the v6 listener.

     */

    private FileDescriptor fd1;

    /*

     * Needed for ipv6 on windows because we need to know

     * if the socket is bound to ::0 or 0.0.0.0, when a caller

     * asks for it. Otherwise we don't know which socket to ask.

     */

    private InetAddress anyLocalBoundAddr = null;

    /* to prevent starvation when listening on two sockets, this is

     * is used to hold the id of the last socket we accepted on.

     */

    private int lastfd = -1;

    // true if this socket is exclusively bound

    private final boolean exclusiveBind;

    // emulates SO_REUSEADDR when exclusiveBind is true

    private boolean isReuseAddress;

    static {

        initProto();

    }

    public TwoStacksPlainSocketImpl(boolean exclBind) {

        exclusiveBind = exclBind;

    }

    public TwoStacksPlainSocketImpl(FileDescriptor fd, boolean exclBind) {

        this.fd = fd;

        exclusiveBind = exclBind;

    }

    /**

     * Creates a socket with a boolean that specifies whether this

     * is a stream socket (true) or an unconnected UDP socket (false).

     */

    protected synchronized void create(boolean stream) throws IOException {

        fd1 = new FileDescriptor();

        try {

            super.create(stream);

        } catch (IOException e) {

            fd1 = null;

            throw e;

        }

    }

     /**

     * Binds the socket to the specified address of the specified local port.

     * @param address the address

     * @param port the port

     */

    protected synchronized void bind(InetAddress address, int lport)

        throws IOException

    {

        super.bind(address, lport);

        if (address.isAnyLocalAddress()) {

            anyLocalBoundAddr = address;

        }

    }

    public Object getOption(int opt) throws SocketException {

        if (isClosedOrPending()) {

            throw new SocketException("Socket Closed");

        }

        if (opt == SO_BINDADDR) {

            if (fd != null && fd1 != null ) {

                /* must be unbound or else bound to anyLocal */

                return anyLocalBoundAddr;

            }

            InetAddressContainer in = new InetAddressContainer();

            socketGetOption(opt, in);

            return in.addr;

        } else if (opt == SO_REUSEADDR && exclusiveBind) {

            // SO_REUSEADDR emulated when using exclusive bind

            return isReuseAddress;

        } else

            return super.getOption(opt);

    }

    @Override

    void socketBind(InetAddress address, int port) throws IOException {

        socketBind(address, port, exclusiveBind);

    }

    @Override

    void socketSetOption(int opt, boolean on, Object value)

        throws SocketException

    {

        // SO_REUSEADDR emulated when using exclusive bind

        if (opt == SO_REUSEADDR && exclusiveBind)

            isReuseAddress = on;

        else

            socketNativeSetOption(opt, on, value);

    }

    /**

     * Closes the socket.

     */

    @Override

    protected void close() throws IOException {

        synchronized(fdLock) {

            if (fd != null || fd1 != null) {

                if (!stream) {

                    ResourceManager.afterUdpClose();

                }

                if (fdUseCount == 0) {

                    if (closePending) {

                        return;

                    }

                    closePending = true;

                    socketClose();

                    fd = null;

                    fd1 = null;

                    return;

                } else {

                    /*

                     * If a thread has acquired the fd and a close

                     * isn't pending then use a deferred close.

                     * Also decrement fdUseCount to signal the last

                     * thread that releases the fd to close it.

                     */

                    if (!closePending) {

                        closePending = true;

                        fdUseCount--;

                        socketClose();

                    }

                }

            }

        }

    }

    @Override

    void reset() throws IOException {

        if (fd != null || fd1 != null) {

            socketClose();

        }

        fd = null;

        fd1 = null;

        super.reset();

    }

    /*

     * Return true if already closed or close is pending

     */

    @Override

    public boolean isClosedOrPending() {

        /*

         * Lock on fdLock to ensure that we wait if a

         * close is in progress.

         */

        synchronized (fdLock) {

            if (closePending || (fd == null && fd1 == null)) {

                return true;

            } else {

                return false;

            }

        }

    }

    /* Native methods */

    static native void initProto();

    native void socketCreate(boolean isServer) throws IOException;

    native void socketConnect(InetAddress address, int port, int timeout)

        throws IOException;

    native void socketBind(InetAddress address, int port, boolean exclBind)

        throws IOException;

    native void socketListen(int count) throws IOException;

    native void socketAccept(SocketImpl s) throws IOException;

    native int socketAvailable() throws IOException;

    native void socketClose0(boolean useDeferredClose) throws IOException;

    native void socketShutdown(int howto) throws IOException;

    native void socketNativeSetOption(int cmd, boolean on, Object value)

        throws SocketException;

    native int socketGetOption(int opt, Object iaContainerObj) throws SocketException;

    native void socketSendUrgentData(int data) throws IOException;

}