1 /* |
|
2 * Copyright (c) 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. Oracle designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Oracle in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 * or visit www.oracle.com if you need additional information or have any |
|
23 * questions. |
|
24 */ |
|
25 |
|
26 package jdk.net; |
|
27 |
|
28 import java.net.*; |
|
29 import java.io.IOException; |
|
30 import java.io.FileDescriptor; |
|
31 import java.security.PrivilegedAction; |
|
32 import java.security.AccessController; |
|
33 import java.lang.reflect.Field; |
|
34 import java.util.Set; |
|
35 import java.util.HashSet; |
|
36 import java.util.HashMap; |
|
37 import java.util.Collections; |
|
38 import sun.net.ExtendedOptionsImpl; |
|
39 |
|
40 /** |
|
41 * Defines static methods to set and get socket options defined by the |
|
42 * {@link java.net.SocketOption} interface. All of the standard options defined |
|
43 * by {@link java.net.Socket}, {@link java.net.ServerSocket}, and |
|
44 * {@link java.net.DatagramSocket} can be set this way, as well as additional |
|
45 * or platform specific options supported by each socket type. |
|
46 * <p> |
|
47 * The {@link #supportedOptions(Class)} method can be called to determine |
|
48 * the complete set of options available (per socket type) on the |
|
49 * current system. |
|
50 * <p> |
|
51 * When a security manager is installed, some non-standard socket options |
|
52 * may require a security permission before being set or get. |
|
53 * The details are specified in {@link ExtendedSocketOptions}. No permission |
|
54 * is required for {@link java.net.StandardSocketOptions}. |
|
55 * |
|
56 * @see java.nio.channels.NetworkChannel |
|
57 */ |
|
58 public class Sockets { |
|
59 |
|
60 private static final HashMap<Class<?>,Set<SocketOption<?>>> |
|
61 options = new HashMap<>(); |
|
62 |
|
63 static { |
|
64 initOptionSets(); |
|
65 } |
|
66 |
|
67 private Sockets() {} |
|
68 |
|
69 /** |
|
70 * Sets the value of a socket option on a {@link java.net.Socket} |
|
71 * |
|
72 * @param s the socket |
|
73 * @param name The socket option |
|
74 * @param value The value of the socket option. May be null for some |
|
75 * options. |
|
76 * |
|
77 * @throws UnsupportedOperationException if the socket does not support |
|
78 * the option. |
|
79 * |
|
80 * @throws IllegalArgumentException if the value is not valid for |
|
81 * the option. |
|
82 * |
|
83 * @throws IOException if an I/O error occurs, or socket is closed. |
|
84 * |
|
85 * @throws SecurityException if a security manager is set and the |
|
86 * caller does not have any required permission. |
|
87 * |
|
88 * @throws NullPointerException if name is null |
|
89 * |
|
90 * @see java.net.StandardSocketOptions |
|
91 */ |
|
92 public static <T> void setOption(Socket s, SocketOption<T> name, T value) throws IOException |
|
93 { |
|
94 s.setOption(name, value); |
|
95 } |
|
96 |
|
97 /** |
|
98 * Returns the value of a socket option from a {@link java.net.Socket} |
|
99 * |
|
100 * @param s the socket |
|
101 * @param name The socket option |
|
102 * |
|
103 * @return The value of the socket option. |
|
104 * |
|
105 * @throws UnsupportedOperationException if the socket does not support |
|
106 * the option. |
|
107 * |
|
108 * @throws IOException if an I/O error occurs |
|
109 * |
|
110 * @throws SecurityException if a security manager is set and the |
|
111 * caller does not have any required permission. |
|
112 * |
|
113 * @throws NullPointerException if name is null |
|
114 * |
|
115 * @see java.net.StandardSocketOptions |
|
116 */ |
|
117 public static <T> T getOption(Socket s, SocketOption<T> name) throws IOException |
|
118 { |
|
119 return s.getOption(name); |
|
120 } |
|
121 |
|
122 /** |
|
123 * Sets the value of a socket option on a {@link java.net.ServerSocket} |
|
124 * |
|
125 * @param s the socket |
|
126 * @param name The socket option |
|
127 * @param value The value of the socket option. |
|
128 * |
|
129 * @throws UnsupportedOperationException if the socket does not support |
|
130 * the option. |
|
131 * |
|
132 * @throws IllegalArgumentException if the value is not valid for |
|
133 * the option. |
|
134 * |
|
135 * @throws IOException if an I/O error occurs |
|
136 * |
|
137 * @throws NullPointerException if name is null |
|
138 * |
|
139 * @throws SecurityException if a security manager is set and the |
|
140 * caller does not have any required permission. |
|
141 * |
|
142 * @see java.net.StandardSocketOptions |
|
143 */ |
|
144 public static <T> void setOption(ServerSocket s, SocketOption<T> name, T value) throws IOException |
|
145 { |
|
146 s.setOption(name, value); |
|
147 } |
|
148 |
|
149 /** |
|
150 * Returns the value of a socket option from a {@link java.net.ServerSocket} |
|
151 * |
|
152 * @param s the socket |
|
153 * @param name The socket option |
|
154 * |
|
155 * @return The value of the socket option. |
|
156 * |
|
157 * @throws UnsupportedOperationException if the socket does not support |
|
158 * the option. |
|
159 * |
|
160 * @throws IOException if an I/O error occurs |
|
161 * |
|
162 * @throws NullPointerException if name is null |
|
163 * |
|
164 * @throws SecurityException if a security manager is set and the |
|
165 * caller does not have any required permission. |
|
166 * |
|
167 * @see java.net.StandardSocketOptions |
|
168 */ |
|
169 public static <T> T getOption(ServerSocket s, SocketOption<T> name) throws IOException |
|
170 { |
|
171 return s.getOption(name); |
|
172 } |
|
173 |
|
174 /** |
|
175 * Sets the value of a socket option on a {@link java.net.DatagramSocket} |
|
176 * or {@link java.net.MulticastSocket} |
|
177 * |
|
178 * @param s the socket |
|
179 * @param name The socket option |
|
180 * @param value The value of the socket option. |
|
181 * |
|
182 * @throws UnsupportedOperationException if the socket does not support |
|
183 * the option. |
|
184 * |
|
185 * @throws IllegalArgumentException if the value is not valid for |
|
186 * the option. |
|
187 * |
|
188 * @throws IOException if an I/O error occurs |
|
189 * |
|
190 * @throws NullPointerException if name is null |
|
191 * |
|
192 * @throws SecurityException if a security manager is set and the |
|
193 * caller does not have any required permission. |
|
194 * |
|
195 * @see java.net.StandardSocketOptions |
|
196 */ |
|
197 public static <T> void setOption(DatagramSocket s, SocketOption<T> name, T value) throws IOException |
|
198 { |
|
199 s.setOption(name, value); |
|
200 } |
|
201 |
|
202 /** |
|
203 * Returns the value of a socket option from a |
|
204 * {@link java.net.DatagramSocket} or {@link java.net.MulticastSocket} |
|
205 * |
|
206 * @param s the socket |
|
207 * @param name The socket option |
|
208 * |
|
209 * @return The value of the socket option. |
|
210 * |
|
211 * @throws UnsupportedOperationException if the socket does not support |
|
212 * the option. |
|
213 * |
|
214 * @throws IOException if an I/O error occurs |
|
215 * |
|
216 * @throws NullPointerException if name is null |
|
217 * |
|
218 * @throws SecurityException if a security manager is set and the |
|
219 * caller does not have any required permission. |
|
220 * |
|
221 * @see java.net.StandardSocketOptions |
|
222 */ |
|
223 public static <T> T getOption(DatagramSocket s, SocketOption<T> name) throws IOException |
|
224 { |
|
225 return s.getOption(name); |
|
226 } |
|
227 |
|
228 /** |
|
229 * Returns a set of {@link java.net.SocketOption}s supported by the |
|
230 * given socket type. This set may include standard options and also |
|
231 * non standard extended options. |
|
232 * |
|
233 * @param socketType the type of java.net socket |
|
234 * |
|
235 * @throws IllegalArgumentException if socketType is not a valid |
|
236 * socket type from the java.net package. |
|
237 */ |
|
238 public static Set<SocketOption<?>> supportedOptions(Class<?> socketType) { |
|
239 Set<SocketOption<?>> set = options.get(socketType); |
|
240 if (set == null) { |
|
241 throw new IllegalArgumentException("unknown socket type"); |
|
242 } |
|
243 return set; |
|
244 } |
|
245 |
|
246 private static void checkValueType(Object value, Class<?> type) { |
|
247 if (!type.isAssignableFrom(value.getClass())) { |
|
248 String s = "Found: " + value.getClass().toString() + " Expected: " |
|
249 + type.toString(); |
|
250 throw new IllegalArgumentException(s); |
|
251 } |
|
252 } |
|
253 |
|
254 private static volatile boolean checkedReusePort; |
|
255 private static volatile boolean isReusePortAvailable; |
|
256 |
|
257 /** |
|
258 * Tells whether SO_REUSEPORT is supported. |
|
259 */ |
|
260 static boolean isReusePortAvailable() { |
|
261 if (!checkedReusePort) { |
|
262 isReusePortAvailable = isReusePortAvailable0(); |
|
263 checkedReusePort = true; |
|
264 } |
|
265 return isReusePortAvailable; |
|
266 } |
|
267 |
|
268 private static void initOptionSets() { |
|
269 boolean flowsupported = ExtendedOptionsImpl.flowSupported(); |
|
270 boolean reuseportsupported = isReusePortAvailable(); |
|
271 // Socket |
|
272 |
|
273 Set<SocketOption<?>> set = new HashSet<>(); |
|
274 set.add(StandardSocketOptions.SO_KEEPALIVE); |
|
275 set.add(StandardSocketOptions.SO_SNDBUF); |
|
276 set.add(StandardSocketOptions.SO_RCVBUF); |
|
277 set.add(StandardSocketOptions.SO_REUSEADDR); |
|
278 if (reuseportsupported) { |
|
279 set.add(StandardSocketOptions.SO_REUSEPORT); |
|
280 } |
|
281 set.add(StandardSocketOptions.SO_LINGER); |
|
282 set.add(StandardSocketOptions.IP_TOS); |
|
283 set.add(StandardSocketOptions.TCP_NODELAY); |
|
284 if (flowsupported) { |
|
285 set.add(ExtendedSocketOptions.SO_FLOW_SLA); |
|
286 } |
|
287 set = Collections.unmodifiableSet(set); |
|
288 options.put(Socket.class, set); |
|
289 |
|
290 // ServerSocket |
|
291 |
|
292 set = new HashSet<>(); |
|
293 set.add(StandardSocketOptions.SO_RCVBUF); |
|
294 set.add(StandardSocketOptions.SO_REUSEADDR); |
|
295 if (reuseportsupported) { |
|
296 set.add(StandardSocketOptions.SO_REUSEPORT); |
|
297 } |
|
298 set.add(StandardSocketOptions.IP_TOS); |
|
299 set = Collections.unmodifiableSet(set); |
|
300 options.put(ServerSocket.class, set); |
|
301 |
|
302 // DatagramSocket |
|
303 |
|
304 set = new HashSet<>(); |
|
305 set.add(StandardSocketOptions.SO_SNDBUF); |
|
306 set.add(StandardSocketOptions.SO_RCVBUF); |
|
307 set.add(StandardSocketOptions.SO_REUSEADDR); |
|
308 if (reuseportsupported) { |
|
309 set.add(StandardSocketOptions.SO_REUSEPORT); |
|
310 } |
|
311 set.add(StandardSocketOptions.IP_TOS); |
|
312 if (flowsupported) { |
|
313 set.add(ExtendedSocketOptions.SO_FLOW_SLA); |
|
314 } |
|
315 set = Collections.unmodifiableSet(set); |
|
316 options.put(DatagramSocket.class, set); |
|
317 |
|
318 // MulticastSocket |
|
319 |
|
320 set = new HashSet<>(); |
|
321 set.add(StandardSocketOptions.SO_SNDBUF); |
|
322 set.add(StandardSocketOptions.SO_RCVBUF); |
|
323 set.add(StandardSocketOptions.SO_REUSEADDR); |
|
324 if (reuseportsupported) { |
|
325 set.add(StandardSocketOptions.SO_REUSEPORT); |
|
326 } |
|
327 set.add(StandardSocketOptions.IP_TOS); |
|
328 set.add(StandardSocketOptions.IP_MULTICAST_IF); |
|
329 set.add(StandardSocketOptions.IP_MULTICAST_TTL); |
|
330 set.add(StandardSocketOptions.IP_MULTICAST_LOOP); |
|
331 if (flowsupported) { |
|
332 set.add(ExtendedSocketOptions.SO_FLOW_SLA); |
|
333 } |
|
334 set = Collections.unmodifiableSet(set); |
|
335 options.put(MulticastSocket.class, set); |
|
336 } |
|
337 |
|
338 private static native boolean isReusePortAvailable0(); |
|
339 } |
|