@onekeyfe/react-native-range-downloader 3.0.81-alpha.1 → 3.0.81-alpha.3

package/ios/FirmwareArtifactStore.swift

@@ -2,6 +2,33 @@ import CryptoKit
 import Foundation
 import SniConnect
 
+func isFirmwareArtifactTLSError(_ error: Error) -> Bool {
+  var current: NSError? = error as NSError
+  var visited = Set<ObjectIdentifier>()
+  while let candidate = current {
+    let identifier = ObjectIdentifier(candidate)
+    guard visited.insert(identifier).inserted else {
+      break
+    }
+    if candidate.domain == NSURLErrorDomain,
+      [
+        NSURLErrorSecureConnectionFailed,
+        NSURLErrorServerCertificateHasBadDate,
+        NSURLErrorServerCertificateUntrusted,
+        NSURLErrorServerCertificateHasUnknownRoot,
+        NSURLErrorServerCertificateNotYetValid,
+        NSURLErrorClientCertificateRejected,
+        NSURLErrorClientCertificateRequired,
+        NSURLErrorAppTransportSecurityRequiresSecureConnection,
+      ].contains(candidate.code)
+    {
+      return true
+    }
+    current = candidate.userInfo[NSUnderlyingErrorKey] as? NSError
+  }
+  return false
+}
+
 enum FirmwareArtifactStoreError: Error {
   case invalidInput(String)
   case downloadFailed(String)
@@ -79,8 +106,8 @@ private actor FirmwareArtifactDownloadCoordinator {
 final class FirmwareArtifactStore {
   static let shared = FirmwareArtifactStore()
   static let maxReadBytes = 256 * 1024
-  private static let maxLeaseMetadataBytes: Int64 = 1024 * 1024
-  private static let maxTotalLeaseRefs = 8192
+  private static let defaultDownloadDeadline: TimeInterval = 180
+  private static let maxDownloadDeadline: TimeInterval = 24 * 60 * 60
   private static let finalArtifactGrace: TimeInterval = 24 * 60 * 60
   private static let partialArtifactGrace: TimeInterval = 7 * 24 * 60 * 60
 
@@ -90,16 +117,11 @@ final class FirmwareArtifactStore {
     let size: Int64
   }
 
-  private struct LeaseState: Codable {
+  private struct LeaseState {
     let transactionId: String
     var artifactRefs: Set<String>
   }
 
-  private struct LeaseEnvelope: Codable {
-    let schemaVersion: Int
-    var leases: [String: LeaseState]
-  }
-
   private let fileManager = FileManager.default
   private let downloadCoordinator = FirmwareArtifactDownloadCoordinator()
   private let leaseLock = NSLock()
@@ -109,6 +131,7 @@ final class FirmwareArtifactStore {
   private var cancelledTransactions: Set<String> = []
   private let readerLock = NSLock()
   private var readers: [String: OpenReader] = [:]
+  private var leases: [String: LeaseState] = [:]
 
   private lazy var rootURL: URL = {
     let base = fileManager.urls(
@@ -170,6 +193,14 @@ final class FirmwareArtifactStore {
     guard params.routeType == "domain" || params.routeType == "pinnedIp" else {
       throw FirmwareArtifactStoreError.invalidInput("Invalid firmware route type")
     }
+    let deadline = params.overallDeadlineSeconds ?? defaultDownloadDeadline
+    guard
+      deadline.isFinite,
+      deadline > 0,
+      deadline <= maxDownloadDeadline
+    else {
+      throw FirmwareArtifactStoreError.invalidInput("Invalid firmware download deadline")
+    }
     if params.routeType == "pinnedIp" {
       guard let resolvedIp = params.resolvedIp, !resolvedIp.isEmpty else {
         throw FirmwareArtifactStoreError.invalidInput("Pinned route requires resolvedIp")
@@ -188,8 +219,11 @@ final class FirmwareArtifactStore {
       transactionId: params.transactionId,
       artifactRef: "fw:\(expectedSha256)"
     )
-    let key =
-      "\(params.transactionId):\(expectedSha256):\(Int64(params.expectedSize))"
+    let key = firmwareArtifactDownloadKey(
+      transactionId: params.transactionId,
+      expectedSize: Int64(params.expectedSize),
+      expectedSha256: expectedSha256
+    )
     markDownloadActive(expectedSha256, delta: 1)
     do {
       let artifact = try await downloadCoordinator.run(
@@ -202,6 +236,7 @@ final class FirmwareArtifactStore {
           expectedSha256: expectedSha256
         )
       }
+      try rejectIfCancelled(transactionId: params.transactionId)
       markDownloadActive(expectedSha256, delta: -1)
       return artifact
     } catch {
@@ -309,17 +344,12 @@ final class FirmwareArtifactStore {
 
   func acceptBackgroundDownload(
     temporaryURL: URL,
-    leaseRef: String,
     transactionId: String,
     expectedSize: Int64,
     expectedSha256: String
   ) throws -> StoredFirmwareArtifact {
     let normalizedExpectedSha256 = expectedSha256.lowercased()
-    try retainExpectedArtifact(
-      leaseRef: leaseRef,
-      transactionId: transactionId,
-      artifactRef: "fw:\(normalizedExpectedSha256)"
-    )
+    try rejectIfCancelled(transactionId: transactionId)
     let finalURL = artifactURL(sha256: normalizedExpectedSha256)
     if let existing = try? validateStoredArtifact(
       fileURL: finalURL,
@@ -360,14 +390,8 @@ final class FirmwareArtifactStore {
   func discard(artifactRef: String) throws {
     let fileURL = try resolveArtifactURL(artifactRef)
     leaseLock.lock()
-    let isRetained: Bool
-    do {
-      isRetained = try loadLeasesLocked().leases.values.contains {
-        $0.artifactRefs.contains(artifactRef)
-      }
-    } catch {
-      leaseLock.unlock()
-      throw error
+    let isRetained = leases.values.contains {
+      $0.artifactRefs.contains(artifactRef)
     }
     leaseLock.unlock()
     guard !isRetained else {
@@ -566,18 +590,16 @@ final class FirmwareArtifactStore {
     }
     leaseLock.lock()
     defer { leaseLock.unlock() }
-    var envelope = try loadLeasesLocked()
-    guard envelope.leases.count < 32 else {
+    guard leases.count < 32 else {
       throw FirmwareArtifactStoreError.invalidInput(
         "Too many firmware artifact leases"
       )
     }
     let leaseRef = "fwlease:\(UUID().uuidString.lowercased())"
-    envelope.leases[leaseRef] = LeaseState(
+    leases[leaseRef] = LeaseState(
       transactionId: transactionId,
       artifactRefs: []
     )
-    try saveLeasesLocked(envelope)
     return leaseRef
   }
 
@@ -603,9 +625,8 @@ final class FirmwareArtifactStore {
     let transactionId: String = try {
       leaseLock.lock()
       defer { leaseLock.unlock() }
-      var envelope = try loadLeasesLocked()
       guard
-        let lease = envelope.leases.removeValue(
+        let lease = leases.removeValue(
           forKey: try validateLeaseRef(leaseRef)
         )
       else {
@@ -613,7 +634,6 @@ final class FirmwareArtifactStore {
           "Firmware artifact lease is unavailable"
         )
       }
-      try saveLeasesLocked(envelope)
       return lease.transactionId
     }()
     cancellationLock.withFirmwareArtifactLock {
@@ -621,43 +641,13 @@ final class FirmwareArtifactStore {
     }
   }
 
-  func reconcileLeases(activeLeaseRefs: [String]) throws {
-    guard activeLeaseRefs.count <= 32 else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Too many active firmware artifact leases"
-      )
-    }
-    let active = try Set(activeLeaseRefs.map(validateLeaseRef))
-    guard active.count == activeLeaseRefs.count else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Duplicate active firmware artifact lease"
-      )
-    }
-    leaseLock.lock()
-    defer { leaseLock.unlock() }
-    var envelope = try loadLeasesLocked()
-    guard active.allSatisfy({ envelope.leases[$0] != nil }) else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Firmware artifact lease reconciliation is incomplete"
-      )
-    }
-    envelope.leases = envelope.leases.filter { active.contains($0.key) }
-    try saveLeasesLocked(envelope)
-  }
-
   func sweepOrphans() throws -> (deletedFiles: Int, deletedBytes: Int64) {
     leaseLock.lock()
-    let retained: Set<String>
-    do {
-      retained = Set(
-        try loadLeasesLocked().leases.values
-          .flatMap(\.artifactRefs)
-          .map { String($0.dropFirst(3)) }
-      )
-    } catch {
-      leaseLock.unlock()
-      throw error
-    }
+    let retained = Set(
+      leases.values
+        .flatMap(\.artifactRefs)
+        .map { String($0.dropFirst(3)) }
+    )
     leaseLock.unlock()
     activeDownloadLock.lock()
     let active = Set(activeDownloadCounts.filter { $0.value > 0 }.keys)
@@ -676,7 +666,7 @@ final class FirmwareArtifactStore {
     )
     for fileURL in files {
       let name = fileURL.lastPathComponent
-      guard name != "leases.json", name.count >= 64 else { continue }
+      guard name.count >= 64 else { continue }
       let sha256 = String(name.prefix(64))
       guard
         sha256.range(of: "^[a-f0-9]{64}$", options: .regularExpression) != nil,
@@ -714,7 +704,7 @@ final class FirmwareArtifactStore {
   private func requireLease(_ leaseRef: String) throws {
     leaseLock.lock()
     defer { leaseLock.unlock() }
-    guard try loadLeasesLocked().leases[validateLeaseRef(leaseRef)] != nil else {
+    guard leases[try validateLeaseRef(leaseRef)] != nil else {
       throw FirmwareArtifactStoreError.invalidInput(
         "Firmware artifact lease is unavailable"
       )
@@ -736,9 +726,8 @@ final class FirmwareArtifactStore {
     }
     leaseLock.lock()
     defer { leaseLock.unlock() }
-    var envelope = try loadLeasesLocked()
     let validatedLeaseRef = try validateLeaseRef(leaseRef)
-    guard var lease = envelope.leases[validatedLeaseRef] else {
+    guard var lease = leases[validatedLeaseRef] else {
       throw FirmwareArtifactStoreError.invalidInput(
         "Firmware artifact lease is unavailable"
       )
@@ -749,8 +738,7 @@ final class FirmwareArtifactStore {
       )
     }
     if lease.artifactRefs.insert(artifactRef).inserted {
-      envelope.leases[validatedLeaseRef] = lease
-      try saveLeasesLocked(envelope)
+      leases[validatedLeaseRef] = lease
     }
   }
 
@@ -777,79 +765,6 @@ final class FirmwareArtifactStore {
     ) != nil
   }
 
-  private func loadLeasesLocked() throws -> LeaseEnvelope {
-    let url = rootURL.appendingPathComponent("leases.json", isDirectory: false)
-    guard fileManager.fileExists(atPath: url.path) else {
-      return LeaseEnvelope(schemaVersion: 1, leases: [:])
-    }
-    let fileSize = try url.resourceValues(forKeys: [.fileSizeKey]).fileSize ?? 0
-    guard fileSize > 0, Int64(fileSize) <= Self.maxLeaseMetadataBytes else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Firmware lease metadata is too large"
-      )
-    }
-    let envelope = try JSONDecoder().decode(
-      LeaseEnvelope.self,
-      from: Data(contentsOf: url)
-    )
-    guard envelope.schemaVersion == 1, envelope.leases.count <= 32 else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Unsupported firmware lease schema"
-      )
-    }
-    guard
-      envelope.leases.values.reduce(0, { $0 + $1.artifactRefs.count })
-        <= Self.maxTotalLeaseRefs
-    else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Firmware lease metadata is too large"
-      )
-    }
-    for (leaseRef, lease) in envelope.leases {
-      guard
-        Self.isValidLeaseRef(leaseRef),
-        Self.isSafeIdentifier(lease.transactionId),
-        lease.artifactRefs.count <= 4096,
-        lease.artifactRefs.allSatisfy({
-          $0.range(
-            of: "^fw:[a-f0-9]{64}$",
-            options: .regularExpression
-          ) != nil
-        })
-      else {
-        throw FirmwareArtifactStoreError.invalidInput(
-          "Invalid persisted firmware lease"
-        )
-      }
-    }
-    return envelope
-  }
-
-  private func saveLeasesLocked(_ envelope: LeaseEnvelope) throws {
-    guard
-      envelope.schemaVersion == 1,
-      envelope.leases.count <= 32,
-      envelope.leases.values.allSatisfy({
-        $0.artifactRefs.count <= 4096
-      }),
-      envelope.leases.values.reduce(0, {
-        $0 + $1.artifactRefs.count
-      }) <= Self.maxTotalLeaseRefs
-    else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Firmware lease metadata is too large"
-      )
-    }
-    let data = try JSONEncoder().encode(envelope)
-    guard Int64(data.count) <= Self.maxLeaseMetadataBytes else {
-      throw FirmwareArtifactStoreError.invalidInput(
-        "Firmware lease metadata is too large"
-      )
-    }
-    let url = rootURL.appendingPathComponent("leases.json", isDirectory: false)
-    try data.write(to: url, options: [.atomic])
-  }
-
   private func markDownloadActive(_ sha256: String, delta: Int) {
     activeDownloadLock.lock()
     let next = (activeDownloadCounts[sha256] ?? 0) + delta
@@ -1002,13 +917,37 @@ final class FirmwareArtifactStore {
     _ params: FirmwareArtifactDownloadParams,
     partialURL: URL,
     resumeOffset: Int64
+  ) async throws {
+    do {
+      try await FirmwareArtifactWallClockDeadline.run(
+        timeoutSeconds:
+          params.overallDeadlineSeconds ?? Self.defaultDownloadDeadline
+      ) { [self] in
+        try await streamDownloadWithinDeadline(
+          params,
+          partialURL: partialURL,
+          resumeOffset: resumeOffset
+        )
+      }
+    } catch FirmwareArtifactDeadlineError.exceeded {
+      throw FirmwareArtifactStoreError.downloadFailed(
+        "ARTIFACT_DEADLINE_EXCEEDED: firmware download exceeded its deadline"
+      )
+    }
+  }
+
+  private func streamDownloadWithinDeadline(
+    _ params: FirmwareArtifactDownloadParams,
+    partialURL: URL,
+    resumeOffset: Int64
   ) async throws {
     guard let url = URL(string: params.url), let hostname = url.host else {
       throw FirmwareArtifactStoreError.invalidInput("Invalid firmware URL")
     }
     var request = URLRequest(url: url)
     request.cachePolicy = .reloadIgnoringLocalCacheData
-    request.timeoutInterval = params.overallDeadlineSeconds ?? 180
+    request.timeoutInterval =
+      params.overallDeadlineSeconds ?? Self.defaultDownloadDeadline
     request.setValue("identity", forHTTPHeaderField: "Accept-Encoding")
     if resumeOffset > 0 {
       request.setValue("bytes=\(resumeOffset)-", forHTTPHeaderField: "Range")
@@ -1037,10 +976,10 @@ final class FirmwareArtifactStore {
       }
     }
 
-    let bytes: URLSession.AsyncBytes
+    let downloadedURL: URL
     let response: URLResponse
     do {
-      (bytes, response) = try await session.bytes(for: request)
+      (downloadedURL, response) = try await session.download(for: request)
     } catch {
       if isCancellationError(
         error,
@@ -1050,13 +989,29 @@ final class FirmwareArtifactStore {
           "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
         )
       }
+      if isFirmwareArtifactTLSError(error) {
+        throw FirmwareArtifactStoreError.downloadFailed(
+          "ARTIFACT_TLS_FAILED: firmware TLS validation failed"
+        )
+      }
       throw FirmwareArtifactStoreError.downloadFailed(
         "ARTIFACT_NETWORK_FAILED: firmware request failed"
       )
     }
+    defer { try? fileManager.removeItem(at: downloadedURL) }
     guard let httpResponse = response as? HTTPURLResponse else {
       throw FirmwareArtifactStoreError.downloadFailed("Firmware response is not HTTP")
     }
+    guard
+      let responseURL = httpResponse.url,
+      responseURL.scheme?.lowercased() == "https",
+      responseURL.host?.lowercased() == hostname.lowercased(),
+      responseURL.port == nil || responseURL.port == 443
+    else {
+      throw FirmwareArtifactStoreError.downloadFailed(
+        "ARTIFACT_REDIRECT_REJECTED: firmware response changed canonical identity"
+      )
+    }
     guard httpResponse.statusCode == 200 || httpResponse.statusCode == 206 else {
       throw FirmwareArtifactStoreError.downloadFailed(
         "ARTIFACT_HTTP_\(httpResponse.statusCode): firmware request failed"
@@ -1086,21 +1041,25 @@ final class FirmwareArtifactStore {
     }
 
     var written = append ? resumeOffset : 0
-    var buffer = Data()
-    buffer.reserveCapacity(64 * 1024)
+    let source = try FileHandle(forReadingFrom: downloadedURL)
+    defer { try? source.close() }
     do {
-      for try await byte in bytes {
-        buffer.append(byte)
-        if buffer.count >= 64 * 1024 {
-          written += Int64(buffer.count)
-          guard written <= Int64(params.maxBytes) else {
-            throw FirmwareArtifactStoreError.downloadFailed(
-              "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
-            )
-          }
-          try handle.write(contentsOf: buffer)
-          buffer.removeAll(keepingCapacity: true)
+      while true {
+        try Task.checkCancellation()
+        try rejectIfCancelled(transactionId: params.transactionId)
+        guard
+          let buffer = try source.read(upToCount: 64 * 1024),
+          !buffer.isEmpty
+        else {
+          break
+        }
+        written += Int64(buffer.count)
+        guard written <= Int64(params.maxBytes) else {
+          throw FirmwareArtifactStoreError.downloadFailed(
+            "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
+          )
         }
+        try handle.write(contentsOf: buffer)
       }
     } catch let error as FirmwareArtifactStoreError {
       throw error
@@ -1113,18 +1072,14 @@ final class FirmwareArtifactStore {
           "ARTIFACT_CANCELLED: firmware artifact download was cancelled"
         )
       }
-      throw FirmwareArtifactStoreError.downloadFailed(
-        "ARTIFACT_NETWORK_FAILED: firmware response stream failed"
-      )
-    }
-    if !buffer.isEmpty {
-      written += Int64(buffer.count)
-      guard written <= Int64(params.maxBytes) else {
+      if isFirmwareArtifactTLSError(error) {
         throw FirmwareArtifactStoreError.downloadFailed(
-          "ARTIFACT_PROTOCOL_INVALID: firmware artifact exceeds maxBytes"
+          "ARTIFACT_TLS_FAILED: firmware TLS validation failed"
         )
       }
-      try handle.write(contentsOf: buffer)
+      throw FirmwareArtifactStoreError.downloadFailed(
+        "ARTIFACT_NETWORK_FAILED: firmware response stream failed"
+      )
     }
     try handle.synchronize()
     try rejectIfCancelled(transactionId: params.transactionId)

package/ios/RangeDownloadLogic.swift

@@ -1,6 +1,77 @@
 import Foundation
 import CommonCrypto
 
+enum FirmwareArtifactDeadlineError: Error {
+  case exceeded
+}
+
+enum FirmwareArtifactWallClockDeadline {
+  static func run<T>(
+    timeoutSeconds: TimeInterval,
+    operation: @escaping @Sendable () async throws -> T
+  ) async throws -> T {
+    let timeoutNanoseconds = UInt64(max(0.001, timeoutSeconds) * 1_000_000_000.0)
+    return try await withThrowingTaskGroup(of: T.self) { group in
+      group.addTask {
+        try await operation()
+      }
+      group.addTask {
+        try await Task.sleep(nanoseconds: timeoutNanoseconds)
+        throw FirmwareArtifactDeadlineError.exceeded
+      }
+      defer { group.cancelAll() }
+      guard let result = try await group.next() else {
+        throw FirmwareArtifactDeadlineError.exceeded
+      }
+      return result
+    }
+  }
+}
+
+func firmwareArtifactDownloadKey(
+  transactionId: String,
+  expectedSize: Int64,
+  expectedSha256: String
+) -> String {
+  "\(transactionId)|\(expectedSize)|\(expectedSha256)"
+}
+
+enum FirmwareBackgroundDownloadError: LocalizedError, CustomStringConvertible {
+  case cancelled
+  case invalidTask
+  case deadlineExceeded
+  case redirectRejected
+  case responseRejected
+  case sizeRejected
+  case tlsRejected
+  case transferFailed
+
+  var errorDescription: String? {
+    switch self {
+    case .cancelled:
+      return "ARTIFACT_CANCELLED: firmware background download was cancelled"
+    case .invalidTask:
+      return "ARTIFACT_PROTOCOL_INVALID: firmware background task is invalid"
+    case .deadlineExceeded:
+      return "ARTIFACT_DEADLINE_EXCEEDED: firmware download exceeded its deadline"
+    case .redirectRejected:
+      return "ARTIFACT_REDIRECT_REJECTED: firmware redirect changed canonical identity"
+    case .responseRejected:
+      return "ARTIFACT_PROTOCOL_INVALID: firmware response is invalid"
+    case .sizeRejected:
+      return "ARTIFACT_PROTOCOL_INVALID: firmware artifact size is invalid"
+    case .tlsRejected:
+      return "ARTIFACT_TLS_FAILED: firmware TLS validation failed"
+    case .transferFailed:
+      return "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
+    }
+  }
+
+  var description: String {
+    errorDescription ?? "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
+  }
+}
+
 // MARK: - Dependency-free RangeDownloader logic (OCDS §4 / §5)
 //
 // This file holds the DETERMINISTIC, dependency-light pieces of the range