/* this code is workaround for subtle bug/feature in JDK1.3.1 and 1.4,
  related to loading applets behind proxy */
  protected PermissionCollection getPermissions(CodeSource codesource) {
    PermissionCollection sysPerms = null;
    Policy policy =
        (Policy)
            AccessController.doPrivileged(
                new PrivilegedAction() {
                  public Object run() {
                    return Policy.getPolicy();
                  }
                });
    if (policy != null) sysPerms = policy.getPermissions(new CodeSource(null, null));
    else sysPerms = new Permissions();

    final PermissionCollection perms = sysPerms;
    if (base != null && base.getHost() != null)
      perms.add(new SocketPermission(base.getHost() + ":1-", "accept,connect,resolve"));
    URL url = codesource.getLocation();

    if (url.getProtocol().equals("file")) {

      String path = url.getFile().replace('/', File.separatorChar);

      if (!path.endsWith(File.separator)) {
        int endIndex = path.lastIndexOf(File.separatorChar);
        if (endIndex != -1) {
          path = path.substring(0, endIndex + 1) + "-";
          perms.add(new FilePermission(path, "read"));
        }
      }
      perms.add(new SocketPermission("localhost", "connect,accept"));
      AccessController.doPrivileged(
          new PrivilegedAction() {
            public Object run() {
              try {
                String host = InetAddress.getLocalHost().getHostName();
                perms.add(new SocketPermission(host, "connect,accept"));
              } catch (UnknownHostException uhe) {
              }
              return null;
            }
          });

      if (base.getProtocol().equals("file")) {
        String bpath = base.getFile().replace('/', File.separatorChar);
        if (bpath.endsWith(File.separator)) {
          bpath += "-";
        }
        perms.add(new FilePermission(bpath, "read"));
      }
    }
    // for (Enumeration e=perms.elements();e.hasMoreElements();)
    // System.err.println("p="+e.nextElement());
    return perms;
  }
  protected PermissionCollection getPermissions(CodeSource codeSource) {
    PermissionCollection perms;
    try {
      try {
        perms = super.getPermissions(codeSource);
      } catch (SecurityException e) {
        // We lied about our CodeSource and that makes URLClassLoader unhappy.
        perms = new Permissions();
      }

      ProtectionDomain myDomain =
          AccessController.doPrivileged(
              new PrivilegedAction<ProtectionDomain>() {
                public ProtectionDomain run() {
                  return getClass().getProtectionDomain();
                }
              });
      PermissionCollection myPerms = myDomain.getPermissions();
      if (myPerms != null) {
        for (Enumeration<Permission> elements = myPerms.elements(); elements.hasMoreElements(); ) {
          perms.add(elements.nextElement());
        }
      }
    } catch (Throwable e) {
      // We lied about our CodeSource and that makes URLClassLoader unhappy.
      perms = new Permissions();
    }
    perms.setReadOnly();
    return perms;
  }
 /**
  * @deprecated Prefer using methods taking a Reader rather than an InputStream to avoid wrong
  *     encoding issues.
  */
 public Class parseClass(final InputStream in, final String fileName)
     throws CompilationFailedException {
   // For generic input streams, provide a catch-all codebase of GroovyScript
   // Security for these classes can be administered via policy grants with
   // a codebase of file:groovy.script
   GroovyCodeSource gcs =
       AccessController.doPrivileged(
           new PrivilegedAction<GroovyCodeSource>() {
             public GroovyCodeSource run() {
               try {
                 String scriptText =
                     config.getSourceEncoding() != null
                         ? IOGroovyMethods.getText(in, config.getSourceEncoding())
                         : IOGroovyMethods.getText(in);
                 return new GroovyCodeSource(scriptText, fileName, "/groovy/script");
               } catch (IOException e) {
                 throw new RuntimeException(
                     "Impossible to read the content of the input stream for file named: "
                         + fileName,
                     e);
               }
             }
           });
   return parseClass(gcs);
 }
 /**
  * creates a ClassCollector for a new compilation.
  *
  * @param unit the compilationUnit
  * @param su the SourceUnit
  * @return the ClassCollector
  */
 protected ClassCollector createCollector(CompilationUnit unit, SourceUnit su) {
   InnerLoader loader =
       AccessController.doPrivileged(
           new PrivilegedAction<InnerLoader>() {
             public InnerLoader run() {
               return new InnerLoader(GroovyClassLoader.this);
             }
           });
   return new ClassCollector(loader, unit, su);
 }
 /**
  * Parses the given text into a Java class capable of being run
  *
  * @param text the text of the script/class to parse
  * @param fileName the file name to use as the name of the class
  * @return the main class defined in the given script
  */
 public Class parseClass(final String text, final String fileName)
     throws CompilationFailedException {
   GroovyCodeSource gcs =
       AccessController.doPrivileged(
           new PrivilegedAction<GroovyCodeSource>() {
             public GroovyCodeSource run() {
               return new GroovyCodeSource(text, fileName, "/groovy/script");
             }
           });
   gcs.setCachable(false);
   return parseClass(gcs);
 }
 public static InputStream openStream(final URL url) throws IOException {
   try {
     return (InputStream)
         AccessController.doPrivileged(
             new PrivilegedExceptionAction() {
               public Object run() throws IOException {
                 return url.openStream();
               }
             });
   } catch (PrivilegedActionException e) {
     throw (IOException) e.getException();
   }
 }
 public static InputStream getResourceAsStream(final Class c, final String name)
     throws IOException {
   try {
     return (InputStream)
         AccessController.doPrivileged(
             new PrivilegedExceptionAction() {
               public Object run() throws IOException {
                 return c.getResourceAsStream(name);
               }
             });
   } catch (PrivilegedActionException e) {
     throw (IOException) e.getException();
   }
 }
 public static ClassLoader getContextClassLoader() {
   return (ClassLoader)
       AccessController.doPrivileged(
           new PrivilegedAction() {
             public Object run() {
               ClassLoader cl = null;
               try {
                 cl = Thread.currentThread().getContextClassLoader();
               } catch (SecurityException ex) {
               }
               return cl;
             }
           });
 }
 public URL loadGroovySource(final String filename) throws MalformedURLException {
   return AccessController.doPrivileged(
       new PrivilegedAction<URL>() {
         public URL run() {
           for (String extension : config.getScriptExtensions()) {
             try {
               URL ret = getSourceFile(filename, extension);
               if (ret != null) return ret;
             } catch (Throwable t) { //
             }
           }
           return null;
         }
       });
 }
 public static Field makeAccessible(Class<?> target, String fieldName) {
   try {
     final Field field = target.getDeclaredField(fieldName);
     return (Field)
         AccessController.doPrivileged(
             new PrivilegedExceptionAction<Object>() {
               public Object run() throws IllegalAccessException, InvocationTargetException {
                 if (!field.isAccessible()) field.setAccessible(true);
                 return field;
               }
             });
   } catch (NoSuchFieldException | PrivilegedActionException e) {
     System.out.print("");
   } // keep quiet IError.printStackTrace(e); }
   return null;
 }
 /** Invoke a method on an object using reflection. */
 public static Object invoke(final Object target, final Method method, final Object... args) {
   try {
     return AccessController.doPrivileged(
         new PrivilegedExceptionAction<Object>() {
           public Object run() throws IllegalAccessException, InvocationTargetException {
             if (!method.isAccessible())
               method.setAccessible(
                   true); // Say please - else invoke() will fail if method is protected
             return method.invoke(target, args);
           }
         });
   } catch (PrivilegedActionException e) {
     e.printStackTrace();
   }
   return null;
 }
 /**
  * adds a classpath to this classloader.
  *
  * @param path is a jar file or a directory.
  * @see #addURL(URL)
  */
 public void addClasspath(final String path) {
   AccessController.doPrivileged(
       new PrivilegedAction<Void>() {
         public Void run() {
           try {
             // As the java.net.URL Javadoc says, the recommended way to get a URL is via URI.
             // http://docs.oracle.com/javase/7/docs/api/java/net/URL.html
             // "Note, the URI class does perform escaping of its component fields in certain
             // circumstances.
             // The recommended way to manage the encoding and decoding of URLs is to use URI, and
             // to convert
             // between these two classes using toURI() and URI.toURL()."
             // A possibly better approach here is to construct a URI and then resolve it against
             // a URI for the current working directory.
             // But we use this string match for now so everyone can see it doesn't hurt file-only
             // classpaths.
             URI newURI;
             if (!URI_PATTERN.matcher(path).matches()) {
               newURI = new File(path).toURI();
             } else {
               newURI = new URI(path);
             }
             URL[] urls = getURLs();
             for (URL url : urls) {
               // Do not use URL.equals.  It uses the network to resolve names and compares ip
               // addresses!
               // That is a violation of RFC and just plain evil.
               // http://michaelscharf.blogspot.com/2006/11/javaneturlequals-and-hashcode-make.html
               // http://docs.oracle.com/javase/7/docs/api/java/net/URL.html#equals(java.lang.Object)
               // "Since hosts comparison requires name resolution, this operation is a blocking
               // operation.
               // Note: The defined behavior for equals is known to be inconsistent with virtual
               // hosting in HTTP."
               if (newURI.equals(url.toURI())) return null;
             }
             addURL(newURI.toURL());
           } catch (MalformedURLException e) {
             // TODO: fail through ?
           } catch (URISyntaxException e) {
             // Just doing the same thing...
           }
           return null;
         }
       });
 }
 /**
  * UIManager.setLookAndFeel calls this method before the first call (and typically the only call)
  * to getDefaults(). Subclasses should do any one-time setup they need here, rather than in a
  * static initializer, because look and feel class uiDefaults may be loaded just to discover that
  * isSupportedLookAndFeel() returns false.
  *
  * @see #uninitialize
  * @see UIManager#setLookAndFeel
  */
 @Override
 public void initialize() {
   // Note: We initialize in a privileged block, because if we are
   //       installed as a Standard Extension in the Java VM, we
   //       are allowed to access our resources (i.e. images),
   //       even then, when the calling application is not allowed
   //       to do so.
   AccessController.doPrivileged(
       new PrivilegedAction() {
         public Object run() {
           target.initialize();
           myDefaults = target.getDefaults();
           initResourceBundle(myDefaults);
           initClassDefaults(myDefaults);
           initGeneralDefaults(myDefaults);
           initComponentDefaults(myDefaults);
           return null;
         }
       });
 }
 public static URL[] getResources(final ClassLoader cl, final String name) {
   return (URL[])
       AccessController.doPrivileged(
           new PrivilegedAction() {
             public Object run() {
               URL[] ret = null;
               try {
                 List v = new ArrayList();
                 Enumeration e = cl.getResources(name);
                 while (e != null && e.hasMoreElements()) {
                   URL url = (URL) e.nextElement();
                   if (url != null) v.add(url);
                 }
                 if (v.size() > 0) {
                   ret = new URL[v.size()];
                   ret = (URL[]) v.toArray(ret);
                 }
               } catch (IOException ioex) {
               } catch (SecurityException ex) {
               }
               return ret;
             }
           });
 }
