/*

* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.lang;

import java.io.InputStream;

import java.io.IOException;

import java.io.File;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.net.MalformedURLException;

import java.net.URL;

import java.security.AccessController;

import java.security.AccessControlContext;

import java.security.CodeSource;

import java.security.Policy;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.security.ProtectionDomain;

import java.security.cert.Certificate;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Set;

import java.util.Stack;

import java.util.Map;

import java.util.Vector;

import java.util.Hashtable;

import java.util.WeakHashMap;

import java.util.concurrent.ConcurrentHashMap;

import sun.misc.CompoundEnumeration;

import sun.misc.Resource;

import sun.misc.URLClassPath;

import sun.misc.VM;

import sun.reflect.CallerSensitive;

import sun.reflect.Reflection;

import sun.reflect.misc.ReflectUtil;

import sun.security.util.SecurityConstants;

/**

* A class loader is an object that is responsible for loading classes. The

* class <tt>ClassLoader</tt> is an abstract class. Given the <a

* href="#name">binary name</a> of a class, a class loader should attempt to

* locate or generate data that constitutes a definition for the class. A

* typical strategy is to transform the name into a file name and then read a

* "class file" of that name from a file system.

*

* <p> Every {@link Class <tt>Class</tt>} object contains a {@link

* Class#getClassLoader() reference} to the <tt>ClassLoader</tt> that defined

* it.

*

* <p> <tt>Class</tt> objects for array classes are not created by class

* loaders, but are created automatically as required by the Java runtime.

* The class loader for an array class, as returned by {@link

* Class#getClassLoader()} is the same as the class loader for its element

* type; if the element type is a primitive type, then the array class has no

* class loader.

*

* <p> Applications implement subclasses of <tt>ClassLoader</tt> in order to

* extend the manner in which the Java virtual machine dynamically loads

* classes.

*

* <p> Class loaders may typically be used by security managers to indicate

* security domains.

*

* <p> The <tt>ClassLoader</tt> class uses a delegation model to search for

* classes and resources. Each instance of <tt>ClassLoader</tt> has an

* associated parent class loader. When requested to find a class or

* resource, a <tt>ClassLoader</tt> instance will delegate the search for the

* class or resource to its parent class loader before attempting to find the

* class or resource itself. The virtual machine's built-in class loader,

* called the "bootstrap class loader", does not itself have a parent but may

* serve as the parent of a <tt>ClassLoader</tt> instance.

*

* <p> Class loaders that support concurrent loading of classes are known as

* <em>parallel capable</em> class loaders and are required to register

* themselves at their class initialization time by invoking the

* {@link

* #registerAsParallelCapable <tt>ClassLoader.registerAsParallelCapable</tt>}

* method. Note that the <tt>ClassLoader</tt> class is registered as parallel

* capable by default. However, its subclasses still need to register themselves

* if they are parallel capable. <br>

* In environments in which the delegation model is not strictly

* hierarchical, class loaders need to be parallel capable, otherwise class

* loading can lead to deadlocks because the loader lock is held for the

* duration of the class loading process (see {@link #loadClass

* <tt>loadClass</tt>} methods).

*

* <p> Normally, the Java virtual machine loads classes from the local file

* system in a platform-dependent manner. For example, on UNIX systems, the

* virtual machine loads classes from the directory defined by the

* <tt>CLASSPATH</tt> environment variable.

*

* <p> However, some classes may not originate from a file; they may originate

* from other sources, such as the network, or they could be constructed by an

* application. The method {@link #defineClass(String, byte[], int, int)

* <tt>defineClass</tt>} converts an array of bytes into an instance of class

* <tt>Class</tt>. Instances of this newly defined class can be created using

* {@link Class#newInstance <tt>Class.newInstance</tt>}.

*

* <p> The methods and constructors of objects created by a class loader may

* reference other classes. To determine the class(es) referred to, the Java

* virtual machine invokes the {@link #loadClass <tt>loadClass</tt>} method of

* the class loader that originally created the class.

*

* <p> For example, an application could create a network class loader to

* download class files from a server. Sample code might look like:

*

* <blockquote><pre>

* ClassLoader loader&nbsp;= new NetworkClassLoader(host,&nbsp;port);

* Object main&nbsp;= loader.loadClass("Main", true).newInstance();

* &nbsp;.&nbsp;.&nbsp;.

* </pre></blockquote>

*

* <p> The network class loader subclass must define the methods {@link

* #findClass <tt>findClass</tt>} and <tt>loadClassData</tt> to load a class

* from the network. Once it has downloaded the bytes that make up the class,

* it should use the method {@link #defineClass <tt>defineClass</tt>} to

* create a class instance. A sample implementation is:

*

* <blockquote><pre>

* class NetworkClassLoader extends ClassLoader {

* String host;

* int port;

*

* public Class findClass(String name) {

* byte[] b = loadClassData(name);

* return defineClass(name, b, 0, b.length);

* }

*

* private byte[] loadClassData(String name) {

* // load the class data from the connection

* &nbsp;.&nbsp;.&nbsp;.

* }

* }

* </pre></blockquote>

*

* <h3> <a name="name">Binary names</a> </h3>

*

* <p> Any class name provided as a {@link String} parameter to methods in

* <tt>ClassLoader</tt> must be a binary name as defined by

* <cite>The Java&trade; Language Specification</cite>.

*

* <p> Examples of valid class names include:

* <blockquote><pre>

* "java.lang.String"

* "javax.swing.JSpinner$DefaultEditor"

* "java.security.KeyStore$Builder$FileBuilder$1"

* "java.net.URLClassLoader$3$1"

* </pre></blockquote>

*

* @see #resolveClass(Class)

* @since 1.0

*/

