RMIClassLoader provider that supports preferred
* classes.
*
* See the {@link RMIClassLoader} specification for information
* about how to install and configure the RMIClassLoader
* service provider.
*
*
PreferredClassProvider uses instances of {@link
* PreferredClassLoader} to load classes from codebase URL paths
* supplied to RMIClassLoader.loadClass methods.
*
*
PreferredClassProvider does not enforce {@link
* DownloadPermission} by default, but a subclass can configure it to
* do so by passing true as the argument to the
* protected constructor.
*
*
By overriding the {@link #getClassAnnotation(ClassLoader) * getClassAnnotation(ClassLoader)} method, a subclass can also * configure the class annotations to be used for classes defined by * the system class loader, its ancestor class loaders, and any class * loader that is not an instance of {@link ClassAnnotation} or {@link * URLClassLoader}. * *
PreferredClassProvider implements the abstract
* methods of RMIClassLoaderSpi. Where applicable, these
* definitions and descriptions are relative to the instance of
* PreferredClassProvider on which a method is invoked
* and the context in which it is invoked.
*
* The annotation string for a class loader is determined by * the following procedure: * *
A PreferredClassProvider maintains an internal
* table of class loader instances indexed by keys that comprise a
* path of URLs and a parent class loader. The table does not
* strongly reference the class loader instances, in order to allow
* them (and the classes they have defined) to be garbage collected
* when they are not otherwise reachable.
*
*
The methods {@link #loadClass loadClass}, {@link #loadProxyClass
* loadProxyClass}, and {@link #getClassLoader getClassLoader}, which
* each have a String parameter named
* codebase, have the following behaviors in common:
*
*
codebase may be null. If it is not
* null, it is interpreted as a path of URLs by parsing
* it as a list of URLs separated by spaces. It is recommended that
* URLs be compliant with RFC3986 Syntax. Prior to parsing, any file path
* separators converted to '/' and any illegal characters are percentage escaped,
* URI(String) is used to parse each URL and then normalised
* in compliance with RFC3986, in addition file URL paths are
* converted to upper case for case insensitive file systems. The array of
* RFC3986 normalised URIs along with the current threads context ClassLoader
* is used to locate the correct ClassLoader. After normalisation is complete,
* each URL is parsed with the URL(String) constructor; this could
* result in a {@link MalformedURLException}. This path of URLs is the
* codebase URL path for the invocation.
*
* - A class loader known as the codebase loader is chosen
* based on
codebase and the current thread's context
* class loader as follows. If codebase is
* null, then the codebase loader is the current thread's
* context class loader. Otherwise, for each non-null
* loader starting with the current thread's context class loader and
* continuing with each successive parent class loader, if the
* codebase URI RFC3986 normalised path is equal to the loader's annotation
* URI RFC3986 normalised path, then the codebase loader is that loader.
* If no such matching loader is found, then the codebase loader is the loader
* in this PreferredClassProvider's internal table with the
* codebase URI RFC3986 normalised path as the key's path of URLs and the current
* thread's context class loader as the key's parent class loader. If
* no such entry exists in the table, then one is created by invoking
* {@link #createClassLoader createClassLoader} with the codebase URL
* path, the current thread's context class loader, and the
* boolean requireDlPerm value that this
* PreferredClassProvider was constructed with; the
* created loader is added to the table, and it is chosen as the
* codebase loader.
*
* - The current security context has permission to access the
* codebase loader if it has the appropriate permission for each
* of the URLs in the codebase loader's annotation URL path, where the
* appropriate permission for a URL is defined as follows. If the
* result of invoking {@link URL#openConnection
* openConnection()}.{@link URLConnection#getPermission
* getPermission()} on the
URL object is not a {@link
* FilePermission} or if it is a FilePermission whose
* name does not contain a directory separator, then that permission
* is the appropriate permission. If it is a
* FilePermission whose name contains a directory
* separator, then the appropriate permission is a
* FilePermission with action "read" and the
* same name except with the last path segment replaced with
* "-" (that is, permission to read all files in the same
* directory and all subdirectories).
*
* When PreferredClassProvider attempts to load a
* class (or interface) named N using class loader
* L, it does so in a manner equivalent to
* evaluating the following expression:
*
*
* Class.forName(* * In particular, the case ofN, false,L) *
N being the binary
* name of an array class is supported.
*
*
* @since 2.0
*
* @com.sun.jini.impl
*
* This implementation uses the {@link Logger} named
* net.jini.loader.pref.PreferredClassProvider to log
* information at the following levels:
*
*
| Level | Description * * |
|---|---|
| {@link Levels#FAILED FAILED} | class loading failures * * |
| {@link Levels#HANDLED HANDLED} | exceptions caught * during class loading operations * * |
| {@link Level#FINE FINE} | invocations of {@link * #loadClass loadClass} and {@link #loadProxyClass loadProxyClass} * * |
| {@link Level#FINEST FINEST} | detailed activity of
* loadClass and loadProxyClass
* implementations
*
* |
PreferredClassProvider.
*
* This constructor is used by the {@link RMIClassLoader}
* service provider location mechanism when
* PreferredClassProvider is configured as the
* RMIClassLoader provider class.
*
*
If there is a security manager, its {@link
* SecurityManager#checkCreateClassLoader checkCreateClassLoader}
* method is invoked; this could result in a
* SecurityException.
*
*
{@link DownloadPermission} is not enforced by the created
* provider.
*
* @throws SecurityException if there is a security manager and
* the invocation of its checkCreateClassLoader
* method fails
**/
public PreferredClassProvider() {
this(false);
}
/**
* Creates a new PreferredClassProvider.
*
*
This constructor is used by subclasses to control whether * or not {@link DownloadPermission} is enforced. * *
If there is a security manager, its {@link
* SecurityManager#checkCreateClassLoader checkCreateClassLoader}
* method is invoked; this could result in a
* If Otherwise, if Otherwise, this method attempts to load the class with the
* specified name using the codebase loader, if there is a
* security manager and the current security context has
* permission to access the codebase loader, or using the current
* thread's context class loader otherwise. If this attempt
* succeeds, this method returns the resulting If Otherwise, this method returns the annotation string for the
* defining class loader of This method is invoked in order to determine the annotation
* string for the system class loader, an ancestor of the system
* class loader, any class loader that is not an instance of
* {@link ClassAnnotation} or {@link URLClassLoader}, or (for an
* invocation of {@link #getClassAnnotation(Class)
* getClassAnnotation(Class)}) a This method returns the value of the system property
* If there is a security manager, its
* This method returns the codebase loader if there is a
* security manager, or the current thread's context class loader
* otherwise.
*
* @param codebase the codebase URL path as a space-separated list
* of URLs, or If Otherwise, this method attempts to load all of the
* interfaces named by the elements of This method creates a new instance of {@link
* PreferredClassLoader} that loads classes and resources from
* SecurityException.
*
* @param requireDlPerm if true, the class loaders
* created by the provider will only define classes with a {@link
* CodeSource} that is granted {@link DownloadPermission}
*
* @throws SecurityException if there is a security manager and
* the invocation of its checkCreateClassLoader
* method fails
**/
protected PreferredClassProvider(boolean requireDlPerm) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkCreateClassLoader();
}
this.requireDlPerm = requireDlPerm;
ConcurrentMapPreferredClassProvider implements this method
* as follows:
*
* name is the binary name of an array class
* (of one or more dimensions) with a primitive element type, this
* method returns the Class for that array class.
*
* defaultLoader is not
* null and any of the following conditions are true:
*
*
*
*
*
* then this method attempts to load the class with the specified
* name using codebase is null.
*
* defaultLoader.
*
* PreferredClassLoader and an invocation of {@link
* PreferredClassLoader#isPreferredResource isPreferredResource}
* on the codebase loader with the class name described below as
* the first argument and true as the second argument
* returns false. If name is the binary
* name of an array class (of one or more dimensions) with a
* element type that is a reference type, the class name passed to
* isPreferredResource is the binary name of that
* element type; otherwise, the class name passed to
* isPreferredResource is name. This
* invocation is only done if none of the previous conditions are
* true. If isPreferredResource throws an
* IOException, this method throws a
* ClassNotFoundException.
*
* defaultLoader. If this attempt
* succeeds, this method returns the resulting Class;
* if it throws a ClassNotFoundException, this method
* proceeds as follows.
*
* Class;
* if it throws a ClassNotFoundException, this method
* throws a ClassNotFoundException.
*
* @param codebase the codebase URL path as a space-separated list
* of URLs, or null
*
* @param name the binary name of the class to load
*
* @param defaultLoader additional contextual class loader
* to use, or null
*
* @return the Class object representing the loaded class
*
* @throws MalformedURLException if codebase is
* non-null and contains an invalid URL
*
* @throws ClassNotFoundException if a definition for the class
* could not be loaded
**/
public Class loadClass(String codebase,
String name,
ClassLoader defaultLoader)
throws MalformedURLException, ClassNotFoundException
{
checkInitialized();
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE,
"name=\"{0}\", codebase={1}, defaultLoader={2}",
new Object[] {
name,
codebase != null ? "\"" + codebase + "\"" : null,
defaultLoader
});
}
// throws MalformedURLException
URI[] codebaseURIs = pathToURIs(codebase); // may be null
URL[] codebaseURLs = asURL(codebaseURIs); // throws MalformedURLException
/*
* Process array class names.
*/
String elementTypeName = null;
int len = name.length();
if (len > 0 && name.charAt(0) == '[') {
int i = 1;
char c = 0;
while (i < len && (c = name.charAt(i)) == '[') {
i++;
}
if (len == i + 1 && PRIMITIVE_TYPES.indexOf(c) != -1) {
return Class.forName(name);
}
if (len > i + 2 && c == 'L' && name.charAt(len - 1) == ';') {
elementTypeName = name.substring(i + 1, len - 1);
}
}
/*
* Try defaultLoader cases that don't require determining the
* codebase loader.
*/
SecurityManager sm = System.getSecurityManager();
if (defaultLoader != null &&
(sm == null || codebaseURIs == null ||
urlsMatchLoaderAnnotation(codebaseURIs, defaultLoader)))
{
try {
Class c = Class.forName(name, false, defaultLoader);
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST, "class \"{0}\" found " +
"via defaultLoader, defined by {1}",
new Object[] { name, getClassLoader(c) });
}
return c;
} catch (ClassNotFoundException e) {
defaultLoader = null; // don't try defaultLoader again
}
}
/*
* Determine the codebase loader.
*/
ClassLoader contextLoader = getRMIContextClassLoader();
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST,
"(thread context class loader: {0})", contextLoader);
}
ClassLoader codebaseLoader;
codebaseLoader = lookupLoader(codebaseURIs, codebaseURLs, contextLoader);
/*
* Try remaining defaultLoader cases that don't require
* checking permission to access the codebase loader.
*/
if (defaultLoader != null &&
!(codebaseLoader instanceof PreferredClassLoader))
{
try {
Class c = Class.forName(name, false, defaultLoader);
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST, "class \"{0}\" found " +
"via defaultLoader, defined by {1}",
new Object[] { name, getClassLoader(c) });
}
return c;
} catch (ClassNotFoundException e) {
defaultLoader = null; // don't try defaultLoader again
}
}
/*
* Check permission to access the codebase loader.
*/
SecurityException secEx = null;
if (sm != null) {
try {
checkLoader(codebaseLoader, contextLoader, codebaseURIs, codebaseURLs);
} catch (SecurityException e) {
secEx = e;
}
}
/*
* Try remaining defaultLoader cases.
*/
if (defaultLoader != null) {
boolean tryDL = secEx != null;
if (!tryDL) {
try {
tryDL = !((PreferredClassLoader) codebaseLoader).
isPreferredResource(elementTypeName != null ?
elementTypeName : name, true);
} catch (IOException e) {
ClassNotFoundException cnfe =
new ClassNotFoundException(name +
" (could not determine preferred setting;" +
" original codebase: \"" + codebase + "\")", e);
if (logger.isLoggable(Levels.FAILED)) {
LogUtil.logThrow(logger, Levels.FAILED,
PreferredClassProvider.class, "loadClass",
"class \"{0}\" not found, " +
"could not obtain preferred value",
new Object[] { name }, cnfe);
}
throw cnfe;
}
}
if (tryDL) {
try {
Class c = Class.forName(name, false, defaultLoader);
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST, "class \"{0}\" found " +
"via defaultLoader, defined by {1}",
new Object[] { name, getClassLoader(c) });
}
return c;
} catch (ClassNotFoundException e) {
}
}
}
/*
* Done with defaultLoader, try the codebase loader or the
* context class loader as appropriate.
*/
try {
Class c = Class.forName(name, false,
(sm != null && secEx == null ?
codebaseLoader : contextLoader));
if (logger.isLoggable(Level.FINEST)) {
String message;
if (sm == null) {
message = "class \"{0}\" found " +
" via thread context class loader " +
" (no security manager), defined by {1}";
} else if (secEx != null) {
message = "class \"{0}\" found " +
" via thread context class loader " +
" (access to codebase loader denied), defined by {1}";
} else {
message = "class \"{0}\" found " +
"via codebase loader, defined by {1}";
}
logger.log(Level.FINEST, message,
new Object[] { name, getClassLoader(c) });
}
return c;
} catch (ClassNotFoundException e) {
if (sm == null) {
ClassNotFoundException cnfe =
new ClassNotFoundException(e.getMessage() +
" (no security manager: codebase loader disabled)", e);
if (logger.isLoggable(Levels.FAILED)) {
LogUtil.logThrow(logger, Levels.FAILED,
PreferredClassProvider.class, "loadClass",
"class \"{0}\" not found " +
"via thread context class loader " +
"(no security manager)",
new Object[] { name }, cnfe);
}
throw cnfe;
} else if (secEx != null) {
/*
* Presumably the original security exception is
* preferable to throw, but log both exceptions.
*/
if (logger.isLoggable(Levels.HANDLED)) {
LogUtil.logThrow(logger, Levels.HANDLED,
PreferredClassProvider.class, "loadClass",
"class \"{0}\" not found " +
"via thread context class loader " +
"(access to codebase loader denied)",
new Object[] { name }, e);
}
ClassNotFoundException cnfe =
new ClassNotFoundException(e.getMessage() +
" (access to codebase loader denied)", secEx);
if (logger.isLoggable(Levels.FAILED)) {
LogUtil.logThrow(logger, Levels.FAILED,
PreferredClassProvider.class, "loadClass",
"class \"{0}\" not found " +
"via thread context class loader " +
"(access to codebase loader denied)",
new Object[] { name }, cnfe);
}
throw cnfe;
} else {
if (logger.isLoggable(Levels.FAILED)) {
LogUtil.logThrow(logger, Levels.FAILED,
PreferredClassProvider.class, "loadClass",
"class \"{0}\" not found via codebase loader",
new Object[] { name }, e);
}
throw e;
}
}
}
/**
* Provides the implementation for {@link
* RMIClassLoaderSpi#getClassAnnotation(Class)}.
*
* PreferredClassProvider implements this method
* as follows:
*
* cl is an array class (of one or more
* dimensions) with a primitive element type, this method returns
* null.
*
* cl, except that if the
* annotation string would be determined by an invocation of
* {@link URLClassLoader#getURLs URLClassLoader.getURLs} on that
* loader and the current security context does not have the
* permissions necessary to connect to each URL returned by that
* invocation (where the permission to connect to a URL is
* determined by invoking {@link URL#openConnection
* openConnection()}.{@link URLConnection#getPermission
* getPermission()} on the URL object), this method
* returns the result of invoking {@link
* #getClassAnnotation(ClassLoader)
* getClassAnnotation(ClassLoader)} with the loader instead.
*
* @param cl the class to obtain the annotation string for
*
* @return the annotation string for the class, or
* null
**/
public String getClassAnnotation(Class cl) {
checkInitialized();
String name = cl.getName();
/*
* Class objects for arrays of primitive types never need an
* annotation, because they never need to be (or can be) downloaded.
*
* REMIND: should we (not) be annotating classes that are in
* "java.*" packages?
*/
int nameLength = name.length();
if (nameLength > 0 && name.charAt(0) == '[') {
// skip past all '[' characters (see bugid 4211906)
int i = 1;
while (nameLength > i && name.charAt(i) == '[') {
i++;
}
if (nameLength > i && name.charAt(i) != 'L') {
return null;
}
}
return getLoaderAnnotation(getClassLoader(cl), true);
}
/**
* Returns the annotation string for the specified class loader.
*
* URLClassLoader for
* which the current security context does not have the
* permissions necessary to connect to all of its URLs.
*
* PreferredClassProvider implements this method
* as follows:
*
* "java.rmi.server.codebase" (or possibly an earlier
* cached value).
*
* @param loader the class loader to obtain the annotation string
* for
*
* @return the annotation string for the class loader, or
* null
**/
protected String getClassAnnotation(ClassLoader loader) {
checkInitialized();
return codebaseProperty;
}
/**
* Returns the annotation string for the specified class loader
* (possibly null). If check is true and the annotation would be
* determined from an invocation of URLClassLoader.getURLs() on
* the loader, only return the true annotation if the current
* security context has permission to connect to all of the URLs.
**/
private String getLoaderAnnotation(ClassLoader loader, boolean check) {
if (isLocalLoader(loader)) {
return getClassAnnotation(loader);
}
/*
* Get the codebase URL path for the class loader, if it supports
* such a notion (i.e., if it is a URLClassLoader or subclass).
*/
String annotation = null;
if (loader instanceof ClassAnnotation) {
/*
* If the class loader is one of our RMI class loaders, we have
* already computed the class annotation string, and no
* permissions are required to know the URLs.
*/
annotation = ((ClassAnnotation) loader).getClassAnnotation();
} else if (loader instanceof URLClassLoader) {
try {
URL[] urls = ((URLClassLoader) loader).getURLs();
if (urls != null) {
if (check) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
Permissions perms = new Permissions();
for (int i = 0; i < urls.length; i++) {
Permission p =
urls[i].openConnection().getPermission();
if (p != null) {
if (!perms.implies(p)) {
sm.checkPermission(p);
perms.add(p);
}
}
}
}
}
annotation = PreferredClassLoader.urlsToPath(urls);
}
} catch (SecurityException e) {
/*
* If access was denied to the knowledge of the class
* loader's URLs, fall back to the default behavior.
*/
} catch (IOException e) {
/*
* This shouldn't happen, although it is declared to be
* thrown by openConnection() and getPermission(). If it
* does happen, forget about this class loader's URLs and
* fall back to the default behavior.
*/
}
}
if (annotation != null) {
return annotation;
} else {
return getClassAnnotation(loader);
}
}
/**
* Return true if the given loader is the system class loader or
* its parent (i.e. the loader for installed extensions) or the null
* class loader
*/
private static boolean isLocalLoader(ClassLoader loader) {
return (loader == null || localLoaders.containsKey(loader));
}
/**
* Provides the implementation for {@link
* RMIClassLoaderSpi#getClassLoader(String)}.
*
* PreferredClassProvider implements this method
* as follows:
*
* checkPermission method is invoked with a
* RuntimePermission("getClassLoader") permission;
* this could result in a SecurityException. Also,
* if there is a security manager, the codebase loader is not the
* current thread's context class loader, and the current security
* context does not have permission to access the codebase loader,
* this method throws a SecurityException.
*
* null
*
* @return a class loader for the specified codebase URL path
*
* @throws MalformedURLException if codebase is
* non-null and contains an invalid URL
*
* @throws SecurityException if there is a security manager and
* the invocation of its checkPermission method
* fails, or if the current security context does not have the
* permissions necessary to connect to all of the URLs in the
* codebase URL path
**/
public ClassLoader getClassLoader(String codebase)
throws MalformedURLException
{
checkInitialized();
// throws MalformedURLException
URI[] codebaseURIs = pathToURIs(codebase); // may be null
URL[] codebaseURLs = asURL(codebaseURIs); // throws MalformedURLException
ClassLoader contextLoader = getRMIContextClassLoader();
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(getClassLoaderPermission);
} else {
return contextLoader;
}
ClassLoader codebaseLoader;
codebaseLoader = lookupLoader(codebaseURIs, codebaseURLs, contextLoader);
checkLoader(codebaseLoader, contextLoader, codebaseURIs, codebaseURLs);
return codebaseLoader;
}
/**
* Provides the implementation of {@link
* RMIClassLoaderSpi#loadProxyClass(String,String[],ClassLoader)}.
*
* PreferredClassProvider implements this method
* as follows:
*
* defaultLoader is not null and
* any of the following conditions are true:
*
*
*
*
*
* then this method attempts to load all of the interfaces named
* by the elements of codebase is null.
*
* defaultLoader.
*
* PreferredClassLoader and an invocation of {@link
* PreferredClassLoader#isPreferredResource isPreferredResource}
* on the codebase loader for each element of
* interfaces, with the element as the first argument
* and true as the second argument, all return
* false. These invocations are only done if none of
* the previous conditions are true. If any invocation of
* isPreferredResource throws an
* IOException, this method throws a
* ClassNotFoundException.
*
* interfaces using
* defaultLoader. If all of the interfaces are
* loaded successfully, then
*
*
*
*
*
* If any of the attempts to load one of the interfaces throws a
* public: if
* there is a security manager, the codebase loader is the current
* thread's context class loader or the current security context
* has permission to access the codebase loader, and the
* annotation URL path for the codebase loader is not equal to the
* annotation URL path for defaultLoader, this method
* first attempts to get a dynamic proxy class (using {@link
* Proxy#getProxyClass Proxy.getProxyClass}) that is defined by
* the codebase loader and that implements all of the interfaces,
* and if this attempt succeeds, this method returns the resulting
* Class. Otherwise, this method attempts to get a
* dynamic proxy class that is defined by
* defaultLoader and that implements all of the
* interfaces. If that attempt succeeds, this method returns the
* resulting Class; if it throws an
* IllegalArgumentException, this method throws a
* ClassNotFoundException.
*
* public interfaces are
* defined by the same class loader: this method attempts to get a
* dynamic proxy class that is defined by that loader and that
* implements all of the interfaces. If this attempt succeeds,
* this method returns the resulting Class; if it
* throws an IllegalArgumentException, this method
* throws a ClassNotFoundException.
*
* public
* interfaces defined by different class loaders): this method
* throws a LinkageError.
*
* ClassNotFoundException, this method proceeds as
* follows.
*
* interfaces
* using the codebase loader, if there is a security manager and
* the current security context has permission to access the
* codebase loader, or using the current thread's context class
* loader otherwise. If all of the interfaces are loaded
* successfully, then
*
*
*
*
*
* If any of the attempts to load one of the interfaces throws a
* public:
* this method attempts to get a dynamic proxy class that is
* defined by the loader used to load the interfaces and that
* implements all of the interfaces. If this attempt succeeds,
* this method returns the resulting Class; if it
* throws an IllegalArgumentException, this method
* throws a ClassNotFoundException.
*
* public interfaces are
* defined by the same class loader: this method attempts to get a
* dynamic proxy class that is defined by that loader and that
* implements all of the interfaces. If this attempt succeeds,
* this method returns the resulting Class; if it
* throws an IllegalArgumentException, this method
* throws a ClassNotFoundException.
*
* public
* interfaces defined by different class loaders): this method
* throws a LinkageError.
*
* ClassNotFoundException, this method throws a
* ClassNotFoundException.
*
* @param codebase the codebase URL path as a space-separated list
* of URLs, or null
*
* @param interfaceNames the binary names of the interfaces for
* the proxy class to implement
*
* @return a dynamic proxy class that implements the named
* interfaces
*
* @param defaultLoader additional contextual class loader to use,
* or null
*
* @throws MalformedURLException if codebase is
* non-null and contains an invalid URL
*
* @throws ClassNotFoundException if a definition for one of the
* named interfaces could not be loaded, or if creation of the
* dynamic proxy class failed (such as if
* Proxy.getProxyClass would throw an
* IllegalArgumentException for the given interface
* list)
**/
public Class loadProxyClass(String codebase,
String[] interfaceNames,
ClassLoader defaultLoader)
throws MalformedURLException, ClassNotFoundException
{
checkInitialized();
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE,
"interfaces={0}, codebase={1}, defaultLoader={2}",
new Object[] {
Arrays.asList(interfaceNames),
codebase != null ? "\"" + codebase + "\"" : null,
defaultLoader
});
}
// throws MalformedURLException containing URISyntaxException message
URI[] codebaseURIs = pathToURIs(codebase); // may be null
URL[] codebaseURLs = asURL(codebaseURIs);
/*
* Determine the codebase loader.
*/
ClassLoader contextLoader = getRMIContextClassLoader();
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST,
"(thread context class loader: {0})", contextLoader);
}
ClassLoader codebaseLoader;
codebaseLoader = lookupLoader(codebaseURIs, codebaseURLs, contextLoader);
/*
* Check permission to access the codebase loader.
*/
SecurityManager sm = System.getSecurityManager();
SecurityException secEx = null;
if (sm != null) {
try {
checkLoader(codebaseLoader, contextLoader, codebaseURIs, codebaseURLs);
} catch (SecurityException e) {
secEx = e;
}
}
/*
* Try all defaultLoader cases.
*/
if (defaultLoader != null) {
boolean codebaseMatchesDL = false;
boolean tryDL =
sm == null || secEx != null ||
codebaseURIs == null;
if (!tryDL) {
codebaseMatchesDL =
urlsMatchLoaderAnnotation(codebaseURIs, defaultLoader);
tryDL = codebaseMatchesDL ||
!(codebaseLoader instanceof PreferredClassLoader) ||
!interfacePreferred((PreferredClassLoader) codebaseLoader,
interfaceNames, codebase);
// throws ClassNotFoundException if IOException occurs
}
if (tryDL) {
try {
boolean preferCodebaseLoader =
sm != null && secEx == null && !codebaseMatchesDL;
Class c = loadProxyClass(interfaceNames,
defaultLoader, "defaultLoader",
codebaseLoader,
preferCodebaseLoader);
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST,
getProxySuccessLogMessage(sm, secEx),
getClassLoader(c));
}
return c;
} catch (ClassNotFoundException e) {
} catch (IllegalArgumentException e) {
ClassNotFoundException cnfe = new ClassNotFoundException(
"dynamic proxy class creation failed", e);
if (logger.isLoggable(Levels.FAILED)) {
logger.log(Levels.FAILED,
"dynamic proxy class creation failed", e);
}
throw cnfe;
}
}
}
/*
* Try the codebase loader or the context class loader as
* appropriate.
*/
ClassLoader loader;
String loaderName;
if (sm != null && secEx == null) {
loader = codebaseLoader;
loaderName = "codebase loader";
} else {
loader = contextLoader;
loaderName = "thread context class loader";
}
try {
Class c = loadProxyClass(interfaceNames, loader, loaderName,
null, false);
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST,
getProxySuccessLogMessage(sm, secEx),
getClassLoader(c));
}
return c;
} catch (ClassNotFoundException e) {
if (sm == null) {
ClassNotFoundException cnfe =
new ClassNotFoundException(e.getMessage() +
" (no security manager: codebase loader disabled)", e);
if (logger.isLoggable(Levels.FAILED)) {
logger.log(Levels.FAILED,
"proxy class resolution failed (no security manager)",
cnfe);
}
throw cnfe;
} else if (secEx != null) {
/*
* Presumably the original security exception is
* preferable to throw, but log both exceptions.
*/
if (logger.isLoggable(Levels.HANDLED)) {
logger.log(Levels.HANDLED,
"proxy class resolution failed " +
"(access to codebase loader denied)", e);
}
ClassNotFoundException cnfe =
new ClassNotFoundException(e.getMessage() +
" (access to codebase loader denied)", secEx);
if (logger.isLoggable(Levels.FAILED)) {
logger.log(Levels.FAILED,
"proxy class resolution failed " +
"(access to codebase loader denied)", cnfe);
}
throw cnfe;
} else {
if (logger.isLoggable(Levels.FAILED)) {
logger.log(Levels.FAILED,
"proxy class resolution failed", e);
}
throw e;
}
} catch (IllegalArgumentException e) {
ClassNotFoundException cnfe = new ClassNotFoundException(
"dynamic proxy class creation failed", e);
if (logger.isLoggable(Levels.FAILED)) {
logger.log(Levels.FAILED,
"dynamic proxy class creation failed", e);
}
throw cnfe;
}
}
private static String getProxySuccessLogMessage(SecurityManager sm,
SecurityException secEx)
{
if (sm == null) {
return "(no security manager) proxy class defined by {0}";
} else if (secEx != null) {
return
"(access to codebase loader denied) " +
"proxy class defined by {0}";
} else {
return "proxy class defined by {0}";
}
}
/**
* Attempts to load the specified interfaces by name using the
* specified loader, and if that is successful, attempts to get a
* dynamic proxy class that implements those interfaces.
*
* If tryOtherLoaderFirst is true, attempts to get the proxy class
* defined by the specified other loader first, and if that fails,
* falls back to get the proxy class defined by the same loader
* used to load the interfaces; otherwise, only attempts to get
* the proxy class defined by the same loader used to load the
* interfaces.
*
* Throws a ClassNotFoundException if attempting to load any of
* the interfaces throws a ClassNotFoundException. Throws
* IllegalArgumentException if the final attempt to get a proxy
* class throws an IllegalArgumentException.
**/
private Class loadProxyClass(String[] interfaceNames,
ClassLoader interfaceLoader,
String interfaceLoaderName,
ClassLoader otherLoader,
boolean tryOtherLoaderFirst)
throws ClassNotFoundException
{
Class[] classObjs = new Class[interfaceNames.length];
boolean[] nonpublic = { false };
ClassLoader proxyLoader =
loadProxyInterfaces(interfaceNames, interfaceLoader,
classObjs, nonpublic);
if (logger.isLoggable(Level.FINEST)) {
ClassLoader[] definingLoaders = new ClassLoader[classObjs.length];
for (int i = 0; i < definingLoaders.length; i++) {
definingLoaders[i] = getClassLoader(classObjs[i]);
}
logger.log(Level.FINEST,
"proxy interfaces loaded via {0}, defined by {1}",
new Object[] {
interfaceLoaderName, Arrays.asList(definingLoaders)
});
}
if (!nonpublic[0]) {
if (tryOtherLoaderFirst) {
try {
return Proxy.getProxyClass(otherLoader, classObjs);
} catch (IllegalArgumentException e) {
}
}
proxyLoader = interfaceLoader;
}
return Proxy.getProxyClass(proxyLoader, classObjs);
}
/**
* Returns true if at least one of the specified interface names
* is preferred for the specified class loader; returns false if
* none of them are preferred. Throws ClassNotFoundException if
* PreferredClassLoader.isPreferredResource throws IOException
* (although isPreferredResource isn't necessarily invoked for all
* of the specified names, because this method short circuits on
* the first invocation that returns true). The codebase argument
* is the original codebase URL path passed to loadProxyClass,
* which typically but not necessarily equals the loader's import
* URL path.
**/
private boolean interfacePreferred(PreferredClassLoader codebaseLoader,
String[] interfaceNames,
String codebase)
throws ClassNotFoundException
{
for (int p = 0; p < interfaceNames.length; p++) {
try {
if (((PreferredClassLoader) codebaseLoader).
isPreferredResource(interfaceNames[p], true))
{
return true;
}
} catch (IOException e) {
ClassNotFoundException cnfe =
new ClassNotFoundException(interfaceNames[p] +
" (could not determine preferred setting;" +
" original codebase: \"" + codebase + "\")", e);
if (logger.isLoggable(Levels.FAILED)) {
LogUtil.logThrow(logger, Levels.FAILED,
PreferredClassProvider.class, "loadProxyClass",
"class \"{0}\" not found, " +
"could not obtain preferred value",
new Object[] { interfaceNames[p] }, cnfe);
}
throw cnfe;
}
}
return false;
}
/**
* Returns an array of URLs corresponding to the annotation string
* for the specified class loader, or null if the annotation
* string is null.
**/
private URI[] getLoaderAnnotationURIs(ClassLoader loader)
throws MalformedURLException
{
return pathToURIs(getLoaderAnnotation(loader, false));
}
/**
* Returns true if the specified path of URLs is equal to the
* annotation URLs of the specified loader, and false otherwise.
**/
private boolean urlsMatchLoaderAnnotation(URI[] urls, ClassLoader loader) {
try {
return Arrays.equals(urls, getLoaderAnnotationURIs(loader));
} catch (MalformedURLException e) {
return false;
}
}
/*
* Load Class objects for the names in the interfaces array from
* the given class loader.
*
* We pass classObjs and useNonpublic array to avoid needing a
* multi-element return value. useNonpublic is an array to enable
* the method to take a boolean argument by reference.
*
* useNonpublic array is needed to signal when the return value of
* this method should be used as the proxy class loader. Because
* null represents a valid class loader, that value is
* insufficient to signal that the return value should not be used
* as the proxy class loader.
*/
private ClassLoader loadProxyInterfaces(String[] interfaces,
ClassLoader loader,
Class[] classObjs,
boolean[] useNonpublic)
throws ClassNotFoundException
{
/* loader of a non-public interface class */
ClassLoader nonpublic = null;
for (int i = 0; i < interfaces.length; i++) {
Class cl =
(classObjs[i] = Class.forName(interfaces[i], false, loader));
if (!Modifier.isPublic(cl.getModifiers())) {
ClassLoader current = getClassLoader(cl);
if (logger.isLoggable(Level.FINEST)) {
logger.logp(Level.FINEST,
PreferredClassProvider.class.getName(),
"loadProxyClass",
"non-public interface \"{0}\" defined by {1}",
new Object[] { interfaces[i], current });
}
if (!useNonpublic[0]) {
nonpublic = current;
useNonpublic[0] = true;
} else if (current != nonpublic) {
throw new IllegalAccessError(
"non-public interfaces defined in different " +
"class loaders");
}
}
}
return nonpublic;
}
/**
* Convert a string containing a space-separated list of URL Strings into a
* corresponding array of URI objects, throwing a MalformedURLException
* if any of the URLs are invalid. This method returns null if the
* specified string is null.
*
* @param path the string path to be converted to an array of urls
* @return the string path converted to an array of URLs, or null
* @throws MalformedURLException if the string path of urls contains a
* mal-formed url which can not be converted into a url object.
*/
private static URI[] pathToURIs(String path) throws MalformedURLException {
if (path == null) {
return null;
}
URI[] urls = uriCache.get(path); // Cache of previously converted strings.
if (urls != null) return urls;
StringTokenizer st = new StringTokenizer(path); // divide by spaces
urls = new URI[st.countTokens()];
for (int i = 0; st.hasMoreTokens(); i++) {
try {
String uri = st.nextToken();
uri = UriString.fixWindowsURI(uri);
urls[i] = UriString.normalise(new URI(UriString.escapeIllegalCharacters(uri)));
if (! urls[i].isAbsolute()){
throw new MalformedURLException( "URI is not absolute: " + urls[i].toString() +" in path: "+ path);
}
} catch (URISyntaxException ex) {
throw new MalformedURLException("URL's must be RFC 3986 Compliant: "
+ ex.getMessage());
}
}
URI [] existed = uriCache.putIfAbsent(path, urls);
if (existed != null) urls = existed;
return urls;
}
/** Converts URI[] to URL[].
*/
private URL[] asURL(URI[] uris) throws MalformedURLException{
if (uris == null) return null;
ListpathURLs or
* null if the origin loader was not present in the delegation
* hierarchy.
*
* Preferred classes introduces the "class boomerang" problem to
* RMI class loading. A class boomerang occurs when a class which
* is marked preferred is accessible from the codebase of a
* virtual machine (VM) and is loaded by that VM. Since the VM
* has a copy of the class in its own resources and the class is
* "returning to its origin" the class should not be preferred.
* If the class is preferred, it will be loaded in a class loader
* for the local codebase annotation. As a result, the class'
* type will not be compatible with types defined from the local
* definition of the class file in the relevant VM.
*
* A boomerang can also occur when a new child loader for a URL
* path is created but an ancestor of the new class loader has the
* same URL path as the new class loader. In such cases the new
* class loader should not be created. The incoming class should
* be loaded from the origin ancestor instead.
*
* A simple example of a class boomerang occurs when when a VM
* makes a remote method call to itself. Suppose an object whose
* class was loaded locally in that VM and is preferred in the
* codebase of the VM is passed in the call. When the VM receives
* its own call, an instance of the unmarshalled parameter will
* not be assignable to instances that were defined by local
* classes (i.e. never unmarshalled).
*
* In order to work around class boomerang problems, the preferred
* class provider lookupLoader algorithm is different from the
* analogous algorithm in LoaderHandler. To avoid boomerangs, the
* lookupLoader method of this class attempts to locate the
* "origin" class loader of an incoming class in a remote method
* call. Loading classes from their origin loader instead of in a
* preferred circumvents type compatibility conflicts.
*
* To find origin loaders, the lookupLoader method calls
* findOriginLoader() before locating or creating new
* PreferredClassLoaders. An origin loader is found by searching
* up the delegation hierarchy above the parent (context) class
* loader for a loader that has an export path which matches the
* parameter path.
*/
private ClassLoader findOriginLoader(final URI[] pathURLs,
final ClassLoader parent)
{
return AccessController.doPrivileged(
new PrivilegedActionPreferredClassProvider to use to load classes from
* the specified path of URLs with the specified delegation
* parent.
*
* PreferredClassProvider implements this method
* as follows:
*
* urls, delegates to parent, and
* enforces {@link DownloadPermission} if
* requireDlPerm is true. The created
* loader uses a restricted security context to ensure that the
* URL retrieval operations undertaken by the loader cannot
* exercise a permission that is not implied by the permissions
* necessary to access the loader as a codebase loader for the
* specified path of URLs.
*
* @param urls the path of URLs to load classes and resources from
*
* @param parent the parent class loader for delegation
*
* @param requireDlPerm if true, the loader must only
* define classes with a {@link CodeSource} that is granted
* DownloadPermission
*
* @return the created class loader
*
* @since 2.1
**/
protected ClassLoader createClassLoader(final URL[] urls,
final ClassLoader parent,
final boolean requireDlPerm)
{
checkInitialized();
return
AccessController.doPrivileged(new PrivilegedAction