/*

 * Copyright (c) 2001, 2018, 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.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.UnsupportedAddressTypeException;

import java.nio.channels.spi.SelectorProvider;

import java.util.Collections;

import java.util.HashSet;

import java.util.Set;

import java.util.concurrent.locks.ReentrantLock;

import sun.net.ResourceManager;

import sun.net.ext.ExtendedSocketOptions;

/**

 * An implementation of DatagramChannels.

 */

class DatagramChannelImpl

    extends DatagramChannel

    implements SelChImpl

{

    // Used to make native read and write calls

    private static NativeDispatcher nd = new DatagramDispatcher();

    // Our file descriptor

    private final FileDescriptor fd;

    private final int fdVal;

    // The protocol family of the socket

    private final ProtocolFamily family;

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

    private volatile long readerThread;

    private volatile long writerThread;

    // 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_UNINITIALIZED = -1;

    private static final int ST_UNCONNECTED = 0;

    private static final int ST_CONNECTED = 1;

    private static final int ST_KILLED = 2;

    private int state = ST_UNINITIALIZED;

    // Binding

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

            this.state = ST_UNCONNECTED;

        } catch (IOException ioe) {

            ResourceManager.afterUdpClose();

            throw ioe;

        }

    }

    public DatagramChannelImpl(SelectorProvider sp, ProtocolFamily family)

        throws IOException

    {

        super(sp);

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

            (family != StandardProtocolFamily.INET6))

        {

            if (family == null)

                throw new NullPointerException("'family' is null");

            else

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

        }

        if (family == StandardProtocolFamily.INET6) {

            if (!Net.isIPv6Available()) {

                throw new UnsupportedOperationException("IPv6 not available");

            }

        }

    }

    public DatagramChannelImpl(SelectorProvider sp, FileDescriptor fd)

        throws IOException

    {

        super(sp);

        this.family = Net.isIPv6Available() ?

            StandardProtocolFamily.INET6 : StandardProtocolFamily.INET;

        this.fd = fd;

        this.fdVal = IOUtil.fdVal(fd);

        this.state = ST_UNCONNECTED;

        this.localAddress = Net.localAddress(fd);

    }

    public DatagramSocket socket() {

        synchronized (stateLock) {

            if (socket == null)

                socket = DatagramSocketAdaptor.create(this);

            return socket;

        }

    }

    @Override

    public SocketAddress getLocalAddress() throws IOException {

        synchronized (stateLock) {

            if (!isOpen())

                throw new ClosedChannelException();

            // Perform security check before returning address

            return Net.getRevealedLocalAddress(localAddress);

        }

    }

    @Override

    public SocketAddress getRemoteAddress() throws IOException {

        synchronized (stateLock) {

            if (!isOpen())

                throw new ClosedChannelException();

            return remoteAddress;

        }

    }

    @Override

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

        throws IOException

    {

        if (name == null)

            throw new NullPointerException();

        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)

            {

                // options are protocol dependent

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

                return this;

            }

            if (name == StandardSocketOptions.IP_MULTICAST_IF) {

                if (value == null)

                    throw new IllegalArgumentException("Cannot set IP_MULTICAST_IF to 'null'");

                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

    {

        if (name == null)

            throw new NullPointerException();

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

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

            ExtendedSocketOptions extendedOptions =

                    ExtendedSocketOptions.getInstance();

            set.addAll(extendedOptions.options());

            return Collections.unmodifiableSet(set);

        }

    }

    @Override

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

        return DefaultOptionsHolder.defaultOptions;

    }

    private void ensureOpen() throws ClosedChannelException {

        if (!isOpen())

            throw new ClosedChannelException();

    }

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

    public SocketAddress receive(ByteBuffer dst) throws IOException {

        if (dst.isReadOnly())

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

        readLock.lock();

        try {

            ensureOpen();

            // Socket was not bound before attempting receive

            if (localAddress() == null)

                bind(null);

            int n = 0;

            ByteBuffer bb = null;

            try {

                begin();

                if (!isOpen())

                    return null;

                SecurityManager security = System.getSecurityManager();

                readerThread = NativeThread.current();

                if (isConnected() || (security == null)) {

                    do {

                        n = receive(fd, dst);

                    } while ((n == IOStatus.INTERRUPTED) && isOpen());

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

                        do {

                            n = receive(fd, bb);

                        } while ((n == IOStatus.INTERRUPTED) && isOpen());

                        if (n == IOStatus.UNAVAILABLE)

                            return null;

                        InetSocketAddress isa = (InetSocketAddress)sender;

                        try {

                            security.checkAccept(

                                isa.getAddress().getHostAddress(),

                                isa.getPort());

                        } catch (SecurityException se) {

                            // Ignore packet

                            bb.clear();

                            n = 0;

                            continue;

                        }

                        bb.flip();

                        dst.put(bb);

                        break;

                    }

                }

                return sender;

            } finally {

                if (bb != null)

                    Util.releaseTemporaryDirectBuffer(bb);

                readerThread = 0;

                end((n > 0) || (n == IOStatus.UNAVAILABLE));

                assert IOStatus.check(n);

            }

        } finally {

            readLock.unlock();

        }

    }

    private int receive(FileDescriptor fd, ByteBuffer dst)

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

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

            bb.flip();

            if (n > 0 && rem > 0)

                dst.put(bb);

            return n;

        } finally {

            Util.releaseTemporaryDirectBuffer(bb);

        }

    }

    private int receiveIntoNativeBuffer(FileDescriptor fd, ByteBuffer bb,

                                        int rem, int pos)

        throws IOException

    {

        int n = receive0(fd, ((DirectBuffer)bb).address() + pos, rem,

                         isConnected());

        if (n > 0)

            bb.position(pos + n);

        return n;

    }

    public int send(ByteBuffer src, SocketAddress target)

        throws IOException

    {

        if (src == null)

            throw new NullPointerException();

        writeLock.lock();

        try {

            ensureOpen();

            InetSocketAddress isa = Net.checkAddress(target);

            InetAddress ia = isa.getAddress();

            if (ia == null)

                throw new IOException("Target address not resolved");

            synchronized (stateLock) {

                if (!isConnected()) {

                    if (target == null)

                        throw new NullPointerException();

                    SecurityManager sm = System.getSecurityManager();

                    if (sm != null) {

                        if (ia.isMulticastAddress()) {

                            sm.checkMulticast(ia);

                        } else {

                            sm.checkConnect(ia.getHostAddress(),

                                            isa.getPort());

                        }

                    }

                } else { // Connected case; Check address then write

                    if (!target.equals(remoteAddress)) {

                        throw new IllegalArgumentException(

                            "Connected address not equal to target address");

                    }

                    return write(src);

                }

            }

            int n = 0;

            try {

                begin();

                if (!isOpen())

                    return 0;

                writerThread = NativeThread.current();

                do {

                    n = send(fd, src, isa);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                synchronized (stateLock) {

                    if (isOpen() && (localAddress == null)) {

                        localAddress = Net.localAddress(fd);

                    }