1 /*
   2  * Copyright (c) 2010, 2013, 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 jdk.nashorn.internal.runtime;
  27 
  28 import static jdk.nashorn.internal.codegen.CompilerConstants.RUN_SCRIPT;
  29 import static jdk.nashorn.internal.codegen.CompilerConstants.STRICT_MODE;
  30 import static jdk.nashorn.internal.lookup.Lookup.MH;
  31 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
  32 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
  33 
  34 import java.io.File;
  35 import java.io.IOException;
  36 import java.io.PrintWriter;
  37 import java.lang.invoke.MethodHandle;
  38 import java.lang.invoke.MethodHandles;
  39 import java.lang.ref.ReferenceQueue;
  40 import java.lang.ref.SoftReference;
  41 import java.lang.reflect.Modifier;
  42 import java.net.MalformedURLException;
  43 import java.net.URL;
  44 import java.security.AccessControlContext;
  45 import java.security.AccessController;
  46 import java.security.CodeSigner;
  47 import java.security.CodeSource;
  48 import java.security.Permissions;
  49 import java.security.PrivilegedAction;
  50 import java.security.ProtectionDomain;
  51 import java.util.LinkedHashMap;
  52 import java.util.Map;
  53 import java.util.concurrent.atomic.AtomicLong;
  54 import jdk.internal.org.objectweb.asm.ClassReader;
  55 import jdk.internal.org.objectweb.asm.util.CheckClassAdapter;
  56 import jdk.nashorn.api.scripting.ScriptObjectMirror;
  57 import jdk.nashorn.internal.codegen.Compiler;
  58 import jdk.nashorn.internal.codegen.ObjectClassGenerator;
  59 import jdk.nashorn.internal.ir.FunctionNode;
  60 import jdk.nashorn.internal.ir.debug.ASTWriter;
  61 import jdk.nashorn.internal.ir.debug.PrintVisitor;
  62 import jdk.nashorn.internal.objects.Global;
  63 import jdk.nashorn.internal.parser.Parser;
  64 import jdk.nashorn.internal.runtime.options.Options;
  65 
  66 /**
  67  * This class manages the global state of execution. Context is immutable.
  68  */
  69 public final class Context {
  70     // nashorn specific security runtime access permission names
  71     /**
  72      * Permission needed to pass arbitrary nashorn command line options when creating Context.
  73      */
  74     public static final String NASHORN_SET_CONFIG      = "nashorn.setConfig";
  75 
  76     /**
  77      * Permission needed to create Nashorn Context instance.
  78      */
  79     public static final String NASHORN_CREATE_CONTEXT  = "nashorn.createContext";
  80 
  81     /**
  82      * Permission needed to create Nashorn Global instance.
  83      */
  84     public static final String NASHORN_CREATE_GLOBAL   = "nashorn.createGlobal";
  85 
  86     /**
  87      * Permission to get current Nashorn Context from thread local storage.
  88      */
  89     public static final String NASHORN_GET_CONTEXT     = "nashorn.getContext";
  90 
  91     /**
  92      * Permission to use Java reflection/jsr292 from script code.
  93      */
  94     public static final String NASHORN_JAVA_REFLECTION = "nashorn.JavaReflection";
  95 
  96     /**
  97      * Permission to enable nashorn debug mode.
  98      */
  99     public static final String NASHORN_DEBUG_MODE = "nashorn.debugMode";
 100 
 101     // nashorn load psuedo URL prefixes
 102     private static final String LOAD_CLASSPATH = "classpath:";
 103     private static final String LOAD_FX = "fx:";
 104     private static final String LOAD_NASHORN = "nashorn:";
 105 
 106     /* Force DebuggerSupport to be loaded. */
 107     static {
 108         DebuggerSupport.FORCELOAD = true;
 109     }
 110 
 111     /**
 112      * ContextCodeInstaller that has the privilege of installing classes in the Context.
 113      * Can only be instantiated from inside the context and is opaque to other classes
 114      */
 115     public static class ContextCodeInstaller implements CodeInstaller<ScriptEnvironment> {
 116         private final Context      context;
 117         private final ScriptLoader loader;
 118         private final CodeSource   codeSource;
 119 
 120         private ContextCodeInstaller(final Context context, final ScriptLoader loader, final CodeSource codeSource) {
 121             this.context    = context;
 122             this.loader     = loader;
 123             this.codeSource = codeSource;
 124         }
 125 
 126         /**
 127          * Return the context for this installer
 128          * @return ScriptEnvironment
 129          */
 130         @Override
 131         public ScriptEnvironment getOwner() {
 132             return context.env;
 133         }
 134 
 135         @Override
 136         public Class<?> install(final String className, final byte[] bytecode) {
 137             return loader.installClass(className, bytecode, codeSource);
 138         }
 139 
 140         @Override
 141         public void verify(final byte[] code) {
 142             context.verify(code);
 143         }
 144 
 145         @Override
 146         public long getUniqueScriptId() {
 147             return context.getUniqueScriptId();
 148         }
 149 
 150         @Override
 151         public long getUniqueEvalId() {
 152             return context.getUniqueEvalId();
 153         }
 154     }
 155 
 156     /** Is Context global debug mode enabled ? */
 157     public static final boolean DEBUG = Options.getBooleanProperty("nashorn.debug");
 158 
 159     private static final ThreadLocal<ScriptObject> currentGlobal = new ThreadLocal<>();
 160 
 161     // class cache
 162     private ClassCache classCache;
 163 
 164     /**
 165      * Get the current global scope
 166      * @return the current global scope
 167      */
 168     public static ScriptObject getGlobal() {
 169         // This class in a package.access protected package.
 170         // Trusted code only can call this method.
 171         return getGlobalTrusted();
 172     }
 173 
 174     /**
 175      * Set the current global scope
 176      * @param global the global scope
 177      */
 178     public static void setGlobal(final ScriptObject global) {
 179         if (global != null && !(global instanceof Global)) {
 180             throw new IllegalArgumentException("global is not an instance of Global!");


 181         }
 182 
 183         setGlobalTrusted(global);







 184     }
 185 
 186     /**
 187      * Get context of the current global
 188      * @return current global scope's context.
 189      */
 190     public static Context getContext() {
 191         final SecurityManager sm = System.getSecurityManager();
 192         if (sm != null) {
 193             sm.checkPermission(new RuntimePermission(NASHORN_GET_CONTEXT));
 194         }
 195         return getContextTrusted();
 196     }
 197 
 198     /**
 199      * Get current context's error writer
 200      *
 201      * @return error writer of the current context
 202      */
 203     public static PrintWriter getCurrentErr() {
 204         final ScriptObject global = getGlobalTrusted();
 205         return (global != null)? global.getContext().getErr() : new PrintWriter(System.err);
 206     }
 207 
 208     /**
 209      * Output text to this Context's error stream
 210      * @param str text to write
 211      */
 212     public static void err(final String str) {
 213         err(str, true);
 214     }
 215 
 216     /**
 217      * Output text to this Context's error stream, optionally with
 218      * a newline afterwards
 219      *
 220      * @param str  text to write
 221      * @param crlf write a carriage return/new line after text
 222      */
 223     @SuppressWarnings("resource")
 224     public static void err(final String str, final boolean crlf) {
 225         final PrintWriter err = Context.getCurrentErr();
 226         if (err != null) {
 227             if (crlf) {
 228                 err.println(str);
 229             } else {
 230                 err.print(str);
 231             }
 232         }
 233     }
 234 
 235     /** Current environment. */
 236     private final ScriptEnvironment env;
 237 
 238     /** is this context in strict mode? Cached from env. as this is used heavily. */
 239     final boolean _strict;
 240 
 241     /** class loader to resolve classes from script. */
 242     private final ClassLoader  appLoader;
 243 
 244     /** Class loader to load classes from -classpath option, if set. */
 245     private final ClassLoader  classPathLoader;
 246 
 247     /** Class loader to load classes compiled from scripts. */
 248     private final ScriptLoader scriptLoader;
 249 
 250     /** Current error manager. */
 251     private final ErrorManager errors;
 252 
 253     /** Unique id for script. Used only when --loader-per-compile=false */
 254     private final AtomicLong uniqueScriptId;
 255 
 256     /** Unique id for 'eval' */
 257     private final AtomicLong uniqueEvalId;
 258 
 259     private static final ClassLoader myLoader = Context.class.getClassLoader();
 260     private static final StructureLoader sharedLoader;
 261 
 262     /*package-private*/ @SuppressWarnings("static-method")
 263     ClassLoader getSharedLoader() {
 264         return sharedLoader;
 265     }
 266 
 267     private static AccessControlContext createNoPermAccCtxt() {
 268         return new AccessControlContext(new ProtectionDomain[] { new ProtectionDomain(null, new Permissions()) });
 269     }
 270 
 271     private static AccessControlContext createPermAccCtxt(final String permName) {
 272         final Permissions perms = new Permissions();
 273         perms.add(new RuntimePermission(permName));
 274         return new AccessControlContext(new ProtectionDomain[] { new ProtectionDomain(null, perms) });
 275     }
 276 
 277     private static final AccessControlContext NO_PERMISSIONS_ACC_CTXT = createNoPermAccCtxt();
 278     private static final AccessControlContext CREATE_LOADER_ACC_CTXT  = createPermAccCtxt("createClassLoader");
 279     private static final AccessControlContext CREATE_GLOBAL_ACC_CTXT  = createPermAccCtxt(NASHORN_CREATE_GLOBAL);
 280 
 281     static {
 282         sharedLoader = AccessController.doPrivileged(new PrivilegedAction<StructureLoader>() {
 283             @Override
 284             public StructureLoader run() {
 285                 return new StructureLoader(myLoader);
 286             }
 287         }, CREATE_LOADER_ACC_CTXT);
 288     }
 289 
 290     /**
 291      * ThrowErrorManager that throws ParserException upon error conditions.
 292      */
 293     public static class ThrowErrorManager extends ErrorManager {
 294         @Override
 295         public void error(final String message) {
 296             throw new ParserException(message);
 297         }
 298 
 299         @Override
 300         public void error(final ParserException e) {
 301             throw e;
 302         }
 303     }
 304 
 305     /**
 306      * Constructor
 307      *
 308      * @param options options from command line or Context creator
 309      * @param errors  error manger
 310      * @param appLoader application class loader
 311      */
 312     public Context(final Options options, final ErrorManager errors, final ClassLoader appLoader) {
 313         this(options, errors, new PrintWriter(System.out, true), new PrintWriter(System.err, true), appLoader);
 314     }
 315 
 316     /**
 317      * Constructor
 318      *
 319      * @param options options from command line or Context creator
 320      * @param errors  error manger
 321      * @param out     output writer for this Context
 322      * @param err     error writer for this Context
 323      * @param appLoader application class loader
 324      */
 325     public Context(final Options options, final ErrorManager errors, final PrintWriter out, final PrintWriter err, final ClassLoader appLoader) {
 326         final SecurityManager sm = System.getSecurityManager();
 327         if (sm != null) {
 328             sm.checkPermission(new RuntimePermission(NASHORN_CREATE_CONTEXT));
 329         }
 330 
 331         this.env       = new ScriptEnvironment(options, out, err);
 332         this._strict   = env._strict;
 333         this.appLoader = appLoader;
 334         if (env._loader_per_compile) {
 335             this.scriptLoader = null;
 336             this.uniqueScriptId = null;
 337         } else {
 338             this.scriptLoader = createNewLoader();
 339             this.uniqueScriptId = new AtomicLong();
 340         }
 341         this.errors    = errors;
 342         this.uniqueEvalId = new AtomicLong();
 343 
 344         // if user passed -classpath option, make a class loader with that and set it as
 345         // thread context class loader so that script can access classes from that path.
 346         final String classPath = options.getString("classpath");
 347         if (! env._compile_only && classPath != null && !classPath.isEmpty()) {
 348             // make sure that caller can create a class loader.
 349             if (sm != null) {
 350                 sm.checkPermission(new RuntimePermission("createClassLoader"));
 351             }
 352             this.classPathLoader = NashornLoader.createClassLoader(classPath);
 353         } else {
 354             this.classPathLoader = null;
 355         }
 356 
 357         final int cacheSize = env._class_cache_size;
 358         if (cacheSize > 0) {
 359             classCache = new ClassCache(cacheSize);
 360         }
 361 
 362         // print version info if asked.
 363         if (env._version) {
 364             getErr().println("nashorn " + Version.version());
 365         }
 366 
 367         if (env._fullversion) {
 368             getErr().println("nashorn full version " + Version.fullVersion());
 369         }
 370     }
 371 
 372     /**
 373      * Get the error manager for this context
 374      * @return error manger
 375      */
 376     public ErrorManager getErrorManager() {
 377         return errors;
 378     }
 379 
 380     /**
 381      * Get the script environment for this context
 382      * @return script environment
 383      */
 384     public ScriptEnvironment getEnv() {
 385         return env;
 386     }
 387 
 388     /**
 389      * Get the output stream for this context
 390      * @return output print writer
 391      */
 392     public PrintWriter getOut() {
 393         return env.getOut();
 394     }
 395 
 396     /**
 397      * Get the error stream for this context
 398      * @return error print writer
 399      */
 400     public PrintWriter getErr() {
 401         return env.getErr();
 402     }
 403 
 404     /**
 405      * Get the PropertyMap of the current global scope
 406      * @return the property map of the current global scope
 407      */
 408     public static PropertyMap getGlobalMap() {
 409         return Context.getGlobalTrusted().getMap();
 410     }
 411 
 412     /**
 413      * Compile a top level script.
 414      *
 415      * @param source the source
 416      * @param scope  the scope
 417      *
 418      * @return top level function for script
 419      */
 420     public ScriptFunction compileScript(final Source source, final ScriptObject scope) {
 421         return compileScript(source, scope, this.errors);
 422     }
 423 
 424     /**
 425      * Entry point for {@code eval}
 426      *
 427      * @param initialScope The scope of this eval call
 428      * @param string       Evaluated code as a String
 429      * @param callThis     "this" to be passed to the evaluated code
 430      * @param location     location of the eval call
 431      * @param strict       is this {@code eval} call from a strict mode code?
 432      *
 433      * @return the return value of the {@code eval}
 434      */
 435     public Object eval(final ScriptObject initialScope, final String string, final Object callThis, final Object location, final boolean strict) {
 436         final String  file       = (location == UNDEFINED || location == null) ? "<eval>" : location.toString();
 437         final Source  source     = new Source(file, string);
 438         final boolean directEval = location != UNDEFINED; // is this direct 'eval' call or indirectly invoked eval?
 439         final ScriptObject global = Context.getGlobalTrusted();
 440 
 441         ScriptObject scope = initialScope;
 442 
 443         // ECMA section 10.1.1 point 2 says eval code is strict if it begins
 444         // with "use strict" directive or eval direct call itself is made
 445         // from from strict mode code. We are passed with caller's strict mode.
 446         boolean strictFlag = directEval && strict;
 447 
 448         Class<?> clazz = null;
 449         try {
 450             clazz = compile(source, new ThrowErrorManager(), strictFlag);
 451         } catch (final ParserException e) {
 452             e.throwAsEcmaException(global);
 453             return null;
 454         }
 455 
 456         if (!strictFlag) {
 457             // We need to get strict mode flag from compiled class. This is
 458             // because eval code may start with "use strict" directive.
 459             try {
 460                 strictFlag = clazz.getField(STRICT_MODE.symbolName()).getBoolean(null);
 461             } catch (final NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
 462                 //ignored
 463                 strictFlag = false;
 464             }
 465         }
 466 
 467         // In strict mode, eval does not instantiate variables and functions
 468         // in the caller's environment. A new environment is created!
 469         if (strictFlag) {
 470             // Create a new scope object
 471             final ScriptObject strictEvalScope = ((GlobalObject)global).newObject();
 472 
 473             // bless it as a "scope"
 474             strictEvalScope.setIsScope();
 475 
 476             // set given scope to be it's proto so that eval can still
 477             // access caller environment vars in the new environment.
 478             strictEvalScope.setProto(scope);
 479             scope = strictEvalScope;
 480         }
 481 
 482         ScriptFunction func = getRunScriptFunction(clazz, scope);
 483         Object evalThis;
 484         if (directEval) {
 485             evalThis = (callThis instanceof ScriptObject || strictFlag) ? callThis : global;
 486         } else {
 487             evalThis = global;
 488         }
 489 
 490         return ScriptRuntime.apply(func, evalThis);
 491     }
 492 
 493     private static Source loadInternal(final String srcStr, final String prefix, final String resourcePath) {
 494         if (srcStr.startsWith(prefix)) {
 495             final String resource = resourcePath + srcStr.substring(prefix.length());
 496             // NOTE: even sandbox scripts should be able to load scripts in nashorn: scheme
 497             // These scripts are always available and are loaded from nashorn.jar's resources.
 498             return AccessController.doPrivileged(
 499                     new PrivilegedAction<Source>() {
 500                         @Override
 501                         public Source run() {
 502                             try {
 503                                 final URL resURL = Context.class.getResource(resource);
 504                                 return (resURL != null)? new Source(srcStr, resURL) : null;
 505                             } catch (final IOException exp) {
 506                                 return null;
 507                             }
 508                         }
 509                     });
 510         }
 511 
 512         return null;
 513     }
 514 
 515     /**
 516      * Implementation of {@code load} Nashorn extension. Load a script file from a source
 517      * expression
 518      *
 519      * @param scope  the scope
 520      * @param from   source expression for script
 521      *
 522      * @return return value for load call (undefined)
 523      *
 524      * @throws IOException if source cannot be found or loaded
 525      */
 526     public Object load(final ScriptObject scope, final Object from) throws IOException {
 527         final Object src = (from instanceof ConsString)?  from.toString() : from;
 528         Source source = null;
 529 
 530         // load accepts a String (which could be a URL or a file name), a File, a URL
 531         // or a ScriptObject that has "name" and "source" (string valued) properties.
 532         if (src instanceof String) {
 533             final String srcStr = (String)src;
 534             if (srcStr.startsWith(LOAD_CLASSPATH)) {
 535                 URL url = getResourceURL(srcStr.substring(LOAD_CLASSPATH.length()));
 536                 source = (url != null)? new Source(url.toString(), url) : null;
 537             } else {
 538                 final File file = new File(srcStr);
 539                 if (srcStr.indexOf(':') != -1) {
 540                     if ((source = loadInternal(srcStr, LOAD_NASHORN, "resources/")) == null &&
 541                         (source = loadInternal(srcStr, LOAD_FX, "resources/fx/")) == null) {
 542                         URL url;
 543                         try {
 544                             //check for malformed url. if malformed, it may still be a valid file
 545                             url = new URL(srcStr);
 546                         } catch (final MalformedURLException e) {
 547                             url = file.toURI().toURL();
 548                         }
 549                         source = new Source(url.toString(), url);
 550                     }
 551                 } else if (file.isFile()) {
 552                     source = new Source(srcStr, file);
 553                 }
 554             }
 555         } else if (src instanceof File && ((File)src).isFile()) {
 556             final File file = (File)src;
 557             source = new Source(file.getName(), file);
 558         } else if (src instanceof URL) {
 559             final URL url = (URL)src;
 560             source = new Source(url.toString(), url);
 561         } else if (src instanceof ScriptObject) {
 562             final ScriptObject sobj = (ScriptObject)src;
 563             if (sobj.has("script") && sobj.has("name")) {
 564                 final String script = JSType.toString(sobj.get("script"));
 565                 final String name   = JSType.toString(sobj.get("name"));
 566                 source = new Source(name, script);
 567             }
 568         } else if (src instanceof Map) {
 569             final Map<?,?> map = (Map<?,?>)src;
 570             if (map.containsKey("script") && map.containsKey("name")) {
 571                 final String script = JSType.toString(map.get("script"));
 572                 final String name   = JSType.toString(map.get("name"));
 573                 source = new Source(name, script);
 574             }
 575         }
 576 
 577         if (source != null) {
 578             return evaluateSource(source, scope, scope);
 579         }
 580 
 581         throw typeError("cant.load.script", ScriptRuntime.safeToString(from));
 582     }
 583 
 584     /**
 585      * Implementation of {@code loadWithNewGlobal} Nashorn extension. Load a script file from a source
 586      * expression, after creating a new global scope.
 587      *
 588      * @param from source expression for script
 589      * @param args (optional) arguments to be passed to the loaded script
 590      *
 591      * @return return value for load call (undefined)
 592      *
 593      * @throws IOException if source cannot be found or loaded
 594      */
 595     public Object loadWithNewGlobal(final Object from, final Object...args) throws IOException {
 596         final ScriptObject oldGlobal = getGlobalTrusted();
 597         final ScriptObject newGlobal = AccessController.doPrivileged(new PrivilegedAction<ScriptObject>() {
 598            @Override
 599            public ScriptObject run() {
 600                try {
 601                    return newGlobal();
 602                } catch (final RuntimeException e) {
 603                    if (Context.DEBUG) {
 604                        e.printStackTrace();
 605                    }
 606                    throw e;
 607                }
 608            }
 609         }, CREATE_GLOBAL_ACC_CTXT);
 610         // initialize newly created Global instance
 611         initGlobal(newGlobal);
 612         setGlobalTrusted(newGlobal);
 613 
 614         final Object[] wrapped = args == null? ScriptRuntime.EMPTY_ARRAY :  ScriptObjectMirror.wrapArray(args, oldGlobal);
 615         newGlobal.put("arguments", ((GlobalObject)newGlobal).wrapAsObject(wrapped), env._strict);
 616 
 617         try {
 618             // wrap objects from newGlobal's world as mirrors - but if result
 619             // is from oldGlobal's world, unwrap it!
 620             return ScriptObjectMirror.unwrap(ScriptObjectMirror.wrap(load(newGlobal, from), newGlobal), oldGlobal);
 621         } finally {
 622             setGlobalTrusted(oldGlobal);
 623         }
 624     }
 625 
 626     /**
 627      * Load or get a structure class. Structure class names are based on the number of parameter fields
 628      * and {@link AccessorProperty} fields in them. Structure classes are used to represent ScriptObjects
 629      *
 630      * @see ObjectClassGenerator
 631      * @see AccessorProperty
 632      * @see ScriptObject
 633      *
 634      * @param fullName  full name of class, e.g. jdk.nashorn.internal.objects.JO2P1 contains 2 fields and 1 parameter.
 635      *
 636      * @return the {@code Class<?>} for this structure
 637      *
 638      * @throws ClassNotFoundException if structure class cannot be resolved
 639      */
 640     public static Class<?> forStructureClass(final String fullName) throws ClassNotFoundException {
 641         if (System.getSecurityManager() != null && !StructureLoader.isStructureClass(fullName)) {
 642             throw new ClassNotFoundException(fullName);
 643         }
 644         return Class.forName(fullName, true, sharedLoader);
 645     }
 646 
 647     /**
 648      * Checks that the given Class can be accessed from no permissions context.
 649      *
 650      * @param clazz Class object
 651      * @throws SecurityException if not accessible
 652      */
 653     public static void checkPackageAccess(final Class<?> clazz) {
 654         final SecurityManager sm = System.getSecurityManager();
 655         if (sm != null) {
 656             Class<?> bottomClazz = clazz;
 657             while (bottomClazz.isArray()) {
 658                 bottomClazz = bottomClazz.getComponentType();
 659             }
 660             checkPackageAccess(sm, bottomClazz.getName());
 661         }
 662     }
 663 
 664     /**
 665      * Checks that the given package name can be accessed from no permissions context.
 666      *
 667      * @param pkgName package name
 668      * @throws SecurityException if not accessible
 669      */
 670     public static void checkPackageAccess(final String pkgName) {
 671         final SecurityManager sm = System.getSecurityManager();
 672         if (sm != null) {
 673             checkPackageAccess(sm, pkgName.endsWith(".") ? pkgName : pkgName + ".");
 674         }
 675     }
 676 
 677     /**
 678      * Checks that the given package can be accessed from no permissions context.
 679      *
 680      * @param sm current security manager instance
 681      * @param fullName fully qualified package name
 682      * @throw SecurityException if not accessible
 683      */
 684     private static void checkPackageAccess(final SecurityManager sm, final String fullName) {
 685         sm.getClass(); // null check
 686         final int index = fullName.lastIndexOf('.');
 687         if (index != -1) {
 688             final String pkgName = fullName.substring(0, index);
 689             AccessController.doPrivileged(new PrivilegedAction<Void>() {
 690                 @Override
 691                 public Void run() {
 692                     sm.checkPackageAccess(pkgName);
 693                     return null;
 694                 }
 695             }, NO_PERMISSIONS_ACC_CTXT);
 696         }
 697     }
 698 
 699     /**
 700      * Checks that the given Class can be accessed from no permissions context.
 701      *
 702      * @param clazz Class object
 703      * @return true if package is accessible, false otherwise
 704      */
 705     private static boolean isAccessiblePackage(final Class<?> clazz) {
 706         try {
 707             checkPackageAccess(clazz);
 708             return true;
 709         } catch (final SecurityException se) {
 710             return false;
 711         }
 712     }
 713 
 714     /**
 715      * Checks that the given Class is public and it can be accessed from no permissions context.
 716      *
 717      * @param clazz Class object to check
 718      * @return true if Class is accessible, false otherwise
 719      */
 720     public static boolean isAccessibleClass(final Class<?> clazz) {
 721         return Modifier.isPublic(clazz.getModifiers()) && Context.isAccessiblePackage(clazz);
 722     }
 723 
 724     /**
 725      * Lookup a Java class. This is used for JSR-223 stuff linking in from
 726      * {@code jdk.nashorn.internal.objects.NativeJava} and {@code jdk.nashorn.internal.runtime.NativeJavaPackage}
 727      *
 728      * @param fullName full name of class to load
 729      *
 730      * @return the {@code Class<?>} for the name
 731      *
 732      * @throws ClassNotFoundException if class cannot be resolved
 733      */
 734     public Class<?> findClass(final String fullName) throws ClassNotFoundException {
 735         if (fullName.indexOf('[') != -1 || fullName.indexOf('/') != -1) {
 736             // don't allow array class names or internal names.
 737             throw new ClassNotFoundException(fullName);
 738         }
 739 
 740         // check package access as soon as possible!
 741         final SecurityManager sm = System.getSecurityManager();
 742         if (sm != null) {
 743             checkPackageAccess(sm, fullName);
 744         }
 745 
 746         // try the script -classpath loader, if that is set
 747         if (classPathLoader != null) {
 748             try {
 749                 return Class.forName(fullName, true, classPathLoader);
 750             } catch (final ClassNotFoundException ignored) {
 751                 // ignore, continue search
 752             }
 753         }
 754 
 755         // Try finding using the "app" loader.
 756         return Class.forName(fullName, true, appLoader);
 757     }
 758 
 759     /**
 760      * Hook to print stack trace for a {@link Throwable} that occurred during
 761      * execution
 762      *
 763      * @param t throwable for which to dump stack
 764      */
 765     public static void printStackTrace(final Throwable t) {
 766         if (Context.DEBUG) {
 767             t.printStackTrace(Context.getCurrentErr());
 768         }
 769     }
 770 
 771     /**
 772      * Verify generated bytecode before emission. This is called back from the
 773      * {@link ObjectClassGenerator} or the {@link Compiler}. If the "--verify-code" parameter
 774      * hasn't been given, this is a nop
 775      *
 776      * Note that verification may load classes -- we don't want to do that unless
 777      * user specified verify option. We check it here even though caller
 778      * may have already checked that flag
 779      *
 780      * @param bytecode bytecode to verify
 781      */
 782     public void verify(final byte[] bytecode) {
 783         if (env._verify_code) {
 784             // No verification when security manager is around as verifier
 785             // may load further classes - which should be avoided.
 786             if (System.getSecurityManager() == null) {
 787                 CheckClassAdapter.verify(new ClassReader(bytecode), sharedLoader, false, new PrintWriter(System.err, true));
 788             }
 789         }
 790     }
 791 
 792     /**
 793      * Create and initialize a new global scope object.
 794      *
 795      * @return the initialized global scope object.
 796      */
 797     public ScriptObject createGlobal() {
 798         return initGlobal(newGlobal());
 799     }
 800 
 801     /**
 802      * Create a new uninitialized global scope object
 803      * @return the global script object
 804      */
 805     public ScriptObject newGlobal() {
 806         return new Global(this);
 807     }
 808 
 809     /**
 810      * Initialize given global scope object.
 811      *
 812      * @param global the global
 813      * @return the initialized global scope object.
 814      */
 815     public ScriptObject initGlobal(final ScriptObject global) {
 816         if (! (global instanceof GlobalObject)) {
 817             throw new IllegalArgumentException("not a global object!");
 818         }
 819 
 820         // Need only minimal global object, if we are just compiling.
 821         if (!env._compile_only) {
 822             final ScriptObject oldGlobal = Context.getGlobalTrusted();
 823             try {
 824                 Context.setGlobalTrusted(global);
 825                 // initialize global scope with builtin global objects
 826                 ((GlobalObject)global).initBuiltinObjects();
 827             } finally {
 828                 Context.setGlobalTrusted(oldGlobal);
 829             }
 830         }
 831 
 832         return global;
 833     }
 834 
 835     /**
 836      * Trusted variants - package-private
 837      */
 838 
 839     /**
 840      * Return the current global scope
 841      * @return current global scope
 842      */
 843     static ScriptObject getGlobalTrusted() {
 844         return currentGlobal.get();
 845     }
 846 
 847     /**
 848      * Set the current global scope
 849      */
 850     static void setGlobalTrusted(ScriptObject global) {
 851          currentGlobal.set(global);
 852     }
 853 
 854     /**
 855      * Return the current global's context
 856      * @return current global's context
 857      */
 858     static Context getContextTrusted() {
 859         return Context.getGlobalTrusted().getContext();
 860     }
 861 
 862     /**
 863      * Try to infer Context instance from the Class. If we cannot,
 864      * then get it from the thread local variable.
 865      *
 866      * @param clazz the class
 867      * @return context
 868      */
 869     static Context fromClass(final Class<?> clazz) {
 870         final ClassLoader loader = clazz.getClassLoader();
 871 
 872         if (loader instanceof ScriptLoader) {
 873             return ((ScriptLoader)loader).getContext();
 874         }
 875 
 876         return Context.getContextTrusted();
 877     }
 878 
 879     private URL getResourceURL(final String resName) {
 880         // try the classPathLoader if we have and then
 881         // try the appLoader if non-null.
 882         if (classPathLoader != null) {
 883             return classPathLoader.getResource(resName);
 884         } else if (appLoader != null) {
 885             return appLoader.getResource(resName);
 886         }
 887 
 888         return null;
 889     }
 890 
 891     private Object evaluateSource(final Source source, final ScriptObject scope, final ScriptObject thiz) {
 892         ScriptFunction script = null;
 893 
 894         try {
 895             script = compileScript(source, scope, new Context.ThrowErrorManager());
 896         } catch (final ParserException e) {
 897             e.throwAsEcmaException();
 898         }
 899 
 900         return ScriptRuntime.apply(script, thiz);
 901     }
 902 
 903     private static ScriptFunction getRunScriptFunction(final Class<?> script, final ScriptObject scope) {
 904         if (script == null) {
 905             return null;
 906         }
 907 
 908         // Get run method - the entry point to the script
 909         final MethodHandle runMethodHandle =
 910                 MH.findStatic(
 911                     MethodHandles.lookup(),
 912                     script,
 913                     RUN_SCRIPT.symbolName(),
 914                     MH.type(
 915                         Object.class,
 916                         ScriptFunction.class,
 917                         Object.class));
 918 
 919         boolean strict;
 920 
 921         try {
 922             strict = script.getField(STRICT_MODE.symbolName()).getBoolean(null);
 923         } catch (final NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
 924             strict = false;
 925         }
 926 
 927         // Package as a JavaScript function and pass function back to shell.
 928         return ((GlobalObject)Context.getGlobalTrusted()).newScriptFunction(RUN_SCRIPT.symbolName(), runMethodHandle, scope, strict);
 929     }
 930 
 931     private ScriptFunction compileScript(final Source source, final ScriptObject scope, final ErrorManager errMan) {
 932         return getRunScriptFunction(compile(source, errMan, this._strict), scope);
 933     }
 934 
 935     private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
 936         // start with no errors, no warnings.
 937         errMan.reset();
 938 
 939         Class<?> script = findCachedClass(source);
 940         if (script != null) {
 941             Compiler.LOG.fine("Code cache hit for ", source, " avoiding recompile.");
 942             return script;
 943         }
 944 
 945         final FunctionNode functionNode = new Parser(env, source, errMan, strict).parse();
 946         if (errors.hasErrors()) {
 947             return null;
 948         }
 949 
 950         if (env._print_ast) {
 951             getErr().println(new ASTWriter(functionNode));
 952         }
 953 
 954         if (env._print_parse) {
 955             getErr().println(new PrintVisitor(functionNode));
 956         }
 957 
 958         if (env._parse_only) {
 959             return null;
 960         }
 961 
 962         final URL          url    = source.getURL();
 963         final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
 964         final CodeSource   cs     = new CodeSource(url, (CodeSigner[])null);
 965         final CodeInstaller<ScriptEnvironment> installer = new ContextCodeInstaller(this, loader, cs);
 966 
 967         final Compiler compiler = new Compiler(installer, strict);
 968 
 969         final FunctionNode newFunctionNode = compiler.compile(functionNode);
 970         script = compiler.install(newFunctionNode);
 971         cacheClass(source, script);
 972 
 973         return script;
 974     }
 975 
 976     private ScriptLoader createNewLoader() {
 977         return AccessController.doPrivileged(
 978              new PrivilegedAction<ScriptLoader>() {
 979                 @Override
 980                 public ScriptLoader run() {
 981                     return new ScriptLoader(appLoader, Context.this);
 982                 }
 983              }, CREATE_LOADER_ACC_CTXT);
 984     }
 985 
 986     private long getUniqueEvalId() {
 987         return uniqueEvalId.getAndIncrement();
 988     }
 989 
 990     private long getUniqueScriptId() {
 991         return uniqueScriptId.getAndIncrement();
 992     }
 993 
 994     /**
 995      * Cache for compiled script classes.
 996      */
 997     @SuppressWarnings("serial")
 998     private static class ClassCache extends LinkedHashMap<Source, ClassReference> {
 999         private final int size;
1000         private final ReferenceQueue<Class<?>> queue;
1001 
1002         ClassCache(int size) {
1003             super(size, 0.75f, true);
1004             this.size = size;
1005             this.queue = new ReferenceQueue<>();
1006         }
1007 
1008         void cache(final Source source, final Class<?> clazz) {
1009             put(source, new ClassReference(clazz, queue, source));
1010         }
1011 
1012         @Override
1013         protected boolean removeEldestEntry(final Map.Entry<Source, ClassReference> eldest) {
1014             return size() > size;
1015         }
1016 
1017         @Override
1018         public ClassReference get(Object key) {
1019             for (ClassReference ref; (ref = (ClassReference)queue.poll()) != null; ) {
1020                 remove(ref.source);
1021             }
1022             return super.get(key);
1023         }
1024 
1025     }
1026 
1027     private static class ClassReference extends SoftReference<Class<?>> {
1028         private final Source source;
1029 
1030         ClassReference(final Class<?> clazz, final ReferenceQueue<Class<?>> queue, final Source source) {
1031             super(clazz, queue);
1032             this.source = source;
1033         }
1034     }
1035 
1036     // Class cache management
1037     private Class<?> findCachedClass(final Source source) {
1038         ClassReference ref = classCache == null ? null : classCache.get(source);
1039         return ref != null ? ref.get() : null;
1040     }
1041 
1042     private void cacheClass(final Source source, final Class<?> clazz) {
1043         if (classCache != null) {
1044             classCache.cache(source, clazz);
1045         }
1046     }
1047 
1048 
1049 }
--- EOF ---