/*

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

import java.nio.channels.NotYetConnectedException;

import java.nio.channels.SelectionKey;

import java.nio.channels.spi.SelectorProvider;

import java.util.Collections;

import java.util.HashSet;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.locks.ReentrantLock;

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

    // The protocol family of the socket

    private final ProtocolFamily family;

    // Our file descriptor

    private final FileDescriptor fd;

    private final int fdVal;

    // Cached InetAddress and port for unconnected DatagramChannels

    // used by receive0

    private InetAddress cachedSenderInetAddress;

    private int cachedSenderPort;

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

    // Binding and remote address (when connected)

    private InetSocketAddress localAddress;

    private InetSocketAddress remoteAddress;

    // Our socket adaptor, if any

    private 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() {

        synchronized (stateLock) {

            if (socket == null)

                socket = DatagramSocketAdaptor.create(this);

            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;

        }

    }

    @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();

            if (name == StandardSocketOptions.IP_TOS ||

                name == StandardSocketOptions.IP_MULTICAST_TTL ||

                name == StandardSocketOptions.IP_MULTICAST_LOOP)

            {

                // options are protocol dependent

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

                return this;

            }

            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, Net.UNSPEC, 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();

            if (name == StandardSocketOptions.IP_TOS ||

                name == StandardSocketOptions.IP_MULTICAST_TTL ||

                name == StandardSocketOptions.IP_MULTICAST_LOOP)

            {

                return (T) Net.getSocketOption(fd, family, 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, Net.UNSPEC, 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);

        }

    }

    private SocketAddress sender;       // Set by receive0 (## ugh)

    @Override

    public SocketAddress receive(ByteBuffer dst) throws IOException {

        if (dst.isReadOnly())

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

        readLock.lock();

        try {

            boolean blocking = isBlocking();

            int n = 0;

            ByteBuffer bb = null;

            try {

                SocketAddress remote = beginRead(blocking, false);

                boolean connected = (remote != null);

                SecurityManager sm = System.getSecurityManager();

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

                    // connected or no security manager

                    n = receive(fd, dst, connected);

                    if (blocking) {

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

                            park(Net.POLLIN);

                            n = receive(fd, dst, connected);

                        }

                    } else if (n == IOStatus.UNAVAILABLE) {

                        return null;

                    }

                } else {

                    // Cannot receive into user's buffer when running with a

                    // security manager and not connected

                    bb = Util.getTemporaryDirectBuffer(dst.remaining());

                    for (;;) {

                        n = receive(fd, bb, connected);

                        if (blocking) {

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

                                park(Net.POLLIN);

                                n = receive(fd, bb, connected);

                            }

                        } else if (n == IOStatus.UNAVAILABLE) {

                            return null;

                        }

                        InetSocketAddress isa = (InetSocketAddress)sender;

                        try {

                            sm.checkAccept(isa.getAddress().getHostAddress(),

                                           isa.getPort());

                        } catch (SecurityException se) {

                            // Ignore packet

                            bb.clear();

                            n = 0;

                            continue;

                        }

                        bb.flip();

                        dst.put(bb);

                        break;

                    }

                }

                assert sender != null;

                return sender;

            } finally {

                if (bb != null)

                    Util.releaseTemporaryDirectBuffer(bb);

                endRead(blocking, n > 0);

                assert IOStatus.check(n);

            }

        } finally {

            readLock.unlock();

        }

    }

    private int receive(FileDescriptor fd, ByteBuffer dst, boolean connected)

        throws IOException

    {

        int pos = dst.position();

        int lim = dst.limit();

        assert (pos <= lim);

        int rem = (pos <= lim ? lim - pos : 0);

        if (dst instanceof DirectBuffer && rem > 0)

            return receiveIntoNativeBuffer(fd, dst, rem, pos, connected);

        // Substitute a native buffer. If the supplied buffer is empty

        // we must instead use a nonempty buffer, otherwise the call

        // will not block waiting for a datagram on some platforms.

        int newSize = Math.max(rem, 1);

        ByteBuffer bb = Util.getTemporaryDirectBuffer(newSize);

        try {

            int n = receiveIntoNativeBuffer(fd, bb, newSize, 0, connected);

            bb.flip();

            if (n > 0 && rem > 0)

                dst.put(bb);