public abstract class ClassLoader {

private static native void registerNatives();

static {

registerNatives();

}

// The parent class loader for delegation

// Note: VM hardcoded the offset of this field, thus all new fields

// must be added *after* it.

private final ClassLoader parent;

/**

* Encapsulates the set of parallel capable loader types.

*/

private static class ParallelLoaders {

private ParallelLoaders() {}

// the set of parallel capable loader types

private static final Set<Class<? extends ClassLoader>> loaderTypes =

Collections.newSetFromMap(

new WeakHashMap<Class<? extends ClassLoader>, Boolean>());

static {

synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }

}

/**

* Registers the given class loader type as parallel capabale.

* Returns {@code true} is successfully registered; {@code false} if

* loader's super class is not registered.

*/

static boolean register(Class<? extends ClassLoader> c) {

synchronized (loaderTypes) {

if (loaderTypes.contains(c.getSuperclass())) {

// register the class loader as parallel capable

// if and only if all of its super classes are.

// Note: given current classloading sequence, if

// the immediate super class is parallel capable,

// all the super classes higher up must be too.

loaderTypes.add(c);

return true;

} else {

return false;

}

}

}

/**

* Returns {@code true} if the given class loader type is

* registered as parallel capable.

*/

static boolean isRegistered(Class<? extends ClassLoader> c) {

synchronized (loaderTypes) {

return loaderTypes.contains(c);

}

}

}

// Maps class name to the corresponding lock object when the current

// class loader is parallel capable.

// Note: VM also uses this field to decide if the current class loader

// is parallel capable and the appropriate lock object for class loading.

private final ConcurrentHashMap<String, Object> parallelLockMap;

// Hashtable that maps packages to certs

private final Map <String, Certificate[]> package2certs;

// Shared among all packages with unsigned classes

private static final Certificate[] nocerts = new Certificate[0];

// The classes loaded by this class loader. The only purpose of this table

// is to keep the classes from being GC'ed until the loader is GC'ed.

private final Vector<Class<?>> classes = new Vector<>();

// The "default" domain. Set as the default ProtectionDomain on newly

// created classes.

private final ProtectionDomain defaultDomain =

new ProtectionDomain(new CodeSource(null, (Certificate[]) null),

null, this, null);

// The initiating protection domains for all classes loaded by this loader

private final Set<ProtectionDomain> domains;

// Invoked by the VM to record every loaded class with this loader.

void addClass(Class<?> c) {

classes.addElement(c);

}

// The packages defined in this class loader. Each package name is mapped

// to its corresponding Package object.

// @GuardedBy("itself")

private final HashMap<String, Package> packages = new HashMap<>();

private static Void checkCreateClassLoader() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkCreateClassLoader();

}

return null;

}

private ClassLoader(Void unused, ClassLoader parent) {

this.parent = parent;

if (ParallelLoaders.isRegistered(this.getClass())) {

parallelLockMap = new ConcurrentHashMap<>();

package2certs = new ConcurrentHashMap<>();

domains =

Collections.synchronizedSet(new HashSet<ProtectionDomain>());

assertionLock = new Object();

} else {

// no finer-grained lock; lock on the classloader instance

parallelLockMap = null;

package2certs = new Hashtable<>();

domains = new HashSet<>();

assertionLock = this;

}

}

