/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Copyright 2001-2004 The Apache Software Foundation.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * $Id: ObjectFactory.java,v 1.2.4.1 2005/09/15 02:39:54 jeffsuttor Exp $

 */

package com.sun.org.apache.xalan.internal.utils;

import java.io.InputStream;

import java.io.IOException;

import java.io.File;

import java.io.FileInputStream;

import java.util.Properties;

import java.io.BufferedReader;

import java.io.InputStreamReader;

/**

 * This class is duplicated for each JAXP subpackage so keep it in sync.

 * It is package private and therefore is not exposed as part of the JAXP

 * API.

 * <p>

 * This code is designed to implement the JAXP 1.1 spec pluggability

 * feature and is designed to run on JDK version 1.1 and

 * later, and to compile on JDK 1.2 and onward.

 * The code also runs both as part of an unbundled jar file and

 * when bundled as part of the JDK.

 * <p>

 * This class was moved from the <code>javax.xml.parsers.ObjectFactory</code>

 * class and modified to be used as a general utility for creating objects

 * dynamically.

 *

 * @version $Id: ObjectFactory.java,v 1.11 2010-11-01 04:34:25 joehw Exp $

 */

public class ObjectFactory {

    //

    // Constants

    //

    // name of default properties file to look for in JDK's jre/lib directory

    private static final String DEFAULT_PROPERTIES_FILENAME =

                                                     "xalan.properties";

    private static final String SERVICES_PATH = "META-INF/services/";

    /** Set to true for debugging */

    private static final boolean DEBUG = false;

    /** cache the contents of the xalan.properties file.

     *  Until an attempt has been made to read this file, this will

     * be null; if the file does not exist or we encounter some other error

     * during the read, this will be empty.

     */

    private static Properties fXalanProperties = null;

    /***

     * Cache the time stamp of the xalan.properties file so

     * that we know if it's been modified and can invalidate

     * the cache when necessary.

     */

    private static long fLastModified = -1;

    //

    // Public static methods

    //

    /**

     * Finds the implementation Class object in the specified order.  The

     * specified order is the following:

     * <ol>

     *  <li>query the system property using <code>System.getProperty</code>

     *  <li>read <code>META-INF/services/<i>factoryId</i></code> file

     *  <li>use fallback classname

     * </ol>

     *

     * @return instance of factory, never null

     *

     * @param factoryId             Name of the factory to find, same as

     *                              a property name

     * @param fallbackClassName     Implementation class name, if nothing else

     *                              is found.  Use null to mean no fallback.

     *

     * @exception ObjectFactory.ConfigurationError

     */

    public static Object createObject(String factoryId, String fallbackClassName)

        throws ConfigurationError {

        return createObject(factoryId, null, fallbackClassName);

    } // createObject(String,String):Object

    /**

     * Finds the implementation Class object in the specified order.  The

     * specified order is the following:

     * <ol>

     *  <li>query the system property using <code>System.getProperty</code>

     *  <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file

     *  <li>read <code>META-INF/services/<i>factoryId</i></code> file

     *  <li>use fallback classname

     * </ol>

     *

     * @return instance of factory, never null

     *

     * @param factoryId             Name of the factory to find, same as

     *                              a property name

     * @param propertiesFilename The filename in the $java.home/lib directory

     *                           of the properties file.  If none specified,

     *                           ${java.home}/lib/xalan.properties will be used.

     * @param fallbackClassName     Implementation class name, if nothing else

     *                              is found.  Use null to mean no fallback.

     *

     * @exception ObjectFactory.ConfigurationError

     */

    static Object createObject(String factoryId,

                                      String propertiesFilename,

                                      String fallbackClassName)

        throws ConfigurationError

    {

        Class factoryClass = lookUpFactoryClass(factoryId,

                                                propertiesFilename,

                                                fallbackClassName);

        if (factoryClass == null) {

            throw new ConfigurationError(

                "Provider for " + factoryId + " cannot be found", null);

        }

        try{

            Object instance = factoryClass.newInstance();

            if (DEBUG) debugPrintln("created new instance of factory " + factoryId);

            return instance;

        } catch (Exception x) {

            throw new ConfigurationError(

                "Provider for factory " + factoryId

                    + " could not be instantiated: " + x, x);

        }

    } // createObject(String,String,String):Object

