| Frames | No Frames |
1: /* SSLServerSocketFactory.java -- factory for SSL server sockets. 2: Copyright (C) 2004 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.net.ssl; 40: 41: import java.io.IOException; 42: import java.net.InetAddress; 43: import java.net.ServerSocket; 44: import java.security.KeyStore; 45: import java.security.Security; 46: 47: import javax.net.ServerSocketFactory; 48: 49: /** 50: * A server socket factory for <i>Secure Socket Layer</i> (<b>SSL</b>) 51: * server sockets. 52: */ 53: public abstract class SSLServerSocketFactory extends ServerSocketFactory 54: { 55: // Field. 56: // ------------------------------------------------------------------------- 57: 58: private static SSLContext context; 59: 60: // Constructor. 61: // ------------------------------------------------------------------------- 62: 63: protected SSLServerSocketFactory() 64: { 65: super(); 66: } 67: 68: // Class methods. 69: // ------------------------------------------------------------------------- 70: 71: /** 72: * Returns a default implementation of a SSL server socket factory. 73: * 74: * <p>To control the class that gets returned by this method, set the 75: * security property "ssl.ServerSocketFactory.provider" to the class 76: * name of a concrete implementation of this class. If not set, a 77: * system-dependent implementation will be used.</p> 78: * 79: * <p>The implementation returned is created by the first implementation 80: * of the {@link SSLContext} class found, which is initialized with 81: * default parameters. To control the key and trust manager factory 82: * algorithms used as defaults, set the security properties 83: * "ssl.keyManagerFactory.algorithm" and "ssl.trustManagerFactory.algorithm" 84: * to the appropriate names.</p> 85: * 86: * <p>Using this method is not recommended. Instead, use the methods of 87: * {@link SSLContext}, which provide much better control over the 88: * creation of server socket factories.</p> 89: * 90: * @return The default server socket factory. 91: * @throws RuntimeException If no default can be created. 92: */ 93: public static synchronized ServerSocketFactory getDefault() 94: { 95: try 96: { 97: String s = Security.getProperty("ssl.ServerSocketFactory.provider"); 98: ClassLoader cl = ClassLoader.getSystemClassLoader(); 99: if (s != null && cl != null) 100: { 101: return (ServerSocketFactory) cl.loadClass(s).newInstance(); 102: } 103: } 104: catch (Exception e) 105: { 106: } 107: if (context == null) 108: { 109: KeyManager[] km = null; 110: TrustManager[] tm = null; 111: 112: // 1. Determine which algorithms to use for the key and trust 113: // manager factories. 114: String kmAlg = KeyManagerFactory.getDefaultAlgorithm(); 115: String tmAlg = TrustManagerFactory.getDefaultAlgorithm(); 116: // 2. Try to initialize the factories with default parameters. 117: try 118: { 119: KeyManagerFactory kmf = KeyManagerFactory.getInstance(kmAlg); 120: kmf.init(null, null); 121: km = kmf.getKeyManagers(); 122: } 123: catch (Exception ex) 124: { 125: } 126: try 127: { 128: TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmAlg); 129: tmf.init((KeyStore) null); 130: tm = tmf.getTrustManagers(); 131: } 132: catch (Exception ex) 133: { 134: } 135: 136: // 3. Create and initialize a context. 137: try 138: { 139: context = SSLContext.getInstance("SSLv3"); 140: context.init(km, tm, null); 141: } 142: catch (Exception ex) 143: { 144: return new ErrorServerSocketFactory(new RuntimeException( 145: "error instantiating default server socket factory: " 146: + ex.toString(), ex)); 147: } 148: } 149: try 150: { 151: return context.getServerSocketFactory(); 152: } 153: catch (Exception e) 154: { 155: } 156: return new ErrorServerSocketFactory(new RuntimeException( 157: "no SSLSocketFactory implementation available")); 158: } 159: 160: private static final class ErrorServerSocketFactory 161: extends SSLServerSocketFactory 162: { 163: private RuntimeException x; 164: 165: ErrorServerSocketFactory(RuntimeException x) 166: { 167: this.x = x; 168: } 169: 170: public ServerSocket createServerSocket() throws IOException 171: { 172: throw (IOException) new IOException().initCause(x); 173: } 174: 175: public ServerSocket createServerSocket(int port) throws IOException 176: { 177: throw (IOException) new IOException().initCause(x); 178: } 179: 180: public ServerSocket createServerSocket(int port, int backlog) 181: throws IOException 182: { 183: throw (IOException) new IOException().initCause(x); 184: } 185: 186: public ServerSocket createServerSocket(int port, int backlog, 187: InetAddress ifAddress) 188: throws IOException 189: { 190: throw (IOException) new IOException().initCause(x); 191: } 192: 193: public String[] getDefaultCipherSuites() 194: { 195: throw new RuntimeException(x); 196: } 197: 198: public String[] getSupportedCipherSuites() 199: { 200: throw new RuntimeException(x); 201: } 202: } 203: 204: // Abstract methods. 205: // ------------------------------------------------------------------------- 206: 207: /** 208: * Returns the list of cipher suites that will be enabled in server sockets 209: * created by this factory. 210: * 211: * @return The default cipher suites. 212: */ 213: public abstract String[] getDefaultCipherSuites(); 214: 215: /** 216: * Returns the list of all cipher suites supported by this factory. 217: * 218: * @return The list of supported cipher suites. 219: */ 220: public abstract String[] getSupportedCipherSuites(); 221: }