/**

* Creates a new class loader using the specified parent class loader for

* delegation.

*

* <p> If there is a security manager, its {@link

* SecurityManager#checkCreateClassLoader()

* <tt>checkCreateClassLoader</tt>} method is invoked. This may result in

* a security exception. </p>

*

* @param parent

* The parent class loader

*

* @throws SecurityException

* If a security manager exists and its

* <tt>checkCreateClassLoader</tt> method doesn't allow creation

* of a new class loader.

*

* @since 1.2

*/

protected ClassLoader(ClassLoader parent) {

this(checkCreateClassLoader(), parent);

}

/**

* Creates a new class loader using the <tt>ClassLoader</tt> returned by

* the method {@link #getSystemClassLoader()

* <tt>getSystemClassLoader()</tt>} as the parent class loader.

*

* <p> If there is a security manager, its {@link

* SecurityManager#checkCreateClassLoader()

* <tt>checkCreateClassLoader</tt>} method is invoked. This may result in

* a security exception. </p>

*

* @throws SecurityException

* If a security manager exists and its

* <tt>checkCreateClassLoader</tt> method doesn't allow creation

* of a new class loader.

*/

protected ClassLoader() {

this(checkCreateClassLoader(), getSystemClassLoader());

}

// -- Class --

/**

* Loads the class with the specified <a href="#name">binary name</a>.

* This method searches for classes in the same manner as the {@link

* #loadClass(String, boolean)} method. It is invoked by the Java virtual

* machine to resolve class references. Invoking this method is equivalent

* to invoking {@link #loadClass(String, boolean) <tt>loadClass(name,

* false)</tt>}.

*

* @param name

* The <a href="#name">binary name</a> of the class

*

* @return The resulting <tt>Class</tt> object

*

* @throws ClassNotFoundException

* If the class was not found

*/

public Class<?> loadClass(String name) throws ClassNotFoundException {

return loadClass(name, false);

}

/**

* Loads the class with the specified <a href="#name">binary name</a>. The

* default implementation of this method searches for classes in the

* following order:

*

* <ol>

*

* <li><p> Invoke {@link #findLoadedClass(String)} to check if the class

* has already been loaded. </p></li>

*

* <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method

* on the parent class loader. If the parent is <tt>null</tt> the class

* loader built-in to the virtual machine is used, instead. </p></li>

*

* <li><p> Invoke the {@link #findClass(String)} method to find the

* class. </p></li>

*

* </ol>

*

* <p> If the class was found using the above steps, and the

* <tt>resolve</tt> flag is true, this method will then invoke the {@link

* #resolveClass(Class)} method on the resulting <tt>Class</tt> object.

*

* <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link

* #findClass(String)}, rather than this method. </p>

*

* <p> Unless overridden, this method synchronizes on the result of

* {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method

* during the entire class loading process.

*

* @param name

* The <a href="#name">binary name</a> of the class

*

* @param resolve

* If <tt>true</tt> then resolve the class

*

* @return The resulting <tt>Class</tt> object

*

* @throws ClassNotFoundException

* If the class could not be found

*/

protected Class<?> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

// First, check if the class has already been loaded

Class<?> c = findLoadedClass(name);

if (c == null) {

long t0 = System.nanoTime();

try {

if (parent != null) {

c = parent.loadClass(name, false);

} else {

c = findBootstrapClassOrNull(name);

}

} catch (ClassNotFoundException e) {

// ClassNotFoundException thrown if class not found

// from the non-null parent class loader

}

if (c == null) {

// If still not found, then invoke findClass in order

// to find the class.

long t1 = System.nanoTime();

c = findClass(name);

// this is the defining class loader; record the stats

sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

}

}

if (resolve) {

resolveClass(c);

}

return c;

}

}

/**

* Returns the lock object for class loading operations.

* For backward compatibility, the default implementation of this method

* behaves as follows. If this ClassLoader object is registered as

* parallel capable, the method returns a dedicated object associated

* with the specified class name. Otherwise, the method returns this

* ClassLoader object.

*

* @param className

* The name of the to-be-loaded class

*

* @return the lock for class loading operations

*

* @throws NullPointerException

* If registered as parallel capable and <tt>className</tt> is null

*

* @see #loadClass(String, boolean)

*

* @since 1.7

*/

