/*

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

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

    // true if interruptible (can be false to emulate legacy DatagramSocket)

    private final boolean interruptible;

    // The protocol family of the socket

    private final ProtocolFamily family;

    // Our file descriptor

    private final FileDescriptor fd;

    private final int fdVal;

    // Native sockaddrs and cached InetSocketAddress for receive, protected by readLock

    private NativeSocketAddress sourceSockAddr;

    private NativeSocketAddress cachedSockAddr;

    private InetSocketAddress cachedInetSocketAddress;

    // Native sockaddr and cached objects for send, protected by writeLock

    private final NativeSocketAddress targetSockAddr;

    private InetSocketAddress previousTarget;

    private int previousSockAddrLength;

    // Cleaner to close file descriptor and free native socket address

    private final Cleanable cleaner;

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

    DatagramChannelImpl(SelectorProvider sp, boolean interruptible) throws IOException {

        this(sp, (Net.isIPv6Available()

                ? StandardProtocolFamily.INET6

                : StandardProtocolFamily.INET),

                interruptible);

    }

    DatagramChannelImpl(SelectorProvider sp, ProtocolFamily family, boolean interruptible)

        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 && !Net.isIPv6Available()) {

            throw new UnsupportedOperationException("IPv6 not available");

        }

        FileDescriptor fd = null;

        NativeSocketAddress[] sockAddrs = null;

        ResourceManager.beforeUdpCreate();

        boolean initialized = false;

        try {

            this.interruptible = interruptible;

            this.family = family;

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

            this.fdVal = IOUtil.fdVal(fd);

            sockAddrs = NativeSocketAddress.allocate(3);

            readLock.lock();

            try {

                this.sourceSockAddr = sockAddrs[0];

                this.cachedSockAddr = sockAddrs[1];

            } finally {

                readLock.unlock();

            }

            this.targetSockAddr = sockAddrs[2];

            initialized = true;

        } finally {

            if (!initialized) {

                if (sockAddrs != null) NativeSocketAddress.freeAll(sockAddrs);

                if (fd != null) nd.close(fd);

                ResourceManager.afterUdpClose();

            }

        }

        Runnable releaser = releaserFor(fd, sockAddrs);

        this.cleaner = CleanerFactory.cleaner().register(this, releaser);

    }

    DatagramChannelImpl(SelectorProvider sp, FileDescriptor fd)

        throws IOException

    {

        super(sp);

        NativeSocketAddress[] sockAddrs = null;

        ResourceManager.beforeUdpCreate();

        boolean initialized = false;

        try {

            this.interruptible = true;

            this.family = Net.isIPv6Available()

                    ? StandardProtocolFamily.INET6

                    : StandardProtocolFamily.INET;

            this.fd = fd;

            this.fdVal = IOUtil.fdVal(fd);

            sockAddrs = NativeSocketAddress.allocate(3);

            readLock.lock();

            try {

                this.sourceSockAddr = sockAddrs[0];

                this.cachedSockAddr = sockAddrs[1];

            } finally {

                readLock.unlock();

            }

            this.targetSockAddr = sockAddrs[2];

            initialized = true;

        } finally {

            if (!initialized) {

                if (sockAddrs != null) NativeSocketAddress.freeAll(sockAddrs);

                nd.close(fd);

                ResourceManager.afterUdpClose();

            }

        }

        Runnable releaser = releaserFor(fd, sockAddrs);

        this.cleaner = CleanerFactory.cleaner().register(this, releaser);

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

            // Some platforms require both IPV6_XXX and IP_XXX socket options to

            // be set when the channel's socket is IPv6 and it is used to send

            // IPv4 multicast datagrams. The IP_XXX socket options are set on a

            // best effort basis.

            boolean needToSetIPv4Option = (family != Net.UNSPEC)

                    && (this.family == StandardProtocolFamily.INET6)

                    && Net.shouldSetBothIPv4AndIPv6Options();

            // outgoing multicast interface

            if (name == StandardSocketOptions.IP_MULTICAST_IF) {

                assert family != Net.UNSPEC;

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

                }

                if (family == StandardProtocolFamily.INET || needToSetIPv4Option) {

                    // need IPv4 address to identify interface

                    Inet4Address target = Net.anyInet4Address(interf);

                    if (target != null) {

                        try {

                            Net.setInterface4(fd, Net.inet4AsInt(target));

                        } catch (IOException ioe) {

                            if (family == StandardProtocolFamily.INET) throw ioe;

                        }

                    } else if (family == StandardProtocolFamily.INET) {

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

                    }

                }

                return this;

            }

            // SO_REUSEADDR needs special handling as it may be emulated

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

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

                try {

                    Net.setSocketOption(fd, StandardProtocolFamily.INET, name, value);

                } catch (IOException ignore) { }

            }

            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 && interruptible) {

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

                }

            }

            if (interruptible) {

                // remove hook for Thread.interrupt (may throw AsynchronousCloseException)

                end(completed);

            } else if (!completed && !isOpen()) {

                throw new AsynchronousCloseException();

            }

        }

    }

    @Override

    public SocketAddress receive(ByteBuffer dst) throws IOException {

        if (dst.isReadOnly())

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

        readLock.lock();

        try {

            boolean blocking = isBlocking();

            SocketAddress sender = null;

            try {

                SocketAddress remote = beginRead(blocking, false);

                boolean connected = (remote != null);

                @SuppressWarnings("removal")

                SecurityManager sm = System.getSecurityManager();

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

                    // connected or no security manager

                    int n = receive(dst, connected);

                    if (blocking) {

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

                            park(Net.POLLIN);

                            n = receive(dst, connected);

                        }

                    }

                    if (n >= 0) {

                        // sender address is in socket address buffer

                        sender = sourceSocketAddress();

                    }

                } else {

                    // security manager and unconnected

                    sender = untrustedReceive(dst);

                }

                return sender;

            } finally {

                endRead(blocking, (sender != null));

            }

        } finally {

            readLock.unlock();

        }

    }

    /**

     * Receives a datagram into an untrusted buffer. When there is a security

     * manager set, and the socket is not connected, datagrams have to be received

     * into a buffer that is not accessible to the user. The datagram is copied

     * into the user's buffer when the sender address is accepted by the security

     * manager.

     */

    private SocketAddress untrustedReceive(ByteBuffer dst) throws IOException {

        @SuppressWarnings("removal")

        SecurityManager sm = System.getSecurityManager();

        assert readLock.isHeldByCurrentThread()

                && sm != null && remoteAddress == null;

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

        try {

            boolean blocking = isBlocking();

            for (;;) {

                int n = receive(bb, false);

                if (blocking) {

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

                        park(Net.POLLIN);

                        n = receive(bb, false);

                    }

                }

                if (n >= 0) {

                    // sender address is in socket address buffer

                    InetSocketAddress isa = sourceSocketAddress();

                    try {

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

                        bb.flip();

                        dst.put(bb);

                        return isa;

                    } catch (SecurityException se) {

                        // ignore datagram

                        bb.clear();

                    }

                } else {

                    return null;

                }

            }

        } finally {

            Util.releaseTemporaryDirectBuffer(bb);

        }

    }

    /**

     * Receives a datagram into the given buffer.

     *

     * @apiNote This method is for use by the socket adaptor. The buffer is

     * assumed to be trusted, meaning it is not accessible to user code.

     *

     * @throws IllegalBlockingModeException if the channel is non-blocking

     * @throws SocketTimeoutException if the timeout elapses

     */

    SocketAddress blockingReceive(ByteBuffer dst, long nanos) throws IOException {

        readLock.lock();

        try {

            ensureOpen();

            if (!isBlocking())

                throw new IllegalBlockingModeException();

            @SuppressWarnings("removal")

            SecurityManager sm = System.getSecurityManager();

            boolean connected = isConnected();

            SocketAddress sender;

            do {

                if (nanos > 0) {

                    sender = trustedBlockingReceive(dst, nanos);

                } else {

                    sender = trustedBlockingReceive(dst);

                }

                // check sender when security manager set and not connected

                if (sm != null && !connected) {

                    InetSocketAddress isa = (InetSocketAddress) sender;

                    try {

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

                    } catch (SecurityException e) {

                        sender = null;

                    }

                }

            } while (sender == null);

            return sender;

        } finally {

            readLock.unlock();

        }

    }

    /**

     * Receives a datagram into given buffer. This method is used to support

     * the socket adaptor. The buffer is assumed to be trusted.

     * @throws SocketTimeoutException if the timeout elapses

     */

    private SocketAddress trustedBlockingReceive(ByteBuffer dst)

        throws IOException

    {

        assert readLock.isHeldByCurrentThread() && isBlocking();

        SocketAddress sender = null;

        try {

            SocketAddress remote = beginRead(true, false);

            boolean connected = (remote != null);

            int n = receive(dst, connected);

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

                park(Net.POLLIN);

                n = receive(dst, connected);

            }

            if (n >= 0) {

                // sender address is in socket address buffer

                sender = sourceSocketAddress();

            }

            return sender;

        } finally {

            endRead(true, (sender != null));

        }

    }

    /**

     * Receives a datagram into given buffer with a timeout. This method is

     * used to support the socket adaptor. The buffer is assumed to be trusted.

     * @throws SocketTimeoutException if the timeout elapses

     */

    private SocketAddress trustedBlockingReceive(ByteBuffer dst, long nanos)

        throws IOException

    {

        assert readLock.isHeldByCurrentThread() && isBlocking();

        SocketAddress sender = null;

        try {

            SocketAddress remote = beginRead(true, false);

            boolean connected = (remote != null);

            // change socket to non-blocking

            lockedConfigureBlocking(false);

            try {

                long startNanos = System.nanoTime();

                int n = receive(dst, connected);

                while (n == IOStatus.UNAVAILABLE && isOpen()) {

                    long remainingNanos = nanos - (System.nanoTime() - startNanos);

                    if (remainingNanos <= 0) {

                        throw new SocketTimeoutException("Receive timed out");

                    }

                    park(Net.POLLIN, remainingNanos);

                    n = receive(dst, connected);

                }

                if (n >= 0) {

                    // sender address is in socket address buffer

                    sender = sourceSocketAddress();

                }

                return sender;

            } finally {

                // restore socket to blocking mode (if channel is open)

                tryLockedConfigureBlocking(true);

            }

        } finally {

            endRead(true, (sender != null));

        }

    }

    private int receive(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(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(bb, newSize, 0, connected);

            bb.flip();

            if (n > 0 && rem > 0)

                dst.put(bb);

            return n;

        } finally {

            Util.releaseTemporaryDirectBuffer(bb);

        }

    }

    private int receiveIntoNativeBuffer(ByteBuffer bb, int rem, int pos,

                                        boolean connected)

        throws IOException

    {

        int n = receive0(fd,

                         ((DirectBuffer)bb).address() + pos, rem,

                         sourceSockAddr.address(),

                         connected);

        if (n > 0)

            bb.position(pos + n);

        return n;

    }

    /**

     * Return an InetSocketAddress to represent the source/sender socket address

     * in sourceSockAddr. Returns the cached InetSocketAddress if the source

     * address is the same as the cached address.

     */

    private InetSocketAddress sourceSocketAddress() throws IOException {

        assert readLock.isHeldByCurrentThread();

        if (cachedInetSocketAddress != null && sourceSockAddr.equals(cachedSockAddr)) {

            return cachedInetSocketAddress;

        }

        InetSocketAddress isa = sourceSockAddr.decode();

        // swap sourceSockAddr and cachedSockAddr

        NativeSocketAddress tmp = cachedSockAddr;

        cachedSockAddr = sourceSockAddr;

        sourceSockAddr = tmp;

        cachedInetSocketAddress = isa;

        return isa;

    }

    @Override

    public int send(ByteBuffer src, SocketAddress target)

        throws IOException

    {

        Objects.requireNonNull(src);

        InetSocketAddress isa = Net.checkAddress(target, family);

        writeLock.lock();

        try {

            boolean blocking = isBlocking();

            int n;

            boolean completed = false;

            try {

                SocketAddress remote = beginWrite(blocking, false);

                if (remote != null) {

                    // connected

                    if (!target.equals(remote)) {

                        throw new AlreadyConnectedException();

                    }

                    n = IOUtil.write(fd, src, -1, nd);

                    if (blocking) {

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

                            park(Net.POLLOUT);

                            n = IOUtil.write(fd, src, -1, nd);

                        }

                    }

                    completed = (n > 0);

                } else {

                    // not connected

                    @SuppressWarnings("removal")

                    SecurityManager sm = System.getSecurityManager();

                    InetAddress ia = isa.getAddress();

                    if (sm != null) {

                        if (ia.isMulticastAddress()) {

                            sm.checkMulticast(ia);

                        } else {

                            sm.checkConnect(ia.getHostAddress(), isa.getPort());

                        }

                    }

                    if (ia.isLinkLocalAddress())

                        isa = IPAddressUtil.toScopedAddress(isa);

                    if (isa.getPort() == 0)

                        throw new SocketException("Can't send to port 0");

                    n = send(fd, src, isa);

                    if (blocking) {

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

                            park(Net.POLLOUT);

                            n = send(fd, src, isa);

                        }

                    }

                    completed = (n >= 0);

                }

            } finally {

                endWrite(blocking, completed);

            }

            assert n >= 0 || n == IOStatus.UNAVAILABLE;

            return IOStatus.normalize(n);

        } finally {

            writeLock.unlock();

        }

    }

    /**

     * Sends a datagram from the bytes in given buffer.

     *

     * @apiNote This method is for use by the socket adaptor.

     *

     * @throws IllegalBlockingModeException if the channel is non-blocking

     */

    void blockingSend(ByteBuffer src, SocketAddress target) throws IOException {

        writeLock.lock();

        try {

            ensureOpen();

            if (!isBlocking())

                throw new IllegalBlockingModeException();

            send(src, target);

        } finally {

            writeLock.unlock();

        }

    }

    private int send(FileDescriptor fd, ByteBuffer src, InetSocketAddress target)

        throws IOException

    {

        if (src instanceof DirectBuffer)

            return sendFromNativeBuffer(fd, src, target);

        // Substitute a native buffer

        int pos = src.position();

        int lim = src.limit();

        assert (pos <= lim);

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

        ByteBuffer bb = Util.getTemporaryDirectBuffer(rem);

        try {

            bb.put(src);

            bb.flip();

            // Do not update src until we see how many bytes were written

            src.position(pos);

            int n = sendFromNativeBuffer(fd, bb, target);

            if (n > 0) {

                // now update src

                src.position(pos + n);

            }

            return n;

        } finally {

            Util.releaseTemporaryDirectBuffer(bb);

        }

    }

    private int sendFromNativeBuffer(FileDescriptor fd, ByteBuffer bb,

                                     InetSocketAddress target)

        throws IOException

    {

        int pos = bb.position();

        int lim = bb.limit();

        assert (pos <= lim);

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

        int written;

        try {

            int addressLen = targetSocketAddress(target);

            written = send0(fd, ((DirectBuffer)bb).address() + pos, rem,

                            targetSockAddr.address(), addressLen);

        } catch (PortUnreachableException pue) {

            if (isConnected())

                throw pue;

            written = rem;

        }

        if (written > 0)

            bb.position(pos + written);

        return written;

    }

    /**

     * Encodes the given InetSocketAddress into targetSockAddr, returning the

     * length of the sockaddr structure (sizeof struct sockaddr or sockaddr6).

     */

    private int targetSocketAddress(InetSocketAddress isa) {

        assert writeLock.isHeldByCurrentThread();

        // Nothing to do if target address is already in the buffer. Use

        // identity rather than equals as Inet6Address.equals ignores scope_id.

        if (isa == previousTarget)

            return previousSockAddrLength;

        previousTarget = null;

        int len = targetSockAddr.encode(family, isa);

        previousTarget = isa;

        previousSockAddrLength = len;

        return len;

    }

    @Override

    public int read(ByteBuffer buf) throws IOException {

        Objects.requireNonNull(buf);

        readLock.lock();

        try {

            boolean blocking = isBlocking();

            int n = 0;

            try {

                beginRead(blocking, true);

                n = IOUtil.read(fd, buf, -1, nd);

                if (blocking) {

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

                        park(Net.POLLIN);

                        n = IOUtil.read(fd, buf, -1, nd);

                    }

                }

            } finally {

                endRead(blocking, n > 0);

                assert IOStatus.check(n);

            }

            return IOStatus.normalize(n);

        } finally {

            readLock.unlock();

        }

    }

    @Override

    public long read(ByteBuffer[] dsts, int offset, int length)

        throws IOException

    {

        Objects.checkFromIndexSize(offset, length, dsts.length);

        readLock.lock();

        try {

            boolean blocking = isBlocking();

            long n = 0;

            try {

                beginRead(blocking, true);

                n = IOUtil.read(fd, dsts, offset, length, nd);

                if (blocking) {

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

                        park(Net.POLLIN);

                        n = IOUtil.read(fd, dsts, offset, length, nd);

                    }

                }

            } finally {

                endRead(blocking, n > 0);

                assert IOStatus.check(n);

            }

            return IOStatus.normalize(n);

        } finally {

            readLock.unlock();

        }

    }

    /**

     * Marks the beginning of a write 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 beginWrite(boolean blocking, boolean mustBeConnected)

        throws IOException

    {

        if (blocking && interruptible) {

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

                writerThread = NativeThread.current();

        }

        return remote;

    }

    /**

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

     *

     * @throws AsynchronousCloseException if the channel was closed asynchronously

     */

    private void endWrite(boolean blocking, boolean completed)

        throws AsynchronousCloseException

    {

        if (blocking) {

            synchronized (stateLock) {

                writerThread = 0;

                if (state == ST_CLOSING) {

                    tryFinishClose();

                }

            }

            if (interruptible) {

                // remove hook for Thread.interrupt (may throw AsynchronousCloseException)

                end(completed);

            } else if (!completed && !isOpen()) {

                throw new AsynchronousCloseException();

            }

        }

    }

    @Override

    public int write(ByteBuffer buf) throws IOException {

        Objects.requireNonNull(buf);

        writeLock.lock();

        try {

            boolean blocking = isBlocking();

            int n = 0;

            try {

                beginWrite(blocking, true);

                n = IOUtil.write(fd, buf, -1, nd);

                if (blocking) {

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

                        park(Net.POLLOUT);

                        n = IOUtil.write(fd, buf, -1, nd);

                    }

                }

            } finally {

                endWrite(blocking, n > 0);

                assert IOStatus.check(n);

            }

            return IOStatus.normalize(n);

        } finally {

            writeLock.unlock();

        }

    }

    @Override

    public long write(ByteBuffer[] srcs, int offset, int length)

        throws IOException

    {

        Objects.checkFromIndexSize(offset, length, srcs.length);

        writeLock.lock();

        try {

            boolean blocking = isBlocking();

            long n = 0;

            try {

                beginWrite(blocking, true);

                n = IOUtil.write(fd, srcs, offset, length, nd);

                if (blocking) {

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

                        park(Net.POLLOUT);

                        n = IOUtil.write(fd, srcs, offset, length, nd);

                    }

                }

            } finally {

                endWrite(blocking, n > 0);

                assert IOStatus.check(n);

            }

            return IOStatus.normalize(n);

        } finally {

            writeLock.unlock();

        }

    }

    @Override

    protected void implConfigureBlocking(boolean block) throws IOException {

        readLock.lock();

        try {

            writeLock.lock();

            try {

                lockedConfigureBlocking(block);

            } finally {

                writeLock.unlock();

            }

        } finally {

            readLock.unlock();

        }

    }

    /**

     * Adjusts the blocking mode. readLock or writeLock must already be held.

     */

    private void lockedConfigureBlocking(boolean block) throws IOException {

        assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();

        synchronized (stateLock) {

            ensureOpen();

            IOUtil.configureBlocking(fd, block);

        }

    }

    /**

     * Adjusts the blocking mode if the channel is open. readLock or writeLock

     * must already be held.

     *

     * @return {@code true} if the blocking mode was adjusted, {@code false} if

     *         the blocking mode was not adjusted because the channel is closed

     */

    private boolean tryLockedConfigureBlocking(boolean block) throws IOException {

        assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();

        synchronized (stateLock) {

            if (isOpen()) {

                IOUtil.configureBlocking(fd, block);

                return true;

            } else {

                return false;

            }

        }

    }

    InetSocketAddress localAddress() {

        synchronized (stateLock) {

            return localAddress;

        }

    }

    InetSocketAddress remoteAddress() {

        synchronized (stateLock) {

            return remoteAddress;

        }

    }

    @Override

    public DatagramChannel bind(SocketAddress local) throws IOException {

        readLock.lock();

        try {

            writeLock.lock();

            try {

                synchronized (stateLock) {

                    ensureOpen();

                    if (localAddress != null)

                        throw new AlreadyBoundException();

                    bindInternal(local);

                }

            } finally {

                writeLock.unlock();

            }

        } finally {

            readLock.unlock();

        }

        return this;

    }

    private void bindInternal(SocketAddress local) throws IOException {

        assert Thread.holdsLock(stateLock )&& (localAddress == null);

        InetSocketAddress isa;

        if (local == null) {

            // only Inet4Address allowed with IPv4 socket

            if (family == StandardProtocolFamily.INET) {

                isa = new InetSocketAddress(InetAddress.getByName("0.0.0.0"), 0);

            } else {

                isa = new InetSocketAddress(0);

            }

        } else {

            isa = Net.checkAddress(local, family);

        }

        @SuppressWarnings("removal")

        SecurityManager sm = System.getSecurityManager();

        if (sm != null)

            sm.checkListen(isa.getPort());

        Net.bind(family, fd, isa.getAddress(), isa.getPort());

        localAddress = Net.localAddress(fd);

    }

    @Override

    public boolean isConnected() {

        synchronized (stateLock) {

            return (state == ST_CONNECTED);

        }

    }

    @Override

    public DatagramChannel connect(SocketAddress sa) throws IOException {

        return connect(sa, true);

    }

    /**

     * Connects the channel's socket.

     *

     * @param sa the remote address to which this channel is to be connected

     * @param check true to check if the channel is already connected.

     */

    DatagramChannel connect(SocketAddress sa, boolean check) throws IOException {

        InetSocketAddress isa = Net.checkAddress(sa, family);

        @SuppressWarnings("removal")

        SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            InetAddress ia = isa.getAddress();

            if (ia.isMulticastAddress()) {

                sm.checkMulticast(ia);

            } else {

                sm.checkConnect(ia.getHostAddress(), isa.getPort());

                sm.checkAccept(ia.getHostAddress(), isa.getPort());

            }

        }

        readLock.lock();

        try {

            writeLock.lock();

            try {

                synchronized (stateLock) {

                    ensureOpen();

                    if (check && state == ST_CONNECTED)

                        throw new AlreadyConnectedException();

                    if (isa.getPort() == 0)

                        throw new SocketException("Can't connect to port 0");

                    // ensure that the socket is bound

                    if (localAddress == null) {

                        bindInternal(null);

                    }

                    // capture local address before connect

                    initialLocalAddress = localAddress;

                    int n = Net.connect(family,

                                        fd,

                                        isa.getAddress(),

                                        isa.getPort());

                    if (n <= 0)

                        throw new Error();      // Can't happen

                    // connected

                    remoteAddress = isa;

                    state = ST_CONNECTED;

                    // refresh local address

                    localAddress = Net.localAddress(fd);

                    // flush any packets already received.

                    boolean blocking = isBlocking();

                    if (blocking) {

                        IOUtil.configureBlocking(fd, false);

                    }

                    try {

                        ByteBuffer buf = ByteBuffer.allocate(100);

                        while (receive(buf, false) >= 0) {

                            buf.clear();

                        }

                    } finally {

                        if (blocking) {

                            IOUtil.configureBlocking(fd, true);

                        }

                    }

                }

            } finally {

                writeLock.unlock();

            }

        } finally {

            readLock.unlock();

        }

        return this;

    }

    @Override

    public DatagramChannel disconnect() throws IOException {

        readLock.lock();

        try {

            writeLock.lock();

            try {

                synchronized (stateLock) {

                    if (!isOpen() || (state != ST_CONNECTED))

                        return this;

                    // disconnect socket

                    boolean isIPv6 = (family == StandardProtocolFamily.INET6);

                    disconnect0(fd, isIPv6);

                    // no longer connected

                    remoteAddress = null;

                    state = ST_UNCONNECTED;

                    // refresh localAddress, should be same as it was prior to connect

                    localAddress = Net.localAddress(fd);

                    try {

                        if (!localAddress.equals(initialLocalAddress)) {

                            // Workaround connect(2) issues on Linux and macOS

                            repairSocket(initialLocalAddress);

                            assert (localAddress != null)

                                    && localAddress.equals(Net.localAddress(fd))

                                    && localAddress.equals(initialLocalAddress);

                        }

                    } finally {

                        initialLocalAddress = null;

                    }

                }

            } finally {

                writeLock.unlock();

            }

        } finally {