/*

 * Copyright (c) 2001, 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 sun.nio.ch;

import java.io.FileDescriptor;

import java.io.IOException;

import java.io.UncheckedIOException;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.VarHandle;

import java.lang.ref.Cleaner.Cleanable;

import java.lang.reflect.Method;

import java.net.DatagramSocket;

import java.net.Inet4Address;

import java.net.Inet6Address;

import java.net.InetAddress;

import java.net.InetSocketAddress;

import java.net.NetworkInterface;

import java.net.PortUnreachableException;

import java.net.ProtocolFamily;

import java.net.SocketAddress;

import java.net.SocketOption;

import java.net.SocketTimeoutException;

import java.net.StandardProtocolFamily;

import java.net.StandardSocketOptions;

import java.nio.ByteBuffer;

import java.nio.channels.AlreadyBoundException;

import java.nio.channels.AlreadyConnectedException;

import java.nio.channels.AsynchronousCloseException;

import java.nio.channels.ClosedChannelException;

import java.nio.channels.DatagramChannel;

import java.nio.channels.IllegalBlockingModeException;

import java.nio.channels.MembershipKey;

import java.nio.channels.NotYetConnectedException;

import java.nio.channels.SelectionKey;

import java.nio.channels.spi.AbstractSelectableChannel;

import java.nio.channels.spi.SelectorProvider;

import java.security.AccessController;

import java.security.PrivilegedExceptionAction;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.locks.ReentrantLock;

import java.util.function.Consumer;

import jdk.internal.ref.CleanerFactory;

import sun.net.ResourceManager;

import sun.net.ext.ExtendedSocketOptions;

import sun.net.util.IPAddressUtil;

/**

 * An implementation of DatagramChannels.

 */

class DatagramChannelImpl

    extends DatagramChannel

    implements SelChImpl

