@onekeyfe/react-native-range-downloader 3.0.81 → 3.0.82

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ReactNativeRangeDownloader.kt

@@ -2,12 +2,16 @@ package com.margelo.nitro.reactnativerangedownloader
 
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.nativelogger.OneKeyLog
 import java.io.File
 import java.security.MessageDigest
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 
 // P1: Nitro adapter for the Android concurrent multi-range downloader.
 //
@@ -33,6 +37,7 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
 
   private val listeners = CopyOnWriteArrayList<Listener>()
   private val nextListenerId = AtomicLong(1)
+  private val firmwareArtifactScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
   // Active downloads keyed by "channel|taskId" so cancel/discardArtifacts can
   // flip the abort flag + stop the worker pool BEFORE deleting files, instead of
@@ -265,6 +270,149 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
     return ctx.cacheDir.absolutePath
   }
 
+  override fun getFirmwareArtifactCapabilities(): FirmwareArtifactCapabilities {
+    return FirmwareArtifactCapabilities(
+      firmwareArtifactProtocolVersion = 4.0,
+      supportedRouteTypes = arrayOf("domain"),
+      supportsArchiveMaterialization = true,
+      maxReadBytes = FirmwareArtifactStore.MAX_READ_BYTES.toDouble(),
+    )
+  }
+
+  override fun downloadFirmwareArtifact(
+    params: FirmwareArtifactDownloadParams,
+  ): Promise<FirmwareArtifactReceipt> {
+    return Promise.async(firmwareArtifactScope) {
+      val artifact = FirmwareArtifactStore.download(params)
+      FirmwareArtifactReceipt(
+        artifactRef = artifact.artifactRef,
+        size = artifact.size.toDouble(),
+        sha256 = artifact.sha256,
+        expectedSha256Verified = params.expectedSha256 != null,
+      )
+    }
+  }
+
+  override fun cancelFirmwareArtifactDownloads(
+    params: FirmwareArtifactCancelParams,
+  ): Promise<Unit> {
+    return Promise.async(firmwareArtifactScope) {
+      FirmwareArtifactStore.cancelDownloads(params.transactionId)
+    }
+  }
+
+  override fun discardFirmwareArtifact(
+    params: FirmwareArtifactRefParams,
+  ): Promise<Unit> {
+    return Promise.async(firmwareArtifactScope) {
+      FirmwareArtifactStore.discard(params.artifactRef)
+    }
+  }
+
+  override fun openFirmwareArtifact(
+    params: FirmwareArtifactRefParams,
+  ): Promise<FirmwareArtifactReaderInfo> {
+    return Promise.async(firmwareArtifactScope) {
+      val (readerId, size) = FirmwareArtifactStore.open(params.artifactRef)
+      FirmwareArtifactReaderInfo(readerId = readerId, size = size.toDouble())
+    }
+  }
+
+  override fun readFirmwareArtifact(
+    params: FirmwareArtifactReaderReadParams,
+  ): Promise<ArrayBuffer> {
+    return Promise.async(firmwareArtifactScope) {
+      require(
+        params.offset.isFinite() &&
+          params.offset >= 0 &&
+          params.offset <= FirmwareArtifactStore.MAX_ARTIFACT_BYTES.toDouble() &&
+          params.offset.toLong().toDouble() == params.offset &&
+          params.length.isFinite() &&
+          params.length > 0 &&
+          params.length <= FirmwareArtifactStore.MAX_READ_BYTES.toDouble() &&
+          params.length.toInt().toDouble() == params.length
+      ) {
+        "Invalid firmware artifact read"
+      }
+      ArrayBuffer.copy(
+        FirmwareArtifactStore.read(
+          readerId = params.readerId,
+          offset = params.offset.toLong(),
+          length = params.length.toInt(),
+        ),
+      )
+    }
+  }
+
+  override fun closeFirmwareArtifact(
+    params: FirmwareArtifactReaderCloseParams,
+  ): Promise<Unit> {
+    return Promise.async(firmwareArtifactScope) {
+      FirmwareArtifactStore.close(params.readerId)
+    }
+  }
+
+  override fun materializeFirmwareArchive(
+    params: FirmwareArchiveMaterializeParams,
+  ): Promise<FirmwareArchiveMaterializeResult> {
+    return Promise.async(firmwareArtifactScope) {
+      val artifacts = FirmwareArtifactStore.materializeArchive(
+        params.leaseRef,
+        params.archiveArtifactRef,
+        params.expectedEntries,
+      )
+      FirmwareArchiveMaterializeResult(
+        artifacts = artifacts.map { entry ->
+          FirmwareArchiveMaterializedArtifact(
+            entryName = entry.entryName,
+            receipt = FirmwareArtifactReceipt(
+              artifactRef = entry.artifact.artifactRef,
+              size = entry.artifact.size.toDouble(),
+              sha256 = entry.artifact.sha256,
+              expectedSha256Verified = params.expectedEntries != null,
+            ),
+          )
+        }.toTypedArray(),
+      )
+    }
+  }
+
+  override fun createFirmwareArtifactLease(
+    params: FirmwareArtifactLeaseCreateParams,
+  ): Promise<FirmwareArtifactLease> {
+    return Promise.async(firmwareArtifactScope) {
+      FirmwareArtifactLease(
+        leaseRef = FirmwareArtifactStore.createLease(params.transactionId),
+      )
+    }
+  }
+
+  override fun retainFirmwareArtifact(
+    params: FirmwareArtifactLeaseRetainParams,
+  ): Promise<Unit> {
+    return Promise.async(firmwareArtifactScope) {
+      FirmwareArtifactStore.retain(params.leaseRef, params.artifactRef)
+    }
+  }
+
+  override fun releaseFirmwareArtifactLease(
+    params: FirmwareArtifactLeaseReleaseParams,
+  ): Promise<Unit> {
+    return Promise.async(firmwareArtifactScope) {
+      FirmwareArtifactStore.releaseLease(params.leaseRef, params.disposition)
+    }
+  }
+
+  override fun sweepFirmwareArtifactOrphans(): Promise<FirmwareArtifactSweepResult> {
+    return Promise.async(firmwareArtifactScope) {
+      val (deletedFiles, deletedBytes) = FirmwareArtifactStore.sweepOrphans()
+      FirmwareArtifactSweepResult(
+        deletedFiles = deletedFiles.toDouble(),
+        deletedBytes = deletedBytes.toDouble(),
+      )
+    }
+  }
+
   // Broadcast one event to every registered listener. Listeners filter by
   // channel/taskId on their side (shared registry, per the design).
   private fun sendEvent(

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArchiveRulesTest.kt

@@ -0,0 +1,114 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import java.io.File
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class FirmwareArchiveRulesTest {
+  @get:Rule
+  val temporaryFolder = TemporaryFolder()
+
+  private fun entry(
+    artifactId: String = "resource-entry",
+    entryName: String = "assets/icon.png",
+    expectedSize: Double = 128.0,
+    expectedSha256: String = "a".repeat(64),
+  ) = FirmwareArchiveExpectedEntry(
+    artifactId = artifactId,
+    entryName = entryName,
+    expectedSize = expectedSize,
+    expectedSha256 = expectedSha256,
+  )
+
+  @Test
+  fun acceptsAnExactPortableAllowlist() {
+    val requirements = FirmwareArchiveRules.validateRequirements(
+      arrayOf(
+        entry(),
+        entry(
+          artifactId = "resource-entry-2",
+          entryName = "assets/sub/icon-2.png",
+          expectedSha256 = "b".repeat(64),
+        ),
+      ),
+    )
+
+    assertEquals(2, requirements.size)
+  }
+
+  @Test
+  fun rejectsTraversalAndNestedArchives() {
+    for (entryName in listOf("../icon.png", "assets/../icon.png", "assets.zip")) {
+      assertThrows(IllegalArgumentException::class.java) {
+        FirmwareArchiveRules.validateRequirements(
+          arrayOf(entry(entryName = entryName)),
+        )
+      }
+    }
+  }
+
+  @Test
+  fun rejectsCaseFoldedDuplicateNames() {
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateRequirements(
+        arrayOf(
+          entry(entryName = "assets/Icon.png"),
+          entry(
+            artifactId = "resource-entry-2",
+            entryName = "assets/icon.png",
+          ),
+        ),
+      )
+    }
+  }
+
+  @Test
+  fun rejectsNonIntegralSizesAndInvalidDigests() {
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateRequirements(
+        arrayOf(entry(expectedSize = 1.5)),
+      )
+    }
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateRequirements(
+        arrayOf(entry(expectedSha256 = "not-a-digest")),
+      )
+    }
+  }
+
+  @Test
+  fun acceptsPortableEntriesWithoutExpectedIntegrityMetadata() {
+    val archive = createArchive("assets/icon.png", byteArrayOf(1, 2, 3))
+
+    val entries = FirmwareArchiveRules.validateCentralDirectory(archive, null)
+
+    assertEquals(1, entries.size)
+    assertEquals("assets/icon.png", entries.single().name)
+    assertEquals(3, entries.single().uncompressedSize)
+  }
+
+  @Test
+  fun rejectsTraversalWithoutExpectedIntegrityMetadata() {
+    val archive = createArchive("../icon.png", byteArrayOf(1))
+
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateCentralDirectory(archive, null)
+    }
+  }
+
+  private fun createArchive(entryName: String, content: ByteArray): File {
+    val archive = temporaryFolder.newFile("firmware.zip")
+    ZipOutputStream(FileOutputStream(archive)).use { zip ->
+      zip.putNextEntry(ZipEntry(entryName))
+      zip.write(content)
+      zip.closeEntry()
+    }
+    return archive
+  }
+}

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArtifactDeadlineTest.kt

