private Class<?> makeClass(String className, JarFile file, JarEntry entry, URL jarLocation) {
   try {
     definePackage(className, file);
     byte[] jeBytes = getJarEntryBytes(file, entry);
     if (jeBytes == null) {
       System.out.println(
           "Could not get bytes for entry " + entry.getName() + " in jar" + file.getName());
       return null;
     } else {
       // System.out.println("Loading class " + className + " from " + entry.getName() + " in " +
       // file.getName());
       return defineClass(
           className,
           jeBytes,
           0,
           jeBytes.length,
           jarLocation != null ? getProtectionDomain(jarLocation) : pd);
     }
   } catch (Throwable t) {
     System.out.println(
         "Error reading class file "
             + entry.getName()
             + " in jar"
             + file.getName()
             + ": "
             + t.toString());
     return null;
   }
 }
Beispiel #2
0
  /** Check the certificates with the ones in the jar file (all must match). */
  private static final void validateCertificate(
      final Certificate[] rootCerts, final JarFile jar, final JarEntry entry, final byte[] buf)
      throws IOException, SecurityException {

    if (DEBUG) {
      System.err.println("JarUtil: validate JarEntry : " + entry.getName());
    }

    // API states that we must read all of the data from the entry's
    // InputStream in order to be able to get its certificates

    final InputStream is = jar.getInputStream(entry);
    try {
      while (is.read(buf) > 0) {}
    } finally {
      is.close();
    }

    // Get the certificates for the JAR entry
    final Certificate[] nativeCerts = entry.getCertificates();
    if (nativeCerts == null || nativeCerts.length == 0) {
      throw new SecurityException("no certificate for " + entry.getName() + " in " + jar.getName());
    }

    if (!SecurityUtil.equals(rootCerts, nativeCerts)) {
      throw new SecurityException(
          "certificates not equal for " + entry.getName() + " in " + jar.getName());
    }
  }
  /*
   * Check for all declared required extensions in the jar file
   * manifest.
   */
  protected boolean checkExtensions(JarFile jar) throws ExtensionInstallationException {
    Manifest man;
    try {
      man = jar.getManifest();
    } catch (IOException e) {
      return false;
    }

    if (man == null) {
      // The applet does not define a manifest file, so
      // we just assume all dependencies are satisfied.
      return true;
    }

    boolean result = true;
    Attributes attr = man.getMainAttributes();
    if (attr != null) {
      // Let's get the list of declared dependencies
      String value = attr.getValue(Name.EXTENSION_LIST);
      if (value != null) {
        StringTokenizer st = new StringTokenizer(value);
        // Iterate over all declared dependencies
        while (st.hasMoreTokens()) {
          String extensionName = st.nextToken();
          debug("The file " + jar.getName() + " appears to depend on " + extensionName);
          // Sanity Check
          String extName = extensionName + "-" + Name.EXTENSION_NAME.toString();
          if (attr.getValue(extName) == null) {
            debug(
                "The jar file "
                    + jar.getName()
                    + " appers to depend on "
                    + extensionName
                    + " but does not define the "
                    + extName
                    + " attribute in its manifest ");

          } else {
            if (!checkExtension(extensionName, attr)) {
              debug("Failed installing " + extensionName);
              result = false;
            }
          }
        }
      } else {
        debug("No dependencies for " + jar.getName());
      }
    }
    return result;
  }
  public void addJarFile(JarFile jf, URL jarLocation) {
    jarFileList.add(jf);
    jarLocationByJarName.put(jf.getName(), jarLocation);

    String jfName = jf.getName();
    Enumeration<JarEntry> jeEnum = jf.entries();
    while (jeEnum.hasMoreElements()) {
      JarEntry je = jeEnum.nextElement();
      if (je.isDirectory()) continue;
      String jeName = je.getName();
      if (!jeName.endsWith(".class")) continue;
      String className = jeName.substring(0, jeName.length() - 6).replace('/', '.');

      if (classCache.containsKey(className)) {
        System.out.println("Ignoring duplicate class " + className + " in jar " + jfName);
        continue;
      }
      if (trackKnown) knownClassJarEntries.put(className, new JarEntryInfo(je, jf, jarLocation));

      /* NOTE: can't do this as classes are defined out of order, end up with NoClassDefFoundError for dependencies:
      Class<?> cls = makeClass(className, jf, je);
      if (cls != null) classCache.put(className, cls);
      */

      if (checkJars) {
        try {
          getParent().loadClass(className);
          System.out.println(
              "Class "
                  + className
                  + " in jar "
                  + jfName
                  + " already loaded from parent ClassLoader");
        } catch (ClassNotFoundException e) {
          /* hoping class is not found! */
        }
        if (jarByClass.containsKey(className)) {
          System.out.println(
              "Found class "
                  + className
                  + " in \njar "
                  + jfName
                  + ", already loaded from \njar "
                  + jarByClass.get(className));
        } else {
          jarByClass.put(className, jfName);
        }
      }
    }
  }
Beispiel #5
0
  @Override
  protected synchronized Class<?> loadClass(String className, boolean resolve)
      throws ClassNotFoundException {
    Class<?> c = null;
    try {
      try {
        ClassLoader cl = getParent();
        c = cl.loadClass(className);
        if (c != null) return c;
      } catch (ClassNotFoundException e) {
        /* let the next one handle this */
      }

      try {
        c = findJarClass(className);
        if (c != null) return c;
      } catch (Exception e) {
        System.out.println(
            "Error loading class ["
                + className
                + "] from jars in war file ["
                + outerFile.getName()
                + "]: "
                + e.toString());
        e.printStackTrace();
      }

      throw new ClassNotFoundException("Class [" + className + "] not found");
    } finally {
      if (c != null && resolve) {
        resolveClass(c);
      }
    }
  }
