* @bug 8231880 8231258

 * @summary Test DatagramChannel bound to specific address/ephemeral port after disconnect

 * @run testng/othervm AfterDisconnect

 * @run testng/othervm -Djava.net.preferIPv4Stack=true AfterDisconnect

 * @run testng/othervm -Djava.net.preferIPv6Addresses=true AfterDisconnect

import java.net.Inet6Address;

import java.net.NetworkInterface;

import java.net.SocketOption;

import java.net.StandardSocketOptions;

import java.nio.ByteBuffer;

import java.nio.channels.MembershipKey;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.util.HashMap;

import java.util.Map;

import static org.testng.Assert.*;

import jdk.test.lib.net.IPSupport;

public class AfterDisconnect {

        InetAddress lb = InetAddress.getLoopbackAddress();

            dc.bind(new InetSocketAddress(lb, 0));

        // test with IPv6 socket

            System.out.println("Test with IPv6 socket");

                dc.bind(new InetSocketAddress(lb, 0));

        // test with IPv4 socket

            System.out.println("Test with IPv4 socket");

                dc.bind(new InetSocketAddress(lb, 0));

    void test(DatagramChannel dc) throws IOException {

        testLocalAddress(dc);

        testSocketOptions(dc);

        testSelectorRegistration(dc);

        testMulticastGroups(dc);

    }

     * Test that disconnect restores local address

    void testLocalAddress(DatagramChannel dc) throws IOException {

            SocketAddress local = dc.getLocalAddress();

            assertEquals(dc.getLocalAddress(), local);

            assertEquals(dc.getRemoteAddress(), remote);

            assertEquals(dc.getLocalAddress(), local);

            assertTrue(dc.getRemoteAddress() == null);

    /**

     * Test that disconnect does not change socket options

     */

    void testSocketOptions(DatagramChannel dc) throws IOException {

        // set a few socket options

        dc.setOption(StandardSocketOptions.SO_SNDBUF, 32*1024);

        dc.setOption(StandardSocketOptions.SO_RCVBUF, 64*1024);

        InetAddress ia = dc.socket().getLocalAddress();

        NetworkInterface ni = NetworkInterface.getByInetAddress(ia);

        if (ni != null && ni.supportsMulticast())

            dc.setOption(StandardSocketOptions.IP_MULTICAST_IF, ni);

        // capture values of socket options

        Map<SocketOption<?>, Object> map = options(dc);

        dc.connect(dc.getLocalAddress());

        dc.disconnect();

        // check socket options have not changed

        assertEquals(map, options(dc));

    }

    /**

     * Returns a map of the given channel's socket options and values.

     */

    private Map<SocketOption<?>, Object> options(DatagramChannel dc) throws IOException {

        Map<SocketOption<?>, Object> map = new HashMap<>();

        for (SocketOption<?> option : dc.supportedOptions()) {

            try {

                Object value = dc.getOption(option);

                if (value != null) {

                    map.put(option, value);

                }

            } catch (IOException ignore) { }

        }

        return map;

    }

    /**

     * Test that disconnect does not interfere with Selector registrations

     */

    void testSelectorRegistration(DatagramChannel dc) throws IOException {

        try (Selector sel = Selector.open()) {

            dc.configureBlocking(false);

            SelectionKey key = dc.register(sel, SelectionKey.OP_READ);

            // ensure socket is registered

            sel.selectNow();

            dc.connect(dc.getLocalAddress());

            dc.disconnect();

            // selection key should still be valid

            assertTrue(key.isValid());

            // check blocking mode with non-blocking receive

            ByteBuffer bb = ByteBuffer.allocate(100);

            SocketAddress sender = dc.receive(bb);

            assertTrue(sender == null);

            // send datagram and ensure that channel is selected

            dc.send(ByteBuffer.wrap("Hello".getBytes("UTF-8")), dc.getLocalAddress());

            assertFalse(key.isReadable());

            while (sel.select() == 0);

            assertTrue(key.isReadable());

            sender = dc.receive(bb);

            assertEquals(sender, dc.getLocalAddress());

            // cancel key, flush from Selector, and restore blocking mode

            key.cancel();

            sel.selectNow();

            dc.configureBlocking(true);

        }

    }

    /**

     * Test that disconnect does not interfere with multicast group membership

     */

    void testMulticastGroups(DatagramChannel dc) throws IOException {

        InetAddress localAddress = dc.socket().getLocalAddress();

        InetAddress group;

        if (localAddress instanceof Inet6Address) {

            group = InetAddress.getByName("ff02::a");

        } else {

            group = InetAddress.getByName("225.4.5.6");

        }

        NetworkInterface ni = NetworkInterface.getByInetAddress(localAddress);

        if (ni != null && ni.supportsMulticast()) {

            // join group

            MembershipKey key = dc.join(group, ni);

            dc.connect(dc.getLocalAddress());

            dc.disconnect();

            // membership key should still be valid

            assertTrue(key.isValid());

            // send datagram to multicast group, should be received

            dc.send(ByteBuffer.wrap("Hello".getBytes("UTF-8")), dc.getLocalAddress());

            ByteBuffer bb = ByteBuffer.allocate(100);

            SocketAddress sender = dc.receive(bb);

            assertEquals(sender, dc.getLocalAddress());

            // drop membership

            key.drop();

        }

    }