@@ -0,0 +1,26 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class FirmwareArtifactDeadlineTest {
+  @Test
+  fun defaultsToABoundedThreeMinuteDeadline() {
+    assertEquals(180.0, validateFirmwareDownloadDeadlineSeconds(null), 0.0)
+  }
+
+  @Test
+  fun preservesFractionalDeadlines() {
+    assertEquals(2.75, validateFirmwareDownloadDeadlineSeconds(2.75), 0.0)
+  }
+
+  @Test
+  fun rejectsUnboundedOrInvalidDeadlines() {
+    listOf(0.0, -1.0, Double.NaN, Double.POSITIVE_INFINITY, 86_400.1).forEach {
+      assertThrows(IllegalArgumentException::class.java) {
+        validateFirmwareDownloadDeadlineSeconds(it)
+      }
+    }
+  }
+}

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArtifactOrphanSweepTest.kt

@@ -0,0 +1,107 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class FirmwareArtifactOrphanSweepTest {
+  @get:Rule
+  val temporaryFolder = TemporaryFolder()
+
+  @Test
+  fun removesOnlyStaleRootScratchEntriesWithExactNamesAndTypes() {
+    val root = temporaryFolder.newFolder("firmware-artifact-sweep")
+    val nowMs = 2_000_000_000_000L
+    val staleAt = nowMs - FIRMWARE_ARTIFACT_SCRATCH_GRACE_MS - 1
+    val freshAt = nowMs - FIRMWARE_ARTIFACT_SCRATCH_GRACE_MS + 1
+    val staleArchive = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000001",
+    ).apply {
+      assertTrue(mkdirs())
+      File(this, "0.entry").writeText("archive")
+    }
+    val stalePromote = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000002",
+    ).apply { writeText("promote") }
+    val freshArchive = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000003",
+    ).apply { assertTrue(mkdirs()) }
+    val freshPromote = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000004",
+    ).apply { writeText("promote") }
+    val malformedArchive = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000005.extra",
+    ).apply { assertTrue(mkdirs()) }
+    val malformedPromote = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000006.tmp",
+    ).apply { writeText("promote") }
+    val archiveNamedFile = File(
+      root,
+      "archive-00000000-0000-4000-8000-000000000007",
+    ).apply { writeText("promote") }
+    val promoteNamedDirectory = File(
+      root,
+      ".promote-00000000-0000-4000-8000-000000000008",
+    ).apply { assertTrue(mkdirs()) }
+    val nestedArchive = File(
+      File(root, "nested"),
+      "archive-00000000-0000-4000-8000-000000000009",
+    ).apply { assertTrue(mkdirs()) }
+
+    for (
+      entry in listOf(
+        staleArchive,
+        stalePromote,
+        malformedArchive,
+        malformedPromote,
+        archiveNamedFile,
+        promoteNamedDirectory,
+        nestedArchive,
+      )
+    ) {
+      assertTrue(entry.setLastModified(staleAt))
+    }
+    for (entry in listOf(freshArchive, freshPromote)) {
+      assertTrue(entry.setLastModified(freshAt))
+    }
+
+    val result = sweepFirmwareArtifactOrphansAtRoot(
+      root = root,
+      retainedSha256 = emptySet(),
+      activeSha256 = emptySet(),
+      openPaths = emptySet(),
+      nowMs = nowMs,
+    )
+
+    assertEquals(2, result.first)
+    assertEquals(14L, result.second)
+    assertFalse(staleArchive.exists())
+    assertFalse(stalePromote.exists())
+    for (
+      retainedEntry in listOf(
+        freshArchive,
+        freshPromote,
+        malformedArchive,
+        malformedPromote,
+        archiveNamedFile,
+        promoteNamedDirectory,
+        nestedArchive,
+      )
+    ) {
+      assertTrue(
+        "Unexpectedly removed ${retainedEntry.name}",
+        retainedEntry.exists(),
+      )
+    }
+  }
+}

