/**
* Unzip a zip file into a directory.
*
* @param zipFile The zip file to be unzipped.
* @param dest the destination directory.
* @throws IOException if the destination does not exist or is not a directory, or if the zip file
* cannot be extracted.
*/
public static void unzip(ZipFile zipFile, File dest) throws IOException {
Enumeration<? extends ZipEntry> entries = zipFile.entries();
if (dest.exists() && dest.isDirectory()) {
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (!entry.isDirectory()) {
File destFile = new File(dest, entry.getName());
createFileWithPath(destFile);
InputStream in = new BufferedInputStream(zipFile.getInputStream(entry));
OutputStream out = new BufferedOutputStream(new FileOutputStream(destFile));
byte[] buffer = new byte[2048];
for (; ; ) {
int nBytes = in.read(buffer);
if (nBytes <= 0) break;
out.write(buffer, 0, nBytes);
}
out.flush();
out.close();
in.close();
}
}
} else {
throw new IOException(
"Destination " + dest.getAbsolutePath() + " is not a directory or does not exist");
}
}
/** @throws IOException */
@Override
protected final void setImageZipEntries() throws IOException {
final File folder = file.getInputFile();
ZipFile zipFolder = new ZipFile(folder);
final Enumeration enumeration = zipFolder.entries();
ZipEntry zipEntry;
List<ZipEntry> tempSource = new ArrayList<ZipEntry>();
final Pattern bandFilenamePattern = Pattern.compile("band[\\d]");
while (enumeration.hasMoreElements()) {
zipEntry = (ZipEntry) enumeration.nextElement();
if (bandFilenamePattern
.matcher(LandsatUtils.getZipEntryFileName(zipEntry).toLowerCase())
.matches()) {
tempSource.add(zipEntry);
}
}
Collections.sort(
tempSource,
new Comparator<ZipEntry>() {
public int compare(ZipEntry entry1, ZipEntry entry2) {
String entry1FileName = LandsatUtils.getZipEntryFileName(entry1);
String entry2FileName = LandsatUtils.getZipEntryFileName(entry2);
return entry1FileName.compareTo(entry2FileName);
}
});
imageSources = tempSource.toArray();
}
@Test
public void includeAsClasses() throws Exception {
String baseDir = testIssue("flexmojos-247").getBasedir();
File target = new File(baseDir, "target");
Assert.assertTrue(target.exists());
File swc = new File(target, "flexmojos-247-1.0-SNAPSHOT.swc");
Assert.assertTrue(swc.exists());
String catalog;
ZipFile zf = new ZipFile(swc);
try {
InputStream in = zf.getInputStream(zf.getEntry("catalog.xml"));
catalog = IOUtils.toString(in);
in.close();
} finally {
zf.close();
}
// must have both classes and the uri
MatcherAssert.assertThat(catalog, StringContains.containsString("AClass"));
MatcherAssert.assertThat(catalog, StringContains.containsString("BClass"));
MatcherAssert.assertThat(
catalog, StringContains.containsString("http://flexmojos.sonatype.org/tests"));
}
public static void registerModInJar(String modid, File jar) {
try {
ZipFile zipfile = new ZipFile(jar);
Enumeration enumeration = zipfile.entries();
while (enumeration.hasMoreElements()) {
ZipEntry zipentry = (ZipEntry) enumeration.nextElement();
String fileName = zipentry.getName();
Path path1 = Paths.get(fileName);
Path path2 = Paths.get("assets", modid, "books");
if (path1.startsWith(path2)) {
try {
String json = IOUtils.toString(zipfile.getInputStream(zipentry));
BookData data =
BookRegistry.register(GsonClientHelper.getGson().fromJson(json, BookData.class));
ELogger.log(
Level.INFO,
"Successfully loaded in the book with the unique identifier: "
+ data.uniqueName
+ " for the language: "
+ data.language);
} catch (Exception e) {
e.printStackTrace();
}
}
}
zipfile.close();
} catch (Exception e) {
}
}
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;
}
@Override
@Nullable
Resource getResource(String name, boolean flag) {
JarMemoryLoader loader = myMemoryLoader != null ? myMemoryLoader.get() : null;
if (loader != null) {
Resource resource = loader.getResource(name);
if (resource != null) return resource;
}
try {
ZipFile zipFile = getZipFile();
try {
ZipEntry entry = zipFile.getEntry(name);
if (entry != null) {
return MemoryResource.load(getBaseURL(), zipFile, entry, myAttributes);
}
} finally {
releaseZipFile(zipFile);
}
} catch (Exception e) {
error("file: " + myCanonicalFile, e);
}
return null;
}
private InputStream getInputStreamFromFprFile(File file) throws IOException {
final ZipFile fprFile = new ZipFile(file);
try {
final InputStream reportStream =
fprFile.getInputStream(fprFile.getEntry(FortifyConstants.AUDIT_FVDL_FILE));
return new InputStream() {
@Override
public int read() throws IOException {
return reportStream.read();
}
@Override
public void close() throws IOException {
try {
reportStream.close();
} finally {
fprFile.close();
}
}
};
} catch (IOException e) {
fprFile.close();
throw e;
}
}
public void testCoverageContents() throws Exception {
final Long processId = issueProcessAndWaitForTermination();
final String request = RESTLET_PATH + "/" + processId.longValue();
final MockHttpServletResponse response = getAsServletResponse(request);
assertEquals(Status.SUCCESS_OK, Status.valueOf(response.getStatus()));
assertEquals(MediaType.APPLICATION_ZIP, MediaType.valueOf(response.getContentType()));
final ByteArrayInputStream responseStream = getBinaryInputStream(response);
File dataDirectoryRoot = super.getTestData().getDataDirectoryRoot();
File file = new File(dataDirectoryRoot, "testCoverageContents.zip");
super.getTestData().copyTo(responseStream, file.getName());
ZipFile zipFile = new ZipFile(file);
try {
// TODO: change this expectation once we normalize the raster file name
String rasterName = RASTER_LAYER.getPrefix() + ":" + RASTER_LAYER.getLocalPart() + ".tiff";
ZipEntry nextEntry = zipFile.getEntry(rasterName);
assertNotNull(nextEntry);
InputStream coverageInputStream = zipFile.getInputStream(nextEntry);
// Use a file, geotiffreader might not work well reading out of a plain input stream
File covFile = new File(file.getParentFile(), "coverage.tiff");
IOUtils.copy(coverageInputStream, covFile);
GeoTiffReader geoTiffReader = new GeoTiffReader(covFile);
GridCoverage2D coverage = geoTiffReader.read(null);
CoordinateReferenceSystem crs = coverage.getCoordinateReferenceSystem();
assertEquals(CRS.decode("EPSG:4326", true), crs);
} finally {
zipFile.close();
}
}
/** @see java.net.URLConnection#connect() */
@Override
public void connect() throws IOException {
this.connected = true;
String file = url.getFile();
int index = file.indexOf("!/");
if (index == -1) {
// It is a direct file access
this.directAccess = new File(file);
if (!directAccess.exists())
throw new FileNotFoundException("Cannot find the file at " + file);
if (directAccess.isDirectory()) throw new IOException("A file was expected at " + file);
return;
}
File f = new File(file.substring(0, index));
if (!f.exists())
throw new FileNotFoundException("Cannot find the file at " + f.getAbsolutePath());
if (f.isDirectory()) throw new IOException("A zip file was expected at " + f.getAbsolutePath());
this.zipFile = new ZipFile(f);
try {
int fromIndex = index + 2;
index = file.indexOf("!/", fromIndex);
String nameEntry;
if (index == -1) nameEntry = file.substring(fromIndex);
else nameEntry = file.substring(fromIndex, index);
ZipEntry entry = zipFile.getEntry(nameEntry);
if (entry == null)
throw new FileNotFoundException(
"Cannot find the file at " + file.substring(0, index == -1 ? file.length() : index));
if (zipFile.getEntry(nameEntry + "/") != null)
throw new IOException(
"A "
+ (index == -1 ? "" : "zip")
+ " file was expected at "
+ file.substring(0, index == -1 ? file.length() : index));
nameEntries = new ArrayList<String>();
nameEntries.add(nameEntry);
if (index == -1) {
// there is no more entries
return;
}
nameEntry = file.substring(index + 2);
// We add it without checking if it exists to avoid reading twice the ZipInputStream
nameEntries.add(nameEntry);
} catch (IOException e) {
try {
zipFile.close();
} catch (IOException e2) {
LOG.debug("Could not close the zip file");
}
throw e;
} catch (RuntimeException e) {
try {
zipFile.close();
} catch (IOException e2) {
LOG.debug("Could not close the zip file");
}
throw e;
}
}
public static void unzip(File dest, String jar) throws IOException {
dest.mkdirs();
ZipFile zf = new ZipFile(jar);
try {
Enumeration es = zf.entries();
while (es.hasMoreElements()) {
ZipEntry je = (ZipEntry) es.nextElement();
String n = je.getName();
File f = new File(dest, n);
if (je.isDirectory()) {
f.mkdirs();
} else {
if (f.exists()) {
f.delete();
} else {
f.getParentFile().mkdirs();
}
InputStream is = zf.getInputStream(je);
FileOutputStream os = new FileOutputStream(f);
try {
copyStream(is, os);
} finally {
os.close();
}
}
long time = je.getTime();
if (time != -1) f.setLastModified(time);
}
} finally {
zf.close();
}
}
/*
* 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();
}
@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);
}
@NotNull
private EntryInfo getOrCreate(
@NotNull String entryName, Map<String, EntryInfo> map, @NotNull ZipFile zip) {
EntryInfo info = map.get(entryName);
if (info == null) {
ZipEntry entry = zip.getEntry(entryName + "/");
if (entry != null) {
return getOrCreate(entry, map, zip);
}
Pair<String, String> path = splitPath(entryName);
EntryInfo parentInfo = getOrCreate(path.first, map, zip);
info =
store(map, parentInfo, path.second, true, DEFAULT_LENGTH, DEFAULT_TIMESTAMP, entryName);
}
if (!info.isDirectory) {
Logger.getInstance(getClass())
.info(zip.getName() + ": " + entryName + " should be a directory");
info = store(map, info.parent, info.shortName, true, info.length, info.timestamp, entryName);
}
return info;
}
public static void main(final String[] args) throws IOException {
File f = new File("pokus.zip");
// ZipFile zf = new ZipFile(f, ZipFile.OPEN_READ);
// ZipFile zf = new ZipFile(f, ZipFile.OPEN_READ | ZipFile.OPEN_DELETE);
ZipFile zf = new ZipFile(f, ZipFile.OPEN_DELETE);
System.out.println("pocet zapakovanych polozek: " + zf.size());
}
public static Part getBinaryPart(ZipFile zf, ContentTypeManager ctm, String resolvedPartUri)
throws Docx4JException {
Part part = null;
InputStream in = null;
try {
in = zf.getInputStream(zf.getEntry(resolvedPartUri));
part = new BinaryPart(new PartName("/" + resolvedPartUri));
if (conserveMemory) {
((BinaryPart) part).setBinaryDataRef(zf.getName(), resolvedPartUri);
} else {
((BinaryPart) part).setBinaryData(in);
}
log.info("Stored as BinaryData");
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException exc) {
exc.printStackTrace();
}
}
}
return part;
}
public static final boolean unzip(File file, File target) throws MojoExecutionException {
Enumeration entries;
ZipFile zipFile;
display(" --- Extracting ---");
try {
zipFile = new ZipFile(file);
entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
if (entry.isDirectory()) {
display(" + " + entry.getName());
File newFolder = new File(target + "/" + entry.getName());
newFolder.mkdir();
continue;
}
display(" " + entry.getName());
copyInputStream(
zipFile.getInputStream(entry),
new BufferedOutputStream(new FileOutputStream(target + "/" + entry.getName())));
}
zipFile.close();
return true;
} catch (IOException ioe) {
throw new MojoExecutionException("Unzip Error", ioe);
}
}
private boolean installBundle(ZipFile zipFile, String location, Application application) {
log.info("processLibsBundle entryName " + location);
this.bundleDebug.installExternalBundle(location);
String fileNameFromEntryName = Utils.getFileNameFromEntryName(location);
String packageNameFromEntryName = Utils.getPackageNameFromEntryName(location);
if (packageNameFromEntryName == null || packageNameFromEntryName.length() <= 0) {
return false;
}
File archvieFile =
new File(new File(application.getFilesDir().getParentFile(), "lib"), fileNameFromEntryName);
if (OpenAtlas.getInstance().getBundle(packageNameFromEntryName) != null) {
return false;
}
try {
if (archvieFile.exists()) {
OpenAtlas.getInstance().installBundle(packageNameFromEntryName, archvieFile);
} else {
OpenAtlas.getInstance()
.installBundle(
packageNameFromEntryName, zipFile.getInputStream(zipFile.getEntry(location)));
}
log.info("Succeed to install bundle " + packageNameFromEntryName);
return true;
} catch (Throwable e) {
Log.e("BundlesInstaller", "Could not install bundle.", e);
return false;
}
}
private static void search(File[] files) {
try {
for (File f : files) {
if (f.isDirectory()) {
search(f.listFiles());
} else {
ZipFile jar = new ZipFile(f);
Enumeration enumration = jar.entries();
while (enumration.hasMoreElements()) {
ZipEntry zipEntry = (ZipEntry) enumration.nextElement();
InputStreamReader isr = new InputStreamReader(jar.getInputStream(zipEntry));
BufferedReader br = new BufferedReader(isr);
String line = br.readLine();
int line_num = 1;
while (null != line) {
// System.out.println(line);
if (line.toLowerCase().contains(keywords.toLowerCase())) {
System.out.println(
f.getPath() + "," + zipEntry.getName() + "," + "line number = " + line_num);
}
line = br.readLine();
line_num++;
}
}
}
}
} catch (ZipException z_e) {
z_e.printStackTrace();
} catch (IOException io_e) {
io_e.printStackTrace();
}
}
/**
* overriding getResource() because we want to search FIRST in this ClassLoader, then the parent,
* the path, etc.
*/
public URL getResource(String name) {
try {
if (jar != null) {
ZipFile zipFile = jar.getZipFile();
ZipEntry entry = zipFile.getEntry(name);
if (entry != null) {
return new URL(getResourceAsPath(name));
}
}
Object obj = resourcesHash.get(name);
if (obj instanceof JARClassLoader) {
JARClassLoader classLoader = (JARClassLoader) obj;
return classLoader.getResource(name);
} else {
URL ret = getSystemResource(name);
if (ret != null) {
Log.log(
Log.DEBUG,
JARClassLoader.class,
"Would have returned null for getResource(" + name + ")");
Log.log(Log.DEBUG, JARClassLoader.class, "returning(" + ret + ")");
}
return ret;
}
} catch (IOException io) {
Log.log(Log.ERROR, this, io);
return null;
}
} // }}}
/**
* 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;
}
public byte[] getBytes() throws EGLModelException {
EGLElement pkg = (EGLElement) getParent();
if (pkg instanceof EglarPackageFragment) {
EglarPackageFragmentRoot root = (EglarPackageFragmentRoot) pkg.getParent();
ZipFile zip = null;
try {
zip = root.getJar();
String entryName =
CharOperation.concatWith(((PackageFragment) pkg).names, getElementName(), '/');
ZipEntry ze = zip.getEntry(entryName);
if (ze != null) {
return org.eclipse.edt.ide.core.internal.model.util.Util.getZipEntryByteContent(ze, zip);
}
throw new EGLModelException(
new EGLModelStatus(IEGLModelStatusConstants.ELEMENT_DOES_NOT_EXIST, this));
} catch (IOException ioe) {
throw new EGLModelException(ioe, IEGLModelStatusConstants.IO_EXCEPTION);
} catch (CoreException e) {
if (e instanceof EGLModelException) {
throw (EGLModelException) e;
} else {
throw new EGLModelException(e);
}
} finally {
EGLModelManager.getEGLModelManager().closeZipFile(zip);
}
} else {
IFile file = (IFile) getResource();
return Util.getResourceContentsAsByteArray(file);
}
}
public Properties searchForVersionProperties() {
try {
FMLLog.log(
getModId(),
Level.FINE,
"Attempting to load the file version.properties from %s to locate a version number for %s",
getSource().getName(),
getModId());
Properties version = null;
if (getSource().isFile()) {
ZipFile source = new ZipFile(getSource());
ZipEntry versionFile = source.getEntry("version.properties");
if (versionFile != null) {
version = new Properties();
version.load(source.getInputStream(versionFile));
}
source.close();
} else if (getSource().isDirectory()) {
File propsFile = new File(getSource(), "version.properties");
if (propsFile.exists() && propsFile.isFile()) {
version = new Properties();
FileInputStream fis = new FileInputStream(propsFile);
version.load(fis);
fis.close();
}
}
return version;
} catch (Exception e) {
Throwables.propagateIfPossible(e);
FMLLog.log(getModId(), Level.FINEST, "Failed to find a usable version.properties file");
return null;
}
}
protected void unpackComponents() throws IOException, FileNotFoundException {
File applicationPackage = new File(getApplication().getPackageResourcePath());
File componentsDir = new File(sGREDir, "components");
if (componentsDir.lastModified() == applicationPackage.lastModified()) return;
componentsDir.mkdir();
componentsDir.setLastModified(applicationPackage.lastModified());
GeckoAppShell.killAnyZombies();
ZipFile zip = new ZipFile(applicationPackage);
byte[] buf = new byte[32768];
try {
if (unpackFile(zip, buf, null, "removed-files")) removeFiles();
} catch (Exception ex) {
// This file may not be there, so just log any errors and move on
Log.w(LOG_FILE_NAME, "error removing files", ex);
}
// copy any .xpi file into an extensions/ directory
Enumeration<? extends ZipEntry> zipEntries = zip.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = zipEntries.nextElement();
if (entry.getName().startsWith("extensions/") && entry.getName().endsWith(".xpi")) {
Log.i("GeckoAppJava", "installing extension : " + entry.getName());
unpackFile(zip, buf, entry, entry.getName());
}
}
}
/**
* extracts class files from jar/zip archive to specified path. See <code>IDecompiler</code>
* documentation for the format of pareameters.
*/
public static void extract(
String archivePath, String packege, String className, boolean inner, String to)
throws IOException {
ZipFile archive = new ZipFile(archivePath);
List entries = findRelevant(archive, packege, className, inner);
InputStream in = null;
OutputStream out = null;
byte[] buffer = new byte[2048];
ZipEntry entry;
String outFile;
int lastSep, amountRead;
for (int i = 0; i < entries.size(); i++) {
entry = (ZipEntry) entries.get(i);
outFile = entry.getName();
if ((lastSep = outFile.lastIndexOf('/')) != -1) outFile = outFile.substring(lastSep);
try {
in = archive.getInputStream(entry);
if (in == null) throw new IOException("Zip file entry <" + entry.getName() + "> not found");
out = new FileOutputStream(to + File.separator + outFile);
while ((amountRead = in.read(buffer)) != -1) out.write(buffer, 0, amountRead);
} finally {
if (in != null) in.close();
if (out != null) out.close();
}
}
}
private String readFromZipFile(String filename) {
ZipFile zip = null;
String str = null;
try {
InputStream fileStream = null;
File applicationPackage = new File(mActivity.getApplication().getPackageResourcePath());
zip = new ZipFile(applicationPackage);
if (zip == null) return null;
ZipEntry fileEntry = zip.getEntry(filename);
if (fileEntry == null) return null;
fileStream = zip.getInputStream(fileEntry);
str = readStringFromStream(fileStream);
} catch (IOException ioe) {
Log.e(LOGTAG, "error reading zip file: " + filename, ioe);
} finally {
try {
if (zip != null) zip.close();
} catch (IOException ioe) {
// catch this here because we can continue even if the
// close failed
Log.e(LOGTAG, "error closing zip filestream", ioe);
}
}
return str;
}
private void addExportedPackages(Set allpackages, ArrayList instructions, File file)
throws ZipException, IOException {
if (file.isDirectory()) {
DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir(file);
ds.setIncludes(new String[] {"**"});
ds.scan();
String[] files = ds.getIncludedFiles();
for (int i = 0; i < files.length; i++) {
String pkg = getPackage(files[i]);
if (pkg != null && !excluded(instructions, pkg)) {
allpackages.add(pkg);
}
}
} else {
ZipFile zip = new ZipFile(file);
try {
Enumeration entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
String pkg = getPackage(entry.getName());
if (pkg != null && !excluded(instructions, pkg)) {
allpackages.add(pkg);
}
}
} finally {
zip.close();
}
}
}
private void removePreviousModVersion(String modName, String installedVersion) {
try {
// Mod has been previously installed uninstall previous version
File previousModZip = new File(cacheDir, modName + "-" + installedVersion + ".zip");
ZipFile zf = new ZipFile(previousModZip);
Enumeration<? extends ZipEntry> entries = zf.entries();
// Go through zipfile of previous version and delete all file from
// Modpack that exist in the zip
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (entry.isDirectory()) {
continue;
}
File file = new File(GameUpdater.modpackDir, entry.getName());
Util.log("Deleting '%s'", entry.getName());
if (file.exists()) {
// File from mod exists.. delete it
file.delete();
}
}
InstalledModsYML.removeMod(modName);
} catch (IOException e) {
e.printStackTrace();
}
}
private static InputStream getInputStreamFromZippedPart(ZipFile zf, String partName)
throws IOException {
InputStream in = null;
in = zf.getInputStream(zf.getEntry(partName));
return in;
}
private void checkLoadedModForPermissionClass(File modFile) {
try {
Pattern p = Pattern.compile("permission", Pattern.CASE_INSENSITIVE);
if (modFile.isDirectory()) {
for (File file : modFile.listFiles()) {
checkLoadedModForPermissionClass(file);
}
} else if ((modFile.getName().endsWith(".zip")) || (modFile.getName().endsWith(".jar"))) {
ZipFile zip = new ZipFile(modFile);
Enumeration entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry zipentry = (ZipEntry) entries.nextElement();
if (zipentry != null
&& zipentry.getName().endsWith(".class")
&& p.matcher(zipentry.getName()).find()) {
checkLoadedClass(zip.getInputStream(zipentry));
}
}
zip.close();
} else if (modFile.getName().endsWith(".class") && p.matcher(modFile.getName()).find()) {
checkLoadedClass(new FileInputStream(modFile));
}
} catch (IOException e) {
}
}
public static final void unzip(File zip, File extractTo) throws IOException {
ZipFile archive = new ZipFile(zip);
Enumeration e = archive.entries();
while (e.hasMoreElements()) {
ZipEntry entry = (ZipEntry) e.nextElement();
File file = new File(extractTo, entry.getName());
if (entry.isDirectory() && !file.exists()) {
file.mkdirs();
} else {
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();
}
InputStream in = archive.getInputStream(entry);
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
byte[] buffer = new byte[8192];
int read;
while (-1 != (read = in.read(buffer))) {
out.write(buffer, 0, read);
}
in.close();
out.close();
}
}
}