Implemented several methods (e.g. CtClass#getURL) to support security

policies based on code source.


git-svn-id: http://anonsvn.jboss.org/repos/javassist/trunk@59 30ef5769-5b8d-40dd-aea6-55b5d6557bb3

9 files changed, 189 insertions, 18 deletions

diff --git a/Readme.html b/Readme.html
index bb6c53ba..00e3d4ba 100644
--- a/Readme.html
+++ b/Readme.html
@@ -251,6 +251,12 @@ see javassist.Dump.
 
 <h2>Changes</h2>
 
+<p>- version 2.8
+
+<ul>
+  <li>CtClass.getURL() and javassist.ClassPath.find() has been added.
+</ul>
+
 <p>- version 2.7 in October, 2003.
 
 <ul>
@@ -534,7 +540,8 @@ Fabian Crabus, Bo Norregaard Jorgensen, Bob Lee, Bill Burke,
 Remy Sanlaville, Muga Nishizawa, Alexey Loubyansky, Saori Oki,
 Andreas Salathe, Dante Torres estrada, S. Pam, Nuno Santos,
 Denis Taye, Colin Sampaleanu, Robert Bialek, Asato Shimotaki,
-Howard Lewis Ship, and Richard Jones for their contributions.
+Howard Lewis Ship, Richard Jones, and Marjan Sterjev
+for their contributions.
 
 <p><br>
 
diff --git a/src/main/javassist/ByteArrayClassPath.java b/src/main/javassist/ByteArrayClassPath.java
index 5eed3d1a..9125646a 100644
--- a/src/main/javassist/ByteArrayClassPath.java
+++ b/src/main/javassist/ByteArrayClassPath.java
@@ -16,6 +16,8 @@
 package javassist;
 
 import java.io.*;
+import java.net.URL;
+import java.net.MalformedURLException;
 
 /**
  * A <code>ByteArrayClassPath</code> contains bytes that is served as
@@ -68,7 +70,7 @@ public class ByteArrayClassPath implements ClassPath {
     }
 
     /**
-     * Opens a class file.
+     * Opens the class file.
      */
     public InputStream openClassfile(String classname) {
         if(this.classname.equals(classname))
@@ -76,4 +78,20 @@ public class ByteArrayClassPath implements ClassPath {
         else
             return null;
     }
+
+    /**
+     * Obtains the URL.
+     */
+    public URL find(String classname) {
+        if(this.classname.equals(classname)) {
+            String cname = classname.replace('.', '/') + ".class";
+            try {
+                // return new File(cname).toURL();
+                return new URL("file:/ByteArrayClassPath/" + cname);
+            }
+            catch (MalformedURLException e) {}
+        }
+
+        return null;
+    }
 }
diff --git a/src/main/javassist/ClassPath.java b/src/main/javassist/ClassPath.java
index f5578e21..f05713a8 100644
--- a/src/main/javassist/ClassPath.java
+++ b/src/main/javassist/ClassPath.java
@@ -16,6 +16,7 @@
 package javassist;
 
 import java.io.InputStream;
+import java.net.URL;
 
 /**
  * <code>ClassPath</code> is an interface implemented by objects
@@ -50,6 +51,15 @@ public interface ClassPath {
     InputStream openClassfile(String classname) throws NotFoundException;
 
     /**
+     * Returns the uniform resource locator (URL) of the class file
+     * with the specified name.
+     *
+     * @param classname         a fully-qualified class name.
+     * @return null if the specified class file could not be found.
+     */
+    URL find(String classname);
+
+    /**
      * This method is invoked when the <code>ClassPath</code> object is
      * detached from the search path.  It will be an empty method in most of
      * classes.
diff --git a/src/main/javassist/ClassPool.java b/src/main/javassist/ClassPool.java
index 394c8410..ac4b5a08 100644
--- a/src/main/javassist/ClassPool.java
+++ b/src/main/javassist/ClassPool.java
@@ -16,6 +16,7 @@
 package javassist;
 
 import java.io.*;
+import java.net.URL;
 import java.util.Hashtable;
 
 /**
@@ -747,6 +748,16 @@ public class ClassPool {
     }
 
     /**
+     * Obtains the URL of the class file specified by classname.
+     *
+     * @param classname     a fully-qualified class name.
+     * @return null if the class file could not be found.
+     */
+    public URL find(String classname) {
+        return source.find(classname);
+    }
+
+    /**
      * Appends the system search path to the end of the
      * search path.  The system search path
      * usually includes the platform library, extension
diff --git a/src/main/javassist/ClassPoolTail.java b/src/main/javassist/ClassPoolTail.java
index 64560147..5e6898e8 100644
--- a/src/main/javassist/ClassPoolTail.java
+++ b/src/main/javassist/ClassPoolTail.java
@@ -16,7 +16,9 @@
 package javassist;
 
 import java.io.*;
-import java.util.zip.*;
+import java.util.jar.*;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.Hashtable;
 
 final class ClassPathList {
@@ -50,6 +52,11 @@ final class SystemClassPath implements ClassPath {
         return thisClass.getResourceAsStream(jarname);
     }
 
+    public URL find(String classname) {
+        String jarname = "/" + classname.replace('.', '/') + ".class";
+        return thisClass.getResource(jarname);
+    }
+
     public void close() {}
 
     public String toString() {
@@ -77,6 +84,21 @@ final class DirClassPath implements ClassPath {
         return null;
     }
 
+    public URL find(String classname) {
+        char sep = File.separatorChar;
+        String filename = directory + sep
+            + classname.replace('.', sep) + ".class";
+        File f = new File(filename);
+        if (f.exists())
+            try {
+                return f.getCanonicalFile().toURL();
+            }
+            catch (MalformedURLException e) {}
+            catch (IOException e) {}
+
+        return null;
+    }
+
     public void close() {}
 
     public String toString() {
@@ -86,14 +108,16 @@ final class DirClassPath implements ClassPath {
 
 
 final class JarClassPath implements ClassPath {
-    ZipFile jarfile;
+    JarFile jarfile;
+    String jarfileURL;
 
     JarClassPath(String pathname) throws NotFoundException {
         try {
-            jarfile = new ZipFile(pathname);
+            jarfile = new JarFile(pathname);
+            jarfileURL = new File(pathname).getCanonicalFile()
+                                           .toURL().toString();
             return;
         }
-        catch (ZipException e) {}
         catch (IOException e) {}
         throw new NotFoundException(pathname);
     }
@@ -103,18 +127,29 @@ final class JarClassPath implements ClassPath {
     {
         try {
             String jarname = classname.replace('.', '/') + ".class";
-            ZipEntry ze = jarfile.getEntry(jarname);
-            if (ze != null)
-                return jarfile.getInputStream(ze);
+            JarEntry je = jarfile.getJarEntry(jarname);
+            if (je != null)
+                return jarfile.getInputStream(je);
             else
                 return null;    // not found
         }
-        catch (ZipException e) {}
         catch (IOException e) {}
         throw new NotFoundException("broken jar file?: "
                                     + jarfile.getName());
     }
 
+    public URL find(String classname) {
+        String jarname = classname.replace('.', '/') + ".class";
+        JarEntry je = jarfile.getJarEntry(jarname);
+        if (je != null)
+            try {
+                return new URL("jar:" + jarfileURL + "!/" + jarname);
+            }
+            catch (MalformedURLException e) {}
+
+        return null;            // not found
+    }
+
     public void close() {
         try {
             jarfile.close();
@@ -183,12 +218,20 @@ final class ClassPoolTail extends ClassPool {
     }
 
     void checkClassName(String classname) throws NotFoundException {
+        if (find(classname) == null)
+            throw new NotFoundException(classname);
+    }
+
+    /* slower version.
+
+    void checkClassName(String classname) throws NotFoundException {
         InputStream fin = openClassfile(classname);
         try {
             fin.close();
         }
-        catch (IOException e) { /* ignore */ }
+        catch (IOException e) {}
     }
