/*

 * 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.io.InputStream;

import java.io.OutputStream;

import java.security.AccessController;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.util.Collections;

import java.util.HashSet;

import java.util.Set;

import sun.net.ConnectionResetException;

import sun.net.NetHooks;

import sun.net.PlatformSocketImpl;

import sun.net.ResourceManager;

import sun.net.util.SocketExceptions;

/**

 * Default Socket Implementation. This implementation does

 * not implement any security checks.

 * Note this class should <b>NOT</b> be public.

 *

 * @author  Steven B. Byrne

 */

abstract class AbstractPlainSocketImpl extends SocketImpl implements PlatformSocketImpl {

    /* instance variable for SO_TIMEOUT */

    int timeout;   // timeout in millisec

    // traffic class

    private int trafficClass;

    private boolean shut_rd = false;

    private boolean shut_wr = false;

    private SocketInputStream socketInputStream = null;

    private SocketOutputStream socketOutputStream = null;

    /* number of threads using the FileDescriptor */

    protected int fdUseCount = 0;

    /* lock when increment/decrementing fdUseCount */

    protected final Object fdLock = new Object();

    /* indicates a close is pending on the file descriptor */

    protected boolean closePending = false;

    /* indicates connection reset state */

    private volatile boolean connectionReset;

   /* whether this Socket is a stream (TCP) socket or not (UDP)

    */

    protected boolean stream;

    /**

     * Load net library into runtime.

     */

    static {

        java.security.AccessController.doPrivileged(

            new java.security.PrivilegedAction<>() {

                public Void run() {

                    System.loadLibrary("net");

                    return null;

                }

            });

    }

    private static volatile boolean checkedReusePort;

    private static volatile boolean isReusePortAvailable;

    /**

     * Tells whether SO_REUSEPORT is supported.

     */

    static boolean isReusePortAvailable() {

        if (!checkedReusePort) {

            isReusePortAvailable = isReusePortAvailable0();

            checkedReusePort = true;

        }

        return isReusePortAvailable;

    }

    /**

     * Returns a set of SocketOptions supported by this impl and by this impl's

     * socket (Socket or ServerSocket)

     *

     * @return a Set of SocketOptions

     */

    @Override

    protected Set<SocketOption<?>> supportedOptions() {

        Set<SocketOption<?>> options;

        if (isReusePortAvailable()) {

            options = new HashSet<>();

            options.addAll(super.supportedOptions());

            options.add(StandardSocketOptions.SO_REUSEPORT);

            options = Collections.unmodifiableSet(options);

        } else {

            options = super.supportedOptions();

        }

        return options;

    }

    /**

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

        this.stream = stream;

        if (!stream) {

            ResourceManager.beforeUdpCreate();

            // only create the fd after we know we will be able to create the socket

            fd = new FileDescriptor();

            try {

                socketCreate(false);

                SocketCleanable.register(fd);

            } catch (IOException ioe) {

                ResourceManager.afterUdpClose();

                fd = null;

                throw ioe;

            }

        } else {

            fd = new FileDescriptor();

            socketCreate(true);

            SocketCleanable.register(fd);

        }

    }

    /**

     * Creates a socket and connects it to the specified port on

     * the specified host.

     * @param host the specified host

     * @param port the specified port

     */

    protected void connect(String host, int port)

        throws UnknownHostException, IOException

    {

        boolean connected = false;

        try {

            InetAddress address = InetAddress.getByName(host);

            this.port = port;

            this.address = address;

            connectToAddress(address, port, timeout);

            connected = true;

        } finally {

            if (!connected) {

                try {

                    close();

                } catch (IOException ioe) {

                    /* Do nothing. If connect threw an exception then

                       it will be passed up the call stack */

                }

            }

        }

    }

    /**

     * Creates a socket and connects it to the specified address on

     * the specified port.

     * @param address the address

     * @param port the specified port

     */

    protected void connect(InetAddress address, int port) throws IOException {

        this.port = port;

        this.address = address;

        try {

            connectToAddress(address, port, timeout);

            return;

        } catch (IOException e) {

            // everything failed

            close();

            throw e;

        }

    }