protected Object getClassLoadingLock(String className) {

Object lock = this;

if (parallelLockMap != null) {

Object newLock = new Object();

lock = parallelLockMap.putIfAbsent(className, newLock);

if (lock == null) {

lock = newLock;

}

}

return lock;

}

// This method is invoked by the virtual machine to load a class.

private Class<?> loadClassInternal(String name)

throws ClassNotFoundException

{

// For backward compatibility, explicitly lock on 'this' when

// the current class loader is not parallel capable.

if (parallelLockMap == null) {

synchronized (this) {

return loadClass(name);

}

} else {

return loadClass(name);

}

}

// Invoked by the VM after loading class with this loader.

private void checkPackageAccess(Class<?> cls, ProtectionDomain pd) {

final SecurityManager sm = System.getSecurityManager();

if (sm != null) {

if (ReflectUtil.isNonPublicProxyClass(cls)) {

for (Class<?> intf: cls.getInterfaces()) {

checkPackageAccess(intf, pd);

}

return;

}

final String name = cls.getName();

final int i = name.lastIndexOf('.');

if (i != -1) {

AccessController.doPrivileged(new PrivilegedAction<Void>() {

public Void run() {

sm.checkPackageAccess(name.substring(0, i));

return null;

}

}, new AccessControlContext(new ProtectionDomain[] {pd}));

}

}

domains.add(pd);

}

/**

* Finds the class with the specified <a href="#name">binary name</a>.

* This method should be overridden by class loader implementations that

* follow the delegation model for loading classes, and will be invoked by

* the {@link #loadClass <tt>loadClass</tt>} method after checking the

* parent class loader for the requested class. The default implementation

* throws a <tt>ClassNotFoundException</tt>.

*

* @param name

* The <a href="#name">binary name</a> of the class

*

* @return The resulting <tt>Class</tt> object

*

* @throws ClassNotFoundException

* If the class could not be found

*

* @since 1.2

*/

protected Class<?> findClass(String name) throws ClassNotFoundException {

throw new ClassNotFoundException(name);

}

/**

* Converts an array of bytes into an instance of class <tt>Class</tt>.

* Before the <tt>Class</tt> can be used it must be resolved. This method

* is deprecated in favor of the version that takes a <a

* href="#name">binary name</a> as its first argument, and is more secure.

*

* @param b

* The bytes that make up the class data. The bytes in positions

* <tt>off</tt> through <tt>off+len-1</tt> should have the format

* of a valid class file as defined by

* <cite>The Java&trade; Virtual Machine Specification</cite>.

*

* @param off

* The start offset in <tt>b</tt> of the class data

*

* @param len

* The length of the class data

*

* @return The <tt>Class</tt> object that was created from the specified

* class data

*

* @throws ClassFormatError

* If the data did not contain a valid class

*

* @throws IndexOutOfBoundsException

* If either <tt>off</tt> or <tt>len</tt> is negative, or if

* <tt>off+len</tt> is greater than <tt>b.length</tt>.

*

* @throws SecurityException

* If an attempt is made to add this class to a package that

* contains classes that were signed by a different set of

* certificates than this class, or if an attempt is made

* to define a class in a package with a fully-qualified name

* that starts with "{@code java.}".

*

* @see #loadClass(String, boolean)

* @see #resolveClass(Class)

*

* @deprecated Replaced by {@link #defineClass(String, byte[], int, int)

* defineClass(String, byte[], int, int)}

*/

@Deprecated

protected final Class<?> defineClass(byte[] b, int off, int len)

throws ClassFormatError

{

return defineClass(null, b, off, len, null);

}

