Java 类java.util.jar.JarEntry 实例源码

@Override
public PluginDescription getPluginDescription(File file) {
    try (JarFile jar = new JarFile(file)) {
        JarEntry entry = jar.getJarEntry("nukkit.yml");
        if (entry == null) {
            entry = jar.getJarEntry("plugin.yml");
            if (entry == null) {
                return null;
            }
        }
        try (InputStream stream = jar.getInputStream(entry)) {
            return new PluginDescription(Utils.readFile(stream));
        }
    } catch (IOException e) {
        return null;
    }
}

/**
 * 解析jar包中的类
 * @param jarFile           表示jar文件
 * @param packageLocation   扫描的包路径
 * @throws Exception 反射时的异常
 */
private void resolveJar(JarFile jarFile, String packageLocation) throws Exception {
    Enumeration<JarEntry> entries = jarFile.entries();
    while (entries.hasMoreElements()) {
        String classLocation = entries.nextElement().getName();
        // 当jar文件中的路径是以packageLocation指定的路径开头,并且是以.class结尾时
        if (classLocation.startsWith(packageLocation) && classLocation.endsWith(".class")) {
            String location = classLocation.replace(".class", "").replace("/", ".");
            Class<?> forName = Class.forName(location);
            configurationBeansHandler(forName);
            Annotation[] annos = forName.getAnnotations();
            if (AnnoUtil.exist(annos, Bean.class) && !forName.isInterface()) {
                beansInitializedHandler(forName);
            }
        }
    }
}

private File copyJar(File file, String manifest) throws IOException {
    File ret = File.createTempFile(file.getName(), "2ndcopy", file.getParentFile());
    JarFile jar = new JarFile(file);
    JarOutputStream os = new JarOutputStream(new FileOutputStream(ret), new Manifest(
        new ByteArrayInputStream(manifest.getBytes())
    ));
    Enumeration<JarEntry> en = jar.entries();
    while (en.hasMoreElements()) {
        JarEntry elem = en.nextElement();
        if (elem.getName().equals("META-INF/MANIFEST.MF")) {
            continue;
        }
        os.putNextEntry(elem);
        InputStream is = jar.getInputStream(elem);
        copyStreams(is, os);
        is.close();
    }
    os.close();
    return ret;
}

private static void writeJarEntry(JarOutputStream jos, String path, File f) throws IOException, FileNotFoundException {
    JarEntry je = new JarEntry(path);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    InputStream is = new FileInputStream(f);
    try {
        copyStreams(is, baos);
    } finally {
        is.close();
    }
    byte[] data = baos.toByteArray();
    je.setSize(data.length);
    CRC32 crc = new CRC32();
    crc.update(data);
    je.setCrc(crc.getValue());
    jos.putNextEntry(je);
    jos.write(data);
}

public static File createAgent(Class<?> agent, Class<?>... resources) throws IOException {
    File jarFile = File.createTempFile("agent", ".jar");
    jarFile.deleteOnExit();
    Manifest manifest = new Manifest();
    Attributes mainAttributes = manifest.getMainAttributes();
    mainAttributes.put(Name.MANIFEST_VERSION, "1.0");
    mainAttributes.put(new Name("Agent-Class"), agent.getName());
    mainAttributes.put(new Name("Can-Retransform-Classes"), "true");
    mainAttributes.put(new Name("Can-Redefine-Classes"), "true");
    JarOutputStream jos = new JarOutputStream(new FileOutputStream(jarFile), manifest);
    jos.putNextEntry(new JarEntry(agent.getName().replace('.', '/') + ".class"));
    jos.write(getBytesFromStream(agent.getClassLoader().getResourceAsStream(unqualify(agent))));
    jos.closeEntry();
    for (Class<?> clazz : resources) {
        String name = unqualify(clazz);
        jos.putNextEntry(new JarEntry(name));
        jos.write(getBytesFromStream(clazz.getClassLoader().getResourceAsStream(name)));
        jos.closeEntry();
    }

    jos.close();
    return jarFile;
}

private static void doJar(String a, File source, File dest,
                          ClassReader options, String encoding,
                          Boolean contError) throws IOException {
    try {
        JarFile jf = new JarFile(source);
        for (JarEntry je : Collections.list(jf.entries())) {
            String name = je.getName();
            if (!name.endsWith(".class")) {
                continue;
            }
            try {
                doStream(name, jf.getInputStream(je), dest, options, encoding);
            } catch (Exception e) {
                if (contError) {
                    System.out.println("Error processing " + source + ": " + e);
                    e.printStackTrace();
                    continue;
                }
            }
        }
    } catch (IOException ioe) {
        throw ioe;
    }
}