    /**

     * Creates a socket and connects it to the specified address on

     * the specified port.

     * @param address the address

     * @param timeout the timeout value in milliseconds, or zero for no timeout.

     * @throws IOException if connection fails

     * @throws  IllegalArgumentException if address is null or is a

     *          SocketAddress subclass not supported by this socket

     * @since 1.4

     */

    protected void connect(SocketAddress address, int timeout)

            throws IOException {

        boolean connected = false;

        try {

            if (address == null || !(address instanceof InetSocketAddress))

                throw new IllegalArgumentException("unsupported address type");

            InetSocketAddress addr = (InetSocketAddress) address;

            if (addr.isUnresolved())

                throw new UnknownHostException(addr.getHostName());

            this.port = addr.getPort();

            this.address = addr.getAddress();

            connectToAddress(this.address, port, timeout);

            connected = true;

        } finally {

            if (!connected) {

                try {

                    close();

                } catch (IOException ioe) {

                    /* Do nothing. If connect threw an exception then

                       it will be passed up the call stack */

                }

            }

        }

    }

    private void connectToAddress(InetAddress address, int port, int timeout) throws IOException {

        if (address.isAnyLocalAddress()) {

            doConnect(InetAddress.getLocalHost(), port, timeout);

        } else {

            doConnect(address, port, timeout);

        }

    }

    public void setOption(int opt, Object val) throws SocketException {

        if (isClosedOrPending()) {

            throw new SocketException("Socket Closed");

        }

        boolean on = true;

        switch (opt) {

            /* check type safety b4 going native.  These should never

             * fail, since only java.Socket* has access to

             * PlainSocketImpl.setOption().

             */

        case SO_LINGER:

            if (val == null || (!(val instanceof Integer) && !(val instanceof Boolean)))

                throw new SocketException("Bad parameter for option");

            if (val instanceof Boolean) {

                /* true only if disabling - enabling should be Integer */

                on = false;

            }

            break;

        case SO_TIMEOUT:

            if (val == null || (!(val instanceof Integer)))

                throw new SocketException("Bad parameter for SO_TIMEOUT");

            int tmp = ((Integer) val).intValue();

            if (tmp < 0)

                throw new IllegalArgumentException("timeout < 0");

            timeout = tmp;

            break;

        case IP_TOS:

             if (val == null || !(val instanceof Integer)) {

                 throw new SocketException("bad argument for IP_TOS");

             }

             trafficClass = ((Integer)val).intValue();

             break;

        case SO_BINDADDR:

            throw new SocketException("Cannot re-bind socket");

        case TCP_NODELAY:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for TCP_NODELAY");

            on = ((Boolean)val).booleanValue();

            break;

        case SO_SNDBUF:

        case SO_RCVBUF:

            if (val == null || !(val instanceof Integer) ||

                !(((Integer)val).intValue() > 0)) {

                throw new SocketException("bad parameter for SO_SNDBUF " +

                                          "or SO_RCVBUF");

            }

            break;

        case SO_KEEPALIVE:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for SO_KEEPALIVE");

            on = ((Boolean)val).booleanValue();

            break;

        case SO_OOBINLINE:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for SO_OOBINLINE");

            on = ((Boolean)val).booleanValue();

            break;

        case SO_REUSEADDR:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for SO_REUSEADDR");

            on = ((Boolean)val).booleanValue();

            break;

        case SO_REUSEPORT:

            if (val == null || !(val instanceof Boolean))

                throw new SocketException("bad parameter for SO_REUSEPORT");

            if (!supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT))

                throw new UnsupportedOperationException("unsupported option");

            on = ((Boolean)val).booleanValue();

            break;

        default:

            throw new SocketException("unrecognized TCP option: " + opt);

        }

