1 /*
   2  * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.invoke.anon;
  27 
  28 import java.io.EOFException;
  29 import java.io.IOException;
  30 import java.lang.reflect.InvocationTargetException;
  31 import java.lang.reflect.Method;
  32 
  33 /**
  34  * Anonymous class loader.  Will load any valid classfile, producing
  35  * a {@link Class} metaobject, without installing that class in the
  36  * system dictionary.  Therefore, {@link Class#forName(String)} will never
  37  * produce a reference to an anonymous class.
  38  * <p>
  39  * The access permissions of the anonymous class are borrowed from
  40  * a <em>host class</em>.  The new class behaves as if it were an
  41  * inner class of the host class.  It can access the host's private
  42  * members, if the creator of the class loader has permission to
  43  * do so (or to create accessible reflective objects).
  44  * <p>
  45  * When the anonymous class is loaded, elements of its constant pool
  46  * can be patched to new values.  This provides a hook to pre-resolve
  47  * named classes in the constant pool to other classes, including
  48  * anonymous ones.  Also, string constants can be pre-resolved to
  49  * any reference.  (The verifier treats non-string, non-class reference
  50  * constants as plain objects.)
  51  *  <p>
  52  * Why include the patching function?  It makes some use cases much easier.
  53  * Second, the constant pool needed some internal patching anyway,
  54  * to anonymize the loaded class itself.  Finally, if you are going
  55  * to use this seriously, you'll want to build anonymous classes
  56  * on top of pre-existing anonymous classes, and that requires patching.
  57  *
  58  * <p>%%% TO-DO:
  59  * <ul>
  60  * <li>needs better documentation</li>
  61  * <li>needs more security work (for safe delegation)</li>
  62  * <li>needs a clearer story about error processing</li>
  63  * <li>patch member references also (use ';' as delimiter char)</li>
  64  * <li>patch method references to (conforming) method handles</li>
  65  * </ul>
  66  *
  67  * @author jrose
  68  * @author Remi Forax
  69  * @see <a href="http://blogs.sun.com/jrose/entry/anonymous_classes_in_the_vm">
  70  *      http://blogs.sun.com/jrose/entry/anonymous_classes_in_the_vm</a>
  71  */
  72 
  73 public class AnonymousClassLoader {
  74     final Class<?> hostClass;
  75 
  76     // Privileged constructor.
  77     private AnonymousClassLoader(Class<?> hostClass) {
  78         this.hostClass = hostClass;
  79     }
  80 
  81     public static AnonymousClassLoader make(jdk.internal.misc.Unsafe unsafe, Class<?> hostClass) {
  82         if (unsafe == null)  throw new NullPointerException();
  83         return new AnonymousClassLoader(hostClass);
  84     }
  85 
  86     public Class<?> loadClass(byte[] classFile) {
  87         if (defineAnonymousClass == null) {
  88             // no JVM support; try to fake an approximation
  89             try {
  90                 return fakeLoadClass(new ConstantPoolParser(classFile).createPatch());
  91             } catch (InvalidConstantPoolFormatException ee) {
  92                 throw new IllegalArgumentException(ee);
  93             }
  94         }
  95         return loadClass(classFile, null);
  96     }
  97 
  98     public Class<?> loadClass(ConstantPoolPatch classPatch) {
  99         if (defineAnonymousClass == null) {
 100             // no JVM support; try to fake an approximation
 101             return fakeLoadClass(classPatch);
 102         }
 103         Object[] patches = classPatch.patchArray;
 104         // Convert class names (this late in the game)
 105         // to use slash '/' instead of dot '.'.
 106         // Java likes dots, but the JVM likes slashes.
 107         for (int i = 0; i < patches.length; i++) {
 108             Object value = patches[i];
 109             if (value != null) {
 110                 byte tag = classPatch.getTag(i);
 111                 switch (tag) {
 112                 case ConstantPoolVisitor.CONSTANT_Class:
 113                     if (value instanceof String) {
 114                         if (patches == classPatch.patchArray)
 115                             patches = patches.clone();
 116                         patches[i] = ((String)value).replace('.', '/');
 117                     }
 118                     break;
 119                 case ConstantPoolVisitor.CONSTANT_Fieldref:
 120                 case ConstantPoolVisitor.CONSTANT_Methodref:
 121                 case ConstantPoolVisitor.CONSTANT_InterfaceMethodref:
 122                 case ConstantPoolVisitor.CONSTANT_NameAndType:
 123                     // When/if the JVM supports these patches,
 124                     // we'll probably need to reformat them also.
 125                     // Meanwhile, let the class loader create the error.
 126                     break;
 127                 }
 128             }
 129         }
 130         return loadClass(classPatch.outer.classFile, classPatch.patchArray);
 131     }
 132 
 133     private Class<?> loadClass(byte[] classFile, Object[] patchArray) {
 134         try {
 135             return (Class<?>)
 136                 defineAnonymousClass.invoke(unsafe,
 137                                             hostClass, classFile, patchArray);
 138         } catch (Exception ex) {
 139             throwReflectedException(ex);
 140             throw new RuntimeException("error loading into "+hostClass, ex);
 141         }
 142     }
 143 
 144     private static void throwReflectedException(Exception ex) {
 145         if (ex instanceof InvocationTargetException) {
 146             Throwable tex = ((InvocationTargetException)ex).getTargetException();
 147             if (tex instanceof Error)
 148                 throw (Error) tex;
 149             ex = (Exception) tex;
 150         }
 151         if (ex instanceof RuntimeException) {
 152             throw (RuntimeException) ex;
 153         }
 154     }
 155 
 156     private Class<?> fakeLoadClass(ConstantPoolPatch classPatch) {
 157         // Implementation:
 158         // 1. Make up a new name nobody has used yet.
 159         // 2. Inspect the tail-header of the class to find the this_class index.
 160         // 3. Patch the CONSTANT_Class for this_class to the new name.
 161         // 4. Add other CP entries required by (e.g.) string patches.
 162         // 5. Flatten Class constants down to their names, making sure that
 163         //    the host class loader can pick them up again accurately.
 164         // 6. Generate the edited class file bytes.
 165         //
 166         // Potential limitations:
 167         // * The class won't be truly anonymous, and may interfere with others.
 168         // * Flattened class constants might not work, because of loader issues.
 169         // * Pseudo-string constants will not flatten down to real strings.
 170         // * Method handles will (of course) fail to flatten to linkage strings.
 171         if (true)  throw new UnsupportedOperationException("NYI");
 172         Object[] cpArray;
 173         try {
 174             cpArray = classPatch.getOriginalCP();
 175         } catch (InvalidConstantPoolFormatException ex) {
 176             throw new RuntimeException(ex);
 177         }
 178         int thisClassIndex = classPatch.getParser().getThisClassIndex();
 179         String thisClassName = (String) cpArray[thisClassIndex];
 180         synchronized (AnonymousClassLoader.class) {
 181             thisClassName = thisClassName+"\\|"+(++fakeNameCounter);
 182         }
 183         classPatch.putUTF8(thisClassIndex, thisClassName);
 184         byte[] classFile = null;
 185         return unsafe.defineClass(null, classFile, 0, classFile.length,
 186                                   hostClass.getClassLoader(),
 187                                   hostClass.getProtectionDomain());
 188     }
 189     private static int fakeNameCounter = 99999;
 190 
 191     // ignore two warnings on this line:
 192     private static jdk.internal.misc.Unsafe unsafe = jdk.internal.misc.Unsafe.getUnsafe();
 193     // preceding line requires that this class be on the boot class path
 194 
 195     private static final Method defineAnonymousClass;
 196     static {
 197         Method dac = null;
 198         Class<? extends jdk.internal.misc.Unsafe> unsafeClass = unsafe.getClass();
 199         try {
 200             dac = unsafeClass.getMethod("defineAnonymousClass",
 201                                         Class.class,
 202                                         byte[].class,
 203                                         Object[].class);
 204         } catch (Exception ee) {
 205             dac = null;
 206         }
 207         defineAnonymousClass = dac;
 208     }
 209 
 210     private static void noJVMSupport() {
 211         throw new UnsupportedOperationException("no JVM support for anonymous classes");
 212     }
 213 
 214 
 215     private static native Class<?> loadClassInternal(Class<?> hostClass,
 216                                                      byte[] classFile,
 217                                                      Object[] patchArray);
 218 
 219     public static byte[] readClassFile(Class<?> templateClass) throws IOException {
 220         String templateName = templateClass.getName();
 221         int lastDot = templateName.lastIndexOf('.');
 222         java.net.URL url = templateClass.getResource(templateName.substring(lastDot+1)+".class");
 223         java.net.URLConnection connection = url.openConnection();
 224         int contentLength = connection.getContentLength();
 225         if (contentLength < 0)
 226             throw new IOException("invalid content length "+contentLength);
 227 
 228         byte[] b = connection.getInputStream().readAllBytes();
 229         if (b.length != contentLength)
 230             throw new EOFException("Expected:" + contentLength + ", read:" + b.length);
 231 
 232         return b;
 233     }
 234 }