--- /dev/null 2019-04-23 10:14:30.487678946 +0100 +++ new/test/jdk/java/net/MulticastSocket/PromiscuousIPv6.java 2019-05-14 16:04:55.684130531 +0100 @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2018, 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. + * + * 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 8215294 + * @requires os.family == "linux" + * @library /test/lib + * @build jdk.test.lib.NetworkConfiguration + * PromiscuousIPv6 + * @run main/othervm PromiscuousIPv6 + * @key randomness + */ + +import java.io.IOException; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetAddress; +import java.net.Inet6Address; +import java.net.InetSocketAddress; +import java.net.MulticastSocket; +import java.net.NetworkInterface; +import java.net.SocketTimeoutException; +import java.net.StandardSocketOptions; +import java.util.List; +import java.util.Random; +import jdk.test.lib.NetworkConfiguration; +import jtreg.SkippedException; +import static java.lang.System.out; +import static java.nio.charset.StandardCharsets.UTF_8; +import static java.util.stream.Collectors.toList; + +/* + * This test was created as a clone of the Promiscuous test and adapted for + * IPv6 node-local and link-local multicast addresses on Linux. + */ +public class PromiscuousIPv6 { + + static final Random rand = new Random(); + + static final int TIMEOUT = 5 * 1000; // 5 secs + + static int sendDatagram(NetworkInterface nif, InetAddress group, int port) + throws IOException + { + try (MulticastSocket mc = new MulticastSocket()) { + mc.setOption(StandardSocketOptions.IP_MULTICAST_IF, nif); + + int id = rand.nextInt(); + byte[] msg = Integer.toString(id).getBytes(UTF_8); + DatagramPacket p = new DatagramPacket(msg, msg.length); + p.setAddress(group); + p.setPort(port); + + out.printf("Sending datagram to: %s/%d\n", group, port); + mc.send(p); + return id; + } + } + + static void receiveDatagram(DatagramSocket mc, boolean datagramExpected, int id) + throws IOException + { + byte[] ba = new byte[100]; + DatagramPacket p = new DatagramPacket(ba, ba.length); + try { + mc.receive(p); + int recvId = Integer.parseInt( + new String(p.getData(), 0, p.getLength(), UTF_8)); + if (datagramExpected) { + if (recvId != id) + throw new RuntimeException("Unexpected id, got " + recvId + + ", expected: " + id); + out.printf("Received message as expected, %s\n", p.getAddress()); + } else { + throw new RuntimeException("Unexpected message received, " + + p.getAddress()); + } + } catch (SocketTimeoutException e) { + if (datagramExpected) + throw new RuntimeException("Expected message not received, " + + e.getMessage()); + else + out.printf("Message not received, as expected\n"); + } + } + + static void test(NetworkInterface nif, InetAddress group1, InetAddress group2) + throws IOException + { + // Bind addresses should include the same network interface / scope, so + // as to not reply on the default route when there are multiple interfaces + InetAddress bindAddr1 = Inet6Address.getByAddress(null, group1.getAddress(), nif); + InetAddress bindAddr2 = Inet6Address.getByAddress(null, group2.getAddress(), nif); + + try (MulticastSocket mc1 = new MulticastSocket(new InetSocketAddress(bindAddr1, 0)); + MulticastSocket mc2 = new MulticastSocket(new InetSocketAddress(bindAddr2, mc1.getLocalPort()))) { + + final int port = mc1.getLocalPort(); + out.printf("Using port: %d\n", port); + + mc1.setSoTimeout(TIMEOUT); + mc2.setSoTimeout(TIMEOUT); + + mc1.joinGroup(new InetSocketAddress(group1, 0), nif); + out.printf("mc1 joined the MC group: %s\n", group1); + mc2.joinGroup(new InetSocketAddress(group2, 0), nif); + out.printf("mc2 joined the MC group: %s\n", group2); + + out.printf("Sending datagram to: %s/%d\n", group1, port); + int id = sendDatagram(nif, group1, port); + + // the packet should be received by mc1 only + receiveDatagram(mc1, true, id); + receiveDatagram(mc2, false, 0); + + + out.printf("Sending datagram to: %s/%d\n", group2, port); + id = sendDatagram(nif, group2, port); + + // the packet should be received by mc2 only + receiveDatagram(mc2, true, id); + receiveDatagram(mc1, false, 0); + + mc1.leaveGroup(new InetSocketAddress(group1, 0), nif); + mc2.leaveGroup(new InetSocketAddress(group2, 0), nif); + } + } + + public static void main(String args[]) throws IOException { + String os = System.getProperty("os.name"); + + if (!os.equals("Linux")) { + throw new SkippedException("This test should be run only on Linux"); + } else { + String osVersion = System.getProperty("os.version"); + String prefix = "3.10.0"; + if (osVersion.startsWith(prefix)) { + throw new SkippedException( + String.format("The behavior under test is known NOT to work on '%s' kernels", prefix)); + } + } + + NetworkConfiguration.printSystemConfiguration(System.out); + List nifs = NetworkConfiguration.probe() + .ip6MulticastInterfaces() + .collect(toList()); + + if (nifs.size() == 0) { + throw new SkippedException( + "No IPv6 interfaces that support multicast found"); + } + + InetAddress interfaceLocal1 = InetAddress.getByName("ff11::3.4.5.6"); + InetAddress interfaceLocal2 = InetAddress.getByName("ff11::5.6.7.8"); + + InetAddress linkLocal1 = InetAddress.getByName("ff12::4.5.6.7"); + InetAddress linkLocal2 = InetAddress.getByName("ff12::7.8.9.10"); + + for (NetworkInterface nif : nifs) { + test(nif, interfaceLocal1, interfaceLocal2); + test(nif, linkLocal1, linkLocal2); + } + } +}