1 /* 2 * Copyright (c) 2014, 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.io.FileDescriptor; 29 import java.net.SocketException; 30 import java.net.SocketOption; 31 import java.security.AccessController; 32 import java.security.PrivilegedAction; 33 import java.util.Collections; 34 import java.util.Set; 35 import jdk.internal.misc.JavaIOFileDescriptorAccess; 36 import jdk.internal.misc.SharedSecrets; 37 38 /** 39 * Defines extended socket options, beyond those defined in 40 * {@link java.net.StandardSocketOptions}. These options may be platform 41 * specific. 42 * 43 * @since 1.8 44 */ 45 public final class ExtendedSocketOptions { 46 47 private static class ExtSocketOption<T> implements SocketOption<T> { 48 private final String name; 49 private final Class<T> type; 50 ExtSocketOption(String name, Class<T> type) { 51 this.name = name; 52 this.type = type; 53 } 54 @Override public String name() { return name; } 55 @Override public Class<T> type() { return type; } 56 @Override public String toString() { return name; } 57 } 58 59 private ExtendedSocketOptions() { } 60 61 /** 62 * Service level properties. When a security manager is installed, 63 * setting or getting this option requires a {@link NetworkPermission} 64 * {@code ("setOption.SO_FLOW_SLA")} or {@code "getOption.SO_FLOW_SLA"} 65 * respectively. 66 */ 67 public static final SocketOption<SocketFlow> SO_FLOW_SLA = new 68 ExtSocketOption<SocketFlow>("SO_FLOW_SLA", SocketFlow.class); 69 70 71 private static final PlatformSocketOptions platformSocketOptions = 72 PlatformSocketOptions.get(); 73 74 private static final boolean flowSupported = 75 platformSocketOptions.flowSupported(); 76 77 private static final Set<SocketOption<?>> extendedOptions = options(); 78 79 static Set<SocketOption<?>> options() { 80 if (flowSupported) 81 return Set.of(SO_FLOW_SLA); 82 else 83 return Collections.<SocketOption<?>>emptySet(); 84 } 85 86 static { 87 // Registers the extended socket options with the base module. 88 sun.net.ext.ExtendedSocketOptions.register( 89 new sun.net.ext.ExtendedSocketOptions(extendedOptions) { 90 91 @Override 92 public void setOption(FileDescriptor fd, 93 SocketOption<?> option, 94 Object value) 95 throws SocketException 96 { 97 SecurityManager sm = System.getSecurityManager(); 98 if (sm != null) 99 sm.checkPermission(new NetworkPermission("setOption." + option.name())); 100 101 if (fd == null || !fd.valid()) 102 throw new SocketException("socket closed"); 103 104 if (option == SO_FLOW_SLA) { 105 assert flowSupported; 106 SocketFlow flow = checkValueType(value, option.type()); 107 setFlowOption(fd, flow); 108 } else { 109 throw new InternalError("Unexpected option " + option); 110 } 111 } 112 113 @Override 114 public Object getOption(FileDescriptor fd, 115 SocketOption<?> option) 116 throws SocketException 117 { 118 SecurityManager sm = System.getSecurityManager(); 119 if (sm != null) 120 sm.checkPermission(new NetworkPermission("getOption." + option.name())); 121 122 if (fd == null || !fd.valid()) 123 throw new SocketException("socket closed"); 124 125 if (option == SO_FLOW_SLA) { 126 assert flowSupported; 127 SocketFlow flow = SocketFlow.create(); 128 getFlowOption(fd, flow); 129 return flow; 130 } else { 131 throw new InternalError("Unexpected option " + option); 132 } 133 } 134 }); 135 } 136 137 @SuppressWarnings("unchecked") 138 private static <T> T checkValueType(Object value, Class<?> type) { 139 if (!type.isAssignableFrom(value.getClass())) { 140 String s = "Found: " + value.getClass() + ", Expected: " + type; 141 throw new IllegalArgumentException(s); 142 } 143 return (T) value; 144 } 145 146 private static final JavaIOFileDescriptorAccess fdAccess = 147 SharedSecrets.getJavaIOFileDescriptorAccess(); 148 149 private static void setFlowOption(FileDescriptor fd, SocketFlow f) 150 throws SocketException 151 { 152 int status = platformSocketOptions.setFlowOption(fdAccess.get(fd), 153 f.priority(), 154 f.bandwidth()); 155 f.status(status); // augment the given flow with the status 156 } 157 158 private static void getFlowOption(FileDescriptor fd, SocketFlow f) 159 throws SocketException 160 { 161 int status = platformSocketOptions.getFlowOption(fdAccess.get(fd), f); 162 f.status(status); // augment the given flow with the status 163 } 164 165 static class PlatformSocketOptions { 166 167 protected PlatformSocketOptions() {} 168 169 @SuppressWarnings("unchecked") 170 private static PlatformSocketOptions newInstance(String cn) { 171 Class<PlatformSocketOptions> c; 172 try { 173 c = (Class<PlatformSocketOptions>)Class.forName(cn); 174 return c.getConstructor(new Class<?>[] { }).newInstance(); 175 } catch (ReflectiveOperationException x) { 176 throw new AssertionError(x); 177 } 178 } 179 180 private static PlatformSocketOptions create() { 181 String osname = AccessController.doPrivileged( 182 new PrivilegedAction<String>() { 183 public String run() { 184 return System.getProperty("os.name"); 185 } 186 }); 187 if ("SunOS".equals(osname)) 188 return newInstance("jdk.net.SolarisSocketOptions"); 189 return new PlatformSocketOptions(); 190 } 191 192 private static final PlatformSocketOptions instance = create(); 193 194 static PlatformSocketOptions get() { 195 return instance; 196 } 197 198 int setFlowOption(int fd, int priority, long bandwidth) 199 throws SocketException 200 { 201 throw new UnsupportedOperationException("unsupported socket option"); 202 } 203 204 int getFlowOption(int fd, SocketFlow f) throws SocketException { 205 throw new UnsupportedOperationException("unsupported socket option"); 206 } 207 208 boolean flowSupported() { 209 return false; 210 } 211 } 212 }