javax.xml.validation.SchemaFactoryFinder Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of qbicc-rt-java.xml Show documentation
Show all versions of qbicc-rt-java.xml Show documentation
The Qbicc builder for the java.xml JDK module
The newest version!
/*
* Copyright (c) 2003, 2021, 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 javax.xml.validation;
import com.sun.org.apache.xerces.internal.jaxp.validation.XMLSchemaFactory;
import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Properties;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
import java.util.function.Supplier;
import jdk.xml.internal.SecuritySupport;
/**
* Implementation of {@link SchemaFactory#newInstance(String)}.
*
* @author Kohsuke Kawaguchi
* @since 1.5
*/
class SchemaFactoryFinder {
/** debug support code. */
private static boolean debug = false;
private static final String DEFAULT_PACKAGE = "com.sun.org.apache.xerces.internal";
/**
* Cache properties for performance.
*/
private static final Properties cacheProps = new Properties();
/**
* First time requires initialization overhead.
*/
private static volatile boolean firstTime = true;
static {
// Use try/catch block to support applets
try {
debug = SecuritySupport.getSystemProperty("jaxp.debug") != null;
} catch (Exception unused) {
debug = false;
}
}
/**
* Conditional debug printing.
*
* @param msgGen Supplier function that returns debug message
*/
private static void debugPrintln(Supplier msgGen) {
if (debug) {
System.err.println("JAXP: " + msgGen.get());
}
}
/**
* ClassLoader to use to find SchemaFactory.
*/
private final ClassLoader classLoader;
/**
* Constructor that specifies ClassLoader to use
* to find SchemaFactory.
*
* @param loader
* to be used to load resource, {@link SchemaFactory}, and
* {@link SchemaFactoryLoader} implementations during
* the resolution process.
* If this parameter is null, the default system class loader
* will be used.
*/
public SchemaFactoryFinder(ClassLoader loader) {
this.classLoader = loader;
if( debug ) {
debugDisplayClassLoader();
}
}
private void debugDisplayClassLoader() {
try {
if( classLoader == SecuritySupport.getContextClassLoader() ) {
debugPrintln(()->"using thread context class loader ("+classLoader+") for search");
return;
}
} catch( Throwable unused ) {
// getContextClassLoader() undefined in JDK1.1
}
if( classLoader==ClassLoader.getSystemClassLoader() ) {
debugPrintln(()->"using system class loader ("+classLoader+") for search");
return;
}
debugPrintln(()->"using class loader ("+classLoader+") for search");
}
/**
* Creates a new {@link SchemaFactory} object for the specified
* schema language.
*
* @param schemaLanguage
* See {@link SchemaFactory Schema Language} table in SchemaFactory
* for the list of available schema languages.
*
* @return null if the callee fails to create one.
*
* @throws NullPointerException
* If the schemaLanguage parameter is null.
* @throws SchemaFactoryConfigurationError
* If a configuration error is encountered.
*/
public SchemaFactory newFactory(String schemaLanguage) {
if(schemaLanguage==null) {
throw new NullPointerException();
}
SchemaFactory f = _newFactory(schemaLanguage);
if (f != null) {
debugPrintln(()->"factory '" + f.getClass().getName() + "' was found for " + schemaLanguage);
} else {
debugPrintln(()->"unable to find a factory for " + schemaLanguage);
}
return f;
}
/**
* Lookup a SchemaFactory for the given schemaLanguage.
*
* @param schemaLanguage Schema language to lookup SchemaFactory for.
*
* @return SchemaFactory for the given schemaLanguage.
*/
private SchemaFactory _newFactory(String schemaLanguage) {
SchemaFactory sf;
String propertyName = SERVICE_CLASS.getName() + ":" + schemaLanguage;
// system property look up
try {
debugPrintln(()->"Looking up system property '"+propertyName+"'" );
String r = SecuritySupport.getSystemProperty(propertyName);
if(r!=null) {
debugPrintln(()->"The value is '"+r+"'");
sf = createInstance(r);
if(sf!=null) return sf;
} else
debugPrintln(()->"The property is undefined.");
} catch( Throwable t ) {
if( debug ) {
debugPrintln(()->"failed to look up system property '"+propertyName+"'" );
t.printStackTrace();
}
}
String javah = SecuritySupport.getSystemProperty( "java.home" );
String configFile = javah + File.separator +
"conf" + File.separator + "jaxp.properties";
// try to read from $java.home/conf/jaxp.properties
try {
if(firstTime){
synchronized(cacheProps){
if(firstTime){
File f=new File( configFile );
firstTime = false;
if(SecuritySupport.doesFileExist(f)){
debugPrintln(()->"Read properties file " + f);
cacheProps.load(SecuritySupport.getFileInputStream(f));
}
}
}
}
final String factoryClassName = cacheProps.getProperty(propertyName);
debugPrintln(()->"found " + factoryClassName + " in $java.home/conf/jaxp.properties");
if (factoryClassName != null) {
sf = createInstance(factoryClassName);
if(sf != null){
return sf;
}
}
} catch (Exception ex) {
if (debug) {
ex.printStackTrace();
}
}
// Try with ServiceLoader
final SchemaFactory factoryImpl = findServiceProvider(schemaLanguage);
// The following assertion should always be true.
// Uncomment it, recompile, and run with -ea in case of doubts:
// assert factoryImpl == null || factoryImpl.isSchemaLanguageSupported(schemaLanguage);
if (factoryImpl != null) {
return factoryImpl;
}
// platform default
if(schemaLanguage.equals("http://www.w3.org/2001/XMLSchema")) {
debugPrintln(()->"attempting to use the platform default XML Schema validator");
return new XMLSchemaFactory();
}
debugPrintln(()->"all things were tried, but none was found. bailing out.");
return null;
}
/** Create class using appropriate ClassLoader.
*
* @param className Name of class to create.
* @return Created class or null.
*/
@SuppressWarnings("removal")
private Class createClass(String className) {
Class clazz;
// make sure we have access to restricted packages
boolean internal = false;
if (System.getSecurityManager() != null) {
if (className != null && className.startsWith(DEFAULT_PACKAGE)) {
internal = true;
}
}
try {
if (classLoader != null && !internal) {
clazz = Class.forName(className, false, classLoader);
} else {
clazz = Class.forName(className);
}
} catch (Throwable t) {
if(debug) {
t.printStackTrace();
}
return null;
}
return clazz;
}
/**
* Creates an instance of the specified and returns it.
*
* @param className
* fully qualified class name to be instantiated.
*
* @return null
* if it fails. Error messages will be printed by this method.
*/
SchemaFactory createInstance(String className) {
SchemaFactory schemaFactory = null;
debugPrintln(()->"createInstance(" + className + ")");
// get Class from className
Class clazz = createClass(className);
if (clazz == null) {
debugPrintln(()->"failed to getClass(" + className + ")");
return null;
}
debugPrintln(()->"loaded " + className + " from " + which(clazz));
// instantiate Class as a SchemaFactory
try {
if (!SchemaFactory.class.isAssignableFrom(clazz)) {
throw new ClassCastException(clazz.getName()
+ " cannot be cast to " + SchemaFactory.class);
}
schemaFactory = (SchemaFactory) clazz.getConstructor().newInstance();
} catch (ClassCastException | IllegalAccessException | IllegalArgumentException |
InstantiationException | InvocationTargetException | NoSuchMethodException |
SecurityException ex) {
debugPrintln(()->"could not instantiate " + clazz.getName());
if (debug) {
ex.printStackTrace();
}
return null;
}
return schemaFactory;
}
// Call isSchemaLanguageSupported with initial context.
@SuppressWarnings("removal")
private boolean isSchemaLanguageSupportedBy(final SchemaFactory factory,
final String schemaLanguage,
AccessControlContext acc) {
return AccessController.doPrivileged(new PrivilegedAction() {
public Boolean run() {
return factory.isSchemaLanguageSupported(schemaLanguage);
}
}, acc);
}
/**
* Finds a service provider subclass of SchemaFactory that supports the
* given schema language using the ServiceLoader.
*
* @param schemaLanguage The schema language for which we seek a factory.
* @return A SchemaFactory supporting the specified schema language, or null
* if none is found.
* @throws SchemaFactoryConfigurationError if a configuration error is found.
*/
@SuppressWarnings("removal")
private SchemaFactory findServiceProvider(final String schemaLanguage) {
assert schemaLanguage != null;
// store current context.
final AccessControlContext acc = AccessController.getContext();
try {
return AccessController.doPrivileged(new PrivilegedAction() {
public SchemaFactory run() {
final ServiceLoader loader =
ServiceLoader.load(SERVICE_CLASS);
for (SchemaFactory factory : loader) {
// restore initial context to call
// factory.isSchemaLanguageSupported
if (isSchemaLanguageSupportedBy(factory, schemaLanguage, acc)) {
return factory;
}
}
return null; // no factory found.
}
});
} catch (ServiceConfigurationError error) {
throw new SchemaFactoryConfigurationError(
"Provider for " + SERVICE_CLASS + " cannot be created", error);
}
}
private static final Class SERVICE_CLASS = SchemaFactory.class;
// Used for debugging purposes
private static String which( Class clazz ) {
return SecuritySupport.getClassSource(clazz);
}
}