package/ios/FirmwareArchiveMinizipBridge.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FirmwareArchiveEntryInfo : NSObject
+
+@property(nonatomic, readonly) NSString *name;
+@property(nonatomic, readonly) int64_t compressedSize;
+@property(nonatomic, readonly) int64_t uncompressedSize;
+@property(nonatomic, readonly) uint32_t crc32;
+@property(nonatomic, readonly) uint16_t flags;
+@property(nonatomic, readonly) uint16_t compressionMethod;
+@property(nonatomic, readonly) uint16_t versionMadeBy;
+@property(nonatomic, readonly) uint32_t externalAttributes;
+@property(nonatomic, readonly) uint32_t diskNumber;
+@property(nonatomic, readonly, nullable) NSString *linkName;
+
+@end
+
+@interface FirmwareArchiveMinizipBridge : NSObject
+
++ (nullable NSArray<FirmwareArchiveEntryInfo *> *)scanArchiveAtPath:
+    (NSString *)path
+    error:(NSError * _Nullable * _Nullable)error;
+
++ (BOOL)extractEntryNamed:(NSString *)entryName
+            archivePath:(NSString *)archivePath
+               consumer:(BOOL (^)(NSData *chunk))consumer
+                  error:(NSError * _Nullable * _Nullable)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/FirmwareArchiveMinizipBridge.mm