/**

* Converts an array of bytes into an instance of class <tt>Class</tt>.

* Before the <tt>Class</tt> can be used it must be resolved.

*

* <p> This method assigns a default {@link java.security.ProtectionDomain

* <tt>ProtectionDomain</tt>} to the newly defined class. The

* <tt>ProtectionDomain</tt> is effectively granted the same set of

* permissions returned when {@link

* java.security.Policy#getPermissions(java.security.CodeSource)

* <tt>Policy.getPolicy().getPermissions(new CodeSource(null, null))</tt>}

* is invoked. The default domain is created on the first invocation of

* {@link #defineClass(String, byte[], int, int) <tt>defineClass</tt>},

* and re-used on subsequent invocations.

*

* <p> To assign a specific <tt>ProtectionDomain</tt> to the class, use

* the {@link #defineClass(String, byte[], int, int,

* java.security.ProtectionDomain) <tt>defineClass</tt>} method that takes a

* <tt>ProtectionDomain</tt> as one of its arguments. </p>

*

* @param name

* The expected <a href="#name">binary name</a> of the class, or

* <tt>null</tt> if not known

*

* @param b

* The bytes that make up the class data. The bytes in positions

* <tt>off</tt> through <tt>off+len-1</tt> should have the format

* of a valid class file as defined by

* <cite>The Java&trade; Virtual Machine Specification</cite>.

*

* @param off

* The start offset in <tt>b</tt> of the class data

*

* @param len

* The length of the class data

*

* @return The <tt>Class</tt> object that was created from the specified

* class data.

*

* @throws ClassFormatError

* If the data did not contain a valid class

*

* @throws IndexOutOfBoundsException

* If either <tt>off</tt> or <tt>len</tt> is negative, or if

* <tt>off+len</tt> is greater than <tt>b.length</tt>.

*

* @throws SecurityException

* If an attempt is made to add this class to a package that

* contains classes that were signed by a different set of

* certificates than this class (which is unsigned), or if

* <tt>name</tt> begins with "<tt>java.</tt>".

*

* @see #loadClass(String, boolean)

* @see #resolveClass(Class)

* @see java.security.CodeSource

* @see java.security.SecureClassLoader

*

* @since 1.1

*/

protected final Class<?> defineClass(String name, byte[] b, int off, int len)

throws ClassFormatError

{

return defineClass(name, b, off, len, null);

}

/* Determine protection domain, and check that:

- not define java.* class,

- signer of this class matches signers for the rest of the classes in

package.

*/

private ProtectionDomain preDefineClass(String name,

ProtectionDomain pd)

{

if (!checkName(name))

throw new NoClassDefFoundError("IllegalName: " + name);

if ((name != null) && name.startsWith("java.")) {

throw new SecurityException

("Prohibited package name: " +

name.substring(0, name.lastIndexOf('.')));

}

if (pd == null) {

pd = defaultDomain;

}

if (name != null) checkCerts(name, pd.getCodeSource());

return pd;

}

private String defineClassSourceLocation(ProtectionDomain pd)

{

CodeSource cs = pd.getCodeSource();

String source = null;

if (cs != null && cs.getLocation() != null) {

source = cs.getLocation().toString();

}

return source;

}

private void postDefineClass(Class<?> c, ProtectionDomain pd)

{

if (pd.getCodeSource() != null) {

Certificate certs[] = pd.getCodeSource().getCertificates();

if (certs != null)

setSigners(c, certs);

}

}

/**

* Converts an array of bytes into an instance of class <tt>Class</tt>,

* with an optional <tt>ProtectionDomain</tt>. If the domain is

* <tt>null</tt>, then a default domain will be assigned to the class as

* specified in the documentation for {@link #defineClass(String, byte[],

* int, int)}. Before the class can be used it must be resolved.

*

* <p> The first class defined in a package determines the exact set of

* certificates that all subsequent classes defined in that package must

* contain. The set of certificates for a class is obtained from the

* {@link java.security.CodeSource <tt>CodeSource</tt>} within the

* <tt>ProtectionDomain</tt> of the class. Any classes added to that

* package must contain the same set of certificates or a

* <tt>SecurityException</tt> will be thrown. Note that if

* <tt>name</tt> is <tt>null</tt>, this check is not performed.

* You should always pass in the <a href="#name">binary name</a> of the

* class you are defining as well as the bytes. This ensures that the

* class you are defining is indeed the class you think it is.

*

* <p> The specified <tt>name</tt> cannot begin with "<tt>java.</tt>", since

* all classes in the "<tt>java.*</tt> packages can only be defined by the

* bootstrap class loader. If <tt>name</tt> is not <tt>null</tt>, it

* must be equal to the <a href="#name">binary name</a> of the class

* specified by the byte array "<tt>b</tt>", otherwise a {@link

* NoClassDefFoundError <tt>NoClassDefFoundError</tt>} will be thrown. </p>

*

* @param name

* The expected <a href="#name">binary name</a> of the class, or

* <tt>null</tt> if not known

*

* @param b

* The bytes that make up the class data. The bytes in positions

* <tt>off</tt> through <tt>off+len-1</tt> should have the format

* of a valid class file as defined by

* <cite>The Java&trade; Virtual Machine Specification</cite>.

*

* @param off

* The start offset in <tt>b</tt> of the class data

*

* @param len

* The length of the class data

*

* @param protectionDomain

* The ProtectionDomain of the class

*

* @return The <tt>Class</tt> object created from the data,

* and optional <tt>ProtectionDomain</tt>.

*

* @throws ClassFormatError

* If the data did not contain a valid class

*

* @throws NoClassDefFoundError

* If <tt>name</tt> is not equal to the <a href="#name">binary

* name</a> of the class specified by <tt>b</tt>

*

* @throws IndexOutOfBoundsException

* If either <tt>off</tt> or <tt>len</tt> is negative, or if

* <tt>off+len</tt> is greater than <tt>b.length</tt>.

*

* @throws SecurityException

* If an attempt is made to add this class to a package that

* contains classes that were signed by a different set of

* certificates than this class, or if <tt>name</tt> begins with

* "<tt>java.</tt>".

*/

