Package org.apache.commons.compress.archivers.zip

Class ZipArchiveOutputStream

java.lang.Object
java.io.OutputStream
org.apache.commons.compress.archivers.ArchiveOutputStream<ZipArchiveEntry>
org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream
All Implemented Interfaces:
Closeable, Flushable, AutoCloseable
Direct Known Subclasses:
JarArchiveOutputStream
public class ZipArchiveOutputStream extends ArchiveOutputStream<ZipArchiveEntry>
Reimplementation of java.util.zip.ZipOutputStream to handle the extended functionality of this package, especially internal/external file attributes and extra fields with different layouts for local file data and central directory entries.

This class will try to use SeekableByteChannel when it knows that the output is going to go to a file and no split archive shall be created.

If SeekableByteChannel cannot be used, this implementation will use a Data Descriptor to store size and CRC information for DEFLATED entries, you don't need to calculate them yourself. Unfortunately, this is not possible for the STORED method, where setting the CRC and uncompressed size information is required before putArchiveEntry(ZipArchiveEntry) can be called.

As of Apache Commons Compress 1.3, the class transparently supports Zip64 extensions and thus individual entries and archives larger than 4 GB or with more than 65536 entries in most cases but explicit control is provided via setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode). If the stream can not use SeekableByteChannel and you try to write a ZipArchiveEntry of unknown size, then Zip64 extensions will be disabled by default.

  • Field Details

    • BUFFER_SIZE

      static final int BUFFER_SIZE
      See Also:

    • LFH_SIG_OFFSET

      private static final int LFH_SIG_OFFSET
      See Also:

    • LFH_VERSION_NEEDED_OFFSET

      private static final int LFH_VERSION_NEEDED_OFFSET
      See Also:

    • LFH_GPB_OFFSET

      private static final int LFH_GPB_OFFSET
      See Also:

    • LFH_METHOD_OFFSET

      private static final int LFH_METHOD_OFFSET
      See Also:

    • LFH_TIME_OFFSET

      private static final int LFH_TIME_OFFSET
      See Also:

    • LFH_CRC_OFFSET

      private static final int LFH_CRC_OFFSET
      See Also:

    • LFH_COMPRESSED_SIZE_OFFSET

      private static final int LFH_COMPRESSED_SIZE_OFFSET
      See Also:

    • LFH_ORIGINAL_SIZE_OFFSET

      private static final int LFH_ORIGINAL_SIZE_OFFSET
      See Also:

    • LFH_FILENAME_LENGTH_OFFSET

      private static final int LFH_FILENAME_LENGTH_OFFSET
      See Also:

    • LFH_EXTRA_LENGTH_OFFSET

      private static final int LFH_EXTRA_LENGTH_OFFSET
      See Also:

    • LFH_FILENAME_OFFSET

      private static final int LFH_FILENAME_OFFSET
      See Also:

    • CFH_SIG_OFFSET

      private static final int CFH_SIG_OFFSET
      See Also:

    • CFH_VERSION_MADE_BY_OFFSET

      private static final int CFH_VERSION_MADE_BY_OFFSET
      See Also:

    • CFH_VERSION_NEEDED_OFFSET

      private static final int CFH_VERSION_NEEDED_OFFSET
      See Also:

    • CFH_GPB_OFFSET

      private static final int CFH_GPB_OFFSET
      See Also:

    • CFH_METHOD_OFFSET

      private static final int CFH_METHOD_OFFSET
      See Also:

    • CFH_TIME_OFFSET

      private static final int CFH_TIME_OFFSET
      See Also:

    • CFH_CRC_OFFSET

      private static final int CFH_CRC_OFFSET
      See Also:

    • CFH_COMPRESSED_SIZE_OFFSET

      private static final int CFH_COMPRESSED_SIZE_OFFSET
      See Also:

    • CFH_ORIGINAL_SIZE_OFFSET

      private static final int CFH_ORIGINAL_SIZE_OFFSET
      See Also:

    • CFH_FILENAME_LENGTH_OFFSET

      private static final int CFH_FILENAME_LENGTH_OFFSET
      See Also:

    • CFH_EXTRA_LENGTH_OFFSET

      private static final int CFH_EXTRA_LENGTH_OFFSET
      See Also:

    • CFH_COMMENT_LENGTH_OFFSET

      private static final int CFH_COMMENT_LENGTH_OFFSET
      See Also:

    • CFH_DISK_NUMBER_OFFSET

      private static final int CFH_DISK_NUMBER_OFFSET
      See Also:

    • CFH_INTERNAL_ATTRIBUTES_OFFSET

      private static final int CFH_INTERNAL_ATTRIBUTES_OFFSET
      See Also:

    • CFH_EXTERNAL_ATTRIBUTES_OFFSET

      private static final int CFH_EXTERNAL_ATTRIBUTES_OFFSET
      See Also:

    • CFH_LFH_OFFSET

      private static final int CFH_LFH_OFFSET
      See Also:

    • CFH_FILENAME_OFFSET

      private static final int CFH_FILENAME_OFFSET
      See Also:

    • DEFLATED

      public static final int DEFLATED
      Compression method for deflated entries.
      See Also:

    • DEFAULT_COMPRESSION

      public static final int DEFAULT_COMPRESSION
      Default compression level for deflated entries.
      See Also:

    • STORED

      public static final int STORED
      Compression method for stored entries.
      See Also:

    • DEFAULT_ENCODING

      static final String DEFAULT_ENCODING
      default encoding for file names and comment.
      See Also:

    • EFS_FLAG

      @Deprecated public static final int EFS_FLAG
      Deprecated.
      use GeneralPurposeBit.UFT8_NAMES_FLAG instead
      General purpose flag, which indicates that file names are written in UTF-8.
      See Also:

    • ZERO

      private static final byte[] ZERO
      Helper, a 0 as ZipShort.

    • LZERO

      private static final byte[] LZERO
      Helper, a 0 as ZipLong.

    • ONE

      private static final byte[] ONE

    • LFH_SIG

      static final byte[] LFH_SIG
      local file header signature

    • DD_SIG

      static final byte[] DD_SIG
      data descriptor signature

    • CFH_SIG

      static final byte[] CFH_SIG
      central file header signature

    • EOCD_SIG

      static final byte[] EOCD_SIG
      end of central dir signature

    • ZIP64_EOCD_SIG

      static final byte[] ZIP64_EOCD_SIG
      ZIP64 end of central dir signature

    • ZIP64_EOCD_LOC_SIG

      static final byte[] ZIP64_EOCD_LOC_SIG
      ZIP64 end of central dir locator signature

    • finished

      protected boolean finished
      indicates if this archive is finished. protected for use in Jar implementation

    • entry

      private ZipArchiveOutputStream.CurrentEntry entry
      Current entry.

    • comment

      private String comment
      The file comment.

    • level

      private int level
      Compression level for next entry.

    • hasCompressionLevelChanged

      private boolean hasCompressionLevelChanged
      Has the compression level changed when compared to the last entry?

    • method

      private int method
      Default compression method for next entry.

    • entries

      private final List<ZipArchiveEntry> entries
      List of ZipArchiveEntries written so far.

    • streamCompressor

      private final StreamCompressor streamCompressor

    • cdOffset

      private long cdOffset
      Start of central directory.

    • cdLength

      private long cdLength
      Length of central directory.

    • cdDiskNumberStart

      private long cdDiskNumberStart
      Disk number start of central directory.

    • eocdLength

      private long eocdLength
      Length of end of central directory

    • metaData

      private final Map<ZipArchiveEntry,ZipArchiveOutputStream.EntryMetaData> metaData
      Holds some book-keeping data for each entry.

    • encoding

      private String encoding
      The encoding to use for file names and the file comment.

      For a list of possible values see Supported Encodings. Defaults to UTF-8.

    • zipEncoding

      private ZipEncoding zipEncoding
      The ZIP encoding to use for file names and the file comment. This field is of internal use and will be set in setEncoding(String).

    • def

      protected final Deflater def
      This Deflater object is used for output.

    • channel

      private final SeekableByteChannel channel
      Optional random access output.

    • outputStream

      private final OutputStream outputStream

    • useUTF8Flag

      private boolean useUTF8Flag
      whether to use the general purpose bit flag when writing UTF-8 file names or not.

    • fallbackToUTF8

      private boolean fallbackToUTF8
      Whether to encode non-encodable file names as UTF-8.

    • createUnicodeExtraFields

      private ZipArchiveOutputStream.UnicodeExtraFieldPolicy createUnicodeExtraFields
      whether to create UnicodePathExtraField-s for each entry.

    • hasUsedZip64

      private boolean hasUsedZip64
      Whether anything inside this archive has used a ZIP64 feature.
      Since:
      1.3

    • zip64Mode

      private Zip64Mode zip64Mode

    • copyBuffer

      private final byte[] copyBuffer

    • isSplitZip

      private final boolean isSplitZip
      Whether we are creating a split zip

    • numberOfCDInDiskData

      private final Map<Integer,Integer> numberOfCDInDiskData
      Holds the number of Central Directories on each disk, this is used when writing Zip64 End Of Central Directory and End Of Central Directory

  • Constructor Details

    • ZipArchiveOutputStream

      public ZipArchiveOutputStream(File file) throws IOException
      Creates a new ZIP OutputStream writing to a File. Will use random access if possible.
      Parameters:
      file - the file to ZIP to
      Throws:
      IOException - on error

    • ZipArchiveOutputStream

      public ZipArchiveOutputStream(File file, long zipSplitSize) throws IOException
      Creates a split ZIP Archive.

      The files making up the archive will use Z01, Z02, ... extensions and the last part of it will be the given file.

      Even though the stream writes to a file this stream will behave as if no random access was possible. This means the sizes of stored entries need to be known before the actual entry data is written.

      Parameters:
      file - the file that will become the last part of the split archive
      zipSplitSize - maximum size of a single part of the split archive created by this stream. Must be between 64kB and about 4GB.
      Throws:
      IOException - on error
      IllegalArgumentException - if zipSplitSize is not in the required range
      Since:
      1.20

    • ZipArchiveOutputStream

      public ZipArchiveOutputStream(OutputStream out)
      Creates a new ZIP OutputStream filtering the underlying stream.
      Parameters:
      out - the outputstream to zip

    • ZipArchiveOutputStream

      public ZipArchiveOutputStream(Path path, long zipSplitSize) throws IOException
      Creates a split ZIP Archive.

      The files making up the archive will use Z01, Z02, ... extensions and the last part of it will be the given file.

      Even though the stream writes to a file this stream will behave as if no random access was possible. This means the sizes of stored entries need to be known before the actual entry data is written.

      Parameters:
      path - the path to the file that will become the last part of the split archive
      zipSplitSize - maximum size of a single part of the split archive created by this stream. Must be between 64kB and about 4GB.
      Throws:
      IOException - on error
      IllegalArgumentException - if zipSplitSize is not in the required range
      Since:
      1.22

    • ZipArchiveOutputStream

      public ZipArchiveOutputStream(Path file, OpenOption... options) throws IOException
      Creates a new ZIP OutputStream writing to a Path. Will use random access if possible.
      Parameters:
      file - the file to ZIP to
      options - options specifying how the file is opened.
      Throws:
      IOException - on error
      Since:
      1.21

    • ZipArchiveOutputStream

      public ZipArchiveOutputStream(SeekableByteChannel channel)
      Creates a new ZIP OutputStream writing to a SeekableByteChannel.

      SeekableInMemoryByteChannel allows you to write to an in-memory archive using random access.

      Parameters:
      channel - the channel to ZIP to
      Since:
      1.13

  • Method Details

    • addRawArchiveEntry

      public void addRawArchiveEntry(ZipArchiveEntry entry, InputStream rawStream) throws IOException
      Adds an archive entry with a raw input stream. If crc, size and compressed size are supplied on the entry, these values will be used as-is. Zip64 status is re-established based on the settings in this stream, and the supplied value is ignored. The entry is put and closed immediately.
      Parameters:
      entry - The archive entry to add
      rawStream - The raw input stream of a different entry. May be compressed/encrypted.
      Throws:
      IOException - If copying fails

    • addUnicodeExtraFields

      private void addUnicodeExtraFields(ZipArchiveEntry ze, boolean encodable, ByteBuffer name) throws IOException
      Adds UnicodeExtra fields for name and file comment if mode is ALWAYS or the data cannot be encoded using the configured encoding.
      Throws:
      IOException

    • canWriteEntryData

      public boolean canWriteEntryData(ArchiveEntry ae)
      Whether this stream is able to write the given entry.

      May return false if it is set up to use encryption or a compression method that hasn't been implemented yet.

      Overrides:
      canWriteEntryData in class ArchiveOutputStream<ZipArchiveEntry>
      Parameters:
      ae - the entry to test
      Returns:
      This implementation always returns true.
      Since:
      1.1

    • checkIfNeedsZip64

      private boolean checkIfNeedsZip64(Zip64Mode effectiveMode) throws ZipException
      Verifies the sizes aren't too big in the Zip64Mode.Never case and returns whether the entry would require a Zip64 extra field.
      Throws:
      ZipException

    • close

      public void close() throws IOException
      Closes this output stream and releases any system resources associated with the stream.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Overrides:
      close in class OutputStream
      Throws:
      IOException - if an I/O error occurs.
      Zip64RequiredException - if the archive's size exceeds 4 GByte or there are more than 65535 entries inside the archive and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.

    • closeArchiveEntry

      public void closeArchiveEntry() throws IOException
      Writes all necessary data for this entry.
      Specified by:
      closeArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
      Throws:
      IOException - on error
      Zip64RequiredException - if the entry's uncompressed or compressed size exceeds 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.

    • closeCopiedEntry

      private void closeCopiedEntry(boolean phased) throws IOException
      Writes all necessary data for this entry.
      Parameters:
      phased - This entry is second phase of a 2-phase ZIP creation, size, compressed size and crc are known in ZipArchiveEntry
      Throws:
      IOException - on error
      Zip64RequiredException - if the entry's uncompressed or compressed size exceeds 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.

    • closeEntry

      private void closeEntry(boolean actuallyNeedsZip64, boolean phased) throws IOException
      Throws:
      IOException

    • copyFromZipInputStream

      private void copyFromZipInputStream(InputStream src) throws IOException
      Throws:
      IOException

    • createArchiveEntry

      public ZipArchiveEntry createArchiveEntry(File inputFile, String entryName) throws IOException
      Creates a new ZIP entry taking some information from the given file and using the provided name.

      The name will be adjusted to end with a forward slash "/" if the file is a directory. If the file is not a directory a potential trailing forward slash will be stripped from the entry name.

      Must not be used if the stream has already been closed.

      Specified by:
      createArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
      Parameters:
      inputFile - the file to create the entry from
      entryName - name to use for the entry
      Returns:
      the ArchiveEntry set up with details from the file
      Throws:
      IOException - if an I/O error occurs

    • createArchiveEntry

      public ZipArchiveEntry createArchiveEntry(Path inputPath, String entryName, LinkOption... options) throws IOException
      Creates a new ZIP entry taking some information from the given file and using the provided name.

      The name will be adjusted to end with a forward slash "/" if the file is a directory. If the file is not a directory a potential trailing forward slash will be stripped from the entry name.

      Must not be used if the stream has already been closed.

      Overrides:
      createArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
      Parameters:
      inputPath - path to create the entry from.
      entryName - name of the entry.
      options - options indicating how symbolic links are handled.
      Returns:
      a new instance.
      Throws:
      IOException - if an I/O error occurs.
      Since:
      1.21

    • createCentralFileHeader

      private byte[] createCentralFileHeader(ZipArchiveEntry ze) throws IOException
      Throws:
      IOException

    • createCentralFileHeader

      private byte[] createCentralFileHeader(ZipArchiveEntry ze, ByteBuffer name, ZipArchiveOutputStream.EntryMetaData entryMetaData, boolean needsZip64Extra) throws IOException
      Writes the central file header entry.
      Parameters:
      ze - the entry to write
      name - The encoded name
      entryMetaData - meta data for this file
      Throws:
      IOException - on error

    • createLocalFileHeader

      private byte[] createLocalFileHeader(ZipArchiveEntry ze, ByteBuffer name, boolean encodable, boolean phased, long archiveOffset)

    • deflate

      protected final void deflate() throws IOException
      Writes next block of compressed data to the output stream.
      Throws:
      IOException - on error

    • destroy

      void destroy() throws IOException
      Closes the underlying stream/file without finishing the archive, the result will likely be a corrupt archive.

      This method only exists to support tests that generate corrupt archives so they can clean up any temporary files.

      Throws:
      IOException

    • finish

      public void finish() throws IOException
      Finishes the addition of entries to this stream, without closing it. Additional data can be written, if the format supports it.
      Specified by:
      finish in class ArchiveOutputStream<ZipArchiveEntry>
      Throws:
      Zip64RequiredException - if the archive's size exceeds 4 GByte or there are more than 65535 entries inside the archive and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
      IOException - if the user forgets to close the entry.

    • flush

      public void flush() throws IOException
      Flushes this output stream and forces any buffered output bytes to be written out to the stream.
      Specified by:
      flush in interface Flushable
      Overrides:
      flush in class OutputStream
      Throws:
      IOException - if an I/O error occurs.

    • flushDeflater

      private void flushDeflater() throws IOException
      Ensures all bytes sent to the deflater are written to the stream.
      Throws:
      IOException

    • getBytesWritten

      public long getBytesWritten()
      Returns the total number of bytes written to this stream.
      Overrides:
      getBytesWritten in class ArchiveOutputStream<ZipArchiveEntry>
      Returns:
      the number of written bytes
      Since:
      1.22

    • getEffectiveZip64Mode

      private Zip64Mode getEffectiveZip64Mode(ZipArchiveEntry ze)
      If the mode is AsNeeded and the entry is a compressed entry of unknown size that gets written to a non-seekable stream then change the default to Never.
      Since:
      1.3

    • getEncoding

      public String getEncoding()
      The encoding to use for file names and the file comment.
      Returns:
      null if using the platform's default character encoding.

    • getEntryEncoding

      private ZipEncoding getEntryEncoding(ZipArchiveEntry ze)

    • getGeneralPurposeBits

      private GeneralPurposeBit getGeneralPurposeBits(boolean utfFallback, boolean usesDataDescriptor)

    • getName

      private ByteBuffer getName(ZipArchiveEntry ze) throws IOException
      Throws:
      IOException

    • getZip64Extra

      private Zip64ExtendedInformationExtraField getZip64Extra(ZipArchiveEntry ze)
      Gets the existing ZIP64 extended information extra field or create a new one and add it to the entry.
      Since:
      1.3

    • handleSizesAndCrc

      private boolean handleSizesAndCrc(long bytesWritten, long crc, Zip64Mode effectiveMode) throws ZipException
      Ensures the current entry's size and CRC information is set to the values just written, verifies it isn't too big in the Zip64Mode.Never case and returns whether the entry would require a Zip64 extra field.
      Throws:
      ZipException

    • handleZip64Extra

      private void handleZip64Extra(ZipArchiveEntry ze, long lfhOffset, boolean needsZip64Extra)
      If the entry needs Zip64 extra information inside the central directory then configure its data.

    • hasZip64Extra

      private boolean hasZip64Extra(ZipArchiveEntry ze)
      Is there a ZIP64 extended information extra field for the entry?
      Since:
      1.3

    • isSeekable

      public boolean isSeekable()
      This method indicates whether this archive is writing to a seekable stream (i.e., to a random access file).

      For seekable streams, you don't need to calculate the CRC or uncompressed size for STORED entries before invoking putArchiveEntry(ZipArchiveEntry).

      Returns:
      true if seekable

    • isTooLargeForZip32

      private boolean isTooLargeForZip32(ZipArchiveEntry zipArchiveEntry)

    • isZip64Required

      private boolean isZip64Required(ZipArchiveEntry entry1, Zip64Mode requestedMode)

    • preClose

      private void preClose() throws IOException
      Throws:
      IOException

    • putArchiveEntry

      public void putArchiveEntry(ZipArchiveEntry archiveEntry) throws IOException
      Writes the headers for an archive entry to the output stream. The caller must then write the content to the stream and call ArchiveOutputStream.closeArchiveEntry() to complete the process.
      Specified by:
      putArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
      Parameters:
      archiveEntry - describes the entry
      Throws:
      ClassCastException - if entry is not an instance of ZipArchiveEntry
      Zip64RequiredException - if the entry's uncompressed or compressed size is known to exceed 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
      IOException - if an I/O error occurs

    • putArchiveEntry

      private void putArchiveEntry(ZipArchiveEntry archiveEntry, boolean phased) throws IOException
      Writes the headers for an archive entry to the output stream. The caller must then write the content to the stream and call closeArchiveEntry() to complete the process.
      Parameters:
      archiveEntry - The archiveEntry
      phased - If true size, compressedSize and crc required to be known up-front in the archiveEntry
      Throws:
      ClassCastException - if entry is not an instance of ZipArchiveEntry
      Zip64RequiredException - if the entry's uncompressed or compressed size is known to exceed 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
      IOException

    • rewriteSizesAndCrc

      private void rewriteSizesAndCrc(boolean actuallyNeedsZip64) throws IOException
      When using random access output, write the local file header and potentially the ZIP64 extra containing the correct CRC and compressed/uncompressed sizes.
      Throws:
      IOException

    • setComment

      public void setComment(String comment)
      Sets the file comment.
      Parameters:
      comment - the comment

    • setCreateUnicodeExtraFields

      public void setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy b)
      Whether to create Unicode Extra Fields.

      Defaults to NEVER.

      Parameters:
      b - whether to create Unicode Extra Fields.

    • setDefaults

      private void setDefaults(ZipArchiveEntry entry)
      Provides default values for compression method and last modification time.

    • setEncoding

      public void setEncoding(String encoding)
      The encoding to use for file names and the file comment.

      For a list of possible values see Supported Encodings. Defaults to UTF-8.

      Parameters:
      encoding - the encoding to use for file names, use null for the platform's default encoding

    • setFallbackToUTF8

      public void setFallbackToUTF8(boolean b)
      Whether to fall back to UTF and the language encoding flag if the file name cannot be encoded using the specified encoding.

      Defaults to false.

      Parameters:
      b - whether to fall back to UTF and the language encoding flag if the file name cannot be encoded using the specified encoding.

    • setLevel

      public void setLevel(int level)
      Sets the compression level for subsequent entries.

      Default is Deflater.DEFAULT_COMPRESSION.

      Parameters:
      level - the compression level.
      Throws:
      IllegalArgumentException - if an invalid compression level is specified.

    • setMethod

      public void setMethod(int method)
      Sets the default compression method for subsequent entries.

      Default is DEFLATED.

      Parameters:
      method - an int from java.util.zip.ZipEntry

    • setUseLanguageEncodingFlag

      public void setUseLanguageEncodingFlag(boolean b)
      Whether to set the language encoding flag if the file name encoding is UTF-8.

      Defaults to true.

      Parameters:
      b - whether to set the language encoding flag if the file name encoding is UTF-8

    • setUseZip64

      public void setUseZip64(Zip64Mode mode)
      Whether Zip64 extensions will be used.

      When setting the mode to Never, putArchiveEntry(org.apache.commons.compress.archivers.zip.ZipArchiveEntry), closeArchiveEntry(), finish() or close() may throw a Zip64RequiredException if the entry's size or the total size of the archive exceeds 4GB or there are more than 65536 entries inside the archive. Any archive created in this mode will be readable by implementations that don't support Zip64.

      When setting the mode to Always, Zip64 extensions will be used for all entries. Any archive created in this mode may be unreadable by implementations that don't support Zip64 even if all its contents would be.

      When setting the mode to AsNeeded, Zip64 extensions will transparently be used for those entries that require them. This mode can only be used if the uncompressed size of the ZipArchiveEntry is known when calling putArchiveEntry(org.apache.commons.compress.archivers.zip.ZipArchiveEntry) or the archive is written to a seekable output (i.e. you have used the File-arg constructor) - this mode is not valid when the output stream is not seekable and the uncompressed size is unknown when putArchiveEntry(org.apache.commons.compress.archivers.zip.ZipArchiveEntry) is called.

      If no entry inside the resulting archive requires Zip64 extensions then Never will create the smallest archive. AsNeeded will create a slightly bigger archive if the uncompressed size of any entry has initially been unknown and create an archive identical to Never otherwise. Always will create an archive that is at least 24 bytes per entry bigger than the one Never would create.

      Defaults to AsNeeded unless putArchiveEntry(org.apache.commons.compress.archivers.zip.ZipArchiveEntry) is called with an entry of unknown size and data is written to a non-seekable stream - in this case the default is Never.

      Parameters:
      mode - Whether Zip64 extensions will be used.
      Since:
      1.3

    • shouldAddZip64Extra

      private boolean shouldAddZip64Extra(ZipArchiveEntry entry, Zip64Mode mode)
      Whether to add a Zip64 extended information extra field to the local file header.

      Returns true if

      • mode is Always
      • or we already know it is going to be needed
      • or the size is unknown and we can ensure it won't hurt other implementations if we add it (i.e. we can erase its usage

    • shouldUseZip64EOCD

      private boolean shouldUseZip64EOCD()
      4.4.1.4 If one of the fields in the end of central directory record is too small to hold required data, the field SHOULD be set to -1 (0xFFFF or 0xFFFFFFFF) and the ZIP64 format record SHOULD be created.
      Returns:
      true if zip64 End Of Central Directory is needed

    • usesDataDescriptor

      private boolean usesDataDescriptor(int zipMethod, boolean phased)

    • validateIfZip64IsNeededInEOCD

      private void validateIfZip64IsNeededInEOCD() throws Zip64RequiredException
      If the Zip64 mode is set to never, then all the data in End Of Central Directory should not exceed their limits.
      Throws:
      Zip64RequiredException - if Zip64 is actually needed

    • validateSizeInformation

      private void validateSizeInformation(Zip64Mode effectiveMode) throws ZipException
      Throws an exception if the size is unknown for a stored entry that is written to a non-seekable output or the entry is too big to be written without Zip64 extra but the mode has been set to Never.
      Throws:
      ZipException

    • versionNeededToExtract

      private int versionNeededToExtract(int zipMethod, boolean zip64, boolean usedDataDescriptor)

    • versionNeededToExtractMethod

      private int versionNeededToExtractMethod(int zipMethod)

    • write

      public void write(byte[] b, int offset, int length) throws IOException
      Writes bytes to ZIP entry.
      Overrides:
      write in class OutputStream
      Parameters:
      b - the byte array to write
      offset - the start position to write from
      length - the number of bytes to write
      Throws:
      IOException - on error

    • writeCentralDirectoryEnd

      protected void writeCentralDirectoryEnd() throws IOException
      Writes the "End of central dir record".
      Throws:
      IOException - on error
      Zip64RequiredException - if the archive's size exceeds 4 GByte or there are more than 65535 entries inside the archive and setUseZip64(Zip64Mode) is Zip64Mode.Never.

    • writeCentralDirectoryInChunks

      private void writeCentralDirectoryInChunks() throws IOException
      Throws:
      IOException

    • writeCentralFileHeader

      protected void writeCentralFileHeader(ZipArchiveEntry ze) throws IOException
      Writes the central file header entry.
      Parameters:
      ze - the entry to write
      Throws:
      IOException - on error
      Zip64RequiredException - if the archive's size exceeds 4 GByte and setUseZip64(Zip64Mode) is Zip64Mode.Never.

    • writeCounted

      private void writeCounted(byte[] data) throws IOException
      Write bytes to output or random access file.
      Parameters:
      data - the byte array to write
      Throws:
      IOException - on error

    • writeDataDescriptor

      protected void writeDataDescriptor(ZipArchiveEntry ze) throws IOException
      Writes the data descriptor entry.
      Parameters:
      ze - the entry to write
      Throws:
      IOException - on error

    • writeLocalFileHeader

      protected void writeLocalFileHeader(ZipArchiveEntry ze) throws IOException
      Writes the local file header entry
      Parameters:
      ze - the entry to write
      Throws:
      IOException - on error

    • writeLocalFileHeader

      private void writeLocalFileHeader(ZipArchiveEntry ze, boolean phased) throws IOException
      Throws:
      IOException

    • writeOut

      protected final void writeOut(byte[] data) throws IOException
      Write bytes to output or random access file.
      Parameters:
      data - the byte array to write
      Throws:
      IOException - on error

    • writeOut

      protected final void writeOut(byte[] data, int offset, int length) throws IOException
      Write bytes to output or random access file.
      Parameters:
      data - the byte array to write
      offset - the start position to write from
      length - the number of bytes to write
      Throws:
      IOException - on error

    • writePreamble

      public void writePreamble(byte[] preamble) throws IOException
      Write preamble data. For most of the time, this is used to make self-extracting zips.
      Parameters:
      preamble - data to write
      Throws:
      IOException - if an entry already exists
      Since:
      1.21

    • writePreamble

      public void writePreamble(byte[] preamble, int offset, int length) throws IOException
      Write preamble data. For most of the time, this is used to make self-extracting zips.
      Parameters:
      preamble - data to write
      offset - the start offset in the data
      length - the number of bytes to write
      Throws:
      IOException - if an entry already exists
      Since:
      1.21

    • writeZip64CentralDirectory

      protected void writeZip64CentralDirectory() throws IOException
      Writes the "ZIP64 End of central dir record" and "ZIP64 End of central dir locator".
      Throws:
      IOException - on error
      Since:
      1.3