/**
* The actual data to put into local file data - without Header-ID
* or length specifier.
* @return get the data
*/
public byte[] getLocalFileDataData()
{
// CRC will be added later
byte[] data = new byte[getLocalFileDataLength().getValue() - WORD];
java.lang.SystemJ.arraycopy(ZipShort.getBytes(getMode()), 0, data, 0, 2);
byte[] linkArray = getLinkedFile().getBytes(); // Uses default charset - see class Javadoc
// CheckStyle:MagicNumber OFF
java.lang.SystemJ.arraycopy(ZipLong.getBytes(linkArray.Length),
0, data, 2, WORD);
java.lang.SystemJ.arraycopy(ZipShort.getBytes(getUserId()),
0, data, 6, 2);
java.lang.SystemJ.arraycopy(ZipShort.getBytes(getGroupId()),
0, data, 8, 2);
java.lang.SystemJ.arraycopy(linkArray, 0, data, 10, linkArray.Length);
// CheckStyle:MagicNumber ON
crc.reset();
crc.update(data);
long checksum = crc.getValue();
byte[] result = new byte[data.Length + WORD];
java.lang.SystemJ.arraycopy(ZipLong.getBytes(checksum), 0, result, 0, WORD);
java.lang.SystemJ.arraycopy(data, 0, result, WORD, data.Length);
return(result);
}
/**
* Writes all necessary data for this entry.
* @throws IOException on error
*/
public override void closeArchiveEntry() //throws IOException
{
if (finished)
{
throw new java.io.IOException("Stream has already been finished");
}
if (entry == null)
{
throw new java.io.IOException("No current entry to close");
}
long realCrc = crc.getValue();
crc.reset();
if (entry.getMethod() == DEFLATED)
{
def.finish();
while (!def.finished())
{
deflate();
}
entry.setSize(ZipUtil.adjustToLong(def.getTotalIn()));
entry.setCompressedSize(ZipUtil.adjustToLong(def.getTotalOut()));
entry.setCrc(realCrc);
def.reset();
written += entry.getCompressedSize();
}
else if (raf == null)
{
if (entry.getCrc() != realCrc)
{
throw new java.util.zip.ZipException("bad CRC checksum for entry "
+ entry.getName() + ": "
+ java.lang.Long.toHexString(entry.getCrc())
+ " instead of "
+ java.lang.Long.toHexString(realCrc));
}
if (entry.getSize() != written - dataStart)
{
throw new java.util.zip.ZipException("bad size for entry "
+ entry.getName() + ": "
+ entry.getSize()
+ " instead of "
+ (written - dataStart));
}
}
else /* method is STORED and we used RandomAccessFile */
{
long size = written - dataStart;
entry.setSize(size);
entry.setCompressedSize(size);
entry.setCrc(realCrc);
}
// If random access output, write the local file header containing
// the correct CRC and compressed/uncompressed sizes
if (raf != null)
{
long save = raf.getFilePointer();
raf.seek(localDataStart);
writeOut(ZipLong.getBytes(entry.getCrc()));
writeOut(ZipLong.getBytes(entry.getCompressedSize()));
writeOut(ZipLong.getBytes(entry.getSize()));
raf.seek(save);
}
writeDataDescriptor(entry);
entry = null;
}
/**
* Closes the current ZIP archive entry and positions the underlying
* stream to the beginning of the next entry. All per-entry variables
* and data structures are cleared.
* <p>
* If the compressed size of this entry is included in the entry header,
* then any outstanding bytes are simply skipped from the underlying
* stream without uncompressing them. This allows an entry to be safely
* closed even if the compression method is unsupported.
* <p>
* In case we don't know the compressed size of this entry or have
* already buffered too much data from the underlying stream to support
* uncompression, then the uncompression process is completed and the
* end position of the stream is adjusted based on the result of that
* process.
*
* @throws IOException if an error occurs
*/
private void closeEntry() //throws IOException
{
if (closed)
{
throw new java.io.IOException("The stream is closed");
}
if (current == null)
{
return;
}
// Ensure all entry bytes are read
if (bytesReadFromStream <= current.getCompressedSize() &&
!hasDataDescriptor)
{
long remaining = current.getCompressedSize() - bytesReadFromStream;
while (remaining > 0)
{
long n = inJ.read(buf, 0, (int)java.lang.Math.min(buf.Length, remaining));
if (n < 0)
{
throw new java.io.EOFException(
"Truncated ZIP entry: " + current.getName());
}
else
{
count(n);
remaining -= n;
}
}
}
else
{
skip(java.lang.Long.MAX_VALUE);
int inB = 0;
if (current.getMethod() == ZipArchiveOutputStream.DEFLATED)
{
inB = inf.getTotalIn();
}
else
{
inB = readBytesOfEntry;
}
int diff = 0;
// Pushback any required bytes
if ((diff = bytesReadFromStream - inB) != 0)
{
((java.io.PushbackInputStream)inJ).unread(
buf, lengthOfLastRead - diff, diff);
pushedBackBytes(diff);
}
}
if (lastStoredEntry == null && hasDataDescriptor)
{
readDataDescriptor();
}
inf.reset();
readBytesOfEntry = offsetInBuffer = bytesReadFromStream =
lengthOfLastRead = 0;
crc.reset();
current = null;
lastStoredEntry = null;
}