private void setSizesAndOffsetFromZip64Extra( final ZipEntry ze, final OffsetEntry offset, final int diskStart) throws IOException { final Zip64ExtendedInformationExtraField z64 = (Zip64ExtendedInformationExtraField) ze.getExtraField(Zip64ExtendedInformationExtraField.HEADER_ID); if (z64 != null) { final boolean hasUncompressedSize = ze.getSize() == 4294967295L; final boolean hasCompressedSize = ze.getCompressedSize() == 4294967295L; final boolean hasRelativeHeaderOffset = offset.headerOffset == 4294967295L; z64.reparseCentralDirectoryData( hasUncompressedSize, hasCompressedSize, hasRelativeHeaderOffset, diskStart == 65535); if (hasUncompressedSize) { ze.setSize(z64.getSize().getLongValue()); } else if (hasCompressedSize) { z64.setSize(new ZipEightByteInteger(ze.getSize())); } if (hasCompressedSize) { ze.setCompressedSize(z64.getCompressedSize().getLongValue()); } else if (hasUncompressedSize) { z64.setCompressedSize(new ZipEightByteInteger(ze.getCompressedSize())); } if (hasRelativeHeaderOffset) { offset.headerOffset = z64.getRelativeHeaderOffset().getLongValue(); } } }
static Hashtable<String, PkgEntry> readJarFile(InputStream in) { Hashtable<String, PkgEntry> tbl = new Hashtable<String, PkgEntry>(); try { ZipInputStream zis = new ZipInputStream(in); ZipEntry ze = zis.getNextEntry(); while (ze != null) { String zname = ze.getName(); if (zname.endsWith(".class")) { String pkgname = getPackageName(zname); if (!tbl.containsKey(pkgname)) { long csize = getCompressedSize(zis); tbl.put(pkgname, new PkgEntry(ze.getSize(), csize)); } else { PkgEntry pe = tbl.get(pkgname); long csize = getCompressedSize(zis); pe.addSizes(ze.getSize(), csize); tbl.put(pkgname, pe); } } ze = zis.getNextEntry(); } } catch (ZipException ex) { Logger.getLogger(JarAnalyzer.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(JarAnalyzer.class.getName()).log(Level.SEVERE, null, ex); } return tbl; }
/** initializes internal hash tables with Jar file resources. */ private void init() { try { // extracts just sizes only. ZipFile zf = new ZipFile(jarFileName); Enumeration e = zf.entries(); while (e.hasMoreElements()) { ZipEntry ze = (ZipEntry) e.nextElement(); if (debugOn) { System.out.println(dumpZipEntry(ze)); } htSizes.put(ze.getName(), new Integer((int) ze.getSize())); } zf.close(); // extract resources and put them into the hashtable. FileInputStream fis = new FileInputStream(jarFileName); BufferedInputStream bis = new BufferedInputStream(fis); ZipInputStream zis = new ZipInputStream(bis); ZipEntry ze = null; while ((ze = zis.getNextEntry()) != null) { if (ze.isDirectory()) { continue; } if (debugOn) { System.out.println("ze.getName()=" + ze.getName() + "," + "getSize()=" + ze.getSize()); } int size = (int) ze.getSize(); // -1 means unknown size. if (size == -1) { size = ((Integer) htSizes.get(ze.getName())).intValue(); } byte[] b = new byte[(int) size]; int rb = 0; int chunk = 0; while (((int) size - rb) > 0) { chunk = zis.read(b, rb, (int) size - rb); if (chunk == -1) { break; } rb += chunk; } // add to internal resource hashtable htJarContents.put(ze.getName(), b); if (debugOn) { System.out.println( ze.getName() + " rb=" + rb + ",size=" + size + ",csize=" + ze.getCompressedSize()); } } } catch (NullPointerException e) { System.out.println("done."); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
@NotNull protected Map<String, EntryInfo> initEntries() { synchronized (lock) { Map<String, EntryInfo> map = myRelPathsToEntries.get(); if (map == null) { final ZipInputStream zip = getZip(); map = new HashMap<String, EntryInfo>(); if (zip != null) { map.put("", new EntryInfo("", null, true, new byte[0])); try { ZipEntry entry = zip.getNextEntry(); while (entry != null) { final String name = entry.getName(); final boolean isDirectory = name.endsWith("/"); if (entry.getExtra() == null) { byte[] cont = new byte[(int) entry.getSize()]; ByteArrayOutputStream byteArray = new ByteArrayOutputStream(); InputStream stream = getZip(); if (stream != null) { int tmp; if ((tmp = stream.read(cont)) == entry.getSize()) { byteArray.write(cont, 0, tmp); entry.setExtra(byteArray.toByteArray()); } else { int readFromIS = tmp; if (tmp < entry.getSize()) { byteArray.write(cont, 0, tmp); while (((tmp = stream.read(cont)) != -1) && (tmp + readFromIS <= entry.getSize())) { byteArray.write(cont, 0, tmp); readFromIS += tmp; } entry.setExtra(byteArray.toByteArray()); } } } } getOrCreate( isDirectory ? name.substring(0, name.length() - 1) : name, isDirectory, map, entry.getExtra()); entry = zip.getNextEntry(); } } catch (IOException e) { e.printStackTrace(); } myRelPathsToEntries = new SoftReference<Map<String, EntryInfo>>(map); } } return map; } }
/** * Return an {@code InputStream} for reading the decompressed contents of ZIP entry. * * @param ze the ZIP entry to be read. * @return the input stream to read from. * @throws IOException if an error occurred while creating the input stream. */ @Override public InputStream getInputStream(ZipEntry ze) throws IOException { if (manifestEntry != null) { getManifest(); } if (verifier != null) { verifier.setManifest(getManifest()); if (manifest != null) { verifier.mainAttributesEnd = manifest.getMainAttributesEnd(); } if (verifier.readCertificates()) { verifier.removeMetaEntries(); if (manifest != null) { manifest.removeChunks(); } if (!verifier.isSignedJar()) { verifier = null; } } } InputStream in = super.getInputStream(ze); if (in == null) { return null; } if (verifier == null || ze.getSize() == -1) { return in; } JarVerifier.VerifierEntry entry = verifier.initEntry(ze.getName()); if (entry == null) { return in; } return new JarFileInputStream(in, ze, entry); }
/** * Returns the entries of an archive. * * @param ctx query context * @return entries * @throws QueryException query exception */ private Iter entries(final QueryContext ctx) throws QueryException { final B64 archive = (B64) checkType(checkItem(expr[0], ctx), AtomType.B64); final ValueBuilder vb = new ValueBuilder(); final ArchiveIn in = ArchiveIn.get(archive.input(info), info); try { while (in.more()) { final ZipEntry ze = in.entry(); if (ze.isDirectory()) continue; final FElem e = new FElem(Q_ENTRY, NS); long s = ze.getSize(); if (s != -1) e.add(Q_SIZE, token(s)); s = ze.getTime(); if (s != -1) e.add(Q_LAST_MOD, new Dtm(s, info).string(info)); s = ze.getCompressedSize(); if (s != -1) e.add(Q_COMP_SIZE, token(s)); e.add(ze.getName()); vb.add(e); } return vb; } catch (final IOException ex) { Util.debug(ex); throw ARCH_FAIL.thrw(info, ex); } finally { in.close(); } }
@NotNull @Override public byte[] contentsToByteArray(@NotNull String relativePath) throws IOException { FileAccessorCache.Handle<ZipFile> zipRef; try { zipRef = getZipFileHandle(); } catch (RuntimeException ex) { Throwable cause = ex.getCause(); if (cause instanceof IOException) throw (IOException) cause; throw ex; } try { ZipFile zip = zipRef.get(); ZipEntry entry = zip.getEntry(relativePath); if (entry != null) { InputStream stream = zip.getInputStream(entry); if (stream != null) { // ZipFile.c#Java_java_util_zip_ZipFile_read reads data in 8K (stack allocated) blocks - // no sense to create BufferedInputStream try { return FileUtil.loadBytes(stream, (int) entry.getSize()); } finally { stream.close(); } } } } finally { zipRef.release(); } throw new FileNotFoundException(getFile() + "!/" + relativePath); }
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(); } }
private boolean unpackFile(ZipFile zip, byte[] buf, ZipEntry fileEntry, String name) throws IOException, FileNotFoundException { if (fileEntry == null) fileEntry = zip.getEntry(name); if (fileEntry == null) throw new FileNotFoundException("Can't find " + name + " in " + zip.getName()); File outFile = new File(sGREDir, name); if (outFile.lastModified() == fileEntry.getTime() && outFile.length() == fileEntry.getSize()) return false; File dir = outFile.getParentFile(); if (!dir.exists()) dir.mkdirs(); InputStream fileStream; fileStream = zip.getInputStream(fileEntry); OutputStream outStream = new FileOutputStream(outFile); while (fileStream.available() > 0) { int read = fileStream.read(buf, 0, buf.length); outStream.write(buf, 0, read); } fileStream.close(); outStream.close(); outFile.setLastModified(fileEntry.getTime()); return true; }
public void connect() throws IOException { if (!connected) { String path = url.getPath(); Matcher matcher = urlPattern.matcher(path); if (matcher.matches()) { path = matcher.group(1); String subPath = matcher.group(2); JarURLConnection jarURLConnection = (JarURLConnection) new URL("jar:" + path).openConnection(); inputStream = jarURLConnection.getInputStream(); if (subPath.isEmpty() == false) { JarFile jar = retrieve(new URL(path), inputStream); String[] nodes = nestingSeparatorPattern.split(subPath); int i; for (i = 0; i < nodes.length - 1; i++) { path += "!/" + nodes[i]; jar = retrieve(new URL(path), inputStream); } ZipEntry entry = jar.getEntry(nodes[i]); entrySize = entry.getSize(); inputStream = jar.getInputStream(entry); } } else { throw new MalformedURLException("Invalid JAP URL path: " + path); } connected = true; } }
InMemorySourceRepository(@WillClose ZipInputStream in) throws IOException { try { while (true) { ZipEntry e = in.getNextEntry(); if (e == null) break; if (!e.isDirectory()) { String name = e.getName(); long size = e.getSize(); if (size > Integer.MAX_VALUE) throw new IOException(name + " is too big at " + size + " bytes"); ByteArrayOutputStream out; if (size <= 0) out = new ByteArrayOutputStream(); else out = new ByteArrayOutputStream((int) size); GZIPOutputStream gOut = new GZIPOutputStream(out); IO.copy(in, gOut); gOut.close(); byte data[] = out.toByteArray(); contents.put(name, data); lastModified.put(name, e.getTime()); } in.closeEntry(); } } finally { Util.closeSilently(in); } }
/** * Unzip an archive * * @param zipname the archive name, stored in the temp directory * @return boolean state indicating the unzip success */ private boolean UnzipLangArchive(String zipname) { ZipFile zipFile; // reset the statuses, thus we will be able to get the progress[%] status m_lMaxDownloadSz = GetZipSize(zipname); m_lCurrentDownloadSz = 0; try { zipFile = new ZipFile(zipname); Enumeration entries = zipFile.entries(); while (entries.hasMoreElements()) { ZipEntry entry = (ZipEntry) entries.nextElement(); String filename = entry.getName(); Log.v(TAG, "Extracting file: " + filename); if (!CopyInputStream(zipFile.getInputStream(entry), entry.getSize(), entry.getName())) return false; m_ParentProgressDialog.setProgress(GetDownloadStatus()); } zipFile.close(); } catch (IOException ioe) { Log.v(TAG, "exception:" + ioe.toString()); return false; } return true; }
/** * @return a mutable list * @throws IOException */ public static List<JSSourceFile> getDefaultExterns() throws IOException { InputStream input = CommandLineRunner.class.getResourceAsStream("/externs.zip"); ZipInputStream zip = new ZipInputStream(input); Map<String, JSSourceFile> externsMap = Maps.newHashMap(); for (ZipEntry entry = null; (entry = zip.getNextEntry()) != null; ) { LimitInputStream entryStream = new LimitInputStream(zip, entry.getSize()); externsMap.put( entry.getName(), JSSourceFile.fromInputStream( // Give the files an odd prefix, so that they do not conflict // with the user's files. "externs.zip//" + entry.getName(), entryStream)); } Preconditions.checkState( externsMap.keySet().equals(Sets.newHashSet(DEFAULT_EXTERNS_NAMES)), "Externs zip must match our hard-coded list of externs."); // Order matters, so the resources must be added to the result list // in the expected order. List<JSSourceFile> externs = Lists.newArrayList(); for (String key : DEFAULT_EXTERNS_NAMES) { externs.add(externsMap.get(key)); } return externs; }
protected void load(ZipFile zipfile) throws IOException { Enumeration entries = zipfile.entries(); while (entries.hasMoreElements()) { ZipEntry entry = (ZipEntry) entries.nextElement(); fireBeginFile(entry.getName()); Logger.getLogger(getClass()) .debug("Starting file " + entry.getName() + " (" + entry.getSize() + " bytes)"); byte[] bytes = null; InputStream in = null; try { in = zipfile.getInputStream(entry); bytes = readBytes(in); } finally { if (in != null) { try { in.close(); } catch (IOException ex) { // Ignore } } } Logger.getLogger(getClass()) .debug("Passing up file " + entry.getName() + " (" + bytes.length + " bytes)"); getLoader().load(entry.getName(), new ByteArrayInputStream(bytes)); fireEndFile(entry.getName()); } }
public byte[] patchClassInJar(String name, byte[] bytes, String ObfName, File location) { try { // open the jar as zip ZipFile zip = new ZipFile(location); // find the file inside the zip that is called te.class or // net.minecraft.entity.monster.EntityCreeper.class // replacing the . to / so it would look for net/minecraft/entity/monster/EntityCreeper.class ZipEntry entry = zip.getEntry(name.replace('.', '/') + ".class"); if (entry == null) { System.out.println(name + " not found in " + location.getName()); } else { // serialize the class file into the bytes array InputStream zin = zip.getInputStream(entry); bytes = new byte[(int) entry.getSize()]; zin.read(bytes); zin.close(); System.out.println("[" + "ExtraFood-patcher" + "]: " + "Class " + name + " patched!"); } zip.close(); } catch (Exception e) { throw new RuntimeException("Error overriding " + name + " from " + location.getName(), e); } // return the new bytes return bytes; }
/** * Checks the contents of the specified zip entry. * * @param file file to be checked * @param data expected file contents * @throws IOException I/O exception */ private static void checkEntry(final String file, final byte[] data) throws IOException { ZipFile zf = null; try { zf = new ZipFile(TMPZIP); final ZipEntry ze = zf.getEntry(file); assertNotNull("File not found: " + file, ze); final DataInputStream is = new DataInputStream(zf.getInputStream(ze)); final byte[] dt = new byte[(int) ze.getSize()]; is.readFully(dt); assertTrue( "Wrong contents in file \"" + file + "\":" + Prop.NL + "Expected: " + string(data) + Prop.NL + "Found: " + string(dt), eq(data, dt)); } finally { if (zf != null) zf.close(); } }
/** * 获得制定zip名称的输入流 * * @param is zip的输入流 * @param reportName 要获得的zip输入流名称 * @return 流 */ @SuppressWarnings("unchecked") public static void getZipReportInputStreamMap(InputStream is, Map<Object, Object> parameters) { ZipInputStream zis = new ZipInputStream(is); BufferedOutputStream dest = null; ZipEntry entry = null; ByteArrayOutputStream fos = null; try { while ((entry = zis.getNextEntry()) != null) { int count; byte data[] = new byte[BUFFER]; // write the files to the disk fos = new ByteArrayOutputStream((int) entry.getSize()); dest = new BufferedOutputStream(fos, BUFFER); while ((count = zis.read(data, 0, BUFFER)) != -1) { dest.write(data, 0, count); } dest.flush(); dest.close(); parameters.put(entry.getName(), new ByteArrayInputStream(fos.toByteArray())); } zis.close(); } catch (Exception e) { throw new ApplicationRuntimeException(e); } }
/* * Load a class from a file in an archive. We currently assume that * the file is a Zip archive. * * Returns null if the class wasn't found. */ private byte[] loadFromArchive(ZipFile zip, String name) { ZipEntry entry; entry = zip.getEntry(name); if (entry == null) return null; ByteArrayOutputStream byteStream; InputStream stream; int count; /* * Copy the data out of the stream. Because we got the ZipEntry * from a ZipFile, the uncompressed size is known, and we can set * the initial size of the ByteArrayOutputStream appropriately. */ try { stream = zip.getInputStream(entry); byteStream = new ByteArrayOutputStream((int) entry.getSize()); byte[] buf = new byte[4096]; while ((count = stream.read(buf)) > 0) byteStream.write(buf, 0, count); stream.close(); } catch (IOException ioex) { // System.out.println("Failed extracting '" + archive + "': " +ioex); return null; } // System.out.println(" loaded from Zip"); return byteStream.toByteArray(); }
// TODO - zipEntry might use extended local header protected void add(ZipEntry zipEntry, ZipFileEntryInputStream zipData, String password) throws IOException, UnsupportedEncodingException { AESEncrypter aesEncrypter = new AESEncrypterBC(password.getBytes("iso-8859-1")); ExtZipEntry entry = new ExtZipEntry(zipEntry.getName()); entry.setMethod(zipEntry.getMethod()); entry.setSize(zipEntry.getSize()); entry.setCompressedSize(zipEntry.getCompressedSize() + 28); entry.setTime(zipEntry.getTime()); entry.initEncryptedEntry(); zipOS.putNextEntry(entry); // ZIP-file data contains: 1. salt 2. pwVerification 3. encryptedContent 4. authenticationCode zipOS.writeBytes(aesEncrypter.getSalt()); zipOS.writeBytes(aesEncrypter.getPwVerification()); byte[] data = new byte[1024]; int read = zipData.read(data); while (read != -1) { aesEncrypter.encrypt(data, read); zipOS.writeBytes(data, 0, read); read = zipData.read(data); } byte[] finalAuthentication = aesEncrypter.getFinalAuthentication(); if (LOG.isLoggable(Level.FINE)) { LOG.fine( "finalAuthentication=" + Arrays.toString(finalAuthentication) + " at pos=" + zipOS.getWritten()); } zipOS.writeBytes(finalAuthentication); }
@Override protected Collection<cgCache> doImport() throws IOException, ParserException { Log.i(Settings.tag, "Import GPX zip file: " + cacheFile.getAbsolutePath()); ZipFile zipFile = new ZipFile(cacheFile); try { final String gpxName = getGpxFileNameForZipFileName(cacheFile.getName()); if (gpxName == null) { throw new ParserException(cacheFile.getName() + " is not a GPX zip file"); } final ZipEntry gpxEntry = zipFile.getEntry(gpxName); if (gpxEntry == null) { throw new ParserException(cacheFile.getName() + " is not a GPX zip file"); } importStepHandler.sendMessage( importStepHandler.obtainMessage( IMPORT_STEP_READ_FILE, R.string.gpx_import_loading_caches, (int) gpxEntry.getSize())); Collection<cgCache> caches; GPXParser parser; try { // try to parse cache file as GPX 10 parser = new GPX10Parser(listId); caches = parser.parse(zipFile.getInputStream(gpxEntry), progressHandler); } catch (ParserException pe) { // didn't work -> lets try GPX11 parser = new GPX11Parser(listId); caches = parser.parse(zipFile.getInputStream(gpxEntry), progressHandler); } final ZipEntry gpxWptsEntry = zipFile.getEntry(getWaypointsFileNameForGpxFileName(gpxName)); if (gpxWptsEntry != null) { Log.i(Settings.tag, "Import GPX waypoint file: " + gpxWptsEntry.getName()); importStepHandler.sendMessage( importStepHandler.obtainMessage( IMPORT_STEP_READ_WPT_FILE, R.string.gpx_import_loading_waypoints, (int) gpxWptsEntry.getSize())); caches = parser.parse(zipFile.getInputStream(gpxWptsEntry), progressHandler); } return caches; } finally { zipFile.close(); } }
@Test public void compressionCanBeSetOnAPerFileBasisAndIsHonoured() throws IOException { // Create some input that can be compressed. String packageName = getClass().getPackage().getName().replace(".", "/"); URL sample = Resources.getResource(packageName + "/sample-bytes.properties"); byte[] input = Resources.toByteArray(sample); try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output)) { CustomZipEntry entry = new CustomZipEntry("default"); // Don't set the compression level. Should be the default. out.putNextEntry(entry); out.write(input); entry = new CustomZipEntry("stored"); entry.setCompressionLevel(NO_COMPRESSION); byte[] bytes = "stored".getBytes(); entry.setSize(bytes.length); entry.setCrc(Hashing.crc32().hashBytes(bytes).padToLong()); out.putNextEntry(entry); out.write(bytes); entry = new CustomZipEntry("best"); entry.setCompressionLevel(BEST_COMPRESSION); out.putNextEntry(entry); out.write(input); } try (ZipInputStream in = new ZipInputStream(Files.newInputStream(output))) { ZipEntry entry = in.getNextEntry(); assertEquals("default", entry.getName()); ByteStreams.copy(in, ByteStreams.nullOutputStream()); long defaultCompressedSize = entry.getCompressedSize(); assertNotEquals(entry.getCompressedSize(), entry.getSize()); entry = in.getNextEntry(); ByteStreams.copy(in, ByteStreams.nullOutputStream()); assertEquals("stored", entry.getName()); assertEquals(entry.getCompressedSize(), entry.getSize()); entry = in.getNextEntry(); ByteStreams.copy(in, ByteStreams.nullOutputStream()); assertEquals("best", entry.getName()); ByteStreams.copy(in, ByteStreams.nullOutputStream()); assertThat(entry.getCompressedSize(), lessThan(defaultCompressedSize)); } }
public PackerItem(final ZipEntry zipEntry) { this.isDirectory = zipEntry.isDirectory(); this.name = zipEntry.getName(); this.compressedSize = zipEntry.getCompressedSize(); this.size = zipEntry.getSize(); this.time = zipEntry.getTime(); this.compression = Integer.MIN_VALUE; }
public long UnpackSize() { long size = 0; for (String path : paths) { ZipEntry entry = zipfile.getEntry(path); if (entry != null) size += entry.getSize(); } return size; }
/** * Finds and loads all classes that derive from a given set of super classes. * * <p>As a side-effect this will load and cache most, if not all, classes in the input JAR file. * * @param packageFilter Base name of package of classes to find. Use an empty string to find * everyting. * @param superClasses The super classes of all the classes to find. * @return An hash map which keys are the super classes looked for and which values are ArrayList * of the classes found. The array lists are always created for all the valid keys, they are * simply empty if no deriving class is found for a given super class. * @throws IOException * @throws InvalidAttributeValueException * @throws ClassFormatError */ @Override public HashMap<String, ArrayList<IClassDescriptor>> findClassesDerivingFrom( String packageFilter, String[] superClasses) throws IOException, InvalidAttributeValueException, ClassFormatError { packageFilter = packageFilter.replaceAll("\\.", "/"); // $NON-NLS-1$ //$NON-NLS-2$ HashMap<String, ArrayList<IClassDescriptor>> mClassesFound = new HashMap<String, ArrayList<IClassDescriptor>>(); for (String className : superClasses) { mClassesFound.put(className, new ArrayList<IClassDescriptor>()); } // create streams to read the intermediary archive FileInputStream fis = new FileInputStream(mOsFrameworkLocation); ZipInputStream zis = new ZipInputStream(fis); ZipEntry entry; while ((entry = zis.getNextEntry()) != null) { // get the name of the entry and convert to a class binary name String entryPath = entry.getName(); if (!entryPath.endsWith(AdtConstants.DOT_CLASS)) { // only accept class files continue; } if (packageFilter.length() > 0 && !entryPath.startsWith(packageFilter)) { // only accept stuff from the requested root package. continue; } String className = entryPathToClassName(entryPath); Class<?> loaded_class = mClassCache.get(className); if (loaded_class == null) { byte[] data = mEntryCache.get(className); if (data == null) { // Get the class and cache it long entrySize = entry.getSize(); if (entrySize > Integer.MAX_VALUE) { throw new InvalidAttributeValueException(); } data = readZipData(zis, (int) entrySize); } loaded_class = defineAndCacheClass(className, data); } for (Class<?> superClass = loaded_class.getSuperclass(); superClass != null; superClass = superClass.getSuperclass()) { String superName = superClass.getCanonicalName(); if (mClassesFound.containsKey(superName)) { mClassesFound.get(superName).add(new ClassWrapper(loaded_class)); break; } } } return mClassesFound; }
private void useFileName() { try { ZipFile zf = new ZipFile(jarFileName); Enumeration e = zf.entries(); while (e.hasMoreElements()) { ZipEntry ze = (ZipEntry) e.nextElement(); dump(ze); htSizes.put(ze.getName(), new Integer((int) ze.getSize())); } zf.close(); FileInputStream fis = new FileInputStream(jarFileName); BufferedInputStream bis = new BufferedInputStream(fis); ZipInputStream zis = new ZipInputStream(bis); ZipEntry ze = null; while ((ze = zis.getNextEntry()) != null) { if (ze.isDirectory()) { continue; } dump(ze); int size = (int) ze.getSize(); if (size == -1) { size = ((Integer) htSizes.get(ze.getName())).intValue(); } byte[] b = new byte[(int) size]; int rb = 0; int chunk = 0; while (((int) size - rb) > 0) { chunk = zis.read(b, rb, (int) size - rb); if (chunk == -1) { break; } rb += chunk; } htJarContents.put(ze.getName(), b); dump(ze, rb, size); } zis.close(); } catch (NullPointerException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
protected long getSize() throws IOException { ZipFile zf = new ZipFile(archiveFile); try { ZipEntry ze = zf.getEntry(this.resName); return ze == null ? 0L : ze.getSize(); } finally { zf.close(); } }
public static File unzipByteArrayIntoDirectory(byte[] input, File directory, boolean overwrite) { try { if (!directory.exists()) { directory.mkdirs(); directory.mkdir(); if (!directory.exists()) { throw new IllegalStateException("could not create directory " + directory); } } else { if (!overwrite) { throw new IllegalStateException( "overwrite is false and file " + directory + " does exist"); } else if (!directory.isDirectory()) { throw new IllegalArgumentException("file " + directory + " is NOT an directory"); } } long start = System.currentTimeMillis(); ByteArrayInputStream bos = new ByteArrayInputStream(input); ZipInputStream in = new ZipInputStream(bos); ZipEntry entry = null; while ((entry = in.getNextEntry()) != null) { String oriName = entry.getName(); String filename = directory.getAbsolutePath() + File.separator + oriName; if (entry.isDirectory()) { if (log.isDebugEnabled()) log.debug("creating directory " + oriName); File f = new File(filename); f.mkdirs(); f.mkdir(); } else { int uncompressedSize = (int) entry.getSize(); if (uncompressedSize > -1) { byte[] b = new byte[uncompressedSize]; in.read(b); FileOutputStream fis = new FileOutputStream(filename); fis.write(b); fis.flush(); fis.close(); if (log.isDebugEnabled()) log.debug("unzipped entry " + filename); } } long end1 = System.currentTimeMillis(); } long end = System.currentTimeMillis(); if (log.isDebugEnabled()) log.debug("whole decompression took " + (end - start)); return directory; } catch (IOException e) { return null; } }
/** 通过流的方法暂时不可用---此处只作保留 */ private void useStream() { try { ZipInputStream ztop = new ZipInputStream(stream1); ZipEntry ztmp = null; while ((ztmp = ztop.getNextEntry()) != null) { dump(ztmp); htSizes.put(ztmp.getName(), new Integer((int) ztmp.getSize())); } ztop.close(); BufferedInputStream bis = new BufferedInputStream(stream2); ZipInputStream zis = new ZipInputStream(bis); ZipEntry ze = null; while ((ze = zis.getNextEntry()) != null) { if (ze.isDirectory()) { continue; } dump(ze); int size = (int) ze.getSize(); if (size == -1) { size = ((Integer) htSizes.get(ze.getName())).intValue(); } System.out.println("size--->" + size); byte[] b = new byte[(int) size]; int rb = 0; int chunk = 0; while (((int) size - rb) > 0) { chunk = zis.read(b, rb, (int) size - rb); if (chunk == -1) { break; } rb += chunk; } htJarContents.put(ze.getName(), b); dump(ze); } } catch (NullPointerException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
public AesZipEntry(ZipEntry zipEntry) { super(zipEntry.getName()); super.setMethod(zipEntry.getMethod()); super.setSize(zipEntry.getSize()); super.setCompressedSize(zipEntry.getCompressedSize() + 28); super.setTime(zipEntry.getTime()); flag |= 1; // bit0 - encrypted // flag |= 8; // bit3 - use data descriptor }
/** @see java.net.URLConnection#getContentLength() */ @Override public int getContentLength() { if (connected) { if (directAccess != null) return (int) directAccess.length(); if (zipFile != null && nameEntries != null && nameEntries.size() == 1) { ZipEntry entry = zipFile.getEntry(nameEntries.get(0)); if (entry != null) return (int) entry.getSize(); } } return -1; }