protected final Class<?> defineClass(String name, byte[] b, int off, int len,

ProtectionDomain protectionDomain)

throws ClassFormatError

{

protectionDomain = preDefineClass(name, protectionDomain);

String source = defineClassSourceLocation(protectionDomain);

Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);

postDefineClass(c, protectionDomain);

return c;

}

/**

* Converts a {@link java.nio.ByteBuffer <tt>ByteBuffer</tt>}

* into an instance of class <tt>Class</tt>,

* with an optional <tt>ProtectionDomain</tt>. If the domain is

* <tt>null</tt>, then a default domain will be assigned to the class as

* specified in the documentation for {@link #defineClass(String, byte[],

* int, int)}. Before the class can be used it must be resolved.

*

* <p>The rules about the first class defined in a package determining the

* set of certificates for the package, and the restrictions on class names

* are identical to those specified in the documentation for {@link

* #defineClass(String, byte[], int, int, ProtectionDomain)}.

*

* <p> An invocation of this method of the form

* <i>cl</i><tt>.defineClass(</tt><i>name</i><tt>,</tt>

* <i>bBuffer</i><tt>,</tt> <i>pd</i><tt>)</tt> yields exactly the same

* result as the statements

*

*<p> <tt>

* ...<br>

* byte[] temp = new byte[bBuffer.{@link

* java.nio.ByteBuffer#remaining remaining}()];<br>

* bBuffer.{@link java.nio.ByteBuffer#get(byte[])

* get}(temp);<br>

* return {@link #defineClass(String, byte[], int, int, ProtectionDomain)

* cl.defineClass}(name, temp, 0,

* temp.length, pd);<br>

* </tt></p>

*

* @param name

* The expected <a href="#name">binary name</a>. of the class, or

* <tt>null</tt> if not known

*

* @param b

* The bytes that make up the class data. The bytes from positions

* <tt>b.position()</tt> through <tt>b.position() + b.limit() -1

* </tt> should have the format of a valid class file as defined by

* <cite>The Java&trade; Virtual Machine Specification</cite>.

*

* @param protectionDomain

* The ProtectionDomain of the class, or <tt>null</tt>.

*

* @return The <tt>Class</tt> object created from the data,

* and optional <tt>ProtectionDomain</tt>.

*

* @throws ClassFormatError

* If the data did not contain a valid class.

*

* @throws NoClassDefFoundError

* If <tt>name</tt> is not equal to the <a href="#name">binary

* name</a> of the class specified by <tt>b</tt>

*

* @throws SecurityException

* If an attempt is made to add this class to a package that

* contains classes that were signed by a different set of

* certificates than this class, or if <tt>name</tt> begins with

* "<tt>java.</tt>".

*

* @see #defineClass(String, byte[], int, int, ProtectionDomain)

*

* @since 1.5

*/

protected final Class<?> defineClass(String name, java.nio.ByteBuffer b,

ProtectionDomain protectionDomain)

throws ClassFormatError

{

int len = b.remaining();

// Use byte[] if not a direct ByteBufer:

if (!b.isDirect()) {

if (b.hasArray()) {

return defineClass(name, b.array(),

b.position() + b.arrayOffset(), len,

protectionDomain);

} else {

// no array, or read-only array

byte[] tb = new byte[len];

b.get(tb); // get bytes out of byte buffer.

return defineClass(name, tb, 0, len, protectionDomain);

}

}

protectionDomain = preDefineClass(name, protectionDomain);

String source = defineClassSourceLocation(protectionDomain);

Class<?> c = defineClass2(name, b, b.position(), len, protectionDomain, source);

postDefineClass(c, protectionDomain);

return c;

}

