test/jdk/java/net/MulticastSocket/SetLoopbackOption.java

/*
 * Copyright (c) 2019, 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.
 *
 * 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.
 */

/*
 * @test
 * @bug 8233296
 * @summary Check that MulticastSocket::setOption and MulticastSocket::getOption
 *          return the correct result for StandardSocketOptions.IP_MULTICAST_LOOP.
 *          The test sets a DatagramSocketImplFactory and needs to run in /othervm
 *          mode.
 * @run testng/othervm SetLoopbackOption
 * @run testng/othervm -Djava.net.preferIPv4Stack=true SetLoopbackOption
 * @run testng/othervm -Djava.net.preferIPv6Addresses=true SetLoopbackOption
 */

import java.io.FileDescriptor;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.DatagramSocketImpl;
import java.net.DatagramSocketImplFactory;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.SocketOption;
import java.net.SocketOptions;
import java.net.StandardSocketOptions;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.testng.annotations.Test;
import static org.testng.Assert.*;

import static java.lang.System.out;

public class SetLoopbackOption {

    final InetAddress loopbackAddress = InetAddress.getLoopbackAddress();

    @Test
    public void run() throws Exception {
        var bindAddress = new InetSocketAddress(loopbackAddress, 0);
        try (MulticastSocket sock = new MulticastSocket(null)) {
            out.println("Testing unbound socket");
            test(sock, null);
            out.printf("\nBinding socket to %s and testing again%n", bindAddress);
            sock.bind(bindAddress);
            test(sock, null);
        }
        TestDatagramSocketImplFactory factory = new TestDatagramSocketImplFactory();
        DatagramSocket.setDatagramSocketImplFactory(factory);
        try (MulticastSocket sock = new MulticastSocket(null)) {
            out.println("\nTesting unbound socket with custom impl");
            TestDatagramSocketImpl impl = factory.last;
            test(sock, impl);
            out.printf("\nBinding socket to %s and testing again%n", bindAddress);
            sock.bind(new InetSocketAddress(loopbackAddress, 0));
            test(sock, impl);
        }
    }

    private void test(MulticastSocket sock, TestDatagramSocketImpl impl) throws Exception {
        out.println("Testing with " + sock.getClass() + (impl == null ? "" : ", " + impl.getClass()));
        var op = StandardSocketOptions.IP_MULTICAST_LOOP;
        var opId = SocketOptions.IP_MULTICAST_LOOP;
        boolean enable = sock.getOption(op);
        assertTrue(enable, "Initial Value for " + op);
        boolean disable = sock.getLoopbackMode();
        assertFalse(disable, "Initial Value for getLoopbackMode()");
        if (impl != null) {
            assertFalse((Boolean)impl.getOption(opId));
            assertTrue((Boolean)impl.getOption(op));
        }

        out.println("Setting " + op + " to " + false);
        if (impl != null) {
            // allows setOption(SocketOption, Object) to be called
            impl.allowAllSetOptions(true);
        }
        sock.setOption(op, false);
        enable = sock.getOption(op);
        assertFalse(enable, "Value for " + op);
        disable = sock.getLoopbackMode();
        assertTrue(disable, "Value for getLoopbackMode()");
        if (impl != null) {
            assertTrue((Boolean)impl.getOption(opId));
            assertFalse((Boolean)impl.getOption(op));
        }
        out.println("Setting " + op + " to " + true);
        sock.setOption(op, true);
        enable = sock.getOption(op);
        assertTrue(enable, "Value for " + op);
        disable = sock.getLoopbackMode();
        assertFalse(disable, "Value for getLoopbackMode()");
        if (impl != null) {
            assertFalse((Boolean)impl.getOption(opId));
            assertTrue((Boolean)impl.getOption(op));
        }

        out.println("Calling setLoopbackMode(true)");
        if (impl != null) {
            // for backward compatibility reason, setLoopbackMode
            // should call setOption(int, Object), not setOption(SocketOption, Object)
            // Make sure that an exception is thrown if the latter is ever called.
            impl.allowAllSetOptions(false);
        }
        sock.setLoopbackMode(true);
        enable = sock.getOption(op);
        assertFalse(enable, "Value for " + op);
        disable = sock.getLoopbackMode();
        assertTrue(disable, "Value for getLoopbackMode()");
        if (impl != null) {
            assertTrue((Boolean)impl.getOption(opId));
            assertFalse((Boolean)impl.getOption(op));
        }
        out.println("Calling setLoopbackMode(false)");
        sock.setLoopbackMode(false);
        enable = sock.getOption(op);
        assertTrue(enable, "Value for " + op);
        disable = sock.getLoopbackMode();
        assertFalse(disable, "Value for getLoopbackMode()");
        if (impl != null) {
            assertFalse((Boolean)impl.getOption(opId));
            assertTrue((Boolean)impl.getOption(op));
        }
    }