    /**

     * Finds the implementation Class object in the specified order.  The

     * specified order is the following:

     * <ol>

     *  <li>query the system property using <code>System.getProperty</code>

     *  <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file

     *  <li>read <code>META-INF/services/<i>factoryId</i></code> file

     *  <li>use fallback classname

     * </ol>

     *

     * @return Class object of factory, never null

     *

     * @param factoryId             Name of the factory to find, same as

     *                              a property name

     * @param propertiesFilename The filename in the $java.home/lib directory

     *                           of the properties file.  If none specified,

     *                           ${java.home}/lib/xalan.properties will be used.

     * @param fallbackClassName     Implementation class name, if nothing else

     *                              is found.  Use null to mean no fallback.

     *

     * @exception ObjectFactory.ConfigurationError

     */

    public static Class lookUpFactoryClass(String factoryId)

        throws ConfigurationError

    {

        return lookUpFactoryClass(factoryId, null, null);

    } // lookUpFactoryClass(String):Class

    /**

     * Finds the implementation Class object in the specified order.  The

     * specified order is the following:

     * <ol>

     *  <li>query the system property using <code>System.getProperty</code>

     *  <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file

     *  <li>read <code>META-INF/services/<i>factoryId</i></code> file

     *  <li>use fallback classname

     * </ol>

     *

     * @return Class object that provides factory service, never null

     *

     * @param factoryId             Name of the factory to find, same as

     *                              a property name

     * @param propertiesFilename The filename in the $java.home/lib directory

     *                           of the properties file.  If none specified,

     *                           ${java.home}/lib/xalan.properties will be used.

     * @param fallbackClassName     Implementation class name, if nothing else

     *                              is found.  Use null to mean no fallback.

     *

     * @exception ObjectFactory.ConfigurationError

     */

    public static Class lookUpFactoryClass(String factoryId,

                                           String propertiesFilename,

                                           String fallbackClassName)

        throws ConfigurationError

    {

        String factoryClassName = lookUpFactoryClassName(factoryId,

                                                         propertiesFilename,

                                                         fallbackClassName);

        ClassLoader cl = findClassLoader();

        if (factoryClassName == null) {

            factoryClassName = fallbackClassName;

        }

        // assert(className != null);

        try{

            Class providerClass = findProviderClass(factoryClassName,

                                                    cl,

                                                    true);

            if (DEBUG) debugPrintln("created new instance of " + providerClass +

                   " using ClassLoader: " + cl);

            return providerClass;

        } catch (ClassNotFoundException x) {

            throw new ConfigurationError(

                "Provider " + factoryClassName + " not found", x);

        } catch (Exception x) {

            throw new ConfigurationError(

                "Provider "+factoryClassName+" could not be instantiated: "+x,

                x);

        }

    } // lookUpFactoryClass(String,String,String):Class

    /**

     * Finds the name of the required implementation class in the specified

     * order.  The specified order is the following:

     * <ol>

     *  <li>query the system property using <code>System.getProperty</code>

     *  <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file

     *  <li>read <code>META-INF/services/<i>factoryId</i></code> file

     *  <li>use fallback classname

     * </ol>

     *

     * @return name of class that provides factory service, never null

     *

     * @param factoryId             Name of the factory to find, same as

     *                              a property name

     * @param propertiesFilename The filename in the $java.home/lib directory

     *                           of the properties file.  If none specified,

     *                           ${java.home}/lib/xalan.properties will be used.

     * @param fallbackClassName     Implementation class name, if nothing else

     *                              is found.  Use null to mean no fallback.

     *

     * @exception ObjectFactory.ConfigurationError

     */

    static String lookUpFactoryClassName(String factoryId,

                                                String propertiesFilename,

                                                String fallbackClassName)

