Enable ArchiveStartOffset for nested archive subfiles

Introduced the ability to specify how the start of an archive should be located when opening a subfile that is itself an archive. This allows using `ArchiveStartOffset::None` to search for the archive header within the subfile's stream, providing greater flexibility for handling nested archives.

Author: rikyoz

include/bit7z/bitarchivereader.hpp

@@ -212,21 +212,65 @@ class BitArchiveReader final : public BitAbstractArchiveOpener, public BitInputA
             const tstring& password = {}
         );
 
+        /**
+         * @brief Constructs a BitArchiveReader object, opening the main subfile of the given archive.
+         *
+         * @note The constructor will throw an exception if the format of the input archive doesn't have a main subfile.
+         *
+         * @param lib           the 7z library used.
+         * @param inArchive     the input archive containing a main subfile.
+         * @param archiveStart  whether to search for the archive's start throughout the entire subfile stream
+         *                      or only at the beginning.
+         * @param format        the format of the main subfile.
+         * @param password      (optional) the password needed for opening the main subfile.
+         *
+         * @throws BitException if the format of the input archive doesn't have a main subfile.
+         */
+        BitArchiveReader(
+            const Bit7zLibrary& lib,
+            const BitInputArchive& inArchive,
+            ArchiveStartOffset archiveStart,
+            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
+            const tstring& password = {}
+        );
+
+        /**
+         * @brief Constructs a BitArchiveReader object, opening the subfile at the specified index of the given archive.
+         *
+         * @param lib           the 7z library used.
+         * @param inArchive     the input archive containing the desired subfile.
+         * @param subfileIndex  the index of the subfile within the input archive.
+         * @param format        the format of the subfile.
+         * @param password      (optional) the password needed for opening the subfile.
+         *
+         * @throws BitException if the format of the input archive doesn't support subfile streams.
+         */
+        BitArchiveReader(
+            const Bit7zLibrary& lib,
+            const BitInputArchive& inArchive,
+            std::uint32_t subfileIndex,
+            const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
+            const tstring& password = {}
+        );
+
         /**
          * @brief Constructs a BitArchiveReader object, opening the subfile at the specified index of the given archive.
          *
          * @param lib           the 7z library used.
          * @param inArchive     the input archive containing the desired subfile.
          * @param subfileIndex  the index of the subfile within the input archive.
+         * @param archiveStart  whether to search for the archive's start throughout the entire subfile stream
+         *                      or only at the beginning.
          * @param format        the format of the subfile.
          * @param password      (optional) the password needed for opening the subfile.
          *
-         * @throws BitException if the format of the input archive doesn't support subfile streams,
+         * @throws BitException if the format of the input archive doesn't support subfile streams.
          */
         BitArchiveReader(
             const Bit7zLibrary& lib,
             const BitInputArchive& inArchive,
             std::uint32_t subfileIndex,
+            ArchiveStartOffset archiveStart,
             const BitInFormat& format BIT7Z_DEFAULT_FORMAT,
             const tstring& password = {}
         );

include/bit7z/bitinputarchive.hpp

