1 /*
   2  * Copyright (c) 2016, 2018, 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.util.Collections;
  31 import java.util.HashMap;
  32 import java.util.HashSet;
  33 import java.util.Map;
  34 import java.util.Set;


  35 import jdk.net.ExtendedSocketOptions.PlatformSocketOptions;
  36 
  37 /**
  38  * Defines static methods to set and get socket options defined by the
  39  * {@link java.net.SocketOption} interface. All of the standard options defined
  40  * by {@link java.net.Socket}, {@link java.net.ServerSocket}, and
  41  * {@link java.net.DatagramSocket} can be set this way, as well as additional
  42  * or platform specific options supported by each socket type.
  43  * <p>
  44  * The {@link #supportedOptions(Class)} method can be called to determine
  45  * the complete set of options available (per socket type) on the
  46  * current system.
  47  * <p>
  48  * When a security manager is installed, some non-standard socket options
  49  * may require a security permission before being set or get.
  50  * The details are specified in {@link ExtendedSocketOptions}. No permission
  51  * is required for {@link java.net.StandardSocketOptions}.
  52  *
  53  * @see java.nio.channels.NetworkChannel
  54  */
  55 public class Sockets {
  56 
  57     private static final Map<Class<?>,Set<SocketOption<?>>>
  58             options = optionSets();
  59 
  60     private Sockets() {}
  61 
  62     /**
  63      * Sets the value of a socket option on a {@link java.net.Socket}
  64      *
  65      * @param s the socket
  66      * @param name The socket option
  67      * @param value The value of the socket option. May be null for some
  68      *              options.
  69      *
  70      * @throws UnsupportedOperationException if the socket does not support
  71      *         the option.
  72      *
  73      * @throws IllegalArgumentException if the value is not valid for
  74      *         the option.
  75      *
  76      * @throws IOException if an I/O error occurs, or socket is closed.
  77      *
  78      * @throws SecurityException if a security manager is set and the
  79      *         caller does not have any required permission.
  80      *
  81      * @throws NullPointerException if name is null
  82      *
  83      * @see java.net.StandardSocketOptions
  84      */
  85     public static <T> void setOption(Socket s, SocketOption<T> name, T value) throws IOException
  86     {
  87         s.setOption(name, value);
  88     }
  89 
  90     /**
  91      * Returns the value of a socket option from a {@link java.net.Socket}
  92      *
  93      * @param s the socket
  94      * @param name The socket option
  95      *
  96      * @return The value of the socket option.
  97      *
  98      * @throws UnsupportedOperationException if the socket does not support
  99      *         the option.
 100      *
 101      * @throws IOException if an I/O error occurs
 102      *
 103      * @throws SecurityException if a security manager is set and the
 104      *         caller does not have any required permission.
 105      *
 106      * @throws NullPointerException if name is null
 107      *
 108      * @see java.net.StandardSocketOptions
 109      */
 110     public static <T> T getOption(Socket s, SocketOption<T> name) throws IOException
 111     {
 112         return s.getOption(name);
 113     }
 114 
 115     /**
 116      * Sets the value of a socket option on a {@link java.net.ServerSocket}
 117      *
 118      * @param s the socket
 119      * @param name The socket option
 120      * @param value The value of the socket option.
 121      *
 122      * @throws UnsupportedOperationException if the socket does not support
 123      *         the option.
 124      *
 125      * @throws IllegalArgumentException if the value is not valid for
 126      *         the option.
 127      *
 128      * @throws IOException if an I/O error occurs
 129      *
 130      * @throws NullPointerException if name is null
 131      *
 132      * @throws SecurityException if a security manager is set and the
 133      *         caller does not have any required permission.
 134      *
 135      * @see java.net.StandardSocketOptions
 136      */
 137     public static <T> void setOption(ServerSocket s, SocketOption<T> name, T value) throws IOException
 138     {
 139         s.setOption(name, value);
 140     }
 141 
 142     /**
 143      * Returns the value of a socket option from a {@link java.net.ServerSocket}
 144      *
 145      * @param s the socket
 146      * @param name The socket option
 147      *
 148      * @return The value of the socket option.
 149      *
 150      * @throws UnsupportedOperationException if the socket does not support
 151      *         the option.
 152      *
 153      * @throws IOException if an I/O error occurs
 154      *
 155      * @throws NullPointerException if name is null
 156      *
 157      * @throws SecurityException if a security manager is set and the
 158      *         caller does not have any required permission.
 159      *
 160      * @see java.net.StandardSocketOptions
 161      */
 162     public static <T> T getOption(ServerSocket s, SocketOption<T> name) throws IOException
 163     {
 164         return s.getOption(name);
 165     }
 166 
 167     /**
 168      * Sets the value of a socket option on a {@link java.net.DatagramSocket}
 169      * or {@link java.net.MulticastSocket}
 170      *
 171      * @param s the socket
 172      * @param name The socket option
 173      * @param value The value of the socket option.
 174      *
 175      * @throws UnsupportedOperationException if the socket does not support
 176      *         the option.
 177      *
 178      * @throws IllegalArgumentException if the value is not valid for
 179      *         the option.
 180      *
 181      * @throws IOException if an I/O error occurs
 182      *
 183      * @throws NullPointerException if name is null
 184      *
 185      * @throws SecurityException if a security manager is set and the
 186      *         caller does not have any required permission.
 187      *
 188      * @see java.net.StandardSocketOptions
 189      */
 190     public static <T> void setOption(DatagramSocket s, SocketOption<T> name, T value) throws IOException
 191     {
 192         s.setOption(name, value);
 193     }
 194 
 195     /**
 196      * Returns the value of a socket option from a
 197      * {@link java.net.DatagramSocket} or {@link java.net.MulticastSocket}
 198      *
 199      * @param s the socket
 200      * @param name The socket option
 201      *
 202      * @return The value of the socket option.
 203      *
 204      * @throws UnsupportedOperationException if the socket does not support
 205      *         the option.
 206      *
 207      * @throws IOException if an I/O error occurs
 208      *
 209      * @throws NullPointerException if name is null
 210      *
 211      * @throws SecurityException if a security manager is set and the
 212      *         caller does not have any required permission.
 213      *
 214      * @see java.net.StandardSocketOptions
 215      */
 216     public static <T> T getOption(DatagramSocket s, SocketOption<T> name) throws IOException
 217     {
 218         return s.getOption(name);
 219     }
 220 
 221     /**
 222      * Returns a set of {@link java.net.SocketOption}s supported by the
 223      * given socket type. This set may include standard options and also
 224      * non standard extended options.
 225      *
 226      * @param socketType the type of java.net socket
 227      *
 228      * @throws IllegalArgumentException if socketType is not a valid
 229      *         socket type from the java.net package.
 230      */
 231     public static Set<SocketOption<?>> supportedOptions(Class<?> socketType) {
 232         Set<SocketOption<?>> set = options.get(socketType);
 233         if (set == null) {
 234             throw new IllegalArgumentException("unknown socket type");
 235         }
 236         return set;
 237     }
 238 
 239     private static void checkValueType(Object value, Class<?> type) {
 240         if (!type.isAssignableFrom(value.getClass())) {
 241             String s = "Found: " + value.getClass().toString() + " Expected: "
 242                         + type.toString();
 243             throw new IllegalArgumentException(s);
 244         }
 245     }
 246 
 247     private static volatile boolean checkedReusePort;
 248     private static volatile boolean isReusePortAvailable;
 249 
 250     /**
 251      * Tells whether SO_REUSEPORT is supported.
 252      */
 253     static boolean isReusePortAvailable() {
 254         if (!checkedReusePort) {
 255             Set<SocketOption<?>> s = new Socket().supportedOptions();
 256             isReusePortAvailable = s.contains(StandardSocketOptions.SO_REUSEPORT);
 257             checkedReusePort = true;
 258         }
 259         return isReusePortAvailable;
 260     }
 261 
 262     private static Map<Class<?>,Set<SocketOption<?>>> optionSets() {
 263         Map<Class<?>,Set<SocketOption<?>>> options = new HashMap<>();
 264         boolean flowsupported = PlatformSocketOptions.get().flowSupported();
 265         boolean reuseportsupported = isReusePortAvailable();
 266         // Socket
 267 
 268         Set<SocketOption<?>> set = new HashSet<>();
 269         set.add(StandardSocketOptions.SO_KEEPALIVE);
 270         set.add(StandardSocketOptions.SO_SNDBUF);
 271         set.add(StandardSocketOptions.SO_RCVBUF);
 272         set.add(StandardSocketOptions.SO_REUSEADDR);
 273         if (reuseportsupported) {
 274             set.add(StandardSocketOptions.SO_REUSEPORT);
 275         }
 276         set.add(StandardSocketOptions.SO_LINGER);
 277         set.add(StandardSocketOptions.IP_TOS);
 278         set.add(StandardSocketOptions.TCP_NODELAY);
 279         if (flowsupported) {
 280             set.add(ExtendedSocketOptions.SO_FLOW_SLA);
 281         }
 282         if (QuickAck.available) {
 283             set.add(ExtendedSocketOptions.TCP_QUICKACK);
 284         }
 285         if (KeepAliveOptions.AVAILABLE) {
 286             set.addAll(Set.of(ExtendedSocketOptions.TCP_KEEPCOUNT,
 287                     ExtendedSocketOptions.TCP_KEEPIDLE,
 288                     ExtendedSocketOptions.TCP_KEEPINTERVAL));
 289         }
 290         set = Collections.unmodifiableSet(set);
 291         options.put(Socket.class, set);
 292 
 293         // ServerSocket
 294 
 295         set = new HashSet<>();
 296         set.add(StandardSocketOptions.SO_RCVBUF);
 297         set.add(StandardSocketOptions.SO_REUSEADDR);
 298         if (reuseportsupported) {
 299             set.add(StandardSocketOptions.SO_REUSEPORT);
 300         }
 301         if (QuickAck.available) {
 302             set.add(ExtendedSocketOptions.TCP_QUICKACK);
 303         }
 304         if (KeepAliveOptions.AVAILABLE) {
 305             set.addAll(Set.of(ExtendedSocketOptions.TCP_KEEPCOUNT,
 306                     ExtendedSocketOptions.TCP_KEEPIDLE,
 307                     ExtendedSocketOptions.TCP_KEEPINTERVAL));
 308         }
 309         set.add(StandardSocketOptions.IP_TOS);
 310         set = Collections.unmodifiableSet(set);
 311         options.put(ServerSocket.class, set);
 312 
 313         // DatagramSocket
 314 
 315         set = new HashSet<>();
 316         set.add(StandardSocketOptions.SO_SNDBUF);
 317         set.add(StandardSocketOptions.SO_RCVBUF);
 318         set.add(StandardSocketOptions.SO_REUSEADDR);
 319         if (reuseportsupported) {
 320             set.add(StandardSocketOptions.SO_REUSEPORT);
 321         }
 322         set.add(StandardSocketOptions.IP_TOS);
 323         if (flowsupported) {
 324             set.add(ExtendedSocketOptions.SO_FLOW_SLA);
 325         }
 326         set = Collections.unmodifiableSet(set);
 327         options.put(DatagramSocket.class, set);
 328 
 329         // MulticastSocket
 330 
 331         set = new HashSet<>();
 332         set.add(StandardSocketOptions.SO_SNDBUF);
 333         set.add(StandardSocketOptions.SO_RCVBUF);
 334         set.add(StandardSocketOptions.SO_REUSEADDR);
 335         if (reuseportsupported) {
 336             set.add(StandardSocketOptions.SO_REUSEPORT);
 337         }
 338         set.add(StandardSocketOptions.IP_TOS);
 339         set.add(StandardSocketOptions.IP_MULTICAST_IF);
 340         set.add(StandardSocketOptions.IP_MULTICAST_TTL);
 341         set.add(StandardSocketOptions.IP_MULTICAST_LOOP);
 342         if (flowsupported) {
 343             set.add(ExtendedSocketOptions.SO_FLOW_SLA);
 344         }
 345         set = Collections.unmodifiableSet(set);
 346         options.put(MulticastSocket.class, set);
 347 
 348         return Collections.unmodifiableMap(options);
 349     }
 350 
 351     /**
 352      * Tells whether TCP_QUICKACK is supported.
 353      */
 354     static class QuickAck {
 355 
 356         static final boolean available;
 357 
 358         static {
 359             Set<SocketOption<?>> s = new Socket().supportedOptions();
 360             available = s.contains(ExtendedSocketOptions.TCP_QUICKACK);
 361         }
 362     }
 363 
 364     /**
 365      * Tells whether TCP_KEEPALIVE options are supported.
 366      */
 367     static class KeepAliveOptions {
 368 
 369         static final boolean AVAILABLE;
 370 
 371         static {
 372             Set<SocketOption<?>> s = new Socket().supportedOptions();
 373             AVAILABLE = s.containsAll(Set.of(ExtendedSocketOptions.TCP_KEEPCOUNT,
 374                                             ExtendedSocketOptions.TCP_KEEPIDLE,
 375                                             ExtendedSocketOptions.TCP_KEEPINTERVAL));
 376         }












































































 377     }
 378 }
--- EOF ---