    {

        // Use the system property first

        try {

            String systemProp = SecuritySupport.getSystemProperty(factoryId);

            if (systemProp != null) {

                if (DEBUG) debugPrintln("found system property, value=" + systemProp);

                return systemProp;

            }

        } catch (SecurityException se) {

            // Ignore and continue w/ next location

        }

        // Try to read from propertiesFilename, or

        // $java.home/lib/xalan.properties

        String factoryClassName = null;

        // no properties file name specified; use

        // $JAVA_HOME/lib/xalan.properties:

        if (propertiesFilename == null) {

            File propertiesFile = null;

            boolean propertiesFileExists = false;

            try {

                String javah = SecuritySupport.getSystemProperty("java.home");

                propertiesFilename = javah + File.separator +

                    "lib" + File.separator + DEFAULT_PROPERTIES_FILENAME;

                propertiesFile = new File(propertiesFilename);

                propertiesFileExists = SecuritySupport.getFileExists(propertiesFile);

            } catch (SecurityException e) {

                // try again...

                fLastModified = -1;

                fXalanProperties = null;

            }

            synchronized (ObjectFactory.class) {

                boolean loadProperties = false;

                FileInputStream fis = null;

                try {

                    // file existed last time

                    if(fLastModified >= 0) {

                        if(propertiesFileExists &&

                                (fLastModified < (fLastModified = SecuritySupport.getLastModified(propertiesFile)))) {

                            loadProperties = true;

                        } else {

                            // file has stopped existing...

                            if(!propertiesFileExists) {

                                fLastModified = -1;

                                fXalanProperties = null;

                            } // else, file wasn't modified!

                        }

                    } else {

                        // file has started to exist:

                        if(propertiesFileExists) {

                            loadProperties = true;

                            fLastModified = SecuritySupport.getLastModified(propertiesFile);

                        } // else, nothing's changed

                    }

                    if(loadProperties) {

                        // must never have attempted to read xalan.properties

                        // before (or it's outdeated)

                        fXalanProperties = new Properties();

                        fis = SecuritySupport.getFileInputStream(propertiesFile);

                        fXalanProperties.load(fis);

                    }

                } catch (Exception x) {

                    fXalanProperties = null;

                    fLastModified = -1;

                    // assert(x instanceof FileNotFoundException

                    //        || x instanceof SecurityException)

                    // In both cases, ignore and continue w/ next location

                }

                finally {

                    // try to close the input stream if one was opened.

                    if (fis != null) {

                        try {

                            fis.close();

                        }

                        // Ignore the exception.

                        catch (IOException exc) {}

                    }

                }

            }

            if(fXalanProperties != null) {

                factoryClassName = fXalanProperties.getProperty(factoryId);

            }

        } else {

            FileInputStream fis = null;

            try {

                fis = SecuritySupport.getFileInputStream(new File(propertiesFilename));

                Properties props = new Properties();

                props.load(fis);

                factoryClassName = props.getProperty(factoryId);

            } catch (Exception x) {

                // assert(x instanceof FileNotFoundException

                //        || x instanceof SecurityException)

                // In both cases, ignore and continue w/ next location

            }

            finally {

                // try to close the input stream if one was opened.

                if (fis != null) {

                    try {

                        fis.close();

                    }

                    // Ignore the exception.

                    catch (IOException exc) {}

                }

            }

        }

        if (factoryClassName != null) {

            if (DEBUG) debugPrintln("found in " + propertiesFilename + ", value="

                          + factoryClassName);

            return factoryClassName;

        }

        // Try Jar Service Provider Mechanism

        return findJarServiceProviderName(factoryId);

    } // lookUpFactoryClass(String,String):String

    //

    // Private static methods

    //

    /** Prints a message to standard error if debugging is enabled. */

    private static void debugPrintln(String msg) {

        if (DEBUG) {

            System.err.println("JAXP: " + msg);

        }

    } // debugPrintln(String)

    /**

     * Figure out which ClassLoader to use.  For JDK 1.2 and later use

     * the context ClassLoader.

     */