Beispiel #6
0
 /**
  * @param jarFileUri jar:file:/some/path/gluegen-rt.jar!/
  * @return JarFile as named by Uri within the given ClassLoader
  * @throws IllegalArgumentException null arguments
  * @throws IOException if the Jar file could not been found
  * @throws URISyntaxException
  */
 public static JarFile getJarFile(final Uri jarFileUri)
     throws IOException, IllegalArgumentException, URISyntaxException {
   if (null == jarFileUri) {
     throw new IllegalArgumentException("null jarFileUri");
   }
   if (DEBUG) {
     System.err.println("getJarFile.0: " + jarFileUri.toString());
   }
   final URL jarFileURL = jarFileUri.toURL();
   if (DEBUG) {
     System.err.println("getJarFile.1: " + jarFileURL.toString());
   }
   final URLConnection urlc = jarFileURL.openConnection();
   if (urlc instanceof JarURLConnection) {
     final JarURLConnection jarConnection = (JarURLConnection) jarFileURL.openConnection();
     final JarFile jarFile = jarConnection.getJarFile();
     if (DEBUG) {
       System.err.println("getJarFile res: " + jarFile.getName());
     }
     return jarFile;
   }
   if (DEBUG) {
     System.err.println("getJarFile res: NULL");
   }
   return null;
 }
Beispiel #7
0
  public File findContainingJar(URL resourceURL)
      throws IllegalArgumentException, URISyntaxException, MalformedURLException,
          IllegalAccessException, InvocationTargetException {
    File result = null;
    if (resourceURL != null) {
      /*
       *The URL will be similar to http://host:port/...path-in-server-namespace!resource-spec
       *Extract the part preceding the ! and ask the Java Web Start loader to
       *find the locally-cached JAR file corresponding to that part of the URL.
       */
      URI resourceURI = resourceURL.toURI();
      String ssp = resourceURI.getSchemeSpecificPart();
      String jarOnlySSP = ssp.substring(0, ssp.indexOf('!'));

      URL jarOnlyURL = new URL(jarOnlySSP).toURI().toURL();

      /*
       *Use introspection to invoke the method.  This avoids complications
       *in building the app server under Java 1.5 in which the JNLPClassLoader
       *does not provide the getJarFile method.
       */
      JarFile jarFile = (JarFile) getJarFileMethod.invoke(getJNLPClassLoader(), jarOnlyURL);
      if (jarFile == null) {
        throw new IllegalArgumentException(resourceURL.toExternalForm());
      }
      result = new File(jarFile.getName());
    }
    return result;
  }
  public String getName() {
    String entryName = null;

    if (entry != null) {
      entryName = entry.getName();

      if (entryName.endsWith("/")) {
        entryName = entryName.substring(0, entryName.length() - 1);
      }
    }

    // for equality we don't consider the path or version of a JAR file,
    // only its name,
    // since it is likely to be found in multiple places such as the maven
    // repository and
    // web-inf/lib. Also, it shouldn't be reimported just because there is a
    // new version if the content itself has not changed.

    File iofile = new File(file.getName());
    String jarWithoutVersion;

    try {
      jarWithoutVersion = new VersionedJar(iofile).getJarWithoutVersion();
    } catch (NotAJarException e) {
      jarWithoutVersion = iofile.getName();
    }

    return jarWithoutVersion + "!" + (entryName != null ? entryName : "n/a");
  }
Beispiel #9
0
 /** @see java.lang.ClassLoader#findResources(java.lang.String) */
 @Override
 public Enumeration<URL> findResources(String resourceName) throws IOException {
   String webInfResourceName = "WEB-INF/classes/" + resourceName;
   List<URL> urlList = new ArrayList<URL>();
   int jarFileListSize = jarFileList.size();
   for (int i = 0; i < jarFileListSize; i++) {
     JarFile jarFile = jarFileList.get(i);
     JarEntry jarEntry = jarFile.getJarEntry(resourceName);
     // to better support war format, look for the resourceName in the WEB-INF/classes directory
     if (loadWebInf && jarEntry == null) jarEntry = jarFile.getJarEntry(webInfResourceName);
     if (jarEntry != null) {
       try {
         String jarFileName = jarFile.getName();
         if (jarFileName.contains("\\")) jarFileName = jarFileName.replace('\\', '/');
         urlList.add(new URL("jar:file:" + jarFileName + "!/" + jarEntry));
       } catch (MalformedURLException e) {
         System.out.println(
             "Error making URL for ["
                 + resourceName
                 + "] in jar ["
                 + jarFile
                 + "] in war file ["
                 + outerFile
                 + "]: "
                 + e.toString());
       }
     }
   }
   // add all resources found in parent loader too
   Enumeration<URL> superResources = super.findResources(resourceName);
   while (superResources.hasMoreElements()) urlList.add(superResources.nextElement());
   return Collections.enumeration(urlList);
 }
Beispiel #10
0
 private Certificate[] loadCertificates(JarFile jarFile, JarEntry je, byte[] readBuffer) {
   try {
     // We must read the stream for the JarEntry to retrieve
     // its certificates.
     InputStream is = new BufferedInputStream(jarFile.getInputStream(je));
     while (is.read(readBuffer, 0, readBuffer.length) != -1) {
       // not using
     }
     is.close();
     return je != null ? je.getCertificates() : null;
   } catch (IOException e) {
     Log.w(TAG, "Exception reading " + je.getName() + " in " + jarFile.getName(), e);
   } catch (RuntimeException e) {
     Log.w(TAG, "Exception reading " + je.getName() + " in " + jarFile.getName(), e);
   }
   return null;
 }
  private Class<?> injectToBootstrapClassLoader(String className)
      throws IllegalArgumentException, IllegalAccessException, InvocationTargetException,
          ClassNotFoundException {
    if (injectedToRoot.compareAndSet(false, true)) {
      instrumentation.appendToBootstrapClassLoaderSearch(pluginJar);
      classPool.appendToBootstrapClassPath(pluginJar.getName());
    }

    return Class.forName(className, false, null);
  }
  private Class<?> injectToPlainClassLoader(ClassLoader classLoader, String className)
      throws NotFoundException, IllegalArgumentException, IOException, CannotCompileException,
          IllegalAccessException, InvocationTargetException {
    ClassPool pool = new ClassPool();

    pool.appendClassPath(new LoaderClassPath(classLoader));
    pool.appendClassPath(pluginJar.getName());

    return injectToPlainClassLoader(pool, classLoader, className);
  }
