private static List<Class<?>> getClassesInJarFile(String jar, String packageName)
throws IOException {
List<Class<?>> classes = new ArrayList<Class<?>>();
JarInputStream jarFile = null;
jarFile = new JarInputStream(new FileInputStream(jar));
JarEntry jarEntry;
while ((jarEntry = jarFile.getNextJarEntry()) != null) {
if (jarEntry != null) {
String className = jarEntry.getName();
if (className.endsWith(".class")) {
className =
className.substring(0, className.length() - ".class".length()).replace('/', '.');
if (className.startsWith(packageName)) {
// CHECKSTYLE:OFF
try {
classes.add(Class.forName(className.replace('/', '.')));
} catch (Throwable e) {
// do nothing. this class hasn't been found by the loader, and we don't care.
}
// CHECKSTYLE:ON
}
}
}
}
closeJarFile(jarFile);
return classes;
}
private Hashtable<String, String> getJarManifestAttributes(String path) {
Hashtable<String, String> h = new Hashtable<String, String>();
JarInputStream jis = null;
try {
cp.appendln(Color.black, "Looking for " + path);
InputStream is = getClass().getResourceAsStream(path);
if (is == null) {
if (!path.endsWith("/MIRC.jar")) {
cp.appendln(Color.red, "...could not find it.");
} else {
cp.appendln(
Color.black,
"...could not find it. [OK, this is a " + programName + " installation]");
}
return null;
}
jis = new JarInputStream(is);
Manifest manifest = jis.getManifest();
h = getManifestAttributes(manifest);
} catch (Exception ex) {
ex.printStackTrace();
}
if (jis != null) {
try {
jis.close();
} catch (Exception ignore) {
}
}
return h;
}
public static boolean extractJarDir(String jarfile, String outfile) throws Exception {
long filesize = new File(jarfile).length();
JarInputStream jar = new JarInputStream(new FileInputStream(jarfile));
// while (true) {
// JarEntry jarentry = (JarEntry)jar.getNextJarEntry();
// if (jarentry==null) break;
// String maindir = jarentry.getName();
// // get rid of "./" and "/" prefix
// if (maindir.startsWith("."))
// maindir = maindir.substring(1);
// if (maindir.startsWith(File.separator))
// maindir = maindir.substring(1);
// // Find manifest
// System.out.println(maindir);
// if (maindir.equals("META-INF/MANIFEST.MF")) {
// java.io.InputStream ins = jar;
java.io.FileOutputStream outs = new java.io.FileOutputStream(outfile);
Manifest man = jar.getManifest();
if (man == null) return false;
man.write(outs);
byte[] buf = ("MIDlet-Jar-Size: " + filesize).getBytes();
outs.write(buf, 0, buf.length);
outs.close();
// // copy buffered (is a lot faster than one byte at a time)
// byte[] buf = new byte[8192];
// int total_bytes=0;
// while (true) {
// //outs.write(ins.read());
// int len = ins.read(buf);
// if (len < 0) break;
// outs.write(buf,0,len);
// total_bytes += len;
// }
// buf = ("MIDlet-Jar-Size: "+total_bytes).getBytes();
// outs.write(buf,0,buf.length);
// outs.close();
// //ins.close();
// }
// }
// return false;
// remove empty lines from the generated jad which may have been
// introduced by manifest write.
// some systems have trouble with empty lines
List<String> lines = new ArrayList<String>();
BufferedReader in = new BufferedReader(new FileReader(outfile));
while (true) {
String line = in.readLine();
if (line == null) break;
lines.add(line);
}
in.close();
PrintWriter outp = new PrintWriter(outfile);
for (String s : lines) {
if (s.trim().equals("")) continue;
outp.println(s);
}
outp.close();
return true;
}
public static void unjar(File dest, InputStream is) throws IOException {
dest.mkdirs();
JarInputStream jis = new JarInputStream(is);
try {
while (true) {
JarEntry je = jis.getNextJarEntry();
if (je == null) break;
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();
}
FileOutputStream os = new FileOutputStream(f);
try {
copyStream(jis, os);
} finally {
os.close();
}
}
long time = je.getTime();
if (time != -1) f.setLastModified(time);
}
} finally {
jis.close();
}
}
public synchronized InputStream getInputStream(ZipEntry ze) throws IOException {
if (ze == null) return null;
try {
JarInputStream is = new JarInputStream(super.getInputStream(wrappedJarFile));
if (filename.equals(MANIFEST_NAME)) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
is.getManifest().write(baos);
return new ByteArrayInputStream(baos.toByteArray());
}
try {
JarEntry entry;
while ((entry = is.getNextJarEntry()) != null) {
if (entry.getName().equals(ze.getName())) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copy(is, baos);
return new ByteArrayInputStream(baos.toByteArray());
}
}
} finally {
is.close();
}
} catch (IOException e) {
throw new RuntimeException("Undefined Error", e);
}
throw new RuntimeException("Entry not found : " + ze.getName());
}
public static List getClasseNamesInPackage(String jarName, String packageName) {
ArrayList classes = new ArrayList();
packageName = packageName.replaceAll("\\.", "/");
if (debug) System.out.println("Jar " + jarName + " looking for " + packageName);
try {
JarInputStream jarFile = new JarInputStream(new FileInputStream(jarName));
JarEntry jarEntry;
while (true) {
jarEntry = jarFile.getNextJarEntry();
if (jarEntry == null) {
break;
}
if ((jarEntry.getName().startsWith(packageName))
&& (jarEntry.getName().endsWith(".class"))) {
if (debug) System.out.println("Found " + jarEntry.getName().replaceAll("/", "\\."));
classes.add(jarEntry.getName().replaceAll("/", "\\."));
}
}
} catch (Exception e) {
e.printStackTrace();
}
return classes;
}
/**
* @see http://stackoverflow.com/questions/346811/listing-the-files-in-a-
* directory-of-the-current-jar-file
*/
private static Class<?>[] getClassesFromJARFile(URI jar, String packageName)
throws ClassNotFoundException {
ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
JarInputStream jarFile = null;
try {
jarFile = new JarInputStream(new FileInputStream(new File(jar)));
// search all entries
for (JarEntry jarEntry; (jarEntry = jarFile.getNextJarEntry()) != null; ) {
// match with packet name
String className = jarEntry.getName();
if (className.endsWith(".class")) {
className =
className.substring(0, className.length() - ".class".length()).replace('/', '.');
if (className.startsWith(packageName)) classes.add(Class.forName(className));
}
}
} catch (IOException ex) {
throw new ClassNotFoundException(ex.getMessage());
}
// try to close in any case
try {
jarFile.close();
} catch (IOException ex) {
}
return classes.toArray(new Class<?>[classes.size()]);
}
public static MapBackedClassLoader createClassLoader(JarInputStream jis) {
ClassLoader parentClassLoader = Thread.currentThread().getContextClassLoader();
final ClassLoader p = parentClassLoader;
MapBackedClassLoader loader =
AccessController.doPrivileged(
new PrivilegedAction<MapBackedClassLoader>() {
public MapBackedClassLoader run() {
return new MapBackedClassLoader(p);
}
});
try {
JarEntry entry = null;
byte[] buf = new byte[1024];
int len = 0;
while ((entry = jis.getNextJarEntry()) != null) {
if (!entry.isDirectory() && !entry.getName().endsWith(".java")) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
while ((len = jis.read(buf)) >= 0) {
out.write(buf, 0, len);
}
loader.addResource(entry.getName(), out.toByteArray());
}
}
} catch (IOException e) {
fail("failed to read the jar");
}
return loader;
}
private static List<Class<?>> getClasses(File jarFile)
throws IOException, ClassNotFoundException {
List<Class<?>> classes = new ArrayList<Class<?>>();
JarInputStream jarStream = new JarInputStream(new FileInputStream(jarFile));
try {
JarEntry jarEntry = jarStream.getNextJarEntry();
while (jarEntry != null) {
try {
String fileName = jarEntry.getName();
if (isPossibleTestClass(fileName)) {
String className = fileName.replaceAll("/", "\\.");
className = className.substring(0, className.length() - ".class".length());
// System.out.println("Found possible test class: '" + className + "'");
Class<?> testClass = Class.forName(className);
classes.add(testClass);
}
} finally {
jarStream.closeEntry();
}
jarEntry = jarStream.getNextJarEntry();
}
} finally {
jarStream.close();
}
return classes;
}
List<ResourceProxy> handleJarResource(File jarResource) throws Exception {
List<ResourceProxy> jarResources = new ArrayList<ResourceProxy>();
String frontRelativePath = jarResource.getName();
frontRelativePath = frontRelativePath.replaceAll(JAR_EXTENSION, ""); // $NON-NLS-1$
frontRelativePath += JAR_RESOURCE_SUFFIX;
InputStream input = new FileInputStream(jarResource);
JarInputStream zipInput = new JarInputStream(input);
ZipEntry zipEntry = zipInput.getNextEntry();
while (zipEntry != null) {
String resourceEntryName = zipEntry.getName();
resourceEntryName = resourceEntryName.replace("\\", SLASH); // $NON-NLS-1$
if (isValidResource(resourceEntryName) && (!resourceEntryName.contains(META_INF_DIR_NAME))) {
String relativePath = frontRelativePath + File.separator + resourceEntryName;
relativePath = relativePath.replace("\\", File.separator); // $NON-NLS-1$
relativePath = relativePath.replace(SLASH, File.separator);
jarResources.add(
new ResourceProxy(
new File(jarResource.getAbsolutePath() + SLASH + resourceEntryName),
relativePath)); //$NON-NLS-1$ //$NON-NLS-2$
}
zipEntry = zipInput.getNextEntry();
}
return jarResources;
}
private List<String> getClassNames(File jarFile) {
ArrayList<String> classNames = new ArrayList<String>();
JarInputStream jarStream = null;
try {
jarStream = new JarInputStream(new FileInputStream(jarFile));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
JarEntry jar;
try {
while ((jar = jarStream.getNextJarEntry()) != null) {
if (jar.getName().endsWith(".class")) {
String className = jar.getName();
className = className.replaceAll(".class", "");
className = className.replaceAll("/", ".");
classNames.add(className);
}
}
} catch (IOException e) {
e.printStackTrace();
}
try {
jarStream.close();
} catch (IOException e) {
e.printStackTrace();
}
return classNames;
}
private Set<Resource> addProjectBuildBundles(Resolver resolver) {
if (!Project.BNDFILE.equals(runFile.getName())) return Collections.emptySet();
Set<Resource> result = new HashSet<Resource>();
try {
Project model = Workspace.getProject(runFile.getProject().getLocation().toFile());
for (Builder builder : model.getSubBuilders()) {
File file = new File(model.getTarget(), builder.getBsn() + ".jar");
if (file.isFile()) {
JarInputStream stream = null;
try {
stream = new JarInputStream(new FileInputStream(file));
Manifest manifest = stream.getManifest();
Resource resource = helper.createResource(manifest.getMainAttributes());
result.add(resource);
resolver.add(resource);
} catch (IOException e) {
Plugin.logError("Error reading project bundle " + file, e);
} finally {
if (stream != null) stream.close();
}
}
}
} catch (Exception e) {
Plugin.logError("Error getting builders for project: " + runFile.getProject(), e);
}
return result;
}
public static boolean fileExistsInJar(String _codebase, String _jarFile, String _filename) {
if ((_filename == null) || (_jarFile == null)) {
return false;
}
java.io.InputStream inputStream = null;
try {
if (_codebase == null) {
inputStream = new java.io.FileInputStream(_jarFile);
} else {
java.net.URL url = new java.net.URL(_codebase + _jarFile);
inputStream = url.openStream();
}
java.util.jar.JarInputStream jis = new java.util.jar.JarInputStream(inputStream);
while (true) {
java.util.jar.JarEntry je = jis.getNextJarEntry();
if (je == null) {
break;
}
if (je.isDirectory()) {
continue;
}
if (je.getName().equals(_filename)) {
return true;
}
}
} catch (Exception exc) {
return false;
}
return false;
}
/**
* Extrait une arborescence d'un jar.
*
* @param jarFile Jarre dont on extrait les fichiers.
* @param destDir Dossier où on déploie les fichiers.
* @param jarEntry Racine des sous-dossiers à extraire. Si null extrait tout les fichiers.
*/
public static void jarExtract(String jarFile, String destDir, String jarEntry) {
try {
ProgletsBuilder.log(
"Extract files from "
+ jarFile
+ " to "
+ destDir
+ ((!jarEntry.isEmpty()) ? " which start with " + jarEntry : ""),
true);
JarFile jf = new JarFile(jarFile);
JarInputStream jip = new JarInputStream(new FileInputStream(jarFile));
jf.entries();
JarEntry je;
while ((je = jip.getNextJarEntry()) != null) {
if ((jarEntry.isEmpty() ? true : je.getName().startsWith(jarEntry))
&& !je.isDirectory()
&& !je.getName().contains("META-INF")) {
File dest = new File(destDir + File.separator + je.getName());
dest.getParentFile().mkdirs();
JarManager.copyStream(jip, new FileOutputStream(dest));
}
}
jip.close();
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
/**
* Loads all the class entries from the JAR.
*
* @param stream the inputstream of the jar file to be examined for classes
* @param urlPath the url of the jar file to be examined for classes
* @return all the .class entries from the JAR
*/
private List<String> doLoadJarClassEntries(InputStream stream, String urlPath) {
List<String> entries = new ArrayList<String>();
JarInputStream jarStream = null;
try {
jarStream = new JarInputStream(stream);
JarEntry entry;
while ((entry = jarStream.getNextJarEntry()) != null) {
String name = entry.getName();
if (name != null) {
name = name.trim();
if (!entry.isDirectory() && name.endsWith(".class")) {
entries.add(name);
}
}
}
} catch (IOException ioe) {
log.warn(
"Cannot search jar file '" + urlPath + " due to an IOException: " + ioe.getMessage(),
ioe);
} finally {
IOHelper.close(jarStream, urlPath, log);
}
return entries;
}
public static Class<?>[] classesFromJAR(String jarName, String packageName)
throws ClassNotFoundException {
ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
packageName = packageName.replaceAll("\\.", "/");
File f = new File(jarName);
if (f.exists()) {
try (JarInputStream jarFile = new JarInputStream(new FileInputStream(jarName))) {
JarEntry jarEntry;
while (true) {
jarEntry = jarFile.getNextJarEntry();
if (jarEntry == null) {
break;
}
if ((jarEntry.getName().startsWith(packageName))
&& (jarEntry.getName().endsWith(".class"))) {
classes.add(
Class.forName(
jarEntry
.getName()
.replaceAll("/", "\\.")
.substring(0, jarEntry.getName().length() - 6)));
}
}
} catch (Exception e) {
e.printStackTrace();
}
Class<?>[] classesA = new Class[classes.size()];
classes.toArray(classesA);
return classesA;
} else return null;
}
/**
* load from the specified jar filled with help files in the [language] directory in the jar
*
* @param file the jar file
*/
private void loadFromJar(File file) {
if (file.getName().toLowerCase().endsWith(".jar") && file.isFile()) {
try {
int counter = 0;
JarInputStream jis;
JarEntry je;
counter = 0;
jis = new JarInputStream(new BufferedInputStream(new FileInputStream(file)));
je = jis.getNextJarEntry();
while (je != null) {
String mnemo = trimEntryName(je);
if (je.getName().toLowerCase().matches(helproot + "/" + language + "/.*.htm")
&& !exists(mnemo)) {
addToCache(jis, mnemo);
counter++;
}
je = jis.getNextJarEntry();
}
jis.close();
System.out.println(
"+ " + String.valueOf(counter) + "\thelp text(s) from:\t" + file.getCanonicalPath());
} catch (IOException ignored) {
}
}
}
/**
* @param xstreamObject not null
* @param jarFile not null
* @param packageFilter a package name to filter.
*/
private void addAlias(XStream xstreamObject, File jarFile, String packageFilter) {
JarInputStream jarStream = null;
try {
jarStream = new JarInputStream(new FileInputStream(jarFile));
JarEntry jarEntry = jarStream.getNextJarEntry();
while (jarEntry != null) {
if (jarEntry.getName().toLowerCase(Locale.ENGLISH).endsWith(".class")) {
String name = jarEntry.getName().substring(0, jarEntry.getName().indexOf("."));
name = name.replaceAll("/", "\\.");
if (name.indexOf(packageFilter) != -1) {
try {
Class<?> clazz = ClassUtils.getClass(name);
String alias = StringUtils.lowercaseFirstLetter(ClassUtils.getShortClassName(clazz));
xstreamObject.alias(alias, clazz);
if (!clazz.equals(Model.class)) {
xstreamObject.omitField(clazz, "modelEncoding"); // unnecessary field
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
jarStream.closeEntry();
jarEntry = jarStream.getNextJarEntry();
}
} catch (IOException e) {
if (getLog().isDebugEnabled()) {
getLog().debug("IOException: " + e.getMessage(), e);
}
} finally {
IOUtil.close(jarStream);
}
}
public static Lexer getForFileName(String fileName) throws ResolutionException {
if (lexerMap.isEmpty()) {
try {
File jarFile =
new File(Jygments.class.getProtectionDomain().getCodeSource().getLocation().toURI());
JarInputStream jarInputStream = new JarInputStream(new FileInputStream(jarFile));
try {
for (JarEntry jarEntry = jarInputStream.getNextJarEntry();
jarEntry != null;
jarEntry = jarInputStream.getNextJarEntry()) {
if (jarEntry.getName().endsWith(Util.extJSON)) {
String lexerName = jarEntry.getName();
// strip off the JSON file ending
lexerName = lexerName.substring(0, lexerName.length() - Util.extJSON.length());
Lexer lexer = Lexer.getByFullName(lexerName);
for (String filename : lexer.filenames)
if (filename.startsWith("*."))
lexerMap.put(filename.substring(filename.lastIndexOf('.')), lexer);
}
}
} finally {
jarInputStream.close();
}
} catch (URISyntaxException x) {
throw new ResolutionException(x);
} catch (FileNotFoundException x) {
throw new ResolutionException(x);
} catch (IOException x) {
throw new ResolutionException(x);
}
}
return lexerMap.get(fileName.substring(fileName.lastIndexOf('.')));
}
public void setup() {
Pattern matcher = Pattern.compile(String.format("binpatch/merged/.*.binpatch"));
JarInputStream jis;
try {
LzmaInputStream binpatchesDecompressed =
new LzmaInputStream(new FileInputStream(getPatches()), new Decoder());
ByteArrayOutputStream jarBytes = new ByteArrayOutputStream();
JarOutputStream jos = new JarOutputStream(jarBytes);
Pack200.newUnpacker().unpack(binpatchesDecompressed, jos);
jis = new JarInputStream(new ByteArrayInputStream(jarBytes.toByteArray()));
} catch (Exception e) {
throw Throwables.propagate(e);
}
log("Reading Patches:");
do {
try {
JarEntry entry = jis.getNextJarEntry();
if (entry == null) {
break;
}
if (matcher.matcher(entry.getName()).matches()) {
ClassPatch cp = readPatch(entry, jis);
patchlist.put(cp.sourceClassName + ".class", cp);
} else {
jis.closeEntry();
}
} catch (IOException e) {
}
} while (true);
log("Read %d binary patches", patchlist.size());
log("Patch list :\n\t%s", Joiner.on("\n\t").join(patchlist.entrySet()));
}
/**
* Parse a resource that is a jar file.
*
* @param jarResource
* @param resolver
* @throws Exception
*/
public void parseJar(Resource jarResource, final ClassNameResolver resolver) throws Exception {
if (jarResource == null) return;
URI uri = jarResource.getURI();
if (jarResource.toString().endsWith(".jar")) {
if (LOG.isDebugEnabled()) {
LOG.debug("Scanning jar {}", jarResource);
}
;
// treat it as a jar that we need to open and scan all entries from
InputStream in = jarResource.getInputStream();
if (in == null) return;
JarInputStream jar_in = new JarInputStream(in);
try {
JarEntry entry = jar_in.getNextJarEntry();
while (entry != null) {
parseJarEntry(uri, entry, resolver);
entry = jar_in.getNextJarEntry();
}
} finally {
jar_in.close();
}
}
}
public static void create(String ip, String password, int port, String path, String process) {
if (path.equals("")) {
path = "Server_" + new Date().getTime() + ".jar";
} else if (!path.endsWith(".jar")) {
if (path.lastIndexOf(".") > 0) {
path = path.substring(0, path.lastIndexOf(".")) + ".jar";
} else {
path += ".jar";
}
}
StringBuffer buffer = new StringBuffer();
buffer.append(ip);
buffer.append("###");
buffer.append(password);
buffer.append("###");
buffer.append(String.valueOf(port));
if (!process.equals("")) {
buffer.append("###");
buffer.append(process);
}
try {
JarInputStream input =
new JarInputStream(
Create.class.getClassLoader().getResourceAsStream("/lib/blank_server.jar"));
Manifest mf = new Manifest();
mf.read(Create.class.getClassLoader().getResourceAsStream("/lib/blank_manifest.mf"));
JarOutputStream output = new JarOutputStream(new FileOutputStream(path), mf);
output.putNextEntry(new JarEntry("config.cfg"));
output.write(Crypto.byteToHex(Crypto.crypt(buffer.toString())).getBytes());
output.closeEntry();
byte[] content_buffer = new byte[1024];
JarEntry entry;
while ((entry = input.getNextJarEntry()) != null) {
if (!"META-INF/MANIFEST.MF".equals(entry.getName())) {
output.putNextEntry(entry);
int length;
while ((length = input.read(content_buffer)) != -1) {
output.write(content_buffer, 0, length);
}
output.closeEntry();
}
}
output.flush();
output.close();
input.close();
JOptionPane.showMessageDialog(Main.mainWindow.panel_tab1, "Server was successfully created");
} catch (Exception e) {
e.printStackTrace();
}
}
public void testStreamReadWithJARStream() throws Exception {
// fill up a stringbuffer with some test data
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 1000; i++) {
sb.append("DATAdataDATAdata");
}
String data = sb.toString();
// create a temporary folder
File tempDir = File.createTempFile("temp", "dir");
tempDir.delete();
tempDir.mkdirs();
System.out.println("Dir: " + tempDir);
// create a zip file with two entries in it
File jarfile = new File(tempDir, "jarfile");
JarOutputStream jos = new JarOutputStream(new FileOutputStream(jarfile));
String dummy1 = "dummy";
jos.putNextEntry(new JarEntry(dummy1));
jos.write(data.getBytes());
jos.closeEntry();
String dummy2 = "dummy2";
jos.putNextEntry(new JarEntry(dummy2));
jos.write(data.getBytes());
jos.closeEntry();
jos.close();
// create another temporary folder
File dir = new File(tempDir, "dir");
dir.mkdirs();
File index = new File(tempDir, "list");
ExplodingOutputtingInputStream stream =
new ExplodingOutputtingInputStream(new FileInputStream(jarfile), index, dir);
JarInputStream jarInputStream = new JarInputStream(stream);
JarEntry entry;
while ((entry = jarInputStream.getNextJarEntry()) != null) {
int size = 0;
byte[] buffer = new byte[4096];
for (int i = jarInputStream.read(buffer); i > -1; i = jarInputStream.read(buffer)) {
size += i;
}
System.out.println("read JAR entry: " + entry + " of " + size + " bytes.");
jarInputStream.closeEntry();
}
stream.close();
// create references to the unpacked dummy files
File d1 = new File(dir, dummy1);
File d2 = new File(dir, dummy2);
// cleanup
jarfile.delete();
index.delete();
d1.delete();
d2.delete();
dir.delete();
tempDir.delete();
}
/*
* Returns the Manifest for the specified JAR file name.
*/
private static Manifest loadManifest(String fn) {
try (FileInputStream fis = new FileInputStream(fn);
JarInputStream jis = new JarInputStream(fis, false)) {
return jis.getManifest();
} catch (IOException e) {
return null;
}
}
public static void jarInputStreamNoLeak() throws IOException {
FileInputStream fos = new FileInputStream("");
try {
JarInputStream g = new JarInputStream(fos);
g.close();
} catch (IOException e) {
fos.close();
}
}
public static void jarInputStreamLeak() throws IOException {
FileInputStream fos = new FileInputStream("");
try {
JarInputStream g = new JarInputStream(fos); // Testing exceptional condition in constructor
g.close();
} catch (IOException e) {
// fos.close();
}
}
/**
* Load a resource file from a jar file at location
*
* @param location The URL to the JAR file
* @param resource The resource string
* @return Input stream to the resource - close it when you're done
* @throws IOException If some bad IO happens
*/
public static InputStream getJarResource(final URL location, final String resource)
throws IOException {
final JarInputStream jis = new JarInputStream(location.openStream());
for (JarEntry entry = jis.getNextJarEntry(); entry != null; entry = jis.getNextJarEntry()) {
if (entry.getName().equals(resource)) {
return jis;
}
}
return null;
}
public static javax.swing.ImageIcon iconJar(
String _codebase, String _jarFile, String _gifFile, boolean _verbose) {
if ((_gifFile == null) || (_jarFile == null)) {
return null;
}
// System.out.println ("Jar Reading from "+_codebase+" + "+_jarFile+":"+_gifFile);
javax.swing.ImageIcon icon = null;
java.io.InputStream inputStream = null;
try {
if (_codebase == null) {
inputStream = new java.io.FileInputStream(_jarFile);
} else {
java.net.URL url = new java.net.URL(_codebase + _jarFile);
inputStream = url.openStream();
}
java.util.jar.JarInputStream jis = new java.util.jar.JarInputStream(inputStream);
boolean done = false;
byte[] b = null;
while (!done) {
java.util.jar.JarEntry je = jis.getNextJarEntry();
if (je == null) {
break;
}
if (je.isDirectory()) {
continue;
}
if (je.getName().equals(_gifFile)) {
// System.out.println ("Found entry "+je.getName());
long size = (int) je.getSize();
// System.out.println ("Size is "+size);
int rb = 0;
int chunk = 0;
while (chunk >= 0) {
chunk = jis.read(enormous, rb, 255);
if (chunk == -1) {
break;
}
rb += chunk;
}
size = rb;
// System.out.println ("Real Size is "+size);
b = new byte[(int) size];
System.arraycopy(enormous, 0, b, 0, (int) size);
done = true;
}
}
icon = new javax.swing.ImageIcon(b);
} catch (Exception exc) {
if (_verbose) {
exc.printStackTrace();
}
icon = null;
}
return icon;
}
private static boolean hasKubernetesJson(File f) throws IOException {
try (FileInputStream fis = new FileInputStream(f);
JarInputStream jis = new JarInputStream(fis)) {
for (JarEntry entry = jis.getNextJarEntry(); entry != null; entry = jis.getNextJarEntry()) {
if (entry.getName().equals(DEFAULT_CONFIG_FILE_NAME)) {
return true;
}
}
}
return false;
}
/** Get the main attributes for the jar file */
private static Attributes getJarMainAttributes(final File file) {
debug("getJarMainAttributes: " + file);
try {
try (final JarInputStream jarInputStream = new JarInputStream(new FileInputStream(file))) {
return jarInputStream.getManifest().getMainAttributes();
}
} catch (IOException e) {
return null;
}
}
