/* SystemClassLoader.java -- the default system class loader Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc. Modifications Copyright (C) 2004 by Etienne Gagnon. Modifications Copyright (C) 2004 by David Belanger. Modifications Copyright (C) 2004 by Grzegorz prokopski. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ package gnu.java.lang; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.IOException; import java.io.File; import java.io.InputStream; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; import java.util.StringTokenizer; import java.util.Vector; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; import gnu.java.io.PlatformHelper; import gnu.java.net.protocol.jar.Connection.JarFileCache; /** * The default system class loader. VMs may wish to replace this with a * similar class that interacts better with their VM. Also, replacing this * class may be necessary when porting to new platforms, like Windows. * * XXX Should this be merged with ClassLoaderHelper? They both do a similar * search of the classpath, including jar/zip files. * * @author John Keiser * @author Mark Wielaard * @author Eric Blake * @author Etienne M. Gagnon */ public class SystemClassLoader extends ClassLoader { protected Class findClass(String className) throws ClassNotFoundException { URL classURL = getResource (className.replace('.','/') + ".class"); if (classURL == null) { throw new ClassNotFoundException(className); } // Try to read the class data, create the CodeSource and construct the // class (and watch out for those nasty IOExceptions) try { byte [] classData; URLConnection conn = classURL.openConnection(); InputStream in = conn.getInputStream(); int length = conn.getContentLength(); if (length != -1) { DataInputStream inData; // We know the length of the data, just read it all in at once classData = new byte[length]; inData = new DataInputStream(in); inData.readFully(classData); } else { // We don't know the data length so we have to read it in chunks ByteArrayOutputStream out = new ByteArrayOutputStream(1024); byte b[] = new byte[1024]; int l = 0; while (l != -1) { l = in.read(b); if (l != -1) { out.write(b, 0, l); } } classData = out.toByteArray(); } // And finally construct the class! return defineClass(className, classData, 0, classData.length); } catch (IOException ioe) { throw new ClassNotFoundException(className, ioe); } } /** A lock for synchronization when reading jars. */ private static final Object NO_SUCH_ARCHIVE = new Object(); /** Flag to avoid infinite loops. */ private static boolean is_trying; /** value of classpath property */ private static String classpath = null; /** A vector contains information for each path in classpath, * the item of the vector can be: * null: if corresponding path isn't valid; * ZipFile object: if corresponding path is a zip/jar file; * String object: if corresponding path is a directory. */ private static Vector pathinfos = new Vector(); /** * Creates a class loader. Note that the parent may be null, when this is * created as the system class loader by ClassLoader.getSystemClassLoader. * * @param parent the parent class loader */ public SystemClassLoader(ClassLoader parent) { super(parent); } /** * Find the URL to a resource. Called by ClassLoader.getResource(). * * @param name the name of the resource * @return the URL to the resource */ protected URL findResource(String name) { return systemFindResource(name); } public URL getResource(String name) { return systemFindResource(name); } /** * Get the URL to a resource. * * @param name the name of the resource * @return the URL to the resource */ private static URL systemFindResource(String name) { if (name.charAt(0) == '/') name = name.substring(1); String cp = System.getProperty("java.class.path", "."); Vector bak_pathinfos = null; // the backup of pathinfos /* if is_trying is true, it's called recursively and in * a transient status, so we backup pathinfos into a temp * variable, and when all are done, restore pathinfos to * backup state. That means, this call won't persistent * its state, it's just a fall through to get out of * transient state. And when next time it's called again * and is_trying is false, pathinfos will be re-calculated. */ if (is_trying) { bak_pathinfos = pathinfos; pathinfos = new Vector(); } // if classpath property has been changed if (!cp.equals(classpath)) { pathinfos.clear(); StringTokenizer st = new StringTokenizer(cp, File.pathSeparator); while (st.hasMoreTokens()) { String path = st.nextToken(); // check if path exists, if not, cache failure File f = new File(path); if(!f.exists()) { pathinfos.add(null); continue; } String lc_path = path.toLowerCase(); path = f.getAbsolutePath(); if (lc_path.endsWith(".zip") || lc_path.endsWith(".jar")) //whether it's zip/jar file { if (is_trying) // Avoid infinite loop. continue; path = f.getAbsolutePath(); ZipFile zf; try { // Construct URL object for the path StringBuffer sb = new StringBuffer(PlatformHelper.INITIAL_MAX_PATH); sb.append("file://"); sb.append(path); URL url = new URL(sb.toString()); // class-level critical section synchronized (NO_SUCH_ARCHIVE) { is_trying = true; zf = JarFileCache.get(url); is_trying = false; } } catch (Exception e) { zf = null; } pathinfos.add(zf); } else //not zip/jar file { if ( !PlatformHelper.endWithSeparator(path) ) pathinfos.add(path + File.separator); else pathinfos.add(path); } } // while more paths } // if classpath property has been changed URL result = null; for (int i = 0; i < pathinfos.size(); i++) { Object o = pathinfos.elementAt(i); if (o == null ) continue; //it's not a valid path if (o instanceof ZipFile) { //it's a zip/jar file ZipFile zf = (ZipFile)o; ZipEntry ze = zf.getEntry(name); // if the resource doesn't reside in this zip/jar file if (ze == null) continue; try { StringBuffer sb = new StringBuffer(PlatformHelper.INITIAL_MAX_PATH); sb.append("jar:file://"); sb.append(zf.getName()); sb.append("!/"); sb.append(name); result = new URL(sb.toString()); } catch (MalformedURLException e) { result = null; } break; } // otherwise o is string String path = (String)o; File f = new File(path + name); if (f.exists()) { try { result = new URL("file://" + f.getAbsolutePath()); } catch (MalformedURLException e) { result = null; } break; } } //for each paths // Restore pathinfos if (is_trying) { pathinfos = bak_pathinfos; } else { /* update classpath, hopefully next time classpath is * not changed, so pathinfos will not be re-calcualted. */ classpath = cp; } return result; } //End of systemFindResource }