@@ -0,0 +1,213 @@
+#import "FirmwareArchiveMinizipBridge.h"
+
+#import "mz.h"
+#import "mz_strm.h"
+#import "mz_zip.h"
+#import "mz_zip_rw.h"
+
+#include <cstring>
+
+static NSString *const FirmwareArchiveBridgeErrorDomain =
+    @"so.onekey.firmware.archive.minizip";
+
+static NSError *FirmwareArchiveBridgeError(NSString *message, int32_t code) {
+  return [NSError errorWithDomain:FirmwareArchiveBridgeErrorDomain
+                             code:code
+                         userInfo:@{NSLocalizedDescriptionKey : message}];
+}
+
+@interface FirmwareArchiveEntryInfo ()
+
+@property(nonatomic, readwrite) NSString *name;
+@property(nonatomic, readwrite) int64_t compressedSize;
+@property(nonatomic, readwrite) int64_t uncompressedSize;
+@property(nonatomic, readwrite) uint32_t crc32;
+@property(nonatomic, readwrite) uint16_t flags;
+@property(nonatomic, readwrite) uint16_t compressionMethod;
+@property(nonatomic, readwrite) uint16_t versionMadeBy;
+@property(nonatomic, readwrite) uint32_t externalAttributes;
+@property(nonatomic, readwrite) uint32_t diskNumber;
+@property(nonatomic, readwrite, nullable) NSString *linkName;
+
+@end
+
+@implementation FirmwareArchiveEntryInfo
+@end
+
+@implementation FirmwareArchiveMinizipBridge
+
++ (nullable NSArray<FirmwareArchiveEntryInfo *> *)scanArchiveAtPath:
+    (NSString *)path
+    error:(NSError * _Nullable * _Nullable)error {
+  void *reader = nullptr;
+  mz_zip_reader_create(&reader);
+  if (reader == nullptr) {
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive reader allocation failed",
+                                          MZ_MEM_ERROR);
+    }
+    return nil;
+  }
+
+  int32_t result = mz_zip_reader_open_file(reader, path.fileSystemRepresentation);
+  if (result != MZ_OK) {
+    mz_zip_reader_delete(&reader);
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive open failed", result);
+    }
+    return nil;
+  }
+
+  NSMutableArray<FirmwareArchiveEntryInfo *> *entries =
+      [NSMutableArray array];
+  result = mz_zip_reader_goto_first_entry(reader);
+  while (result == MZ_OK) {
+    mz_zip_file *fileInfo = nullptr;
+    result = mz_zip_reader_entry_get_info(reader, &fileInfo);
+    if (result != MZ_OK || fileInfo == nullptr ||
+        fileInfo->filename == nullptr) {
+      result = result == MZ_OK ? MZ_FORMAT_ERROR : result;
+      break;
+    }
+    const size_t filenameLength = std::strlen(fileInfo->filename);
+    if (filenameLength == 0 || filenameLength > 4096) {
+      result = MZ_FORMAT_ERROR;
+      break;
+    }
+    if ((fileInfo->flag & (1 << 11)) == 0) {
+      const unsigned char *filenameBytes =
+          reinterpret_cast<const unsigned char *>(fileInfo->filename);
+      bool isAscii = true;
+      for (size_t index = 0; index < filenameLength; index += 1) {
+        if (filenameBytes[index] >= 0x80) {
+          isAscii = false;
+          break;
+        }
+      }
+      if (!isAscii) {
+        result = MZ_FORMAT_ERROR;
+        break;
+      }
+    }
+    NSString *name = [NSString stringWithUTF8String:fileInfo->filename];
+    if (name == nil) {
+      result = MZ_FORMAT_ERROR;
+      break;
+    }
+    NSString *linkName = nil;
+    if (fileInfo->linkname != nullptr) {
+      linkName = [NSString stringWithUTF8String:fileInfo->linkname];
+      if (linkName == nil) {
+        result = MZ_FORMAT_ERROR;
+        break;
+      }
+    }
+
+    FirmwareArchiveEntryInfo *entry =
+        [[FirmwareArchiveEntryInfo alloc] init];
+    entry.name = name;
+    entry.compressedSize = fileInfo->compressed_size;
+    entry.uncompressedSize = fileInfo->uncompressed_size;
+    entry.crc32 = fileInfo->crc;
+    entry.flags = fileInfo->flag;
+    entry.compressionMethod = fileInfo->compression_method;
+    entry.versionMadeBy = fileInfo->version_madeby;
+    entry.externalAttributes = fileInfo->external_fa;
+    entry.diskNumber = fileInfo->disk_number;
+    entry.linkName = linkName;
+    [entries addObject:entry];
+    if (entries.count > 4096) {
+      result = MZ_FORMAT_ERROR;
+      break;
+    }
+    result = mz_zip_reader_goto_next_entry(reader);
+  }
+
+  if (result == MZ_END_OF_LIST) {
+    result = MZ_OK;
+  }
+  int32_t closeResult = mz_zip_reader_close(reader);
+  mz_zip_reader_delete(&reader);
+  if (result != MZ_OK || closeResult != MZ_OK) {
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive scan failed",
+                                          result != MZ_OK ? result
+                                                          : closeResult);
+    }
+    return nil;
+  }
+  return entries;
+}
+
++ (BOOL)extractEntryNamed:(NSString *)entryName
+            archivePath:(NSString *)archivePath
+               consumer:(BOOL (^)(NSData *chunk))consumer
+                  error:(NSError * _Nullable * _Nullable)error {
+  void *reader = nullptr;
+  bool archiveOpened = false;
+  bool entryOpened = false;
+  mz_zip_reader_create(&reader);
+  if (reader == nullptr) {
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive reader allocation failed",
+                                          MZ_MEM_ERROR);
+    }
+    return NO;
+  }
+
+  int32_t result =
+      mz_zip_reader_open_file(reader, archivePath.fileSystemRepresentation);
+  if (result == MZ_OK) {
+    archiveOpened = true;
+  }
+  if (result == MZ_OK) {
+    result = mz_zip_reader_locate_entry(
+        reader, entryName.UTF8String, 0);
+  }
+  if (result == MZ_OK) {
+    result = mz_zip_reader_entry_open(reader);
+    if (result == MZ_OK) {
+      entryOpened = true;
+    }
+  }
+
+  uint8_t buffer[64 * 1024];
+  while (result == MZ_OK) {
+    int32_t count =
+        mz_zip_reader_entry_read(reader, buffer, (int32_t)sizeof(buffer));
+    if (count < 0) {
+      result = count;
+      break;
+    }
+    if (count == 0) {
+      break;
+    }
+    NSData *chunk = [NSData dataWithBytes:buffer length:(NSUInteger)count];
+    if (!consumer(chunk)) {
+      result = MZ_WRITE_ERROR;
+      break;
+    }
+  }
+
+  int32_t entryCloseResult =
+      entryOpened ? mz_zip_reader_entry_close(reader) : MZ_OK;
+  int32_t archiveCloseResult =
+      archiveOpened ? mz_zip_reader_close(reader) : MZ_OK;
+  mz_zip_reader_delete(&reader);
+  if (result != MZ_OK || entryCloseResult != MZ_OK ||
+      archiveCloseResult != MZ_OK) {
+    if (error != nullptr) {
+      int32_t failure = result != MZ_OK
+                            ? result
+                            : (entryCloseResult != MZ_OK
+                                   ? entryCloseResult
+                                   : archiveCloseResult);
+      *error = FirmwareArchiveBridgeError(
+          @"Archive entry extraction or CRC validation failed", failure);
+    }
+    return NO;
+  }
+  return YES;
+}
+
+@end