public Map<String, String> getRenameMap(String jarFilePath) {
    Map<String, String> map = new HashMap<>();
    try {
        File jarFile = new File(jarFilePath);
        JarFile file = new JarFile(jarFile);
        Enumeration<JarEntry> enumeration = file.entries();
        while (enumeration.hasMoreElements()) {
            JarEntry jarEntry = enumeration.nextElement();
            String entryName = jarEntry.getName();
            String className;
            if (entryName.endsWith(".class")) {
                className = Utils.path2Classname(entryName);
                String simpleName = className.substring(className.lastIndexOf('.') + 1);
                if (Utils.isProguardedName(simpleName)) {
                    map.put(className, getNewClassName(className, simpleName));
                }
            }
        }
        file.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return map;
}

/**
 * Converts a jar entry to a class name.
 * 
 * @param entry <code>JarEntry</code> to process.
 * @return The classname of the jar entry or <code>null</code> if it cannot be 
 *      devised.
 */
private static String getClassName(JarEntry entry) {
    final String name = entry.getName();

    if (name.endsWith(".class")) { // NOI18N
        final String className = 
                name.substring(0, name.length() - 6).replace('/', '.'); // NOMAGI
        if (className.matches(
                "([a-zA-Z][a-zA-Z0-9_]+\\.)+[a-zA-Z][a-zA-Z0-9_]+")) { // NOI18N
            return className;
        } else {
            return null;
        }
    }

    return null;
}

public JarClassIterator(JarFile jar) {
    m_jar = jar;

    // get the jar entries that correspond to classes
    List<JarEntry> classEntries = Lists.newArrayList();
    Enumeration<JarEntry> entries = m_jar.entries();
    while (entries.hasMoreElements()) {
        JarEntry entry = entries.nextElement();

        // is this a class file?
        if (entry.getName().endsWith(".class")) {
            classEntries.add(entry);
        }
    }
    m_iter = classEntries.iterator();
}

/**
 * 加载jar的所有类
 * 
 * @param jarFiles
 * @param loader
 * @return
 * @throws ClassNotFoundException
 * @throws IOException
 */
protected Set<Class<?>> loadAllClass(File jarFile, ScriptClassLoader loader) throws Exception {
    Set<Class<?>> clzzs = new HashSet<Class<?>>();
    JarFile jf = new JarFile(jarFile);
    try {
        loader.addURL(jarFile.toURI().toURL());// 添加文件到加载器
        Enumeration<JarEntry> it = jf.entries();
        while (it.hasMoreElements()) {
            JarEntry jarEntry = it.nextElement();
            if (jarEntry.getName().endsWith(".class")) {
                String className = jarEntry.getName().replace("/", ".").replaceAll(".class", "");
                clzzs.add(loader.findClass(className));
            }
        }
    } finally {
        jf.close();
    }
    return clzzs;
}

/**
 * Finds native library entry.
 *
 * @param sLib Library name. For example for the library name "Native"
 *  - Windows returns entry "Native.dll"
 *  - Linux returns entry "libNative.so"
 *  - Mac returns entry "libNative.jnilib" or "libNative.dylib"
 *    (depending on Apple or Oracle JDK and/or JDK version)
 * @return Native library entry.
 */
private JarEntryInfo findJarNativeEntry(String sLib) {
    String sName = System.mapLibraryName(sLib);
    for (JarFileInfo jarFileInfo : lstJarFile) {
        JarFile jarFile = jarFileInfo.jarFile;
        Enumeration<JarEntry> en = jarFile.entries();
        while (en.hasMoreElements()) {
            JarEntry je = en.nextElement();
            if (je.isDirectory()) {
                continue;
            }
            // Example: sName is "Native.dll"
            String sEntry = je.getName(); // "Native.dll" or "abc/xyz/Native.dll"
            // sName "Native.dll" could be found, for example
            //   - in the path: abc/Native.dll/xyz/my.dll <-- do not load this one!
            //   - in the partial name: abc/aNative.dll   <-- do not load this one!
            String[] token = sEntry.split("/"); // the last token is library name
            if (token.length > 0 && token[token.length - 1].equals(sName)) {
                logInfo(LogArea.NATIVE, "Loading native library '%s' found as '%s' in JAR %s",
                        sLib, sEntry, jarFileInfo.simpleName);
                return new JarEntryInfo(jarFileInfo, je);
            }
        }
    }
    return null;
}

private Class<?>[] getClasses(File jarFile) {
    Set<Class<?>> classes = new HashSet<>();
    try {
        JarFile file = new JarFile(jarFile);
        for (Enumeration<JarEntry> entry = file.entries(); entry.hasMoreElements(); ) {
            JarEntry jarEntry = entry.nextElement();
            String jarName = jarEntry.getName().replace('/', '.');

            if (jarName.endsWith(".class")) {
                if (!jarName.contains("1_8") && !jarName.contains("1_9") && !jarName.contains("1_10") && !jarName.contains("1_11") && !jarName.contains("1_7"))
                    classes.add(Class.forName(jarName.substring(0, jarName.length() - 6)));
            }
        }
        file.close();
    } catch (IOException | ClassNotFoundException ex) {
        Bukkit.getLogger().severe("Error ocurred at getting classes, log: " + ex);
    }

    return classes.toArray(new Class[classes.size()]);
}

private void writeFileObjects(JarOutputStream jos) throws IOException {
    for (FileObject fo : fileObjects) {
        String p = guessPath(fo);
        JarEntry e = new JarEntry(p);
        jos.putNextEntry(e);
        try {
            byte[] buf = new byte[1024];
            try (BufferedInputStream in = new BufferedInputStream(fo.openInputStream())) {
                int n;
                while ((n = in.read(buf)) > 0)
                    jos.write(buf, 0, n);
            } catch (IOException ex) {
                error("Exception while adding " + fo.getName() + " to jar file", ex);
            }
    } finally {
            jos.closeEntry();
    }
    }
}

private static Collection<String> listTestsFromJar(File archive) {
    Collection<String> result = new LinkedList<String>();

    try {
        JarFile jf = new JarFile(archive);
        Enumeration<JarEntry> entries = jf.entries();

        while (entries.hasMoreElements()) {
            JarEntry entry = entries.nextElement();

            if (entry.getName().endsWith(".test")) {
                result.add(entry.getName());
            }
        }
    } catch (IOException ex) {
        throw new IllegalStateException(ex);
    }

    return result;
}

public void createRealJarFile(File f) throws Exception {
        OutputStream os = new FileOutputStream(f);
        try {
            JarOutputStream jos = new JarOutputStream(os);
//            jos.setMethod(ZipEntry.STORED);
            JarEntry entry = new JarEntry("foo.txt");
//            entry.setSize(0L);
//            entry.setTime(System.currentTimeMillis());
//            entry.setCrc(new CRC32().getValue());
            jos.putNextEntry(entry);
            jos.flush();
            jos.close();
        } finally {
            os.close();
        }
    }

private File createModuleJar(String manifest) throws IOException {
    // XXX use TestFileUtils.writeZipFile
    File jarFile = new File( getWorkDir(), "mymodule.jar" );

    JarOutputStream os = new JarOutputStream(new FileOutputStream(jarFile), new Manifest(
        new ByteArrayInputStream(manifest.getBytes())
    ));
    JarEntry entry = new JarEntry("foo/mf-layer.xml");
    os.putNextEntry( entry );

    File l3 = new File(new File(new File(getDataDir(), "layers"), "data"), "layer3.xml");
    InputStream is = new FileInputStream(l3);
    FileUtil.copy( is, os );
    is.close();
    os.close();

    return jarFile;
}

private File createModuleJar(String manifest) throws IOException {
    File jarFile = new File( getWorkDir(), "mymodule.jar" );

    JarOutputStream os = new JarOutputStream(new FileOutputStream(jarFile), new Manifest(
        new ByteArrayInputStream(manifest.getBytes())
    ));
    JarEntry entry = new JarEntry("foo/mf-layer.xml");
    os.putNextEntry( entry );

    File l3 = new File(new File(new File(getDataDir(), "layers"), "data"), "layer3.xml");
    InputStream is = new FileInputStream(l3);
    FileUtil.copy( is, os );
    is.close();
    os.putNextEntry(new JarEntry("org/netbeans/core/startup/layers/DelayFSInstaller.class"));
    is = DelayFSEventsTest.class.getResourceAsStream("DelayFSInstaller.class");
    FileUtil.copy (is, os);

    os.close();

    return jarFile;
}

private void addDirectory( Set<String> resources, JarOutputStream jos, String name, boolean consistentDates )
    throws IOException
{
    if ( name.lastIndexOf( '/' ) > 0 )
    {
        String parent = name.substring( 0, name.lastIndexOf( '/' ) );
        if ( !resources.contains( parent ) )
        {
            addDirectory( resources, jos, parent, consistentDates );
        }
    }

    // directory entries must end in "/"
    JarEntry entry = new ConsistentJarEntry( name + "/", consistentDates );
    jos.putNextEntry( entry );

    resources.add( name );
}

static void generateLargeJar(File result, File source) throws IOException {
    if (result.exists()) {
        result.delete();
    }

    try (JarOutputStream copyTo = new JarOutputStream(new FileOutputStream(result));
         JarFile srcJar = new JarFile(source)) {

        for (JarEntry je : Collections.list(srcJar.entries())) {
            copyTo.putNextEntry(je);
            if (!je.isDirectory()) {
                copyStream(srcJar.getInputStream(je), copyTo);
            }
            copyTo.closeEntry();
        }

        int many = Short.MAX_VALUE * 2 + 2;

        for (int i = 0 ; i < many ; i++) {
            JarEntry e = new JarEntry("F-" + i + ".txt");
            copyTo.putNextEntry(e);
        }
        copyTo.flush();
        copyTo.close();
    }
}

@Override
protected void setUp() throws Exception {
    clearWorkDir();
    f = new File(getWorkDir(), "m.jar");

    Manifest man = new Manifest();
    Attributes attr = man.getMainAttributes();
    attr.putValue("OpenIDE-Module", "m.test");
    attr.putValue("OpenIDE-Module-Public-Packages", "-");
    attr.putValue("Manifest-Version", "1.0");
    JarOutputStream os = new JarOutputStream(new FileOutputStream(f), man);
    os.putNextEntry(new JarEntry("META-INF/namedservices/ui/javax.swing.JComponent"));
    os.write("javax.swing.JButton\n".getBytes("UTF-8"));
    os.closeEntry();
    os.close();

    FileObject fo = FileUtil.createData(FileUtil.getConfigRoot(), "ui/ch/my/javax-swing-JPanel.instance");
}

/**
 * Scans a jar file for uses of deprecated APIs.
 *
 * @param jarname the jar file to process
 * @return true on success, false on failure
 */
public boolean scanJar(String jarname) {
    try (JarFile jf = new JarFile(jarname)) {
        out.println(Messages.get("scan.head.jar", jarname));
        finder.addJar(jarname);
        Enumeration<JarEntry> entries = jf.entries();
        while (entries.hasMoreElements()) {
            JarEntry entry = entries.nextElement();
            String name = entry.getName();
            if (name.endsWith(".class")
                    && !name.endsWith("package-info.class")
                    && !name.endsWith("module-info.class")) {
                processClass(ClassFile.read(jf.getInputStream(entry)));
            }
        }
        return true;
    } catch (NoSuchFileException nsfe) {
        errorNoFile(jarname);
    } catch (IOException | ConstantPoolException ex) {
        errorException(ex);
    }
    return false;
}

private static String getBaseSuffix(JarEntry je, int version) {
    String name = je.getName();
    if (name.startsWith(META_INF_VERSIONS)) {
        int len = META_INF_VERSIONS.length();
        int index = name.indexOf('/', len);
        if (index == -1 || index == (name.length() - 1)) {
            // filter out META-INF/versions/* and META-INF/versions/*/
            return null;
        }
        try {
            if (Integer.parseInt(name, len, index, 10) > version) {
                // not an integer
                return null;
            }
        } catch (NumberFormatException x) {
            // silently remove malformed entries
            return null;
        }
        // We know name looks like META-INF/versions/*/*
        return name.substring(index + 1);
    }
    return name;
}

/**
 * Writes a new {@link File} into the archive.
 *
 * @param inputFile the {@link File} to write.
 * @param jarPath   the filepath inside the archive.
 * @throws IOException
 */
public void writeFile(File inputFile, String jarPath) throws IOException {
    // Get an input stream on the file.
    FileInputStream fis = new FileInputStream(inputFile);
    try {

        // create the zip entry
        JarEntry entry = new JarEntry(jarPath);
        entry.setTime(inputFile.lastModified());

        writeEntry(fis, entry);
    } finally {
        // close the file stream used to read the file
        fis.close();
    }
}

static void generateLargeJar(File result, File source) throws IOException {
    if (result.exists()) {
        result.delete();
    }

    try (JarOutputStream copyTo = new JarOutputStream(new FileOutputStream(result));
         JarFile srcJar = new JarFile(source)) {

        for (JarEntry je : Collections.list(srcJar.entries())) {
            copyTo.putNextEntry(je);
            if (!je.isDirectory()) {
                copyStream(srcJar.getInputStream(je), copyTo);
            }
            copyTo.closeEntry();
        }

        int many = Short.MAX_VALUE * 2 + 2;

        for (int i = 0 ; i < many ; i++) {
            JarEntry e = new JarEntry("F-" + i + ".txt");
            copyTo.putNextEntry(e);
        }
        copyTo.flush();
        copyTo.close();
    }
}

private static void publicize(Path inPath, Path outPath) throws IOException {
    try (JarInputStream in = new JarInputStream(Files.newInputStream(inPath))) {
        try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(outPath))) {
            JarEntry entry;
            while ((entry = in.getNextJarEntry()) != null) {
                if (entry.isDirectory()) {
                    continue;
                }

                String name = entry.getName();
                out.putNextEntry(new JarEntry(name));

                if (name.endsWith(".class")) {
                    ClassWriter writer = new ClassWriter(0);

                    ClassReader reader = new ClassReader(in);
                    reader.accept(new CheckClassAdapter(new ClassDefinalizer(new ClassPublicizer(writer)), true), 0);

                    out.write(writer.toByteArray());
                } else {
                    ByteStreams.copy(in, out);
                }
            }
        }
    }
}