+    */
 
     public synchronized ClassPath insertClassPath(ClassPath cp) {
         pathList = new ClassPathList(cp, pathList);
@@ -313,6 +356,29 @@ final class ClassPoolTail extends ClassPool {
     }
 
     /**
+     * Obtains the URL of the class file specified by classname.
+     *
+     * @param classname     a fully-qualified class name.
+     * @return null if the class file could not be found.
+     */
+    public URL find(String classname) {
+        if (packages.get(classname) != null)
+            return null;
+
+        ClassPathList list = pathList;
+        URL url = null;
+        while (list != null) {
+            url = list.path.find(classname);
+            if (url == null)
+                list = list.next;
+            else
+                return url;
+        }
+
+        return null;
+    }
+
+    /**
      * Reads an input stream until it reaches the end.
      *
      * @return          the contents of that input stream
diff --git a/src/main/javassist/CtClass.java b/src/main/javassist/CtClass.java
index b4f4e26a..228f31b8 100644
--- a/src/main/javassist/CtClass.java
+++ b/src/main/javassist/CtClass.java
@@ -20,6 +20,7 @@ import java.io.IOException;
 import javassist.bytecode.*;
 import java.util.Collection;
 import javassist.expr.ExprEditor;
+import java.net.URL;
 
 // Subclasses of CtClass: CtClassType, CtPrimitiveType, and CtArray
 
@@ -200,6 +201,13 @@ public abstract class CtClass {
     public ClassFile getClassFile2() { return null; }
 
     /**
+     * Returns the uniform resource locator (URL) of the class file.
+     */
+    public URL getURL() throws NotFoundException {
+        throw new NotFoundException(getName());
+    }
+
+    /**
      * Returns true if the definition of the class has been modified.
      */
     public boolean isModified() { return false; }
@@ -859,7 +867,7 @@ public abstract class CtClass {
         ClassPool cp = getClassPool();
         if (cp == null)
             throw new CannotCompileException(
-                                "no ClassPool found. not a class?");
+                        getName() + ": no ClassPool found. not a class?");
         else
             return cp;
     }