private native Class<?> defineClass0(String name, byte[] b, int off, int len,

ProtectionDomain pd);

private native Class<?> defineClass1(String name, byte[] b, int off, int len,

ProtectionDomain pd, String source);

private native Class<?> defineClass2(String name, java.nio.ByteBuffer b,

int off, int len, ProtectionDomain pd,

String source);

// true if the name is null or has the potential to be a valid binary name

private boolean checkName(String name) {

if ((name == null) || (name.length() == 0))

return true;

if ((name.indexOf('/') != -1)

|| (!VM.allowArraySyntax() && (name.charAt(0) == '[')))

return false;

return true;

}

private void checkCerts(String name, CodeSource cs) {

int i = name.lastIndexOf('.');

String pname = (i == -1) ? "" : name.substring(0, i);

Certificate[] certs = null;

if (cs != null) {

certs = cs.getCertificates();

}

Certificate[] pcerts = null;

if (parallelLockMap == null) {

synchronized (this) {

pcerts = package2certs.get(pname);

if (pcerts == null) {

package2certs.put(pname, (certs == null? nocerts:certs));

}

}

} else {

pcerts = ((ConcurrentHashMap<String, Certificate[]>)package2certs).

putIfAbsent(pname, (certs == null? nocerts:certs));

}

if (pcerts != null && !compareCerts(pcerts, certs)) {

throw new SecurityException("class \""+ name +

"\"'s signer information does not match signer information of other classes in the same package");

}

}

/**

* check to make sure the certs for the new class (certs) are the same as

* the certs for the first class inserted in the package (pcerts)

*/

private boolean compareCerts(Certificate[] pcerts,

Certificate[] certs)

{

// certs can be null, indicating no certs.

if ((certs == null) || (certs.length == 0)) {

return pcerts.length == 0;

}

// the length must be the same at this point

if (certs.length != pcerts.length)

return false;

// go through and make sure all the certs in one array

// are in the other and vice-versa.

boolean match;

for (int i = 0; i < certs.length; i++) {

match = false;

for (int j = 0; j < pcerts.length; j++) {

if (certs[i].equals(pcerts[j])) {

match = true;

break;

}

}

if (!match) return false;

}

// now do the same for pcerts

for (int i = 0; i < pcerts.length; i++) {

match = false;

for (int j = 0; j < certs.length; j++) {

if (pcerts[i].equals(certs[j])) {

match = true;

break;

}

}

if (!match) return false;

}

return true;

}

/**

* Links the specified class. This (misleadingly named) method may be

* used by a class loader to link a class. If the class <tt>c</tt> has

* already been linked, then this method simply returns. Otherwise, the

* class is linked as described in the "Execution" chapter of

* <cite>The Java&trade; Language Specification</cite>.

*

* @param c

* The class to link

*

* @throws NullPointerException

* If <tt>c</tt> is <tt>null</tt>.

*

* @see #defineClass(String, byte[], int, int)

*/

protected final void resolveClass(Class<?> c) {

resolveClass0(c);

}

private native void resolveClass0(Class<?> c);

/**

* Finds a class with the specified <a href="#name">binary name</a>,

* loading it if necessary.

*

* <p> This method loads the class through the system class loader (see

* {@link #getSystemClassLoader()}). The <tt>Class</tt> object returned

* might have more than one <tt>ClassLoader</tt> associated with it.

* Subclasses of <tt>ClassLoader</tt> need not usually invoke this method,

* because most class loaders need to override just {@link

* #findClass(String)}. </p>

*

* @param name

* The <a href="#name">binary name</a> of the class

*

* @return The <tt>Class</tt> object for the specified <tt>name</tt>

*

* @throws ClassNotFoundException

* If the class could not be found

*

* @see #ClassLoader(ClassLoader)

* @see #getParent()

*/

protected final Class<?> findSystemClass(String name)

throws ClassNotFoundException

{

ClassLoader system = getSystemClassLoader();

if (system == null) {

if (!checkName(name))

throw new ClassNotFoundException(name);

Class<?> cls = findBootstrapClass(name);

if (cls == null) {

throw new ClassNotFoundException(name);

}

return cls;

}