private static void writeJarEntry(JarOutputStream jos, String path, File f) throws IOException, FileNotFoundException {
    JarEntry je = new JarEntry(path);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    InputStream is = new FileInputStream(f);
    try {
        copyStreams(is, baos);
    } finally {
        is.close();
    }
    byte[] data = baos.toByteArray();
    je.setSize(data.length);
    CRC32 crc = new CRC32();
    crc.update(data);
    je.setCrc(crc.getValue());
    jos.putNextEntry(je);
    jos.write(data);
}

@Override
public PluginDescription getPluginDescription(File file) {
    try (JarFile jar = new JarFile(file)) {
        JarEntry entry = jar.getJarEntry("nukkit.yml");
        if (entry == null) {
            entry = jar.getJarEntry("plugin.yml");
            if (entry == null) {
                return null;
            }
        }
        try (InputStream stream = jar.getInputStream(entry)) {
            return new PluginDescription(Utils.readFile(stream));
        }
    } catch (IOException e) {
        return null;
    }
}

@Override
protected void handleClazz(JarFile jarFile, JarOutputStream jos, JarEntry ze, String pathName) {

    //            logger.log(pathName);
    if (reMapping.containsKey(pathName.substring(0, pathName.length() - 6))) {
        logger.info("[ClazzReplacer] remove class  " + pathName + " form " + jarFile);
        return;
    }

    try {
        InputStream in = jarFile.getInputStream(ze);
        ClassReader cr = new ClassReader(in);
        ClassWriter cw = new ClassWriter(0);
        RemappingClassAdapter remappingClassAdapter = new RemappingClassAdapter(cw, new SimpleRemapper(reMapping));
        cr.accept(remappingClassAdapter, ClassReader.EXPAND_FRAMES);

        InputStream inputStream = new ByteArrayInputStream(cw.toByteArray());
        copyStreamToJar(inputStream, jos, pathName, ze.getTime());

    } catch (Throwable e) {

        System.err.println("[ClazzReplacer] rewrite error > " + pathName);
        justCopy(jarFile, jos, ze, pathName);
    }

}

