Datasets:

Kitxuuu
/

AIXCC-Java-Challenge

ArXiv:

Kitxuuu commited on Sep 12

Commit

296a4e2

verified ·

1 Parent(s): cf36d98

Add files using upload-large-folder tool

Browse files

Files changed (20) hide show

local-test-commons-compress-delta-03/afc-commons-compress/src/site/resources/download_compress.cgi +20 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/resources/images/compress-logo-white.xcf +0 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/resources/profile.jacoco +16 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/conventions.xml +71 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/download_compress.xml +158 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/examples.xml +1295 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/index.xml +122 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/issue-tracking.xml +104 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/limitations.xml +259 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/mail-lists.xml +215 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/pack200.xml +91 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/security.xml +301 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/tar.xml +236 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/zip.xml +645 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-379.jar +0 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-382 +0 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-386 +1 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/bla-multi.7z.001 +0 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/test1.xml +4 -0
local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/test3.xml +10 -0

local-test-commons-compress-delta-03/afc-commons-compress/src/site/resources/download_compress.cgi ADDED Viewed

	@@ -0,0 +1,20 @@

+#!/bin/sh
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Just call the standard mirrors.cgi script. It will use download.html
+# as the input template.
+exec /www/www.apache.org/dyn/mirrors/mirrors.cgi $*

local-test-commons-compress-delta-03/afc-commons-compress/src/site/resources/images/compress-logo-white.xcf ADDED Viewed

Binary file (25.8 kB). View file

local-test-commons-compress-delta-03/afc-commons-compress/src/site/resources/profile.jacoco ADDED Viewed

	@@ -0,0 +1,16 @@

+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//  https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/conventions.xml ADDED Viewed

	@@ -0,0 +1,71 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+   <properties>