    public static ClassLoader findClassLoader()

        throws ConfigurationError

    {

        if (System.getSecurityManager()!=null) {

            //this will ensure bootclassloader is used

            return null;

        }

        // Figure out which ClassLoader to use for loading the provider

        // class.  If there is a Context ClassLoader then use it.

        ClassLoader context = SecuritySupport.getContextClassLoader();

        ClassLoader system = SecuritySupport.getSystemClassLoader();

        ClassLoader chain = system;

        while (true) {

            if (context == chain) {

                // Assert: we are on JDK 1.1 or we have no Context ClassLoader

                // or any Context ClassLoader in chain of system classloader

                // (including extension ClassLoader) so extend to widest

                // ClassLoader (always look in system ClassLoader if Xalan

                // is in boot/extension/system classpath and in current

                // ClassLoader otherwise); normal classloaders delegate

                // back to system ClassLoader first so this widening doesn't

                // change the fact that context ClassLoader will be consulted

                ClassLoader current = ObjectFactory.class.getClassLoader();

                chain = system;

                while (true) {

                    if (current == chain) {

                        // Assert: Current ClassLoader in chain of

                        // boot/extension/system ClassLoaders

                        return system;

                    }

                    if (chain == null) {

                        break;

                    }

                    chain = SecuritySupport.getParentClassLoader(chain);

                }

                // Assert: Current ClassLoader not in chain of

                // boot/extension/system ClassLoaders

                return current;

            }

            if (chain == null) {

                // boot ClassLoader reached

                break;

            }

            // Check for any extension ClassLoaders in chain up to

            // boot ClassLoader

            chain = SecuritySupport.getParentClassLoader(chain);

        }

        // Assert: Context ClassLoader not in chain of

        // boot/extension/system ClassLoaders

        return context;

    } // findClassLoader():ClassLoader

    /**

     * Create an instance of a class using the same classloader for the ObjectFactory by default

     * or bootclassloader when Security Manager is in place

     */

    public static Object newInstance(String className, boolean doFallback)

        throws ConfigurationError

    {

        if (System.getSecurityManager()!=null) {

            return newInstance(className, null, doFallback);

        } else {

            return newInstance(className,

                findClassLoader (), doFallback);

        }

    }

    /**

     * Create an instance of a class using the specified ClassLoader

     */

    static Object newInstance(String className, ClassLoader cl,

                                      boolean doFallback)

        throws ConfigurationError

    {

        // assert(className != null);

        try{

            Class providerClass = findProviderClass(className, cl, doFallback);

            Object instance = providerClass.newInstance();

            if (DEBUG) debugPrintln("created new instance of " + providerClass +

                   " using ClassLoader: " + cl);

            return instance;

        } catch (ClassNotFoundException x) {

            throw new ConfigurationError(

                "Provider " + className + " not found", x);

        } catch (Exception x) {

            throw new ConfigurationError(

                "Provider " + className + " could not be instantiated: " + x,

                x);

        }

    }

    /**

     * Find a Class using the same classloader for the ObjectFactory by default

     * or bootclassloader when Security Manager is in place

     */

    public static Class findProviderClass(String className, boolean doFallback)

        throws ClassNotFoundException, ConfigurationError

    {

        if (System.getSecurityManager()!=null) {

            return Class.forName(className);

        } else {

            return findProviderClass (className,

                findClassLoader (), doFallback);

        }

    }

    /**

     * Find a Class using the specified ClassLoader

     */

    static Class findProviderClass(String className, ClassLoader cl,

                                           boolean doFallback)

        throws ClassNotFoundException, ConfigurationError

    {

        //throw security exception if the calling thread is not allowed to access the

        //class. Restrict the access to the package classes as specified in java.security policy.

        SecurityManager security = System.getSecurityManager();

        try{

                    final int lastDot = className.lastIndexOf(".");

                    String packageName = className;

                    if (lastDot != -1) packageName = className.substring(0, lastDot);

                    security.checkPackageAccess(packageName);