ojluni/src/main/java/sun/security/jca/GetInstance.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package sun.security.jca;

 import java.util.*;

 import java.security.*;
 import java.security.Provider.Service;

 /**
  * Collection of utility methods to facilitate implementing getInstance()
  * methods in the JCA/JCE/JSSE/... framework.
  *
  * @author  Andreas Sterbenz
  * @since   1.5
  */
 public class GetInstance {

     private GetInstance() {
         // empty
     }

     /**
      * Static inner class representing a newly created instance.
      */
     public static final class Instance {
         // public final fields, access directly without accessors
         public final Provider provider;
         public final Object impl;
         private Instance(Provider provider, Object impl) {
             this.provider = provider;
             this.impl = impl;
         }
         // Return Provider and implementation as an array as used in the
         // old Security.getImpl() methods.
         public Object[] toArray() {
             return new Object[] {impl, provider};
         }
     }

     public static Service getService(String type, String algorithm)
             throws NoSuchAlgorithmException {
         ProviderList list = Providers.getProviderList();
         Service s = list.getService(type, algorithm);
         if (s == null) {
             throw new NoSuchAlgorithmException
                     (algorithm + " " + type + " not available");
         }
         return s;
     }

     public static Service getService(String type, String algorithm,
             String provider) throws NoSuchAlgorithmException,
             NoSuchProviderException {
         if ((provider == null) || (provider.length() == 0)) {
             throw new IllegalArgumentException("missing provider");
         }
         Provider p = Providers.getProviderList().getProvider(provider);
         if (p == null) {
             throw new NoSuchProviderException("no such provider: " + provider);
         }
         Service s = p.getService(type, algorithm);
         if (s == null) {
             throw new NoSuchAlgorithmException("no such algorithm: "
                 + algorithm + " for provider " + provider);
         }
         return s;
     }

     public static Service getService(String type, String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (provider == null) {
             throw new IllegalArgumentException("missing provider");
         }
         Service s = provider.getService(type, algorithm);
         if (s == null) {
             throw new NoSuchAlgorithmException("no such algorithm: "
                 + algorithm + " for provider " + provider.getName());
         }
         return s;
     }

     /**
      * Return a List of all the available Services that implement
      * (type, algorithm). Note that the list is initialized lazily
      * and Provider loading and lookup is only trigered when
      * necessary.
      */
     public static List<Service> getServices(String type, String algorithm) {
         ProviderList list = Providers.getProviderList();
         return list.getServices(type, algorithm);
     }

     /**
      * This method exists for compatibility with JCE only. It will be removed
      * once JCE has been changed to use the replacement method.
      * @deprecated use getServices(List<ServiceId>) instead
      */
     @Deprecated
     public static List<Service> getServices(String type,
             List<String> algorithms) {
         ProviderList list = Providers.getProviderList();
         return list.getServices(type, algorithms);
     }

     /**
      * Return a List of all the available Services that implement any of
      * the specified algorithms. See getServices(String, String) for detals.
      */
     public static List<Service> getServices(List<ServiceId> ids) {
         ProviderList list = Providers.getProviderList();
         return list.getServices(ids);
     }

     /*
      * For all the getInstance() methods below:
      * @param type the type of engine (e.g. MessageDigest)
      * @param clazz the Spi class that the implementation must subclass
      *   (e.g. MessageDigestSpi.class) or null if no superclass check
      *   is required
      * @param algorithm the name of the algorithm (or alias), e.g. MD5
      * @param provider the provider (String or Provider object)
      * @param param the parameter to pass to the Spi constructor
      *   (for CertStores)
      *
      * There are overloaded methods for all the permutations.
      */

     public static Instance getInstance(String type, Class clazz,
             String algorithm) throws NoSuchAlgorithmException {
         // in the almost all cases, the first service will work
         // avoid taking long path if so
         ProviderList list = Providers.getProviderList();
         Service firstService = list.getService(type, algorithm);
         if (firstService == null) {
             throw new NoSuchAlgorithmException
                     (algorithm + " " + type + " not available");
         }
         NoSuchAlgorithmException failure;
         try {
             return getInstance(firstService, clazz);
         } catch (NoSuchAlgorithmException e) {
             failure = e;
         }
         // if we cannot get the service from the prefered provider,
         // fail over to the next
         for (Service s : list.getServices(type, algorithm)) {
             if (s == firstService) {
                 // do not retry initial failed service
                 continue;
             }
             try {
                 return getInstance(s, clazz);
             } catch (NoSuchAlgorithmException e) {
                 failure = e;
             }
         }
         throw failure;
     }

     public static Instance getInstance(String type, Class clazz,
             String algorithm, Object param) throws NoSuchAlgorithmException {
         List<Service> services = getServices(type, algorithm);
         NoSuchAlgorithmException failure = null;
         for (Service s : services) {
             try {
                 return getInstance(s, clazz, param);
             } catch (NoSuchAlgorithmException e) {
                 failure = e;
             }
         }
         if (failure != null) {
             throw failure;
         } else {
             throw new NoSuchAlgorithmException
                     (algorithm + " " + type + " not available");
         }
     }

     public static Instance getInstance(String type, Class clazz,
             String algorithm, String provider) throws NoSuchAlgorithmException,
             NoSuchProviderException {
         return getInstance(getService(type, algorithm, provider), clazz);
     }

     public static Instance getInstance(String type, Class clazz,
             String algorithm, Object param, String provider)
             throws NoSuchAlgorithmException, NoSuchProviderException {
         return getInstance(getService(type, algorithm, provider), clazz, param);
     }

     public static Instance getInstance(String type, Class clazz,
             String algorithm, Provider provider)
             throws NoSuchAlgorithmException {
         return getInstance(getService(type, algorithm, provider), clazz);
     }

     public static Instance getInstance(String type, Class clazz,
             String algorithm, Object param, Provider provider)
             throws NoSuchAlgorithmException {
         return getInstance(getService(type, algorithm, provider), clazz, param);
     }

     /*
      * The two getInstance() methods below take a service. They are
      * intended for classes that cannot use the standard methods, e.g.
      * because they implement delayed provider selection like the
      * Signature class.
      */

     public static Instance getInstance(Service s, Class clazz)
             throws NoSuchAlgorithmException {
         Object instance = s.newInstance(null);
         checkSuperClass(s, instance.getClass(), clazz);
         return new Instance(s.getProvider(), instance);
     }

     public static Instance getInstance(Service s, Class clazz,
             Object param) throws NoSuchAlgorithmException {
         Object instance = s.newInstance(param);
         checkSuperClass(s, instance.getClass(), clazz);
         return new Instance(s.getProvider(), instance);
     }

     /**
      * Check is subClass is a subclass of superClass. If not,
      * throw a NoSuchAlgorithmException.
      */
     public static void checkSuperClass(Service s, Class subClass,
             Class superClass) throws NoSuchAlgorithmException {
         if (superClass == null) {
             return;
         }
         if (superClass.isAssignableFrom(subClass) == false) {
             throw new NoSuchAlgorithmException
                 ("class configured for " + s.getType() + ": "
                 + s.getClassName() + " not a " + s.getType());
         }
     }

 }
	/*
	* Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.security.jca;

	import java.util.*;

	import java.security.*;
	import java.security.Provider.Service;

	/**
	* Collection of utility methods to facilitate implementing getInstance()
	* methods in the JCA/JCE/JSSE/... framework.
	*
	* @author Andreas Sterbenz
	* @since 1.5
	*/
	public class GetInstance {

	private GetInstance() {
	// empty
	}

	/**
	* Static inner class representing a newly created instance.
	*/
	public static final class Instance {
	// public final fields, access directly without accessors
	public final Provider provider;
	public final Object impl;
	private Instance(Provider provider, Object impl) {
	this.provider = provider;
	this.impl = impl;
	}
	// Return Provider and implementation as an array as used in the
	// old Security.getImpl() methods.
	public Object[] toArray() {
	return new Object[] {impl, provider};
	}
	}

	public static Service getService(String type, String algorithm)
	throws NoSuchAlgorithmException {
	ProviderList list = Providers.getProviderList();
	Service s = list.getService(type, algorithm);
	if (s == null) {
	throw new NoSuchAlgorithmException
	(algorithm + " " + type + " not available");
	}
	return s;
	}

	public static Service getService(String type, String algorithm,
	String provider) throws NoSuchAlgorithmException,
	NoSuchProviderException {
	if ((provider == null) \|\| (provider.length() == 0)) {
	throw new IllegalArgumentException("missing provider");
	}
	Provider p = Providers.getProviderList().getProvider(provider);
	if (p == null) {
	throw new NoSuchProviderException("no such provider: " + provider);
	}
	Service s = p.getService(type, algorithm);
	if (s == null) {
	throw new NoSuchAlgorithmException("no such algorithm: "
	+ algorithm + " for provider " + provider);
	}
	return s;
	}

	public static Service getService(String type, String algorithm,
	Provider provider) throws NoSuchAlgorithmException {
	if (provider == null) {
	throw new IllegalArgumentException("missing provider");
	}
	Service s = provider.getService(type, algorithm);
	if (s == null) {
	throw new NoSuchAlgorithmException("no such algorithm: "
	+ algorithm + " for provider " + provider.getName());
	}
	return s;
	}

	/**
	* Return a List of all the available Services that implement
	* (type, algorithm). Note that the list is initialized lazily
	* and Provider loading and lookup is only trigered when
	* necessary.
	*/
	public static List<Service> getServices(String type, String algorithm) {
	ProviderList list = Providers.getProviderList();
	return list.getServices(type, algorithm);
	}

	/**
	* This method exists for compatibility with JCE only. It will be removed
	* once JCE has been changed to use the replacement method.
	* @deprecated use getServices(List<ServiceId>) instead
	*/
	@Deprecated
	public static List<Service> getServices(String type,
	List<String> algorithms) {
	ProviderList list = Providers.getProviderList();
	return list.getServices(type, algorithms);
	}

	/**
	* Return a List of all the available Services that implement any of
	* the specified algorithms. See getServices(String, String) for detals.
	*/
	public static List<Service> getServices(List<ServiceId> ids) {
	ProviderList list = Providers.getProviderList();
	return list.getServices(ids);
	}

	/*
	* For all the getInstance() methods below:
	* @param type the type of engine (e.g. MessageDigest)
	* @param clazz the Spi class that the implementation must subclass
	* (e.g. MessageDigestSpi.class) or null if no superclass check
	* is required
	* @param algorithm the name of the algorithm (or alias), e.g. MD5
	* @param provider the provider (String or Provider object)
	* @param param the parameter to pass to the Spi constructor
	* (for CertStores)
	*
	* There are overloaded methods for all the permutations.
	*/

	public static Instance getInstance(String type, Class clazz,
	String algorithm) throws NoSuchAlgorithmException {
	// in the almost all cases, the first service will work
	// avoid taking long path if so
	ProviderList list = Providers.getProviderList();
	Service firstService = list.getService(type, algorithm);
	if (firstService == null) {
	throw new NoSuchAlgorithmException
	(algorithm + " " + type + " not available");
	}
	NoSuchAlgorithmException failure;
	try {
	return getInstance(firstService, clazz);
	} catch (NoSuchAlgorithmException e) {
	failure = e;
	}
	// if we cannot get the service from the prefered provider,
	// fail over to the next
	for (Service s : list.getServices(type, algorithm)) {
	if (s == firstService) {
	// do not retry initial failed service
	continue;
	}
	try {
	return getInstance(s, clazz);
	} catch (NoSuchAlgorithmException e) {
	failure = e;
	}
	}
	throw failure;
	}

	public static Instance getInstance(String type, Class clazz,
	String algorithm, Object param) throws NoSuchAlgorithmException {
	List<Service> services = getServices(type, algorithm);
	NoSuchAlgorithmException failure = null;
	for (Service s : services) {
	try {
	return getInstance(s, clazz, param);
	} catch (NoSuchAlgorithmException e) {
	failure = e;
	}
	}
	if (failure != null) {
	throw failure;
	} else {
	throw new NoSuchAlgorithmException
	(algorithm + " " + type + " not available");
	}
	}

	public static Instance getInstance(String type, Class clazz,
	String algorithm, String provider) throws NoSuchAlgorithmException,
	NoSuchProviderException {
	return getInstance(getService(type, algorithm, provider), clazz);
	}

	public static Instance getInstance(String type, Class clazz,
	String algorithm, Object param, String provider)
	throws NoSuchAlgorithmException, NoSuchProviderException {
	return getInstance(getService(type, algorithm, provider), clazz, param);
	}

	public static Instance getInstance(String type, Class clazz,
	String algorithm, Provider provider)
	throws NoSuchAlgorithmException {
	return getInstance(getService(type, algorithm, provider), clazz);
	}

	public static Instance getInstance(String type, Class clazz,
	String algorithm, Object param, Provider provider)
	throws NoSuchAlgorithmException {
	return getInstance(getService(type, algorithm, provider), clazz, param);
	}

	/*
	* The two getInstance() methods below take a service. They are
	* intended for classes that cannot use the standard methods, e.g.
	* because they implement delayed provider selection like the
	* Signature class.
	*/

	public static Instance getInstance(Service s, Class clazz)
	throws NoSuchAlgorithmException {
	Object instance = s.newInstance(null);
	checkSuperClass(s, instance.getClass(), clazz);
	return new Instance(s.getProvider(), instance);
	}

	public static Instance getInstance(Service s, Class clazz,
	Object param) throws NoSuchAlgorithmException {
	Object instance = s.newInstance(param);
	checkSuperClass(s, instance.getClass(), clazz);
	return new Instance(s.getProvider(), instance);
	}

	/**
	* Check is subClass is a subclass of superClass. If not,
	* throw a NoSuchAlgorithmException.
	*/
	public static void checkSuperClass(Service s, Class subClass,
	Class superClass) throws NoSuchAlgorithmException {
	if (superClass == null) {
	return;
	}
	if (superClass.isAssignableFrom(subClass) == false) {
	throw new NoSuchAlgorithmException
	("class configured for " + s.getType() + ": "
	+ s.getClassName() + " not a " + s.getType());
	}
	}

	}