You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdelibs/khtml/java/org/kde/kjas/server/KJASAppletClassLoader.java

361 lines
12 KiB

package org.kde.kjas.server;
import java.net.*;
import java.io.*;
import java.util.*;
import java.util.zip.*;
import java.util.jar.*;
import java.security.*;
/**
* ClassLoader used to download and instantiate Applets.
* <P>
* NOTE: The class loader extends Java 1.2 specific class.
*/
public final class KJASAppletClassLoader
extends URLClassLoader
{
private static Hashtable loaders = new Hashtable();
public static synchronized void removeLoaders()
{
loaders.clear();
}
public static synchronized KJASAppletClassLoader getLoader( String docBase, String codeBase, String archives )
{
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
URL docBaseURL;
KJASAppletClassLoader loader = null;
try
{
docBaseURL = new URL( docBase );
URL codeBaseURL = getCodeBaseURL( docBaseURL, codeBase );
String key = codeBaseURL.toString();
if (archives != null)
key += archives;
Main.debug( "CL: getLoader: key = " + key );
loader = (KJASAppletClassLoader) loaders.get( key );
if( loader == null )
{
URL [] urlList = {};
loader = new KJASAppletClassLoader( urlList, docBaseURL, codeBaseURL);
loaders.put( key, loader );
}
else
{
Main.debug( "CL: reusing classloader" );
}
} catch( MalformedURLException e ) { Main.kjas_err( "bad DocBase URL", e ); }
return loader;
}
public static URL getCodeBaseURL( URL docBaseURL, String codeBase )
{
URL codeBaseURL = null;
try
{
//first determine what the real codeBase is: 3 cases
//#1. codeBase is absolute URL- use that
//#2. codeBase is relative to docBase, create url from those
//#3. last resort, use docBase as the codeBase
if(codeBase != null)
{
//we need to do this since codeBase should be a directory
if( !codeBase.endsWith("/") )
codeBase = codeBase + "/";
try
{
codeBaseURL = new URL( codeBase );
} catch( MalformedURLException mue )
{
try
{
codeBaseURL = new URL( docBaseURL, codeBase );
} catch( MalformedURLException mue2 ) {}
}
}
if(codeBaseURL == null)
{
//fall back to docBase but fix it up...
String file = docBaseURL.getFile();
if( file == null || (file.length() == 0) )
codeBaseURL = docBaseURL;
else if( file.endsWith( "/" ) )
codeBaseURL = docBaseURL;
else
{
//delete up to the ending '/'
String urlString = docBaseURL.toString();
int dot_index = urlString.lastIndexOf( '/' );
String newfile = urlString.substring( 0, dot_index+1 );
codeBaseURL = new URL( newfile );
}
}
}catch( Exception e ) { Main.kjas_err( "CL: exception ", e ); }
return codeBaseURL;
}
public static KJASAppletClassLoader getLoader( String key )
{
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
if( loaders.containsKey( key ) )
return (KJASAppletClassLoader) loaders.get( key );
return null;
}
/*********************************************************************************
****************** KJASAppletClassLoader Implementation *************************
**********************************************************************************/
private URL docBaseURL;
private URL codeBaseURL;
private Vector archives;
private String dbgID;
private static int globalId = 0;
private int myId = 0;
private Vector statusListeners = new Vector();
private AccessControlContext acc;
// a mapping JS referenced Java objects
private Hashtable jsReferencedObjects = new Hashtable();
final static RuntimePermission kjas_access = new RuntimePermission("accessClassInPackage.org.kde.kjas.server");
public KJASAppletClassLoader( URL[] urlList, URL _docBaseURL, URL _codeBaseURL)
{
super(urlList);
acc = AccessController.getContext();
synchronized(KJASAppletClassLoader.class) {
myId = ++globalId;
}
docBaseURL = _docBaseURL;
codeBaseURL = _codeBaseURL;
archives = new Vector();
dbgID = "CL-" + myId + "(" + codeBaseURL.toString() + "): ";
}
protected void addURL(URL url) {
Main.debug(this + " add URL: " + url);
super.addURL(url);
}
public void addStatusListener(StatusListener lsnr) {
statusListeners.add(lsnr);
}
public void removeStatusListener(StatusListener lsnr) {
statusListeners.remove(lsnr);
}
public void showStatus(String msg) {
Enumeration en = statusListeners.elements();
while (en.hasMoreElements()) {
StatusListener lsnr = (StatusListener)en.nextElement();
lsnr.showStatus(msg);
}
}
public void paramsDone() {
// simply builds up the search path
// put the archives first because they are
// cached.
for( int i = 0; i < archives.size(); ++i ) {
String jar = (String)archives.elementAt( i );
try {
URL jarURL = new URL(codeBaseURL, jar);
addURL(jarURL);
Main.debug("added archive URL \"" + jarURL + "\" to KJASAppletClassLoader");
} catch (MalformedURLException e) {
Main.kjas_err("Could not construct URL for jar file: " + codeBaseURL + " + " + jar, e);
}
}
// finally add code base url and docbase url
addURL(codeBaseURL);
// the docBaseURL has to be fixed.
// strip file part from end otherwise this
// will be interpreted as an archive
// (should this perhaps be done generally ??)
String dbs = docBaseURL.toString();
int idx = dbs.lastIndexOf("/");
if (idx > 0) {
dbs = dbs.substring(0, idx+1);
}
URL docDirURL = null;
try {
docDirURL = new URL(dbs);
} catch (MalformedURLException e) {
Main.debug("Could not make a new URL from docBaseURL=" + docBaseURL);
}
if (docDirURL != null && !codeBaseURL.equals(docDirURL)) {
addURL(docDirURL);
}
}
void addArchiveName( String jarname )
{
if( !archives.contains( jarname ) )
{
archives.add( jarname );
}
}
public URL getDocBase()
{
return docBaseURL;
}
public URL getCodeBase()
{
return codeBaseURL;
}
Hashtable getJSReferencedObjects() {
return jsReferencedObjects;
}
/***************************************************************************
**** Class Loading Methods
**************************************************************************/
public synchronized Class findClass( String name ) throws ClassNotFoundException
{
Class rval = null;
//check the loaded classes
rval = findLoadedClass( name );
if( rval == null ) {
try {
rval = super.findClass(name);
} catch (ClassFormatError cfe) {
Main.debug(name + ": Catched " + cfe + ". Trying to repair...");
rval = loadFixedClass( name );
} catch (Exception ex) {
Main.debug("findClass " + name + " " + ex.getMessage());
}
}
if (rval == null) {
throw new ClassNotFoundException("Class: " + name);
}
return rval;
}
public Class loadClass(String name) throws ClassNotFoundException {
if (name.startsWith("org.kde.kjas.server")) {
SecurityManager sec = System.getSecurityManager();
if (sec != null)
sec.checkPermission(kjas_access);
}
return super.loadClass(name);
}
private Hashtable loadedClasses = new Hashtable();
private synchronized final Class loadFixedClass(String name) throws ClassNotFoundException {
final String fileName = name.replace('.', '/') + ".class";
try {
// try to get the class as resource
final URL u = getResource(fileName);
Main.debug(dbgID + name + ": got URL: " + u);
if (u == null) {
throw new ClassNotFoundException(fileName + ": invalid resource URL.");
}
java.security.cert.Certificate[] certs = {}; // FIXME
CodeSource cs = new CodeSource(u, certs);
InputStream instream = (InputStream)AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
try {
return u.openStream();
} catch (IOException ioe) {
ioe.printStackTrace();
return null;
}
}
}, acc
);
if (instream == null) {
throw new ClassNotFoundException(name + ": could not be loaded.");
}
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
int cnt;
int total = 0;
int bufSize = 1024;
byte [] buffer = new byte[bufSize];
while ((cnt = instream.read(buffer, 0, bufSize)) > 0) {
total += cnt;
byteStream.write(buffer, 0, cnt);
}
Main.debug(dbgID + name + ": " + total + " bytes");
Class cl = fixAndDefineClass(name, byteStream.toByteArray(), 0, total, cs);
if (cl != null) {
loadedClasses.put(name, cl);
}
return cl;
} catch (Throwable e) {
e.printStackTrace();
throw new ClassNotFoundException("triggered by " + e);
}
}
public URL findResource( String name)
{
Main.debug( dbgID + "findResource, name = " + name );
String displayName = name;
try {
URL u = new URL(name);
String filename = u.getFile();
if (filename != null && filename.length() > 0) {
displayName = filename;
}
} catch (Throwable e) {
}
showStatus("Loading: " + displayName);
URL url = super.findResource( name );
Main.debug("findResource for " + name + " returns " + url);
return url;
}
protected PermissionCollection getPermissions(CodeSource cs) {
Main.debug(dbgID + " getPermissions(" + cs + ")");
PermissionCollection permissions = super.getPermissions(cs);
Enumeration perms_enum = permissions.elements();
while (perms_enum.hasMoreElements()) {
Main.debug(this + " Permission: " + perms_enum.nextElement());
}
return permissions;
}
/**
* define the class <b>name</b>. If <b>name</b> is broken, try to fix it.
*/
private final Class fixAndDefineClass(
String name,
byte[] b,
int off,
int len,
CodeSource cs) throws ClassFormatError
{
KJASBrokenClassFixer fixer = new KJASBrokenClassFixer();
if (fixer.process(b, off, len)) {
Main.debug(name + " fixed");
} else {
Main.info(name + " could not be fixed");
}
return defineClass(name,
fixer.getProcessedData(),
fixer.getProcessedDataOffset(),
fixer.getProcessedDataLength(),
cs);
}
}