+      <title>Conventions</title>
+   </properties>
+   <body>
+      <section name="Code Style">
+            <p>
+            The developers of this component decided to follow the recommended standards
+            but not to include Checkstyle (or similar tools) into Commons Compress.
+            </p>
+      </section>
+      <section name="Multithreading">
+            <p>
+            Commons Compress does not aim to be threadsafe at the moment. But the developers
+            agreed to document multithreading behavior in the javadocs.
+            </p>
+            <p>
+            We use some of the annotations from
+            <a href="http://jcip.net/annotations/doc/net/jcip/annotations/package-summary.html">JCIP</a>
+            as Javadoc tags. The used tags are:
+            </p>
+            <ul>
+                <li>@GuardedBy (field or method)</li>
+                <li>@Immutable (class)</li>
+                <li>@NotThreadSafe (class)</li>
+                <li>@ThreadSafe (class)</li>
+            </ul>
+            <p>
+            For example:
+            <source>
+/**
+ * Utility class that represents a four byte integer with conversion
+ * rules for the big endian byte order of ZIP files.
+ *
+ * @Immutable
+ */
+public final class ZipLong implements Cloneable {
+            </source>
+            and:
+            <source>
+private final char [] highChars;
+//@GuardedBy("this")
+private Simple8BitZipEncoding encoding;
+            </source>
+            </p>
+      </section>
+   </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/download_compress.xml ADDED Viewed

	@@ -0,0 +1,158 @@

+<?xml version="1.0"?>
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+     https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+<!--
+ +======================================================================+
+ |****                                                              ****|
+ |****      THIS FILE IS GENERATED BY THE COMMONS BUILD PLUGIN      ****|
+ |****                    DO NOT EDIT DIRECTLY                      ****|
+ |****                                                              ****|
+ +======================================================================+
+ | TEMPLATE FILE: download-page-template.xml                            |
+ | commons-build-plugin/trunk/src/main/resources/commons-xdoc-templates |
+ +======================================================================+
+ |                                                                      |
+ | 1) Re-generate using: mvn commons-build:download-page                |
+ |                                                                      |
+ | 2) Set the following properties in the component's pom:              |
+ |    - commons.componentid     (required, alphabetic, lower case)      |
+ |    - commons.release.version (required)                              |
+ |    - commons.release.name    (required)                              |
+ |    - commons.binary.suffix   (optional)                              |
+ |      (defaults to "-bin", set to "" for pre-maven2 releases)         |
+ |    - commons.release.desc    (optional)                              |
+ |    - commons.release.subdir  (optional)                              |
+ |    - commons.release.hash    (optional, lowercase, default sha512)   |
+ |                                                                      |
+ |    - commons.release.[234].version       (conditional)               |
+ |    - commons.release.[234].name          (conditional)               |
+ |    - commons.release.[234].binary.suffix (optional)                  |
+ |    - commons.release.[234].desc          (optional)                  |
+ |    - commons.release.[234].subdir        (optional)                  |
+ |    - commons.release.[234].hash       (optional, lowercase, [sha512])|
+ |                                                                      |
+ | 3) Example Properties                                                |
+ |    (commons.release.name inherited by parent:                        |
+ |     ${project.artifactId}-${commons.release.version}                 |
+ |                                                                      |
+ |  <properties>                                                        |
+ |    <commons.componentid>math</commons.componentid>                   |
+ |    <commons.release.version>1.2</commons.release.version>            |
+ |  </properties>                                                       |
+ |                                                                      |
+ +======================================================================+
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Download Apache Commons Compress</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="Download Apache Commons Compress">
+    <subsection name="Using a Mirror">
+      <p>
+        We recommend you use a mirror to download our release
+        builds, but you <strong>must</strong> <a href="https://www.apache.org/info/verification.html">verify the integrity</a> of
+        the downloaded files using signatures downloaded from our main
+        distribution directories. Recent releases (48 hours) may not yet
+        be available from all the mirrors.
+      </p>
+      <p>
+        You are currently using <b>[preferred]</b>.  If you
+        encounter a problem with this mirror, please select another
+        mirror.  If all mirrors are failing, there are <i>backup</i>
+        mirrors (at the end of the mirrors list) that should be
+        available.
+        <br></br>
+        [if-any logo]<a href="[link]"><img align="right" src="[logo]" border="0" alt="Logo"></img></a>[end]
+      </p>
+      <form action="[location]" method="get" id="SelectMirror">
+        <p>
+          Other mirrors:
+          <select name="Preferred">
+          [if-any http]
+            [for http]<option value="[http]">[http]</option>[end]
+          [end]
+          [if-any ftp]
+            [for ftp]<option value="[ftp]">[ftp]</option>[end]
+          [end]
+          [if-any backup]
+            [for backup]<option value="[backup]">[backup] (backup)</option>[end]
+          [end]
+          </select>
+          <input type="submit" value="Change"></input>
+        </p>
+      </form>
+      <p>
+        It is essential that you
+        <a href="https://www.apache.org/info/verification.html">verify the integrity</a>
+        of downloaded files, preferably using the <code>PGP</code> signature (<code>*.asc</code> files);
+        failing that using the <code>SHA512</code> hash (<code>*.sha512</code> checksum files).
+      </p>
+      <p>
+        The <a href="https://downloads.apache.org/commons/KEYS">KEYS</a>
+        file contains the public PGP keys used by Apache Commons developers
+        to sign releases.
+      </p>
+    </subsection>
+    </section>
+    <section name="Apache Commons Compress 1.28.0 ">
+      <subsection name="Binaries">
+        <table>
+          <tr>
+              <td><a href="[preferred]/commons/compress/binaries/commons-compress-1.28.0-bin.tar.gz">commons-compress-1.28.0-bin.tar.gz</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/binaries/commons-compress-1.28.0-bin.tar.gz.sha512">sha512</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/binaries/commons-compress-1.28.0-bin.tar.gz.asc">pgp</a></td>
+          </tr>
+          <tr>
+              <td><a href="[preferred]/commons/compress/binaries/commons-compress-1.28.0-bin.zip">commons-compress-1.28.0-bin.zip</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/binaries/commons-compress-1.28.0-bin.zip.sha512">sha512</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/binaries/commons-compress-1.28.0-bin.zip.asc">pgp</a></td>
+          </tr>
+        </table>
+      </subsection>
+      <subsection name="Source">
+        <table>
+          <tr>
+              <td><a href="[preferred]/commons/compress/source/commons-compress-1.28.0-src.tar.gz">commons-compress-1.28.0-src.tar.gz</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/source/commons-compress-1.28.0-src.tar.gz.sha512">sha512</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/source/commons-compress-1.28.0-src.tar.gz.asc">pgp</a></td>
+          </tr>
+          <tr>
+              <td><a href="[preferred]/commons/compress/source/commons-compress-1.28.0-src.zip">commons-compress-1.28.0-src.zip</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/source/commons-compress-1.28.0-src.zip.sha512">sha512</a></td>
+              <td><a href="https://downloads.apache.org/commons/compress/source/commons-compress-1.28.0-src.zip.asc">pgp</a></td>
+          </tr>
+        </table>
+      </subsection>
+    </section>
+    <section name="Archives">
+        <p>
+          Older releases can be obtained from the archives.
+        </p>
+        <ul>
+          <li class="download"><a href="[preferred]/commons/compress/">browse download area</a></li>
+          <li><a href="https://archive.apache.org/dist/commons/compress/">archives...</a></li>
+        </ul>
+    </section>
+  </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/examples.xml ADDED Viewed

	@@ -0,0 +1,1295 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Commons Compress User Guide</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="General Notes">
+      <subsection name="Archivers and Compressors">
+        <p>Commons Compress calls all formats that compress a single
+        stream of data compressor formats while all formats that
+        collect multiple entries inside a single (potentially
+        compressed) archive are archiver formats.</p>
+        <p>The compressor formats supported are gzip, bzip2, XZ, LZMA,
+        Pack200, DEFLATE, Brotli, DEFLATE64, ZStandard and Z, the archiver formats are 7z, ar, arj,
+        cpio, dump, tar and zip.  Pack200 is a special case as it can
+        only compress JAR files.</p>
+        <p>We currently only provide read support for arj,
+        dump, Brotli, DEFLATE64 and Z.  arj can only read uncompressed archives, 7z can read
+        archives with many compression and encryption algorithms
+        supported by 7z but doesn't support encryption when writing
+        archives.</p>
+      </subsection>
+      <subsection name="Buffering">
+        <p>The stream classes all wrap around streams provided by the
+          calling code and they work on them directly without any
+          additional buffering.  On the other hand most of them will
+          benefit from buffering so it is highly recommended that
+          users wrap their stream
+          in <code>Buffered<em>(In|Out)</em>putStream</code>s before
+          using the Commons Compress API.</p>
+      </subsection>
+      <subsection name="Factories">
+        <p>Compress provides factory methods to create input/output
+          streams based on the names of the compressor or archiver
+          format as well as factory methods that try to guess the
+          format of an input stream.</p>
+        <p>To create a compressor writing to a given output by using
+          the algorithm name:</p>
+        <source><![CDATA[
+CompressorOutputStream gzippedOut = new CompressorStreamFactory()
+    .createCompressorOutputStream(CompressorStreamFactory.GZIP, myOutputStream);
+]]></source>
+        <p>Make the factory guess the input format for a given
+        archiver stream:</p>
+        <source><![CDATA[
+ArchiveInputStream input = new ArchiveStreamFactory()
+    .createArchiveInputStream(originalInput);
+]]></source>
+        <p>Make the factory guess the input format for a given
+        compressor stream:</p>
+        <source><![CDATA[
+CompressorInputStream input = new CompressorStreamFactory()
+    .createCompressorInputStream(originalInput);
+]]></source>
+        <p>Note that there is no way to detect the LZMA or Brotli formats so only
+        the two-arg version of
+        <code>createCompressorInputStream</code> can be used.  Prior
+        to Compress 1.9 the .Z format hasn't been auto-detected
+        either.</p>
+      </subsection>
+      <subsection name="Restricting Memory Usage">
+        <p>Starting with Compress 1.14
+        <code>CompressorStreamFactory</code> has an optional
+        constructor argument that can be used to set an upper limit of
+        memory that may be used while decompressing or compressing a
+        stream. As of 1.14 this setting only affects decompressing Z,
+        XZ and LZMA compressed streams.</p>
+        <p>Since Compress 1.19 <code>SevenZFile</code> also has an
+        optional constructor to pass an upper memory limit which is supported
+        in LZMA compressed streams. Since Compress 1.21 this setting
+        also is taken into account when reading the metadata of an archive.</p>
+        <p>For the Snappy and LZ4 formats the amount of memory used
+        during compression is directly proportional to the window
+        size.</p>
+      </subsection>
+      <subsection name="Statistics">
+        <p>Starting with Compress 1.17 most of the
+        <code>CompressorInputStream</code> implementations as well as
+        <code>ZipArchiveInputStream</code> and all streams returned by
+        <code>ZipFile.getInputStream</code> implement the
+        <code>InputStreamStatistics</code>
+        interface. <code>SevenZFile</code> provides statistics for the
+        current entry via the
+        <code>getStatisticsForCurrentEntry</code> method. This
+        interface can be used to track progress while extracting a
+        stream or to detect potential <a
+        href="https://en.wikipedia.org/wiki/Zip_bomb">zip bombs</a>
+        when the compression ratio becomes suspiciously large.</p>
+      </subsection>
+    </section>
+    <section name="Archivers">
+      <subsection name="Unsupported Features">
+        <p>Many of the supported formats have developed different
+        dialects and extensions and some formats allow for features
+        (not yet) supported by Commons Compress.</p>
+        <p>The <code>ArchiveInputStream</code> class provides a method
+        <code>canReadEntryData</code> that will return false if
+        Commons Compress can detect that an archive uses a feature
+        that is not supported by the current implementation.  If it
+        returns false you should not try to read the entry but skip
+        over it.</p>
+      </subsection>
+      <subsection name="Entry Names">
+        <p>All archive formats provide meta data about the individual
+        archive entries via instances of <code>ArchiveEntry</code> (or
+        rather subclasses of it). When reading from an archive the
+        information provided the <code>getName</code> method is the
+        raw name as stored inside of the archive. There is no
+        guarantee the name represents a relative file name or even a
+        valid file name on your target operating system at all. You
+        should double check the outcome when you try to create file
+        names from entry names.</p>
+      </subsection>
+      <subsection name="Common Extraction Logic">
+        <p>Apart from 7z all formats provide a subclass of
+        <code>ArchiveInputStream</code> that can be used to create an
+        archive. For 7z <code>SevenZFile</code> provides a similar API
+        that does not represent a stream as our implementation
+        requires random access to the input and cannot be used for
+        general streams. The ZIP implementation can benefit a lot from
+        random access as well, see the <a
+        href="zip.html#ZipArchiveInputStream_vs_ZipFile">zip
+        page</a> for details.</p>
+        <p>Assuming you want to extract an archive to a target
+        directory you'd call <code>getNextEntry</code>, verify the
+        entry can be read, construct a sane file name from the entry's
+        name, create a <code>File</code> and write all contents to
+        it - here <code>IOUtils.copy</code> may come handy. You do so
+        for every entry until <code>getNextEntry</code> returns
+        <code>null</code>.</p>
+        <p>A skeleton might look like:</p>
+        <source><![CDATA[
+File targetDir = ...
+try (ArchiveInputStream i = ... create the stream for your format, use buffering...) {
+    ArchiveEntry entry = null;
+    while ((entry = i.getNextEntry()) != null) {
+        if (!i.canReadEntryData(entry)) {
+            // log something?
+            continue;
+        }
+        String name = fileName(targetDir, entry);
+        File f = new File(name);
+        if (entry.isDirectory()) {
+            if (!f.isDirectory() && !f.mkdirs()) {
+                throw new IOException("failed to create directory " + f);
+            }
+        } else {
+            File parent = f.getParentFile();
+            if (!parent.isDirectory() && !parent.mkdirs()) {
+                throw new IOException("failed to create directory " + parent);
+            }
+            try (OutputStream o = Files.newOutputStream(f.toPath())) {
+                IOUtils.copy(i, o);
+            }
+        }
+    }
+}
+]]></source>
+        <p>where the hypothetical <code>fileName</code> method is
+        written by you and provides the absolute name for the file
+        that is going to be written on disk. Here you should perform
+        checks that ensure the resulting file name actually is a valid
+        file name on your operating system or belongs to a file inside
+        of <code>targetDir</code> when using the entry's name as
+        input.</p>
+        <p>If you want to combine an archive format with a compression
+        format - like when reading a "tar.gz" file - you wrap the
+        <code>ArchiveInputStream</code> around
+        <code>CompressorInputStream</code> for example:</p>
+        <source><![CDATA[
+try (InputStream fi = Files.newInputStream(Paths.get("my.tar.gz"));
+     InputStream bi = new BufferedInputStream(fi);
+     InputStream gzi = new GzipCompressorInputStream(bi);
+     ArchiveInputStream o = new TarArchiveInputStream(gzi)) {
+}
+]]></source>
+      </subsection>
+      <subsection name="Common Archival Logic">
+        <p>Apart from 7z all formats that support writing provide a
+        subclass of <code>ArchiveOutputStream</code> that can be used
+        to create an archive. For 7z <code>SevenZOutputFile</code>
+        provides a similar API that does not represent a stream as our
+        implementation requires random access to the output and cannot
+        be used for general streams. The
+        <code>ZipArchiveOutputStream</code> class will benefit from
+        random access as well but can be used for non-seekable streams
+        - but not all features will be available and the archive size
+        might be slightly bigger, see <a
+        href="zip.html#ZipArchiveOutputStream">the zip page</a> for
+        details.</p>
+        <p>Assuming you want to add a collection of files to an
+        archive, you can first use <code>createArchiveEntry</code> for
+        each file. In general this will set a few flags (usually the
+        last modified time, the size and the information whether this
+        is a file or directory) based on the <code>File</code> or <code>Path</code>
+        instance. Alternatively you can create the
+        <code>ArchiveEntry</code> subclass corresponding to your
+        format directly. Often you may want to set additional flags
+        like file permissions or owner information before adding the
+        entry to the archive.</p>
+        <p>Next you use <code>putArchiveEntry</code> in order to add
+        the entry and then start using <code>write</code> to add the
+        content of the entry - here <code>IOUtils.copy</code> may
+        come handy. Finally you invoke
+        <code>closeArchiveEntry</code> once you've written all content
+        and before you add the next entry.</p>
+        <p>Once all entries have been added you'd invoke
+        <code>finish</code> and finally <code>close</code> the
+        stream.</p>
+        <p>A skeleton might look like:</p>
+        <source><![CDATA[
+Collection<File> filesToArchive = ...
+try (ArchiveOutputStream o = ... create the stream for your format ...) {
+    for (File f : filesToArchive) {
+        // maybe skip directories for formats like AR that don't store directories
+        ArchiveEntry entry = o.createArchiveEntry(f, entryName(f));
+        // potentially add more flags to entry
+        o.putArchiveEntry(entry);
+        if (f.isFile()) {
+            try (InputStream i = Files.newInputStream(f.toPath())) {
+                IOUtils.copy(i, o);
+            }
+        }
+        o.closeArchiveEntry();
+    }
+    o.finish();
+}
+]]></source>
+        <p>where the hypothetical <code>entryName</code> method is
+        written by you and provides the name for the entry as it is
+        going to be written to the archive.</p>
+        <p>If you want to combine an archive format with a compression
+        format - like when creating a "tar.gz" file - you wrap the
+        <code>ArchiveOutputStream</code> around a
+        <code>CompressorOutputStream</code> for example:</p>
+        <source><![CDATA[
+try (OutputStream fo = Files.newOutputStream(Paths.get("my.tar.gz"));
+     OutputStream gzo = new GzipCompressorOutputStream(fo);
+     ArchiveOutputStream o = new TarArchiveOutputStream(gzo)) {
+}
+]]></source>
+      </subsection>
+      <subsection name="7z">
+        <p>Note that Commons Compress currently only supports a subset
+        of compression and encryption algorithms used for 7z archives.
+        For writing only uncompressed entries, LZMA, LZMA2, BZIP2 and
+        Deflate are supported - in addition to those reading supports
+        AES-256/SHA-256 and DEFLATE64.</p>
+        <p>Writing multipart archives is not supported at
+        all. Multipart archives can be read by concatenating the parts
+        for example by using
+        <code>MultiReadOnlySeekableByteChannel</code>.</p>
+        <p>7z archives can use multiple compression and encryption
+        methods as well as filters combined as a pipeline of methods
+        for its entries.  Prior to Compress 1.8 you could only specify
+        a single method when creating archives - reading archives
+        using more than one method has been possible before.  Starting
+        with Compress 1.8 it is possible to configure the full
+        pipeline using the <code>setContentMethods</code> method of
+        <code>SevenZOutputFile</code>.  Methods are specified in the
+        order they appear inside the pipeline when creating the
+        archive, you can also specify certain parameters for some of
+        the methods - see the Javadocs of
+        <code>SevenZMethodConfiguration</code> for details.</p>
+        <p>When reading entries from an archive the
+        <code>getContentMethods</code> method of
+        <code>SevenZArchiveEntry</code> will properly represent the
+        compression/encryption/filter methods but may fail to
+        determine the configuration options used.  As of Compress 1.8
+        only the dictionary size used for LZMA2 can be read.</p>
+        <p>Currently solid compression - compressing multiple files
+        as a single block to benefit from patterns repeating across
+        files - is only supported when reading archives.  This also
+        means compression ratio will likely be worse when using
+        Commons Compress compared to the native 7z executable.</p>
+        <p>Reading or writing requires a
+        <code>SeekableByteChannel</code> that will be obtained
+        transparently when reading from or writing to a file. The
+        class
+        <code>org.apache.commons.compress.utils.SeekableInMemoryByteChannel</code>
+        allows you to read from or write to an in-memory archive.</p>
+        <p>Some 7z archives don't contain any names for the archive
+        entries. The native 7zip tools derive a default name from the
+        name of the archive itself for such entries. Starting with
+        Compress 1.19 <code>SevenZFile</code> has an option to mimic
+        this behavior, but by default unnamed archive entries will
+        return <code>null</code> from
+        <code>SevenZArchiveEntry#getName</code>.</p>
+        <p>Adding an entry to a 7z archive:</p>
+<source><![CDATA[
+SevenZOutputFile sevenZOutput = new SevenZOutputFile(file);
+SevenZArchiveEntry entry = sevenZOutput.createArchiveEntry(fileToArchive, name);
+sevenZOutput.putArchiveEntry(entry);
+sevenZOutput.write(contentOfEntry);
+sevenZOutput.closeArchiveEntry();
+]]></source>
+        <p>Uncompressing a given 7z archive (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+SevenZFile sevenZFile = new SevenZFile(new File("archive.7z"));
+SevenZArchiveEntry entry = sevenZFile.getNextEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    sevenZFile.read(content, offset, content.length - offset);
+}
+]]></source>
+          <p>Uncompressing a given in-memory 7z archive:</p>
+          <source><![CDATA[
+byte[] inputData; // 7z archive contents
+SeekableInMemoryByteChannel inMemoryByteChannel = new SeekableInMemoryByteChannel(inputData);
+SevenZFile sevenZFile = new SevenZFile(inMemoryByteChannel);
+SevenZArchiveEntry entry = sevenZFile.getNextEntry();
+sevenZFile.read();  // read current entry's data
+]]></source>
+          <h4><a name="Encrypted-7z-Archives"></a>Encrypted 7z Archives</h4>
+          <p>Currently Compress supports reading but not writing of
+          encrypted archives. When reading an encrypted archive a
+          password has to be provided to one of
+          <code>SevenZFile</code>'s constructors. If you try to read
+          an encrypted archive without specifying a password a
+          <code>PasswordRequiredException</code> (a subclass of
+          <code>IOException</code>) will be thrown.</p>
+          <p>When specifying the password as a <code>byte[]</code> one
+          common mistake is to use the wrong encoding when creating
+          the <code>byte[]</code> from a <code>String</code>. The
+          <code>SevenZFile</code> class expects the bytes to
+          correspond to the UTF16-LE encoding of the password. An
+          example of reading an encrypted archive is</p>
+<source><![CDATA[
+SevenZFile sevenZFile = new SevenZFile(new File("archive.7z"), "secret".getBytes(StandardCharsets.UTF_16LE));
+SevenZArchiveEntry entry = sevenZFile.getNextEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    sevenZFile.read(content, offset, content.length - offset);
+}
+]]></source>
+        <p>Starting with Compress 1.17 new constructors have been
+        added that accept the password as <code>char[]</code> rather
+        than a <code>byte[]</code>. We recommend you use these in
+        order to avoid the problem above.</p>
+<source><![CDATA[
+SevenZFile sevenZFile = new SevenZFile(new File("archive.7z"), "secret".toCharArray());
+SevenZArchiveEntry entry = sevenZFile.getNextEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    sevenZFile.read(content, offset, content.length - offset);
+}
+]]></source>
+        <h4><a name="Random-Access-to-7z-Archives"></a>Random-Access to 7z Archives</h4>
+        <p>Prior to Compress 1.20 7z archives could only be read
+        sequentially. The
+        <code>getInputStream(SevenZArchiveEntry)</code> method
+        introduced with Compress 1.20 now provides random access but
+        at least when the archive uses solid compression random access
+        will likely be significantly slower than sequential
+        access.</p>
+        <h4><a name="Recovering-from-Certain-Broken-7z-Archives"></a>Recovering from Certain Broken 7z Archives</h4>
+        <p><code>SevenZFile</code> tries
+        to recover archives that look as if they were part of a
+        multi-volume archive where the first volume has been removed
+        too early.</p>
+        <p>This option has to be enabled
+        explicitly in <code>SevenZFile.Builder</code>. The way recovery
+        works is by Compress scanning an archive from the end for
+        something that might look like valid 7z metadata and use that,
+        if it can successfully parse the block of data. When doing so
+        Compress may encounter blocks of metadata that look like the
+        metadata of very large archives which in turn may make
+        Compress allocate a lot of memory. Therefore we strongly
+        recommend you also set a memory limit inside the
+        <code>SevenZFile.Builder</code> if you enable recovery.</p>
+      </subsection>
+      <subsection name="ar">
+        <p>In addition to the information stored
+          in <code>ArchiveEntry</code> a <code>ArArchiveEntry</code>
+          stores information about the owner user and group as well as
+          Unix permissions.</p>
+        <p>Adding an entry to an ar archive:</p>
+<source><![CDATA[
+ArArchiveEntry entry = new ArArchiveEntry(name, size);
+arOutput.putArchiveEntry(entry);
+arOutput.write(contentOfEntry);
+arOutput.closeArchiveEntry();
+]]></source>
+        <p>Reading entries from an ar archive:</p>
+<source><![CDATA[
+ArArchiveEntry entry = (ArArchiveEntry) arInput.getNextEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    arInput.read(content, offset, content.length - offset);
+}
+]]></source>
+        <p>Traditionally the AR format doesn't allow file names longer
+          than 16 characters.  There are two variants that circumvent
+          this limitation in different ways, the GNU/SRV4 and the BSD
+          variant.  Commons Compress 1.0 to 1.2 can only read archives
+          using the GNU/SRV4 variant, support for the BSD variant has
+          been added in Commons Compress 1.3.  Commons Compress 1.3
+          also optionally supports writing archives with file names
+          longer than 16 characters using the BSD dialect, writing
+          the SVR4/GNU dialect is not supported.</p>
+        <table>
+          <thead>
+            <tr>
+              <th>Version of Apache Commons Compress</th>
+              <th>Support for Traditional AR Format</th>
+              <th>Support for GNU/SRV4 Dialect</th>
+              <th>Support for BSD Dialect</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>1.0 to 1.2</td>
+              <td>read/write</td>
+              <td>read</td>
+              <td>-</td>
+            </tr>
+            <tr>
+              <td>1.3 and later</td>
+              <td>read/write</td>
+              <td>read</td>
+              <td>read/write</td>
+            </tr>
+          </tbody>
+        </table>
+        <p>It is not possible to detect the end of an AR archive in a
+        reliable way so <code>ArArchiveInputStream</code> will read
+        until it reaches the end of the stream or fails to parse the
+        stream's content as AR entries.</p>
+      </subsection>
+      <subsection name="arj">
+        <p>Note that Commons Compress doesn't support compressed,
+        encrypted or multi-volume ARJ archives, yet.</p>
+        <p>Uncompressing a given arj archive (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+ArjArchiveEntry entry = arjInput.getNextEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    arjInput.read(content, offset, content.length - offset);
+}
+]]></source>
+      </subsection>
+      <subsection name="cpio">
+        <p>In addition to the information stored
+          in <code>ArchiveEntry</code> a <code>CpioArchiveEntry</code>
+          stores various attributes including information about the
+          original owner and permissions.</p>
+        <p>The cpio package supports the "new portable" as well as the
+          "old" format of CPIO archives in their binary, ASCII and
+          "with CRC" variants.</p>
+        <p>Adding an entry to a cpio archive:</p>
+<source><![CDATA[
+CpioArchiveEntry entry = new CpioArchiveEntry(name, size);
+cpioOutput.putArchiveEntry(entry);
+cpioOutput.write(contentOfEntry);
+cpioOutput.closeArchiveEntry();
+]]></source>
+        <p>Reading entries from an cpio archive:</p>
+<source><![CDATA[
+CpioArchiveEntry entry = cpioInput.getNextCPIOEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    cpioInput.read(content, offset, content.length - offset);
+}
+]]></source>
+        <p>Traditionally CPIO archives are written in blocks of 512
+        bytes - the block size is a configuration parameter of the
+        <code>Cpio*Stream</code>'s constructors.  Starting with version
+        1.5 <code>CpioArchiveInputStream</code> will consume the
+        padding written to fill the current block when the end of the
+        archive is reached.  Unfortunately many CPIO implementations
+        use larger block sizes so there may be more zero-byte padding
+        left inside the original input stream after the archive has
+        been consumed completely.</p>
+      </subsection>
+      <subsection name="jar">
+        <p>In general, JAR archives are ZIP files, so the JAR package
+          supports all options provided by the <a href="#zip">ZIP</a> package.</p>
+        <p>To be interoperable JAR archives should always be created
+          using the UTF-8 encoding for file names (which is the
+          default).</p>
+        <p>Archives created using <code>JarArchiveOutputStream</code>
+          will implicitly add a <code>JarMarker</code> extra field to
+          the very first archive entry of the archive which will make
+          Solaris recognize them as Java archives and allows them to
+          be used as executables.</p>
+        <p>Note that <code>ArchiveStreamFactory</code> doesn't
+          distinguish ZIP archives from JAR archives, so if you use
+          the one-argument <code>createArchiveInputStream</code>
+          method on a JAR archive, it will still return the more
+          generic <code>ZipArchiveInputStream</code>.</p>
+        <p>The <code>JarArchiveEntry</code> class contains fields for
+          certificates and attributes that are planned to be supported
+          in the future but are not supported as of Compress 1.0.</p>
+        <p>Adding an entry to a jar archive:</p>
+<source><![CDATA[
+JarArchiveEntry entry = new JarArchiveEntry(name, size);
+entry.setSize(size);
+jarOutput.putArchiveEntry(entry);
+jarOutput.write(contentOfEntry);
+jarOutput.closeArchiveEntry();
+]]></source>
+        <p>Reading entries from an jar archive:</p>
+<source><![CDATA[
+JarArchiveEntry entry = jarInput.getNextJarEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    jarInput.read(content, offset, content.length - offset);
+}
+]]></source>
+      </subsection>
+      <subsection name="dump">
+        <p>In addition to the information stored
+          in <code>ArchiveEntry</code> a <code>DumpArchiveEntry</code>
+          stores various attributes including information about the
+          original owner and permissions.</p>
+        <p>As of Commons Compress 1.3 only dump archives using the
+          new-fs format - this is the most common variant - are
+          supported.  Right now this library supports uncompressed and
+          ZLIB compressed archives and can not write archives at
+          all.</p>
+        <p>Reading entries from an dump archive:</p>
+<source><![CDATA[
+DumpArchiveEntry entry = dumpInput.getNextDumpEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    dumpInput.read(content, offset, content.length - offset);
+}
+]]></source>
+        <p>Prior to version 1.5 <code>DumpArchiveInputStream</code>
+        would close the original input once it had read the last
+        record.  Starting with version 1.5 it will not close the
+        stream implicitly.</p>
+      </subsection>
+      <subsection name="tar">
+        <p>The TAR package has a <a href="tar.html">dedicated
+            documentation page</a>.</p>
+        <p>Adding an entry to a tar archive:</p>
+<source><![CDATA[
+TarArchiveEntry entry = new TarArchiveEntry(name);
+entry.setSize(size);
+tarOutput.putArchiveEntry(entry);
+tarOutput.write(contentOfEntry);
+tarOutput.closeArchiveEntry();
+]]></source>
+        <p>Reading entries from an tar archive:</p>
+<source><![CDATA[
+TarArchiveEntry entry = tarInput.getNextTarEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    tarInput.read(content, offset, content.length - offset);
+}
+]]></source>
+      </subsection>
+      <subsection name="zip">
+        <p>The ZIP package has a <a href="zip.html">dedicated
+            documentation page</a>.</p>
+        <p>Adding an entry to a zip archive:</p>
+<source><![CDATA[
+ZipArchiveEntry entry = new ZipArchiveEntry(name);
+entry.setSize(size);
+zipOutput.putArchiveEntry(entry);
+zipOutput.write(contentOfEntry);
+zipOutput.closeArchiveEntry();
+]]></source>
+        <p><code>ZipArchiveOutputStream</code> can use some internal
+          optimizations exploiting <code>SeekableByteChannel</code> if it
+          knows it is writing to a seekable output rather than a non-seekable
+          stream.  If you are writing to a file, you should use the
+          constructor that accepts a <code>File</code> or
+          <code>SeekableByteChannel</code> argument rather
+          than the one using an <code>OutputStream</code> or the
+          factory method in <code>ArchiveStreamFactory</code>.</p>
+        <p>Reading entries from an zip archive:</p>
+<source><![CDATA[
+ZipArchiveEntry entry = zipInput.getNextZipEntry();
+byte[] content = new byte[entry.getSize()];
+LOOP UNTIL entry.getSize() HAS BEEN READ {
+    zipInput.read(content, offset, content.length - offset);
+}
+]]></source>
+        <p>Reading entries from an zip archive using the
+          recommended <code>ZipFile</code> class:</p>
+<source><![CDATA[
+ZipArchiveEntry entry = zipFile.getEntry(name);
+InputStream content = zipFile.getInputStream(entry);
+try {
+    READ UNTIL content IS EXHAUSTED
+} finally {
+    content.close();
+}
+]]></source>
+          <p>Reading entries from an in-memory zip archive using
+              <code>SeekableInMemoryByteChannel</code> and <code>ZipFile</code> class:</p>
+<source><![CDATA[
+byte[] inputData; // zip archive contents
+SeekableInMemoryByteChannel inMemoryByteChannel = new SeekableInMemoryByteChannel(inputData);
+ZipFile zipFile = new ZipFile(inMemoryByteChannel);
+ZipArchiveEntry archiveEntry = zipFile.getEntry("entryName");
+InputStream inputStream = zipFile.getInputStream(archiveEntry);
+inputStream.read() // read data from the input stream
+]]></source>
+          <p>Creating a zip file with multiple threads:</p>
+          <p>
+            A simple implementation to create a zip file might look like this:
+          </p>
+<source><![CDATA[
+public class ScatterSample {
+  ParallelScatterZipCreator scatterZipCreator = new ParallelScatterZipCreator();
+  ScatterZipOutputStream dirs = ScatterZipOutputStream.fileBased(File.createTempFile("scatter-dirs", "tmp"));
+  public ScatterSample() throws IOException {
+  }
+  public void addEntry(ZipArchiveEntry zipArchiveEntry, InputStreamSupplier streamSupplier) throws IOException {
+     if (zipArchiveEntry.isDirectory() && !zipArchiveEntry.isUnixSymlink())
+        dirs.addArchiveEntry(ZipArchiveEntryRequest.createZipArchiveEntryRequest(zipArchiveEntry, streamSupplier));
+     else
+        scatterZipCreator.addArchiveEntry( zipArchiveEntry, streamSupplier);
+  }
+  public void writeTo(ZipArchiveOutputStream zipArchiveOutputStream)
+  throws IOException, ExecutionException, InterruptedException {
+     dirs.writeTo(zipArchiveOutputStream);
+     dirs.close();
+     scatterZipCreator.writeTo(zipArchiveOutputStream);
+  }
+}
+]]></source>
+      </subsection>
+    </section>
+    <section name="Compressors">
+      <subsection name="Concatenated Streams">
+        <p>For the bzip2, gzip and XZ formats as well as the framed
+        lz4 format a single compressed file
+        may actually consist of several streams that will be
+        concatenated by the command line utilities when decompressing
+        them.  Starting with Commons Compress 1.4 the
+        <code>*CompressorInputStream</code>s for these formats support
+        concatenating streams as well, but they won't do so by
+        default.  You must use the two-arg constructor and explicitly
+        enable the support.</p>
+      </subsection>
+      <subsection name="Brotli">
+        <p>The implementation of this package is provided by the
+          <a href="https://github.com/google/brotli">Google Brotli dec</a> library.</p>
+        <p>Uncompressing a given Brotli compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.br"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+BrotliCompressorInputStream brIn = new BrotliCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = brIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+brIn.close();
+]]></source>
+      </subsection>
+      <subsection name="bzip2">
+        <p>Note that <code>BZipCompressorOutputStream</code> keeps
+          hold of some big data structures in memory.  While it is
+          recommended for <em>any</em> stream that you close it as soon as
+          you no longer need it, this is even more important
+          for <code>BZipCompressorOutputStream</code>.</p>
+        <p>Uncompressing a given bzip2 compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.bz2"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+BZip2CompressorInputStream bzIn = new BZip2CompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = bzIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+bzIn.close();
+]]></source>
+        <p>Compressing a given file using bzip2 (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.bz2"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+BZip2CompressorOutputStream bzOut = new BZip2CompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    bzOut.write(buffer, 0, n);
+}
+bzOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="DEFLATE">
+        <p>The implementation of the DEFLATE/INFLATE code used by this
+        package is provided by the <code>java.util.zip</code> package
+        of the Java class library.</p>
+        <p>Uncompressing a given DEFLATE compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("some-file"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+DeflateCompressorInputStream defIn = new DeflateCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = defIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+defIn.close();
+]]></source>
+        <p>Compressing a given file using DEFLATE (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("some-file"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+DeflateCompressorOutputStream defOut = new DeflateCompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    defOut.write(buffer, 0, n);
+}
+defOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="DEFLATE64">
+        <p>Uncompressing a given DEFLATE64 compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("some-file"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+Deflate64CompressorInputStream defIn = new Deflate64CompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = defIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+defIn.close();
+]]></source>
+      </subsection>
+      <subsection name="gzip">
+        <p>The implementation of the DEFLATE/INFLATE code used by this
+        package is provided by the <code>java.util.zip</code> package
+        of the Java class library.</p>
+        <p>Uncompressing a given gzip compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.gz"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+GzipCompressorInputStream gzIn = new GzipCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = gzIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+gzIn.close();
+]]></source>
+        <p>Compressing a given file using gzip (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.gz"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+GzipCompressorOutputStream gzOut = new GzipCompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    gzOut.write(buffer, 0, n);
+}
+gzOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="LZ4">
+        <p>There are two different "formats" used for <a
+        href="http://lz4.github.io/lz4/">lz4</a>. The format called
+        "block format" only contains the raw compressed data while the
+        other provides a higher level "frame format" - Commons
+        Compress offers two different stream classes for reading or
+        writing either format.</p>
+        <p>Uncompressing a given framed LZ4 file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.lz4"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+FramedLZ4CompressorInputStream zIn = new FramedLZ4CompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = zIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+zIn.close();
+]]></source>
+        <p>Compressing a given file using the LZ4 frame format (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.lz4"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+FramedLZ4CompressorOutputStream lzOut = new FramedLZ4CompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    lzOut.write(buffer, 0, n);
+}
+lzOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="lzma">
+        <p>The implementation of this package is provided by the
+          public domain <a href="https://tukaani.org/xz/java.html">XZ
+          for Java</a> library.</p>
+        <p>Uncompressing a given LZMA compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.lzma"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+LZMACompressorInputStream lzmaIn = new LZMACompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = xzIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+lzmaIn.close();
+]]></source>
+        <p>Compressing a given file using LZMA (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.lzma"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+LZMACompressorOutputStream lzOut = new LZMACompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    lzOut.write(buffer, 0, n);
+}
+lzOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="Pack200">
+        <p>The Pack200 package has a <a href="pack200.html">dedicated
+          documentation page</a>.</p>
+        <p>The implementation of this package used to be provided by
+          the <code>java.util.zip</code> package of the Java class
+          library. Starting with Compress 1.21 the implementation uses
+          a copy of the pack200 code of the now retired Apache
+          Harmony&#x2122; project that ships with Compress itself.</p>
+        <p>Uncompressing a given pack200 compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.pack"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.jar"));
+Pack200CompressorInputStream pIn = new Pack200CompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = pIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+pIn.close();
+]]></source>
+        <p>Compressing a given jar using pack200 (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.jar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.pack"));
+BufferedOutputStream out = new BufferedInputStream(fout);
+Pack200CompressorOutputStream pOut = new Pack200CompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    pOut.write(buffer, 0, n);
+}
+pOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="Snappy">
+        <p>There are two different "formats" used for <a
+        href="https://github.com/google/snappy/">Snappy</a>, one only
+        contains the raw compressed data while the other provides a
+        higher level "framing format" - Commons Compress offers two
+        different stream classes for reading either format.</p>
+        <p>Starting with 1.12 we've added support for different
+        dialects of the framing format that can be specified when
+        constructing the stream. The <code>STANDARD</code> dialect
+        follows the "framing format" specification while the
+        <code>IWORK_ARCHIVE</code> dialect can be used to parse IWA
+        files that are part of Apple's iWork 13 format. If no dialect
+        has been specified, <code>STANDARD</code> is used. Only the
+        <code>STANDARD</code> format can be detected by
+        <code>CompressorStreamFactory</code>.</p>
+        <p>Uncompressing a given framed Snappy file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.sz"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+FramedSnappyCompressorInputStream zIn = new FramedSnappyCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = zIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+zIn.close();
+]]></source>
+        <p>Compressing a given file using framed Snappy (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.sz"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+FramedSnappyCompressorOutputStream snOut = new FramedSnappyCompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    snOut.write(buffer, 0, n);
+}
+snOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="XZ">
+        <p>The implementation of this package is provided by the
+          public domain <a href="https://tukaani.org/xz/java.html">XZ
+          for Java</a> library.</p>
+        <p>When you try to open an XZ stream for reading using
+        <code>CompressorStreamFactory</code>, Commons Compress will
+        check whether the XZ for Java library is available.  Starting
+        with Compress 1.9 the result of this check will be cached
+        unless Compress finds OSGi classes in its classpath.  You can
+        use <code>XZUtils#setCacheXZAvailability</code> to override
+        this default behavior.</p>
+        <p>Uncompressing a given XZ compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.xz"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+XZCompressorInputStream xzIn = new XZCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = xzIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+xzIn.close();
+]]></source>
+        <p>Compressing a given file using XZ (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.xz"));
+BufferedOutputStream out = new BufferedInputStream(fout);
+XZCompressorOutputStream xzOut = new XZCompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    xzOut.write(buffer, 0, n);
+}
+xzOut.close();
+in.close();
+]]></source>
+      </subsection>
+      <subsection name="Z">
+        <p>Uncompressing a given Z compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.Z"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+ZCompressorInputStream zIn = new ZCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = zIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+zIn.close();
+]]></source>
+      </subsection>
+      <subsection name="Zstandard">
+        <p>The implementation of this package is provided by the
+          <a href="https://github.com/luben/zstd-jni">Zstandard JNI</a> library.</p>
+        <p>Uncompressing a given Zstandard compressed file (you would
+          certainly add exception handling and make sure all streams
+          get closed properly):</p>
+<source><![CDATA[
+InputStream fin = Files.newInputStream(Paths.get("archive.tar.zstd"));
+BufferedInputStream in = new BufferedInputStream(fin);
+OutputStream out = Files.newOutputStream(Paths.get("archive.tar"));
+ZstdCompressorInputStream zsIn = new ZstdCompressorInputStream(in);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = zsIn.read(buffer))) {
+    out.write(buffer, 0, n);
+}
+out.close();
+zsIn.close();
+]]></source>
+        <p>Compressing a given file using the Zstandard format (you
+        would certainly add exception handling and make sure all
+        streams get closed properly):</p>
+<source><![CDATA[
+InputStream in = Files.newInputStream(Paths.get("archive.tar"));
+OutputStream fout = Files.newOutputStream(Paths.get("archive.tar.zstd"));
+BufferedOutputStream out = new BufferedOutputStream(fout);
+ZstdCompressorOutputStream zOut = new ZstdCompressorOutputStream(out);
+final byte[] buffer = new byte[buffersize];
+int n = 0;
+while (-1 != (n = in.read(buffer))) {
+    zOut.write(buffer, 0, n);
+}
+zOut.close();
+in.close();
+]]></source>
+      </subsection>
+    </section>
+    <section name="Extending Commons Compress">
+        <p>
+          Starting in release 1.13, it is now possible to add Compressor- and ArchiverStream implementations using the
+          Java's <a href="https://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html">ServiceLoader</a>
+          mechanism.
+        </p>
+    <subsection name="Extending Commons Compress Compressors">
+        <p>
+          To provide your own compressor, you must make available on the classpath a file called
+          <code>META-INF/services/org.apache.commons.compress.compressors.CompressorStreamProvider</code>.
+        </p>
+        <p>
+          This file MUST contain one fully-qualified class name per line.
+        </p>
+        <p>
+          For example:
+        </p>
+        <pre>org.apache.commons.compress.compressors.TestCompressorStreamProvider</pre>
+        <p>
+          This class MUST implement the Commons Compress interface
+          <a href="apidocs/org/apache/commons/compress/compressors/CompressorStreamProvider.html">org.apache.commons.compress.compressors.CompressorStreamProvider</a>.
+        </p>
+    </subsection>
+    <subsection name="Extending Commons Compress Archivers">
+        <p>
+          To provide your own compressor, you must make available on the classpath a file called
+          <code>META-INF/services/org.apache.commons.compress.archivers.ArchiveStreamProvider</code>.
+        </p>
+        <p>
+          This file MUST contain one fully-qualified class name per line.
+        </p>
+        <p>
+          For example:
+        </p>
+        <pre>org.apache.commons.compress.archivers.TestArchiveStreamProvider</pre>
+        <p>
+          This class MUST implement the Commons Compress interface
+          <a href="apidocs/org/apache/commons/compress/archivers/ArchiveStreamProvider.html">org.apache.commons.compress.archivers.ArchiveStreamProvider</a>.
+        </p>
+    </subsection>
+    </section>
+  </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/index.xml ADDED Viewed

	@@ -0,0 +1,122 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+    <properties>