        socketSetOption(opt, on, val);

    }

    public Object getOption(int opt) throws SocketException {

        if (isClosedOrPending()) {

            throw new SocketException("Socket Closed");

        }

        if (opt == SO_TIMEOUT) {

            return timeout;

        }

        int ret = 0;

        /*

         * The native socketGetOption() knows about 3 options.

         * The 32 bit value it returns will be interpreted according

         * to what we're asking.  A return of -1 means it understands

         * the option but its turned off.  It will raise a SocketException

         * if "opt" isn't one it understands.

         */

        switch (opt) {

        case TCP_NODELAY:

            ret = socketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        case SO_OOBINLINE:

            ret = socketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        case SO_LINGER:

            ret = socketGetOption(opt, null);

            return (ret == -1) ? Boolean.FALSE: (Object)(ret);

        case SO_REUSEADDR:

            ret = socketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        case SO_BINDADDR:

            InetAddressContainer in = new InetAddressContainer();

            ret = socketGetOption(opt, in);

            return in.addr;

        case SO_SNDBUF:

        case SO_RCVBUF:

            ret = socketGetOption(opt, null);

            return ret;

        case IP_TOS:

            try {

                ret = socketGetOption(opt, null);

                if (ret == -1) { // ipv6 tos

                    return trafficClass;

                } else {

                    return ret;

                }

            } catch (SocketException se) {

                    // TODO - should make better effort to read TOS or TCLASS

                    return trafficClass; // ipv6 tos

            }

        case SO_KEEPALIVE:

            ret = socketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        case SO_REUSEPORT:

            if (!supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {

                throw new UnsupportedOperationException("unsupported option");

            }

            ret = socketGetOption(opt, null);

            return Boolean.valueOf(ret != -1);

        // should never get here

        default:

            return null;

        }

    }

    /**

     * The workhorse of the connection operation.  Tries several times to

     * establish a connection to the given <host, port>.  If unsuccessful,

     * throws an IOException indicating what went wrong.

     */

    synchronized void doConnect(InetAddress address, int port, int timeout) throws IOException {

        synchronized (fdLock) {

                NetHooks.beforeTcpConnect(fd, address, port);

            }

        }

        try {

            acquireFD();

            try {

                socketConnect(address, port, timeout);

                /* socket may have been closed during poll/select */

                synchronized (fdLock) {

                    if (closePending) {

                        throw new SocketException ("Socket closed");

                    }

                }

            } finally {

                releaseFD();

            }

        } catch (IOException e) {

            close();

            throw SocketExceptions.of(e, new InetSocketAddress(address, port));

        }

    }

    /**

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

     * @param address the address

     * @param lport the port

     */

    protected synchronized void bind(InetAddress address, int lport)

        throws IOException

    {

       synchronized (fdLock) {

                NetHooks.beforeTcpBind(fd, address, lport);

            }

        }

        socketBind(address, lport);

    }

    /**

     * Listens, for a specified amount of time, for connections.

     * @param count the amount of time to listen for connections

     */

    protected synchronized void listen(int count) throws IOException {

        socketListen(count);

    }

    /**

     * Accepts connections.

     * @param si the socket impl

     */

    protected void accept(SocketImpl si) throws IOException {

        si.fd = new FileDescriptor();

        acquireFD();

        try {

            socketAccept(si);

        } finally {

            releaseFD();

        }

        SocketCleanable.register(si.fd);

    }

    /**

     * Gets an InputStream for this socket.

     */

    protected synchronized InputStream getInputStream() throws IOException {

        synchronized (fdLock) {

            if (isClosedOrPending())

                throw new IOException("Socket Closed");

            if (shut_rd)

                throw new IOException("Socket input is shutdown");

            if (socketInputStream == null) {

                PrivilegedExceptionAction<SocketInputStream> pa = () -> new SocketInputStream(this);

                try {

                    socketInputStream = AccessController.doPrivileged(pa);

                } catch (PrivilegedActionException e) {

                    throw (IOException) e.getCause();

                }

            }

        }

        return socketInputStream;

    }

    void setInputStream(SocketInputStream in) {

        socketInputStream = in;

    }

    /**

     * Gets an OutputStream for this socket.

     */

    protected synchronized OutputStream getOutputStream() throws IOException {

        synchronized (fdLock) {

            if (isClosedOrPending())

                throw new IOException("Socket Closed");

            if (shut_wr)

                throw new IOException("Socket output is shutdown");

            if (socketOutputStream == null) {

                PrivilegedExceptionAction<SocketOutputStream> pa = () -> new SocketOutputStream(this);

                try {

                    socketOutputStream = AccessController.doPrivileged(pa);

                } catch (PrivilegedActionException e) {

                    throw (IOException) e.getCause();