Beispiel #13
0
    private void index() throws IOException {
      Enumeration entries = _jar.entries();

      _nameToEntryMap = new HashMap();
      _crcToEntryMap = new HashMap();

      _entries = new ArrayList();
      if (_debug) {
        System.out.println("indexing: " + _jar.getName());
      }
      if (entries != null) {
        while (entries.hasMoreElements()) {
          JarEntry entry = (JarEntry) entries.nextElement();

          long crc = entry.getCrc();

          Long crcL = new Long(crc);

          if (_debug) {
            System.out.println("\t" + entry.getName() + " CRC " + crc);
          }

          _nameToEntryMap.put(entry.getName(), entry);
          _entries.add(entry);

          // generate the CRC to entries map
          if (_crcToEntryMap.containsKey(crcL)) {
            // key exist, add the entry to the correcponding
            // linked list

            // get the linked list
            LinkedList ll = (LinkedList) _crcToEntryMap.get(crcL);

            // put in the new entry
            ll.add(entry);

            // put it back in the hash map
            _crcToEntryMap.put(crcL, ll);
          } else {
            // create a new entry in the hashmap for the new key

            // first create the linked list and put in the new
            // entry
            LinkedList ll = new LinkedList();
            ll.add(entry);

            // create the new entry in the hashmap
            _crcToEntryMap.put(crcL, ll);
          }
        }
      }
    }
 public static void addJar(JarFile jar) throws IOException {
   Manifest manifest = jar.getManifest();
   String atList = manifest.getMainAttributes().getValue("FMLAT");
   if (atList == null) return;
   for (String at : atList.split(" ")) {
     JarEntry jarEntry = jar.getJarEntry("META-INF/" + at);
     if (jarEntry != null) {
       embedded.put(
           String.format("%s!META-INF/%s", jar.getName(), at),
           new JarByteSource(jar, jarEntry).asCharSource(Charsets.UTF_8).read());
     }
   }
 }
Beispiel #15
0
  /** @see java.lang.ClassLoader#findResource(java.lang.String) */
  @Override
  protected URL findResource(String resourceName) {
    if (resourceCache.containsKey(resourceName)) return resourceCache.get(resourceName);

    // try the runtime/classes directory for conf files and such
    String runtimePath = System.getProperty("moqui.runtime");
    String fullPath = runtimePath + "/classes/" + resourceName;
    File resourceFile = new File(fullPath);
    if (resourceFile.exists())
      try {
        return resourceFile.toURI().toURL();
      } catch (MalformedURLException e) {
        System.out.println(
            "Error making URL for ["
                + resourceName
                + "] in runtime classes directory ["
                + runtimePath
                + "/classes/"
                + "]: "
                + e.toString());
      }

    String webInfResourceName = "WEB-INF/classes/" + resourceName;
    int jarFileListSize = jarFileList.size();
    for (int i = 0; i < jarFileListSize; i++) {
      JarFile jarFile = jarFileList.get(i);
      JarEntry jarEntry = jarFile.getJarEntry(resourceName);
      // to better support war format, look for the resourceName in the WEB-INF/classes directory
      if (loadWebInf && jarEntry == null) jarEntry = jarFile.getJarEntry(webInfResourceName);
      if (jarEntry != null) {
        try {
          String jarFileName = jarFile.getName();
          if (jarFileName.contains("\\")) jarFileName = jarFileName.replace('\\', '/');
          URL resourceUrl = new URL("jar:file:" + jarFileName + "!/" + jarEntry);
          resourceCache.put(resourceName, resourceUrl);
          return resourceUrl;
        } catch (MalformedURLException e) {
          System.out.println(
              "Error making URL for ["
                  + resourceName
                  + "] in jar ["
                  + jarFile
                  + "] in war file ["
                  + outerFile
                  + "]: "
                  + e.toString());
        }
      }
    }
    return super.findResource(resourceName);
  }
  @Override
  public String toString() {
    String name = null;

    if (entry != null) {
      name = entry.getName();

      if (name.endsWith("/")) {
        name = name.substring(0, name.length() - 1);
      }
    }

    return file.getName() + "!" + (name != null ? name : "n/a");
  }
