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());
}
}
private void deflate(String tmpDir, String path) {
String tmpFile = "tmp-" + Utils.timestamp() + ".zip";
try {
ZipFile zipFile = new ZipFile(tmpFile);
ZipParameters parameters = new ZipParameters();
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE);
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
parameters.setIncludeRootFolder(false);
zipFile.addFolder(tmpDir, parameters);
} catch (Exception e) {
e.printStackTrace();
return;
}
File from = null;
File to = null;
try {
File target = new File(path);
if (target.exists()) FileUtils.forceDelete(target);
from = new File(tmpFile);
to = new File(path);
FileUtils.moveFile(from, to);
} catch (IOException e) {
Utils.onError(new Error.FileMove(tmpFile, path));
}
try {
FileUtils.deleteDirectory(new File(tmpDir));
} catch (IOException e) {
Utils.log("can't delete temporary folder");
}
}
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());
}
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());
}
}
}
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;
}
protected void load(String filename) {
Logger.getLogger(getClass()).debug("Starting group in file " + filename);
ZipFile zipfile = null;
try {
zipfile = new ZipFile(filename);
fireBeginGroup(filename, zipfile.size());
Logger.getLogger(getClass()).debug("Loading ZipFile " + filename);
load(zipfile);
Logger.getLogger(getClass()).debug("Loaded ZipFile " + filename);
fireEndGroup(filename);
} catch (IOException ex) {
Logger.getLogger(getClass()).error("Cannot load Zip file \"" + filename + "\"", ex);
} finally {
if (zipfile != null) {
try {
zipfile.close();
} catch (IOException ex) {
// Ignore
}
}
}
}
/** Lists contents of JAR file, via ZipFile. */
void list(String fname, String files[]) throws IOException {
ZipFile zf = new ZipFile(fname);
Enumeration<? extends ZipEntry> zes = zf.entries();
while (zes.hasMoreElements()) {
printEntry(zes.nextElement(), files);
}
zf.close();
}
public static void main(String[] args) throws Exception {
Reader trainingFile = null;
// Process arguments
int restArgs = commandOptions.processOptions(args);
// Check arguments
if (restArgs != args.length) {
commandOptions.printUsage(true);
throw new IllegalArgumentException("Unexpected arg " + args[restArgs]);
}
if (trainFileOption.value == null) {
commandOptions.printUsage(true);
throw new IllegalArgumentException("Expected --train-file FILE");
}
if (modelFileOption.value == null) {
commandOptions.printUsage(true);
throw new IllegalArgumentException("Expected --model-file FILE");
}
// Get the CRF structure specification.
ZipFile zipFile = new ZipFile(modelFileOption.value);
ZipEntry zipEntry = zipFile.getEntry("crf-info.xml");
CRFInfo crfInfo = new CRFInfo(zipFile.getInputStream(zipEntry));
StringBuffer crfInfoBuffer = new StringBuffer();
BufferedReader reader =
new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry)));
String line;
while ((line = reader.readLine()) != null) {
crfInfoBuffer.append(line).append('\n');
}
reader.close();
// Create the CRF, and train it.
CRF4 crf = createCRF(trainFileOption.value, crfInfo);
// Create a new zip file for our output. This will overwrite
// the file we used for input.
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(modelFileOption.value));
// Copy the CRF info xml to the output zip file.
zos.putNextEntry(new ZipEntry("crf-info.xml"));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(zos));
writer.write(crfInfoBuffer.toString());
writer.flush();
zos.closeEntry();
// Save the CRF classifier model to the output zip file.
zos.putNextEntry(new ZipEntry("crf-model.ser"));
ObjectOutputStream oos = new ObjectOutputStream(zos);
oos.writeObject(crf);
oos.flush();
zos.closeEntry();
zos.close();
}
public void installFramework(File frameFile, String tag) throws AndrolibException {
InputStream in = null;
ZipOutputStream out = null;
try {
ZipFile zip = new ZipFile(frameFile);
ZipEntry entry = zip.getEntry("resources.arsc");
if (entry == null) {
throw new AndrolibException("Can't find resources.arsc file");
}
in = zip.getInputStream(entry);
byte[] data = IOUtils.toByteArray(in);
ARSCData arsc = ARSCDecoder.decode(new ByteArrayInputStream(data), true, true);
publicizeResources(data, arsc.getFlagsOffsets());
File outFile =
new File(
getFrameworkDir(),
String.valueOf(arsc.getOnePackage().getId())
+ (tag == null ? "" : '-' + tag)
+ ".apk");
out = new ZipOutputStream(new FileOutputStream(outFile));
out.setMethod(ZipOutputStream.STORED);
CRC32 crc = new CRC32();
crc.update(data);
entry = new ZipEntry("resources.arsc");
entry.setSize(data.length);
entry.setCrc(crc.getValue());
out.putNextEntry(entry);
out.write(data);
LOGGER.info("Framework installed to: " + outFile);
} catch (ZipException ex) {
throw new AndrolibException(ex);
} catch (IOException ex) {
throw new AndrolibException(ex);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ex) {
}
}
if (out != null) {
try {
out.close();
} catch (IOException ex) {
}
}
}
}
// Take a tree of files starting in a directory in a zip file
// and copy them to a disk directory, recreating the tree.
private int unpackZipFile(
File inZipFile, String directory, String parent, boolean suppressFirstPathElement) {
int count = 0;
if (!inZipFile.exists()) return count;
parent = parent.trim();
if (!parent.endsWith(File.separator)) parent += File.separator;
if (!directory.endsWith(File.separator)) directory += File.separator;
File outFile = null;
try {
ZipFile zipFile = new ZipFile(inZipFile);
Enumeration zipEntries = zipFile.entries();
while (zipEntries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) zipEntries.nextElement();
String name = entry.getName().replace('/', File.separatorChar);
if (name.startsWith(directory)) {
if (suppressFirstPathElement) name = name.substring(directory.length());
outFile = new File(parent + name);
// Create the directory, just in case
if (name.indexOf(File.separatorChar) >= 0) {
String p = name.substring(0, name.lastIndexOf(File.separatorChar) + 1);
File dirFile = new File(parent + p);
dirFile.mkdirs();
}
if (!entry.isDirectory()) {
System.out.println("Installing " + outFile);
// Copy the file
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFile));
BufferedInputStream in = new BufferedInputStream(zipFile.getInputStream(entry));
int size = 1024;
int n = 0;
byte[] b = new byte[size];
while ((n = in.read(b, 0, size)) != -1) out.write(b, 0, n);
in.close();
out.flush();
out.close();
// Count the file
count++;
}
}
}
zipFile.close();
} catch (Exception e) {
System.err.println("...an error occured while installing " + outFile);
e.printStackTrace();
System.err.println("Error copying " + outFile.getName() + "\n" + e.getMessage());
return -count;
}
System.out.println(count + " files were installed.");
return count;
}
public static void main(String[] args) throws Exception {
int iterations = 0;
File zFile1 = new File(System.getProperty("test.src", "."), "pkware123456789012345.zip");
while (iterations < 2500) {
ZipFile zipFile = new ZipFile(zFile1);
List entries = Collections.list(zipFile.entries());
for (Iterator it = entries.iterator(); it.hasNext(); ) {
ZipEntry zipEntry = (ZipEntry) it.next();
InputStream in = zipFile.getInputStream(zipEntry);
in.close();
}
iterations++;
}
}
public static String[] getZipList(String zipFile) throws ZipException, IOException {
File file = new File(zipFile);
ZipFile zip = new ZipFile(file);
Enumeration<? extends ZipEntry> zipFileEntries = zip.entries();
ArrayList<String> files = new ArrayList<String>();
// Process each entry
while (zipFileEntries.hasMoreElements()) {
// grab a zip file entry
ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
String currentEntry = entry.getName();
files.add(currentEntry);
}
return files.toArray(new String[files.size()]);
}
static List<ZLFile> archiveEntries(ZLFile archive) {
try {
final ZipFile zf = ZLZipEntryFile.getZipFile(archive);
final Collection<LocalFileHeader> headers = zf.headers();
if (!headers.isEmpty()) {
ArrayList<ZLFile> entries = new ArrayList<ZLFile>(headers.size());
for (LocalFileHeader h : headers) {
entries.add(new ZLZipEntryFile(archive, h.FileName));
}
return entries;
}
} catch (IOException e) {
}
return Collections.emptyList();
}
private String inflate(String path) {
if (!new File(path).canRead()) {
Utils.onError(new Error.FileRead(path));
return null;
}
String tmpDir = "tmp-" + Utils.timestamp();
try {
ZipFile zipFile = new ZipFile(path);
zipFile.extractAll(tmpDir);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return tmpDir;
}
public static void closeQuietly(final ZipFile zipfile) {
if (zipfile != null) {
try {
zipfile.close();
} catch (IOException ex) {
}
}
}
public static void extract(String zipFile, String newPath, boolean overwrite)
throws ZipException, IOException {
File file = new File(zipFile);
ZipFile zip = new ZipFile(file);
new File(newPath).mkdir();
Enumeration<? extends ZipEntry> zipFileEntries = zip.entries();
// Process each entry
while (zipFileEntries.hasMoreElements()) {
// grab a zip file entry
ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
String currentEntry = entry.getName();
File destFile = new File(newPath, currentEntry);
// destFile = new File(newPath, destFile.getName());
File destinationParent = destFile.getParentFile();
// create the parent directory structure if needed
destinationParent.mkdirs();
if (!entry.isDirectory()) {
if (!overwrite && destFile.exists()) continue;
BufferedInputStream is = new BufferedInputStream(zip.getInputStream(entry));
int currentByte;
// establish buffer for writing file
byte data[] = new byte[BUFFER];
// write the current file to disk
FileOutputStream fos = new FileOutputStream(destFile);
BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
// read and write until last byte is encountered
while ((currentByte = is.read(data, 0, BUFFER)) != -1) {
dest.write(data, 0, currentByte);
}
close(dest);
close(is);
}
}
}
protected void loadAirspacesFromPath(String path, Collection<Airspace> airspaces) {
File file = ExampleUtil.saveResourceToTempFile(path, ".zip");
if (file == null) return;
try {
ZipFile zipFile = new ZipFile(file);
ZipEntry entry = null;
for (Enumeration<? extends ZipEntry> e = zipFile.entries();
e.hasMoreElements();
entry = e.nextElement()) {
if (entry == null) continue;
String name = WWIO.getFilename(entry.getName());
if (!(name.startsWith("gov.nasa.worldwind.render.airspaces") && name.endsWith(".xml")))
continue;
String[] tokens = name.split("-");
try {
Class c = Class.forName(tokens[0]);
Airspace airspace = (Airspace) c.newInstance();
BufferedReader input =
new BufferedReader(new InputStreamReader(zipFile.getInputStream(entry)));
String s = input.readLine();
airspace.restoreState(s);
airspaces.add(airspace);
if (tokens.length >= 2) {
airspace.setValue(AVKey.DISPLAY_NAME, tokens[1]);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
/** Extracts specified entries from JAR file, via ZipFile. */
void extract(String fname, String files[]) throws IOException {
ZipFile zf = new ZipFile(fname);
Set<ZipEntry> dirs = newDirSet();
Enumeration<? extends ZipEntry> zes = zf.entries();
while (zes.hasMoreElements()) {
ZipEntry e = zes.nextElement();
InputStream is;
if (files == null) {
dirs.add(extractFile(zf.getInputStream(e), e));
} else {
String name = e.getName();
for (String file : files) {
if (name.startsWith(file)) {
dirs.add(extractFile(zf.getInputStream(e), e));
break;
}
}
}
}
zf.close();
updateLastModifiedTime(dirs);
}
/**
* Unzips the transferred file. Returns <code>true</code> if the unzip was successful, and <code>
* false</code> otherwise. In case of failure, this method handles setting an appropriate
* response.
*/
private boolean completeUnzip(HttpServletRequest req, HttpServletResponse resp)
throws ServletException {
IPath destPath = new Path(getPath());
try {
ZipFile source = new ZipFile(new File(getStorageDirectory(), FILE_DATA));
IFileStore destinationRoot = NewFileServlet.getFileStore(destPath);
Enumeration<? extends ZipEntry> entries = source.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
IFileStore destination = destinationRoot.getChild(entry.getName());
if (entry.isDirectory()) destination.mkdir(EFS.NONE, null);
else {
destination.getParent().mkdir(EFS.NONE, null);
IOUtilities.pipe(
source.getInputStream(entry),
destination.openOutputStream(EFS.NONE, null),
false,
true);
}
}
source.close();
} catch (ZipException e) {
// zip exception implies client sent us invalid input
String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString());
statusHandler.handleRequest(
req, resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, e));
return false;
} catch (Exception e) {
// other failures should be considered server errors
String msg = NLS.bind("Failed to complete file transfer on {0}", destPath.toString());
statusHandler.handleRequest(
req,
resp,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, e));
return false;
}
return true;
}
public InputStream getInputStream(ZipEntry entry) throws IOException {
return zf.getInputStream(entry);
}
// =============================================================================
/** initializes internal hash tables with Jar file resources. */
private byte[] read(String name) {
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;
}
if (debugOn) {
System.out.println(
ze.getName() + " rb=" + rb + ",size=" + size + ",csize=" + ze.getCompressedSize());
}
if (ze.getName().equals(name)) {
return b;
}
}
} catch (NullPointerException e) {
System.out.println("done.");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public ZipEntry getEntry(String name) {
return zf.getEntry(name);
}
public static void upgrade(File wrFile) throws Exception {
System.out.println("Installing/upgrading Myna in '" + wrFile.toString() + "'...");
wrFile.mkdirs();
File web_inf = new File(wrFile.toURI().resolve("WEB-INF"));
boolean isUpgrade = false;
File backupDir = null;
if (web_inf.exists()) {
String dateString =
new java.text.SimpleDateFormat("MM-dd-yyyy_HH.mm.ss.S").format(new Date());
String backupBase = "WEB-INF/upgrade_backups/backup_" + dateString;
backupDir = new File(wrFile.toURI().resolve(backupBase));
backupDir.mkdirs();
isUpgrade = true;
System.out.println("Backups stored in " + backupDir);
// backup entire /myna folder because we're wiping it out
FileUtils.copyDirectory(
new File(wrFile.toURI().resolve("myna")), new File(backupDir.toURI().resolve("myna")));
FileUtils.deleteDirectory(new File(wrFile.toURI().resolve("myna")));
}
if (isJar) {
String jarFilePath = classUrl.substring(classUrl.indexOf(":") + 1, classUrl.indexOf("!"));
File jarFile = new File(new java.net.URL(jarFilePath).toURI());
ZipFile zipFile = new ZipFile(jarFile);
for (ZipEntry entry : java.util.Collections.list(zipFile.entries())) {;
File outputFile =
new File(wrFile.toURI().resolve(java.net.URLEncoder.encode(entry.getName(), "UTF-8")));
File backupFile = null;
if (isUpgrade) {
backupFile =
new File(
backupDir.toURI().resolve(java.net.URLEncoder.encode(entry.getName(), "UTF-8")));
}
if (entry.isDirectory()) {
outputFile.mkdirs();
if (isUpgrade) backupFile.mkdirs();
} else {
if (isUpgrade && outputFile.exists()) {
java.io.InputStream sourceIS = zipFile.getInputStream(entry);
java.io.InputStream targetIS = FileUtils.openInputStream(outputFile);
boolean isSame = IOUtils.contentEquals(sourceIS, targetIS);
sourceIS.close();
targetIS.close();
if (isSame
|| entry.toString().equals("index.html")
|| entry.toString().equals("application.sjs")
|| entry.toString().equals("WEB-INF/classes/general.properties")
|| entry.toString().startsWith("WEB-INF/myna/ds")) {
continue;
} else {
System.out.println("...backing up " + entry);
FileUtils.copyFile(outputFile, backupFile, true);
// outputFile.copyTo(backupFile);
// fusebox.upgradeLog("Backup: " + backupFile);
}
}
java.io.InputStream is = zipFile.getInputStream(entry);
java.io.OutputStream os = FileUtils.openOutputStream(outputFile);
IOUtils.copyLarge(is, os);
is.close();
os.close();
}
}
zipFile.close();
// FileUtils.deleteDirectory()
System.out.println("Done unpacking.");
}
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.writeObject(zf.getName());
}
public void close() throws IOException {
zf.close();
}
public int size() {
return zf.size();
}
public Enumeration entries() {
return zf.entries();
}
public String getName() {
return zf.getName();
}