diff --git "a/local-test-commons-compress-delta-03/afc-commons-compress/src/changes/changes.xml" "b/local-test-commons-compress-delta-03/afc-commons-compress/src/changes/changes.xml" new file mode 100644--- /dev/null +++ "b/local-test-commons-compress-delta-03/afc-commons-compress/src/changes/changes.xml" @@ -0,0 +1,2525 @@ + + + + + + Apache Commons Compress Release Notes + + + + + Better exception messages in SeekableInMemoryByteChannel. + ZipArchiveOutputStream.addRawArchiveEntry() should check is2PhaseSource #571. + ArchiveException extends IOException #605, see also https://github.com/apache/httpcomponents-client/pull/580. + CompressorException extends IOException #605, see also https://github.com/apache/httpcomponents-client/pull/580. + Update outdated descriptions in IOUtils and IOUtilsTest #612. + Remove unused local variable in ZipFile #615. + Optimize ZipEightByteInteger #614. + ZipEightByteInteger.toString() now returns a number string without text prefix, like BigInteger. + Throw an IllegalArgumentException when a file name or comment in gzip parameters encodes to a byte array with a 0 byte #618. + Update outdated links in ZipMethod Javadoc #619. + Deprecate ZipUtil.signedByteToUnsignedInt(byte) in favor of Byte.toUnsignedInt(byte). + ZipArchiveOutputStream.close() does not close its underlying output stream. + ZipArchiveOutputStream.close() does not close its underlying output stream. + Don't use deprecated code in TarArchiveInputStream. + Don't use deprecated code in TarFile. + CpioArchiveInputStream.read(byte[], int, int) now throws an IOException on a data pad count mismatch. + CpioArchiveInputStream.readNewEntry(boolean) now throws an IOException on a header pad count mismatch. + CpioArchiveInputStream.readOldBinaryEntry(boolean) now throws an IOException on a header pad count mismatch. + Fix Javadoc and names in the org.apache.commons.compress.archivers.sevenz package to specify kibibyte scale in memory limits. + Fix Javadoc and names in the org.apache.commons.compress.compressors.lzw package to specify kibibyte scale in memory limits. + Fix Javadoc and names in the org.apache.commons.compress.compressors.z package to specify kibibyte scale in memory limits. + Refactor LZ77Compressor block classes to reduce duplication. + Package-private and private classes can be final. + + Add GzipParameters.getModificationInstant(). + Add GzipParameters.setModificationInstant(Instant). + Add GzipParameters.OS, setOS(OS), getOS(). + Add GzipParameters.toString(). + Add GzipParameters.setFileNameCharset(Charset) and getFileNameCharset() to override the default ISO-8859-1 Charset #602. + Add support for gzip extra subfields, see GzipParameters.setExtra(HeaderExtraField) #604. + Add CompressFilterOutputStream and refactor to use. + Add ZipFile.stream(). + GzipCompressorInputStream reads the modification time (MTIME) and stores its value incorrectly multiplied by 1,000. + GzipCompressorInputStream writes the modification time (MTIME) the value incorrectly divided by 1,000. + Add optional FHCRC to GZIP header #627. + Add GzipCompressorInputStream.Builder allowing to customize the file name and comment Charsets. + Add GzipCompressorInputStream.Builder.setOnMemberStart(IOConsumer) to monitor member parsing. + Add GzipCompressorInputStream.Builder.setOnMemberEnd(IOConsumer) to monitor member parsing. + Add PMD check to default Maven goal. + Add SevenZFile.Builder.setMaxMemoryLimitKiB(int). + Add MemoryLimitException.MemoryLimitException(long, int, Throwable) and deprecate MemoryLimitException.MemoryLimitException(long, int, Exception). + Add support for zstd compression in zip archives. + Add support for XZ compression in ZIP archives. + + Bump org.apache.commons:commons-parent from 72 to 79 #563, #567, #574, #582, #587, #595. + Bump com.github.luben:zstd-jni from 1.5.6-4 to 1.5.6-10 #565, #578, #601, #616, #630, #640. + Bump org.apache.commons:commons-lang3 from 3.16.0 to 3.17.0 #568. + Bump commons-io:commons-io from 2.16.1 to 2.18.0 #575, #610. + Bump com.github.marschall:memoryfilesystem from 2.8.0 to 2.8.1 #577. + Bump org.ow2.asm:asm from 9.7 to 9.7.1 #586. + Bump commons-codec:commons-codec from 1.17.1 to 1.18.0 #636. + + GzipCompressorOutputStream no longer percent-endcodes in US-ASCII a file name or comment that the Charset in GzipParameters.setFileNameCharset(Charset) cannot encode. + Remove ZstdCompressorOutputStream.toString(), it was misleading by returning the delegate's toString(). + + + Compression into BZip2 format has unexpected end of file when using a BufferedOutputStream. + + Bump org.apache.commons:commons-lang3 from 3.15.0 to 3.16.0 #556. + + + + Fix PMD UnnecessaryFullyQualifiedName and others. + Support reading a 7z file that writing archive properties #541. + Upgrade commons-io from 2.15.1 to 2.16.1 #513 + CompressorOutputStream now extends FilterOutputStream. + ArchiveOutputStream now extends FilterOutputStream. + Update Javadoc description for GzipCompressorInputStream #551. + Replace FileNameUtil.getCompressedFileName(String) use of Locale.ENGLISH with Locale.ROOT. + Fix SpotBugs DLS_DEAD_LOCAL_STORE in SevenZFile.readPackInfo(ByteBuffer, Archive). + Fix SpotBugs NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE in ZipFile.openZipChannel(Path, long, OpenOption[]). + Fix SpotBugs UC_USELESS_OBJECT in unpack200.CpBands.parseCpSignature(InputStream). + Fix PMD UselessOverridingMethod in unpack200.bytecode.InnerClassesAttribute. + Fix PMD UselessOverridingMethod in unpack200.bytecode.LineNumberTableAttribute. + Fix PMD CheckSkipResult in ZipArchiveInputStream.closeEntry(). + + Add ArchiveInputStream.forEach(IOConsumer). + Add ArchiveInputStream.iterator(). + Add ArchiveOutputStream.isFinished(). + Add ArchiveOutputStream.checkFinished(). + + Replace assert with Exception + Bump org.apache.commons:commons-parent from 69 to 72 #537. + Bump PMD from 6.x to 7.2.0. + Bump commons-codec:commons-codec from 1.17.0 to 1.17.1 #544. + Bump org.apache.commons:commons-lang3 from 3.14.0 to 3.15.0 #545. + Bump com.github.luben:zstd-jni from 1.5.6-3 to 1.5.6-4 #548. + Bump org.tukaani:xz from 1.9 to 1.10 #550. + Bump org.hamcrest:hamcrest from 2.2 to 3.0 #552. + + + + Deprecate org.apache.commons.compress.utils.CharsetNames in favor or java.nio.charset.StandardCharsets. + Validate TarArchiveEntry checksums #500. + OSGi: Remove unresolvable dependencies in manifest and make the commons-io packages really optional. + Avoid possible NullPointerException in org.apache.commons.compress.utils.Sets.newHashSet(E...). + ZipArchiveOutputStream.setEncoding(String) with a null value throws IllegalArgumentException. + org.apache.commons.compress.harmony.unpack200.Archive.unpack() should not close streams it does not own (when constructed from Archive(InputStream, JarOutputStream)). + ArArchiveOutputStream doesn't pad correctly when a file name length is odd and greater than 16 (padding missing). + ArArchiveOutputStream should check that a file name length greater than 16 fits in a header. + ArArchiveOutputStream implicit narrowing conversion in compound assignment. + Regression on parallel processing of 7zip files. + Regression in pack200's Archive class -- underlying InputStream is now closed. + Avoid NullPointerException in java.nio.channels.spi.AbstractInterruptibleChannel.close() when calling org.apache.commons.compress.archivers.zip.FileRandomAccessOutputStream.close(). + Fix SpotBugs NP_NULL_PARAM_DEREF in Sets.newHashSet(). + Private class' method PackingLogger.setVerbose(boolean) should be private. + + Bump org.apache.commons:commons-parent from 66 to 69 #495, #508. + Bump org.ow2.asm:asm from 9.6 to 9.7 #504. + Bump com.github.luben:zstd-jni from 1.5.5-11 to 1.5.6-2 #510. + Bump commons-io:commons-io from 2.15.1 to 2.16.1 #514. + Bump org.slf4j:slf4j-api from 2.0.12 to 2.0.13 #519. + Bump commons-codec:commons-codec from 1.16.1 to 1.17.0. + + + + TarArchiveOutputStream should use Commons IO Charsets instead of Commons Codec Charsets. + Add org.apache.commons.codec to OSGi imports #482. + Return null value from getNextEntry() for empty file #486. + Remove unused variables in tests #487. + Multithreaded access to Tar archive throws java.util.zip.ZipException: Corrupt GZIP trailer. + ArchiveStreamFactory.detect(InputStream) returns TAR for ICO file #386. + ArchiveInputStream markSupported should always return false. + + Remove out of date jar and scripts #483. + + + + Check for invalid PAX values in TarArchiveEntry #438. + Fix for zero size headers in ArjInputStream #439. + Fixes and tests for ArInputStream #440. + Fixes for dump file parsing #442. + Improve CPIO exception detection and handling #441. + Deprecate SkipShieldingInputStream without replacement (no longer used). + Reuse commons-codec, don't duplicate class PureJavaCrc32C (removed package-private class). + Reuse commons-codec, don't duplicate class XXHash32 (deprecated class). + Reuse commons-io, don't duplicate class Charsets (deprecated class). + Reuse commons-io, don't duplicate class IOUtils (deprecated methods). + Reuse commons-io, don't duplicate class BoundedInputStream (deprecated class). + Reuse commons-io, don't duplicate class FileTimes (deprecated TimeUtils methods). + Reuse Arrays.equals(byte[], byte[]) and deprecate ArchiveUtils.isEqual(byte[], byte[]). + Add a null-check for the class loader of OsgiUtils #451. + Add a null-check in Pack200.newInstance(String, String). + Deprecate ChecksumCalculatingInputStream in favor of java.util.zip.CheckedInputStream. + Deprecate CRC32VerifyingInputStream.CRC32VerifyingInputStream(InputStream, long, int). + FramedSnappyCompressorOutputStream produces incorrect output when writing a large buffer #457. + Fix TAR directory entries being misinterpreted as files #460. + Deprecate unused method FileNameUtils.getBaseName(String). + Deprecate unused method FileNameUtils.getExtension(String). + ArchiveInputStream.BoundedInputStream.read() incorrectly adds 1 for EOF to the bytes read count. + Deprecate IOUtils.read(File, byte[]). + Deprecate IOUtils.copyRange(InputStream, long, OutputStream, int). + ZipArchiveOutputStream multi archive updates metadata in incorrect file #455. + Deprecate ByteUtils.InputStreamByteSupplier. + Deprecate ByteUtils.fromLittleEndian(InputStream, int). + Deprecate ByteUtils.toLittleEndian(DataOutput, long, int). + Reduce duplication by having ArchiveInputStream extend FilterInputStream. + Support preamble garbage in ZipArchiveInputStream #471. + Fix formatting the lowest expressable DOS time #472. + Drop reflection from ExtraFieldUtils static initialization #480. + Preserve exception causation in ExtraFieldUtils.register(Class). + + New runtime dependencies on commons-codec, commons-lang3 and commons-io. + Add and use ZipFile.builder(), ZipFile.Builder, and deprecate constructors. + Add and use SevenZFile.builder(), SevenZFile.Builder, and deprecate constructors. + Add and use ArchiveInputStream.getCharset(). + Add and use ArchiveEntry.resolveIn(Path). + Add Maven property project.build.outputTimestamp for build reproducibility. + + Bump commons-lang3 from 3.13.0 to 3.14.0. + Bump com.github.marschall:memoryfilesystem from 2.6.1 to 2.8.0 #444, #458. + Bump commons-io from 2.15.0 to 2.15.1. + Bump org.apache.commons:commons-parent from 64 to 66. + Bump com.github.luben:zstd-jni from 1.5.5-10 to 1.5.5-11 #448. + Bump org.slf4j:slf4j-api from 2.0.9 to 2.0.12. + Bump commons-codec:commons-codec from 1.16.0 to 1.16.1. + Add dependency on commons-codec:commons-codec:1.16.1. + Add dependency on org.apache.commons:commons-lang3:3.14.0. + Add dependency on commons-io:commons-io:2.15.1. + + + + Add GzipParameters.getFileName() and deprecate getFilename(). + Add GzipParameters.setFileName(String) and deprecate setFilename(String). + Add FileNameUtil.getCompressedFileName(String) and deprecate getCompressedFilename(String). + Add FileNameUtil.getUncompressedFileName(String) and deprecate getUncompressedFilename(String). + Add FileNameUtil.isCompressedFileName(String) and deprecate isCompressedFilename(String). + Add BZip2Utils.getCompressedFileName(String) and deprecate getCompressedFilename(String). + Add BZip2Utils.getUncompressedFileName(String) and deprecate getUncompressedFilename(String). + Add BZip2Utils.isCompressedFileName(String) and deprecate isCompressedFilename(String). + Add LZMAUtils.getCompressedFileName(String) and deprecate getCompressedFilename(String). + Add LZMAUtils.getUncompressedFileName(String) and deprecate getUncompressedFilename(String). + Add LZMAUtils.isCompressedFileName(String) and deprecate isCompressedFilename(String). + Add XYUtils.getCompressedFileName(String) and deprecate getCompressedFilename(String). + Add XYUtils.getUncompressedFileName(String) and deprecate getUncompressedFilename(String). + Add XYUtils.isCompressedFileName(String) and deprecate isCompressedFilename(String). + Add GzipUtils.getCompressedFileName(String) and deprecate getCompressedFilename(String). + Add GzipUtils.getUncompressedFileName(String) and deprecate getUncompressedFilename(String). + Add GzipUtils.isCompressedFileName(String) and deprecate isCompressedFilename(String). + Add SevenZOutputFile.putArchiveEntry(SevenZArchiveEntry) and deprecate putArchiveEntry(ArchiveEntry). + Add generics to ChangeSet and ChangeSetPerformer. + Add generics to ArchiveStreamProvider and friends. + Add a generic type parameter to ArchiveOutputStream and avoid unchecked/unconfirmed type casts in subclasses. + Add a generic type parameter to ArchiveInputStream and deprecate redundant get methods in subclasses. + Add ability to restrict autodetection in CompressorStreamFactory #433. + + Precompile regular expression in ArArchiveInputStream.isBSDLongName(String). + Precompile regular expression in ArArchiveInputStream.isGNULongName(String). + Precompile regular expression in TarArchiveEntry.parseInstantFromDecimalSeconds(String). + Precompile regular expression in ChangeSet.addDeletion(Change). + Improve performance in BlockLZ4CompressorOutputStream. + Null-guard Lister.main(String[]) for programmatic invocation. + NPE in pack200.NewAttributeBands.Reference.addAttributeToBand(NewAttribute, InputStream). + Incorrect lazy initialization and update of static field in pack200.CodecEncoding.getSpecifier(Codec, Codec). + Incorrect string comparison in unpack200.AttributeLayout.numBackwardsCallables(). + Inefficient use of keySet iterator instead of entrySet iterator in pack200.PackingOptions.addOrUpdateAttributeActions(List, Map, int). + Package private class pack200.IcBands.IcTuple should be a static inner class. + Private class ZipFile.BoundedFileChannelInputStream should be a static inner class. + Refactor internal SevenZ AES256SHA256Decoder InputStream into a named static inner class. + Refactor internal SevenZ AES256SHA256Decoder OutputStream into a named static inner class. + Use the root Locale for string conversion of command line options in org.apache.commons.compress.archivers.sevenz.CLI. + Calling PackingUtils.config(PackingOptions) with null now closes the internal FileHandler. + LZ4 compressor throws IndexOutOfBoundsException. + LZWInputStream.initializeTables(int) should throw IllegalArgumentException instead of ArrayIndexOutOfBoundsException. + Throw IOException instead of ArrayIndexOutOfBoundsException when reading Zip with data descriptor entries. + + Bump org.slf4j:slf4j-api from 2.0.8 to 2.0.9 #413. + Bump commons-io:commons-io from 2.13.0 to 2.15.0. + Bump com.github.luben:zstd-jni from 1.5.5-5 to 1.5.5-10 #422, #431. + Bump org.ow2.asm:asm from 9.5 to 9.6 #421. + Bump org.apache.commons:commons-parent from 62 to 64 #421. + + + + Make ZipArchiveEntry.getLocalHeaderOffset() public. + + Use try-with-resources in ArchiveStreamFactory #391. + Javadoc and code comments: Sanitize grammar issues and typos #393. + Remove redundant (null) initializations #394. + [StepSecurity] ci: Harden GitHub Actions #396. + + Bump zstd-jni from 1.5.4-2 to 1.5.5-5 #377, #383, #388, #390, #400. + Bump memoryfilesystem from 2.5.0 to 2.6.1 #381, #385, #387. + Bump commons-parent from 56 to 61 #384. + Bump commons-io:commons-io from 2.11.0 to 2.13.0. + Bump commons-lang3 from 3.12.0 to 3.13.0. + Bump org.slf4j:slf4j-api from 2.0.7 to 2.0.8. + + + + Implicit narrowing conversion in compound assignment. + Avoid NPE in FileNameUtils.getBaseName(Path) for paths with zero elements like root paths. + Avoid NPE in FileNameUtils.getExtension(Path) for paths with zero elements like root paths. + LZMA2Decoder.decode() looses original exception. + Extract conditions and avoid duplicate code. #297. + Remove duplicate conditions. Use switch instead. #298. + Replace JUnit 3 and 4 with JUnit 5 #344, #346. + Make 'ZipFile.offsetComparator' static #353. + + The GzipCompressorOutputStream#writeHeader() uses ISO_8859_1 to write the file name and comment. + If the strings contains non-ISO_8859_1 characters, unknown characters are displayed after decompression. + Use percent encoding for non ISO_8859_1 characters. + + Port some code from IO to NIO APIs. + pack200: Fix FileBands misusing InputStream#read(byte[]) #360. + Add TarArchiveEntry.getLinkFlag() #365. + Integer overflow ArithmeticException in TarArchiveOutputStream #368. + org.apache.commons.compress.archivers.zip.ZipFile.finalize() should not write to std err. + + Use FileTime for time fields in SevenZipArchiveEntry #256. + Fix calculation the offset of the first ZIP central directory entry #334. + Add encryption support for SevenZ #332. + Support for extra time data in Zip archives #345. + Add org.apache.commons.compress.archivers.zip.DefaultBackingStoreSupplier to write to a custom folder instead of the default temporary folder. + Add capability to configure Deflater strategy in GzipCompressorOutputStream: GzipParameters.setDeflateStrategy(int). + + Remove BZip2CompressorOutputStream.finalize() which only wrote to std err. + + Bump mockito.version from 4.8.0 to 4.11.0 #328, #331, #340, #348. + Bump pmd from 6.50.0 to 6.53.0. + Bump memoryfilesystem from 2.3.0 to 2.5.0 #330, #359. + Bump slf4j-api from 2.0.3 to 2.0.7 #329, #333, #341, #371. + Bump japicmp from 0.16.0 to 0.17.1. + Bump commons-parent from 54 to 56 #339, #349. + Bump zstd-jni from 1.5.2-5 to 1.5.4-2 #362, #364. + Bump asm from 9.4 to 9.5 #376. + + + + + Fix some compiler warnings in pack200 packages. + + + Close File input stream after unpacking in Pack200UnpackerAdapter.unpack(File, JarOutputStream). + + + Pack200UnpackerAdapter.unpack(InputStream, JarOutputStream) should not close its given input stream. + + + Fix minor problem in examples. + + + Add a limit to the copy buffer in IOUtils.readRange() to + avoid reading more from a channel than asked for. + Github Pull Request #214. + + + Documentation nits #217. + + + Replace wrapper Collections.sort is with an instance method directly. #245. + + + Replace manual comparisons with Comparator.comparingInt() #244. + + + Replace manual copy of array contents with System.arraycopy() #246. + + + Fix thread safety issues when encoding 7z password #248. + + + bzip2: calculate median-of-3 on unsigned values #242. + + + Use Math.min and Math.max calculations. #247. + + + Expander should be able to work if an entry's name is "./". + + + Ensure compatibility with Java 8 #252. + + + Use StringBuilder instead of StringBuffer. #284. + + + Inline variable. Remove redundant local variable. #283. + + + Use compare method #285. + + + Remove Unnecessary interface modifiers #281. + + + Avoid use C-style array declaration. #282. + + + ChecksumVerifyingInputStream.read() does not always validate checksum at end-of-stream. + + + Fix TarFileTest #289. + + + Update Wikipedia link in TarUtils.java:627. + + + OutOfMemoryError on malformed pack200 input (attributes). + + + OutOfMemoryError on malformed pack200 input (org.apache.commons.compress.harmony.pack200.NewAttributeBands.readNextUnionCase). + + + OutOfMemoryError on malformed unpack200 input (org.apache.commons.compress.harmony.unpack200.NewAttributeBands.readNextUnionCase). + + + Some input streams are not closed in org.apache.commons.compress.harmony.pack200.PackingUtils. + + + Pack200 causes a 'archive.3E' error if it’s not in the system class loader. + + + + Migrate ZIP package to use NIO #236. + + + Add APK file extension constants: ArchiveStreamFactory.APK, APKM, APKS, XAPK. + + + ArchiveStreamFactory.createArchiveInputStream(String, InputStream, String) supports the "APK" format (it's a JAR). + + + Expander example now has NIO Path versions of IO File APIs. + + + Improve TAR support for file times #254. + + + Add SevenZArchiveEntry.setContentMethods(SevenZMethodConfiguration...). + + + + Bump actions/cache from 2.1.6 to 3.0.10 #230, #257, #305, #320. + + + Bump actions/checkout from 2.3.4 to 3.1.0 #226, #227, #251, #300, #321. + + + Bump actions/setup-java from 2 to 3.5.1 #278. + + + Bump github/codeql-action from 1 to 2 #287. + + + Bump mockito-core from 3.11.1 to 4.6.1 #209, #224, #231, #235, #243, #253, #286, #294. + + + Bump org.apache.felix.framework from 7.0.0 to 7.0.1 #208. + + + Bump memoryfilesystem from 2.1.0 to 2.3.0 #212, #237. + + + Bump zstd-jni from 1.5.0-2 to 1.5.2-5 #215, #233, #238, #240, #250, #291, #326. + + + Bump Pack200 packages from ASM 3.2 to 9.2 #216. + Breaks binary compatibility in the internals of the pack200 implementation: + - org.apache.commons.compress.harmony.pack200.Segment + - org.apache.commons.compress.harmony.pack200.SegmentMethodVisitor + - org.apache.commons.compress.harmony.pack200.SegmentAnnotationVisitor + - org.apache.commons.compress.harmony.pack200.SegmentFieldVisitor + + + Bump asm from 9.2 to 9.4 #279, #322. + + + Bump maven-javadoc-plugin from 3.3.0 to 3.4.1 #221, #249, #288, #308. + + + Bump maven-pmd-plugin from 3.14.0 to 3.19.0 #296, #309, #311. + + + Bump pmd from 6.44.0 to 6.50.0. + + + Bump commons.japicmp.version from 0.15.3 to 0.16.0. + + + Bump maven-bundle-plugin from 5.1.2 to 5.1.8 #234, #239, #290, #292, #301, #304. + + + Bump org.apache.felix.framework from 7.0.1 to 7.0.5 #232, #295. + + + Bump slf4j-api from 1.7.30 to 2.0.3 #213, #241, #258, #310, #314, #315, #318. + + + Bump commons-parent from 52 to 54 #280. + + + Bump commons.jacoco.version from 0.8.7 to 0.8.8. + + + Bump junit.version from 5.8.2 to 5.9.1 #302, #317. + + + Bump mockito.version from 4.6.1 to 4.8.0 #307, #312. + + + Bump maven-surefire-plugin from 3.0.0-M6 to 3.0.0-M7. + + + + + Made sure ZstdCompressorOutputStream no longer used + deprecated ZstOutputStream constructors. + Github Pull Request #94. + + + Make compression level of ParallelScatterZipCreator + configurable via a new constructor. + + + Fix bugs in random access of 7z. Problems may happen + in a mixture use of random access and sequential access + of 7z. + Github Pull Request #95. + + + Fix bugs in random access of 7z. Exceptions are thrown + when reading the first entry multiple times by random + access. + + + Add '/' to directories with long name in tar. This is to + resolve the ambiguous behavior of the TarArchiveEntry.getName() + method between directory with short name and long name. + + + Removed the PowerMock dependency. + + + Added improved checks to detect corrupted bzip2 streams and + throw the expected IOException rather than obscure + RuntimeExceptions. + See also COMPRESS-519. + + + Improved parsing of X5455_ExtendedTimestamp ZIP extra field. + + + ZipArchiveInputStream and ZipFile will now throw an + IOException rather than a RuntimeException if the zip64 extra + field of an entry could not be parsed. + + + Improved detection of corrupt ZIP archives in ZipArchiveInputStream. + + + Added improved checks to detect corrupted deflate64 streams and + throw the expected IOException rather than obscure + RuntimeExceptions. + See also COMPRESS-522, COMPRESS-525, COMPRESS-526, and COMPRESS-527. + + + Add the archive name in the exception in the constructor of + ZipFile to make it a more specific exception. + Github Pull Request #102. + + + Throw IOException when it encounters a non-number while parsing pax header. + + + Throw IOException when a tar archive contains a PAX header + without any normal entry following it. + + + Added improved checks to detect corrupted IMPLODED streams and + throw the expected IOException rather than obscure + RuntimeExceptions. + + + Throw expected IOException instead of NumberFormatException if + it encounters non-numbers when parsing pax headers for tarball. + + Throw IllegalArgumentException instead of RuntimeExceptions if + the file name is longer than 100 bytes with the longFileMode + of LONGFILE_ERROR, and address this in java docs. + + Throw IllegalArgumentException instead of RuntimeExceptions if + the any of the numeric values of an entry exceeds the limits + of a traditional tar header while bigNumberMode is + BIGNUMBER_ERROR, and address this in java docs. + + + Made an inner class static + Github Pull Request #107. + + + added an early exit to a loop in BZip2CompressorOutputStream + Github Pull Request #106. + + + Update the class of variable file in TarArchiveEntry from + java.io.File to java.nio.file.Path. Corresponding constructors + and methods are also modified/added. + + NOTE: The userName, groupName, userID and groupID will also be + set if they are available. The userName and groupName was not + set previously, and the previous value of UserID:GroupID was + 0:0 by default. + Please note this may cause a reproducibility problem. + + Github Pull Request #97. + + + Reuse the record buffer in TarArchiveInputStream. + + + Add SevenZOutputFile.write(InputStream). + + + Add SevenZOutputFile.write(Path, OpenOption...). + + + Add SevenZOutputFile.createArchiveEntry(Path, String, LinkOption...). + + + Add ArArchiveOutputStream.createArchiveEntry(Path, String, LinkOption...). + + + Add ArArchiveEntry(Path, String, LinkOption...). + + + Add ctor CpioArchiveEntry(Path, String, LinkOption...). + + + Add ctor CpioArchiveEntry(short, Path, String, LinkOption...). + + + Add CpioArchiveEntry.setTime(FileTime). + + + Add TarArchiveOutputStream.createArchiveEntry(Path, String, LinkOption...). + + + Add ctor TarArchiveEntry(Path, String, LinkOption...). + + + Add IOUtils.EMPTY_LINK_OPTIONS. + + + Add Path support to ZipArchiveOutputStream #123. + + + Fix for test fails on Windows. The tests are failing because the + default charset is not UTF-8. + + + TarArchiveInputStream can not detect a truncated tar in skip() + and skipRecordPadding(). + + + Make the memory allocation in SevenZFile.readFilesInfo a lazy + allocation to avoid OOM when dealing some giant 7z archives. + Github Pull Request #120. + + Also added sanity checks before even trying to parse an + archive and made SevenZFileOptions' maxMemorySizeInKb apply to + the stored metadata for an archive. + + And further added an option that needs to be enabled in order + to make SevenZFile try to recover a broken archive. This is a + backwards incompatible change. + + + ZipArchiveInputStream should throw an exception if a corrputed + zip64 extra field is met. + + + Add a new maven profile in pom.xml for JDK14+ to ignore the + failing tests about Pack200. + + This has later been superseeded by adding the Apache Harmony + classes for Pack200 support. + + + Throw an IOException when reading the ZIP extra field if the + length is too short. + + + Throw an declared IOException if a null entry is met when + reading a global pax header instead of a runtime NPE. + + + ZIP extraction could lead to ArrayIndexOutOfBoundsExceptions + rather than the expected IOException. + + + Add asserts for Arrays.copyOf in X0017_StrongEncryptionHeader. + + + Add writePreamble to ZipArchiveInputStream. This method could + write raw data to ZIP archive before any entry was written to + the ZIP archive. + For most of the time, this is used to create self-extracting + ZIP. + Github Pull Request #127. + + + Fix for the CFH signature detect in ZipArchiveInputStream. + The problem could be reproduced by a ZIP archive with Data + Descriptor and STORED, and without the Data Descriptor + signature. + + + The length validation in TarArchiveInputStream.parsePaxHeaders + should also consider the headers with length smaller than 1 + and ignore these headers. + + + Fix accidentally added '/' to file names. + This problem is caused by the incomplete fix of + COMPRESS-509. + Github Pull Request #151. + + + As sparse entries can be successfully parsed now, + TarArchiveInputStream.canReadEntryData should return + true if the entry is a sparse entry. + Github Pull Request #153. + + + SparseFilesTest#testExtractPaxGNU should be skipped + if the version of GNU tar binary is 1.28. + Github Pull Request #152. + + + Some minor improvements. + Github Pull Request #157. + + + Added support for random access to the TAR packages. + Github Pull Request #113. + + + Added support for BufferPool in ZstdCompressorInputStream. + Github Pull Request #165. + + + Removed an empty loop that was just warming the planet for + certain ZIP archives. + Github Pull Request #172. + + + Made some of the stream classes used internally throw + IOExceptions on illegal arguments rather than + RuntimeExceptions to make it more likely that corrupt archives + cause expected checked exceptions rather than RuntimException + for various formats. + + Fixes a specific case for ZIP but affects other formats as + well. + + + Commons Compress cannot be built with JDK14 due to Pack200 removal. + Add Pack200 implementation from Apache Harmony. + + + Simplify Assertions #205. + + + + Update from Java 7 to 8. + + + Update GitHub actions/checkout from v1 to v2.3.4, #114, #124, #139, #150. + + + Update actions/setup-java from v1.4.0 to v2, #125, #133, #141. + + + Update com.github.luben:zstd-jni from 1.4.4-7 to 1.5.0-2, #118, #159, #173, #174, #203. + + + Update tests slf4j-api from 1.7.26 to 1.7.30 #117. + + + Update maven-pmd-plugin from 3.12.0 to 3.14.0, #115, #154. + + + Update maven-bundle-plugin from 3.5.1 to 5.1.2 #116, #180. + + + Bump memoryfilesystem from 1.3.0 to 2.1.0 #131. + + + Bump actions/cache from v2 to v2.1.6, #164, #200. + + + Bump junit from 4.13 to 4.13.2, #143, #167. + + + Bump mockito-core from 1.10.19 to 3.11.1, #161, #170, #204. + + + Bump commons.jacoco.version from 0.8.5 to 0.8.7 (Java 16 builds). + + + Bump org.apache.felix:org.apache.felix.framework from 6.0.3 to 7.0.0 (Java 16 builds). + + + Bump commons.japicmp.version from 0.14.3 to 0.15.3 (Java 16 builds). + + + Bump commons.javadoc.version from 3.2.0 to 3.3.0. + + + Checked the sizes read for archive entries and reject archives + as broken with negative entry sizes. + + Fixes an infinite loop in the new TarFile class but affects + several formats. + + + OSGi detection was broken and so we always cached whether + XZ/brotli/zstd/LZMA have been available even in OSGi + environments. + + + SevenZFile.getEntries now return a copy of entries. + + + Update com.github.luben:zstd-jni from 1.4.8-7 to 1.4.9-1 #176. + + + Handling of sparse tar entries has been hardened to ensure bad + inputs cause expected IOExceptions rather than RuntimeExceptions. + + + Update org.tukaani:xz from 1.8 to 1.9 + + + Add a new AlwaysWithCompatibility in Zip64Mode, this is a + compromise for some libraries including 7z and Expand-Archive + Powershell utility(and likely Excel). + + And we will encode both the LFH offset and Disk Number Start + in the ZIP64 Extended Information Extra Field - even if only + the disk number needs to be encoded. + + Github Pull Request #169. + + + Some minor improvements. + Github Pull Request #193. + + + Java8 improvements. + Github Pull Request #194. + + + Remove redundant local variable. + Github Pull Request #195. + + + Remove redundant operation + Github Pull Request #196. + + + gzip deflate buffer size is now configurable. + + + The parser for GNU sparse tar headers could throw a + NullPointerExcpetion rather than an IOException if the archive + ended while more sparse headers were expected. + + + Call enableRelaxedEndCondition() to enable decoding of 7z + files containing LZMA streams with end marker. + Github Pull Request #223. + + + Use LinkedHashMap for fileMap in SevenZFile.readFilesInfo, + as it will be read in specific order. + + + + + Update optional library com.github.luben:zstd-jni from 1.4.0-1 to 1.4.4-7. + + + Update tests from org.apache.felix:org.apache.felix.framework 6.0.2 to 6.0.3. + + + SevenZFile could throw NullPointerException rather than + IOException for certain archives. In addition it now handles + certain empty archives more gracefully. + + + Deflate64CompressorInputStream.read would return 0 for some + inputs in violation of the InputStream.read contract. + + + Removed the extraction code from the example CLI class inside + of the SevenZ package. Not only is it superseeded by the + examples package, its implementation was vulnerable to the + ZipSlip attack. + + + SevenZFile can now recover from a certain corruption that + seems to happen occasionally when split archives are created. + + + Added random access support to SevenZFile. + + + Added support for split ZIP archives. + + + Added support for reading sparse entries to the TAR package. + + + SeekableInMemoryByteChannel's truncate didn't set position + according to the spec in an edge case. + + + BZip2CompressorInputStream now incorporates a similar patch as + the one that fixed CVE-2019-12900 in libbzip2. + + Commons Compress has not been vulnerable to this CVE as it + would have rejected a file with too many selectors. With this + patch Commons Compress will be able to read certain archives + that would have caused errors in Compress 1.19. + + + Update JUnit from 4.12 to 4.13. + + + + + ZipArchiveInputStream could forget the compression level has + changed under certain circumstances. + + + It is now possible to skip parsing of local file headers when + using ZipFile which may speed up reading the archive at the + cost of potentially missing important information. See the + javadocs of the ZipFile class for details. + + + TarArchiveInputStream has a new constructor-arg lenient that + can be used to accept certain broken archives. + + + Fixed another potential resource leak in + ParallelScatterZipCreator#writeTo. + + + ArjArchiveEntry and SevenZArchiveEntry now implement hashCode + and equals. + + + ArArchiveInputStream could think it had hit EOF prematurely. + Github Pull Request #74. + + + SevenZFile now provides a way to cap memory consumption for + LZMA(2) compressed content. + Github Pull Request #76. + + + The ARJ package has been updated to contain constants for more + recent specifications. + + + Update optional library zstd-jni from 1.3.3-3 to 1.4.0-1. + + + ParallelScatterZipCreator now writes the entries to the + gathered output in the same order they have been added. + Github Pull Requests #78 and #79. + + + Throw IOException rather than RuntimeExceptions for certain + malformed LZ4 or Snappy inputs. + + + The Expander and Archive example classes can leak resources + they have wrapped around passed in streams or channels. The + methods consuming streams and channels have been adapted to + give the calling code a chance to deal with those wrapper + resources. + + + ZipArchiveInputStream and ZipFile no longer assume Commons + Compress would understand extra fields better than the writer + of the archive and silently turn extra fields that Commons + Compress should understand into UnrecognizedExtraFields if + parsing said fields fails. + It is now possible to take more control over the extra field + parsing process with a new overload of + ZipArchiveEntry#getExtraFields. + + + ZipArchiveInputStream failed to read stored entries with a + data descriptor if the data descriptor didn't use the + signature invented by InfoZIP. + + + ZipArchiveInputStream will now throw an exception if reading a + stored entry with a data descriptor and the data descriptor + doesn't match what it has actually read. + + The most common case for a situation like this is a stored ZIP + archive inside of the archive ZipArchiveInputStream currently + reads. In such a case ZipArchiveInputStream would happily + extract the contained archive and stop once the central + directory of the inner archive has been hit. This is a case + where ZipArchiveInputStream simply can not be used and only + ZipFile is able to read the archive. + + The only other explanation is a broken archive. So the + exception prevents users from thinking they had successfully + read the contents of the archive. + + + Added a MultiReadOnlySeekableByteChannel class + that can be used to concatenate the parts of a multi volume 7z + archive so that SevenZFile can read them. + + + The 7zip tools provide a default name for archive entries + without name; SevenZFile returns a null name for such + entries. A new method getDefaultName has been added to derive + the same name the 7zip tools would use and an option has been + added that sets SevenZArchiveEntry's name to the default name + if it is not contained inside the archive. + + + NioZipEncoding#encode could enter an infinite loop for certain + inputs. + + + + + The example Expander class has been vulnerable to a path + traversal in the edge case that happens when the target + directory has a sibling directory and the name of the target + directory is a prefix of the sibling directory's name. + + + Changed the OSGi Import-Package to also optionally import + javax.crypto so encrypted archives can be read. + + + Changed various implementations of the close method to better + ensure all held resources get closed even if exceptions are + thrown during the closing the stream. + + + ZipArchiveInputStream can now detect the APK Signing Block + used in signed Android APK files and treats it as an "end of + archive" marker. + + + The cpio streams didn't handle archives using a multi-byte + encoding properly. + + + It is now possible to specify the arguments of zstd-jni's + ZstdOutputStream constructors via Commons Compress as well. + + + ZipArchiveInputStream#read would silently return -1 on a + corrupted stored entry and even return > 0 after hitting the + end of the archive. + + + ArArchiveInputStream#read would allow to read from the stream + without opening an entry at all. + + + + + Removed the objenesis dependency from the pom as it is not + needed at all. + + + Fixed resource leak in ParallelScatterZipCreator#writeTo. + + + Fixed some code examples. + Github Pull Request #63. + + + Certain errors when parsing ZIP extra fields in corrupt + archives are now turned into ZipException, they used to + manifest as ArrayIndexOutOfBoundsException before. + + + The streams returned by ZipFile and most other decompressing + streams now provide information about the number of compressed + and uncompressed bytes read so far. This may be used to detect + a ZipBomb if the compression ratio exceeds a certain + threshold, for example. + For SevenZFile a new method returns the statistics for the + current entry. + + + Added a unit test that is supposed to fail if we break the + OSGi manifest entries again. + + + Add a new SkipShieldingInputStream class that can be used with + streams that throw an IOException when skip is invoked. + + + IOUtils.copy now verifies the buffer size is bigger than 0. + + + New constructors have been added to SevenZFile that accept + char[]s rather than byte[]s in order to avoid a common error + of using the wrong encoding when creating the byte[]. This + change may break source compatibility for client code that + uses one of the constructors expecting a password and passes + in null as password. We recommend to change the code to use a + constructor without password argument. + + + Added a workaround for a bug in AdoptOpenJDK for S/390 to + BZip2CompressorInputStream. + + + ZipArchiveInputStream failed to read some files with stored + entries using a data descriptor. + + + + + Fixed the OSGi manifest entry for imports that has been broken + in 1.16. + + + + + Add read-only support for Zstandard compression based on the + Zstd-jni project. + + + Added auto-detection for Zstandard compressed streams. + + + Synchronized iteration over a synchronizedList in ParallelScatterZipCreator. + + + ZipFile could get stuck in an infinite loop when parsing ZIP + archives with certain strong encryption headers. + + + Replaces instanceof checks with a type marker in LZ77 support code. + + + Added write-support for Zstandard compression. + + + Added improved checks to detect corrupted bzip2 streams and + throw the expected IOException rather than obscure + RuntimeExceptions. + + + Updated XZ for Java dependency to 1.8 in order to pick up bug + fix to LZMA2InputStream's available method. + + + ZipArchiveEntry now exposes how the name or comment have been + determined when the entry was read. + + + Added read-only DEFLATE64 support to ZIP archives and as + stand-alone CompressorInputStream. + + + ZipFile.getInputStream will now always buffer the stream + internally in order to improve read performance. + + + Speed improvement for DEFLATE64 decompression. + + + Added read-only DEFLATE64 support to 7z archives. + + + Added a few extra sanity checks for the rarer compression + methods used in ZIP archives. + + + Simplified the special handling for the dummy byte required by + zlib when using java.util.zip.Inflater. + + + Various code cleanups. + Github Pull Request #61. + + + TarArchiveEntry's preserveLeadingSlashes constructor argument + has been renamed and can now also be used to preserve the + drive letter on Windows. + + + + + Make sure "version needed to extract" in local file header and + central directory of a ZIP archive agree with each other. + Also ensure the version is set to 2.0 if DEFLATE is used. + + + Don't use a data descriptor in ZIP archives when copying a raw + entry that already knows its size and CRC information. + + + Travis build redundantly repeats compilation and tests redundantly #43. + + + Added magic MANIFEST entry Automatic-Module-Name so the module + name will be org.apache.commons.compress when the jar is used + as an automatic module in Java9. + + + The MANIFEST of 1.14 lacks an OSGi Import-Package for XZ for + Java. + + + BUILDING.md now passes the RAT check. + + + Added a new utility class FixedLengthBlockOutputStream that + can be used to ensure writing always happens in blocks of a + given size. + + + Made sure ChecksumCalculatingInputStream receives valid + checksum and input stream instances via the constructor. + + + TarArchiveOutputStream now verifies the block and record sizes + specified at construction time are compatible with the tar + specification. In particular 512 is the only record size + accepted and the block size must be a multiple of 512. + At the same time the default block size in + TarArchiveOutputStream has been changed from 10240 to 512 + bytes. + + + It is now possible to specify/read custom PAX headers when + writing/reading tar archives. + + + Fixed class names of CpioArchiveEntry and + CpioArchiveInputStream in various Javadocs. + + + The code of the extended timestamp ZIP extra field incorrectly + assumed the time was stored as unsigned 32-bit int and thus + created incorrect results for years after 2037. + + + Removed ZipEncoding code that became obsolete when we started + to require Java 5 as baseline long ago. + + + The tar package will no longer try to parse the major and + minor device numbers unless the entry represents a character + or block special file. + + + When reading tar headers with name fields containing embedded + NULs, the name will now be terminated at the first NUL byte. + + + Simplified TarArchiveOutputStream by replacing the internal + buffering with new class FixedLengthBlockOutputStream. + + + + + SnappyCompressorInputStream slides the window too early + leading to ArrayIndexOutOfBoundsExceptions for some streams. + + + Added write support for Snappy. + + + The blocksize for FramedSnappyCompressorInputStream can now be + configured as some IWA files seem to be using blocks larger + than the default 32k. + + + ZipArchiveEntry#isUnixSymlink now only returns true if the + corresponding link flag is the only file-type flag set. + + + Added support for LZ4 (block and frame format). + + + BZip2CompressorInputstream now uses BitInputStream internally. + Pull Request #13. + + + Fixed an integer overflow in CPIO's CRC calculation. + Pull Request #17. + + + Add static detect(InputStream in) to CompressorStreamFactory + and ArchiveStreamFactory + + + Make unit tests work on Windows paths with spaces in their names. + + + Improved performance for concurrent reads from ZipFile when + reading from a file. + + + Added a way to limit amount of memory ZCompressorStream may + use. + + + Added a way to limit amount of memory ZCompressorStream may + use. + + + Added a way to limit amount of memory LZMACompressorStream and + XZCompressorInputStream may use. + + + Internal location pointer in ZipFile could get incremented + even if nothing had been read. + + + Add Brotli decoder based on the Google Brotli library. + + + ZipEntry now exposes its data offset. + + + LZMACompressorOutputStream#flush would throw an exception + rather than be the NOP it promised to be. + + + Using ZipArchiveEntry's setAlignment it is now possible to + ensure the data offset of an entry starts at a file position + that at word or page boundaries. + A new extra field has been added for this purpose. + + + + + Update Java requirement from 6 to 7. + + + BitInputStream could return bad results when overflowing + internally - if two consecutive reads tried to read more than + 64 bits. + + + Clarified which TarArchiveEntry methods are useless for + entries read from an archive. + + + ZipArchiveInputStream.closeEntry does not properly advance to + next entry if there are junk bytes at end of data section + + + SevenZFile, SevenZOutputFile, ZipFile and + ZipArchiveOutputStream can now work on non-file resources if + they can be accessed via SeekableByteChannel. + + + Allow compressor extensions through a standard JRE ServiceLoader. + + + Allow archive extensions through a standard JRE ServiceLoader. + + + Add write support for the legacy LZMA format, this requires XZ + for Java 1.6. + + + Add write support for the legacy LZMA stream to 7z, this + requires XZ for Java 1.6. + + + Allow the clients of ParallelScatterZipCreator to provide + ZipArchiveEntryRequestSupplier. + + + ZipArchiveInputStream now throws an Exception if it encounters + a broken ZIP archive rather than signaling end-of-archive. + + + ScatterZipOutputStream didn't close the StreamCompressor + causing a potential resource leak. + + + Add a version-independent link to the API docs of the latest + release. + + + + + Update requirement from Java 5 to 6. + + + TarArchiveEntry wastefully allocates empty arrays. + + + SevenZFile.read() throws an IllegalStateException for empty entries. + + + Javadoc for BZip2CompressorInputStream(InputStream, boolean) should refer to IOEx, not NPE. + + + PureJavaCrc32C in the snappy package is now final so it is now + safe to call a virtual method inside the constructor. + + + TarArchiveInputStream failed to parse PAX headers that + included blank lines. + + + TarArchiveInputStream failed to parse PAX headers whose tar + entry name ended with a slash. + + + FramedSnappyCompressorInputStream now supports the dialect of + Snappy used by the IWA files contained within the ZIP archives + used in Apple's iWork 13 files. + + + ZipArchiveInputStream and CpioArchiveInputStream could throw + exceptions who's messages contained potentially corrupt entry + names read from a broken archive. They will now sanitize the + names by replacing unprintable characters and restricting the + length to 255 characters. + + + BZip2CompressorOutputStream no longer tries to finish the + output stream in finalize. This is a breaking change for code + that relied on the finalizer. + + + + + TarArchiveInputStream now supports reading global PAX headers. + + + The PAX headers for sparse entries written by star are now + applied. + + + GNU sparse files using one of the PAX formats are now + detected, but cannot be extracted. + + + ArArchiveInputStream can now read GNU extended names that are + terminated with a NUL byte rather than a linefeed. + + + New method SevenZFile.getEntries can be used to list the + contents of a 7z archive. + + + Native Memory Leak in Sevenz-DeflateDecoder. + + + When using Zip64Mode.Always also use ZIP64 extensions inside + the central directory. + GitHub Pull Request #10 + + + SevenZFile will now only try to drain an entry's content when + moving on to the next entry if data is read from the next + entry. This should improve performance for applications that + try to skip over entries. + + + file names of tar archives using the xstar format are now + parsed properly. + + + checksums of tars that pad the checksum field to the left are + now calculated properly. + + + ArArchiveInputStream failed to read past the first entry when + BSD long names have been used. + + + Added buffering for random access which speeds up 7Z support. + + + The checksum validation of TararchiveEntry is now as strict as + the validation of GNU tar, which eliminates a few cases of + false positives of ArchiveStreamFactory. + This behavior is a breaking change since the check has become + more strict but any archive that fails the checksum test now + would also fail it when extracted with other tools and must be + considered an invalid archive. + + + ZipFile.getRawInputStream() is now part of the public API + + + SnappyCompressorInputStream and + FramedSnappyCompressorInputStream returned 0 at the end of the + stream under certain circumstances. + + + Allow byte-for-byte replication of Zip entries. + GitHub Pull Request #6. + + + TarArchiveEntry's preserveLeadingSlashes is now a property and used + on later calls to setName, too. + This behavior is a breaking change. + + + Adjusted unit test to updates in Java8 and later that change + the logic of ZipEntry#getTime. + + + TarArchiveOutputStream will now recognize GNU long name and + link entries even if the special entry has a different name + than GNU tar uses itself. This seems to be the case for + archives created by star. + + + ArrayIndexOutOfBoundsException when InfoZIP type 7875 extra + fields are read from the central directory. + + + Added read-only support for bzip2 compression used inside of + ZIP archives. + GitHub Pull Request #4. + + + + + + + ArrayIndexOutOfBoundsException when ZIP extra fields are read + and the entry contains an UnparseableExtraField. + + + CompressorStreamFactory can now auto-detect DEFLATE streams + with ZLIB header. + + + TarArchiveInputStream can now read entries with group or + user ids > 0x80000000. + + + TarArchiveOutputStream can now write entries with group or + user ids > 0x80000000. + + + CompressorStreamFactory can now auto-detect LZMA streams. + + + TarArchiveEntry's constructor with a File and a String arg + didn't normalize the name. + + + ZipEncodingHelper no longer reads system properties directly + to determine the default charset. + + + BZip2CompressorInputStream#read would return -1 when asked to + read 0 bytes. + + + ArchiveStreamFactory fails to pass on the encoding when creating some streams. + * ArjArchiveInputStream + * CpioArchiveInputStream + * DumpArchiveInputStream + * JarArchiveInputStream + * TarArchiveInputStream + * JarArchiveOutputStream + + + Restore immutability/thread-safety to ArchiveStreamFactory. + The class is now immutable provided that the method setEntryEncoding is not used. + The class is thread-safe. + + + Restore immutability/thread-safety to CompressorStreamFactory. + The class is now immutable provided that the method setDecompressConcatenated is not used. + The class is thread-safe. + + + SevenZFile now throws the specific PasswordRequiredException + when it encounters an encrypted stream but no password has + been specified. + + + Improved error message when tar encounters a groupId that is + too big to write without using the STAR or POSIX format. + + + Added support for parallel compression. This low-level API allows + a client to build a ZIP/jar file by using the class + org.apache.commons.compress.archivers.zip.ParallelScatterZipCreator. + + Zip documentation updated with further notes about parallel features. + + Please note that some aspects of jar creation need to be + handled by client code and is not part of commons-compress for this + release. + + + Cut overall object instantiation in half by changing file + header generation algorithm, for a 10-15 percent performance + improvement. + + Also extracted two private methods createLocalFileHeader + and createCentralFileHeader in ZipArchiveOutputStream. + These may have some interesting additional usages in the + near future. + + + ZipFile logs a warning in its finalizer when its constructor + has thrown an exception reading the file - for example if the + file doesn't exist. + + + New methods in ZipArchiveOutputStream and ZipFile allows + entries to be copied from one archive to another without + having to re-compress them. + + + Moved the package + org.apache.commons.compress.compressors.z._internal_ to + org.apache.commons.compress.compressors.lzw and made it part + of the API that is officially supported. This will break + existing code that uses the old package. + + + + + + Added support for DEFLATE streams without any gzip framing. + + + When reading 7z files unknown file properties and properties + of type kDummy are now ignored. + + + Expanding 7z archives using LZMA compression could cause an + EOFException. + + + Checking for XZ for Java may be expensive. The result will + now be cached outside of an OSGi environment. You can use the + new XZUtils#setCacheXZAvailability to overrride this default + behavior. + + + Long-Name and -link or PAX-header entries in TAR archives + always had the current time as last modfication time, creating + archives that are different at the byte level each time an + archive was built. + + + + + + The dependency on org.tukaani:xz is now marked as optional. + + + The snappy, ar and tar inputstreams might fail to read from a + non-buffered stream in certain cases. + + + CompressorStreamFactory can now auto-detect Unix compress + (".Z") streams. + + + IOUtils#skip might skip fewer bytes than requested even though + more could be read from the stream. + + + ArchiveStreams now validate there is a current entry before + reading or writing entry data. + + + ArjArchiveInputStream#canReadEntryData tested the current + entry of the stream rather than its argument. + + + ChangeSet#delete and deleteDir now properly deal with unnamed + entries. + + + Added a few null checks to improve robustness. + + + TarArchiveInputStream failed to read archives with empty + gid/uid fields. + + + TarArchiveInputStream now again throws an exception when it + encounters a truncated archive while reading from the last + entry. + + + Adapted TarArchiveInputStream#skip to the modified + IOUtils#skip method. + + + + + BZip2CompressorInputStream read fewer bytes than possible from + a truncated stream. + + + SevenZFile failed claiming the dictionary was too large when + archives used LZMA compression for headers and content and + certain non-default dictionary sizes. + + + CompressorStreamFactory.createCompressorInputStream with + explicit compression did not honor decompressConcatenated + + + GzipCompressorInputStream now provides access to the same + metadata that can be provided via GzipParameters when writing + a gzip stream. + + + TarArchiveInputStream will now read archives created by tar + implementations that encode big numbers by not adding a + trailing NUL. + + + ZipArchiveInputStream would return NUL bytes for the first 512 + bytes of a STORED entry if it was the very first entry of the + archive. + + + When writing PAX/POSIX headers for TAR entries with + backslashes or certain non-ASCII characters in their name + TarArchiveOutputStream could fail. + + + ArchiveStreamFactory now throws a StreamingNotSupported - a + new subclass of ArchiveException - if it is asked to read from + or write to a stream and Commons Compress doesn't support + streaming for the format. This currently only applies to the + 7z format. + + + SevenZOutputFile now supports chaining multiple + compression/encryption/filter methods and passing options to + the methods. + + + The (compression) method(s) can now be specified per entry in + SevenZOutputFile. + + + SevenZArchiveEntry "knows" which method(s) have been used to + write it to the archive. + + + The 7z package now supports the delta filter as method. + + + The 7z package now supports BCJ filters for several platforms. + You will need a version >= 1.5 of XZ for Java to read archives + using BCJ, though. + + + + + SevenZOutputFile#closeArchiveEntry throws an exception when + using LZMA2 compression on Java8. + + + Read-Only support for Snappy compression. + + + 7z reading of big 64bit values could be wrong. + + + Read-Only support for .Z compressed files. + + + ZipFile and ZipArchiveInputStream now support reading entries compressed using the + SHRINKING method. + + + TarArchiveInputStream could fail to read an archive completely. + + + The time-setters in X5455_ExtendedTimestamp now set the + corresponding flags explicitly - i.e. they set the bit if the + valus is not-null and reset it otherwise. This may cause + incompatibilities if you use setFlags to unset a bit and later + set the time to a non-null value - the flag will now be set. + + + GzipCompressorOutputStream now supports setting the compression level and the header metadata + (filename, comment, modification time, operating system and extra flags) + + + ZipFile and ZipArchiveInputStream now support reading entries compressed using the IMPLODE method. + + + SevenZOutputFile would create invalid archives if more than + six empty files or directories were included. + + + ZipFile and the 7z file classes now implement Closeable and + can be used in try-with-resources constructs. + + + + + TarBuffer.tryToConsumeSecondEOFRecord could throw a + NullPointerException + + + Added support for 7z archives. Most compression algorithms + can be read and written, LZMA and encryption are only + supported when reading. + + + Added read-only support for ARJ archives that don't use + compression. + + + Parsing of zip64 extra fields has become more lenient in order + to be able to read archives created by DotNetZip and maybe + other archivers as well. + + + TAR will now properly read the names of symbolic links with + long names that use the GNU variant to specify the long file + name. + + + ZipFile#getInputStream could return null if the archive + contained duplicate entries. + The class now also provides two new methods to obtain all + entries of a given name rather than just the first one. + + + Readabilty patch to TarArchiveInputStream. + + + Performance improvements to TarArchiveInputStream, in + particular to the skip method. + + + CpioArchiveInputStream failed to read archives created by + Redline RPM. + + + TarArchiveOutputStream now properly handles link names that + are too long to fit into a traditional TAR header. + + + DumpArchiveInputStream now supports an encoding parameter that + can be used to specify the encoding of file names. + + + The CPIO streams now support an encoding parameter that can be + used to specify the encoding of file names. + + + Read-only support for LZMA standalone compression has been added. + + + The auto-detecting create*InputStream methods of Archive and + CompressorStreamFactory could fail to detect the format of + blocking input streams. + + + ZipEncodingHelper.isUTF8(String) does not check all UTF-8 aliases. + + + + + Typo in CompressorStreamFactory Javadoc + + + Improved exception message if a ZIP archive cannot be read + because of an unsupported compression method. + + + ArchiveStreamFactory has a setting for file name encoding that + sets up encoding for ZIP and TAR streams. + + + ArchiveStreamFactory's tar stream detection created false + positives for AIFF files. + + + TarArchiveEntry now has a method to verify its checksum. + + + XZ for Java didn't provide an OSGi bundle. Compress' + dependency on it has now been marked optional so Compress + itself can still be used in an OSGi context. + + + When specifying the encoding explicitly TarArchiveOutputStream + would write unreadable names in GNU mode or even cause errors + in POSIX mode for file names longer than 66 characters. + + + Writing TAR PAX headers failed if the generated entry name + ended with a "/". + + + ZipArchiveInputStream sometimes failed to provide input to the + Inflater when it needed it, leading to reads returning 0. + + + Split/spanned ZIP archives are now properly detected by + ArchiveStreamFactory but will cause an + UnsupportedZipFeatureException when read. + + + ZipArchiveInputStream now reads archives that start with a + "PK00" signature. Archives with this signatures are created + when the archiver was willing to split the archive but in the + end only needed a single segment - so didn't split anything. + + + TarArchiveEntry has a new constructor that allows setting + linkFlag and preserveLeadingSlashes at the same time. + + + ChangeSetPerformer has a new perform overload that uses a + ZipFile instance as input. + + + TarArchiveInputStream ignored the encoding for GNU long name + entries. + + + Garbage collection pressure has been reduced by reusing + temporary byte arrays in classes. + + + Can now handle ZIP extra field 0x5455 - Extended Timestamp. + + + handle ZIP extra field 0x7875 - Info Zip New Unix Extra Field. + + + ZipShort, ZipLong, ZipEightByteInteger should implement Serializable + + + better support for Unix symlinks in ZipFile entries + + + ZipFile's initialization has been improved for non-Zip64 + archives. + + + TarArchiveInputStream could leave the second EOF record + inside the stream it had just finished reading. + + + DumpArchiveInputStream no longer implicitly closes the + original input stream when it reaches the end of the + archive. + + + ZipArchiveInputStream now consumes the remainder of the + archive when getNextZipEntry returns null. + + + Unit tests could fail if the source tree was checked out to + a directory tree containign spaces. + + + Updated XZ for Java dependency to 1.2 as this version + provides proper OSGi manifest attributes. + + + Fixed a potential ArrayIndexOutOfBoundsException when + reading STORED entries from ZipArchiveInputStream. + + + CompressorStreamFactory can now be used without XZ for Java + being available. + + + CompressorStreamFactory has an option to create + decompressing streams that decompress the full input for + formats that support multiple concatenated streams. + + + + + Ported libbzip2's fallback sort algorithm to + BZip2CompressorOutputStream to speed up compression in certain + edge cases. + Using specially crafted inputs this can be used as a denial + of service attack. See the security reports page for details. + + + + + The tar package now allows the encoding of file names to be + specified and can optionally use PAX extension headers to + write non-ASCII file names. + The stream classes now write (or expect to read) archives that + use the platform's native encoding for file names. Apache + Commons Compress 1.3 used to strip everything but the lower + eight bits of each character which effectively only worked for + ASCII and ISO-8859-1 file names. + This new default behavior is a breaking change. + + + TarArchiveInputStream failed to parse PAX headers that + contained non-ASCII characters. + + + The tar package can now write archives that use star/GNU/BSD + extensions or use the POSIX/PAX variant to store numeric + values that don't fit into the traditional header fields. + + + Added a workaround for a Bug some tar implementations that add + a NUL byte as first byte in numeric header fields. + + + Added a workaround for a Bug in WinZIP which uses backslashes + as path separators in Unicode Extra Fields. + + + ArrayOutOfBounds while decompressing bz2. Added test case - code already seems to have been fixed. + + + TarArchiveInputStream throws IllegalArgumentException instead of IOException + + + TarUtils.formatLongOctalOrBinaryBytes() assumes the field will be 12 bytes long + + + GNU Tar sometimes uses binary encoding for UID and GID + + + ArchiveStreamFactory.createArchiveInputStream would claim + short text files were TAR archives. + + + Support for the XZ format has been added. + + + BZip2CompressorInputStream now optionally supports reading of + concatenated .bz2 files. + + + GZipCompressorInputStream now optionally supports reading of + concatenated .gz files. + + + ZipFile didn't work properly for archives using unicode extra + fields rather than UTF-8 filenames and the EFS-Flag. + + + The tar package can now read archives that use star/GNU/BSD + extensions for files that are longer than 8 GByte as well as + archives that use the POSIX/PAX variant. + + + The tar package can now write archives that use star/GNU/BSD + extensions for files that are longer than 8 GByte as well as + archives that use the POSIX/PAX variant. + + + The tar package can now use the POSIX/PAX variant for writing + entries with names longer than 100 characters. + + + For corrupt archives ZipFile would throw a RuntimeException in + some cases and an IOException in others. It will now + consistently throw an IOException. + + + + + Support for the Pack200 format has been added. + + + Read-only support for the format used by the Unix dump(8) tool + has been added. + + + The ZIP package now supports Zip64 extensions. + + + The AR package now supports the BSD dialect of storing file + names longer than 16 chars (both reading and writing). + + + BZip2CompressorInputStream's getBytesRead method always + returned 0. + + + ZipArchiveInputStream and ZipArchiveOutputStream could leak + resources on some JDKs. + + + TarArchiveOutputStream's getBytesWritten method didn't count + correctly. + + + + + ZipArchiveInputStream could fail with a "Truncated ZIP" error + message for entries between 2 GByte and 4 GByte in size. + + + TarArchiveInputStream now detects sparse entries using the + oldgnu format and properly reports it cannot extract their + contents. + + + ZipArchiveEntry has a new method getRawName that provides the + original bytes that made up the name. This may allow user + code to detect the encoding. + + + The Javadoc for ZipArchiveInputStream#skip now matches the + implementation, the code has been made more defensive. + + + ArArchiveInputStream fails if entries contain only blanks for + userId or groupId. + + + ZipFile may leak resources on some JDKs. + + + ZipFile now implements finalize which closes the underlying + file. + + + Certain tar files not recognised by ArchiveStreamFactory. + + + BZip2CompressorInputStream throws IOException if underlying stream returns available() == 0. + Removed the check. + + + Calling close() on inputStream returned by CompressorStreamFactory.createCompressorInputStream() + does not close the underlying input stream. + + + TarArchiveEntry provides access to the flags that determine + whether it is an archived symbolic link, pipe or other + "uncommon" file system object. + + + TarArchiveOutputStream#finish now writes all buffered data to the stream + + + + + Move acknowledgements from NOTICE to README + + + TarArchiveEntry.parseTarHeader() includes the trailing space/NUL when parsing the octal size + + + Command-line interface to list archive contents. + Usage: java -jar commons-compress-n.m.jar archive-name [zip|tar|etc] + + + TarUtils.parseName does not properly handle characters outside the range 0-127 + + + ArArchiveInputStream does not handle GNU extended filename records (//) + + + Tar implementation does not support Pax headers + Added support for reading pax headers. + Note: does not support global pax headers + + + ArchiveStreamFactory does not recognise tar files created by Ant + + + Support "ustar" prefix field, which is used when file paths are longer + than 100 characters. + + + Document that the name of an ZipArchiveEntry determines whether + an entry is considered a directory or not. + If you don't use the constructor with the File argument the entry's + name must end in a "/" in order for the entry to be known as a directory. + + + ZipArchiveInputStream can optionally extract data that used + the STORED compression method and a data descriptor. + Doing so in a stream is not safe in general, so you have to + explicitly enable the feature. By default the stream will + throw an exception if it encounters such an entry. + + + ZipArchiveInputStream will throw an exception if it detects an + entry that uses a data descriptor for a STORED entry since it + cannot reliably find the end of data for this "compression" + method. + + + ZipArchiveInputStream should now properly read archives that + use data descriptors but without the "unofficial" signature. + + + The ZIP classes will throw specialized exceptions if any + attempt is made to read or write data that uses ZIP features + not supported (yet). + + + ZipFile#getEntries returns entries in a predictable order - + the order they appear inside the central directory. + A new method getEntriesInPhysicalOrder returns entries in + order of the entry data, i.e. the order ZipArchiveInputStream + would see. + + + The Archive*Stream and ZipFile classes now have + can(Read|Write)EntryData methods that can be used to check + whether a given entry's data can be read/written. + The method currently returns false for ZIP archives if an + entry uses an unsupported compression method or encryption. + + + The ZIP classes now detect encrypted entries. + + + Move DOS/Java time conversions into Zip utility class. + + + ZipArchiveInputStream failed to update the number of bytes + read properly. + + + ArchiveInputStream has a new method getBytesRead that should + be preferred over getCount since the later may truncate the + number of bytes read for big archives. + + + The cpio archives created by CpioArchiveOutputStream couldn't + be read by many existing native implementations because the + archives contained multiple entries with the same inode/device + combinations and weren't padded to a blocksize of 512 bytes. + + + ZipArchiveEntry, ZipFile and ZipArchiveInputStream are now + more lenient when parsing extra fields. + + + ZipArchiveInputStream does not show location in file where a problem occurred. + + + cpio is terribly slow. + Documented that buffered streams are needed for performance + + + Added autodetection of compression format to + CompressorStreamFactory. + + + Improved exception message if the extra field data in ZIP + archives cannot be parsed. + + + Tar format unspecified - current support documented. + + + Improve ExceptionMessages in ArchiveStreamFactory + + + ZipArchiveEntry's equals method was broken for entries created + with the String-arg constructor. This lead to broken ZIP + archives if two different entries had the same hash code. + + + ZipArchiveInputStream could repeatedly return 0 on read() when + the archive was truncated. + + + Tar archive entries holding the file name for names longer + than 100 characters in GNU longfile mode didn't properly + specify they'd be using the "oldgnu" extension. + + + A new constructor of TarArchiveEntry can create entries with + names that start with slashes - the default is to strip + leading slashes in order to create relative path names. + + + Delegate all read and write methods in GZip stream in order to + speed up operations. + + + ArchiveEntry now has a getLastModifiedDate method. + + + The ar and cpio streams now properly read and write last + modified times. + + + TarOutputStream can leave garbage at the end of the archive + + + Add a BZip2Utils class modelled after GZipUtils + + + + + Initial release + + + Updating the pom.xml for preparing a move to commons-proper + + + +