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.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         set = Collections.unmodifiableSet(set);

   283         options.put(Socket.class, set);

   284 

   285         // ServerSocket

   286 

   287         set = new HashSet<>();

   288         set.add(StandardSocketOptions.SO_RCVBUF);

   289         set.add(StandardSocketOptions.SO_REUSEADDR);

   290         if (reuseportsupported) {

   291             set.add(StandardSocketOptions.SO_REUSEPORT);

   292         }

   293         set.add(StandardSocketOptions.IP_TOS);

   294         set = Collections.unmodifiableSet(set);

   295         options.put(ServerSocket.class, set);

   296 

   297         // DatagramSocket

   298 

   299         set = new HashSet<>();

   300         set.add(StandardSocketOptions.SO_SNDBUF);

   301         set.add(StandardSocketOptions.SO_RCVBUF);

   302         set.add(StandardSocketOptions.SO_REUSEADDR);

   303         if (reuseportsupported) {

   304             set.add(StandardSocketOptions.SO_REUSEPORT);

   305         }

   306         set.add(StandardSocketOptions.IP_TOS);

   307         if (flowsupported) {

   308             set.add(ExtendedSocketOptions.SO_FLOW_SLA);

   309         }

   310         set = Collections.unmodifiableSet(set);

   311         options.put(DatagramSocket.class, set);

   312 

   313         // MulticastSocket

   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         set.add(StandardSocketOptions.IP_MULTICAST_IF);

   324         set.add(StandardSocketOptions.IP_MULTICAST_TTL);

   325         set.add(StandardSocketOptions.IP_MULTICAST_LOOP);

   326         if (flowsupported) {

   327             set.add(ExtendedSocketOptions.SO_FLOW_SLA);

   328         }

   329         set = Collections.unmodifiableSet(set);

   330         options.put(MulticastSocket.class, set);

   331 

   332         return Collections.unmodifiableMap(options);

   333     }

   334 }