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;

/**

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); }

}

/**

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;

}

}

}

/**

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;

}

}

/**

protected ClassLoader(ClassLoader parent) {

this(checkCreateClassLoader(), parent);

}

/**

protected ClassLoader() {

this(checkCreateClassLoader(), getSystemClassLoader());

}

// -- Class --

/**

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

return loadClass(name, false);

}

/**

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;

}

}

/**

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);

}

/**

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

throw new ClassNotFoundException(name);

}

/**

@Deprecated

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

throws ClassFormatError

{

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

}

/**

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:

private ProtectionDomain preDefineClass(String name,

ProtectionDomain pd)

{

if (!checkName(name))

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

// Note: Checking logic in java.lang.invoke.MemberName.checkForTypeAlias

// relies on the fact that spoofing is impossible if a class has a name

// of the form "java.*"

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);

}

}

/**

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;

}

/**

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");

}

}

/**

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;

}

/**

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

resolveClass0(c);

}

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

/**

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);