Beispiel #15
0
  /** Does install of JRE */
  public static void install() {

    // Hide the JNLP Clients installer window and show own
    Config.getInstallService().hideStatusWindow();
    showInstallerWindow();

    // Make sure the destination exists.
    String path = Config.getInstallService().getInstallPath();
    if (Config.isWindowsInstall()) {
      String defaultLocation = "C:\\Program Files\\Java\\j2re" + Config.getJavaVersion() + "\\";
      File defaultDir = new File(defaultLocation);
      if (!defaultDir.exists()) {
        defaultDir.mkdirs();
      }
      if (defaultDir.exists() && defaultDir.canWrite()) {
        path = defaultLocation; // use default if you can
      }
    }

    File installDir = new File(path);

    if (!installDir.exists()) {
      installDir.mkdirs();
      if (!installDir.exists()) {
        // The installFailed string is only for debugging. No localization needed
        installFailed("couldntCreateDirectory", null);
        return;
      }
    }

    // Show license if neccesary
    enableStep(STEP_LICENSE);
    if (!showLicensing()) {
      // The installFailed string is only for debugging. No localization needed
      installFailed("Licensing was not accepted", null);
    }
    ;

    // Make sure that the data JAR is downloaded
    enableStep(STEP_DOWNLOAD);
    if (!downloadInstallerComponent()) {
      // The installFailed string is only for debugging. No localization needed
      installFailed("Unable to download data component", null);
    }

    String nativeLibName = Config.getNativeLibName();
    File installerFile = null;

    try {
      // Load native library into process if found
      if (nativeLibName != null && !Config.isSolarisInstall()) {
        System.loadLibrary(nativeLibName);
      }

      // Unpack installer
      enableStep(STEP_UNPACK);
      String installResource = Config.getInstallerResource();
      Config.trace("Installer resource: " + installResource);
      installerFile = unpackInstaller(installResource);

      // To clean-up downloaded files
      Config.trace("Unpacked installer to: " + installerFile);
      if (installerFile == null) {
        // The installFailed string is only for debugging. No localization needed
        installFailed("Could not unpack installer components", null);
        return;
      }

      enableStep(STEP_INSTALL);
      setStepText(STEP_INSTALL, Config.getWindowStepWait(STEP_INSTALL));

      boolean success = false;
      if (Config.isSolarisInstall()) {
        success = runSolarisInstaller(path, installerFile);
      } else {
        success = runWindowsInstaller(path, installerFile);
      }

      if (!success) {
        // The installFailed string is only for debugging. No localization needed
        installFailed("Could not run installer", null);
        return;
      }
    } catch (UnsatisfiedLinkError ule) {
      // The installFailed string is only for debugging. No localization needed
      installFailed("Unable to load library: " + nativeLibName, null);
      return;
    } finally {
      if (installerFile != null) {
        installerFile.delete();
      }
    }

    setStepText(STEP_INSTALL, Config.getWindowStep(STEP_INSTALL));
    enableStep(STEP_DONE);

    String execPath = path + Config.getJavaPath();
    Config.trace(execPath);

    /** Remove installer JAR from cache */
    removeInstallerComponent();

    // If we're running anything after 1.0.1 or not on Windows, just call
    // finishedInstall.  Otherwise, deny ExitVM permission so that we can
    // return here and do a reboot.  We have to do this because we need to
    // call ExtensionInstallerService.finishedInstall(), which registers
    // that our extension (the JRE) is installed.  Unfortunately pre-1.2 it
    // also does not understand that we are requesting a reboot, and calls
    // System.exit().  So for pre 1.2 we want to deny the permission to
    // exit the VM so we can return here and perform a reboot.
    boolean ispre12 = false;
    String version = Config.getJavaWSVersion();
    // get first tuple
    String v = version.substring(version.indexOf('-') + 1);
    int i2 = v.indexOf('.');
    int v1 = Integer.parseInt(v.substring(0, i2));
    // get second tuple
    v = v.substring(i2 + 1);
    i2 = v.indexOf('.');
    if (i2 == -1) i2 = v.indexOf('-');
    if (i2 == -1) i2 = v.indexOf('[');
    if (i2 == -1) i2 = v.length();
    int v2 = Integer.parseInt(v.substring(0, i2));
    // are we pre 1.2?
    if (v1 < 1 || (v1 == 1 && v2 < 2)) ispre12 = true;

    if (Config.isWindowsInstall() && ispre12 && Config.isHopper()) {
      // deny ExitVM permission then call finishedInstall
      ProtectionDomain pd = (new Object()).getClass().getProtectionDomain();
      CodeSource cs = pd.getCodeSource();
      AllPermissionExceptExitVM perm = new AllPermissionExceptExitVM();
      PermissionCollection newpc = perm.newPermissionCollection();
      newpc.add(perm);

      // run finishedInstall within the new context which excluded
      // just the ExitVM permission
      ProtectionDomain newpd = new ProtectionDomain(cs, newpc);
      AccessControlContext newacc = new AccessControlContext(new ProtectionDomain[] {newpd});
      final String fExecPath = execPath;
      try {
        AccessController.doPrivileged(
            new PrivilegedExceptionAction() {
              public Object run() throws SecurityException {
                finishedInstall(fExecPath);
                return null;
              }
            },
            newacc);
      } catch (PrivilegedActionException pae) {
        // swallow the exception because we want ExitVM to fail silent
      } catch (SecurityException se) {
        // swallow the exception because we want ExitVM to fail silent
      }
    } else {
      // just call finished Install
      finishedInstall(execPath);
    }

    if (Config.isWindowsInstall() && WindowsInstaller.IsRebootNecessary()) {
      // reboot
      if (!WindowsInstaller.askUserForReboot()) System.exit(0);
    } else {
      System.exit(0);
    }
  }