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
26package sun.security.jca;
27
28import java.util.*;
29
30import java.security.*;
31import 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 */
40public 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.length() == 0)) {
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}
265