1 /* 2 * Copyright (c) 2014, 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 8032808 8044773 27 * @modules jdk.net 28 * @library /test/lib 29 * @build jdk.test.lib.OSVersion jdk.test.lib.Platform 30 * @run main/othervm -Xcheck:jni Test success 31 * @run main/othervm/policy=policy.fail -Xcheck:jni Test fail 32 * @run main/othervm/policy=policy.success -Xcheck:jni Test success 33 */ 34 35 import jdk.net.SocketFlow; 36 import jdk.net.Sockets; 37 import jdk.test.lib.Platform; 38 import jdk.test.lib.OSVersion; 39 40 import java.io.IOException; 41 import java.net.*; 42 import java.nio.channels.AsynchronousSocketChannel; 43 import java.nio.channels.DatagramChannel; 44 import java.nio.channels.SocketChannel; 45 import java.util.concurrent.Future; 46 47 import static java.lang.System.out; 48 import static jdk.net.ExtendedSocketOptions.SO_FLOW_SLA; 49 50 public class Test { 51 52 interface Runner { void run() throws Exception; } 53 54 static boolean expectSuccess; 55 private static final boolean expectSupport = checkExpectedOptionSupport(); 56 57 public static void main(String[] args) throws Exception { 58 59 // quick check to see if supportedOptions() working before 60 // creating any sockets and libnet loaded 61 62 Sockets.supportedOptions(Socket.class); 63 64 expectSuccess = args[0].equals("success"); 65 66 // Main thing is to check for JNI problems 67 // Doesn't matter if currently setting the option with the loopback 68 // interface doesn't work 69 70 boolean sm = System.getSecurityManager() != null; 71 out.println("Security Manager enabled: " + sm); 72 out.println("Success expected: " + expectSuccess); 73 74 SocketFlow flowIn = SocketFlow.create() 75 .bandwidth(1000) 76 .priority(SocketFlow.HIGH_PRIORITY); 77 78 try (ServerSocket ss = new ServerSocket(0); 79 DatagramSocket dg = new DatagramSocket(0)) { 80 81 int tcp_port = ss.getLocalPort(); 82 final InetAddress loop = InetAddress.getLoopbackAddress(); 83 final InetSocketAddress loopad = new InetSocketAddress(loop, tcp_port); 84 85 final int udp_port = dg.getLocalPort(); 86 87 final Socket s = new Socket(loop, tcp_port); 88 final SocketChannel sc = SocketChannel.open(); 89 sc.connect(new InetSocketAddress(loop, tcp_port)); 90 91 doTest("Sockets.setOption Socket", () -> { 92 out.println(flowIn); 93 if (s.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) { 94 throw new RuntimeException("Unexpected supportedOptions()"); 95 } 96 Sockets.setOption(s, SO_FLOW_SLA, flowIn); 97 out.println(flowIn); 98 }); 99 100 doTest("Sockets.getOption Socket", () -> { 101 Sockets.getOption(s, SO_FLOW_SLA); 102 out.println(flowIn); 103 }); 104 105 doTest("Sockets.setOption SocketChannel", () -> { 106 if (sc.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) { 107 throw new RuntimeException("Unexpected supportedOptions()"); 108 } 109 sc.setOption(SO_FLOW_SLA, flowIn); 110 }); 111 doTest("Sockets.getOption SocketChannel", () -> 112 sc.getOption(SO_FLOW_SLA) 113 ); 114 doTest("Sockets.setOption DatagramSocket", () -> { 115 try (DatagramSocket dg1 = new DatagramSocket(0)) { 116 if (dg1.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) { 117 throw new RuntimeException("Unexpected supportedOptions()"); 118 } 119 120 dg1.connect(loop, udp_port); 121 Sockets.setOption(dg1, SO_FLOW_SLA, flowIn); 122 } 123 }); 124 doTest("Sockets.setOption DatagramSocket 2", () -> { 125 try (DatagramChannel dg2 = DatagramChannel.open()) { 126 if (dg2.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) { 127 throw new RuntimeException("Unexpected supportedOptions()"); 128 } 129 dg2.bind(new InetSocketAddress(loop, 0)); 130 dg2.connect(new InetSocketAddress(loop, udp_port)); 131 dg2.setOption(SO_FLOW_SLA, flowIn); 132 } 133 }); 134 doTest("Sockets.setOption MulticastSocket", () -> { 135 try (MulticastSocket mc1 = new MulticastSocket(0)) { 136 if (mc1.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) { 137 throw new RuntimeException("Unexpected supportedOptions()"); 138 } 139 mc1.connect(loop, udp_port); 140 Sockets.setOption(mc1, SO_FLOW_SLA, flowIn); 141 } 142 }); 143 doTest("Sockets.setOption AsynchronousSocketChannel", () -> { 144 try (AsynchronousSocketChannel asc = AsynchronousSocketChannel.open()) { 145 if (asc.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) { 146 throw new RuntimeException("Unexpected supportedOptions()"); 147 } 148 Future<Void> f = asc.connect(loopad); 149 f.get(); 150 asc.setOption(SO_FLOW_SLA, flowIn); 151 } 152 }); 153 } 154 } 155 156 static void doTest(String message, Runner func) throws Exception { 157 out.println(message); 158 try { 159 func.run(); 160 if (expectSuccess) { 161 out.println("Completed as expected"); 162 } else { 163 throw new RuntimeException("Operation succeeded, but expected SecurityException"); 164 } 165 } catch (SecurityException e) { 166 if (expectSuccess) { 167 throw new RuntimeException("Unexpected SecurityException", e); 168 } else { 169 out.println("Caught expected: " + e); 170 return; 171 } 172 } catch (UnsupportedOperationException e) { 173 if (expectSupport) { 174 throw new RuntimeException("Test failed: " + 175 "unexpected UnsupportedOperationException"); 176 } 177 out.println("UnsupportedOperationException as expected"); 178 return; 179 } catch (IOException e) { 180 // Probably a permission error, but we're not 181 // going to check unless a specific permission exception 182 // is defined. 183 System.out.println(e); 184 } 185 if (!expectSupport) { 186 throw new RuntimeException("Test failed: " + 187 "UnsupportedOperationException was not thrown"); 188 } 189 } 190 191 private static boolean checkExpectedOptionSupport() { 192 System.out.println("SO_FLOW_SLA should not be supported"); 193 return false; 194 } 195 196 }