{

    // Used to make native read and write calls

    private static final NativeDispatcher nd = new DatagramDispatcher();

    // The protocol family of the socket

    private final ProtocolFamily family;

    // Our file descriptor

    private final FileDescriptor fd;

    private final int fdVal;

    // Lock held by current reading or connecting thread

    private final ReentrantLock readLock = new ReentrantLock();

    // Lock held by current writing or connecting thread

    private final ReentrantLock writeLock = new ReentrantLock();

    // Lock held by any thread that modifies the state fields declared below

    // DO NOT invoke a blocking I/O operation while holding this lock!

    private final Object stateLock = new Object();

    // -- The following fields are protected by stateLock

    // State (does not necessarily increase monotonically)

    private static final int ST_UNCONNECTED = 0;

    private static final int ST_CONNECTED = 1;

    private static final int ST_CLOSING = 2;

    private static final int ST_CLOSED = 3;

    private int state;

    // IDs of native threads doing reads and writes, for signalling

    private long readerThread;

    private long writerThread;

    // Local and remote (connected) address

    private InetSocketAddress localAddress;

    private InetSocketAddress remoteAddress;

    // Local address prior to connecting

    private InetSocketAddress initialLocalAddress;

    // Socket adaptor, created lazily

    private static final VarHandle SOCKET;

    static {

        try {

            MethodHandles.Lookup l = MethodHandles.lookup();

            SOCKET = l.findVarHandle(DatagramChannelImpl.class, "socket", DatagramSocket.class);

        } catch (Exception e) {

            throw new InternalError(e);

        }

    }

    private volatile DatagramSocket socket;

    // Multicast support

    private MembershipRegistry registry;

    // set true when socket is bound and SO_REUSEADDRESS is emulated

    private boolean reuseAddressEmulated;

    // set true/false when socket is already bound and SO_REUSEADDR is emulated

    private boolean isReuseAddress;

    // -- End of fields protected by stateLock

    public DatagramChannelImpl(SelectorProvider sp)

        throws IOException

    {

        super(sp);

        ResourceManager.beforeUdpCreate();

        try {

            this.family = Net.isIPv6Available()

                    ? StandardProtocolFamily.INET6

                    : StandardProtocolFamily.INET;

            this.fd = Net.socket(family, false);

            this.fdVal = IOUtil.fdVal(fd);

        } catch (IOException ioe) {

            ResourceManager.afterUdpClose();

            throw ioe;

        }

    }

    public DatagramChannelImpl(SelectorProvider sp, ProtocolFamily family)

        throws IOException

    {

        super(sp);

        Objects.requireNonNull(family, "'family' is null");

        if ((family != StandardProtocolFamily.INET) &&

            (family != StandardProtocolFamily.INET6)) {

            throw new UnsupportedOperationException("Protocol family not supported");

        }

        if (family == StandardProtocolFamily.INET6) {

            if (!Net.isIPv6Available()) {

                throw new UnsupportedOperationException("IPv6 not available");

            }

        }

        ResourceManager.beforeUdpCreate();

        try {

            this.family = family;

            this.fd = Net.socket(family, false);

            this.fdVal = IOUtil.fdVal(fd);

        } catch (IOException ioe) {

            ResourceManager.afterUdpClose();

            throw ioe;

        }

    }

    public DatagramChannelImpl(SelectorProvider sp, FileDescriptor fd)

        throws IOException

    {

        super(sp);

        // increment UDP count to match decrement when closing

        ResourceManager.beforeUdpCreate();

        this.family = Net.isIPv6Available()

                ? StandardProtocolFamily.INET6

                : StandardProtocolFamily.INET;

        this.fd = fd;

        this.fdVal = IOUtil.fdVal(fd);

        synchronized (stateLock) {

            this.localAddress = Net.localAddress(fd);

        }

    }

    // @throws ClosedChannelException if channel is closed

    private void ensureOpen() throws ClosedChannelException {

        if (!isOpen())

            throw new ClosedChannelException();

    }

    @Override

    public DatagramSocket socket() {

        DatagramSocket socket = this.socket;

        if (socket == null) {

            socket = DatagramSocketAdaptor.create(this);

            if (!SOCKET.compareAndSet(this, null, socket)) {

                socket = this.socket;

            }

        }

        return socket;

    }

    @Override

    public SocketAddress getLocalAddress() throws IOException {

        synchronized (stateLock) {

            ensureOpen();

            // Perform security check before returning address

            return Net.getRevealedLocalAddress(localAddress);

        }

    }

    @Override

    public SocketAddress getRemoteAddress() throws IOException {

        synchronized (stateLock) {

            ensureOpen();

            return remoteAddress;

        }

    }

    /**

     * Returns the protocol family to specify to set/getSocketOption for the

     * given socket option.

     */

    private ProtocolFamily familyFor(SocketOption<?> name) {

        assert Thread.holdsLock(stateLock);

        // unspecified (most options)

        if (SocketOptionRegistry.findOption(name, Net.UNSPEC) != null)

            return Net.UNSPEC;

        // IPv4 socket

        if (family == StandardProtocolFamily.INET)

            return StandardProtocolFamily.INET;

        // IPv6 socket that is unbound

        if (localAddress == null)

            return StandardProtocolFamily.INET6;

        // IPv6 socket bound to wildcard or IPv6 address

        InetAddress address = localAddress.getAddress();

        if (address.isAnyLocalAddress() || (address instanceof Inet6Address))

            return StandardProtocolFamily.INET6;

        // IPv6 socket bound to IPv4 address

        if (Net.canUseIPv6OptionsWithIPv4LocalAddress()) {

            // IPV6_XXX options can be used

            return StandardProtocolFamily.INET6;

        } else {

            // IPV6_XXX options cannot be used

            return StandardProtocolFamily.INET;

        }

    }

    @Override

    public <T> DatagramChannel setOption(SocketOption<T> name, T value)

        throws IOException

    {

        Objects.requireNonNull(name);

        if (!supportedOptions().contains(name))

            throw new UnsupportedOperationException("'" + name + "' not supported");

        if (!name.type().isInstance(value))

            throw new IllegalArgumentException("Invalid value '" + value + "'");

        synchronized (stateLock) {

            ensureOpen();

            ProtocolFamily family = familyFor(name);

            if (name == StandardSocketOptions.IP_MULTICAST_IF) {

                NetworkInterface interf = (NetworkInterface)value;

                if (family == StandardProtocolFamily.INET6) {

                    int index = interf.getIndex();

                    if (index == -1)

                        throw new IOException("Network interface cannot be identified");

                    Net.setInterface6(fd, index);

                } else {

                    // need IPv4 address to identify interface

                    Inet4Address target = Net.anyInet4Address(interf);

                    if (target == null)

                        throw new IOException("Network interface not configured for IPv4");

                    int targetAddress = Net.inet4AsInt(target);

                    Net.setInterface4(fd, targetAddress);

                }

                return this;

            }

            if (name == StandardSocketOptions.SO_REUSEADDR

                && Net.useExclusiveBind() && localAddress != null) {

                reuseAddressEmulated = true;

                this.isReuseAddress = (Boolean)value;

            }

            // remaining options don't need any special handling

            Net.setSocketOption(fd, family, name, value);

            return this;

        }

    }

    @Override

    @SuppressWarnings("unchecked")

    public <T> T getOption(SocketOption<T> name)

        throws IOException

    {

        Objects.requireNonNull(name);

        if (!supportedOptions().contains(name))

            throw new UnsupportedOperationException("'" + name + "' not supported");

        synchronized (stateLock) {

            ensureOpen();

            ProtocolFamily family = familyFor(name);

            if (name == StandardSocketOptions.IP_MULTICAST_IF) {

                if (family == StandardProtocolFamily.INET) {

                    int address = Net.getInterface4(fd);

                    if (address == 0)

                        return null;    // default interface

                    InetAddress ia = Net.inet4FromInt(address);

                    NetworkInterface ni = NetworkInterface.getByInetAddress(ia);

                    if (ni == null)

                        throw new IOException("Unable to map address to interface");

                    return (T) ni;

                } else {

                    int index = Net.getInterface6(fd);

                    if (index == 0)

                        return null;    // default interface

                    NetworkInterface ni = NetworkInterface.getByIndex(index);

                    if (ni == null)

                        throw new IOException("Unable to map index to interface");

                    return (T) ni;

                }

            }

            if (name == StandardSocketOptions.SO_REUSEADDR && reuseAddressEmulated) {

                return (T) Boolean.valueOf(isReuseAddress);

            }

            // no special handling

            return (T) Net.getSocketOption(fd, family, name);

        }

    }

    private static class DefaultOptionsHolder {

        static final Set<SocketOption<?>> defaultOptions = defaultOptions();

        private static Set<SocketOption<?>> defaultOptions() {

            HashSet<SocketOption<?>> set = new HashSet<>();

            set.add(StandardSocketOptions.SO_SNDBUF);

            set.add(StandardSocketOptions.SO_RCVBUF);

            set.add(StandardSocketOptions.SO_REUSEADDR);

            if (Net.isReusePortAvailable()) {

                set.add(StandardSocketOptions.SO_REUSEPORT);

            }

            set.add(StandardSocketOptions.SO_BROADCAST);

            set.add(StandardSocketOptions.IP_TOS);

            set.add(StandardSocketOptions.IP_MULTICAST_IF);

            set.add(StandardSocketOptions.IP_MULTICAST_TTL);

            set.add(StandardSocketOptions.IP_MULTICAST_LOOP);

            set.addAll(ExtendedSocketOptions.datagramSocketOptions());

            return Collections.unmodifiableSet(set);

        }

    }

    @Override

    public final Set<SocketOption<?>> supportedOptions() {

        return DefaultOptionsHolder.defaultOptions;

    }

    /**

     * Marks the beginning of a read operation that might block.

     *

     * @param blocking true if configured blocking

     * @param mustBeConnected true if the socket must be connected

     * @return remote address if connected

     * @throws ClosedChannelException if the channel is closed

     * @throws NotYetConnectedException if mustBeConnected and not connected

     * @throws IOException if socket not bound and cannot be bound

     */

    private SocketAddress beginRead(boolean blocking, boolean mustBeConnected)

        throws IOException

    {

        if (blocking) {

            // set hook for Thread.interrupt

            begin();

        }

        SocketAddress remote;

        synchronized (stateLock) {

            ensureOpen();

            remote = remoteAddress;

            if ((remote == null) && mustBeConnected)

                throw new NotYetConnectedException();

            if (localAddress == null)

                bindInternal(null);

            if (blocking)

                readerThread = NativeThread.current();

        }

        return remote;

    }

    /**

     * Marks the end of a read operation that may have blocked.

     *

     * @throws AsynchronousCloseException if the channel was closed asynchronously

     */

    private void endRead(boolean blocking, boolean completed)

        throws AsynchronousCloseException

    {

        if (blocking) {

            synchronized (stateLock) {

                readerThread = 0;

                if (state == ST_CLOSING) {

                    tryFinishClose();

                }

            }

            // remove hook for Thread.interrupt

            end(completed);

        }

    }

    @Override

    public SocketAddress receive(ByteBuffer dst) throws IOException {

        if (dst.isReadOnly())

            throw new IllegalArgumentException("Read-only buffer");

        readLock.lock();

        try {

            boolean blocking = isBlocking();

            try {

                SocketAddress remote = beginRead(blocking, false);

                boolean connected = (remote != null);

                SecurityManager sm = System.getSecurityManager();

                if (connected || (sm == null)) {

                    // connected or no security manager

                    if (blocking) {

                        while (IOStatus.okayToRetry(n) && isOpen()) {