/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.util.zip;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Vector;
import org.apache.harmony.archive.internal.nls.Messages;
/**
* This class provides an implementation of {@code FilterOutputStream} that
* compresses data entries into a <i>ZIP-archive</i> output stream.
* <p>
* {@code ZipOutputStream} is used to write {@code ZipEntries} to the underlying
* stream. Output from {@code ZipOutputStream} conforms to the {@code ZipFile}
* file format.
* <p>
* While {@code DeflaterOutputStream} can write a compressed <i>ZIP-archive</i>
* entry, this extension can write uncompressed entries as well. In this case
* special rules apply, for this purpose refer to the <a
* href="http://www.pkware.com/documents/casestudies/APPNOTE.TXT">file format
* specification</a>.
*
* @see ZipEntry
* @see ZipFile
*/
public class ZipOutputStream extends DeflaterOutputStream implements
ZipConstants {
/**
* Indicates deflated entries.
*/
public static final int DEFLATED = 8;
/**
* Indicates uncompressed entries.
*/
public static final int STORED = 0;
static final int ZIPDataDescriptorFlag = 8;
static final int ZIPLocalHeaderVersionNeeded = 20;
private String comment;
private final Vector<String> entries = new Vector<String>();
private int compressMethod = DEFLATED;
private int compressLevel = Deflater.DEFAULT_COMPRESSION;
private ByteArrayOutputStream cDir = new ByteArrayOutputStream();
private ZipEntry currentEntry;
private final CRC32 crc = new CRC32();
private int offset = 0, curOffset = 0, nameLength;
private byte[] nameBytes;
/**
* Constructs a new {@code ZipOutputStream} with the specified output
* stream.
*
* @param p1
* the {@code OutputStream} to write the data to.
*/
public ZipOutputStream(OutputStream p1) {
super(p1, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
}
/**
* Closes the current {@code ZipEntry}, if any, and the underlying output
* stream. If the stream is already closed this method does nothing.
*
* @throws IOException
* If an error occurs closing the stream.
*/
@Override
public void close() throws IOException {
if (out != null) {
finish();
out.close();
out = null;
}
}
/**
* Closes the current {@code ZipEntry}. Any entry terminal data is written
* to the underlying stream.
*
* @throws IOException
* If an error occurs closing the entry.
*/
public void closeEntry() throws IOException {
if (cDir == null) {
throw new IOException(Messages.getString("archive.1E")); //$NON-NLS-1$
}
if (currentEntry == null) {
return;
}
if (currentEntry.getMethod() == DEFLATED) {
super.finish();
}
// Verify values for STORED types
if (currentEntry.getMethod() == STORED) {
if (crc.getValue() != currentEntry.crc) {
throw new ZipException(Messages.getString("archive.20")); //$NON-NLS-1$
}
if (currentEntry.size != crc.tbytes) {
throw new ZipException(Messages.getString("archive.21")); //$NON-NLS-1$
}
}
curOffset = LOCHDR;
// Write the DataDescriptor
if (currentEntry.getMethod() != STORED) {
curOffset += EXTHDR;
writeLong(out, EXTSIG);
writeLong(out, currentEntry.crc = crc.getValue());
writeLong(out, currentEntry.compressedSize = def.getTotalOut());
writeLong(out, currentEntry.size = def.getTotalIn());
}
// Update the CentralDirectory
writeLong(cDir, CENSIG);
writeShort(cDir, ZIPLocalHeaderVersionNeeded); // Version created
writeShort(cDir, ZIPLocalHeaderVersionNeeded); // Version to extract
writeShort(cDir, currentEntry.getMethod() == STORED ? 0
: ZIPDataDescriptorFlag);
writeShort(cDir, currentEntry.getMethod());
writeShort(cDir, currentEntry.time);
writeShort(cDir, currentEntry.modDate);
writeLong(cDir, crc.getValue());
if (currentEntry.getMethod() == DEFLATED) {
curOffset += writeLong(cDir, def.getTotalOut());
writeLong(cDir, def.getTotalIn());
} else {
curOffset += writeLong(cDir, crc.tbytes);
writeLong(cDir, crc.tbytes);
}
curOffset += writeShort(cDir, nameLength);
if (currentEntry.extra != null) {
curOffset += writeShort(cDir, currentEntry.extra.length);
} else {
writeShort(cDir, 0);
}
String c;
if ((c = currentEntry.getComment()) != null) {
writeShort(cDir, c.length());
} else {
writeShort(cDir, 0);
}
writeShort(cDir, 0); // Disk Start
writeShort(cDir, 0); // Internal File Attributes
writeLong(cDir, 0); // External File Attributes
writeLong(cDir, offset);
cDir.write(nameBytes);
nameBytes = null;
if (currentEntry.extra != null) {
cDir.write(currentEntry.extra);
}
offset += curOffset;
if (c != null) {
cDir.write(c.getBytes());
}
currentEntry = null;
crc.reset();
def.reset();
done = false;
}
/**
* Indicates that all entries have been written to the stream. Any terminal
* information is written to the underlying stream.
*
* @throws IOException
* if an error occurs while terminating the stream.
*/
@Override
public void finish() throws IOException {
if (out == null) {
throw new IOException(Messages.getString("archive.1E")); //$NON-NLS-1$
}
if (cDir == null) {
return;
}
if (entries.size() == 0) {
throw new ZipException(Messages.getString("archive.28")); //$NON-NLS-1$;
}
if (currentEntry != null) {
closeEntry();
}
int cdirSize = cDir.size();
// Write Central Dir End
writeLong(cDir, ENDSIG);
writeShort(cDir, 0); // Disk Number
writeShort(cDir, 0); // Start Disk
writeShort(cDir, entries.size()); // Number of entries
writeShort(cDir, entries.size()); // Number of entries
writeLong(cDir, cdirSize); // Size of central dir
writeLong(cDir, offset); // Offset of central dir
if (comment != null) {
writeShort(cDir, comment.length());
cDir.write(comment.getBytes());
} else {
writeShort(cDir, 0);
}
// Write the central dir
out.write(cDir.toByteArray());
cDir = null;
}
/**
* Writes entry information to the underlying stream. Data associated with
* the entry can then be written using {@code write()}. After data is
* written {@code closeEntry()} must be called to complete the writing of
* the entry to the underlying stream.
*
* @param ze
* the {@code ZipEntry} to store.
* @throws IOException
* If an error occurs storing the entry.
* @see #write
*/
public void putNextEntry(ZipEntry ze) throws java.io.IOException {
if (currentEntry != null) {
closeEntry();
}
if (ze.getMethod() == STORED
|| (compressMethod == STORED && ze.getMethod() == -1)) {
if (ze.crc == -1) {
/* [MSG "archive.20", "Crc mismatch"] */
throw new ZipException(Messages.getString("archive.20")); //$NON-NLS-1$
}
if (ze.size == -1 && ze.compressedSize == -1) {
/* [MSG "archive.21", "Size mismatch"] */
throw new ZipException(Messages.getString("archive.21")); //$NON-NLS-1$
}
if (ze.size != ze.compressedSize && ze.compressedSize != -1
&& ze.size != -1) {
/* [MSG "archive.21", "Size mismatch"] */
throw new ZipException(Messages.getString("archive.21")); //$NON-NLS-1$
}
}
/* [MSG "archive.1E", "Stream is closed"] */
if (cDir == null) {
throw new IOException(Messages.getString("archive.1E")); //$NON-NLS-1$
}
if (entries.contains(ze.name)) {
/* [MSG "archive.29", "Entry already exists: {0}"] */
throw new ZipException(Messages.getString("archive.29", ze.name)); //$NON-NLS-1$
}
nameLength = utf8Count(ze.name);
if (nameLength > 0xffff) {
/* [MSG "archive.2A", "Name too long: {0}"] */
throw new IllegalArgumentException(Messages.getString(
"archive.2A", ze.name)); //$NON-NLS-1$
}
def.setLevel(compressLevel);
currentEntry = ze;
entries.add(currentEntry.name);
if (currentEntry.getMethod() == -1) {
currentEntry.setMethod(compressMethod);
}
writeLong(out, LOCSIG); // Entry header
writeShort(out, ZIPLocalHeaderVersionNeeded); // Extraction version
writeShort(out, currentEntry.getMethod() == STORED ? 0
: ZIPDataDescriptorFlag);
writeShort(out, currentEntry.getMethod());
if (currentEntry.getTime() == -1) {
currentEntry.setTime(System.currentTimeMillis());
}
writeShort(out, currentEntry.time);
writeShort(out, currentEntry.modDate);
if (currentEntry.getMethod() == STORED) {
if (currentEntry.size == -1) {
currentEntry.size = currentEntry.compressedSize;
} else if (currentEntry.compressedSize == -1) {
currentEntry.compressedSize = currentEntry.size;
}
writeLong(out, currentEntry.crc);
writeLong(out, currentEntry.size);
writeLong(out, currentEntry.size);
} else {
writeLong(out, 0);
writeLong(out, 0);
writeLong(out, 0);
}
writeShort(out, nameLength);
if (currentEntry.extra != null) {
writeShort(out, currentEntry.extra.length);
} else {
writeShort(out, 0);
}
nameBytes = toUTF8Bytes(currentEntry.name, nameLength);
out.write(nameBytes);
if (currentEntry.extra != null) {
out.write(currentEntry.extra);
}
}
/**
* Sets the {@code ZipFile} comment associated with the file being written.
*
* @param comment
* the comment associated with the file.
*/
public void setComment(String comment) {
if (comment.length() > 0xFFFF) {
throw new IllegalArgumentException(Messages.getString("archive.2B")); //$NON-NLS-1$
}
this.comment = comment;
}
/**
* Sets the compression level to be used for writing entry data. This level
* may be set on a per entry basis. The level must have a value between -1
* and 8 according to the {@code Deflater} compression level bounds.
*
* @param level
* the compression level (ranging from -1 to 8).
* @see Deflater
*/
public void setLevel(int level) {
if (level < Deflater.DEFAULT_COMPRESSION
|| level > Deflater.BEST_COMPRESSION) {
throw new IllegalArgumentException();
}
compressLevel = level;
}
/**
* Sets the compression method to be used when compressing entry data.
* method must be one of {@code STORED} (for no compression) or {@code
* DEFLATED}.
*
* @param method
* the compression method to use.
*/
public void setMethod(int method) {
if (method != STORED && method != DEFLATED) {
throw new IllegalArgumentException();
}
compressMethod = method;
}
private long writeLong(OutputStream os, long i) throws java.io.IOException {
// Write out the long value as an unsigned int
os.write((int) (i & 0xFF));
os.write((int) (i >> 8) & 0xFF);
os.write((int) (i >> 16) & 0xFF);
os.write((int) (i >> 24) & 0xFF);
return i;
}
private int writeShort(OutputStream os, int i) throws java.io.IOException {
os.write(i & 0xFF);
os.write((i >> 8) & 0xFF);
return i;
}
/**
* Writes data for the current entry to the underlying stream.
*
* @exception IOException
* If an error occurs writing to the stream
*/
@Override
public void write(byte[] buffer, int off, int nbytes)
throws java.io.IOException {
// avoid int overflow, check null buf
if ((off < 0 || (nbytes < 0) || off > buffer.length)
|| (buffer.length - off < nbytes)) {
throw new IndexOutOfBoundsException();
}
if (currentEntry == null) {
/* [MSG "archive.2C", "No active entry"] */
throw new ZipException(Messages.getString("archive.2C")); //$NON-NLS-1$
}
if (currentEntry.getMethod() == STORED) {
out.write(buffer, off, nbytes);
} else {
super.write(buffer, off, nbytes);
}
crc.update(buffer, off, nbytes);
}
static int utf8Count(String value) {
int total = 0;
for (int i = value.length(); --i >= 0;) {
char ch = value.charAt(i);
if (ch < 0x80) {
total++;
} else if (ch < 0x800) {
total += 2;
} else {
total += 3;
}
}
return total;
}
static byte[] toUTF8Bytes(String value, int length) {
byte[] result = new byte[length];
int pos = result.length;
for (int i = value.length(); --i >= 0;) {
char ch = value.charAt(i);
if (ch < 0x80) {
result[--pos] = (byte) ch;
} else if (ch < 0x800) {
result[--pos] = (byte) (0x80 | (ch & 0x3f));
result[--pos] = (byte) (0xc0 | (ch >> 6));
} else {
result[--pos] = (byte) (0x80 | (ch & 0x3f));
result[--pos] = (byte) (0x80 | ((ch >> 6) & 0x3f));
result[--pos] = (byte) (0xe0 | (ch >> 12));
}
}
return result;
}
}