Beispiel #17
0
  /** @see java.lang.ClassLoader#findResources(java.lang.String) */
  @Override
  public Enumeration<URL> findResources(String resourceName) throws IOException {
    ArrayList<URL> cachedUrls = resourceAllCache.get(resourceName);
    if (cachedUrls != null) return Collections.enumeration(cachedUrls);

    ArrayList<URL> urlList = new ArrayList<>();
    int classesDirectoryListSize = classesDirectoryList.size();
    for (int i = 0; i < classesDirectoryListSize; i++) {
      File classesDir = classesDirectoryList.get(i);
      File testFile = new File(classesDir.getAbsolutePath() + "/" + resourceName);
      try {
        if (testFile.exists() && testFile.isFile()) urlList.add(testFile.toURI().toURL());
      } catch (MalformedURLException e) {
        System.out.println(
            "Error making URL for ["
                + resourceName
                + "] in classes directory ["
                + classesDir
                + "]: "
                + e.toString());
      }
    }
    int jarFileListSize = jarFileList.size();
    for (int i = 0; i < jarFileListSize; i++) {
      JarFile jarFile = jarFileList.get(i);
      JarEntry jarEntry = jarFile.getJarEntry(resourceName);
      if (jarEntry != null) {
        try {
          String jarFileName = jarFile.getName();
          if (jarFileName.contains("\\")) jarFileName = jarFileName.replace('\\', '/');
          urlList.add(new URL("jar:file:" + jarFileName + "!/" + jarEntry));
        } catch (MalformedURLException e) {
          System.out.println(
              "Error making URL for ["
                  + resourceName
                  + "] in jar ["
                  + jarFile
                  + "]: "
                  + e.toString());
        }
      }
    }
    // add all resources found in parent loader too
    Enumeration<URL> superResources = getParent().getResources(resourceName);
    while (superResources.hasMoreElements()) urlList.add(superResources.nextElement());
    resourceAllCache.putIfAbsent(resourceName, urlList);
    // System.out.println("finding all resources with name " + resourceName + " got " + urlList);
    return Collections.enumeration(urlList);
  }
  private JarFile[] getClassPathJars() throws IOException {
    Vector<JarFile> jars = new Vector<JarFile>();

    String classPath = System.getProperty("java.class.path");
    String pathSeparator = System.getProperty("path.separator");

    StringTokenizer strTok = new StringTokenizer(classPath, pathSeparator);

    while (strTok.hasMoreTokens()) {
      String classPathEntry = strTok.nextToken();

      File file = new File(classPathEntry);

      if (isJarFile(file)) {
        jars.add(new JarFile(file));
      }
    }

    /*
     * If only one JAR was found assume that application was started using
     * "jar" option - look in JAR manifest's Class-Path entry for the rest
     * of the JARs
     */
    if (jars.size() == 1) {
      JarFile jarFile = jars.get(0);
      Manifest manifest = jarFile.getManifest();

      if (manifest != null) {
        Attributes attributes = manifest.getMainAttributes();
        String jarClassPath = attributes.getValue("Class-Path");

        if (jarClassPath != null) {
          strTok = new StringTokenizer(jarClassPath, " ");

          while (strTok.hasMoreTokens()) {
            String jarClassPathEntry = strTok.nextToken();

            File file = new File(new File(jarFile.getName()).getParent(), jarClassPathEntry);

            if (isJarFile(file)) {
              jars.add(new JarFile(file));
            }
          }
        }
      }
    }

    return jars.toArray(new JarFile[jars.size()]);
  }
  public URLConnection openConnection(URL url) throws IOException {
    if (expectedUrl == null) {
      throw new IllegalStateException("expectedUrl was not set");
    }

    // the caller copied the URL reusing a stream handler from a previous call
    if (!expectedUrl.equals(url)) {
      // the new url is supposed to be within our context, so it must have a jar protocol
      if (!url.getProtocol().equals("jar")) {
        throw new IllegalArgumentException("Unsupported protocol " + url.getProtocol());
      }

      // split the path at "!/" into the file part and entry part
      String path = url.getPath();
      String[] chunks = path.split("!/", 2);

      // if we only got only one chunk, it didn't contain the required "!/" delimiter
      if (chunks.length == 1) {
        throw new MalformedURLException("Url does not contain a '!' character: " + url);
      }

      String file = chunks[0];
      String entryPath = chunks[1];

      // this handler only supports jars on the local file system
      if (!file.startsWith("file:")) {
        // let the system handler deal with this
        return new URL(url.toExternalForm()).openConnection();
      }
      file = file.substring("file:".length());

      // again the new url is supposed to be within our context so it must reference the same jar
      // file
      if (!jarFile.getName().equals(file)) {
        // let the system handler deal with this
        return new URL(url.toExternalForm()).openConnection();
      }

      // get the entry
      JarEntry newEntry = jarFile.getJarEntry(entryPath);
      if (newEntry == null) {
        throw new FileNotFoundException("Entry not found: " + url);
      }
      return new JarFileUrlConnection(url, jarFile, newEntry);
    }

    return new JarFileUrlConnection(url, jarFile, jarEntry);
  }
Beispiel #20
0
  /* ------------------------------------------------------------ */
  @Override
  protected synchronized void newConnection() throws IOException {
    super.newConnection();

    _entry = null;
    _file = null;
    _jarFile = null;
    _list = null;

    int sep = _urlString.indexOf("!/");
    _jarUrl = _urlString.substring(0, sep + 2);
    _path = _urlString.substring(sep + 2);
    if (_path.length() == 0) _path = null;
    _jarFile = _jarConnection.getJarFile();
    _file = new File(_jarFile.getName());
  }
