1/*
2 * Copyright (c) 2016, 2017, 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 javax.xml.soap;
27
28import java.util.ServiceLoader;
29import java.util.logging.Level;
30import java.util.logging.Logger;
31
32/**
33 * Shared ServiceLoader/FactoryFinder Utils shared among SAAJ, JAXB and JAXWS
34 * Class duplicated to all those projects.
35 *
36 * @author Miroslav.Kos@oracle.com
37 */
38class ServiceLoaderUtil {
39
40    static <P, T extends Exception> P firstByServiceLoader(Class<P> spiClass,
41                                                           Logger logger,
42                                                           ExceptionHandler<T> handler) throws T {
43        logger.log(Level.FINE, "Using java.util.ServiceLoader to find {0}", spiClass.getName());
44        // service discovery
45        try {
46            ServiceLoader<P> serviceLoader = ServiceLoader.load(spiClass);
47
48            for (P impl : serviceLoader) {
49                logger.log(Level.FINE, "ServiceProvider loading Facility used; returning object [{0}]", impl.getClass().getName());
50
51                return impl;
52            }
53        } catch (Throwable t) {
54            throw handler.createException(t, "Error while searching for service [" + spiClass.getName() + "]");
55        }
56        return null;
57    }
58
59    static void checkPackageAccess(String className) {
60        // make sure that the current thread has an access to the package of the given name.
61        SecurityManager s = System.getSecurityManager();
62        if (s != null) {
63            int i = className.lastIndexOf('.');
64            if (i != -1) {
65                s.checkPackageAccess(className.substring(0, i));
66            }
67        }
68    }
69
70    static Class nullSafeLoadClass(String className, ClassLoader classLoader) throws ClassNotFoundException {
71        if (classLoader == null) {
72            return Class.forName(className);
73        } else {
74            return classLoader.loadClass(className);
75        }
76    }
77
78    // Returns instance of required class. It checks package access (security)
79    // unless it is defaultClassname. It means if you are trying to instantiate
80    // default implementation (fallback), pass the class name to both first and second parameter.
81    static <T extends Exception> Object newInstance(String className,
82                                                    String defaultImplClassName, ClassLoader classLoader,
83                                                    final ExceptionHandler<T> handler) throws T {
84        try {
85            return safeLoadClass(className, defaultImplClassName, classLoader).newInstance();
86        } catch (ClassNotFoundException x) {
87            throw handler.createException(x, "Provider " + className + " not found");
88        } catch (Exception x) {
89            throw handler.createException(x, "Provider " + className + " could not be instantiated: " + x);
90        }
91    }
92
93    static Class safeLoadClass(String className,
94                               String defaultImplClassName,
95                               ClassLoader classLoader) throws ClassNotFoundException {
96
97        try {
98            checkPackageAccess(className);
99        } catch (SecurityException se) {
100            // anyone can access the platform default factory class without permission
101            if (defaultImplClassName != null && defaultImplClassName.equals(className)) {
102                return Class.forName(className);
103            }
104            // not platform default implementation ...
105            throw se;
106        }
107        return nullSafeLoadClass(className, classLoader);
108    }
109
110    static <T extends Exception> ClassLoader contextClassLoader(ExceptionHandler<T> exceptionHandler) throws T {
111        try {
112            return Thread.currentThread().getContextClassLoader();
113        } catch (Exception x) {
114            throw exceptionHandler.createException(x, x.toString());
115        }
116    }
117
118    static abstract class ExceptionHandler<T extends Exception> {
119
120        public abstract T createException(Throwable throwable, String message);
121
122    }
123
124}
125