+        <title>Overview</title>
+        <author email="dev@commons.apache.org">Apache Commons Team</author>
+    </properties>
+    <body>
+        <section name="Apache Commons Compress&#x2122;">
+            <p>
+                The Apache Commons Compress library defines an API for
+                working with ar, cpio, Unix dump, tar, zip, gzip, XZ,
+                Pack200, bzip2, 7z, arj, LZMA, snappy, DEFLATE, lz4,
+                Brotli, Zstandard, DEFLATE64 and Z files.
+            </p>
+            <p>
+                The code in this component has many origins:
+            </p>
+            <ul>
+              <li>The bzip2, tar and zip support came from Avalon's
+                Excalibur, but originally from Ant, as far as life in
+                Apache goes. The tar package is originally Tim Endres'
+                public domain package. The bzip2 package is based on
+                the work done by Keiron Liddle as well as Julian Seward's
+                <a href="http://www.bzip.org/index.html">libbzip2</a>.
+                It has migrated
+                via:<br/> Ant -&gt; Avalon-Excalibur -&gt; Commons-IO
+                -&gt; Commons-Compress.</li>
+              <li>The cpio package has been contributed by Michael Kuss
+                and
+                the <a href="http://jrpm.sourceforge.net/">jRPM</a>
+                project.</li>
+              <li>The pack200 code has originally been part of the now
+                retired <a href="https://harmony.apache.org/">Apache
+                Harmony&#x2122;</a> project.</li>
+            </ul>
+        </section>
+        <section name="Status">
+          <p>The current release requires Java 8 or above.</p>
+          <p>For a list of changes see the <a href="changes.html">Changes Report</a>.</p>
+        </section>
+        <section name="Documentation">
+          <p>The compress component is split into <em>compressors</em> and
+            <em>archivers</em>.  While <em>compressors</em>
+            (un)compress streams that usually store a single
+            entry, <em>archivers</em> deal with archives that contain
+            structured content represented
+            by <code>ArchiveEntry</code> instances which in turn
+            usually correspond to single files or directories.</p>
+          <p>Currently the bzip2, Pack200, XZ, gzip, LZMA, brotli,
+            Zstandard and Z formats are
+            supported as compressors where gzip support is mostly provided by
+            the <code>java.util.zip</code> package of the Java
+            class library.  XZ and LZMA support is provided by the public
+            domain <a href="https://tukaani.org/xz/java.html">XZ for
+            Java</a> library.  Brotli support is provided by the MIT
+            licensed <a href="https://github.com/google/brotli">Google
+            Brotli decoder</a>. Zstandard support is provided by the BSD
+            licensed <a href="https://github.com/luben/zstd-jni">Zstd-jni</a>.
+            As of Commons Compress 1.21 support for the DEFLATE64, Z and Brotli
+            formats is read-only.</p>
+          <p>The ar, arj, cpio, dump, tar, 7z and zip formats are supported as
+            archivers where the <a href="zip.html">zip</a>
+            implementation provides capabilities that go beyond the
+            features found in java.util.zip.  As of Commons Compress
+            1.21 support for the dump and arj formats is
+            read-only - 7z can read most compressed and encrypted
+            archives but only write unencrypted ones.  LZMA(2) support
+            in 7z requires <a href="https://tukaani.org/xz/java.html">XZ for
+            Java</a> as well.</p>
+          <p>The compress component provides abstract base classes for
+            compressors and archivers together with factories that can
+            be used to choose implementations by algorithm name.  In
+            the case of input streams the factories can also be used
+            to guess the format and provide the matching
+            implementation.</p>
+          <ul>
+            <li>The <a href="examples.html">user guide</a> contains
+            more detailed information and some examples.</li>
+            <li>The <a href="limitations.html">known limitations and
+            problems</a> page lists the currently known problems
+            grouped by the format they apply to.</li>
+            <li>The <a href="apidocs/index.html">Javadoc</a> of the latest GIT</li>
+            <li>The <a href="https://gitbox.apache.org/repos/asf?p=commons-compress.git">GIT
+                repository</a> can be browsed.</li>
+            </ul>
+        </section>
+        <section name="Releases">
+          <p>
+            <a href="https://commons.apache.org/compress/download_compress.cgi">Download now!</a>
+          </p>
+        </section>
+    </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/issue-tracking.xml ADDED Viewed

	@@ -0,0 +1,104 @@