diff --git a/src/main/javassist/CtClassType.java b/src/main/javassist/CtClassType.java
index 943f9ea9..c2c4cf20 100644
--- a/src/main/javassist/CtClassType.java
+++ b/src/main/javassist/CtClassType.java
@@ -24,6 +24,7 @@ import java.io.InputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Hashtable;
@@ -126,6 +127,14 @@ class CtClassType extends CtClass {
 
     public ClassPool getClassPool() { return classPool; }
 
+    public URL getURL() throws NotFoundException {
+        URL url = classPool.find(getName());
+        if (url == null)
+            throw new NotFoundException(getName());
+        else
+            return url;
+    }
+
     public boolean isModified() { return wasChanged; }
 
     public boolean isFrozen() { return wasFrozen; }
diff --git a/src/main/javassist/LoaderClassPath.java b/src/main/javassist/LoaderClassPath.java
index e6d83836..071b2fc9 100644
--- a/src/main/javassist/LoaderClassPath.java
+++ b/src/main/javassist/LoaderClassPath.java
@@ -16,6 +16,7 @@
 package javassist;
 
 import java.io.InputStream;
+import java.net.URL;
 import java.lang.ref.WeakReference;
 
 /**
@@ -65,6 +66,20 @@ public class LoaderClassPath implements ClassPath {
     }
 
     /**
+     * Obtains the URL of the specified class file.
+     *
+     * @return null if the class file could not be found. 
+     */
+    public URL find(String classname) {
+        String cname = classname.replace('.', '/') + ".class";
+        ClassLoader cl = (ClassLoader)clref.get();
+        if (cl == null)
+            return null;        // not found
+        else
+            return cl.getResource(cname);
+    }
+
+    /**
      * Closes this class path.
      */
     public void close() {
diff --git a/src/main/javassist/URLClassPath.java b/src/main/javassist/URLClassPath.java
index b455f381..745f3208 100644
--- a/src/main/javassist/URLClassPath.java
+++ b/src/main/javassist/URLClassPath.java
@@ -45,6 +45,7 @@ public class URLClassPath implements ClassPath {
      * @param port              port number
      * @param directory         directory name ending with "/".
      *                          It can be "/" (root directory).
+     *                          It must start with "/".
      * @param packageName       package name.
      */
     public URLClassPath(String host, int port,
@@ -62,19 +63,44 @@ public class URLClassPath implements ClassPath {
     /**
      * Opens a class file with http.
      *
-     * @return null if the class file is not found. 
+     * @return null if the class file could not be found. 
      */
     public InputStream openClassfile(String classname) {
         try {
-            if (packageName == null || classname.startsWith(packageName)) {
-                String jarname
-                    = directory + classname.replace('.', '/') + ".class";
-                URLConnection con = fetchClass0(hostname, port, jarname);
+            URLConnection con = openClassfile0(classname);
+            if (con != null)
                 return con.getInputStream();
+        }
+        catch (IOException e) {}
+        return null;        // not found
+    }
+
+    private URLConnection openClassfile0(String classname) throws IOException {
+        if (packageName == null || classname.startsWith(packageName)) {
+            String jarname
+                    = directory + classname.replace('.', '/') + ".class";
+            return fetchClass0(hostname, port, jarname);
+        }
+        else
+            return null;    // not found
+    }
+
+    /**
+     * Returns the URL.
+     *
+     * @return null if the class file could not be obtained. 
+     */
+    public URL find(String classname) {
+        try {
+            URLConnection con = openClassfile0(classname);
+            InputStream is = con.getInputStream();
+            if (is != null) {
+                is.close();
+                return con.getURL();
             }
         }
         catch (IOException e) {}
-        return null;    // not found
+        return null; 
     }
 
     /**
@@ -89,6 +115,7 @@ public class URLClassPath implements ClassPath {
      * @param port              port number
      * @param directory         directory name ending with "/".
      *                          It can be "/" (root directory).
+     *                          It must start with "/".
      * @param classname         fully-qualified class name
      */
     public static byte[] fetchClass(String host, int port,