java/src/main/com/google/appengine/tools/development/agent/runtime/Runtime.java

   1 // Copyright 2009 Google Inc. All Rights Reserved.
   2
   3 package com.google.appengine.tools.development.agent.runtime;
   4
   5 import com.google.appengine.tools.development.agent.AppEngineDevAgent;
   6 import com.google.appengine.tools.development.agent.impl.Agent;
   7 import com.google.apphosting.utils.clearcast.ClearCast;
   8
   9 import sun.reflect.Reflection;
  10
  11 import java.lang.reflect.AccessibleObject;
  12 import java.lang.reflect.Constructor;
  13 import java.lang.reflect.Field;
  14 import java.lang.reflect.InvocationTargetException;
  15 import java.lang.reflect.Member;
  16 import java.lang.reflect.Method;
  17 import java.lang.reflect.Modifier;
  18 import java.security.AccessController;
  19 import java.security.PrivilegedAction;
  20 import java.security.PrivilegedActionException;
  21 import java.security.PrivilegedExceptionAction;
  22 import java.util.Set;
  23
  24 /**
  25  * Provides runtime support for
  26  * {@link com.google.appengine.tools.development.agent.AppEngineDevAgent AppEngineDevAgent}.
  27  *
  28  */
  29 public class Runtime {
  30
  31   private static Agent agent = ClearCast.cast(AppEngineDevAgent.getAgent(), Agent.class);
  32   private static Set<String> blackList = agent.getBlackList();
  33
  34   public static ClassLoader checkParentClassLoader(ClassLoader loader) {
  35     ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
  36     return loader != null && loader != systemLoader ? loader : Runtime.class.getClassLoader();
  37   }
  38
  39   public static void recordClassLoader(ClassLoader loader) {
  40     agent.recordAppClassLoader(loader);
  41   }
  42
  43   public static void reject(String className) {
  44     throw new NoClassDefFoundError(className + " is a restricted class. Please see the Google "
  45         + " App Engine developer's guide for more details.");
  46   }
  47
  48   /**
  49    * This method is only invoked via injected bytecode.
  50    *
  51    * @see RuntimeHelper#checkRestricted(boolean, String, String, String) ;
  52    */
  53   @SuppressWarnings("unused")
  54   public static void checkRestricted(boolean violationIsError, String classStr,
  55       String callingClassStr, String callingClassCodeSource) {
  56     if (System.getProperty("appengine.disableRestrictedCheck") == null) {
  57       RuntimeHelper.checkRestricted(
  58           violationIsError, classStr, callingClassStr, callingClassCodeSource);
  59     }
  60   }
  61
  62   private static boolean isBlackListed(Class<?> klass) {
  63     String className = klass.getName().replace('.', '/');
  64     return blackList.contains(className);
  65   }
  66
  67   private static Class<?> verifyWhiteListed(Member m) throws IllegalAccessException {
  68     Class<?> klass = m.getDeclaringClass();
  69     if (!isWhiteListed(klass, m)) {
  70       throw new IllegalAccessException("Reflection is not allowed on " + m);
  71     }
  72     return klass;
  73   }
  74
  75   private static void verifyReadable(Class<?> caller, Field f, Object target)
  76       throws IllegalAccessException {
  77     checkAccess(f, target, caller);
  78     verifyWhiteListed(f);
  79   }
  80
  81   private static void verifyWritable(Class<?> caller, Field f, Object target)
  82       throws IllegalAccessException {
  83     checkAccess(f, target, caller);
  84     Class<?> klass = verifyWhiteListed(f);
  85
  86     if (getClassLoaderPrivileged(klass) == null) {
  87       if (!Modifier.isPublic(f.getModifiers())) {
  88         throw new IllegalAccessException("Private fields can not be set on JRE classes.");
  89       }
  90     }
  91   }
  92
  93   private static ClassLoader getClassLoaderPrivileged(final Class<?> klass) {
  94     return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
  95       @Override
  96       public ClassLoader run() {
  97         return klass.getClassLoader();
  98       }
  99     });
 100   }
 101
 102   public static Object invoke(Method method, Object target, Object[] args) throws
 103       InvocationTargetException, IllegalAccessException {
 104     checkAccess(method, target, getImmediateCallerClassPrivileged());
 105     verifyWhiteListed(method);
 106     AccessibilityModifier am = new AccessibilityModifier(method);
 107     try {
 108       return method.invoke(target, args);
 109     } finally {
 110       am.restore();
 111     }
 112   }
 113
 114   private static Object newInstance_(Class<?> callerClass, Constructor<?> cons, Object[] args)
 115       throws InstantiationException, IllegalAccessException, InvocationTargetException {
 116     checkAccess(cons, null, callerClass);
 117     verifyWhiteListed(cons);
 118     AccessibilityModifier am = new AccessibilityModifier(cons);
 119     try {
 120       return cons.newInstance(args);
 121     } finally {
 122       am.restore();
 123     }
 124   }
 125
 126   public static Object newInstance(Constructor<?> cons, Object[] args)
 127       throws InstantiationException, IllegalAccessException, InvocationTargetException {
 128     return newInstance_(getImmediateCallerClassPrivileged(), cons, args);
 129   }
 130
 131   public static Object newInstance(final Class<?> klass) throws InstantiationException,
 132       IllegalAccessException {
 133     try {
 134       Constructor<?> cons = AccessController.doPrivileged(
 135           new PrivilegedExceptionAction<Constructor<?>>() {
 136             @Override
 137             public Constructor<?> run() throws NoSuchMethodException {
 138               return klass.getDeclaredConstructor();
 139             }
 140           });
 141       return newInstance_(getImmediateCallerClassPrivileged(), cons, new Object[0]);
 142     } catch (PrivilegedActionException e) {
 143       Throwable t = e.getCause();
 144       if (t instanceof NoSuchMethodException) {
 145         throw new InstantiationException(t.getMessage());
 146       }
 147       throw new RuntimeException(t);
 148     } catch (InvocationTargetException e) {
 149       throwAsUnchecked(e.getCause());
 150       throw new InstantiationException((e.getCause().getMessage()));
 151     }
 152   }
 153
 154   public static Object get(final Field f, final Object obj)
 155       throws IllegalAccessException, IllegalArgumentException {
 156     return verifyAndRun(f, obj, Op.Get, new Action<Object>() {
 157       @Override
 158       public Object run(Field f, Object target) throws IllegalAccessException {
 159         return f.get(target);
 160       }
 161     });
 162   }
 163
 164   public static boolean getBoolean(final Field f, final Object obj)
 165       throws IllegalAccessException, IllegalArgumentException {
 166     return verifyAndRun(f, obj, Op.Get, new Action<Boolean>() {
 167       @Override
 168       public Boolean run(Field f, Object target) throws IllegalAccessException {
 169         return f.getBoolean(target);
 170       }
 171     });
 172   }
 173
 174   public static byte getByte(final Field f, final Object obj)
 175       throws IllegalAccessException, IllegalArgumentException {
 176     return verifyAndRun(f, obj, Op.Get, new Action<Byte>() {
 177       @Override
 178       public Byte run(Field f, Object target) throws IllegalAccessException {
 179         return f.getByte(target);
 180       }
 181     });
 182   }
 183
 184   public static char getChar(final Field f, final Object obj)
 185       throws IllegalAccessException, IllegalArgumentException {
 186     return verifyAndRun(f, obj, Op.Get, new Action<Character>() {
 187       @Override
 188       public Character run(Field f, Object target) throws IllegalAccessException {
 189         return f.getChar(target);
 190       }
 191     });
 192   }
 193
 194   public static double getDouble(final Field f, final Object obj)
 195       throws IllegalAccessException, IllegalArgumentException {
 196     return verifyAndRun(f, obj, Op.Get, new Action<Double>() {
 197       @Override
 198       public Double run(Field f, Object target) throws IllegalAccessException {
 199         return f.getDouble(target);
 200       }
 201     });
 202   }
 203
 204   public static float getFloat(final Field f, final Object obj)
 205       throws IllegalAccessException, IllegalArgumentException {
 206     return verifyAndRun(f, obj, Op.Get, new Action<Float>() {
 207       @Override
 208       public Float run(Field f, Object target) throws IllegalAccessException {
 209         return f.getFloat(target);
 210       }
 211     });
 212   }
 213
 214   public static int getInt(final Field f, final Object obj)
 215       throws IllegalAccessException, IllegalArgumentException {
 216     return verifyAndRun(f, obj, Op.Get, new Action<Integer>() {
 217       @Override
 218       public Integer run(Field f, Object target) throws IllegalAccessException {
 219         return f.getInt(target);
 220       }
 221     });
 222   }
 223
 224   public static long getLong(final Field f, final Object obj)
 225       throws IllegalAccessException, IllegalArgumentException {
 226     return verifyAndRun(f, obj, Op.Get, new Action<Long>() {
 227       @Override
 228       public Long run(Field f, Object target) throws IllegalAccessException {
 229         return f.getLong(target);
 230       }
 231     });
 232   }
 233
 234   public static short getShort(final Field f, final Object obj)
 235       throws IllegalAccessException, IllegalArgumentException {
 236     return verifyAndRun(f, obj, Op.Get, new Action<Short>() {
 237       @Override
 238       public Short run(Field f, Object target) throws IllegalAccessException {
 239         return f.getShort(target);
 240       }
 241     });
 242   }
 243
 244   public static void set(Field f, Object obj, final Object value)
 245       throws IllegalAccessException, IllegalArgumentException {
 246     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 247       @Override
 248       public Object run(Field f, Object target) throws IllegalAccessException {
 249         f.set(target, value);
 250         return null;
 251       }
 252     });
 253   }
 254
 255   public static void setBoolean(Field f, Object obj, final boolean value)
 256       throws IllegalAccessException, IllegalArgumentException {
 257     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 258       @Override
 259       public Object run(Field f, Object target) throws IllegalAccessException {
 260         f.setBoolean(target, value);
 261         return null;
 262       }
 263     });
 264   }
 265
 266   public static void setByte(Field f, Object obj, final byte value)
 267       throws IllegalAccessException, IllegalArgumentException {
 268     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 269       @Override
 270       public Object run(Field f, Object target) throws IllegalAccessException {
 271         f.setByte(target, value);
 272         return null;
 273       }
 274     });
 275   }
 276
 277   public static void setChar(Field f, Object obj, final char value)
 278       throws IllegalAccessException, IllegalArgumentException {
 279     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 280       @Override
 281       public Object run(Field f, Object target) throws IllegalAccessException {
 282         f.setChar(target, value);
 283         return null;
 284       }
 285     });
 286   }
 287
 288   public static void setDouble(Field f, Object obj, final double value)
 289       throws IllegalAccessException, IllegalArgumentException {
 290     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 291       @Override
 292       public Object run(Field f, Object target) throws IllegalAccessException {
 293         f.setDouble(target, value);
 294         return null;
 295       }
 296     });
 297   }
 298
 299   public static void setFloat(Field f, Object obj, final float value)
 300       throws IllegalAccessException, IllegalArgumentException {
 301     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 302       @Override
 303       public Object run(Field f, Object target) throws IllegalAccessException {
 304         f.setFloat(target, value);
 305         return null;
 306       }
 307     });
 308   }
 309
 310   public static void setInt(Field f, Object obj, final int value)
 311       throws IllegalAccessException, IllegalArgumentException {
 312     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 313       @Override
 314       public Object run(Field f, Object target) throws IllegalAccessException {
 315         f.setInt(target, value);
 316         return null;
 317       }
 318     });
 319   }
 320
 321   public static void setLong(Field f, Object obj, final long value)
 322       throws IllegalAccessException, IllegalArgumentException {
 323     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 324       @Override
 325       public Object run(Field f, Object target) throws IllegalAccessException {
 326         f.setLong(target, value);
 327         return null;
 328       }
 329     });
 330   }
 331
 332   public static void setShort(Field f, Object obj, final short value)
 333       throws IllegalAccessException, IllegalArgumentException {
 334     verifyAndRun(f, obj, Op.Set, new Action<Object>() {
 335       @Override
 336       public Object run(Field f, Object target) throws IllegalAccessException {
 337         f.setShort(target, value);
 338         return null;
 339       }
 340     });
 341   }
 342
 343   enum Op {
 344     Get,
 345     Set
 346   }
 347
 348   private interface Action<T> {
 349     public T run(Field f, Object target) throws IllegalAccessException;
 350   }
 351
 352   private static <T> T verifyAndRun(Field f, Object target, Op op, Action<T> action)
 353       throws IllegalAccessException {
 354     Class<?> userCaller = getCallerClassPrivileged(3);
 355     if (op == Op.Get) {
 356       verifyReadable(userCaller, f, target);
 357     } else {
 358       verifyWritable(userCaller, f, target);
 359     }
 360
 361     AccessibilityModifier am = new AccessibilityModifier(f);
 362     try {
 363       return action.run(f, target);
 364     } finally {
 365       am.restore();
 366     }
 367   }
 368
 369   private static boolean isWhiteListed(Class<?> klass, Member member) {
 370     if (klass == null) {
 371       return false;
 372     }
 373
 374     if (isWhiteListed_(klass, member)) {
 375       return true;
 376     }
 377
 378     if (member instanceof Constructor) {
 379       return false;
 380     }
 381
 382     Class<?>[] interfaces = klass.getInterfaces();
 383
 384     for (Class<?> i : interfaces) {
 385       if (isWhiteListed(i, member)) {
 386         return true;
 387       }
 388     }
 389
 390     Class<?> parentClass = klass.getSuperclass();
 391     return isWhiteListed(parentClass, member);
 392   }
 393
 394   private static boolean isWhiteListed_(Class<?> klass, Member member) {
 395     if (isBlackListed(klass)) {
 396       return false;
 397     }
 398     if (klass == member.getDeclaringClass()) {
 399       return true;
 400     }
 401     return hasMember(klass, member);
 402   }
 403
 404   private static boolean hasMember(Class<?> klass, Member member) {
 405     if (member instanceof Method) {
 406       Method m = (Method) member;
 407       try {
 408         klass.getDeclaredMethod(m.getName(), m.getParameterTypes());
 409         return true;
 410       } catch (NoSuchMethodException e) {
 411         return false;
 412       }
 413     }
 414
 415     if (member instanceof Constructor) {
 416       Constructor<?> constructor = (Constructor<?>) member;
 417       try {
 418         klass.getDeclaredConstructor(constructor.getParameterTypes());
 419         return true;
 420       } catch (NoSuchMethodException e) {
 421         return false;
 422       }
 423     }
 424
 425     Field field = (Field) member;
 426     try {
 427       klass.getDeclaredField(field.getName());
 428       return true;
 429     } catch (NoSuchFieldException e) {
 430       return false;
 431     }
 432   }
 433
 434   private static Class<?> getImmediateCallerClassPrivileged() {
 435     return getCallerClassPrivileged(3);
 436   }
 437
 438   private static Class<?> getCallerClassPrivileged(final int depth) {
 439     return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
 440       @Override
 441       public Class<?> run() {
 442         return Reflection.getCallerClass(depth + 4);
 443       }
 444     });
 445   }
 446
 447   private static <T extends AccessibleObject & Member> void checkAccess(final T m,
 448       final Object target, Class<?> caller)
 449       throws IllegalAccessException {
 450     if (m.isAccessible()) {
 451       return;
 452     }
 453     checkAccess(caller, m.getDeclaringClass(), target, m.getModifiers());
 454   }
 455
 456   private static void checkAccess(final Class<?> caller, final Class<?> member, final Object target,
 457       final int modifiers) throws IllegalAccessException {
 458     try {
 459       AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
 460         @Override
 461         public Object run() throws IllegalAccessException {
 462           Reflection.ensureMemberAccess(caller, member, target, modifiers);
 463           return null;
 464         }
 465       });
 466     } catch (PrivilegedActionException e) {
 467       Throwable t = e.getCause();
 468       if (t instanceof IllegalAccessException) {
 469         throw (IllegalAccessException) t;
 470       }
 471       throw new RuntimeException(t);
 472     }
 473   }
 474
 475   public static void throwAsUnchecked(Throwable t) {
 476     Runtime.<RuntimeException>throwException_(t);
 477   }
 478
 479   @SuppressWarnings("unchecked")
 480   private static <T extends Throwable> void throwException_(Throwable t) throws T {
 481     throw (T) t;
 482   }
 483
 484   static class AccessibilityModifier {
 485     private final AccessibleObject obj;
 486     private final boolean originalAccessibility;
 487
 488     AccessibilityModifier(AccessibleObject obj) {
 489       this.obj = obj;
 490       originalAccessibility = obj.isAccessible();
 491       setAccessible_(true);
 492     }
 493
 494     public void restore() {
 495       setAccessible_(originalAccessibility);
 496     }
 497
 498     private void setAccessible_(final boolean flag) {
 499       AccessController.doPrivileged(new PrivilegedAction<Object>() {
 500         @Override
 501         public Object run() {
 502           obj.setAccessible(flag);
 503           return null;
 504         }
 505       });
 506     }
 507   }
 508 }