Beispiel #21
0
  private Class<?> findJarClass(String className)
      throws IOException, ClassFormatError, ClassNotFoundException {
    Class cachedClass = classCache.get(className);
    if (cachedClass != null) return cachedClass;
    if (rememberClassNotFound) {
      ClassNotFoundException cachedExc = notFoundCache.get(className);
      if (cachedExc != null) throw cachedExc;
    }

    Class<?> c = null;
    String classFileName = className.replace('.', '/').concat(".class");

    int classesDirectoryListSize = classesDirectoryList.size();
    for (int i = 0; i < classesDirectoryListSize; i++) {
      File classesDir = classesDirectoryList.get(i);
      File testFile = new File(classesDir.getAbsolutePath() + "/" + classFileName);
      if (testFile.exists() && testFile.isFile()) {
        c = makeClass(className, testFile);
        if (c != null) break;
      }
    }

    if (c == null) {
      int jarFileListSize = jarFileList.size();
      for (int i = 0; i < jarFileListSize; i++) {
        JarFile jarFile = jarFileList.get(i);
        // System.out.println("Finding class file " + classFileName + " in jar file " +
        // jarFile.getName());
        JarEntry jarEntry = jarFile.getJarEntry(classFileName);
        if (jarEntry != null) {
          c = makeClass(className, jarFile, jarEntry, jarLocationByJarName.get(jarFile.getName()));
          break;
        }
      }
    }

    // down here only cache if found
    if (c != null) {
      Class existingClass = classCache.putIfAbsent(className, c);
      if (existingClass != null) return existingClass;
      else return c;
    } else {
      return null;
    }
  }
 private static Map<String, InputStream> findResourceInFile(
     File resourceFile, String fileNamePattern) throws IOException {
   Map<String, InputStream> result = new TreeMap<String, InputStream>();
   if (resourceFile.canRead() && resourceFile.getAbsolutePath().endsWith(".jar")) {
     log.debug("jar file found: " + resourceFile.getAbsolutePath());
     JarFile jarFile = new JarFile(resourceFile);
     Enumeration<JarEntry> entries = jarFile.entries();
     while (entries.hasMoreElements()) {
       JarEntry singleEntry = entries.nextElement();
       log.debug("jar entry: " + singleEntry.getName());
       if (singleEntry.getName().matches(fileNamePattern)) {
         result.put(
             jarFile.getName() + "/" + singleEntry.getName(), jarFile.getInputStream(singleEntry));
       }
     }
   }
   return result;
 }
  private LameIndex index(JarFile jar) throws IOException, MojoExecutionException {
    String fileName = jar.getName();
    int dotIndex = fileName.lastIndexOf('.');
    if (dotIndex == -1) {
      throw new MojoExecutionException("cold not determine type of artifact: " + jar);
    }
    String extension = fileName.substring(dotIndex + 1);
    boolean changed = false;
    Index index = null;
    if (containsClasses(extension)) {
      if (!containsIndex(jar)) {
        index = buildIndex(jar);
        changed = true;
      }
    }

    List<LameSubDeploymentIndex> resultIndices;
    if (containsSubDeplyoments(extension)) {
      List<SubDeploymentIndex> subDeploymentIndexs = indexSubdeplyoments(extension, jar);
      if (!subDeploymentIndexs.isEmpty()) {
        resultIndices = new ArrayList<>(subDeploymentIndexs.size());
        changed = true;
        for (SubDeploymentIndex each : subDeploymentIndexs) {
          Index subDeploymentIndex = each.index;
          String subDeploymentName = each.subDeployment.getName();
          File subDepolyentFile;
          int subDeploymentDotIndex = subDeploymentName.lastIndexOf('.');
          String subDeploymentExtension = subDeploymentName.substring(subDeploymentDotIndex + 1);
          if (containsSubDeplyoments(subDeploymentExtension)) {
            subDepolyentFile = each.file;
          } else {
            subDepolyentFile = null;
          }
          resultIndices.add(
              new LameSubDeploymentIndex(subDeploymentName, subDeploymentIndex, subDepolyentFile));
        }
      } else {
        resultIndices = Collections.emptyList();
      }
    } else {
      resultIndices = Collections.emptyList();
    }
    return new LameIndex(index, changed, resultIndices);
  }
  private void scan() throws InvalidPluginException {
    Enumeration<JarEntry> e = jarFile.entries();
    while (e.hasMoreElements()) {
      JarEntry entry = e.nextElement();
      if (skip(entry)) {
        continue;
      }

      ClassData def = new ClassData();
      try {
        new ClassReader(read(entry)).accept(def, SKIP_ALL);
      } catch (IOException err) {
        throw new InvalidPluginException("Cannot auto-register", err);
      } catch (RuntimeException err) {
        PluginLoader.log.warn(
            String.format(
                "Plugin %s has invaild class file %s inside of %s",
                pluginName, entry.getName(), jarFile.getName()),
            err);
        continue;
      }

      if (def.exportedAsName != null) {
        if (def.isConcrete()) {
          export(def);
        } else {
          PluginLoader.log.warn(
              String.format(
                  "Plugin %s tries to @Export(\"%s\") abstract class %s",
                  pluginName, def.exportedAsName, def.className));
        }
      } else if (def.listen) {
        if (def.isConcrete()) {
          listen(def);
        } else {
          PluginLoader.log.warn(
              String.format(
                  "Plugin %s tries to @Listen abstract class %s", pluginName, def.className));
        }
      }
    }
  }
Beispiel #25
0
  /**
   * Validate the certificates for each native Lib in the jar file. Throws an IOException if any
   * certificate is not valid.
   *
   * <pre>
   * Certificate[] rootCerts = Something.class.getProtectionDomain().
   * getCodeSource().getCertificates();
   * </pre>
   */
  public static final void validateCertificates(
      final Certificate[] rootCerts, final JarFile jarFile) throws IOException, SecurityException {

    if (DEBUG) {
      System.err.println("JarUtil: validateCertificates: " + jarFile.getName());
    }

    if (rootCerts == null || rootCerts.length == 0) {
      throw new IllegalArgumentException("Null certificates passed");
    }

    final byte[] buf = new byte[1024];
    final Enumeration<JarEntry> entries = jarFile.entries();
    while (entries.hasMoreElements()) {
      final JarEntry entry = entries.nextElement();
      if (!entry.isDirectory() && !entry.getName().startsWith("META-INF/")) {
        // only validate non META-INF and non directories
        validateCertificate(rootCerts, jarFile, entry, buf);
      }
    }
  }
