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 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 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 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; }
/** * load from specified JarInputStream * * @param fis Jar Input Stream * @param mnemo the name for the text file */ private void addToCache(JarInputStream fis, String mnemo) { String text = ""; byte[] buf = new byte[4096]; int i = 0; try { while ((i = fis.read(buf)) != -1) { text += new String(buf, 0, i); } } catch (IOException ignored) { } helpcache.put(mnemo, text); }
/** * Attempt to verify that a Jar file is signed. All files (aside from ones in META-INF) must be * signed and trusted. * * @param in input stream * @throws SecurityException throw on verification failure * @throws IOException on I/O error */ @SuppressWarnings("resource") public void verifyJar(InputStream in) throws IOException { JarInputStream jarFile = null; try { jarFile = new JarInputStream(in); Manifest manifest = jarFile.getManifest(); if (manifest == null) { throw new SecurityException("The given file was not digitally signed"); } // Ensure all the entries' signatures verify correctly byte[] buffer = new byte[8192]; JarEntry entry; while ((entry = jarFile.getNextJarEntry()) != null) { if (entry.isDirectory()) continue; do {} while (jarFile.read(buffer, 0, buffer.length) != -1); Certificate[] certs = entry.getCertificates(); if (isMetaInf(entry.getName())) { continue; } else if (certs == null || certs.length == 0) { throw new SecurityException("The archive contains files that are not digitally signed"); } else { int i = 0; boolean verified = false; while (i < certs.length) { X509Certificate[] chain = findChain(certs, i); try { verify(chain); verified = true; break; } catch (SecurityException e) { } i += chain.length; } if (!verified) { throw new SecurityException( "The file(s) are signed by an entity that is not registered as 'trusted' with the launcher"); } } } } finally { LauncherUtils.close(jarFile); } }
/** deletes the META-INF */ public static void killMetaInf() { File inputFile = new File( Settings.getSettings().getInstallPath() + "/" + ModPack.getSelectedPack().getDir() + "/minecraft/bin", "minecraft.jar"); File outputTmpFile = new File( Settings.getSettings().getInstallPath() + "/" + ModPack.getSelectedPack().getDir() + "/minecraft/bin", "minecraft.jar.tmp"); try { JarInputStream input = new JarInputStream(new FileInputStream(inputFile)); JarOutputStream output = new JarOutputStream(new FileOutputStream(outputTmpFile)); JarEntry entry; while ((entry = input.getNextJarEntry()) != null) { if (entry.getName().contains("META-INF")) { continue; } output.putNextEntry(entry); byte buffer[] = new byte[1024]; int amo; while ((amo = input.read(buffer, 0, 1024)) != -1) { output.write(buffer, 0, amo); } output.closeEntry(); } input.close(); output.close(); if (!inputFile.delete()) { Logger.logError("Failed to delete Minecraft.jar."); return; } outputTmpFile.renameTo(inputFile); } catch (FileNotFoundException e) { Logger.logError(e.getMessage(), e); } catch (IOException e) { Logger.logError(e.getMessage(), e); } }
public static byte[] addJarEntry(byte[] jarToUpdate, String entryName, byte[] entryContent) throws IOException { ByteArrayOutputStream out = null; ByteArrayInputStream bais = null; JarOutputStream jos = null; JarInputStream jis = null; byte[] buffer = new byte[4096]; try { bais = new ByteArrayInputStream(jarToUpdate); jis = new JarInputStream(bais); out = new ByteArrayOutputStream(); jos = new JarOutputStream(out); JarEntry inEntry; while ((inEntry = (JarEntry) jis.getNextEntry()) != null) { if (!inEntry.getName().equals(entryName)) { jos.putNextEntry(new JarEntry(inEntry)); } else { throw new IllegalArgumentException( "Jar entry " + entryName + " already exists in jar to update"); } int len; while ((len = jis.read(buffer)) > 0) { jos.write(buffer, 0, len); } jos.flush(); } JarEntry entry = new JarEntry(entryName); jos.putNextEntry(entry); jos.write(entryContent); jos.closeEntry(); jos.finish(); out.flush(); return out.toByteArray(); } finally { if (jos != null) { jos.close(); } if (out != null) { out.close(); } if (jis != null) { jis.close(); } } }
/** * Internally compute the hash used for jar comparison. * * <p>https://github.com/beachhouse/jboss-beach-jar-digest * * <p>TODO we also need a way to do something similar for modules, since a hash for jar is not * enough. We probably need to include all .jars, resources and parts of module.xml (not * <resources /> which are by name changes). * * @param file the jar file * @return the hash * @throws NoSuchAlgorithmException * @throws IOException */ protected static byte[] internalJarComparison(final File file) throws NoSuchAlgorithmException, IOException { // TODO: make the algorithm choice configurable final MessageDigest jarDigest = MessageDigest.getInstance("SHA1"); final MessageDigest digest = MessageDigest.getInstance("SHA1"); final JarInputStream in = new JarInputStream(new BufferedInputStream(new FileInputStream(file))); try { JarEntry entry; while ((entry = in.getNextJarEntry()) != null) { // do not hash directories if (entry.isDirectory()) { continue; } final String name = entry.getName(); // do not hash information added by jarsigner if (name.startsWith("META-INF/")) { if (name.endsWith(".SF") || name.endsWith(".DSA")) continue; } if (name.equals("META-INF/INDEX.LIST")) { continue; } // do not hash timestamped maven artifacts // TODO: make this optional, enabled by default if (name.startsWith("META-INF/maven/") && name.endsWith("/pom.properties")) { continue; } digest.reset(); final byte[] buf = new byte[4096]; int l; while ((l = in.read(buf)) > 0) { digest.update(buf, 0, l); } final byte[] d = digest.digest(); jarDigest.update(d); } } finally { in.close(); } return jarDigest.digest(); }
/** Given an InputStream on a jar file, unjars the contents into the given directory. */ public void unjar(InputStream in, File destDir) throws IOException { BufferedOutputStream dest = null; JarInputStream jis = new JarInputStream(in); JarEntry entry; while ((entry = jis.getNextJarEntry()) != null) { if (entry.isDirectory()) { File dir = new File(destDir, entry.getName()); dir.mkdir(); if (entry.getTime() != -1) dir.setLastModified(entry.getTime()); continue; } // ///////////////////////////////////////// String name = entry.getName(); while (name.contains("/") || name.contains("//")) { File fdir = new File(destDir.getCanonicalPath() + "/" + name.split("/")[0]); // System.out.println(name.split("/")[0]); int index = name.indexOf("/"); if (!fdir.exists()) fdir.mkdir(); name = name.substring(index + 1); } // //////////////////////////////////////////// int count; byte data[] = new byte[BUFFER_SIZE]; File destFile = new File(destDir, entry.getName()); if (mVerbose) System.out.println("unjarring " + destFile + " from " + entry.getName()); FileOutputStream fos = new FileOutputStream(destFile); dest = new BufferedOutputStream(fos, BUFFER_SIZE); while ((count = jis.read(data, 0, BUFFER_SIZE)) != -1) { dest.write(data, 0, count); } dest.flush(); dest.close(); if (entry.getTime() != -1) destFile.setLastModified(entry.getTime()); } jis.close(); }
/** Load the jar contents from InputStream */ private void loadJar(InputStream jarStream, ProtectionDomain protectionDomain) { BufferedInputStream bis = null; JarInputStream jis = null; try { bis = new BufferedInputStream(jarStream); jis = new JarInputStream(bis); JarEntry jarEntry = null; while ((jarEntry = jis.getNextJarEntry()) != null) { if (logger.isLoggable(Level.FINEST)) logger.finest(dump(jarEntry)); if (jarEntry.isDirectory()) { continue; } if (jarEntryContents.containsKey(jarEntry.getName())) { if (!collisionAllowed) throw new JclException("Class/Resource " + jarEntry.getName() + " already loaded"); else { if (logger.isLoggable(Level.FINEST)) logger.finest( "Class/Resource " + jarEntry.getName() + " already loaded; ignoring entry..."); continue; } } if (logger.isLoggable(Level.FINEST)) logger.finest( "Entry Name: " + jarEntry.getName() + ", " + "Entry Size: " + jarEntry.getSize()); byte[] b = new byte[2048]; ByteArrayOutputStream out = new ByteArrayOutputStream(); int len = 0; while ((len = jis.read(b)) > 0) { out.write(b, 0, len); } // add to internal resource HashMap jarEntryContents.put( jarEntry.getName(), new JarResource(out.toByteArray(), protectionDomain)); if (logger.isLoggable(Level.FINEST)) logger.finest( jarEntry.getName() + ": size=" + out.size() + " ,csize=" + jarEntry.getCompressedSize()); out.close(); } } catch (IOException e) { throw new JclException(e); } catch (NullPointerException e) { if (logger.isLoggable(Level.FINEST)) logger.finest("Done loading."); } finally { if (jis != null) try { jis.close(); } catch (IOException e) { throw new JclException(e); } if (bis != null) try { bis.close(); } catch (IOException e) { throw new JclException(e); } } }
/** * Reads the jar found at the specified URL and stores the entries in the jar_entry table. * * @param jarId The id used for the foreign key to the jar_repository table * @param urlStream An InputStream (opened on what may have been a URL) * @param sz The expected size of the stream, used as a worst-case mark/reset limit. The caller * might pass -1 if the URLConnection can't determine a size in advance (a generous guess will * be made in that case). * @throws SQLException */ public static void addClassImages(int jarId, InputStream urlStream, int sz) throws SQLException { PreparedStatement stmt = null; PreparedStatement descIdFetchStmt = null; PreparedStatement descIdStoreStmt = null; ResultSet rs = null; try { byte[] buf = new byte[1024]; ByteArrayOutputStream img = new ByteArrayOutputStream(); stmt = SQLUtils.getDefaultConnection() .prepareStatement( "INSERT INTO sqlj.jar_entry(entryName, jarId, entryImage) VALUES(?, ?, ?)"); BufferedInputStream bis = new BufferedInputStream(urlStream); String manifest = rawManifest(bis, sz); JarInputStream jis = new JarInputStream(bis); if (manifest != null) { PreparedStatement us = SQLUtils.getDefaultConnection() .prepareStatement("UPDATE sqlj.jar_repository SET jarManifest = ? WHERE jarId = ?"); try { us.setString(1, manifest); us.setInt(2, jarId); if (us.executeUpdate() != 1) throw new SQLException("Jar repository update did not update 1 row"); } finally { SQLUtils.close(us); } } for (; ; ) { JarEntry je = jis.getNextJarEntry(); if (je == null) break; if (je.isDirectory()) continue; String entryName = je.getName(); int nBytes; img.reset(); while ((nBytes = jis.read(buf)) > 0) img.write(buf, 0, nBytes); jis.closeEntry(); stmt.setString(1, entryName); stmt.setInt(2, jarId); stmt.setBytes(3, img.toByteArray()); if (stmt.executeUpdate() != 1) throw new SQLException("Jar entry insert did not insert 1 row"); } Matcher ddr = ddrSection.matcher(null != manifest ? manifest : ""); Matcher cnt = mfCont.matcher(""); for (int ordinal = 0; ddr.find(); ++ordinal) { String entryName = cnt.reset(ddr.group(1)).replaceAll(""); if (descIdFetchStmt == null) descIdFetchStmt = SQLUtils.getDefaultConnection() .prepareStatement( "SELECT entryId FROM sqlj.jar_entry" + " WHERE jarId = ? AND entryName = ?"); descIdFetchStmt.setInt(1, jarId); descIdFetchStmt.setString(2, entryName); rs = descIdFetchStmt.executeQuery(); if (!rs.next()) throw new SQLException("Failed to refetch row in sqlj.jar_entry"); int deployImageId = rs.getInt(1); if (descIdStoreStmt == null) descIdStoreStmt = SQLUtils.getDefaultConnection() .prepareStatement( "INSERT INTO sqlj.jar_descriptor" + " (jarId, entryId, ordinal) VALUES" + " ( ?, ?, ? )"); descIdStoreStmt.setInt(1, jarId); descIdStoreStmt.setInt(2, deployImageId); descIdStoreStmt.setInt(3, ordinal); if (descIdStoreStmt.executeUpdate() != 1) throw new SQLException("Jar deployment descriptor insert did not insert " + "1 row"); } } catch (IOException e) { throw new SQLException("I/O exception reading jar file: " + e.getMessage()); } finally { SQLUtils.close(rs); SQLUtils.close(descIdStoreStmt); SQLUtils.close(descIdFetchStmt); SQLUtils.close(stmt); } }
/** Unzips a file in the file directory */ public static final void unjar(final String filenamePath) throws IOException { final int BUFFER = 2048; int count; byte data[] = new byte[BUFFER]; if (filenamePath == null || filenamePath.length() == 0) { throw new IllegalArgumentException("No file to unjar!"); } String baseJarDirName = getFilepath(filenamePath); String unjaredDirName = getNakedFilename(filenamePath); String baseUnjaredDirName = getFilepath(filenamePath) + DIRECTORY_SEPARATOR + unjaredDirName; File baseUnjaredDir = new File(baseUnjaredDirName); if (!baseUnjaredDir.exists()) { baseUnjaredDir.mkdirs(); } FileInputStream fileInputstream = null; JarInputStream jarIn = null; try { fileInputstream = new FileInputStream(filenamePath); jarIn = new JarInputStream(new BufferedInputStream(fileInputstream)); JarEntry entry; while ((entry = jarIn.getNextJarEntry()) != null) { String entryFilenamePath = entry.getName(); if (!entryFilenamePath.startsWith(unjaredDirName)) { entryFilenamePath = unjaredDirName + DIRECTORY_SEPARATOR + entryFilenamePath; } // Check entry sub directory String entryPathname = getFilepath(entryFilenamePath); if (entryPathname != null && entryPathname.length() > 0) { File entryPath = new File(baseJarDirName + DIRECTORY_SEPARATOR + entryPathname); if (!entryPath.exists()) { entryPath.mkdirs(); } } // Check entry file String entryFilename = getFilename(entryFilenamePath); if (entryFilename != null & entryFilename.length() > 0) { File outputFile = new File(baseJarDirName + DIRECTORY_SEPARATOR + entryFilenamePath); if (!outputFile.exists()) { outputFile.createNewFile(); } // write the files to the disk(); BufferedOutputStream dest = null; FileOutputStream fileOutputstream = null; try { fileOutputstream = new FileOutputStream(outputFile); dest = new BufferedOutputStream(fileOutputstream, BUFFER); while ((count = jarIn.read(data, 0, BUFFER)) != -1) { dest.write(data, 0, count); } dest.flush(); } finally { if (fileOutputstream != null) { fileOutputstream.close(); } if (dest != null) { dest.close(); } } } } } finally { if (fileInputstream != null) { fileInputstream.close(); } if (jarIn != null) { jarIn.close(); } } }
private File writeIndexes( File jar, String entryName, List<LameSubDeploymentIndex> subDeploymentIndices) throws IOException { int dotIndex = entryName.lastIndexOf('.'); if (dotIndex == -1) { throw new AssertionError("missing extension from: " + entryName); } String suffix = entryName.substring(dotIndex); int slashIndex = entryName.lastIndexOf('/'); String prefix; if (slashIndex == -1) { prefix = entryName.substring(0, dotIndex); } else { prefix = entryName.substring(slashIndex + 1, dotIndex); } File indexedJar = File.createTempFile(prefix, suffix); try (JarInputStream inputStream = new JarInputStream(new FileInputStream(jar))) { Manifest manifest = inputStream.getManifest(); Map<String, File> replacementMap = this.buildReplacementMap(subDeploymentIndices); try (FileOutputStream fileOutputStream = new FileOutputStream(indexedJar); JarOutputStream outputStream = manifest != null ? new JarOutputStream(fileOutputStream, manifest) : new JarOutputStream(fileOutputStream)) { JarEntry entry = inputStream.getNextJarEntry(); byte[] buffer = new byte[8192]; ByteArrayOutputStream bos = null; while (entry != null) { // TODO should we keep META-INF/INDEX.LIST or drop it? should be first entry boolean isFuckedUpIbm = isFuckedUpIbmMqSeriesEntry(entryName, entry); if (!isFuckedUpIbm) { File replacement = replacementMap.get(entryName); if (replacement == null) { outputStream.putNextEntry(entry); if (entry.getSize() != 0L) { int read; while ((read = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, read); } } } else { // some subdeployments (eg WAR in EAR) have changed and we need to replace them JarEntry replaced = safeCopy(entry); replaced.setSize(replacement.length()); outputStream.putNextEntry(replaced); try (InputStream input = new FileInputStream(replacement)) { int read; while ((read = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, read); } } } } else { // some JARs in the IBM RAR are f****d up // the size of certain file in the central directory index is wrong if (bos == null) { bos = new ByteArrayOutputStream(1024); } else { bos.reset(); } long actualSize = 0L; int read; while ((read = inputStream.read(buffer)) != -1) { bos.write(buffer, 0, read); actualSize += read; } System.out.println( "encountered f****d up entry: " + entry.getName() + " in: " + entryName + " reported size: " + entry.getSize() + " actual size: " + actualSize); JarEntry unfucked = safeCopy(entry); unfucked.setSize(actualSize); outputStream.putNextEntry(unfucked); bos.writeTo(outputStream); } entry = inputStream.getNextJarEntry(); } // REVIEW: more or less reuse? IndexWriter indexWriter = new IndexWriter(outputStream); for (LameSubDeploymentIndex subDeploymentIndex : subDeploymentIndices) { String indexFile = subDeploymentIndex.name + ".index"; JarEntry indexEntry = new JarEntry(indexFile); indexEntry.setMethod(ZipEntry.DEFLATED); outputStream.putNextEntry(indexEntry); // IndexWriter does buffering indexWriter.write(subDeploymentIndex.index); } } } return indexedJar; }
/** * Unpacks the Archive from the input file to the output file * * @throws Pack200Exception * @throws IOException */ public void unpack() throws Pack200Exception, IOException { outputStream.setComment("PACK200"); try { if (!inputStream.markSupported()) { inputStream = new BufferedInputStream(inputStream); if (!inputStream.markSupported()) throw new IllegalStateException(); } inputStream.mark(2); if (((inputStream.read() & 0xFF) | (inputStream.read() & 0xFF) << 8) == GZIPInputStream.GZIP_MAGIC) { inputStream.reset(); inputStream = new BufferedInputStream(new GZIPInputStream(inputStream)); } else { inputStream.reset(); } inputStream.mark(4); int[] magic = {0xCA, 0xFE, 0xD0, 0x0D}; // Magic word for // pack200 int word[] = new int[4]; for (int i = 0; i < word.length; i++) { word[i] = inputStream.read(); } boolean compressedWithE0 = false; for (int m = 0; m < magic.length; m++) { if (word[m] != magic[m]) { compressedWithE0 = true; } } inputStream.reset(); if (compressedWithE0) { // The original Jar was not packed, so just // copy it across JarInputStream jarInputStream = new JarInputStream(inputStream); JarEntry jarEntry; while ((jarEntry = jarInputStream.getNextJarEntry()) != null) { outputStream.putNextEntry(jarEntry); byte[] bytes = new byte[16384]; int bytesRead = jarInputStream.read(bytes); while (bytesRead != -1) { outputStream.write(bytes, 0, bytesRead); bytesRead = jarInputStream.read(bytes); } outputStream.closeEntry(); } } else { int i = 0; while (available(inputStream)) { i++; Segment segment = new Segment(); segment.setLogLevel(logLevel); segment.setLogStream( logFile != null ? (OutputStream) logFile : (OutputStream) System.out); segment.setPreRead(false); if (i == 1) { segment.log( Segment.LOG_LEVEL_VERBOSE, "Unpacking from " + inputFileName + " to " + outputFileName); } segment.log(Segment.LOG_LEVEL_VERBOSE, "Reading segment " + i); if (overrideDeflateHint) { segment.overrideDeflateHint(deflateHint); } segment.unpack(inputStream, outputStream); outputStream.flush(); if (inputStream instanceof FileInputStream) { inputFileName = ((FileInputStream) inputStream).getFD().toString(); } } } } finally { try { inputStream.close(); } catch (Exception e) { } try { outputStream.close(); } catch (Exception e) { } if (logFile != null) { try { logFile.close(); } catch (Exception e) { } } } if (removePackFile) { File file = new File(inputFileName); boolean deleted = file.delete(); if (!deleted) { throw new Pack200Exception("Failed to delete the input file."); } } }
public int read(byte b[], int off, int len) throws IOException { return jis.read(b, off, len); }
public int read() throws IOException { return jis.read(); }