/**
* 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) {
}
}
}
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;
}
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('.')));
}
/**
* 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();
}
}
}
/**
* @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);
}
}
/**
* 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;
}
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;
}
private Set<String> getJarInputStreamEntryNames(JarInputStream jarInputStream)
throws IOException {
Set<String> entryNames = new HashSet<>();
JarEntry jarEntry = jarInputStream.getNextJarEntry();
while (jarEntry != null) {
entryNames.add(jarEntry.getName());
jarEntry = jarInputStream.getNextJarEntry();
}
if (jarInputStream.getManifest() != null) {
entryNames.add(MANIFEST_JAR_ENTRY_NAME);
}
return entryNames;
}
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;
}
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;
}
/**
* 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 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 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;
}
/**
* Unpack distribution files from a downloaded jar stream.
*
* <p>The caller is responsible for closing the provided stream.
*/
private boolean copyFilesFromStream(JarInputStream jar)
throws FileNotFoundException, IOException {
final byte[] buffer = new byte[1024];
boolean distributionSet = false;
JarEntry entry;
while ((entry = jar.getNextJarEntry()) != null) {
final String name = entry.getName();
if (entry.isDirectory()) {
// We'll let getDataFile deal with creating the directory hierarchy.
// Yes, we can do better, but it can wait.
continue;
}
if (!name.startsWith(DISTRIBUTION_PATH)) {
continue;
}
File outFile = getDataFile(name);
if (outFile == null) {
continue;
}
distributionSet = true;
writeStream(jar, outFile, entry.getTime(), buffer);
}
return distributionSet;
}
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;
}
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 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;
}
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;
}
/**
* @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 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()));
}
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();
}
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();
}
}
/**
* Scans the given JarInputStream for TLD files located in META-INF (or a subdirectory of it),
* adding an implicit map entry to the taglib map for any TLD that has a <uri> element.
*
* @param conn - the
* @param ignore true if any exceptions raised when processing the given JAR should be ignored,
* false otherwise
*/
private void scanJar(
URLConnection conn, String resourcePath, boolean ignore, Map tmpMappings) // SYNC
throws JasperException, IOException {
InputStream connIS = conn.getInputStream();
JarInputStream jis = new JarInputStream(connIS);
try {
JarEntry entry = jis.getNextJarEntry();
while (entry != null) {
String name = entry.getName();
if (name.endsWith(".tld") == false) {
entry = jis.getNextJarEntry();
continue;
}
EntryInputStream eis = new EntryInputStream(jis);
String uri = getUriFromTld(resourcePath, eis);
// Add implicit map entry only if its uri is not already
// present in the map
if (uri != null && tmpMappings.get(uri) == null) // SYNC
{
tmpMappings.put(uri, new String[] {resourcePath, name}); // SYNC
}
entry = jis.getNextJarEntry();
}
} catch (Exception ex) {
if (!ignore) {
throw new JasperException(ex);
}
} finally {
if (jis != null) {
try {
jis.close();
} catch (Throwable t) {
// ignore
}
}
if (connIS != null) {
try {
connIS.close();
} catch (Throwable t) {
// ignore
}
}
}
}
public static JarEntry findJarEntry(JarInputStream jis, String name) throws IOException {
JarEntry entry;
while ((entry = jis.getNextJarEntry()) != null) {
if (entry.getName().equals(name)) {
return entry;
}
}
return null;
}
/**
* Scan entries in a jar file.
*
* <p>An entry will be reported to the scanning listener if the entry is a child of the parent
* path.
*
* @param in the jar file as an input stream.
* @param parent the parent path.
* @param sl the scanning lister to report jar entries.
* @throws IOException if an error occurred scanning the jar entries
*/
public static void scan(final InputStream in, final String parent, final ScannerListener sl)
throws IOException {
JarInputStream jarIn = null;
try {
jarIn = new JarInputStream(in);
JarEntry e = jarIn.getNextJarEntry();
while (e != null) {
if (!e.isDirectory() && e.getName().startsWith(parent) && sl.onAccept(e.getName())) {
sl.onProcess(e.getName(), jarIn);
}
jarIn.closeEntry();
e = jarIn.getNextJarEntry();
}
} finally {
if (jarIn != null) {
jarIn.close();
}
}
}
public void matched(URI uri) throws Exception {
LOG.debug("Search of {}", uri);
if (uri.toString().toLowerCase(Locale.ENGLISH).endsWith(".jar")) {
InputStream in = Resource.newResource(uri).getInputStream();
if (in == null) return;
JarInputStream jar_in = new JarInputStream(in);
try {
JarEntry entry = jar_in.getNextJarEntry();
while (entry != null) {
processEntry(uri, entry);
entry = jar_in.getNextJarEntry();
}
} finally {
jar_in.close();
}
}
}
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;
}
/**
* Enables to get the name of an object in the spoken language thanks to the jar file
*
* @param jarName the file that contains the object classes
* @return the object name in the spoken language
*/
private String getLangName(File jarName) {
String name = null;
try {
URL url = jarName.toURI().toURL();
JarInputStream jarFile = new JarInputStream(url.openStream());
JarEntry jarEntry = jarFile.getNextJarEntry();
while (jarEntry != null) {
if (!jarEntry.isDirectory()
&& jarEntry.getName().contains(Configuration.instance().getLanguage())) {
int lang_index = jarEntry.getName().lastIndexOf(Configuration.instance().getLanguage());
name = jarEntry.getName().substring(lang_index + 3, jarEntry.getName().length() - 6);
}
jarEntry = jarFile.getNextJarEntry();
}
} catch (Exception e) {
LOG.error("Error getLangName " + jarName + " " + e);
}
return name;
}
private static List<String> listEntries(JarInputStream is) throws IOException {
List<String> entries = new ArrayList<String>();
while (true) {
final JarEntry jarEntry = is.getNextJarEntry();
if (jarEntry == null) {
break;
}
entries.add(jarEntry.getName());
}
return entries;
}