private Set<String> pakArchiefBestandUit(final Path tmpFolder) {
    getLog().debug("Unpacking artifact");
    Set<String> keys = new TreeSet<>();
    try (final JarInputStream archiefStream = new JarInputStream(new FileInputStream(artifact + ".bak"))) {

        final List<String> bestanden = new ArrayList<>();
        JarEntry archiefItem = archiefStream.getNextJarEntry();
        while (archiefItem != null) {
            final File archiefBestand = new File(tmpFolder.toFile(), archiefItem.getName());
            if (archiefItem.isDirectory()) {
                archiefBestand.mkdirs();
            } else {
                pakBestandUit(archiefStream, archiefBestand);
            }
            bestanden.add(archiefItem.getName());
            archiefStream.closeEntry();
            archiefItem = archiefStream.getNextJarEntry();
        }

        pakManifestUit(tmpFolder, archiefStream, bestanden);
        keys.addAll(bestanden);
    } catch (IOException | WrappedException e) {
        getLog().debug("Artifact cannot be fixed", e);
    }
    return keys;
}

protected Class<?> findClassInJarFile(String qualifiedClassName) throws ClassNotFoundException {
    URI classUri = URIUtil.buildUri(StandardLocation.CLASS_OUTPUT, qualifiedClassName);
    String internalClassName = classUri.getPath().substring(1);
    JarFile jarFile = null;
    try {
        for (int i = 0; i < jarFiles.size(); i++) {
            jarFile = jarFiles.get(i);
            JarEntry jarEntry = jarFile.getJarEntry(internalClassName);
            if (jarEntry != null) {
                InputStream inputStream = jarFile.getInputStream(jarEntry);
                try {
                    byte[] byteCode = new byte[(int) jarEntry.getSize()];
                    ByteStreams.read(inputStream, byteCode, 0, byteCode.length);
                    return defineClass(qualifiedClassName, byteCode, 0, byteCode.length);
                } finally {
                    Closeables.closeQuietly(inputStream);
                }
            }
        }
    } catch (IOException e) {
        throw new IllegalStateException(String.format("Failed to lookup class %s in jar file %s", qualifiedClassName, jarFile), e);
    }
    return null;
}

