/**
* Parse a repository document.
*
* @param url
* @throws IOException
* @throws XmlPullParserException
* @throws Exception
*/
void parseDocument(URL url) throws IOException, XmlPullParserException, Exception {
if (!visited.contains(url)) {
visited.add(url);
try {
System.out.println("Visiting: " + url);
InputStream in = null;
if (url.getPath().endsWith(".zip")) {
ZipInputStream zin = new ZipInputStream(url.openStream());
ZipEntry entry = zin.getNextEntry();
while (entry != null) {
if (entry.getName().equals("repository.xml")) {
in = zin;
break;
}
entry = zin.getNextEntry();
}
} else {
in = url.openStream();
}
Reader reader = new InputStreamReader(in);
XmlPullParser parser = new KXmlParser();
parser.setInput(reader);
parseRepository(parser);
} catch (MalformedURLException e) {
System.out.println("Cannot create connection to url");
}
}
}
/**
* Loop through the ZIP file, copying its entries into a new, temporary ZIP file, skipping the
* entry to be deleted. Then replace the original file with the new one.
*/
protected Integer deleteEntry() throws XMLDataStoreException {
try {
ZipInputStream inStream = this.buildZipInputStream();
File outFile = this.buildTempFile();
ZipOutputStream outStream = new ZipOutputStream(new FileOutputStream(outFile));
byte[] buffer = new byte[32768];
int inCount = 0;
int outCount = 0;
// copy all the entries except the one to be deleted
ZipEntry entry = inStream.getNextEntry();
while (entry != null) {
inCount++;
if (!this.getZipEntryName().equals(entry.getName())) {
outCount++;
outStream.putNextEntry(entry);
int byteCount;
while ((byteCount = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, byteCount);
}
outStream.closeEntry();
}
entry = inStream.getNextEntry();
}
inStream.close();
if (outCount == 0) {
// add a dummy record to an empty file so we can close it
// this is required by ZipOutputStream
outStream.putNextEntry(new ZipEntry("delete.txt"));
outStream.write(
"This file is a place-holder. The containing ZIP file should be deleted.".getBytes());
outStream.closeEntry();
}
outStream.close();
if (outCount == inCount) {
// no entries were removed - just delete the temp file
outFile.delete();
} else {
// at least one entry removed - delete the original file
this.getFile().delete();
if (outCount == 0) {
// NO entries remain - just delete the temp file too
outFile.delete();
} else {
// entries remain - replace original file with temp file
outFile.renameTo(this.getFile());
}
}
return new Integer(inCount - outCount); // should be 0 or 1
} catch (IOException ex) {
throw XMLDataStoreException.ioException(ex);
}
}
/**
* Rename the ZIP file to a temporary file, then copy its entries back into the original ZIP file,
* leaving the stream open and returning it.
*/
protected Writer buildWriteStream(boolean entryShouldExist) throws XMLDataStoreException {
try {
File inFile = this.buildTempFile();
inFile.delete(); // the file actually gets created - delete it
boolean renameSucceeded = this.getFile().renameTo(inFile);
ZipInputStream inStream = this.buildZipInputStream(inFile);
ZipOutputStream outStream = this.buildZipOutputStream();
boolean entryActuallyExists = false;
byte[] buffer = new byte[32768];
ZipEntry entry = inStream.getNextEntry();
while (entry != null) {
boolean weWantToWriteTheEntry = true;
if (this.getZipEntryName().equals(entry.getName())) {
entryActuallyExists = true;
// if we were expecting the entry, skip it;
// if we were NOT expecting the entry, allow it to be rewritten
// so the file is restored to its original condition
if (entryShouldExist) {
weWantToWriteTheEntry = false;
}
}
if (weWantToWriteTheEntry) {
outStream.putNextEntry(entry);
int byteCount;
while ((byteCount = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, byteCount);
}
outStream.closeEntry();
}
entry = inStream.getNextEntry();
}
// close and delete the temporary file
inStream.close();
inFile.delete();
// check for invalid state
if (entryShouldExist != entryActuallyExists) {
outStream.close(); // close it since we will not be returning it
// need more helpful exceptions here
if (entryActuallyExists) {
throw XMLDataStoreException.fileAlreadyExists(new File(this.getZipEntryName()));
} else {
throw XMLDataStoreException.fileNotFound(new File(this.getZipEntryName()), null);
}
}
outStream.putNextEntry(new ZipEntry(this.getZipEntryName()));
return new OutputStreamWriter(outStream);
} catch (IOException ex) {
throw XMLDataStoreException.ioException(ex);
}
}
/**
* Puts the uninstaller.
*
* @exception Exception Description of the Exception
*/
private void putUninstaller() throws Exception {
// Me make the .uninstaller directory
String dest = translatePath("$INSTALL_PATH") + File.separator + "Uninstaller";
String jar = dest + File.separator + "uninstaller.jar";
File pathMaker = new File(dest);
pathMaker.mkdirs();
// We log the uninstaller deletion information
UninstallData udata = UninstallData.getInstance();
udata.setUninstallerJarFilename(jar);
udata.setUninstallerPath(dest);
// We open our final jar file
FileOutputStream out = new FileOutputStream(jar);
ZipOutputStream outJar = new ZipOutputStream(out);
idata.uninstallOutJar = outJar;
outJar.setLevel(9);
udata.addFile(jar);
// We copy the uninstaller
InputStream in = getClass().getResourceAsStream("/res/IzPack.uninstaller");
ZipInputStream inRes = new ZipInputStream(in);
ZipEntry zentry = inRes.getNextEntry();
while (zentry != null) {
// Puts a new entry
outJar.putNextEntry(new ZipEntry(zentry.getName()));
// Byte to byte copy
int unc = inRes.read();
while (unc != -1) {
outJar.write(unc);
unc = inRes.read();
}
// Next one please
inRes.closeEntry();
outJar.closeEntry();
zentry = inRes.getNextEntry();
}
inRes.close();
// We put the langpack
in = getClass().getResourceAsStream("/langpacks/" + idata.localeISO3 + ".xml");
outJar.putNextEntry(new ZipEntry("langpack.xml"));
int read = in.read();
while (read != -1) {
outJar.write(read);
read = in.read();
}
outJar.closeEntry();
}
/** Return the specified ZIP file entry wrapped in a stream. */
protected Reader buildReadStream(String readZipEntryName) throws XMLDataStoreException {
try {
ZipInputStream inStream = this.buildZipInputStream();
ZipEntry entry = inStream.getNextEntry();
while (entry != null) {
if (readZipEntryName.equals(entry.getName())) {
return new InputStreamReader(inStream);
}
entry = inStream.getNextEntry();
}
inStream.close();
} catch (IOException ex) {
throw XMLDataStoreException.ioException(ex);
}
return null;
}
/** Extracts specified entries from JAR file. */
void extract(InputStream in, String files[]) throws IOException {
ZipInputStream zis = new ZipInputStream(in);
ZipEntry e;
// Set of all directory entries specified in archive. Disallows
// null entries. Disallows all entries if using pre-6.0 behavior.
Set<ZipEntry> dirs = newDirSet();
while ((e = zis.getNextEntry()) != null) {
if (files == null) {
dirs.add(extractFile(zis, e));
} else {
String name = e.getName();
for (String file : files) {
if (name.startsWith(file)) {
dirs.add(extractFile(zis, e));
break;
}
}
}
}
// Update timestamps of directories specified in archive with their
// timestamps as given in the archive. We do this after extraction,
// instead of during, because creating a file in a directory changes
// that directory's timestamp.
updateLastModifiedTime(dirs);
}
/** Lists contents of JAR file. */
void list(InputStream in, String files[]) throws IOException {
ZipInputStream zis = new ZipInputStream(in);
ZipEntry e;
while ((e = zis.getNextEntry()) != null) {
/*
* In the case of a compressed (deflated) entry, the entry size
* is stored immediately following the entry data and cannot be
* determined until the entry is fully read. Therefore, we close
* the entry first before printing out its attributes.
*/
zis.closeEntry();
printEntry(e, files);
}
}
protected void load(ZipInputStream in) throws IOException {
ZipEntry entry;
while ((entry = in.getNextEntry()) != null) {
fireBeginFile(entry.getName());
Logger.getLogger(getClass())
.debug("Starting file " + entry.getName() + " (" + entry.getSize() + " bytes)");
byte[] bytes = readBytes(in);
Logger.getLogger(getClass())
.debug("Passing up file " + entry.getName() + " (" + bytes.length + " bytes)");
getLoader().load(entry.getName(), new ByteArrayInputStream(bytes));
fireEndFile(entry.getName());
}
}
public static byte [] unzipBytes(byte [] bs, Compression cmp) {
InputStream is = null;
int off = 0;
try {
switch(cmp) {
case NONE: // No compression
return bs;
case ZIP: {
ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(bs));
ZipEntry ze = zis.getNextEntry(); // Get the *FIRST* entry
// There is at least one entry in zip file and it is not a directory.
if( ze != null && !ze.isDirectory() ) {
is = zis;
break;
}
zis.close();
return bs; // Don't crash, ignore file if cannot unzip
}
case GZIP:
is = new GZIPInputStream(new ByteArrayInputStream(bs));
break;
default:
assert false:"cmp = " + cmp;
}
// If reading from a compressed stream, estimate we can read 2x uncompressed
assert( is != null ):"is is NULL, cmp = " + cmp;
bs = new byte[bs.length * 2];
// Now read from the (possibly compressed) stream
while( off < bs.length ) {
int len = is.read(bs, off, bs.length - off);
if( len < 0 )
break;
off += len;
if( off == bs.length ) { // Dataset is uncompressing alot! Need more space...
if( bs.length >= ValueArray.CHUNK_SZ )
break; // Already got enough
bs = Arrays.copyOf(bs, bs.length * 2);
}
}
} catch( IOException ioe ) { // Stop at any io error
Log.err(ioe);
} finally {
Utils.close(is);
}
return bs;
}
/** 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;
}
// =============================================================================
/** Updates an existing jar file. */
boolean update(InputStream in, OutputStream out, InputStream newManifest, JarIndex jarIndex)
throws IOException {
ZipInputStream zis = new ZipInputStream(in);
ZipOutputStream zos = new JarOutputStream(out);
ZipEntry e = null;
boolean foundManifest = false;
boolean updateOk = true;
if (jarIndex != null) {
addIndex(jarIndex, zos);
}
// put the old entries first, replace if necessary
while ((e = zis.getNextEntry()) != null) {
String name = e.getName();
boolean isManifestEntry = equalsIgnoreCase(name, MANIFEST_NAME);
if ((jarIndex != null && equalsIgnoreCase(name, INDEX_NAME)) || (Mflag && isManifestEntry)) {
continue;
} else if (isManifestEntry && ((newManifest != null) || (ename != null) || (pname != null))) {
foundManifest = true;
if (newManifest != null) {
// Don't read from the newManifest InputStream, as we
// might need it below, and we can't re-read the same data
// twice.
FileInputStream fis = new FileInputStream(mname);
boolean ambiguous = isAmbiguousMainClass(new Manifest(fis));
fis.close();
if (ambiguous) {
return false;
}
}
// Update the manifest.
Manifest old = new Manifest(zis);
if (newManifest != null) {
old.read(newManifest);
}
if (!updateManifest(old, zos)) {
return false;
}
} else {
if (!entryMap.containsKey(name)) { // copy the old stuff
// do our own compression
ZipEntry e2 = new ZipEntry(name);
e2.setMethod(e.getMethod());
e2.setTime(e.getTime());
e2.setComment(e.getComment());
e2.setExtra(e.getExtra());
if (e.getMethod() == ZipEntry.STORED) {
e2.setSize(e.getSize());
e2.setCrc(e.getCrc());
}
zos.putNextEntry(e2);
copy(zis, zos);
} else { // replace with the new files
File f = entryMap.get(name);
addFile(zos, f);
entryMap.remove(name);
entries.remove(f);
}
}
}
// add the remaining new files
for (File f : entries) {
addFile(zos, f);
}
if (!foundManifest) {
if (newManifest != null) {
Manifest m = new Manifest(newManifest);
updateOk = !isAmbiguousMainClass(m);
if (updateOk) {
if (!updateManifest(m, zos)) {
updateOk = false;
}
}
} else if (ename != null || pname != null) {
if (!updateManifest(new Manifest(), zos)) {
updateOk = false;
}
}
}
zis.close();
zos.close();
return updateOk;
}