Beispiel #26
0
  protected Class<?> findJarClass(String className) throws IOException, ClassFormatError {
    if (classCache.containsKey(className)) return classCache.get(className);

    Class<?> c = null;
    String classFileName = className.replace('.', '/') + ".class";
    String webInfFileName = "WEB-INF/classes/" + classFileName;
    int jarFileListSize = jarFileList.size();
    for (int i = 0; i < jarFileListSize; i++) {
      JarFile jarFile = jarFileList.get(i);
      // System.out.println("Finding Class [" + className + "] in jarFile [" + jarFile.getName() +
      // "]");

      JarEntry jarEntry = jarFile.getJarEntry(classFileName);
      // to better support war format, look for the resourceName in the WEB-INF/classes directory
      if (loadWebInf && jarEntry == null) jarEntry = jarFile.getJarEntry(webInfFileName);
      if (jarEntry != null) {
        definePackage(className, jarFile);
        byte[] jeBytes = getJarEntryBytes(jarFile, jarEntry);
        if (jeBytes == null) {
          System.out.println(
              "Could not get bytes for ["
                  + jarEntry.getName()
                  + "] in ["
                  + jarFile.getName()
                  + "]");
          continue;
        }
        // System.out.println("Class [" + classFileName + "] FOUND in jarFile [" + jarFile.getName()
        // + "], size is " + (jeBytes == null ? "null" : jeBytes.length));
        c = defineClass(className, jeBytes, 0, jeBytes.length, pd);
        break;
      }
    }
    classCache.put(className, c);
    return c;
  }
Beispiel #27
0
  public static void main(String[] args) throws IOException {
    // now grab the first arg and see if it is a known command
    String firstArg = args.length > 0 ? args[0] : "";

    if (firstArg.contains("-help") || "-?".equals(firstArg)) {
      // setup the class loader
      MoquiStart moquiStartLoader = new MoquiStart(true);
      Thread.currentThread().setContextClassLoader(moquiStartLoader);
      Runtime.getRuntime()
          .addShutdownHook(new MoquiShutdown(null, null, moquiStartLoader.jarFileList));
      initSystemProperties(moquiStartLoader, false);

      System.out.println("Internal Class Path Jars:");
      for (JarFile jf : moquiStartLoader.jarFileList) {
        String fn = jf.getName();
        System.out.println(fn.contains("moqui_temp") ? fn.substring(fn.indexOf("moqui_temp")) : fn);
      }
      System.out.println("------------------------------------------------");
      System.out.println(
          "Current runtime directory (moqui.runtime): " + System.getProperty("moqui.runtime"));
      System.out.println(
          "Current configuration file (moqui.conf): " + System.getProperty("moqui.conf"));
      System.out.println(
          "To set these properties use something like: java -Dmoqui.conf=conf/MoquiStagingConf.xml -jar moqui.war ...");
      System.out.println("------------------------------------------------");
      System.out.println("Usage: java -jar moqui.war [command] [arguments]");
      System.out.println("-help, -? ---- Help (this text)");
      System.out.println("-load -------- Run data loader");
      System.out.println(
          "    -types=<type>[,<type>] ------- Data types to load (can be anything, common are: seed, seed-initial, demo, ...)");
      System.out.println(
          "    -components=<name>[,<name>] -- Component names to load for data types; if none specified loads from all");
      System.out.println("    -location=<location> ---- Location of data file to load");
      System.out.println(
          "    -timeout=<seconds> ------ Transaction timeout for each file, defaults to 600 seconds (10 minutes)");
      System.out.println(
          "    -dummy-fks -------------- Use dummy foreign-keys to avoid referential integrity errors");
      System.out.println(
          "    -use-try-insert --------- Try insert and update on error instead of checking for record first");
      System.out.println("    -tenantId=<tenantId> ---- ID for the Tenant to load the data into");
      System.out.println(
          "  If no -types or -location argument is used all known data files of all types will be loaded.");
      System.out.println("[default] ---- Run embedded Winstone server.");
      System.out.println(
          "  See https://code.google.com/p/winstone/wiki/CmdLineOption for all argument details.");
      System.out.println("  Selected argument details:");
      System.out.println(
          "    --httpPort               = set the http listening port. -1 to disable, Default is 8080");
      System.out.println(
          "    --httpListenAddress      = set the http listening address. Default is all interfaces");
      System.out.println(
          "    --httpsPort              = set the https listening port. -1 to disable, Default is disabled");
      System.out.println(
          "    --ajp13Port              = set the ajp13 listening port. -1 to disable, Default is 8009");
      System.out.println(
          "    --controlPort            = set the shutdown/control port. -1 to disable, Default disabled");
      System.out.println("");
      System.exit(0);
    }

    // make a list of arguments, remove the first one (the command)
    List<String> argList = new ArrayList<String>(Arrays.asList(args));

    // now run the command
    if ("-load".equals(firstArg)) {
      MoquiStart moquiStartLoader = new MoquiStart(true);
      Thread.currentThread().setContextClassLoader(moquiStartLoader);
      Runtime.getRuntime()
          .addShutdownHook(new MoquiShutdown(null, null, moquiStartLoader.jarFileList));
      initSystemProperties(moquiStartLoader, false);

      Map<String, String> argMap = new HashMap<String, String>();
      for (String arg : argList) {
        if (arg.startsWith("-")) arg = arg.substring(1);
        if (arg.contains("=")) {
          argMap.put(arg.substring(0, arg.indexOf("=")), arg.substring(arg.indexOf("=") + 1));
        } else {
          argMap.put(arg, "");
        }
      }

      try {
        System.out.println("Loading data with args [" + argMap + "]");
        Class<?> c = moquiStartLoader.loadClass("org.moqui.Moqui");
        Method m = c.getMethod("loadData", new Class[] {Map.class});
        m.invoke(null, argMap);
      } catch (Exception e) {
        System.out.println(
            "Error loading or running Moqui.loadData with args [" + argMap + "]: " + e.toString());
        e.printStackTrace();
      }
      System.exit(0);
    }

    // ===== Done trying specific commands, so load the embedded server

    // Get a start loader with loadWebInf=false since the container will load those we don't want to
    // here (would be on classpath twice)
    MoquiStart moquiStartLoader = new MoquiStart(false);
    Thread.currentThread().setContextClassLoader(moquiStartLoader);
    // NOTE: the MoquiShutdown hook is not set here because we want to get the winstone Launcher
    // object first, so done below...
    initSystemProperties(moquiStartLoader, true);

    Map<String, String> argMap = new HashMap<String, String>();
    for (String arg : argList) {
      if (arg.startsWith("--")) arg = arg.substring(2);
      if (arg.contains("=")) {
        argMap.put(arg.substring(0, arg.indexOf("=")), arg.substring(arg.indexOf("=") + 1));
      } else {
        argMap.put(arg, "");
      }
    }

    try {
      argMap.put("warfile", moquiStartLoader.outerFile.getName());
      System.out.println("Running Winstone embedded server with args [" + argMap + "]");

      /* for old Winstone 0.9.10:
      Class<?> c = moquiStartLoader.loadClass("winstone.Launcher");
      Method initLogger = c.getMethod("initLogger", new Class[] { Map.class });
      Method shutdown = c.getMethod("shutdown");
      // init the Winstone logger
      initLogger.invoke(null, argMap);
      // start Winstone with a new instance of the server
      Constructor wlc = c.getConstructor(new Class[] { Map.class });
      Object winstone = wlc.newInstance(argMap);
      */

      Class<?> c = moquiStartLoader.loadClass("net.winstone.Server");
      Method start = c.getMethod("start");
      // Method shutdown = c.getMethod("shutdown");
      // start Winstone with a new instance of the server
      Constructor wlc = c.getConstructor(new Class[] {Map.class});
      Object winstone = wlc.newInstance(argMap);
      start.invoke(winstone);

      // NOTE: winstone seems to have its own shutdown hook in the newer version, so using hook to
      // close files only:
      Thread shutdownHook = new MoquiShutdown(null, null, moquiStartLoader.jarFileList);
      shutdownHook.setDaemon(true);
      Runtime.getRuntime().addShutdownHook(shutdownHook);
    } catch (Exception e) {
      System.out.println(
          "Error loading or running Winstone embedded server with args ["
              + argMap
              + "]: "
              + e.toString());
      e.printStackTrace();
    }

    // now wait for break...
  }
