/**
* Load the policies from the specified file. Also checks that the policies are correctly signed.
*/
private static void loadPolicies(
File jarPathName, CryptoPermissions defaultPolicy, CryptoPermissions exemptPolicy)
throws Exception {
JarFile jf = new JarFile(jarPathName);
Enumeration<JarEntry> entries = jf.entries();
while (entries.hasMoreElements()) {
JarEntry je = entries.nextElement();
InputStream is = null;
try {
if (je.getName().startsWith("default_")) {
is = jf.getInputStream(je);
defaultPolicy.load(is);
} else if (je.getName().startsWith("exempt_")) {
is = jf.getInputStream(je);
exemptPolicy.load(is);
} else {
continue;
}
} finally {
if (is != null) {
is.close();
}
}
// Enforce the signer restraint, i.e. signer of JCE framework
// jar should also be the signer of the two jurisdiction policy
// jar files.
JarVerifier.verifyPolicySigned(je.getCertificates());
}
// Close and nullify the JarFile reference to help GC.
jf.close();
jf = null;
}
@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();
}
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;
}
/** @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
}
}
/**
* Create an OAR
*
* @param url The URL for the OperationalString Archive
* @throws OARException If the manifest cannot be read
* @throws IllegalArgumentException If the url is null
*/
public OAR(URL url) throws OARException {
if (url == null) throw new IllegalArgumentException("url cannot be null");
JarFile jar = null;
try {
URL oarURL;
if (url.getProtocol().equals("jar")) {
oarURL = url;
} else {
StringBuilder sb = new StringBuilder();
sb.append("jar:").append(url.toExternalForm()).append("!/");
oarURL = new URL(sb.toString());
}
JarURLConnection conn = (JarURLConnection) oarURL.openConnection();
jar = conn.getJarFile();
Manifest man = jar.getManifest();
getManifestAttributes(man);
loadRepositories(jar);
jar.close();
this.url = url;
} catch (Exception e) {
throw new OARException("Problem processing " + url.toExternalForm(), e);
} finally {
try {
if (jar != null) jar.close();
} 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;
}
public void process(File f) throws Exception {
if (f.isDirectory()) {
File[] files =
f.listFiles(
new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.matches(FILE_PATTERN);
}
});
for (File ff : files) {
byte[] bindingBytes = Files.toByteArray(ff);
this.addCurrentBinding(bindingBytes, ff.getName(), "file:" + ff.getAbsolutePath());
}
} else {
String digest = new BigInteger(Files.getDigest(f, Digest.MD5.get())).abs().toString(16);
CURRENT_PROPS.put(BINDING_CACHE_JAR_PREFIX + f.getName(), digest);
final JarFile jar = new JarFile(f);
final List<JarEntry> jarList = Collections.list(jar.entries());
for (final JarEntry j : jarList) {
try {
if (j.getName().matches(FILE_PATTERN)) {
byte[] bindingBytes = ByteStreams.toByteArray(jar.getInputStream(j));
String bindingName = j.getName();
String bindingFullPath = "jar:file:" + f.getAbsolutePath() + "!/" + bindingName;
this.addCurrentBinding(bindingBytes, bindingName, bindingFullPath);
} else if (j.getName().matches(".*\\.class.{0,1}")) {
final String classGuess =
j.getName().replaceAll("/", ".").replaceAll("\\.class.{0,1}", "");
final Class candidate = ClassLoader.getSystemClassLoader().loadClass(classGuess);
if (MSG_BASE_CLASS.isAssignableFrom(candidate)
|| MSG_DATA_CLASS.isAssignableFrom(candidate)) {
InputSupplier<InputStream> classSupplier =
Resources.newInputStreamSupplier(ClassLoader.getSystemResource(j.getName()));
File destClassFile = SubDirectory.CLASSCACHE.getChildFile(j.getName());
if (!destClassFile.exists()) {
Files.createParentDirs(destClassFile);
Files.copy(classSupplier, destClassFile);
Logs.extreme()
.debug("Caching: " + j.getName() + " => " + destClassFile.getAbsolutePath());
}
BINDING_CLASS_MAP.putIfAbsent(classGuess, candidate);
}
}
} catch (RuntimeException ex) {
LOG.error(ex, ex);
jar.close();
throw ex;
}
}
jar.close();
}
}
private boolean isNotSignedJar(File file) throws IOException {
JarFile jar = new JarFile(file);
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
if (entry.getName().startsWith("META-INF") && entry.getName().endsWith(".SF")) {
jar.close();
return false;
}
}
jar.close();
return true;
}
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;
}
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) {
}
}
}
/** Copies all entries under the path specified by the jarPath to the JarOutputStream. */
private void copyJarEntries(URL jarPath, Set<String> entries, JarOutputStream jarOut)
throws IOException {
String spec = new URL(jarPath.getFile()).getFile();
String entryRoot = spec.substring(spec.lastIndexOf('!') + 1);
if (entryRoot.charAt(0) == '/') {
entryRoot = entryRoot.substring(1);
}
JarFile jarFile = new JarFile(spec.substring(0, spec.lastIndexOf('!')));
try {
Enumeration<JarEntry> jarEntries = jarFile.entries();
while (jarEntries.hasMoreElements()) {
JarEntry jarEntry = jarEntries.nextElement();
String name = jarEntry.getName();
if (name == null || !name.startsWith(entryRoot)) {
continue;
}
if (entries.add(name)) {
jarOut.putNextEntry(new JarEntry(jarEntry));
ByteStreams.copy(jarFile.getInputStream(jarEntry), jarOut);
jarOut.closeEntry();
}
}
} finally {
jarFile.close();
}
}
private void _dovV() throws IOException {
if (z_aString.endsWith(".jar")) {
try {
JarFile jarfile = new JarFile(z_aString, false);
for (Enumeration enumeration = jarfile.entries(); enumeration.hasMoreElements(); ) {
ZipEntry zipentry = (ZipEntry) enumeration.nextElement();
String s = zipentry.getName();
if (s.endsWith(".class")) {
InputStream inputstream = jarfile.getInputStream(zipentry);
_aInputStreamStringV(inputstream, (int) zipentry.getSize(), s);
inputstream.close();
}
}
jarfile.close();
z_newZ = true;
} catch (IOException ioexception) {
throw new IOException(ioexception.getMessage() + ": " + z_aString);
}
} else {
File file = new File(z_aString);
FileInputStream fileinputstream = new FileInputStream(file);
_aInputStreamStringV(fileinputstream, (int) file.length(), z_aString);
fileinputstream.close();
}
}
public void run() {
// run this first, ie shutdown the container before closing jarFiles to avoid errors with
// classes missing
if (callMethod != null) {
try {
callMethod.invoke(callObject);
} catch (Exception e) {
System.out.println("Error in shutdown: " + e.toString());
}
}
// give things a couple seconds to destroy; this way of running is mostly for dev/test where
// this should be sufficient
try {
synchronized (this) {
this.wait(2000);
}
} catch (Exception e) {
System.out.println("Shutdown wait interrupted");
}
System.out.println(
"========== Shutting down Moqui Executable (closing jars, etc) ==========");
// close all jarFiles so they will "deleteOnExit"
for (JarFile jarFile : jarFileList) {
try {
jarFile.close();
} catch (IOException e) {
System.out.println("Error closing jar [" + jarFile + "]: " + e.toString());
}
}
}
private Map<String, URLClassLoader> createClassLoaderMap(File dir, String[] files)
throws IOException {
Map<String, URLClassLoader> m = new TreeMap<String, URLClassLoader>();
for (int i = 0; i < files.length; i++) {
File moduleJar = new File(dir, files[i]);
Manifest manifest;
JarFile jar = new JarFile(moduleJar);
try {
manifest = jar.getManifest();
} finally {
jar.close();
}
if (manifest == null) {
log(moduleJar + " has no manifest", Project.MSG_WARN);
continue;
}
String codename = JarWithModuleAttributes.extractCodeName(manifest.getMainAttributes());
if (codename == null) {
log(moduleJar + " is not a module", Project.MSG_WARN);
continue;
}
m.put(
codename.replaceFirst("/[0-9]+$", ""),
new URLClassLoader(
new URL[] {moduleJar.toURI().toURL()},
ClassLoader.getSystemClassLoader().getParent(),
new NbDocsStreamHandler.Factory()));
}
return m;
}
private Class<?> loadClassFromJar(String className) throws ClassNotFoundException {
Class<?> result = null;
result = classes.get(className); // checks in cached classes
if (result != null) {
return result;
}
try {
final JarFile jar = new JarFile(jarFile);
try {
final String path = className.replace('.', '/');
final JarEntry entry = jar.getJarEntry(path + ".class");
final InputStream in = jar.getInputStream(entry);
try {
final byte[] classBytes = IOUtils.toByteArray(in);
result = defineClass(className, classBytes, 0, classBytes.length, null);
classes.put(className, result);
return result;
} finally {
in.close();
}
} finally {
jar.close();
}
} catch (Exception e) {
throw new ClassNotFoundException("Can't find class " + className + " in jar " + jarFile, e);
}
}
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();
}
public static void extractFileFromJar(String archive, List<String> filenames, String destination)
throws IOException {
// open the jar (zip) file
JarFile jar = new JarFile(archive);
// parse the entries
Enumeration<JarEntry> entryEnum = jar.entries();
while (entryEnum.hasMoreElements()) {
JarEntry file = entryEnum.nextElement();
if (filenames.contains(file.getName())) {
// match found
File f = new File(destination + File.separator + file.getName());
InputStream in = jar.getInputStream(file);
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(f));
byte[] byteBuffer = new byte[1024];
int numRead;
while ((numRead = in.read(byteBuffer)) != -1) {
out.write(byteBuffer, 0, numRead);
}
in.close();
out.close();
}
}
jar.close();
}
JarFile get(URL url, boolean useCaches) throws IOException {
JarFile result = null;
JarFile local_result = null;
if (useCaches) {
synchronized (this) {
result = getCachedJarFile(url);
}
if (result == null) {
local_result = URLJarFile.getJarFile(url);
synchronized (this) {
result = getCachedJarFile(url);
if (result == null) {
fileCache.put(url, local_result);
urlCache.put(local_result, url);
result = local_result;
} else {
if (local_result != null) {
local_result.close();
}
}
}
}
} else {
result = URLJarFile.getJarFile(url);
}
if (result == null) throw new FileNotFoundException(url.toString());
return result;
}
public static String generateJpaDependencies(
final URLClassLoader classLoader, final URL jarUrl, final UmlOptions options) {
JpaDependencyDiagramModel dependencyModel = new JpaDependencyDiagramModel();
try {
List<String> classes = new ArrayList<String>();
final JarFile jarFile = new JarFile(jarUrl.getFile());
if (jarFile != null) {
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry jarEntry = entries.nextElement();
String jarEntryName = jarEntry.getName();
if (jarEntryName.endsWith(".class") && !jarEntryName.contains("Test")) {
String className = jarEntryName.replace('/', '.').replace(".class", "");
classes.add(className);
}
}
jarFile.close();
}
// Parse all the classes for UML
extractJpaClasses(
classLoader,
classes,
dependencyModel,
options.getIncludePatterns(),
options.getExcludePatterns());
} catch (Exception e) {
e.printStackTrace();
}
return dependencyModel.getUml();
}
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;
}
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;
}
}
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;
}
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 boolean pack200(final File sourceFile, final File targetFile) throws IOException {
JarFile jarFile = new JarFile(sourceFile);
try {
if (isSigned(jarFile)) {
return false;
}
try {
String pack200Executable =
new File(System.getProperty("java.home"), "bin/pack200" + (isWindows() ? ".exe" : ""))
.getAbsolutePath();
ProcessBuilder pb =
new ProcessBuilder(
pack200Executable, targetFile.getAbsolutePath(), sourceFile.getAbsolutePath());
pb.directory(sourceFile.getParentFile());
int result;
Process process = pb.start();
result = process.waitFor();
process.destroy();
return result == 0;
} catch (InterruptedException e) {
return false;
} finally {
if (targetFile.exists()) {
targetFile.setLastModified(sourceFile.lastModified());
}
}
} finally {
jarFile.close();
}
}
/**
* Return the directories in a jar URI, relative to the jar entry, if any. . Jar URLS have several
* forms, the most common being: <code>jar:file:///foo/bar.jar/!/bif/baz</code>, which means that
* the jar file /foo/bar.jar has a directory or file name bif/baz. If such a file is passed to
* this method, then any directories in the jar file directory bif/baz will be returned.
*
* @param jarURL The Jar URL for which we are to look for directories.
* @return An list of Strings that name the directories
* @exception IOException If opening the connection fails or if getting the jar file from the
* connection fails
*/
public static List<String> jarURLDirectories(URL jarURL) throws IOException {
List<String> directories = new LinkedList<String>();
JarURLConnection connection = (JarURLConnection) (jarURL.openConnection());
String jarEntryName = connection.getEntryName();
if (jarEntryName.endsWith("/")) {
jarEntryName = jarEntryName.substring(0, jarEntryName.length() - 1);
}
JarFile jarFile = connection.getJarFile();
Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
String name = entry.getName();
int jarEntryIndex = name.indexOf(jarEntryName + "/");
int jarEntrySlashIndex = jarEntryIndex + jarEntryName.length() + 1;
int nextSlashIndex = name.indexOf("/", jarEntrySlashIndex);
int lastSlashIndex = name.indexOf("/", jarEntrySlashIndex);
if (jarEntryIndex > -1
&& jarEntrySlashIndex > -1
&& nextSlashIndex > -1
&& nextSlashIndex == lastSlashIndex
&& nextSlashIndex == name.length() - 1
&& entry.isDirectory()) {
directories.add(name);
}
}
jarFile.close();
return directories;
}
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();
}
}
@Test
public void getEntryTime() throws Exception {
java.util.jar.JarFile jdkJarFile = new java.util.jar.JarFile(this.rootJarFile);
assertThat(this.jarFile.getEntry("META-INF/MANIFEST.MF").getTime())
.isEqualTo(jdkJarFile.getEntry("META-INF/MANIFEST.MF").getTime());
jdkJarFile.close();
}
public boolean canHandle(File artifact) {
JarFile jar = null;
try {
// Handle OSGi bundles with the default deployer
String name = artifact.getName();
if (!artifact.canRead()
|| name.endsWith(".txt")
|| name.endsWith(".xml")
|| name.endsWith(".properties")
|| name.endsWith(".cfg")) {
// that's file type which is not supported as bundle and avoid
// exception in the log
return false;
}
jar = new JarFile(artifact);
Manifest m = jar.getManifest();
if (m != null
&& m.getMainAttributes().getValue(new Attributes.Name("Bundle-SymbolicName")) != null) {
return true;
}
} catch (Exception e) {
// Ignore
} finally {
if (jar != null) {
try {
jar.close();
} catch (IOException e) {
// Ignore
}
}
}
return false;
}
/**
* Gets the manifest.
*
* @param jarName the jar name
* @param lineSeparator the line separator
* @return the manifest
*/
public String getManifest(final String jarName, final String lineSeparator) {
StringBuilder sb = new StringBuilder();
String lib = getLibraryPathName(jarBaseName);
if (!isEmpty(lib)) {
lib = lib.replaceAll("file:", "");
final File[] files = new File(lib).listFiles(new FilenameFilterJar());
if ((files != null) && (files.length > 0)) {
for (File jar : files) {
if (jar.getName().matches(".*" + jarName + ".*") && jar.exists()) {
try {
JarFile jarFile = new JarFile(jar);
final JarEntry entry = jarFile.getJarEntry("META-INF/MANIFEST.MF");
final InputStream is = jarFile.getInputStream(entry);
final BufferedReader br = new BufferedReader(new InputStreamReader(is));
String line;
while ((line = br.readLine()) != null) {
sb.append(lineSeparator).append(line);
}
if (jarFile != null) {
jarFile.close();
jarFile = null;
}
} catch (final Exception e) {
}
}
}
}
}
return sb.toString();
}
/**
* Scan manifest classpath entries of a jar, adding all found jar files to the set of manifest
* jars.
*/
private static void _recursiveGetManifestJars(File jarFile, Set<File> manifestJars) {
if (!jarFile.exists()) return;
JarFile jar = null;
try {
jar = new JarFile(jarFile);
Manifest mf = jar.getManifest();
if (mf == null) return;
String classpath = mf.getMainAttributes().getValue(Attributes.Name.CLASS_PATH);
if (classpath == null) return;
// We've got some entries
File parent = jarFile.getParentFile();
String[] rgPaths = classpath.split(" "); // $NON-NLS-1$
for (String path : rgPaths) {
if (path.length() == 0) continue;
File file = new File(parent, path);
// If we haven't seen this, we need to get its manifest jars as well
if (!manifestJars.contains(file) && file.exists()) {
manifestJars.add(file);
_recursiveGetManifestJars(file, manifestJars);
}
}
} catch (IOException ioe) {
} finally {
if (jar != null) {
try {
jar.close();
} catch (IOException ioe) {
}
}
}
}