    // Used to attempt to control what is called/passed to the impl.
    static class TestDatagramSocketImplFactory implements DatagramSocketImplFactory {
        TestDatagramSocketImpl last;
        public synchronized DatagramSocketImpl createDatagramSocketImpl() {
            TestDatagramSocketImpl last = this.last;
            if (last == null) {
                return (last = this.last = new TestDatagramSocketImpl());
            } else {
                throw new AssertionError("Only one instance should be created");
            }
        }
    }

    // Used to attempt to control what is called/passed to the impl.
    static class TestDatagramSocketImpl extends DatagramSocketImpl {
        InetAddress address;
        private boolean allowAllSetOptions;

        @Override
        protected void create() throws SocketException {
            legacyOptions.put(SocketOptions.IP_MULTICAST_LOOP, false);
            options.put(StandardSocketOptions.IP_MULTICAST_LOOP, true);
        }

        final Map<Integer, Object> legacyOptions = new HashMap<>();
        final Map<SocketOption<?>, Object> options = new HashMap<>();

        static <T> T shouldNotComeHere() {
            throw new AssertionError("should not come here");
        }

        @Override
        protected void bind(int lport, InetAddress laddr) throws SocketException {
            this.localPort = (lport == 0 ? 6789 : lport);
            this.address = laddr;
        }

        @Override
        protected void send(DatagramPacket p) throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected int peek(InetAddress i) throws IOException {
            return shouldNotComeHere();
        }

        @Override
        protected int peekData(DatagramPacket p) throws IOException {
            return shouldNotComeHere();
        }

        @Override
        protected void receive(DatagramPacket p) throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected void setTTL(byte ttl) throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected byte getTTL() throws IOException {
            return shouldNotComeHere();
        }

        @Override
        protected void setTimeToLive(int ttl) throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected int getTimeToLive() throws IOException {
            return shouldNotComeHere();
        }

        @Override
        protected void join(InetAddress inetaddr) throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected void leave(InetAddress inetaddr) throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected void joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)
                throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected void leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)
                throws IOException {
            shouldNotComeHere();
        }

        @Override
        protected void close() {

        }

        @Override
        public void setOption(int optID, Object value) throws SocketException {
            legacyOptions.put(optID, value);
            if (optID == SocketOptions.IP_MULTICAST_LOOP) {
                boolean disable = (Boolean) value;
                options.put(StandardSocketOptions.IP_MULTICAST_LOOP, !disable);
            }
        }

        @Override
        public Object getOption(int optID) throws SocketException {
            return legacyOptions.get(optID);
        }

        @Override
        protected Set<SocketOption<?>> supportedOptions() {
            return Set.of(StandardSocketOptions.IP_MULTICAST_LOOP);
        }

        @Override
        protected void connect(InetAddress address, int port) throws SocketException {
            shouldNotComeHere();
        }

        @Override
        protected void disconnect() {
            shouldNotComeHere();
        }

        @Override
        protected FileDescriptor getFileDescriptor() {
            return super.getFileDescriptor();
        }

        @Override
        protected <T> void setOption(SocketOption<T> name, T value) throws IOException {
            if (!allowAllSetOptions) shouldNotComeHere();
            options.put(name, value);
            if (name.equals(StandardSocketOptions.IP_MULTICAST_LOOP)) {
                boolean enable = (Boolean)value;
                legacyOptions.put(SocketOptions.IP_MULTICAST_LOOP, !enable);
            }
        }

        @Override
        protected <T> T getOption(SocketOption<T> name) throws IOException {
            return (T) options.get(name);
        }

        public void allowAllSetOptions(boolean allow) {
            this.allowAllSetOptions = allow;
        }
    }

    public static void main (String args[]) throws Exception {
        new SetLoopbackOption().run();
    }
}