Beispiel #28
0
  /**
   * Constructor.
   *
   * @param parent class loader parent.
   */
  public JarClassLoader(ClassLoader parent) {
    super(parent);
    initLogger();

    hmClass = new HashMap<String, Class<?>>();
    lstJarFile = new ArrayList<JarFileInfo>();
    hsDeleteOnExit = new HashSet<File>();

    // Prepare common for all protocols
    String sUrlTopJar = null;
    pd = getClass().getProtectionDomain();
    CodeSource cs = pd.getCodeSource();
    URL urlTopJar = cs.getLocation();
    String protocol = urlTopJar.getProtocol();

    // Work with different cases:
    JarFileInfo jarFileInfo = null;
    if ("http".equals(protocol) || "https".equals(protocol)) {
      // Protocol 'http' - application launched from WebStart / JNLP or as Java applet
      try {
        // Convert:
        //   urlTopJar = "http://.../MyApp.jar" --> connection
        // sun.net.www.protocol.http.HttpURLConnection
        // to
        //   urlTopJar = "jar:http://.../MyApp.jar!/" --> connection java.net.JarURLConnection
        urlTopJar = new URL("jar:" + urlTopJar + "!/");
        JarURLConnection jarCon = (JarURLConnection) urlTopJar.openConnection();
        JarFile jarFile = jarCon.getJarFile();
        jarFileInfo = new JarFileInfo(jarFile, jarFile.getName(), null, null);
        logInfo(LogArea.JAR, "Loading from top JAR: '%s' PROTOCOL: '%s'", urlTopJar, protocol);
      } catch (Exception e) {
        // ClassCastException, IOException
        logError(LogArea.JAR, "Failure to load HTTP JAR: %s %s", urlTopJar, e.toString());
        return;
      }
    }
    if ("file".equals(protocol)) {
      // Protocol 'file' - application launched from exploded dir or JAR
      // Decoding required for 'space char' in URL:
      //    URL.getFile() returns "/C:/my%20dir/MyApp.jar" for "/C:/my dir/MyApp.jar"
      try {
        sUrlTopJar = URLDecoder.decode(urlTopJar.getFile(), "UTF-8");
      } catch (UnsupportedEncodingException e) {
        logError(LogArea.JAR, "Failure to decode URL: %s %s", urlTopJar, e.toString());
        return;
      }
      File fileJar = new File(sUrlTopJar);

      // Application is loaded from directory:
      if (fileJar.isDirectory()) {
        logInfo(LogArea.JAR, "Loading from exploded directory: %s", sUrlTopJar);
        return; // JarClassLoader completed its job
      }

      // Application is loaded from a JAR:
      try {
        // The call "new JarFile(fileJar)" might throw IOException
        jarFileInfo = new JarFileInfo(new JarFile(fileJar), fileJar.getName(), null, null);
        logInfo(LogArea.JAR, "Loading from top JAR: '%s' PROTOCOL: '%s'", sUrlTopJar, protocol);
      } catch (IOException e) {
        logError(LogArea.JAR, "Not a JAR: %s %s", sUrlTopJar, e.toString());
        return;
      }
    }

    // FINALLY LOAD TOP JAR:
    try {
      if (jarFileInfo == null) {
        throw new IOException(String.format("Unknown protocol %s", protocol));
      }
      loadJar(jarFileInfo);
    } catch (IOException e) {
      logError(LogArea.JAR, "Not valid URL: %s %s", urlTopJar, e.toString());
      return;
    }

    checkShading();
    Runtime.getRuntime()
        .addShutdownHook(
            new Thread() {
              public void run() {
                shutdown();
              }
            });
  } // JarClassLoader()