+<?xml version="1.0"?>
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+     https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+<!--
+ +======================================================================+
+ |****                                                              ****|
+ |****      THIS FILE IS GENERATED BY THE COMMONS BUILD PLUGIN      ****|
+ |****                    DO NOT EDIT DIRECTLY                      ****|
+ |****                                                              ****|
+ +======================================================================+
+ | TEMPLATE FILE: issue-tracking-template.xml                           |
+ | commons-build-plugin/trunk/src/main/resources/commons-xdoc-templates |
+ +======================================================================+
+ |                                                                      |
+ | 1) Re-generate using: mvn commons-build:jira-page                    |
+ |                                                                      |
+ | 2) Set the following properties in the component's pom:              |
+ |    - commons.jira.id  (required, alphabetic, upper case)             |
+ |    - commons.jira.pid (required, numeric)                            |
+ |                                                                      |
+ | 3) Example Properties                                                |
+ |                                                                      |
+ |  <properties>                                                        |
+ |    <commons.jira.id>MATH</commons.jira.id>                           |
+ |    <commons.jira.pid>12310485</commons.jira.pid>                     |
+ |  </properties>                                                       |
+ |                                                                      |
+ +======================================================================+
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Apache Commons Compress Issue tracking</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="Apache Commons Compress Issue tracking">
+      <p>
+      Apache Commons Compress uses <a href="https://issues.apache.org/jira/">ASF JIRA</a> for tracking issues.
+      See the <a href="https://issues.apache.org/jira/browse/COMPRESS">Apache Commons Compress JIRA project page</a>.
+      </p>
+      <p>
+      To use JIRA you may need to <a href="https://issues.apache.org/jira/secure/Signup!default.jspa">create an account</a>
+      (if you have previously created/updated Commons issues using Bugzilla an account will have been automatically
+      created and you can use the <a href="https://issues.apache.org/jira/secure/ForgotPassword!default.jspa">Forgot Password</a>
+      page to get a new password).
+      </p>
+      <p>
+      If you would like to report a bug, or raise an enhancement request with
+      Apache Commons Compress please do the following:
+      </p>
+      <ol>
+        <li><a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&amp;pid=12310904&amp;sorter/field=issuekey&amp;sorter/order=DESC&amp;status=1&amp;status=3&amp;status=4">Search existing open bugs</a>.
+            If you find your issue listed then please add a comment with your details.</li>
+        <li><a href="mail-lists.html">Search the mailing list archive(s)</a>.
+            You may find your issue or idea has already been discussed.</li>
+        <li>Decide if your issue is a bug or an enhancement.</li>
+        <li>Submit either a <a href="https://issues.apache.org/jira/secure/CreateIssueDetails!init.jspa?pid=12310904&amp;issuetype=1&amp;priority=4&amp;assignee=-1">bug report</a>
+            or <a href="https://issues.apache.org/jira/secure/CreateIssueDetails!init.jspa?pid=12310904&amp;issuetype=4&amp;priority=4&amp;assignee=-1">enhancement request</a>.</li>
+      </ol>
+      <p>
+      Please also remember these points:
+      </p>
+      <ul>
+        <li>the more information you provide, the better we can help you</li>
+        <li>test cases are vital, particularly for any proposed enhancements</li>
+        <li>the developers of Apache Commons Compress are all unpaid volunteers</li>
+      </ul>
+      <p>
+      For more information on creating patches see the
+      <a href="https://www.apache.org/dev/contributors.html">Apache Contributors Guide</a>.
+      </p>
+      <p>
+      You may also find these links useful:
+      </p>
+      <ul>
+        <li><a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&amp;pid=12310904&amp;sorter/field=issuekey&amp;sorter/order=DESC&amp;status=1&amp;status=3&amp;status=4">All Open Apache Commons Compress bugs</a></li>
+        <li><a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&amp;pid=12310904&amp;sorter/field=issuekey&amp;sorter/order=DESC&amp;status=5&amp;status=6">All Resolved Apache Commons Compress bugs</a></li>
+        <li><a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&amp;pid=12310904&amp;sorter/field=issuekey&amp;sorter/order=DESC">All Apache Commons Compress bugs</a></li>
+      </ul>
+    </section>
+  </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/limitations.xml ADDED Viewed

	@@ -0,0 +1,259 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+   <properties>
+      <title>Known Limitations and Problems</title>
+   </properties>
+   <body>
+     <section name="General">
+       <p>
+         This page lists the known limitations and problems of Apache
+         Commons Compress&#x2122; grouped by the archiving/compression
+         format they apply to.
+       </p>
+       <ul>
+         <li>Several implementations of decompressors and unarchivers will
+         invoke <a
+         href="https://docs.oracle.com/javase/10/docs/api/java/io/InputStream.html#skip(long)"><code>skip</code></a>
+         on the underlying <code>InputStream</code> which may throw an
+         <code>IOException</code> in some stream implementations. One
+         known case where this happens is when using
+         <code>System.in</code> as input. If you encounter an
+         exception with a message like "Illegal seek" we recommend you
+         wrap your stream in a <code>SkipShieldingInputStream</code>
+         from our utils package before passing it to Compress.</li>
+         <li>Commons Compress prior to 1.21 cannot be built on JDK 14 or newer.</li>
+       </ul>
+     </section>
+     <section name="7Z">
+       <ul>
+         <li>the format requires the otherwise optional <a
+         href="https://tukaani.org/xz/java.html">XZ for Java</a>
+         library.</li>
+         <li>only <code>File</code>s are supported as input/output,
+         not streams. Starting with Compress 1.13
+         <code>SeekableByteChannel</code> is supported as well.</li>
+         <li>In Compress 1.7
+         <code>ArchiveStreamFactory</code> will not auto-detect 7z
+         archives, starting with 1.8 it will throw a
+         <code>StreamingNotSupportedException</code> when reading from
+         a 7z archive.</li>
+         <li>Encryption, solid compression and header compression
+         are only supported when reading archives</li>
+         <li>Commons Compress 1.12 and earlier didn't support writing
+         LZMA.</li>
+         <li>Several of the "methods" supported by 7z are not
+         implemented in Compress.</li>
+         <li>No support for writing multi-volume archives. Such
+         archives can be read by simply concatenating the parts, for
+         example by using
+         <code>MultiReadOnlySeekableByteChannel</code>.</li>
+         <li>Support for some BCJ filters and the DELTA filter has
+         been added with Compress 1.8.  Because of a known bug in
+         version 1.4 of the <a
+         href="https://tukaani.org/xz/java.html">XZ for Java</a>
+         library, archives using BCJ filters will cause an
+         <code>AssertionError</code> when read.  If you need support
+         for BCJ filters you must use XZ for Java 1.5 or later.</li>
+       </ul>
+     </section>
+     <section name="AR">
+       <ul>
+         <li>AR archives can not contain directories - this is a
+         limitation of the format rather than one of Compress'
+         implementation.</li>
+         <li>file names longer than 16 characters are only fully
+         supported using the BSD dialect, the GNU/SRV4 dialect is only
+         supported when reading archives.</li>
+       </ul>
+     </section>
+     <section name="ARJ">
+       <ul>
+         <li>read-only support</li>
+         <li>no support for compression, encryption or multi-volume
+         archives</li>
+       </ul>
+     </section>
+     <section name="Brotli">
+       <ul>
+         <li>the format requires the otherwise optional <a
+         href="https://github.com/google/brotli">Google Brotli dec</a>
+         library.</li>
+         <li>read-only support</li>
+         <li><code>CompressorStreamFactory</code> is not able to auto-detect
+         streams using Brotli compression.</li>
+       </ul>
+     </section>
+     <section name="BZIP2">
+       <p>Versions of Compress prior to 1.4.1 are vulnerable to a
+       possible denial of service attack, see the <a
+       href="security.html">Security Reports</a> page for details.</p>
+     </section>
+     <section name="CPIO">
+       <p>We are not aware of any problems.</p>
+     </section>
+     <section name="DEFLATE">
+       <ul>
+         <li><code>CompressorStreamFactory</code> is not able to auto-detect
+         streams using DEFLATE compression.</li>
+       </ul>
+     </section>
+     <section name="DEFLATE64">
+       <ul>
+         <li><code>CompressorStreamFactory</code> is not able to auto-detect
+         streams using DEFLATE64 compression.</li>
+         <li>read-only support</li>
+       </ul>
+     </section>
+     <section name="DUMP">
+       <ul>
+         <li>read-only support</li>
+         <li>only the new-fs format is supported</li>
+         <li>the only compression algorithm supported is zlib</li>
+       </ul>
+     </section>
+     <section name="GZIP">
+       <p>We are not aware of any problems.</p>
+     </section>
+     <section name="JAR">
+       <p>JAR archives are special ZIP archives, all limitations of <a
+       href="#ZIP">ZIP</a> apply to JAR as well.</p>
+       <ul>
+         <li><code>ArchiveStreamFactory</code> cannot tell JAR
+         archives from ZIP archives and will not auto-detect
+         JARs.</li>
+         <li>Compress doesn't provide special access to the archive's
+         MANIFEST</li>
+       </ul>
+     </section>
+     <section name="LZ4">
+       <ul>
+         <li>In theory LZ4 compressed streams can contain literals and
+         copies of arbitrary length while Commons Compress only
+         supports sizes up to 2<sup>63</sup> - 1 (i.e. &#x2248; 9.2
+         EB).</li>
+       </ul>
+     </section>
+     <section name="LZMA">
+       <ul>
+         <li>the format requires the otherwise optional <a
+         href="https://tukaani.org/xz/java.html">XZ for Java</a>
+         library.</li>
+         <li>Commons Compress 1.12 and earlier only support reading
+         the format</li>
+       </ul>
+     </section>
+     <section name="PACK200">
+       <ul>
+         <li><p>Pack200 support in Commons Compress prior to 1.21 relies on the
+         <code>Pack200</code> class of the Java classlib. Java 14
+         removed support and thus Pack200 will not work at all when
+         running on Java 14 or later.</p>
+         <p>Starting with Commons Compress 1.21 the classlib
+         implementation is no longer used at all, instead Commons
+         Compress contains the pack200 code of the retired Apache
+         Harmony&#x2122; project.</p></li>
+       </ul>
+     </section>
+     <section name="SNAPPY">
+       <ul>
+         <li>Commons Compress 1.13 and earlier only support reading
+         the format</li>
+       </ul>
+     </section>
+     <section name="TAR">
+       <ul>
+         <li>sparse files could not be read in version prior to
+         Compress 1.20</li>
+         <li>sparse files can not be written</li>
+         <li>only a subset of the GNU and POSIX extensions are
+         supported</li>
+         <li>In Compress 1.6 <code>TarArchiveInputStream</code> could
+         fail to read the full contents of an entry unless the stream
+         was wrapped in a buffering stream.</li>
+       </ul>
+     </section>
+     <section name="XZ">
+       <ul>
+         <li>the format requires the otherwise optional <a
+         href="https://tukaani.org/xz/java.html">XZ for Java</a>
+         library.</li>
+       </ul>
+     </section>
+     <section name="Z">
+       <ul>
+         <li>Prior to Compress 1.8.1
+         <code>CompressorStreamFactory</code> was not able to
+         auto-detect streams using .Z compression.</li>
+         <li>read-only support</li>
+       </ul>
+     </section>
+     <section name="ZIP">
+       <ul>
+         <li><code>ZipArchiveInputStream</code> is limited and may
+         even return false contents in some cases, use
+         <code>ZipFile</code> whenever possible.  See <a
+         href="zip.html#ZipArchiveInputStream_vs_ZipFile">the ZIP
+         documentation page</a> for details.  This limitation is a
+         result of streaming data vs using random access and not a
+         limitation of Compress' specific implementation.</li>
+         <li>only a subset of compression methods are supported,
+         including the most common STORED and DEFLATEd.  IMPLODE,
+         SHRINK, DEFLATE64 and BZIP2 support is read-only.</li>
+         <li>no support for encryption</li>
+         <li>no support for multi-volume archives prior to Compress 1.20</li>
+         <li>It is currently not possible to write split archives with
+         more than 64k segments. When creating split archives with more
+         than 100 segments you will need to adjust the file names as
+         <code>ZipArchiveOutputStream</code> assumes extensions will be
+         three characters long.</li>
+         <li>In versions prior to Compress 1.6
+         <code>ZipArchiveEntries</code> read from an archive will
+         contain non-zero millisecond values when using Java 8 or later rather
+         than the expected two-second granularity.</li>
+         <li>Compress 1.7 has a known bug where the very first entry
+         of an archive will not be read correctly by
+         <code>ZipArchiveInputStream</code> if it used the STORED
+         method.</li>
+         <li><code>ZipArchiveEntry#getLastModifiedDate</code> uses
+         <code>ZipEntry#getTime</code> under the covers which may
+         return different times for the same archive when using
+         different versions of Java.</li>
+         <li>In versions of Compress prior to 1.16 a specially crafted
+         ZIP archive can be used to cause an infinite loop inside of
+         Compress' extra field parser used by the <code>ZipFile</code>
+         and <code>ZipArchiveInputStream</code> classes.  This can be
+         used to mount a denial of service attack against services
+         that use Compress' zip package. See the <a
+         href="security.html">Security Reports</a> page for
+         details.</li>
+       </ul>
+     </section>
+     <section name="Zstandard">
+       <ul>
+         <li>the format requires the otherwise optional <a
+         href="https://github.com/luben/zstd-jni">Zstandard JNI</a>
+         library.</li>
+       </ul>
+     </section>
+   </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/mail-lists.xml ADDED Viewed

	@@ -0,0 +1,215 @@