public void add(String name, byte[] data) {
  try {
    JarEntry entry = new JarEntry(name.replace('.', '/') + ".class");
    _output.putNextEntry(entry);
    _output.write(data);
    _output.closeEntry();
  } catch (Exception e) {
    throw new RuntimeException("Failed to add jar entry", e);
  }
}

public static boolean extractFromJar(final String fileName, final String dest) throws IOException {
    if (getRunningJar() == null) {
        return false;
    }
    final File file = new File(dest);
    if (file.isDirectory()) {
        file.mkdir();
        return false;
    }
    if (!file.exists()) {
        file.getParentFile().mkdirs();
    }

    final JarFile jar = getRunningJar();
    final Enumeration<JarEntry> e = jar.entries();
    while (e.hasMoreElements()) {
        final JarEntry je = e.nextElement();
        if (!je.getName().contains(fileName)) {
            continue;
        }
        final InputStream in = new BufferedInputStream(jar.getInputStream(je));
        final OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
        copyInputStream(in, out);
        jar.close();
        return true;
    }
    jar.close();
    return false;
}

protected Set<String> scan() {
    try (JarFile jf = openJarFile(path.toFile(), version)) {
        return VersionedStream.stream(jf).map(JarEntry::getName)
                 .filter(n -> n.endsWith(".class"))
                 .collect(Collectors.toSet());
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

/**
     * Check the specified JAR file, and return <code>true</code> if it does
     * not contain any of the trigger classes.
     *
//     * @param jarFile The JAR file to be checked
     *
     * @exception IOException if an input/output error occurs
     */
    private boolean validateJarFile(File jarfile)
        throws IOException {

        if (triggers == null)
            return (true);
        JarFile jarFile = new JarFile(jarfile);
        for (int i = 0; i < triggers.length; i++) {
            Class clazz = null;
            try {
                if (parent != null) {
                    clazz = parent.loadClass(triggers[i]);
                } else {
                    clazz = Class.forName(triggers[i]);
                }
            } catch (Throwable t) {
                clazz = null;
            }
            if (clazz == null)
                continue;
            String name = triggers[i].replace('.', '/') + ".class";
            if (debug >= 2)
                log(" Checking for " + name);
            JarEntry jarEntry = jarFile.getJarEntry(name);
            if (jarEntry != null) {
                log("validateJarFile(" + jarfile +
                    ") - jar not loaded. See Servlet Spec 2.3, "
                    + "section 9.7.2. Offending class: " + name);
                jarFile.close();
                return (false);
            }
        }
        jarFile.close();
        return (true);

    }

/**
 * Create a fresh JAR file.
 * @param jar the file to create
 * @param contents keys are JAR entry paths, values are text contents (will be written in UTF-8)
 * @param manifest a manifest to store (key/value pairs for main section)
 */
public static void createJar(File jar, Map<String,String> contents, Map<String,String> manifest) throws IOException {
    // XXX use TestFileUtils.writeZipFile
    Manifest m = new Manifest();
    m.getMainAttributes().putValue("Manifest-Version", "1.0"); // workaround for JDK bug
    for (Map.Entry<String,String> line : manifest.entrySet()) {
        m.getMainAttributes().putValue(line.getKey(), line.getValue());
    }
    jar.getParentFile().mkdirs();
    OutputStream os = new FileOutputStream(jar);
    try {
        JarOutputStream jos = new JarOutputStream(os, m);
        Iterator it = contents.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            String path = (String) entry.getKey();
            byte[] data = ((String) entry.getValue()).getBytes("UTF-8");
            JarEntry je = new JarEntry(path);
            je.setSize(data.length);
            CRC32 crc = new CRC32();
            crc.update(data);
            je.setCrc(crc.getValue());
            jos.putNextEntry(je);
            jos.write(data);
        }
        jos.close();
    } finally {
        os.close();
    }
}

private void testBadTestyJar(String jar) throws IOException, RepoUpdater.UpdateException {
    Repo repo = MultiRepoUpdaterTest.createRepo("Testy", jar, context, TESTY_CERT);
    IndexV1Updater updater = new IndexV1Updater(context, repo);
    JarFile jarFile = new JarFile(TestUtils.copyResourceToTempFile(jar), true);
    JarEntry indexEntry = (JarEntry) jarFile.getEntry(IndexV1Updater.DATA_FILE_NAME);
    InputStream indexInputStream = jarFile.getInputStream(indexEntry);
    updater.processIndexV1(indexInputStream, indexEntry, "fakeEtag");
    fail(); // it should never reach here, it should throw a SigningException
}

private List<JarEntryInfo> findJarEntries(String sName) {
    List<JarEntryInfo> lst = new ArrayList<JarEntryInfo>();
    for (JarFileInfo jarFileInfo : lstJarFile) {
        JarFile jarFile = jarFileInfo.jarFile;
        JarEntry jarEntry = jarFile.getJarEntry(sName);
        if (jarEntry != null) {
            lst.add(new JarEntryInfo(jarFileInfo, jarEntry));
        }
    }
    return lst;
}

@Override
public void guide(URLVisitor v, boolean recurse, boolean strip) {
    try {
        Enumeration<JarEntry> entries = jarFile.entries();

        while (entries.hasMoreElements()) {
            JarEntry entry = entries.nextElement();

            if (!entry.isDirectory()) { // skip just directory paths
                String name = entry.getName();

                if (name.startsWith(prefix)) {
                    name = name.substring(prefix.length());
                    int ix = name.lastIndexOf('/');
                    if (ix > 0 && !recurse) {
                        continue;
                    }
                    if (strip && ix != -1) {
                        name = name.substring(ix+1);
                    }
                    v.visit(name);
                }
            }
        }
    }
    catch (Exception e) {
        if (DEBUG) System.err.println("icurb jar error: " + e);
    }
}

/**
 * Checks whether the given file is a signed jar archive.
 *
 * @param file File to check for being a signed jar archive.
 * @return <code>true</code> if the file is a signed jar archive,
 *      <code>false</code> otherwise.
 * @throws java.io.IOException if an I/O error occurs.
 */
public static boolean isSigned(final File file) throws IOException {
    JarFile jar = new JarFile(file);

    try {
        Enumeration<JarEntry> entries = jar.entries();
        boolean signatureInfoPresent = false;
        boolean signatureFilePresent = false;
        while (entries.hasMoreElements()) {
            String entryName = entries.nextElement().getName();
            if (entryName.startsWith("META-INF/")) {
                if (entryName.endsWith(".RSA") || entryName.endsWith(".DSA")) {
                    signatureFilePresent = true;
                    if(signatureInfoPresent) {
                        break;
                    }
                } else if (entryName.endsWith(".SF")) {
                    signatureInfoPresent = true;
                    if(signatureFilePresent) {
                        break;
                    }
                }
            }
        }
        return signatureFilePresent && signatureInfoPresent;
    } finally {
        jar.close();
    }
}

private static JarEntry findJarEntry(JarFile jarFile, String entryName) {

        Enumeration entries = jarFile.entries();

        while (entries.hasMoreElements()) {
            JarEntry entry = (JarEntry) entries.nextElement();
            if (entry.getName().equals(entryName)) {
                return entry;
            }
        }

        return null;
    }