1 /*
2 * Copyright (c) 2014, 2016, 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 /lib/testlibrary
29 * @build jdk.testlibrary.*
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.ExtendedSocketOptions;
36 import jdk.net.SocketFlow;
37 import jdk.net.Sockets;
38 import jdk.testlibrary.OSInfo;
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 private static final double solarisVersionToCheck = 11.2;
57
58 public static void main(String[] args) throws Exception {
59
60 // quick check to see if supportedOptions() working before
61 // creating any sockets and libnet loaded
62
63 Sockets.supportedOptions(Socket.class);
64
65 expectSuccess = args[0].equals("success");
66
67 // Main thing is to check for JNI problems
68 // Doesn't matter if currently setting the option with the loopback
69 // interface doesn't work
70
71 boolean sm = System.getSecurityManager() != null;
72 out.println("Security Manager enabled: " + sm);
73 out.println("Success expected: " + expectSuccess);
74
75 SocketFlow flowIn = SocketFlow.create()
76 .bandwidth(1000)
77 .priority(SocketFlow.HIGH_PRIORITY);
78
79 try (ServerSocket ss = new ServerSocket(0);
80 DatagramSocket dg = new DatagramSocket(0)) {
81
82 int tcp_port = ss.getLocalPort();
83 final InetAddress loop = InetAddress.getByName("127.0.0.1");
84 final InetSocketAddress loopad = new InetSocketAddress(loop, tcp_port);
85
86 final int udp_port = dg.getLocalPort();
87
88 final Socket s = new Socket("127.0.0.1", tcp_port);
89 final SocketChannel sc = SocketChannel.open();
90 sc.connect(new InetSocketAddress("127.0.0.1", tcp_port));
91
92 doTest("Sockets.setOption Socket", () -> {
93 out.println(flowIn);
94 if (s.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) {
95 throw new RuntimeException("Unexpected supportedOptions()");
96 }
97 Sockets.setOption(s, SO_FLOW_SLA, flowIn);
98 out.println(flowIn);
99 });
100
101 doTest("Sockets.getOption Socket", () -> {
102 Sockets.getOption(s, SO_FLOW_SLA);
103 out.println(flowIn);
104 });
105
106 doTest("Sockets.setOption SocketChannel", () -> {
107 if (sc.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) {
108 throw new RuntimeException("Unexpected supportedOptions()");
109 }
110 sc.setOption(SO_FLOW_SLA, flowIn);
111 });
112 doTest("Sockets.getOption SocketChannel", () ->
113 sc.getOption(SO_FLOW_SLA)
114 );
115 doTest("Sockets.setOption DatagramSocket", () -> {
116 try (DatagramSocket dg1 = new DatagramSocket(0)) {
117 if (dg1.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) {
118 throw new RuntimeException("Unexpected supportedOptions()");
119 }
120
121 dg1.connect(loop, udp_port);
122 Sockets.setOption(dg1, SO_FLOW_SLA, flowIn);
123 }
124 });
125 doTest("Sockets.setOption DatagramSocket 2", () -> {
126 try (DatagramChannel dg2 = DatagramChannel.open()) {
127 if (dg2.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) {
128 throw new RuntimeException("Unexpected supportedOptions()");
129 }
130 dg2.bind(new InetSocketAddress(loop, 0));
131 dg2.connect(new InetSocketAddress(loop, udp_port));
132 dg2.setOption(SO_FLOW_SLA, flowIn);
133 }
134 });
135 doTest("Sockets.setOption MulticastSocket", () -> {
136 try (MulticastSocket mc1 = new MulticastSocket(0)) {
137 if (mc1.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) {
138 throw new RuntimeException("Unexpected supportedOptions()");
139 }
140 mc1.connect(loop, udp_port);
141 Sockets.setOption(mc1, SO_FLOW_SLA, flowIn);
142 }
143 });
144 doTest("Sockets.setOption AsynchronousSocketChannel", () -> {
145 try (AsynchronousSocketChannel asc = AsynchronousSocketChannel.open()) {
146 if (asc.supportedOptions().contains(SO_FLOW_SLA) != expectSupport) {
147 throw new RuntimeException("Unexpected supportedOptions()");
148 }
149 Future<Void> f = asc.connect(loopad);
150 f.get();
151 asc.setOption(SO_FLOW_SLA, flowIn);
152 }
153 });
154 }
155 }
156
157 static void doTest(String message, Runner func) throws Exception {
158 out.println(message);
159 try {
160 func.run();
161 if (expectSuccess) {
162 out.println("Completed as expected");
163 } else {
164 throw new RuntimeException("Operation succeeded, but expected SecurityException");
165 }
166 } catch (SecurityException e) {
167 if (expectSuccess) {
168 throw new RuntimeException("Unexpected SecurityException", e);
169 } else {
170 out.println("Caught expected: " + e);
171 return;
172 }
173 } catch (UnsupportedOperationException e) {
174 if (expectSupport) {
175 throw new RuntimeException("Test failed: " +
176 "unexpected UnsupportedOperationException");
177 }
178 out.println("UnsupportedOperationException as expected");
179 return;
180 } catch (IOException e) {
181 // Probably a permission error, but we're not
182 // going to check unless a specific permission exception
183 // is defined.
184 System.out.println(e);
185 }
186 if (!expectSupport) {
187 throw new RuntimeException("Test failed: " +
188 "UnsupportedOperationException was not thrown");
189 }
190 }
191
192 private static boolean checkExpectedOptionSupport() {
193 if (OSInfo.getOSType().equals(OSInfo.OSType.SOLARIS)) {
194 double solarisVersion = OSInfo.getSolarisVersion();
195 if (solarisVersion >= solarisVersionToCheck) {
196 System.out.println("This Solaris version (" + solarisVersion
197 + ") should support SO_FLOW_SLA option");
198 return true;
199 } else {
200 System.out.println("This Solaris version (" + solarisVersion
201 + ") should not support SO_FLOW_SLA option");
202 }
203 } else {
204 System.out.println("Not Solaris, SO_FLOW_SLA should not be " +
205 "supported");
206 }
207 return false;
208 }
209
210 }