+<?xml version="1.0"?>
+<!--
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+     https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+<!--
+ +======================================================================+
+ |****                                                              ****|
+ |****      THIS FILE IS GENERATED BY THE COMMONS BUILD PLUGIN      ****|
+ |****                    DO NOT EDIT DIRECTLY                      ****|
+ |****                                                              ****|
+ +======================================================================+
+ | TEMPLATE FILE: mail-lists-template.xml                               |
+ | commons-build-plugin/trunk/src/main/resources/commons-xdoc-templates |
+ +======================================================================+
+ |                                                                      |
+ | 1) Re-generate using: mvn commons-build:mail-page                    |
+ |                                                                      |
+ | 2) Set the following properties in the component's pom:              |
+ |    - commons.componentid (required, alphabetic, lower case)          |
+ |                                                                      |
+ | 3) Example Properties                                                |
+ |                                                                      |
+ |  <properties>                                                        |
+ |    <commons.componentid>math</commons.componentid>                   |
+ |  </properties>                                                       |
+ |                                                                      |
+ +======================================================================+
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Apache Commons Compress Mailing Lists</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="Overview">
+      <p>
+        <a href="index.html">Apache Commons Compress</a> shares mailing lists with all the other
+        <a href="https://commons.apache.org/components.html">Commons Components</a>.
+        To make it easier for people to only read messages related to components they are interested in,
+        the convention in Commons is to prefix the subject line of messages with the component's name,
+        for example:
+      </p>
+      <ul>
+        <li>[compress] Problem with the ...</li>
+      </ul>
+      <p>
+        Questions related to the usage of Apache Commons Compress should be posted to the
+        <a href="https://lists.apache.org/list.html?user@commons.apache.org">User List</a>.
+        <br />
+        The <a href="https://lists.apache.org/list.html?dev@commons.apache.org">Developer List</a>
+        is for questions and discussion related to the development of Apache Commons Compress.
+        <br />
+        Please do not cross-post; developers are also subscribed to the user list.
+        <br />
+        You must be subscribed to post to the mailing lists.  Follow the Subscribe links below
+        to subscribe.
+      </p>
+      <p>
+        <strong>Note:</strong> please don't send patches or attachments to any of the mailing lists;
+        most of the lists are set up to drop attachments.
+        Patches are best handled via the <a href="issue-tracking.html">Issue Tracking</a> system.
+        If you have a GitHub account, most components also accept PRs (pull requests).
+        Otherwise, please upload the file to a public server and include the URL in the mail.
+      </p>
+    </section>
+    <section name="Apache Commons Compress Mailing Lists">
+      <p>
+        <strong>Please prefix the subject line of any messages for <a href="index.html">Apache Commons Compress</a>
+        with <i>[compress]</i></strong> - <i>thanks!</i>
+        <br />
+        <br />
+      </p>
+      <table>
+        <tr>
+          <th>Name</th>
+          <th>Subscribe</th>
+          <th>Unsubscribe</th>
+          <th>Post</th>
+          <th>Archive</th>
+          <th>Other Archives</th>
+        </tr>
+        <tr>
+          <td>
+            <strong>Commons User List</strong>
+            <br /><br />
+            Questions on using Apache Commons Compress.
+            <br /><br />
+          </td>
+          <td><a href="mailto:user-subscribe@commons.apache.org">Subscribe</a></td>
+          <td><a href="mailto:user-unsubscribe@commons.apache.org">Unsubscribe</a></td>
+          <td><a href="mailto:user@commons.apache.org?subject=[compress]">Post</a></td>
+          <td>
+              <a href="https://lists.apache.org/list.html?user@commons.apache.org">lists.apache.org</a>
+          </td>
+          <td>
+              <a href="https://www.mail-archive.com/user@commons.apache.org/">www.mail-archive.com</a>
+          </td>
+        </tr>
+        <tr>
+          <td>
+            <strong>Commons Developer List</strong>
+            <br /><br />
+            Discussion of development of Apache Commons Compress.
+            <br /><br />
+          </td>
+          <td><a href="mailto:dev-subscribe@commons.apache.org">Subscribe</a></td>
+          <td><a href="mailto:dev-unsubscribe@commons.apache.org">Unsubscribe</a></td>
+          <td><a href="mailto:dev@commons.apache.org?subject=[compress]">Post</a></td>
+          <td>
+              <a href="https://lists.apache.org/list.html?dev@commons.apache.org">lists.apache.org</a>
+          </td>
+          <td>
+              <a href="https://www.mail-archive.com/dev@commons.apache.org/">www.mail-archive.com</a>
+          </td>
+        </tr>
+        <tr>
+          <td>
+            <strong>Commons Issues List</strong>
+            <br /><br />
+            Only for e-mails automatically generated by the <a href="issue-tracking.html">issue tracking</a> system.
+            <br /><br />
+          </td>
+          <td><a href="mailto:issues-subscribe@commons.apache.org">Subscribe</a></td>
+          <td><a href="mailto:issues-unsubscribe@commons.apache.org">Unsubscribe</a></td>
+          <td><i>read only</i></td>
+          <td>
+              <a href="https://lists.apache.org/list.html?issues@commons.apache.org">lists.apache.org</a>
+          </td>
+          <td>
+              <a href="https://www.mail-archive.com/issues@commons.apache.org/">www.mail-archive.com</a>
+          </td>
+        </tr>
+        <tr>
+          <td>
+            <strong>Commons Commits List</strong>
+            <br /><br />
+            Only for e-mails automatically generated by the <a href="scm.html">source control</a> system.
+            <br /><br />
+          </td>
+          <td><a href="mailto:commits-subscribe@commons.apache.org">Subscribe</a></td>
+          <td><a href="mailto:commits-unsubscribe@commons.apache.org">Unsubscribe</a></td>
+          <td><i>read only</i></td>
+          <td>
+              <a href="https://lists.apache.org/list.html?commits@commons.apache.org">lists.apache.org</a>
+          </td>
+          <td>
+              <a href="https://www.mail-archive.com/commits@commons.apache.org/">www.mail-archive.com</a>
+          </td>
+        </tr>
+      </table>
+    </section>
+    <section name="Apache Mailing Lists">
+      <p>
+        Other mailing lists which you may find useful include:
+      </p>
+      <table>
+        <tr>
+          <th>Name</th>
+          <th>Subscribe</th>
+          <th>Unsubscribe</th>
+          <th>Post</th>
+          <th>Archive</th>
+          <th>Other Archives</th>
+        </tr>
+        <tr>
+          <td>
+            <strong>Apache Announce List</strong>
+            <br /><br />
+            General announcements of Apache project releases.
+            <br /><br />
+          </td>
+          <td><a class="externalLink" href="mailto:announce-subscribe@apache.org">Subscribe</a></td>
+          <td><a class="externalLink" href="mailto:announce-unsubscribe@apache.org">Unsubscribe</a></td>
+          <td><i>read only</i></td>
+          <td>
+              <a class="externalLink" href="https://lists.apache.org/list.html?announce@apache.org">lists.apache.org</a>
+          </td>
+          <td>
+              <a class="externalLink" href="https://www.mail-archive.com/announce@apache.org/">www.mail-archive.com</a>
+          </td>
+        </tr>
+      </table>
+    </section>
+  </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/pack200.xml ADDED Viewed

	@@ -0,0 +1,91 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Commons Compress Pack200 Package</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="The Pack200 package">
+      <p>The Pack200 algorithm is not a general purpose compression
+      algorithm but one specialized for compressing JAR archives.  JAR
+      archives compressed with Pack200 will in general be different
+      from the original archive when decompressed again.  More
+      information can be found in the Javadocs of the <a
+      href="https://docs.oracle.com/javase/7/docs/api/java/util/jar/Pack200.Packer.html">Pack200.Packer
+      class</a>.</p>
+      <p>While the <code>pack200</code> command line utility of the
+      JDK creates GZip compressed archives (<code>.pack.gz</code>) by
+      default, the streams provided by the Pack200 package only
+      perform the actual Pack200 operation.  Wrap them in an
+      additional <code>GzipCompressor(In|Out)putStream</code> in order to deal
+      with deflated streams.</p>
+      <subsection name="Pack200Strategy">
+        <p>The Pack200-API provided by the java class library is not
+        streaming friendly as it wants to consume its input completely
+        in a single operation.  Because of this
+        <code>Pack200CompressorInputStream</code>'s constructor will immediately
+        unpack the stream, cache the results and provide an input
+        stream to the cache.</p>
+        <p><code>Pack200CompressorOutputStream</code> will cache all data that
+        is written to it and then pack it once the <code>finish</code>
+        or <code>close</code> method is called.</p>
+        <p>Two different caching modes are available - "in memory",
+        which is the default, and "temporary file".  By default data
+        is cached in memory but you should switch to the temporary
+        file option if your archives are really big.</p>
+        <p>Given there always is an intermediate result
+        the <code>getBytesRead</code> and <code>getCount</code>
+        methods of <code>Pack200CompressorInputStream</code> are
+        meaningless (read from the real stream or from the
+        intermediate result?)  and always return 0.</p>
+      </subsection>
+      <subsection name="Normalization">
+        <p>As a pack/unpack cycle may create a JAR archive that is
+        different from the original, digital signatures created for
+        the initial JAR will be broken by the process.  There is a way
+        to "normalize" JAR archives prior to packing them that ensures
+        signatures applied to the "normalized" JAR will still be valid
+        aftre a pack/unpack cycle - see <a
+        href="https://download.oracle.com/javase/7/docs/api/java/util/jar/Pack200.Packer.html">Pack200.Packer</a>'s
+        javadocs.</p>
+        <p>The <code>Pack200Utils</code> class in the
+        <code>pack200</code> package provides several overloads of a
+        <code>normalize</code> method that can be used to prepare a
+        JAR archive in place or to a separate file.</p>
+      </subsection>
+    </section>
+</body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/security.xml ADDED Viewed

	@@ -0,0 +1,301 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+    <properties>
