1 /*
   2  * Copyright (c) 2003, 2006, 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 javax.xml.transform;
  27 
  28 import java.io.File;
  29 import java.lang.reflect.Method;
  30 import java.security.AccessController;
  31 import java.security.PrivilegedAction;
  32 import java.util.Properties;
  33 import java.util.ServiceConfigurationError;
  34 import java.util.ServiceLoader;
  35 
  36 /**
  37  * <p>Implements pluggable Datatypes.</p>
  38  *
  39  * <p>This class is duplicated for each JAXP subpackage so keep it in sync. It
  40  * is package private for secure class loading.</p>
  41  *
  42  * @author Santiago.PericasGeertsen@sun.com
  43  * @author Huizhe.Wang@oracle.com
  44  */
  45 class FactoryFinder {
  46 
  47     /**
  48      * Internal debug flag.
  49      */
  50     private static boolean debug = false;
  51     /**
  52      * Cache for properties in java.home/lib/jaxp.properties
  53      */
  54     static Properties cacheProps = new Properties();
  55     /**
  56      * Flag indicating if properties from java.home/lib/jaxp.properties have
  57      * been cached.
  58      */
  59     static volatile boolean firstTime = true;
  60     /**
  61      * Security support class use to check access control before getting certain
  62      * system resources.
  63      */
  64     static SecuritySupport ss = new SecuritySupport();
  65 
  66     // Define system property "jaxp.debug" to get output
  67     static {
  68         // Use try/catch block to support applets, which throws
  69         // SecurityException out of this code.
  70         try {
  71             String val = ss.getSystemProperty("jaxp.debug");
  72             // Allow simply setting the prop to turn on debug
  73             debug = val != null && !"false".equals(val);
  74         } catch (SecurityException se) {
  75             debug = false;
  76         }
  77     }
  78 
  79     private static void dPrint(String msg) {
  80         if (debug) {
  81             System.err.println("JAXP: " + msg);
  82         }
  83     }
  84 
  85     /**
  86      * Attempt to load a class using the class loader supplied. If that fails
  87      * and fall back is enabled, the current (i.e. bootstrap) class loader is
  88      * tried.
  89      *
  90      * If the class loader supplied is
  91      * <code>null</code>, first try using the context class loader followed by
  92      * the current (i.e. bootstrap) class loader.
  93      *
  94      * Use bootstrap classLoader if cl = null and useBSClsLoader is true
  95      */
  96     static private Class getProviderClass(String className, ClassLoader cl,
  97             boolean doFallback, boolean useBSClsLoader) throws ClassNotFoundException {
  98         try {
  99             if (cl == null) {
 100                 if (useBSClsLoader) {
 101                     return Class.forName(className, true, FactoryFinder.class.getClassLoader());
 102                 } else {
 103                     cl = ss.getContextClassLoader();
 104                     if (cl == null) {
 105                         throw new ClassNotFoundException();
 106                     } else {
 107                         return cl.loadClass(className);
 108                     }
 109                 }
 110             } else {
 111                 return cl.loadClass(className);
 112             }
 113         } catch (ClassNotFoundException e1) {
 114             if (doFallback) {
 115                 // Use current class loader - should always be bootstrap CL
 116                 return Class.forName(className, true, FactoryFinder.class.getClassLoader());
 117             } else {
 118                 throw e1;
 119             }
 120         }
 121     }
 122 
 123     /**
 124      * Create an instance of a class. Delegates to method
 125      * <code>getProviderClass()</code> in order to load the class.
 126      *
 127      * @param className Name of the concrete class corresponding to the service
 128      * provider
 129      *
 130      * @param cl <code>ClassLoader</code> used to load the factory class.
 131      * If <code>null</code> current <code>Thread</code>'s context classLoader is
 132      * used to load the factory class.
 133      *
 134      * @param doFallback True if the current ClassLoader should be tried as a
 135      * fallback if the class is not found using cl
 136      */
 137     static Object newInstance(String className, ClassLoader cl, boolean doFallback)
 138             throws TransformerFactoryConfigurationError {
 139         return newInstance(className, cl, doFallback, false, false);
 140     }
 141 
 142     /**
 143      * Create an instance of a class. Delegates to method
 144      * <code>getProviderClass()</code> in order to load the class.
 145      *
 146      * @param className Name of the concrete class corresponding to the service
 147      * provider
 148      *
 149      * @param cl <code>ClassLoader</code> used to load the factory class.
 150      * If <code>null</code> current <code>Thread</code>'s context classLoader is
 151      * used to load the factory class.
 152      *
 153      * @param doFallback True if the current ClassLoader should be tried as a
 154      * fallback if the class is not found using cl
 155      *
 156      * @param useBSClsLoader True if cl=null actually meant bootstrap
 157      * classLoader. This parameter is needed since
 158      * DocumentBuilderFactory/SAXParserFactory defined null as context
 159      * classLoader.
 160      *
 161      * @param useServicesMechanism True use services mechanism
 162      */
 163     static Object newInstance(String className, ClassLoader cl, boolean doFallback, boolean useBSClsLoader, boolean useServicesMechanism)
 164             throws TransformerFactoryConfigurationError {
 165         try {
 166             Class providerClass = getProviderClass(className, cl, doFallback, useBSClsLoader);
 167             Object instance = null;
 168             if (!useServicesMechanism) {
 169                 instance = newInstanceNoServiceLoader(providerClass);
 170             }
 171             if (instance == null) {
 172                 instance = providerClass.newInstance();
 173             }
 174             if (debug) {    // Extra check to avoid computing cl strings
 175                 dPrint("created new instance of " + providerClass
 176                         + " using ClassLoader: " + cl);
 177             }
 178             return instance;
 179         } catch (ClassNotFoundException x) {
 180             throw new TransformerFactoryConfigurationError(x,
 181                     "Provider " + className + " not found");
 182         } catch (Exception x) {
 183             throw new TransformerFactoryConfigurationError(x,
 184                     "Provider " + className + " could not be instantiated: " + x);
 185         }
 186     }
 187 
 188     /**
 189      * Try to construct using newTransformerFactoryNoServiceLoader method if
 190      * available.
 191      */
 192     private static Object newInstanceNoServiceLoader(
 193             Class<?> providerClass) {
 194         // Retain maximum compatibility if no security manager.
 195         if (System.getSecurityManager() == null) {
 196             return null;
 197         }
 198         try {
 199             Method creationMethod =
 200                     providerClass.getDeclaredMethod(
 201                     "newTransformerFactoryNoServiceLoader");
 202             return creationMethod.invoke(null, null);
 203         } catch (NoSuchMethodException exc) {
 204             return null;
 205         } catch (Exception exc) {
 206             return null;
 207         }
 208     }
 209 
 210     /**
 211      * Finds the implementation Class object in the specified order. Main entry
 212      * point.
 213      *
 214      * @return Class object of factory, never null
 215      *
 216      * @param factoryId Name of the factory to find, same as a property name
 217      * @param fallbackClassName Implementation class name, if nothing else is
 218      * found. Use null to mean no fallback.
 219      *
 220      * Package private so this code can be shared.
 221      */
 222     static Object find(Class factoryClass, String factoryId, String fallbackClassName)
 223             throws TransformerFactoryConfigurationError {
 224         dPrint("find factoryId =" + factoryId);
 225         // Use the system property first
 226         try {
 227             String systemProp = ss.getSystemProperty(factoryId);
 228             if (systemProp != null) {
 229                 dPrint("found system property, value=" + systemProp);
 230                 return newInstance(systemProp, null, true, false, true);
 231             }
 232         } catch (SecurityException se) {
 233             if (debug) {
 234                 se.printStackTrace();
 235             }
 236         }
 237 
 238         // try to read from $java.home/lib/jaxp.properties
 239         try {
 240             String factoryClassName = null;
 241             if (firstTime) {
 242                 synchronized (cacheProps) {
 243                     if (firstTime) {
 244                         String configFile = ss.getSystemProperty("java.home") + File.separator
 245                                 + "lib" + File.separator + "jaxp.properties";
 246                         File f = new File(configFile);
 247                         firstTime = false;
 248                         if (ss.doesFileExist(f)) {
 249                             dPrint("Read properties file " + f);
 250                             cacheProps.load(ss.getFileInputStream(f));
 251                         }
 252                     }
 253                 }
 254             }
 255             factoryClassName = cacheProps.getProperty(factoryId);
 256 
 257             if (factoryClassName != null) {
 258                 dPrint("found in $java.home/jaxp.properties, value=" + factoryClassName);
 259                 return newInstance(factoryClassName, null, true, false, true);
 260             }
 261         } catch (Exception ex) {
 262             if (debug) {
 263                 ex.printStackTrace();
 264             }
 265         }
 266 
 267         // Try Jar Service Provider Mechanism
 268         Object provider = findServiceProvider(factoryClass, fallbackClassName);
 269         if (provider != null) {
 270             return provider;
 271         }
 272         if (fallbackClassName == null) {
 273             throw new TransformerFactoryConfigurationError(null,
 274                     "Provider for " + factoryId + " cannot be found");
 275         }
 276 
 277         dPrint("loaded from fallback value: " + fallbackClassName);
 278         return newInstance(fallbackClassName, null, true, false, true);
 279     }
 280 
 281     /*
 282      * Try to find a provider using Service Loader
 283      *
 284      * @return instance of provider class if found or null
 285      */
 286     private static Object findServiceProvider(final Class factoryClass, final String fallbackClassName)
 287             throws TransformerFactoryConfigurationError {
 288         try {
 289             return AccessController.doPrivileged(new PrivilegedAction() {
 290                 public Object run() {
 291                     Object defaultProvider = null;
 292                     for (Object factory : ServiceLoader.load(factoryClass)) {
 293                         if (factory.getClass().getName().equals(fallbackClassName)) {
 294                             defaultProvider = factory;
 295                         } else {
 296                             return factory;
 297                         }
 298                     }
 299                     if (defaultProvider != null) {
 300                         return defaultProvider;
 301                     }
 302                     return null;
 303                 }
 304             });
 305         } catch (ServiceConfigurationError e) {
 306             throw new TransformerFactoryConfigurationError((Exception) e.getCause(), e.getMessage());
 307         }
 308     }
 309 }