@Test public void verifySignedJar() throws Exception { String classpath = System.getProperty("java.class.path"); String[] entries = classpath.split(System.getProperty("path.separator")); String signedJarFile = null; for (String entry : entries) { if (entry.contains("bcprov")) { signedJarFile = entry; } } assertThat(signedJarFile).isNotNull(); java.util.jar.JarFile jarFile = new JarFile(new File(signedJarFile)); jarFile.getManifest(); Enumeration<JarEntry> jarEntries = jarFile.entries(); while (jarEntries.hasMoreElements()) { JarEntry jarEntry = jarEntries.nextElement(); InputStream inputStream = jarFile.getInputStream(jarEntry); inputStream.skip(Long.MAX_VALUE); inputStream.close(); if (!jarEntry.getName().startsWith("META-INF") && !jarEntry.isDirectory() && !jarEntry.getName().endsWith("TigerDigest.class")) { assertThat(jarEntry.getCertificates()).isNotNull(); } } jarFile.close(); }
/** * Finds native library entry. * * @param sLib Library name. For example for the library name "Native" the Windows returns entry * "Native.dll", the Linux returns entry "libNative.so", the Mac returns entry * "libNative.jnilib". * @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; } // findJarNativeEntry()
/** @throws IOException java.util.jar.JarFile#getJarEntry(java.lang.String) */ public void test_getJarEntryLjava_lang_String() throws IOException { try { Support_Resources.copyFile(resources, null, jarName); JarFile jarFile = new JarFile(new File(resources, jarName)); assertEquals("Error in returned entry", 311, jarFile.getJarEntry(entryName).getSize()); jarFile.close(); } catch (Exception e) { fail("Exception during test: " + e.toString()); } Support_Resources.copyFile(resources, null, jarName); JarFile jarFile = new JarFile(new File(resources, jarName)); Enumeration<JarEntry> enumeration = jarFile.entries(); assertTrue(enumeration.hasMoreElements()); while (enumeration.hasMoreElements()) { JarEntry je = enumeration.nextElement(); jarFile.getJarEntry(je.getName()); } enumeration = jarFile.entries(); assertTrue(enumeration.hasMoreElements()); JarEntry je = enumeration.nextElement(); try { jarFile.close(); jarFile.getJarEntry(je.getName()); // fail("IllegalStateException expected."); } catch (IllegalStateException ee) { // Per documentation exception // may be thrown. // expected } }
private Collection<JarEntry> findSubdeployments(String extension, JarFile jar) throws IOException { List<JarEntry> jars = new ArrayList<>(); switch (extension) { // TODO only check specific locations case "ear": for (JarEntry entry : asIterable(jar.entries())) { String entryName = entry.getName(); if (entryName.endsWith(".jar") || entryName.endsWith(".war") || entryName.endsWith(".rar")) { jars.add(entry); } } return jars; case "war": case "rar": for (JarEntry entry : asIterable(jar.entries())) { String entryName = entry.getName(); if (entryName.endsWith(".jar")) { jars.add(entry); } } return jars; default: throw new IllegalArgumentException("uknown deployment container: " + extension); } }
protected void processJar( ClassResource classResource, Set<Class<?>> classes, String filter, Integer limit) { URL resource = classResource.getResource(); String packageName = classResource.getPackageName(); String relativePath = getPackageRelativePath(packageName); String jarPath = getJarPath(resource); JarFile jarFile; try { jarFile = new JarFile(jarPath); } catch (IOException e) { LOG.debug("IOException reading JAR '" + jarPath + ". Reason: " + e, e); return; } Enumeration<JarEntry> entries = jarFile.entries(); while (entries.hasMoreElements() && withinLimit(limit, classes)) { JarEntry entry = entries.nextElement(); String entryName = entry.getName(); String className = null; if (entryName.endsWith(".class") && entryName.startsWith(relativePath) && entryName.length() > (relativePath.length() + 1)) { className = entryName.replace('/', '.').replace('\\', '.').replace(".class", ""); } Class<?> aClass = tryFindClass(className, filter); if (aClass != null) { classes.add(aClass); } } }
/** * Removes an entry from a jar file * * @param jar The jar file * @param entryName The name of the entry to remove * @return The data of the jar with the entry removed * @throws IOException */ public static byte[] removeJarEntry(JarFile jar, String entryName) throws IOException { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); JarOutputStream jarOut = new JarOutputStream(bytes); // copy all entries except the one with the matching name Set<String> copiedEntries = new HashSet<String>(); Enumeration<JarEntry> jarEntries = jar.entries(); while (jarEntries.hasMoreElements()) { JarEntry entry = jarEntries.nextElement(); String name = entry.getName(); if (!name.equals(entryName)) { if (!copiedEntries.contains(name)) { jarOut.putNextEntry(entry); InputStream entryStream = jar.getInputStream(entry); byte[] entryBytes = streamToBytes(entryStream); entryStream.close(); jarOut.write(entryBytes); jarOut.closeEntry(); copiedEntries.add(name); } } } jarOut.flush(); jarOut.close(); return bytes.toByteArray(); }
private Map<String, byte[]> digestJar(final File file) throws IOException { Map<String, byte[]> digest = CACHE.get(file); if (digest == null) { digest = new HashMap<String, byte[]>(); JarFile jar = new JarFile(file); try { for (Enumeration<JarEntry> entries = jar.entries(); entries.hasMoreElements(); ) { JarEntry entry = entries.nextElement(); String path = entry.getName(); if (path.endsWith(".class")) { String type = toJavaType(path); try { digest.put(type, digester.digest(ClassFileReader.read(jar, path))); } catch (ClassFormatException e) { // the class file is old for sure, according to jdt } } } } finally { jar.close(); } CACHE.put(file, digest); } return digest; }
/* * (non-Javadoc) * * @see * net.xeoh.plugins.base.impl.classpath.locator.AbstractClassPathLocation * #getInputStream(java.lang.String) */ @Override public InputStream getInputStream(String file) { try { final JarURLConnection connection = (JarURLConnection) new URI("jar:" + this.location + "!/").toURL().openConnection(); final JarFile jarFile = connection.getJarFile(); final Enumeration<JarEntry> entries = jarFile.entries(); while (entries.hasMoreElements()) { final JarEntry entry = entries.nextElement(); // We only search for class file entries if (entry.isDirectory()) continue; String name = entry.getName(); if (name.equals(file)) return jarFile.getInputStream(entry); } } catch (MalformedURLException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (URISyntaxException e) { e.printStackTrace(); } return null; }
public MoquiStart(ClassLoader parent, boolean loadWebInf) { super(parent); this.loadWebInf = loadWebInf; URL wrapperWarUrl = null; try { // get outer file (the war file) pd = getClass().getProtectionDomain(); CodeSource cs = pd.getCodeSource(); wrapperWarUrl = cs.getLocation(); outerFile = new JarFile(new File(wrapperWarUrl.toURI())); // allow for classes in the outerFile as well jarFileList.add(outerFile); Enumeration<JarEntry> jarEntries = outerFile.entries(); while (jarEntries.hasMoreElements()) { JarEntry je = jarEntries.nextElement(); if (je.isDirectory()) continue; // if we aren't loading the WEB-INF files and it is one, skip it if (!loadWebInf && je.getName().startsWith("WEB-INF")) continue; // get jars, can be anywhere in the file String jeName = je.getName().toLowerCase(); if (jeName.lastIndexOf(".jar") == jeName.length() - 4) { File file = createTempFile(je); jarFileList.add(new JarFile(file)); } } } catch (Exception e) { System.out.println("Error loading jars in war file [" + wrapperWarUrl + "]: " + e.toString()); } }
/** * Unpacks a jar file to a temporary directory that will be removed when the VM exits. * * @param jarfilePath the path of the jar to unpack * @return the path of the temporary directory */ private static String explodeJarToTempDir(File jarfilePath) { try { final Path jarfileDir = Files.createTempDirectory(jarfilePath.getName()); Runtime.getRuntime() .addShutdownHook( new Thread() { @Override public void run() { delete(jarfileDir.toFile()); } }); jarfileDir.toFile().deleteOnExit(); JarFile jarfile = new JarFile(jarfilePath); Enumeration<JarEntry> entries = jarfile.entries(); while (entries.hasMoreElements()) { JarEntry e = entries.nextElement(); if (!e.isDirectory()) { File path = new File(jarfileDir.toFile(), e.getName().replace('/', File.separatorChar)); File dir = path.getParentFile(); dir.mkdirs(); assert dir.exists(); Files.copy(jarfile.getInputStream(e), path.toPath()); } } return jarfileDir.toFile().getAbsolutePath(); } catch (IOException e) { throw new AssertionError(e); } }
public static Set<Class<?>> getClassFromJar(String jarPath) throws IOException { // read jar file JarFile jarFile = new JarFile(jarPath); Enumeration<JarEntry> jarEntries = jarFile.entries(); Set<Class<?>> classes = new LinkedHashSet<Class<?>>(); while (jarEntries.hasMoreElements()) { JarEntry jarEntry = jarEntries.nextElement(); String name = jarEntry.getName(); if (name.endsWith(".class")) { String className = name.replaceAll(".class", "").replaceAll("/", "."); Class<?> type = null; try { type = ClassLoader.getSystemClassLoader().loadClass(className); } catch (Error e) { } catch (ClassNotFoundException e) { } if (type != null) { classes.add(type); } } } jarFile.close(); return classes; }
private static void scanJar(File jarfile, File root, List<GenerationTarget> targets) { JarFile jar = null; try { jar = new JarFile(jarfile); } catch (IOException e1) { } if (jar == null) return; Enumeration<JarEntry> entries = jar.entries(); while (entries.hasMoreElements()) { JarEntry jarEntry = (JarEntry) entries.nextElement(); if (jarEntry.isDirectory()) { continue; } // expand .vm also but do not create a target. They are needed during generation. if (jarEntry.getName().endsWith("templates.xml") || jarEntry.getName().endsWith(".vm")) { File tempfile = null; try { tempfile = JarUtil.createTemporaryFile(jar, jarEntry); } catch (IOException e) { } if (tempfile != null && jarEntry.getName().endsWith("templates.xml")) { GenerationTarget target = createTarget(tempfile, root); if (target != null) { targets.add(target); } } } } } // end scanJar
private List<ResourceProxy> extractResourcesFromJar(File file) { List<ResourceProxy> jarResources = new LinkedList<ResourceProxy>(); try { JarFile jarPluginOrFeature = new JarFile(file); Enumeration<JarEntry> jarEntries = jarPluginOrFeature.entries(); JarEntry jarEntry = jarEntries.nextElement(); while (jarEntry != null) { String resourceEntryName = jarEntry.getName(); if (isValidResource(resourceEntryName)) { jarResources.add( new ResourceProxy( new File(file.getAbsolutePath() + File.separator + resourceEntryName), resourceEntryName)); } if (jarEntries.hasMoreElements()) { jarEntry = jarEntries.nextElement(); } else { jarEntry = null; } } } catch (Exception e) { System.out.println(e.getMessage()); } return jarResources; }
public static void unjar(File dest, String jar) throws IOException { dest.mkdirs(); JarFile jf = new JarFile(jar); try { Enumeration es = jf.entries(); while (es.hasMoreElements()) { JarEntry je = (JarEntry) es.nextElement(); String n = je.getName(); File f = new File(dest, n); if (je.isDirectory()) { f.mkdirs(); } else { if (f.exists()) { f.delete(); } else { f.getParentFile().mkdirs(); } InputStream is = jf.getInputStream(je); FileOutputStream os = new FileOutputStream(f); try { copyStream(is, os); } finally { os.close(); } } long time = je.getTime(); if (time != -1) f.setLastModified(time); } } finally { jf.close(); } }
public static List<String> listFiles(File archive, String[] extensions) throws IOException { if (!archive.exists() || !archive.isFile()) { throw new IllegalArgumentException(archive.getPath() + " is not a file"); } List<String> files = new ArrayList<String>(); JarFile file = new JarFile(archive); Enumeration<JarEntry> entries = file.entries(); while (entries.hasMoreElements()) { JarEntry entry = entries.nextElement(); String name = entry.getName(); for (String ext : extensions) { if (name.endsWith(ext)) { if (CLASS_EXT.equals(ext)) { files.add(name.replace("/", ".")); } else { files.add(name); } break; } } } return files; }
public static void copyJarResourcesRecursively(File destination, JarURLConnection jarConnection) { JarFile jarFile; try { jarFile = jarConnection.getJarFile(); } catch (Exception e) { _.die("Failed to get jar file)"); return; } Enumeration<JarEntry> em = jarFile.entries(); while (em.hasMoreElements()) { JarEntry entry = em.nextElement(); if (entry.getName().startsWith(jarConnection.getEntryName())) { String fileName = StringUtils.removeStart(entry.getName(), jarConnection.getEntryName()); if (!fileName.equals("/")) { // exclude the directory InputStream entryInputStream = null; try { entryInputStream = jarFile.getInputStream(entry); FileUtils.copyInputStreamToFile(entryInputStream, new File(destination, fileName)); } catch (Exception e) { die("Failed to copy resource: " + fileName); } finally { if (entryInputStream != null) { try { entryInputStream.close(); } catch (Exception e) { } } } } } } }
public static List<JarFileItem> listJarFile(String jarPath, JarFileFilter filter, String ext) throws IOException { List<JarFileItem> result = new ArrayList<JarFileItem>(); JarFile jar = null; try { jar = new JarFile(jarPath); Enumeration<JarEntry> en = jar.entries(); while (en.hasMoreElements()) { JarEntry entry = en.nextElement(); if (entry.isDirectory() || !entry.getName().endsWith("." + ext)) { continue; } if (filter == null) { continue; } else if (filter.accept(entry)) { result.add(new JarFileItem(jarPath, entry.getName())); } } jar.close(); } catch (IOException e) { log.error(e, e); throw e; } return result; }
/** Load all the classes in the current jar file so it can be overwritten */ private void loadAllClasses() { LWC lwc = LWC.getInstance(); try { // Load the jar JarFile jar = new JarFile(lwc.getPlugin().getFile()); // Walk through all of the entries Enumeration<JarEntry> enumeration = jar.entries(); while (enumeration.hasMoreElements()) { JarEntry entry = enumeration.nextElement(); String name = entry.getName(); // is it a class file? if (name.endsWith(".class")) { // convert to package String path = name.replaceAll("/", "."); path = path.substring(0, path.length() - ".class".length()); // Load it this.getClass().getClassLoader().loadClass(path); } } } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } }
public boolean isDirectory(URI uri) { try { if (uri.getPath() != null && uri.getPath().endsWith(".jar!")) { // if the uri is the root of a jar, and it ends with a !, it should be considered a // directory return true; } String jar = getJar(uri); String path = getPath(uri); if (!path.endsWith("/")) { path = path + "/"; } JarFile jarFile = new JarFile(jar); try { JarEntry jarEntry = jarFile.getJarEntry(path); if (jarEntry != null && jarEntry.isDirectory()) { return true; } // maybe the path is not in the jar as a seperate entry, but there are files in the path Enumeration<JarEntry> entries = jarFile.entries(); while (entries.hasMoreElements()) { if (entries.nextElement().getName().startsWith(path)) { return true; } } return false; } finally { jarFile.close(); } } catch (IOException e) { return false; } }
/** * 通过流将jar中的一个文件的内容输出 * * @param jarPaht jar文件存放的位置 * @param filePaht 指定的文件目录 */ private void getStream(String jarPath, String filePath) { JarFile jarFile = null; try { jarFile = new JarFile(jarPath); } catch (IOException e1) { e1.printStackTrace(); } Enumeration<JarEntry> ee = jarFile.entries(); List<JarEntry> jarEntryList = new ArrayList<JarEntry>(); while (ee.hasMoreElements()) { JarEntry entry = ee.nextElement(); // 过滤我们出满足我们需求的东西,这里的fileName是指向一个具体的文件的对象的完整包路径,比如com/mypackage/test.txt if (entry.getName().startsWith(filePath)) { jarEntryList.add(entry); } } try { InputStream in = jarFile.getInputStream(jarEntryList.get(0)); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String s = ""; while ((s = br.readLine()) != null) { System.out.println(s); } } catch (IOException e) { e.printStackTrace(); } }
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; }
private void findPackagesInJar(String packageRoot, Set<String> list, File jar) throws IOException { Set<String> paths = new HashSet<String>(); JarFile jf = null; try { jf = new JarFile(jar); String packagePath = packageRoot.replaceAll("\\.", "/"); Enumeration<JarEntry> entries = jf.entries(); while (entries.hasMoreElements()) { JarEntry entry = entries.nextElement(); if (entry.getName().startsWith(packagePath)) { String match = entry.getName().substring(0, entry.getName().lastIndexOf("/")); paths.add(match.replaceAll("/", "\\.")); } } list.addAll(paths); } finally { try { if (jf != null) { jf.close(); } } catch (IOException e) { } } }
/** * Unpack files from jar by path * * @param jar jar to unpack * @param path path in jar to be unpacked * @param outputDirectory unpack to this directory * @throws IOException */ private static void unpackReport(JarFile jar, String path, File outputDirectory) throws IOException { Enumeration entries = jar.entries(); while (entries.hasMoreElements()) { JarEntry file = (JarEntry) entries.nextElement(); if (file.getName().startsWith(path)) { System.out.println("copy " + file.getName()); String newFileName = file.getName().replace(path, ""); if (newFileName.length() > 0) { String newFilePath = outputDirectory + newFileName; System.out.println("copy to " + newFilePath); File f = new File(newFilePath); if (f.exists()) { continue; } if (file.isDirectory() && !f.mkdirs()) { throw new RuntimeException(String.format("Can't create directory <%s>", f.getPath())); } if (file.isDirectory()) { continue; } copy(jar, file, f); } } } }
public static LinkedHashMap readJarFileEntries(File jarFile) throws Exception { LinkedHashMap entries = new LinkedHashMap(); JarFile jarFileWrapper = null; if (jarFile != null) { logger.debug("Reading jar entries from " + jarFile.getAbsolutePath()); try { jarFileWrapper = new JarFile(jarFile); Enumeration iter = jarFileWrapper.entries(); while (iter.hasMoreElements()) { ZipEntry zipEntry = (ZipEntry) iter.nextElement(); InputStream entryStream = jarFileWrapper.getInputStream(zipEntry); ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream(); try { IOUtils.copy(entryStream, byteArrayStream); entries.put(zipEntry.getName(), byteArrayStream.toByteArray()); logger.debug( "Read jar entry " + zipEntry.getName() + " from " + jarFile.getAbsolutePath()); } finally { byteArrayStream.close(); } } } finally { if (jarFileWrapper != null) { try { jarFileWrapper.close(); } catch (Exception ignore) { logger.debug(ignore); } } } } return entries; }
/** * Lists all entries for the given JAR. * * @param uri * @return . */ public static Collection<String> listAllEntriesFor(URI uri) { final Collection<String> rval = new ArrayList<String>(); try { final JarURLConnection connection = (JarURLConnection) new URI("jar:" + uri + "!/").toURL().openConnection(); final JarFile jarFile = connection.getJarFile(); final Enumeration<JarEntry> entries = jarFile.entries(); while (entries.hasMoreElements()) { final JarEntry entry = entries.nextElement(); // We only search for class file entries if (entry.isDirectory()) continue; String name = entry.getName(); rval.add(name); } } catch (MalformedURLException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (URISyntaxException e) { e.printStackTrace(); } return rval; }
public static void copyJarContents(String prefix, String pathToJar) throws IOException { LOG.info("Copying jar (location: " + pathToJar + ") to prefix " + prefix); JarFile jar = null; jar = new JarFile(pathToJar); Enumeration<JarEntry> enumr = jar.entries(); byte[] bytes = new byte[1024]; while (enumr.hasMoreElements()) { JarEntry entry = enumr.nextElement(); if (entry.getName().startsWith(prefix)) { if (entry.isDirectory()) { File cr = new File(entry.getName()); cr.mkdirs(); continue; } InputStream inStream = jar.getInputStream(entry); File outFile = new File(entry.getName()); if (outFile.exists()) { throw new RuntimeException("File unexpectedly exists"); } FileOutputStream outputStream = new FileOutputStream(outFile); int read = 0; while ((read = inStream.read(bytes)) != -1) { outputStream.write(bytes, 0, read); } inStream.close(); outputStream.close(); } } jar.close(); }
protected Set<Class> processJarUrl(URL url, String basepath, Class clazz) throws IOException { Set<Class> set = new HashSet<Class>(); String path = url.getFile().substring(5, url.getFile().indexOf("!")); JarFile jar = new JarFile(path); for (Enumeration entries = jar.entries(); entries.hasMoreElements(); ) { JarEntry entry = (JarEntry) entries.nextElement(); if (entry.getName().startsWith(basepath) && entry.getName().endsWith(".class")) { try { String name = entry.getName(); // Ignore anonymous // TODO RM what about the other anonymous classes like $2, $3 ? if (name.contains("$1")) { continue; } URL classURL = classLoader.getResource(name); ClassReader reader = new ClassReader(classURL.openStream()); ClassScanner visitor = getScanner(clazz); reader.accept(visitor, 0); if (visitor.isMatch()) { Class c = loadClass(visitor.getClassName()); if (c != null) { set.add(c); } } } catch (Exception e) { if (logger.isDebugEnabled()) { Throwable t = ExceptionHelper.getRootException(e); logger.debug(String.format("%s: caused by: %s", e.toString(), t.toString())); } } } } return set; }
private void checkShading() { if (logLevel.ordinal() < LogLevel.WARN.ordinal()) { // Do not waste time if no logging. return; } Map<String, JarFileInfo> hm = new HashMap<String, JarFileInfo>(); for (JarFileInfo jarFileInfo : lstJarFile) { JarFile jarFile = jarFileInfo.jarFile; Enumeration<JarEntry> en = jarFile.entries(); while (en.hasMoreElements()) { JarEntry je = en.nextElement(); if (je.isDirectory()) { continue; } String sEntry = je.getName(); // "Some.txt" or "abc/xyz/Some.txt" if ("META-INF/MANIFEST.MF".equals(sEntry)) { continue; } JarFileInfo jar = hm.get(sEntry); if (jar == null) { hm.put(sEntry, jarFileInfo); } else { logWarn( LogArea.JAR, "ENTRY %s IN %s SHADES %s", sEntry, jar.simpleName, jarFileInfo.simpleName); } } } }
protected boolean jarUpToDate(String source, String target, boolean verbose) { JarFile targetJar, sourceJar; try { targetJar = new JarFile(target); } catch (IOException e) { if (verbose) err.println(target + " does not exist yet"); return false; } try { sourceJar = new JarFile(source); } catch (IOException e) { return true; } for (JarEntry entry : Collections.list(sourceJar.entries())) { JarEntry other = (JarEntry) targetJar.getEntry(entry.getName()); if (other == null) { if (verbose) err.println(target + " lacks the file " + entry.getName()); return false; } if (entry.getTime() > other.getTime()) { if (verbose) err.println(target + " is not " + "up-to-date because of " + entry.getName()); return false; } } try { targetJar.close(); sourceJar.close(); } catch (IOException e) { } return true; }
private static void readJarEntries(URL location, String basePath, Map<String, URL> resources) throws IOException { JarURLConnection conn = (JarURLConnection) location.openConnection(); JarFile jarfile = null; jarfile = conn.getJarFile(); Enumeration<JarEntry> entries = jarfile.entries(); while (entries != null && entries.hasMoreElements()) { JarEntry entry = entries.nextElement(); String name = entry.getName(); if (entry.isDirectory() || !name.startsWith(basePath) || name.length() == basePath.length()) { continue; } name = name.substring(basePath.length()); if (name.contains("/")) { continue; } URL resource = new URL(location, name); resources.put(name, resource); } }