+        <title>Commons Compress Security Reports</title>
+        <author email="dev@commons.apache.org">Commons Team</author>
+    </properties>
+    <body>
+      <section name="General Information">
+        <p>For information about reporting or asking questions about
+        security problems, please see the <a
+        href="https://commons.apache.org/security.html">security page
+        of the Commons project</a>.</p>
+      </section>
+      <section name="Apache Commons Compress Security Vulnerabilities">
+        <p>This page lists all security vulnerabilities fixed in
+        released versions of Apache Commons Compress. Each
+        vulnerability is given a security impact rating by the
+        development team - please note that this rating may vary from
+        platform to platform. We also list the versions of Commons
+        Compress the flaw is known to affect, and where a flaw has not
+        been verified list the version with a question mark.</p>
+        <p>Please note that binary patches are never provided. If you
+        need to apply a source code patch, use the building
+        instructions for the Commons Compress version that you are
+        using.</p>
+        <p>If you need help on building Commons Compress or other help
+        on following the instructions to mitigate the known
+        vulnerabilities listed here, please send your questions to the
+        public <a href="mail-lists.html">Compress Users mailing
+        list</a>.</p>
+        <p>If you have encountered an unlisted security vulnerability
+        or other unexpected behavior that has security impact, or if
+        the descriptions here are incomplete, please report them
+        privately to the Apache Security Team. Thank you.</p>
+        <subsection name="Fixed in Apache Commons Compress 1.26.0">
+          <p><b>Important: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-25710">CVE-2024-25710</a></p>
+          <p>This affects version 1.3 through 1.25.0.</p>
+          <p>This denial of service is caused by an infinite loop reading a corrupted DUMP file.</p>
+          <p>Users are recommended to upgrade to version 1.26.0 which fixes the issue.</p>
+          <p>Credit to Yakov Shafranovich, Amazon Web Services (reporter).</p>
+          <p><b>Moderate: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-26308">CVE-2024-26308</a></p>
+          <p>You can get an OutOfMemoryError unpacking a broken Pack200 file.</p>
+          <p>This issue affects Commons Compress 1.21 before 1.26.0.</p>
+          <p>Users are recommended to upgrade to version 1.26.0 which fixes the issue.</p>
+          <p>Credit to Yakov Shafranovich, Amazon Web Services (reporter).</p>
+        </subsection>
+        <subsection name="Fixed in Apache Commons Compress 1.24.0">
+          <p><b>Moderate: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-42503">CVE-2023-42503</a></p>
+          <p>Improper Input Validation, Uncontrolled Resource Consumption vulnerability in Apache Commons Compress in TAR parsing.</p>
+          <p>This issue affects Apache Commons Compress: from 1.22 before 1.24.0.</p>
+          <p>Users are recommended to upgrade to version 1.24.0, which fixes the issue.</p>
+          <p>A third party can create a malformed TAR file by manipulating file modification times headers,
+             which when parsed with Apache Commons Compress, will cause a denial of service issue via CPU consumption.</p>
+          <p>In version 1.22 of Apache Commons Compress, support was added for file modification times with higher precision
+             (issue # COMPRESS-612<sup><a href="#Ref-1-24-1">[1]</a></sup>).
+             The format for the PAX extended headers carrying this data consists of two numbers separated by a period<sup><a href="#Ref-1-24-2">[2]</a></sup>,
+             indicating seconds and subsecond precision (for example “1647221103.5998539”). The impacted fields are “atime”, “ctime”, “mtime” and
+             “LIBARCHIVE.creationtime”. No input validation is performed prior to the parsing of header values.</p>
+          <p>Parsing of these numbers uses the BigDecimal<sup><a href="#Ref-1-24-3">[3]</a></sup> class from the JDK which has a publicly known algorithmic complexity issue when doing
+             operations on large numbers, causing denial of service (see issue # JDK-6560193<sup><a href="#Ref-1-24-4">[4]</a></sup>). A third party can manipulate file time headers
+             in a TAR file by placing a number with a very long fraction (300,000 digits) or a number with exponent notation (such as “9e9999999”)
+             within a file modification time header, and the parsing of files with these headers will take hours instead of seconds, leading to a
+             denial of service via exhaustion of CPU resources. This issue is similar to CVE-2012-2098<sup><a href="#Ref-1-24-5">[5]</a></sup>.</p>
+          <ul>
+            <li id="Ref-1-24-1">[1]: <a href="https://issues.apache.org/jira/browse/COMPRESS-612">COMPRESS-612</a></li>
+            <li id="Ref-1-24-2">[2]: <a href="https://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_05">PAX extended headers</a></li>
+            <li id="Ref-1-24-3">[3]: <a href="https://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html">BigDecimal</a></li>
+            <li id="Ref-1-24-4">[4]: <a href="https://bugs.openjdk.org/browse/JDK-6560193">JDK-6560193</a></li>
+            <li id="Ref-1-24-5">[5]: <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-2098">CVE-2012-2098</a></li>
+          </ul>
+          <p>Only applications using CompressorStreamFactory class (with auto-detection of file types), TarArchiveInputStream and TarFile
+             classes to parse TAR files are impacted. Since this code was introduced in v1.22, only that version and later versions are impacted.</p>
+        </subsection>
+        <subsection name="Fixed in Apache Commons Compress 1.21">
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-35515">CVE-2021-35515</a></p>
+          <p>When reading a specially crafted 7Z archive, the construction of the
+          list of codecs that decompress an entry can result in an infinite
+          loop.  This could be used to mount a denial of service attack against
+          services that use Compress' sevenz package.</p>
+          <p>This was fixed in revision <a
+          href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=3fe6b42110dc56d0d6fe0aaf80cfecb8feea5321">3fe6b42</a>.</p>
+          <p>This issue was discovered by OSS Fuzz.</p>
+          <p>Affects: 1.6 - 1.20</p>
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-35516">CVE-2021-35516</a></p>
+          <p>When reading a specially crafted 7Z archive, Compress can be made to
+          allocate large amounts of memory that finally leads to an out of memory
+          error even for very small inputs. This could be used to mount a denial
+          of service attack against services that use Compress' sevenz package.</p>
+          <p>This was fixed in revisions
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=26924e96c7730db014c310757e11c9359db07f3e">26924e9</a>,
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=c51de6cfaec75b21566374158f25e1734c3a94cb">c51de6c</a>,
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=0aba8b8fd8053ae323f15d736d1762b2161c76a6">0aba8b8</a>,
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=60d551a748236d7f4651a4ae88d5a351f7c5754b">60d551a</a>,
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=bf5a5346ae04b9d2a5b0356ca75f11dcc8d94789">bf5a534</a>,
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=5761493cbaf7a7d608a3b68f4d61aaa822dbeb4f">5761493</a>,
+          and <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=ae2b27cc011f47f0289cb24a11f2d4f1db711f8a">ae2b27c</a>
+          .</p>
+          <p>This issue was first reported to the project's issue tracker as
+          <a href="https://issues.apache.org/jira/browse/COMPRESS-542">COMPRESS-542</a>
+          by Robin Schimpf.
+          Later OSS Fuzz detected ways to exploit this issue which managed to
+          escape the initial attempt to fix it.</p>
+          <p>Affects: 1.6 - 1.20</p>
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-35517">CVE-2021-35517</a></p>
+          <p>When reading a specially crafted TAR archive, Compress
+          can be made to allocate large amounts of memory that finally
+          leads to an out of memory error even for very small
+          inputs. This could be used to mount a denial of service
+          attack against services that use Compress' tar package.</p>
+          <p>This was fixed in revisions
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=d0af873e77d16f41edfef7b69da5c8c35c96a650">d0af873</a>,
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=7ce1b0796d6cbe1f41b969583bd49f33ae0efef0">7ce1b07</a>
+          and <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=80124dd9fe4b0a0b2e203ca19aacac8cd0afc96f">80124dd</a>.</p>
+          <p>This issue was discovered by OSS Fuzz.</p>
+          <p>Affects: 1.1 - 1.20</p>
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-36090">CVE-2021-36090</a></p>
+          <p>When reading a specially crafted ZIP archive, Compress
+          can be made to allocate large amounts of memory that finally
+          leads to an out of memory error even for very small
+          inputs. This could be used to mount a denial of service
+          attack against services that use Compress' zip package.</p>
+          <p>This was fixed in revisions
+          <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=ef5d70b625000e38404194aaab311b771c44efda">ef5d70b</a>
+          and <a
+              href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commit;h=80124dd9fe4b0a0b2e203ca19aacac8cd0afc96f">80124dd</a>.</p>
+          <p>This issue was discovered by OSS Fuzz.</p>
+          <p>Affects: 1.0 - 1.20</p>
+        </subsection>
+        <subsection name="Fixed in Apache Commons Compress 1.19">
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-12402">CVE-2019-12402</a></p>
+          <p>The file name encoding algorithm used internally in Apache Commons
+          Compress can get into an infinite loop when faced with specially
+          crafted inputs. This can lead to a denial of service attack if an
+          attacker can choose the file names inside of an archive created by
+          Compress.</p>
+          <p>This was fixed in revision <a
+          href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=commitdiff;h=4ad5d80a6272e007f64a6ac66829ca189a8093b9;hp=16a0c84e84b93cc8c107b7ff3080bd11317ab581">4ad5d80a</a>.</p>
+          <p>This was first reported to the Commons Security Team on 22 August
+          2019 and made public on 27 August 2019.</p>
+          <p>Affects: 1.15 - 1.18</p>
+        </subsection>
+        <subsection name="Fixed in Apache Commons Compress 1.18">
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-11771">CVE-2018-11771</a></p>
+          <p>When reading a specially crafted ZIP archive, the read
+          method of <code>ZipArchiveInputStream</code> can fail to
+          return the correct EOF indication after the end of the
+          stream has been reached. When combined with a
+          <code>java.io.InputStreamReader</code> this can lead to an
+          infinite stream, which can be used to mount a denial of
+          service attack against services that use Compress' zip
+          package</p>
+          <p>This was fixed in revision <a
+          href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=blobdiff;f=src/main/java/org/apache/commons/compress/archivers/zip/ZipArchiveInputStream.java;h=e1995d7aa51dfac6ae933987fb0b7760c607582b;hp=0a2c1aa0063c620c867715119eae2013c87b5e70;hb=a41ce6892cb0590b2e658704434ac0dbcb6834c8;hpb=64ed6dde03afbef6715fdfdeab5fc04be6192899">a41ce68</a>.</p>
+          <p>This was first reported to the Security Team on 14 June
+          2018 and made public on 16 August 2018.</p>
+          <p>Affects: 1.7 - 1.17</p>
+        </subsection>
+        <subsection name="Fixed in Apache Commons Compress 1.16">
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1324">CVE-2018-1324</a></p>
+          <p>A specially crafted ZIP archive can be used to cause an
+          infinite loop inside of Compress' extra field parser used by
+          the <code>ZipFile</code> and
+          <code>ZipArchiveInputStream</code> classes.  This can be
+          used to mount a denial of service attack against services
+          that use Compress' zip package.</p>
+          <p>This was fixed in revision <a
+          href="https://gitbox.apache.org/repos/asf?p=commons-compress.git;a=blobdiff;f=src/main/java/org/apache/commons/compress/archivers/zip/X0017_StrongEncryptionHeader.java;h=acc3b22346b49845e85b5ef27a5814b69e834139;hp=0feb9c98cc622cde1defa3bbd268ef82b4ae5c18;hb=2a2f1dc48e22a34ddb72321a4db211da91aa933b;hpb=dcb0486fb4cb2b6592c04d6ec2edbd3f690df5f2">2a2f1dc4</a>.</p>
+          <p>This was first reported to the project's JIRA on <a
+          href="https://issues.apache.org/jira/browse/COMPRESS-432">19
+          December 2017</a>.</p>
+          <p>Affects: 1.11 - 1.15</p>
+        </subsection>
+        <subsection name="Fixed in Apache Commons Compress 1.4.1">
+          <p><b>Low: Denial of Service</b> <a
+          href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-2098">CVE-2012-2098</a></p>
+          <p>The bzip2 compressing streams in Apache Commons Compress
+          internally use sorting algorithms with unacceptable
+          worst-case performance on very repetitive inputs.  A
+          specially crafted input to Compress'
+          <code>BZip2CompressorOutputStream</code> can be used to make
+          the process spend a very long time while using up all
+          available processing time effectively leading to a denial of
+          service.</p>
+          <p>This was fixed in revisions
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1332540">1332540</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1332552">1332552</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1333522">1333522</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1337444">1337444</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340715">1340715</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340723">1340723</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340757">1340757</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340786">1340786</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340787">1340787</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340790">1340790</a>,
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340795">1340795</a> and
+          <a href="https://svn.apache.org/viewvc?view=revision&amp;revision=1340799">1340799</a>.</p>
+          <p>This was first reported to the Security Team on 12 April
+          2012 and made public on 23 May 2012.</p>
+          <p>Affects: 1.0 - 1.4</p>
+        </subsection>
+      </section>
+      <section name="Errors and Omissions">
+        <p>Please report any errors or omissions to <a
+        href="mail-lists.html">the dev mailing list</a>.</p>
+      </section>
+    </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/tar.xml ADDED Viewed

	@@ -0,0 +1,236 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Commons Compress TAR package</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="The TAR package">
+      <p>In addition to the information stored
+      in <code>ArchiveEntry</code> a <code>TarArchiveEntry</code>
+      stores various attributes including information about the
+      original owner and permissions.</p>
+      <p>There are several different dialects of the TAR format, maybe
+      even different TAR formats. The tar package contains special
+      cases in order to read many of the existing dialects and will by
+      default try to create archives in the original format (often
+      called "ustar"). This original format didn't support file names
+      longer than 100 characters or bigger than 8 GiB and the tar
+      package will by default fail if you try to write an entry that
+      goes beyond those limits. "ustar" is the common denominator of
+      all the existing tar dialects and is understood by most of the
+      existing tools.</p>
+      <p>The tar package does not support the full POSIX tar standard
+      nor more modern GNU extension of said standard.</p>
+      <subsection name="Long File Names">
+        <p>The <code>longFileMode</code> option of
+        <code>TarArchiveOutputStream</code> controls how files with
+        names longer than 100 characters are handled.  The possible
+        choices are:</p>
+        <ul>
+          <li><code>LONGFILE_ERROR</code>: throw an exception if such a
+          file is added.  This is the default.</li>
+          <li><code>LONGFILE_TRUNCATE</code>: truncate such names.</li>
+          <li><code>LONGFILE_GNU</code>: use a GNU tar variant now
+          referred to as "oldgnu" of storing such names.  If you choose
+          the GNU tar option, the archive can not be extracted using
+          many other tar implementations like the ones of OpenBSD,
+          Solaris or MacOS X.</li>
+          <li><code>LONGFILE_POSIX</code>: use a PAX <a
+          href="http://pubs.opengroup.org/onlinepubs/009695399/utilities/pax.html#tag_04_100_13_03">extended
+          header</a> as defined by POSIX 1003.1.  Most modern tar
+          implementations are able to extract such archives. <em>since
+          Commons Compress 1.4</em></li>
+        </ul>
+        <p><code>TarArchiveInputStream</code> will recognize the GNU
+        tar as well as the POSIX extensions (starting with Commons
+        Compress 1.2) for long file names and reads the longer names
+        transparently.</p>
+      </subsection>
+      <subsection name="Big Numeric Values">
+        <p>The <code>bigNumberMode</code> option of
+        <code>TarArchiveOutputStream</code> controls how files larger
+        than 8GiB or with other big numeric values that can't be
+        encoded in traditional header fields are handled.  The
+        possible choices are:</p>
+        <ul>
+          <li><code>BIGNUMBER_ERROR</code>: throw an exception if such an
+          entry is added.  This is the default.</li>
+          <li><code>BIGNUMBER_STAR</code>: use a variant first
+          introduced by J&#xf6;rg Schilling's <a
+          href="http://developer.berlios.de/projects/star">star</a>
+          and later adopted by GNU and BSD tar.  This method is not
+          supported by all implementations.</li>
+          <li><code>BIGNUMBER_POSIX</code>: use a PAX <a
+          href="http://pubs.opengroup.org/onlinepubs/009695399/utilities/pax.html#tag_04_100_13_03">extended
+          header</a> as defined by POSIX 1003.1.  Most modern tar
+          implementations are able to extract such archives.</li>
+        </ul>
+        <p>Starting with Commons Compress 1.4
+        <code>TarArchiveInputStream</code> will recognize the star as
+        well as the POSIX extensions for big numeric values and reads them
+        transparently.</p>
+      </subsection>
+      <subsection name="File Name Encoding">
+        <p>The original ustar format only supports 7-Bit ASCII file
+        names, later implementations use the platform's default
+        encoding to encode file names.  The POSIX standard recommends
+        using PAX extension headers for non-ASCII file names
+        instead.</p>
+        <p>Commons Compress 1.1 to 1.3 assumed file names would be
+        encoded using ISO-8859-1.  Starting with Commons Compress 1.4
+        you can specify the encoding to expect (to use when writing)
+        as a parameter to <code>TarArchiveInputStream</code>
+        (<code>TarArchiveOutputStream</code>), it now defaults to the
+        platform's default encoding.</p>
+        <p>Since Commons Compress 1.4 another optional parameter -
+        <code>addPaxHeadersForNonAsciiNames</code> - of
+        <code>TarArchiveOutputStream</code> controls whether PAX
+        extension headers will be written for non-ASCII file names.
+        By default they will not be written to preserve space.
+        <code>TarArchiveInputStream</code> will read them
+        transparently if present.</p>
+      </subsection>
+      <subsection name="Sparse files">
+        <p>Prior to Commons Compress 1.20 <code>TarArchiveInputStream</code> would recognize sparse
+        file entries stored using the "oldgnu" format
+        (<code>-&#x2d;sparse-version=0.0</code> in GNU tar) but not
+        able to extract them correctly. Starting with Commons Compress 1.20
+        all GNU and POSIX variants of sparse files are recognized and
+        can be read.</p>
+      </subsection>
+      <subsection name="Consuming Archives Completely">
+        <p>The end of a tar archive is signaled by two consecutive
+        records of all zeros.  Unfortunately not all tar
+        implementations adhere to this and some only write one record
+        to end the archive.  Commons Compress will always write two
+        records but stop reading an archive as soon as finds one
+        record of all zeros.</p>
+        <p>Prior to version 1.5 this could leave the second EOF record
+        inside the stream when <code>getNextEntry</code> or
+        <code>getNextTarEntry</code> returned <code>null</code>
+        Starting with version 1.5 <code>TarArchiveInputStream</code>
+        will try to read a second record as well if present,
+        effectively consuming the archive completely.</p>
+      </subsection>
+      <subsection name="PAX Extended Header">
+        <p>The tar package has supported reading PAX extended headers
+        since 1.3 for local headers and 1.11 for global headers. The
+        following entries of PAX headers are applied when reading:</p>
+        <dl>
+          <dt>path</dt>
+          <dd>set the entry's name</dd>
+          <dt>linkpath</dt>
+          <dd>set the entry's link name</dd>
+          <dt>gid</dt>
+          <dd>set the entry's group id</dd>
+          <dt>gname</dt>
+          <dd>set the entry's group name</dd>
+          <dt>uid</dt>
+          <dd>set the entry's user id</dd>
+          <dt>uname</dt>
+          <dd>set the entry's user name</dd>
+          <dt>size</dt>
+          <dd>set the entry's size</dd>
+          <dt>mtime</dt>
+          <dd>set the entry's modification time</dd>
+          <dt>SCHILY.devminor</dt>
+          <dd>set the entry's minor device number</dd>
+          <dt>SCHILY.devmajor</dt>
+          <dd>set the entry's major device number</dd>
+        </dl>
+        <p>in addition some fields used by GNU tar and star used to
+        signal sparse entries are supported and are used for the
+        <code>is*GNUSparse</code> and <code>isStarSparse</code>
+        methods.</p>
+        <p>Some PAX extra headers may be set when writing archives,
+        for example for non-ASCII names or big numeric values. This
+        depends on various setting of the output stream - see the
+        previous sections.</p>
+        <p>Since 1.15 you can directly access all PAX extension
+        headers that have been found when reading an entry or specify
+        extra headers to be written to a (local) PAX extended header
+        entry.</p>
+        <p>Some hints if you try to set extended headers:</p>
+        <ul>
+          <li>pax header keywords should be ascii.  star/gnutar
+          (SCHILY.xattr.* ) do not check for this.  libarchive/bsdtar
+          (LIBARCHIVE.xattr.*) uses URL-Encoding.</li>
+          <li>pax header values should be encoded as UTF-8 characters
+          (including trailing <code>\0</code>).  star/gnutar
+          (SCHILY.xattr.*) do not check for this.  libarchive/bsdtar
+          (LIBARCHIVE.xattr.*) encode values using Base64.</li>
+          <li>libarchive/bsdtar will read SCHILY.xattr headers, but
+          will not generate them.</li>
+          <li>gnutar will complain about LIBARCHIVE.xattr (and any
+          other unknown) headers and will neither encode nor decode
+          them.</li>
+        </ul>
+      </subsection>
+      <subsection name="Random Access">
+        <p>Starting with Commons Compress 1.21 the tar package
+        contains a <code>TarFile</code> class that provides random
+        access to archives. Except for the ability to access entries
+        out of order <code>TarFile</code> is not superior to
+        <code>TarArchiveInputStream</code>.</p>
+      </subsection>
+    </section>
+  </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/site/xdoc/zip.xml ADDED Viewed

	@@ -0,0 +1,645 @@

+<?xml version="1.0"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+-->
+<document xmlns="http://maven.apache.org/XDOC/2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
+  <properties>
+    <title>Commons Compress ZIP package</title>
+    <author email="dev@commons.apache.org">Apache Commons Team</author>
+  </properties>
+  <body>
+    <section name="The ZIP package">
+      <p>The ZIP package provides features not found
+        in <code>java.util.zip</code>:</p>
+      <ul>
+        <li>Support for encodings other than UTF-8 for filenames and
+          comments.  Starting with Java7 this is supported
+          by <code>java.util.zip</code> as well.</li>
+        <li>Access to internal and external attributes (which are used
+          to store Unix permission by some zip implementations).</li>
+        <li>Structured support for extra fields.</li>
+      </ul>
+      <p>In addition to the information stored
+        in <code>ArchiveEntry</code> a <code>ZipArchiveEntry</code>
+        stores internal and external attributes as well as extra
+        fields which may contain information like Unix permissions,
+        information about the platform they've been created on, their
+        last modification time and an optional comment.</p>
+      <subsection name="ZipArchiveInputStream vs ZipFile">
+        <p>ZIP archives store a archive entries in sequence and
+          contain a registry of all entries at the very end of the
+          archive.  It is acceptable for an archive to contain several
+          entries of the same name and have the registry (called the
+          central directory) decide which entry is actually to be used
+          (if any).</p>
+        <p>In addition the ZIP format stores certain information only
+          inside the central directory but not together with the entry
+          itself, this is:</p>
+        <ul>
+          <li>internal and external attributes</li>
+          <li>different or additional extra fields</li>
+        </ul>
+        <p>This means the ZIP format cannot really be parsed
+          correctly while reading a non-seekable stream, which is what
+          <code>ZipArchiveInputStream</code> is forced to do.  As a
+          result <code>ZipArchiveInputStream</code></p>
+        <ul>
+          <li>may return entries that are not part of the central
+            directory at all and shouldn't be considered part of the
+            archive.</li>
+          <li>may return several entries with the same name.</li>
+          <li>will not return internal or external attributes.</li>
+          <li>may return incomplete extra field data.</li>
+          <li>may return unknown sizes and CRC values for entries
+          until the next entry has been reached if the archive uses
+          the data descriptor feature (see below).</li>
+          <li>can not skip over bytes that occur before the real zip
+          stream. This means self-extracting zips as they are created
+          by some tools can not be read using
+          <code>ZipArchiveInputStream</code> at all. This also applies
+          to Chrome extension archives, for example.</li>
+        </ul>
+        <p><code>ZipArchiveInputStream</code> shares these limitations
+          with <code>java.util.zip.ZipInputStream</code>.</p>
+        <p><code>ZipFile</code> is able to read the central directory
+          first and provide correct and complete information on any
+          ZIP archive.</p>
+        <p>ZIP archives know a feature called the data descriptor
+          which is a way to store an entry's length after the entry's
+          data.  This can only work reliably if the size information
+          can be taken from the central directory or the data itself
+          can signal it is complete, which is true for data that is
+          compressed using the DEFLATED compression algorithm.</p>
+        <p><code>ZipFile</code> has access to the central directory
+          and can extract entries using the data descriptor reliably.
+          The same is true for <code>ZipArchiveInputStream</code> as
+          long as the entry is DEFLATED.  For STORED
+          entries <code>ZipArchiveInputStream</code> can try to read
+          ahead until it finds the next entry, but this approach is
+          not safe and has to be enabled by a constructor argument
+          explicitly. For example it will completely fail if the
+          stored entry is a ZIP archive itself.  Starting with Compress 1.19
+          <code>ZipArchiveInputStream</code> will perform a few sanity
+          checks for STORED entries with data descriptors and throw an
+          exception if they fail.</p>
+        <p>If possible, you should <strong>always</strong> prefer <code>ZipFile</code>
+          over <code>ZipArchiveInputStream</code>.</p>
+        <p><code>ZipFile</code> requires a
+        <code>SeekableByteChannel</code> that will be obtained
+        transparently when reading from a file. The class
+        <code>org.apache.commons.compress.utils.SeekableInMemoryByteChannel</code>
+        allows you to read from an in-memory archive.</p>
+      </subsection>
+      <subsection name="ZipArchiveOutputStream" id="ZipArchiveOutputStream">
+        <p><code>ZipArchiveOutputStream</code> has four constructors,
+        two of them uses a <code>File</code> argument, one a
+        <code>SeekableByteChannel</code> and the last uses an
+        <code>OutputStream</code>.</p>
+        <p>The constructor accepting a <code>File</code> and a size is
+        used exclusively for creating a split ZIP archive and is
+        described in the next section. For the remainder of this
+        section this constructor is equivalent to the one using the
+        <code>OutputStream</code> argument and thus it is not possible
+        to add uncompressed entries of unknown size.</p>
+        <p>Of the remaining three constructors the <code>File</code> version will
+        try to use <code>SeekableByteChannel</code> and fall back to
+        using a <code>FileOutputStream</code> internally if that
+        fails.</p>
+        <p>If <code>ZipArchiveOutputStream</code> can
+          use <code>SeekableByteChannel</code> it can employ some
+          optimizations that lead to smaller archives.  It also makes
+          it possible to add uncompressed (<code>setMethod</code> used
+          with <code>STORED</code>) entries of unknown size when
+          calling <code>putArchiveEntry</code> - this is not allowed
+          if <code>ZipArchiveOutputStream</code> has to use
+          an <code>OutputStream</code>.</p>
+        <p>If you know you are writing to a file, you should always
+        prefer the <code>File</code>- or
+        <code>SeekableByteChannel</code>-arg constructors.  The class
+        <code>org.apache.commons.compress.utils.SeekableInMemoryByteChannel</code>
+        allows you to write to an in-memory archive.</p>
+      </subsection>
+      <subsection name="Multi Volume Archives">
+        <p>The ZIP format knows so called split and spanned
+        archives. Spanned archives cross several removable media and
+        are not supported by Commons Compress.</p>
+        <p>Split archives consist of multiple files that reside in the
+        same directory with the same base name (the file name without
+        the file extension). The last file of the archive has the
+        extension <code>zip</code> the remaining files conventionally
+        use extensions <code>z01</code>, <code>z02</code> and so
+        on. Support for splitted archives has been added with Compress
+        1.20.</p>
+        <p>If you want to create a split ZIP archive you use the
+        constructor of <code>ZipArchiveOutputStream</code> that
+        accepts a <code>File</code> argument and a size. The size
+        determines the maximum size of a split segment - the size must
+        be between 64kB and 4GB. While creating the archive, this will
+        create several files following the naming convention described
+        above. The name of the <code>File</code> argument used inside
+        of the constructor must use the extension
+        <code>zip</code>.</p>
+        <p>It is currently not possible to write split archives with
+        more than 64k segments. When creating split archives with more
+        than 100 segments you will need to adjust the file names as
+        <code>ZipArchiveOutputStream</code> assumes extensions will be
+        three characters long.</p>
+        <p>If you want to read a split archive you must create a
+        <code>ZipSplitReadOnlySeekableByteChannel</code> from the
+        parts. Both <code>ZipFile</code> and
+        <code>ZipArchiveInputStream</code> support reading streams of
+        this type, in the case of <code>ZipArchiveInputStream</code>
+        you need to use a constructor where you can set
+        <code>skipSplitSig</code> to true.</p>
+      </subsection>
+      <subsection name="Extra Fields">
+        <p>Inside a ZIP archive, additional data can be attached to
+          each entry.  The <code>java.util.zip.ZipEntry</code> class
+          provides access to this via the <code>get/setExtra</code>
+          methods as arrays of <code>byte</code>s.</p>
+        <p>Actually the extra data is supposed to be more structured
+          than that and Compress' ZIP package provides access to the
+          structured data as <code>ZipExtraField</code> instances.  Only
+          a subset of all defined extra field formats is supported by
+          the package, any other extra field will be stored
+          as <code>UnrecognizedExtraField</code>.</p>
+        <p>Prior to version 1.1 of this library trying to read an
+          archive with extra fields that didn't follow the recommended
+          structure for those fields would cause Compress to throw an
+          exception.  Starting with version 1.1 these extra fields
+          will now be read
+          as <code>UnparseableExtraFieldData</code>.</p>
+        <p>Prior to version 1.19 of this library trying to read an
+          archive with extra fields that Compress expects to
+          understand but that used a different content than expected
+          would cause Compress to throw an exception.  Starting with
+          version 1.19 these extra fields will now be read as
+          <code>UnrecognizedExtraField</code>. Using
+          <code>ZipArchiveEntry.getExtraFields(ExtraFieldParsingBehavior)</code>
+          you have a more fine grained control over the parser.</p>
+      </subsection>
+      <subsection name="Encoding" id="encoding">
+        <p>Traditionally the ZIP archive format uses CodePage 437 as
+          encoding for file name, which is not sufficient for many
+          international character sets.</p>
+        <p>Over time different archivers have chosen different ways to
+          work around the limitation - the <code>java.util.zip</code>
+          packages simply uses UTF-8 as its encoding for example.</p>
+        <p>Ant has been offering the encoding attribute of the zip and
+          unzip task as a way to explicitly specify the encoding to
+          use (or expect) since Ant 1.4.  It defaults to the
+          platform's default encoding for zip and UTF-8 for jar and
+          other jar-like tasks (war, ear, ...) as well as the unzip
+          family of tasks.</p>
+        <p>More recent versions of the ZIP specification introduce
+          something called the &quot;language encoding flag&quot;
+          which can be used to signal that a file name has been
+          encoded using UTF-8.  All ZIP-archives written by Compress
+          will set this flag, if the encoding has been set to UTF-8.
+          Our interoperability tests with existing archivers didn't
+          show any ill effects (in fact, most archivers ignore the
+          flag to date), but you can turn off the "language encoding
+          flag" by setting the attribute
+          <code>useLanguageEncodingFlag</code> to <code>false</code> on the
+          <code>ZipArchiveOutputStream</code> if you should encounter
+          problems.</p>
+        <p>The <code>ZipFile</code>
+          and <code>ZipArchiveInputStream</code> classes will
+          recognize the language encoding flag and ignore the encoding
+          set in the constructor if it has been found.</p>
+        <p>The InfoZIP developers have introduced new ZIP extra fields
+          that can be used to add an additional UTF-8 encoded file
+          name to the entry's metadata.  Most archivers ignore these
+          extra fields.  <code>ZipArchiveOutputStream</code> supports
+          an option <code>createUnicodeExtraFields</code> which makes
+          it write these extra fields either for all entries
+          ("always") or only those whose name cannot be encoded using
+          the specified encoding (not-encodable), it defaults to
+          "never" since the extra fields create bigger archives.</p>
+        <p>The fallbackToUTF8 attribute
+          of <code>ZipArchiveOutputStream</code> can be used to create
+          archives that use the specified encoding in the majority of
+          cases but UTF-8 and the language encoding flag for filenames
+          that cannot be encoded using the specified encoding.</p>
+        <p>The <code>ZipFile</code>
+          and <code>ZipArchiveInputStream</code> classes recognize the
+          Unicode extra fields by default and read the file name
+          information from them, unless you set the constructor parameter
+          <code>scanForUnicodeExtraFields</code> to false.</p>
+        <h4>Recommendations for Interoperability</h4>
+        <p>The optimal setting of flags depends on the archivers you
+          expect as consumers/producers of the ZIP archives.  Below
+          are some test results which may be superseded with later
+          versions of each tool.</p>
+        <ul>
+          <li>The java.util.zip package used by the jar executable or
+            to read jars from your CLASSPATH reads and writes UTF-8
+            names, it doesn't set or recognize any flags or Unicode
+            extra fields.</li>
+          <li>Starting with Java7 <code>java.util.zip</code> writes
+            UTF-8 by default and uses the language encoding flag.  It
+            is possible to specify a different encoding when
+            reading/writing ZIPs via new constructors.  The package
+            now recognizes the language encoding flag when reading and
+            ignores the Unicode extra fields.</li>
+          <li>7Zip writes CodePage 437 by default but uses UTF-8 and
+            the language encoding flag when writing entries that
+            cannot be encoded as CodePage 437 (similar to the zip task
+            with fallbacktoUTF8 set to true).  It recognizes the
+            language encoding flag when reading and ignores the
+            Unicode extra fields.</li>
+          <li>WinZIP writes CodePage 437 and uses Unicode extra fields
+            by default.  It recognizes the Unicode extra field and the
+            language encoding flag when reading.</li>
+          <li>Windows' "compressed folder" feature doesn't recognize
+            any flag or extra field and creates archives using the
+            platforms default encoding - and expects archives to be in
+            that encoding when reading them.</li>
+          <li>InfoZIP based tools can recognize and write both, it is
+            a compile time option and depends on the platform so your
+            mileage may vary.</li>
+          <li>PKWARE zip tools recognize both and prefer the language
+            encoding flag.  They create archives using CodePage 437 if
+            possible and UTF-8 plus the language encoding flag for
+            file names that cannot be encoded as CodePage 437.</li>
+        </ul>
+        <p>So, what to do?</p>
+        <p>If you are creating jars, then java.util.zip is your main
+          consumer.  We recommend you set the encoding to UTF-8 and
+          keep the language encoding flag enabled.  The flag won't
+          help or hurt java.util.zip prior to Java7 but archivers that
+          support it will show the correct file names.</p>
+        <p>For maximum interop it is probably best to set the encoding
+          to UTF-8, enable the language encoding flag and create
+          Unicode extra fields when writing ZIPs.  Such archives
+          should be extracted correctly by java.util.zip, 7Zip,
+          WinZIP, PKWARE tools and most likely InfoZIP tools.  They
+          will be unusable with Windows' "compressed folders" feature
+          and bigger than archives without the Unicode extra fields,
+          though.</p>
+        <p>If Windows' "compressed folders" is your primary consumer,
+          then your best option is to explicitly set the encoding to
+          the target platform.  You may want to enable creation of
+          Unicode extra fields so the tools that support them will
+          extract the file names correctly.</p>
+      </subsection>
+      <subsection name="Encryption and Alternative Compression Algorithms"
+                  id="encryption">
+        <p>In most cases entries of an archive are not encrypted and
+        are either not compressed at all or use the DEFLATE
+        algorithm, Commons Compress' ZIP archiver will handle them
+        just fine.   As of version 1.7, Commons Compress can also
+        decompress entries compressed with the legacy SHRINK and
+        IMPLODE algorithms of PKZIP 1.x.  Version 1.11 of Commons
+        Compress adds read-only support for BZIP2.  Version 1.16 adds
+        read-only support for DEFLATE64 - also known as "enhanced DEFLATE".</p>
+        <p>The ZIP specification allows for various other compression
+        algorithms and also supports several different ways of
+        encrypting archive contents.  Neither of those methods is
+        currently supported by Commons Compress and any such entry can
+        not be extracted by the archiving code.</p>
+        <p><code>ZipFile</code>'s and
+        <code>ZipArchiveInputStream</code>'s
+        <code>canReadEntryData</code> methods will return false for
+        encrypted entries or entries using an unsupported encryption
+        mechanism.  Using this method it is possible to at least
+        detect and skip the entries that can not be extracted.</p>
+        <table>
+          <thead>
+            <tr>
+              <th>Version of Apache Commons Compress</th>
+              <th>Supported Compression Methods</th>
+              <th>Supported Encryption Methods</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>1.0 to 1.6</td>
+              <td>STORED, DEFLATE</td>
+              <td>-</td>
+            </tr>
+            <tr>
+              <td>1.7 to 1.10</td>
+              <td>STORED, DEFLATE, SHRINK, IMPLODE</td>
+              <td>-</td>
+            </tr>
+            <tr>
+              <td>1.11 to 1.15</td>
+              <td>STORED, DEFLATE, SHRINK, IMPLODE, BZIP2</td>
+              <td>-</td>
+            </tr>
+            <tr>
+              <td>1.16 and later</td>
+              <td>STORED, DEFLATE, SHRINK, IMPLODE, BZIP2, DEFLATE64
+              (enhanced deflate)</td>
+              <td>-</td>
+            </tr>
+          </tbody>
+        </table>
+      </subsection>
+      <subsection name="Zip64 Support" id="zip64">
+        <p>The traditional ZIP format is limited to archive sizes of
+          four gibibyte (actually 2<sup>32</sup> - 1 bytes &#x2248;
+          4.3 GB) and 65635 entries, where each individual entry is
+          limited to four gibibyte as well.  These limits seemed
+          excessive in the 1980s.</p>
+        <p>Version 4.5 of the ZIP specification introduced the so
+          called "Zip64 extensions" to push those limitations for
+          compressed or uncompressed sizes of up to 16 exbibyte
+          (actually 2<sup>64</sup> - 1 bytes &#x2248; 18.5 EB, i.e
+          18.5 x 10<sup>18</sup> bytes) in archives that themselves
+          can take up to 16 exbibyte containing more than
+          18 x 10<sup>18</sup> entries.</p>
+        <p>Apache Commons Compress 1.2 and earlier do not support
+          Zip64 extensions at all.</p>
+        <p>Starting with Apache Commons Compress
+          1.3 <code>ZipArchiveInputStream</code>
+          and <code>ZipFile</code> transparently support Zip64
+          extensions.  By default <code>ZipArchiveOutputStream</code>
+          supports them transparently as well (i.e. it adds Zip64
+          extensions if needed and doesn't use them for
+          entries/archives that don't need them) if the compressed and
+          uncompressed sizes of the entry are known
+          when <code>putArchiveEntry</code> is called
+          or <code>ZipArchiveOutputStream</code>
+          uses <code>SeekableByteChannel</code>
+          (see <a href="#ZipArchiveOutputStream">above</a>).  If only
+          the uncompressed size is
+          known <code>ZipArchiveOutputStream</code> will assume the
+          compressed size will not be bigger than the uncompressed
+          size.</p>
+        <p><code>ZipArchiveOutputStream</code>'s
+          <code>setUseZip64</code> can be used to control the behavior.
+          <code>Zip64Mode.AsNeeded</code> is the default behavior
+          described in the previous paragraph.</p>
+        <p>If <code>ZipArchiveOutputStream</code> is writing to a
+          non-seekable stream it has to decide whether to use Zip64
+          extensions or not before it starts writing the entry data.
+          This means that if the size of the entry is unknown
+          when <code>putArchiveEntry</code> is called it doesn't have
+          anything to base the decision on.  By default it will not
+          use Zip64 extensions in order to create archives that can be
+          extracted by older archivers (it will later throw an
+          exception in <code>closeEntry</code> if it detects Zip64
+          extensions had been needed).  It is possible to
+          instruct <code>ZipArchiveOutputStream</code> to always
+          create Zip64 extensions by using
+          the <code>setUseZip64</code> with an argument
+          of <code>Zip64Mode.Always</code>; use this if you are
+          writing entries of unknown size to a stream and expect some
+          of them to be too big to fit into the traditional
+          limits.</p>
+        <p><code>Zip64Mode.Always</code> creates archives that use
+          Zip64 extensions for all entries, even those that don't
+          require them.  Such archives will be slightly bigger than
+          archives created with one of the other modes and not be
+          readable by unarchivers that don't support Zip64
+          extensions.</p>
+        <p><code>Zip64Mode.Never</code> will not use any Zip64
+          extensions at all and may lead to
+          a <code>Zip64RequiredException</code> to be thrown
+          if <code>ZipArchiveOutputStream</code> detects that one of
+          the format's limits is exceeded.  Archives created in this
+          mode will be readable by all unarchivers; they may be
+          slightly smaller than archives created
+          with <code>SeekableByteChannel</code>
+          in <code>Zip64Mode.AsNeeded</code> mode if some of the
+          entries had unknown sizes.</p>
+        <p>The <code>java.util.zip</code> package and the
+          <code>jar</code> command of Java5 and earlier can not read
+          Zip64 extensions and will fail if the archive contains any.
+          So if you intend to create archives that Java5 can consume
+          you must set the mode to <code>Zip64Mode.Never</code></p>
+        <h4>Known Limitations</h4>
+        <p>Some of the theoretical limits of the format are not
+          reached because Apache Commons Compress' own API
+          (<code>ArchiveEntry</code>'s size information uses
+          a <code>long</code>) or its usage of Java collections
+          or <code>SeekableByteChannel</code> internally.  The table
+          below shows the theoretical limits supported by Apache
+          Commons Compress.  In practice it is very likely that you'd
+          run out of memory or your file system won't allow files that
+          big long before you reach either limit.</p>
+        <table>
+          <thead>
+            <tr>
+              <th/>
+              <th>Max. Size of Archive</th>
+              <th>Max. Compressed/Uncompressed Size of Entry</th>
+              <th>Max. Number of Entries</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>ZIP Format Without Zip 64 Extensions</td>
+              <td>2<sup>32</sup> - 1 bytes &#x2248; 4.3 GB</td>
+              <td>2<sup>32</sup> - 1 bytes &#x2248; 4.3 GB</td>
+              <td>65535</td>
+            </tr>
+            <tr>
+              <td>ZIP Format using Zip 64 Extensions</td>
+              <td>2<sup>64</sup> - 1 bytes &#x2248; 18.5 EB</td>
+              <td>2<sup>64</sup> - 1 bytes &#x2248; 18.5 EB</td>
+              <td>2<sup>64</sup> - 1 &#x2248; 18.5 x 10<sup>18</sup></td>
+            </tr>
+            <tr>
+              <td>Commons Compress 1.2 and earlier</td>
+              <td>unlimited in <code>ZipArchiveInputStream</code>
+                and <code>ZipArchiveOutputStream</code> and
+                2<sup>32</sup> - 1 bytes &#x2248; 4.3 GB
+                in <code>ZipFile</code>.</td>
+              <td>2<sup>32</sup> - 1 bytes &#x2248; 4.3 GB</td>
+              <td>unlimited in <code>ZipArchiveInputStream</code>,
+                65535 in <code>ZipArchiveOutputStream</code>
+                and <code>ZipFile</code>.</td>
+            </tr>
+            <tr>
+              <td>Commons Compress 1.3 and later</td>
+              <td>unlimited in <code>ZipArchiveInputStream</code>
+                and <code>ZipArchiveOutputStream</code> and
+                2<sup>63</sup> - 1 bytes &#x2248; 9.2 EB
+                in <code>ZipFile</code>.</td>
+              <td>2<sup>63</sup> - 1 bytes &#x2248; 9.2 EB</td>
+              <td>unlimited in <code>ZipArchiveInputStream</code>,
+                2<sup>31</sup> - 1 &#x2248; 2.1 billion
+                in <code>ZipArchiveOutputStream</code>
+                and <code>ZipFile</code>.</td>
+            </tr>
+          </tbody>
+        </table>
+        <h4>Known Interoperability Problems</h4>
+        <p>The <code>java.util.zip</code> package of OpenJDK7 supports
+        Zip 64 extensions but its <code>ZipInputStream</code> and
+        <code>ZipFile</code> classes will be unable to extract
+        archives created with Commons Compress 1.3's
+        <code>ZipArchiveOutputStream</code> if the archive contains
+        entries that use the data descriptor, are smaller than 4 GiB
+        and have Zip 64 extensions enabled.  I.e. the classes in
+        OpenJDK currently only support archives that use Zip 64
+        extensions only when they are actually needed.  These classes
+        are used to load JAR files and are the base for the
+        <code>jar</code> command line utility as well.</p>
+      </subsection>
+      <subsection name="Consuming Archives Completely">
+        <p>Prior to version 1.5 <code>ZipArchiveInputStream</code>
+        would return null from <code>getNextEntry</code> or
+        <code>getNextZipEntry</code> as soon as the first central
+        directory header of the archive was found, leaving the whole
+        central directory itself unread inside the stream.  Starting
+        with version 1.5 <code>ZipArchiveInputStream</code> will try
+        to read the archive up to and including the "end of central
+        directory" record effectively consuming the archive
+        completely.</p>
+      </subsection>
+      <subsection name="Symbolic Links" id="symlinks">
+        <p>Starting with Compress 1.5 <code>ZipArchiveEntry</code>
+        recognizes Unix Symbolic Link entries written by InfoZIP's
+        zip.</p>
+        <p>The <code>ZipFile</code> class contains a convenience
+        method to read the link name of an entry.  Basically all it
+        does is read the contents of the entry and convert it to
+        a string using the given file name encoding of the
+        archive.</p>
+      </subsection>
+      <subsection name="Parallel zip creation" id="parallel">
+        <p>Starting with Compress 1.10 there is now built-in support for
+          parallel creation of zip archives</p>
+          <p>Multiple threads can write
+          to their own <code>ScatterZipOutputStream</code>
+          instance that is backed to file or to some user-implemented form of
+          storage (implementing <code>ScatterGatherBackingStore</code>).</p>
+          <p>When the threads finish, they can join these streams together
+          to a complete zip file using the <code>writeTo</code> method
+          that will write a single <code>ScatterOutputStream</code> to a target
+          <code>ZipArchiveOutputStream</code>.</p>
+          <p>To assist this process, clients can use
+          <code>ParallelScatterZipCreator</code> that will handle threads
+          pools and correct memory model consistency so the client
+          can avoid these issues.</p>
+          <p>Until version 1.18, there was no guarantee of order of the entries when writing a Zip
+          file with <code>ParallelScatterZipCreator</code>.  In consequence, when writing well-formed
+          Zip files this way, it was usually necessary to keep a
+          separate <code>ScatterZipOutputStream</code> that received all directories
+          and wrote this to the target <code>ZipArchiveOutputStream</code> before
+          the ones created through <code>ParallelScatterZipCreator</code>. This was the responsibility of the client.</p>
+          <p>Starting with version 1.19, entries order is kept, then this specific handling of directories is not
+          necessary any more.</p>
+          <p>
+            See the examples section for a code sample demonstrating how to make a zip file.
+          </p>
+      </subsection>
+      <subsection name="Zstandard Support" id="zstd">
+        <p>
+          Starting with Compress 1.28.0, <code>org.apache.commons.compress.archivers.zip</code> supports reading and writing using the Zstandard method.
+          Zstandard method <code>93</code> and the deprecated <code>20</code>  are supported.
+        </p>
+      </subsection>
+    </section>
+  </body>
+</document>

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-379.jar ADDED Viewed

Binary file (222 Bytes). View file

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-382 ADDED Viewed

Binary file (19 Bytes). View file

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-386 ADDED Viewed

	@@ -0,0 +1 @@


1	+ �B

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/bla-multi.7z.001 ADDED Viewed

Binary file (512 Bytes). View file

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/test1.xml ADDED Viewed

	@@ -0,0 +1,4 @@

+<?xml version = '1.0'?>
+<!DOCTYPE connections>
+<connections>
+</connections>

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/test3.xml ADDED Viewed

	@@ -0,0 +1,10 @@

+<?xml version = '1.0'?>
+<!DOCTYPE connections>
+<text>
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
+sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat,
+sed diam voluptua.
+At vero eos et accusam et justo duo dolores et ea rebum.
+Stet clita kasd gubergren, no sea takimata sanctus est
+Lorem ipsum dolor sit amet.
+</text>