Beispiel #29
0
  protected LoadServiceResource tryResourceFromJarURLWithLoadPath(
      String namePlusSuffix, String loadPathEntry) {
    LoadServiceResource foundResource = null;

    JarFile current = jarFiles.get(loadPathEntry);
    boolean isFileJarUrl = loadPathEntry.startsWith("file:") && loadPathEntry.indexOf("!/") != -1;
    String after =
        isFileJarUrl ? loadPathEntry.substring(loadPathEntry.indexOf("!/") + 2) + "/" : "";
    String before =
        isFileJarUrl ? loadPathEntry.substring(0, loadPathEntry.indexOf("!/")) : loadPathEntry;

    if (null == current) {
      try {
        if (loadPathEntry.startsWith("jar:")) {
          current = new JarFile(loadPathEntry.substring(4));
        } else if (loadPathEntry.endsWith(".jar")) {
          current = new JarFile(loadPathEntry);
        } else {
          current = new JarFile(loadPathEntry.substring(5, loadPathEntry.indexOf("!/")));
        }
        jarFiles.put(loadPathEntry, current);
      } catch (ZipException ignored) {
        if (runtime.getInstanceConfig().isDebug()) {
          runtime
              .getErr()
              .println("ZipException trying to access " + loadPathEntry + ", stack trace follows:");
          ignored.printStackTrace(runtime.getErr());
        }
      } catch (FileNotFoundException ignored) {
      } catch (IOException e) {
        throw runtime.newIOErrorFromException(e);
      }
    }
    String canonicalEntry = after + namePlusSuffix;
    if (current != null) {
      debugLogTry("resourceFromJarURLWithLoadPath", current.getName() + "!/" + canonicalEntry);
      if (current.getJarEntry(canonicalEntry) != null) {
        try {
          if (loadPathEntry.endsWith(".jar")) {
            foundResource =
                new LoadServiceResource(
                    new URL("jar:file:" + loadPathEntry + "!/" + canonicalEntry),
                    "/" + namePlusSuffix);
          } else if (loadPathEntry.startsWith("file:")) {
            foundResource =
                new LoadServiceResource(
                    new URL("jar:" + before + "!/" + canonicalEntry),
                    loadPathEntry + "/" + namePlusSuffix);
          } else {
            foundResource =
                new LoadServiceResource(
                    new URL("jar:file:" + loadPathEntry.substring(4) + "!/" + namePlusSuffix),
                    loadPathEntry + namePlusSuffix);
          }
          debugLogFound(foundResource);
        } catch (MalformedURLException e) {
          throw runtime.newIOErrorFromException(e);
        }
      }
    }

    return foundResource;
  }
  /**
   * This method is designed to clear out classloader file locks in windows.
   *
   * @param clazzLdr class loader to clean up
   */
  public void closeClassLoader() {
    HashSet<String> closedFiles = new HashSet<String>();
    try {
      Object obj = getFieldObject(URLClassLoader.class, "ucp", this);
      ArrayList<?> loaders = (ArrayList<?>) getFieldObject(obj.getClass(), "loaders", obj);
      for (Object ldr : loaders) {
        try {
          JarFile file = (JarFile) getFieldObject(ldr.getClass(), "jar", ldr);
          closedFiles.add(file.getName());
          file.close();
        } catch (Exception e) {
          // skip
        }
      }
    } catch (Exception e) {
      // skip
    }

    try {
      Vector<?> nativeLibArr =
          (Vector<?>) getFieldObject(ClassLoader.class, "nativeLibraries", this);
      for (Object lib : nativeLibArr) {
        try {
          Method fMethod = lib.getClass().getDeclaredMethod("finalize", new Class<?>[0]);
          fMethod.setAccessible(true);
          fMethod.invoke(lib, new Object[0]);
        } catch (Exception e) {
          // skip
        }
      }
    } catch (Exception e) {
      // skip
    }

    HashMap<?, ?> uCache = null;
    HashMap<?, ?> fCache = null;

    try {
      Class<?> jarUrlConnClass = null;
      try {
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        jarUrlConnClass = contextClassLoader.loadClass("sun.net.www.protocol.jar.JarURLConnection");
      } catch (Throwable skip) {
        // skip
      }
      if (jarUrlConnClass == null) {
        jarUrlConnClass = Class.forName("sun.net.www.protocol.jar.JarURLConnection");
      }
      Class<?> factory = getFieldObject(jarUrlConnClass, "factory", null).getClass();
      try {
        fCache = (HashMap<?, ?>) getFieldObject(factory, "fileCache", null);
      } catch (Exception e) {
        // skip
      }
      try {
        uCache = (HashMap<?, ?>) getFieldObject(factory, "urlCache", null);
      } catch (Exception e) {
        // skip
      }
      if (uCache != null) {
        Set<?> set = null;
        while (set == null) {
          try {
            set = ((HashMap<?, ?>) uCache.clone()).keySet();
          } catch (ConcurrentModificationException e) {
            // Fix for BACKLOG-2149 - Do nothing - while loop will try again.
          }
        }

        for (Object file : set) {
          if (file instanceof JarFile) {
            JarFile jar = (JarFile) file;
            if (!closedFiles.contains(jar.getName())) {
              continue;
            }
            try {
              jar.close();
            } catch (IOException e) {
              // skip
            }
            if (fCache != null) {
              fCache.remove(uCache.get(jar));
            }
            uCache.remove(jar);
          }
        }
      } else if (fCache != null) {
        for (Object key : ((HashMap<?, ?>) fCache.clone()).keySet()) {
          Object file = fCache.get(key);
          if (file instanceof JarFile) {
            JarFile jar = (JarFile) file;
            if (!closedFiles.contains(jar.getName())) {
              continue;
            }
            try {
              jar.close();
            } catch (IOException e) {
              // ignore
            }
            fCache.remove(key);
          }
        }
      }
    } catch (Exception e) {
      // skip
      e.printStackTrace();
    }
  }