1 /*
   2  * Copyright (c) 2003, 2013, 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 sun.security.jca;
  27 
  28 import java.util.*;
  29 
  30 import java.security.*;
  31 import java.security.Provider.Service;
  32 
  33 /**
  34  * Collection of utility methods to facilitate implementing getInstance()
  35  * methods in the JCA/JCE/JSSE/... framework.
  36  *
  37  * @author  Andreas Sterbenz
  38  * @since   1.5
  39  */
  40 public class GetInstance {
  41 
  42     private GetInstance() {
  43         // empty
  44     }
  45 
  46     /**
  47      * Static inner class representing a newly created instance.
  48      */
  49     public static final class Instance {
  50         // public final fields, access directly without accessors
  51         public final Provider provider;
  52         public final Object impl;
  53         private Instance(Provider provider, Object impl) {
  54             this.provider = provider;
  55             this.impl = impl;
  56         }
  57         // Return Provider and implementation as an array as used in the
  58         // old Security.getImpl() methods.
  59         public Object[] toArray() {
  60             return new Object[] {impl, provider};
  61         }
  62     }
  63 
  64     public static Service getService(String type, String algorithm)
  65             throws NoSuchAlgorithmException {
  66         ProviderList list = Providers.getProviderList();
  67         Service s = list.getService(type, algorithm);
  68         if (s == null) {
  69             throw new NoSuchAlgorithmException
  70                     (algorithm + " " + type + " not available");
  71         }
  72         return s;
  73     }
  74 
  75     public static Service getService(String type, String algorithm,
  76             String provider) throws NoSuchAlgorithmException,
  77             NoSuchProviderException {
  78         if (provider == null || provider.isEmpty()) {
  79             throw new IllegalArgumentException("missing provider");
  80         }
  81         Provider p = Providers.getProviderList().getProvider(provider);
  82         if (p == null) {
  83             throw new NoSuchProviderException("no such provider: " + provider);
  84         }
  85         Service s = p.getService(type, algorithm);
  86         if (s == null) {
  87             throw new NoSuchAlgorithmException("no such algorithm: "
  88                 + algorithm + " for provider " + provider);
  89         }
  90         return s;
  91     }
  92 
  93     public static Service getService(String type, String algorithm,
  94             Provider provider) throws NoSuchAlgorithmException {
  95         if (provider == null) {
  96             throw new IllegalArgumentException("missing provider");
  97         }
  98         Service s = provider.getService(type, algorithm);
  99         if (s == null) {
 100             throw new NoSuchAlgorithmException("no such algorithm: "
 101                 + algorithm + " for provider " + provider.getName());
 102         }
 103         return s;
 104     }
 105 
 106     /**
 107      * Return a List of all the available Services that implement
 108      * (type, algorithm). Note that the list is initialized lazily
 109      * and Provider loading and lookup is only trigered when
 110      * necessary.
 111      */
 112     public static List<Service> getServices(String type, String algorithm) {
 113         ProviderList list = Providers.getProviderList();
 114         return list.getServices(type, algorithm);
 115     }
 116 
 117     /**
 118      * This method exists for compatibility with JCE only. It will be removed
 119      * once JCE has been changed to use the replacement method.
 120      * @deprecated use {@code getServices(List<ServiceId>)} instead
 121      */
 122     @Deprecated
 123     public static List<Service> getServices(String type,
 124             List<String> algorithms) {
 125         ProviderList list = Providers.getProviderList();
 126         return list.getServices(type, algorithms);
 127     }
 128 
 129     /**
 130      * Return a List of all the available Services that implement any of
 131      * the specified algorithms. See getServices(String, String) for detals.
 132      */
 133     public static List<Service> getServices(List<ServiceId> ids) {
 134         ProviderList list = Providers.getProviderList();
 135         return list.getServices(ids);
 136     }
 137 
 138     /*
 139      * For all the getInstance() methods below:
 140      * @param type the type of engine (e.g. MessageDigest)
 141      * @param clazz the Spi class that the implementation must subclass
 142      *   (e.g. MessageDigestSpi.class) or null if no superclass check
 143      *   is required
 144      * @param algorithm the name of the algorithm (or alias), e.g. MD5
 145      * @param provider the provider (String or Provider object)
 146      * @param param the parameter to pass to the Spi constructor
 147      *   (for CertStores)
 148      *
 149      * There are overloaded methods for all the permutations.
 150      */
 151 
 152     public static Instance getInstance(String type, Class<?> clazz,
 153             String algorithm) throws NoSuchAlgorithmException {
 154         // in the almost all cases, the first service will work
 155         // avoid taking long path if so
 156         ProviderList list = Providers.getProviderList();
 157         Service firstService = list.getService(type, algorithm);
 158         if (firstService == null) {
 159             throw new NoSuchAlgorithmException
 160                     (algorithm + " " + type + " not available");
 161         }
 162         NoSuchAlgorithmException failure;
 163         try {
 164             return getInstance(firstService, clazz);
 165         } catch (NoSuchAlgorithmException e) {
 166             failure = e;
 167         }
 168         // if we cannot get the service from the preferred provider,
 169         // fail over to the next
 170         for (Service s : list.getServices(type, algorithm)) {
 171             if (s == firstService) {
 172                 // do not retry initial failed service
 173                 continue;
 174             }
 175             try {
 176                 return getInstance(s, clazz);
 177             } catch (NoSuchAlgorithmException e) {
 178                 failure = e;
 179             }
 180         }
 181         throw failure;
 182     }
 183 
 184     public static Instance getInstance(String type, Class<?> clazz,
 185             String algorithm, Object param) throws NoSuchAlgorithmException {
 186         List<Service> services = getServices(type, algorithm);
 187         NoSuchAlgorithmException failure = null;
 188         for (Service s : services) {
 189             try {
 190                 return getInstance(s, clazz, param);
 191             } catch (NoSuchAlgorithmException e) {
 192                 failure = e;
 193             }
 194         }
 195         if (failure != null) {
 196             throw failure;
 197         } else {
 198             throw new NoSuchAlgorithmException
 199                     (algorithm + " " + type + " not available");
 200         }
 201     }
 202 
 203     public static Instance getInstance(String type, Class<?> clazz,
 204             String algorithm, String provider) throws NoSuchAlgorithmException,
 205             NoSuchProviderException {
 206         return getInstance(getService(type, algorithm, provider), clazz);
 207     }
 208 
 209     public static Instance getInstance(String type, Class<?> clazz,
 210             String algorithm, Object param, String provider)
 211             throws NoSuchAlgorithmException, NoSuchProviderException {
 212         return getInstance(getService(type, algorithm, provider), clazz, param);
 213     }
 214 
 215     public static Instance getInstance(String type, Class<?> clazz,
 216             String algorithm, Provider provider)
 217             throws NoSuchAlgorithmException {
 218         return getInstance(getService(type, algorithm, provider), clazz);
 219     }
 220 
 221     public static Instance getInstance(String type, Class<?> clazz,
 222             String algorithm, Object param, Provider provider)
 223             throws NoSuchAlgorithmException {
 224         return getInstance(getService(type, algorithm, provider), clazz, param);
 225     }
 226 
 227     /*
 228      * The two getInstance() methods below take a service. They are
 229      * intended for classes that cannot use the standard methods, e.g.
 230      * because they implement delayed provider selection like the
 231      * Signature class.
 232      */
 233 
 234     public static Instance getInstance(Service s, Class<?> clazz)
 235             throws NoSuchAlgorithmException {
 236         Object instance = s.newInstance(null);
 237         checkSuperClass(s, instance.getClass(), clazz);
 238         return new Instance(s.getProvider(), instance);
 239     }
 240 
 241     public static Instance getInstance(Service s, Class<?> clazz,
 242             Object param) throws NoSuchAlgorithmException {
 243         Object instance = s.newInstance(param);
 244         checkSuperClass(s, instance.getClass(), clazz);
 245         return new Instance(s.getProvider(), instance);
 246     }
 247 
 248     /**
 249      * Check is subClass is a subclass of superClass. If not,
 250      * throw a NoSuchAlgorithmException.
 251      */
 252     public static void checkSuperClass(Service s, Class<?> subClass,
 253             Class<?> superClass) throws NoSuchAlgorithmException {
 254         if (superClass == null) {
 255             return;
 256         }
 257         if (superClass.isAssignableFrom(subClass) == false) {
 258             throw new NoSuchAlgorithmException
 259                 ("class configured for " + s.getType() + ": "
 260                 + s.getClassName() + " not a " + s.getType());
 261         }
 262     }
 263 
 264 }