@@ -669,12 +669,11 @@ class BitInputArchive {
         BIT7Z_NODISCARD auto mainSubfileIndex() const -> std::uint32_t;
 
     protected:
-        explicit BitInputArchive( const BitAbstractArchiveHandler& handler, const BitInputArchive& parentArchive );
-
         explicit BitInputArchive(
             const BitAbstractArchiveHandler& handler,
             const BitInputArchive& parentArchive,
-            std::uint32_t index
+            std::uint32_t subfileIndex,
+            ArchiveStartOffset archiveStart
         );
 
         BIT7Z_NODISCARD

src/bitarchivereader.cpp

@@ -84,15 +84,33 @@ BitArchiveReader::BitArchiveReader(
     const BitInputArchive& inArchive,
     const BitInFormat& format,
     const tstring& password
-) : BitAbstractArchiveOpener{ lib, format, password }, BitInputArchive{ *this, inArchive } {}
+) : BitArchiveReader{ lib, inArchive, ArchiveStartOffset::FileStart, format, password } {}
+
+BitArchiveReader::BitArchiveReader(
+    const Bit7zLibrary& lib,
+    const BitInputArchive& inArchive,
+    ArchiveStartOffset archiveStart,
+    const BitInFormat& format,
+    const tstring& password
+) : BitArchiveReader{ lib, inArchive, inArchive.mainSubfileIndex(), archiveStart, format, password } {}
 
 BitArchiveReader::BitArchiveReader(
     const Bit7zLibrary& lib,
     const BitInputArchive& inArchive,
     std::uint32_t subfileIndex,
     const BitInFormat& format,
     const tstring& password
-) : BitAbstractArchiveOpener{ lib, format, password }, BitInputArchive{ *this, inArchive, subfileIndex } {}
+) : BitArchiveReader{ lib, inArchive, subfileIndex, ArchiveStartOffset::FileStart, format, password } {}
+
+BitArchiveReader::BitArchiveReader(
+    const Bit7zLibrary& lib,
+    const BitInputArchive& inArchive,
+    std::uint32_t subfileIndex,
+    ArchiveStartOffset archiveStart,
+    const BitInFormat& format,
+    const tstring& password
+) : BitAbstractArchiveOpener{ lib, format, password },
+    BitInputArchive{ *this, inArchive, subfileIndex, archiveStart } {}
 
 auto BitArchiveReader::archiveProperties() const -> std::map< BitProperty, BitPropVariant > {
     std::map< BitProperty, BitPropVariant > result;

src/bitinputarchive.cpp

@@ -196,18 +196,16 @@ BitInputArchive::BitInputArchive( const BitAbstractArchiveHandler& handler, cons
     mInArchive = arc.Detach();
 }
 
-BitInputArchive::BitInputArchive( const BitAbstractArchiveHandler& handler, const BitInputArchive& parentArchive )
-    : BitInputArchive{ handler, parentArchive, parentArchive.mainSubfileIndex() } {}
-
 BitInputArchive::BitInputArchive(
     const BitAbstractArchiveHandler& handler,
     const BitInputArchive& parentArchive,
-    std::uint32_t index
+    std::uint32_t subfileIndex,
+    ArchiveStartOffset archiveStart
 ) : mDetectedFormat{ &handler.format() },
     mArchiveHandler{ handler },
-    mArchivePath{ parentArchive.itemAt( index ).path() } {
-    const CMyComPtr< IInStream > subStream = parentArchive.getSubfileStream( index );
-    mInArchive = openArchiveStream( fs::path{}, subStream, ArchiveStartOffset::FileStart );
+    mArchivePath{ parentArchive.itemAt( subfileIndex ).path() } {
+    const CMyComPtr< IInStream > subStream = parentArchive.getSubfileStream( subfileIndex );
+    mInArchive = openArchiveStream( fs::path{}, subStream, archiveStart );
 }
 
 auto BitInputArchive::archiveProperty( BitProperty property ) const -> BitPropVariant {

tests/src/test_bitinputarchive.cpp

@@ -2244,6 +2244,92 @@ TEMPLATE_TEST_CASE(
     }
 }
 
+// NOLINTNEXTLINE(*-err58-cpp)
+TEST_CASE(
+    "BitInputArchive: Reading the main subfile of an archive with a specified archive start offset",
+    "[bitinputarchive]"
+) {
+    const TestDirectory testDir{ fs::path{ test_archives_dir } / "extraction" / "split" };
+
+    // A split archive exposes its reassembled content as the main subfile; here that content is a 7z
+    // archive located at the start of the subfile stream, so it can be opened both by checking only
+    // the file start and by scanning the whole subfile stream.
+    const fs::path splitArcFileName = "clouds.jpg.7z.001";
+    const BitArchiveReader splitArchive( test::sevenzipLib(), splitArcFileName.string< tchar >(), BitFormat::Split );
+
+    const auto archiveStart = GENERATE( ArchiveStartOffset::FileStart, ArchiveStartOffset::None );
+
+    const BitArchiveReader innerArchive( test::sevenzipLib(), splitArchive, archiveStart, BitFormat::SevenZip );
+    REQUIRE( innerArchive.itemsCount() == singleFileContent().fileCount );
+    REQUIRE_ARCHIVE_TESTS( innerArchive );
+}
+
+// NOLINTNEXTLINE(*-err58-cpp)
+TEMPLATE_TEST_CASE(
+    "BitInputArchive: Reading a subfile by index of an archive with a specified archive start offset",
+    "[bitinputarchive]",
+    tstring,
+    buffer_t,
+    stream_t
+) {
+    const TestDirectory testDir{ fs::path{ test_archives_dir } / "extraction" / "nested" };
+
+    const fs::path arcFileName = "multiple_nested2.tar";
+
+    TestType inputArchive{};
+    getInputArchive( arcFileName, inputArchive );
+    const Bit7zLibrary lib{ test::sevenzipLibPath() };
+
+    // The outer Tar archive stores nested archives as its items; Tar supports retrieving each item's
+    // stream, which can then be opened as a nested archive at the specified archive start offset.
+    const BitArchiveReader outerArchive( lib, inputArchive, BitFormat::Tar );
+
+    const auto archiveStart = GENERATE( ArchiveStartOffset::FileStart, ArchiveStartOffset::None );
+
+    SECTION( "Opening the nested 7z subfile" ) {
+        const BitArchiveReader innerArchive( lib, outerArchive, 1U, archiveStart, BitFormat::SevenZip );
+        REQUIRE_NOTHROW( innerArchive.test() );
+    }
+
+    SECTION( "Opening the nested zip subfile" ) {
+        const BitArchiveReader innerArchive( lib, outerArchive, 2U, archiveStart, BitFormat::Zip );
+        REQUIRE_NOTHROW( innerArchive.test() );
+    }
+}
+
+// NOLINTNEXTLINE(*-err58-cpp)
+TEST_CASE(
+    "BitInputArchive: Reading a subfile whose archive data does not start at the subfile stream start",
+    "[bitinputarchive]"
+) {
+    const TestDirectory testDir{ fs::path{ test_archives_dir } / "extraction" / "nested" };
+
+    const fs::path arcFileName = "multiple_nested2.tar";
+
+    const Bit7zLibrary lib{ test::sevenzipLibPath() };
+
+    // TODO: Add some fixture archives with an embedded archive at a non-zero offset *within* a subfile stream.
+    // Until then, build one at runtime: an outer Tar whose only item is multiple_nested2.tar (itself a Tar
+    // holding a nested 7z). The Tar handler returns that item's bytes verbatim, so within the subfile stream
+    // the nested 7z starts well after offset 0 (which is just a Tar header).
+    // This way we can test a case where the two ArchiveStartOffset values behave differently, proving that
+    // FileStart restricts the scan.
+    buffer_t outerArchiveBuffer;
+    BitArchiveWriter writer{ lib, BitFormat::Tar };
+    writer.addFile( arcFileName.string< tchar >() );
+    writer.compressTo( outerArchiveBuffer );
+
+    const BitArchiveReader outerArchive( lib, outerArchiveBuffer, BitFormat::Tar );
+
+    // Scanning the whole subfile stream (None) finds the nested 7z archive, so the opening succeeds...
+    const BitArchiveReader innerArchive( lib, outerArchive, 0U, ArchiveStartOffset::None, BitFormat::SevenZip );
+    REQUIRE_NOTHROW( innerArchive.test() );
+
+    // ...while checking only the file start of the same subfile stream (FileStart) sees a Tar header
+    // instead of a 7z signature, so the opening must fail.
+    REQUIRE_THROWS( BitArchiveReader( lib, outerArchive, 0U, ArchiveStartOffset::FileStart, BitFormat::SevenZip ) );
+}
+
 // NOLINTNEXTLINE(*-err58-cpp)
 TEMPLATE_TEST_CASE(
     "BitInputArchive: Reading a nested archive with wrong extension",