@onekeyfe/react-native-range-downloader 3.0.81-alpha.8 → 3.0.81-alpha.9

package/ios/RangeDownloadLogic.swift

@@ -1,6 +1,23 @@
 import Foundation
 import CommonCrypto
 
+enum FirmwareArtifactStoreError: Error, CustomStringConvertible {
+  case invalidInput(String)
+  case downloadFailed(String)
+  case integrityMismatch(String)
+  case readerInvalid(String)
+  case archiveInvalid(String)
+
+  var description: String {
+    switch self {
+    case let .invalidInput(message), let .downloadFailed(message),
+      let .integrityMismatch(message), let .readerInvalid(message),
+      let .archiveInvalid(message):
+      return message
+    }
+  }
+}
+
 enum FirmwareArtifactDeadlineError: Error {
   case exceeded
 }
@@ -30,16 +47,32 @@ enum FirmwareArtifactWallClockDeadline {
 
 func firmwareArtifactDownloadKey(
   transactionId: String,
-  expectedSize: Int64,
-  expectedSha256: String
+  taskId: String,
+  expectedSize: Int64?,
+  expectedSha256: String?
 ) -> String {
-  "\(transactionId)|\(expectedSize)|\(expectedSha256)"
+  "\(transactionId)|\(taskId)|\(expectedSize.map(String.init) ?? "unknown")|\(expectedSha256 ?? "unknown")"
+}
+
+func firmwareArtifactDownloadToken(
+  expectedSha256: String?,
+  url: String
+) -> String {
+  if let expectedSha256 {
+    return expectedSha256.lowercased()
+  }
+  let urlData = Data(url.utf8)
+  var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+  urlData.withUnsafeBytes {
+    _ = CC_SHA256($0.baseAddress, CC_LONG(urlData.count), &hash)
+  }
+  return hash.map { String(format: "%02x", $0) }.joined()
 }
 
 func firmwareArtifactPartialFileName(
   transactionId: String,
   taskId: String,
-  expectedSha256: String
+  downloadToken: String
 ) -> String {
   let transactionData = Data(transactionId.utf8)
   var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
@@ -50,13 +83,14 @@ func firmwareArtifactPartialFileName(
     .prefix(8)
     .map { String(format: "%02x", $0) }
     .joined()
-  return "\(expectedSha256).\(taskId).\(transactionToken).partial"
+  return "\(downloadToken).\(taskId).\(transactionToken).partial"
 }
 
 func firmwareArtifactContentRangeIsValid(
   _ value: String,
   expectedStart: Int64,
-  expectedTotal: Int64
+  expectedTotal: Int64?,
+  maxBytes: Int64
 ) -> Bool {
   guard value.lowercased().hasPrefix("bytes ") else {
     return false
@@ -67,10 +101,11 @@ func firmwareArtifactContentRangeIsValid(
   else {
     return false
   }
+  let totalMatches = expectedTotal.map { total == $0 } ?? (total > 0 && total <= maxBytes)
   return bounds.start == expectedStart &&
     bounds.end >= bounds.start &&
     bounds.end < total &&
-    total == expectedTotal
+    totalMatches
 }
 
 func firmwareArtifactResponseFits(
@@ -85,40 +120,163 @@ func firmwareArtifactResponseFits(
     expectedContentLength <= maxBytes - baseOffset
 }
 
-enum FirmwareBackgroundDownloadError: LocalizedError, CustomStringConvertible {
-  case cancelled
-  case invalidTask
-  case deadlineExceeded
-  case redirectRejected
-  case responseRejected
-  case sizeRejected
-  case tlsRejected
-  case transferFailed
+let firmwareArtifactFinalGrace: TimeInterval = 24 * 60 * 60
+let firmwareArtifactPartialGrace: TimeInterval = 7 * 24 * 60 * 60
+let firmwareArtifactScratchGrace: TimeInterval = firmwareArtifactPartialGrace
 
-  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"
+func firmwareArtifactIdentifierIsSafe(_ value: String) -> Bool {
+  value.range(
+    of: "^[A-Za-z0-9._:-]{1,160}$",
+    options: .regularExpression
+  ) != nil
+}
+
+private func firmwareArtifactScratchNameIsValid(
+  _ name: String,
+  prefix: String
+) -> Bool {
+  guard name.hasPrefix(prefix) else {
+    return false
+  }
+  let rawUUID = String(name.dropFirst(prefix.count))
+  guard
+    rawUUID.count == 36,
+    let uuid = UUID(uuidString: rawUUID)
+  else {
+    return false
+  }
+  return uuid.uuidString.caseInsensitiveCompare(rawUUID) == .orderedSame
+}
+
+private func firmwareArtifactEntrySize(
+  _ entryURL: URL,
+  values: URLResourceValues,
+  fileManager: FileManager
+) -> Int64 {
+  if values.isRegularFile == true {
+    return Int64(values.fileSize ?? 0)
+  }
+  guard
+    values.isDirectory == true,
+    let enumerator = fileManager.enumerator(
+      at: entryURL,
+      includingPropertiesForKeys: [
+        .isRegularFileKey,
+        .isSymbolicLinkKey,
+        .fileSizeKey,
+      ],
+      options: [],
+      errorHandler: nil
+    )
+  else {
+    return 0
+  }
+  var size: Int64 = 0
+  for case let childURL as URL in enumerator {
+    guard
+      let childValues = try? childURL.resourceValues(
+        forKeys: [.isRegularFileKey, .isSymbolicLinkKey, .fileSizeKey]
+      ),
+      childValues.isRegularFile == true,
+      childValues.isSymbolicLink != true
+    else {
+      continue
     }
+    size += Int64(childValues.fileSize ?? 0)
   }
+  return size
+}
 
-  var description: String {
-    errorDescription ?? "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
+func sweepFirmwareArtifactOrphansAtRoot(
+  _ rootURL: URL,
+  retainedSha256: Set<String>,
+  activeSha256: Set<String>,
+  openPaths: Set<String>,
+  now: Date = Date(),
+  fileManager: FileManager = .default
+) throws -> (deletedFiles: Int, deletedBytes: Int64) {
+  var deletedFiles = 0
+  var deletedBytes: Int64 = 0
+  let resourceKeys: Set<URLResourceKey> = [
+    .isRegularFileKey,
+    .isDirectoryKey,
+    .isSymbolicLinkKey,
+    .contentModificationDateKey,
+    .fileSizeKey,
+  ]
+  let entries = try fileManager.contentsOfDirectory(
+    at: rootURL,
+    includingPropertiesForKeys: Array(resourceKeys),
+    options: []
+  )
+  for entryURL in entries {
+    let name = entryURL.lastPathComponent
+    let values = try entryURL.resourceValues(forKeys: resourceKeys)
+    let isArchiveScratch = firmwareArtifactScratchNameIsValid(
+      name,
+      prefix: "archive-"
+    )
+    let isPromoteScratch = firmwareArtifactScratchNameIsValid(
+      name,
+      prefix: ".promote-"
+    )
+    let isScratchCandidate = values.isSymbolicLink != true &&
+      ((isArchiveScratch && values.isDirectory == true) ||
+        (isPromoteScratch && values.isRegularFile == true))
+    if isScratchCandidate {
+      guard
+        let modifiedAt = values.contentModificationDate,
+        now.timeIntervalSince(modifiedAt) >= firmwareArtifactScratchGrace
+      else {
+        continue
+      }
+      let size = firmwareArtifactEntrySize(
+        entryURL,
+        values: values,
+        fileManager: fileManager
+      )
+      try fileManager.removeItem(at: entryURL)
+      deletedFiles += 1
+      deletedBytes += size
+      continue
+    }
+
+    guard
+      values.isRegularFile == true,
+      values.isSymbolicLink != true,
+      name.count >= 64
+    else {
+      continue
+    }
+    let sha256 = String(name.prefix(64))
+    guard
+      sha256.range(of: "^[a-f0-9]{64}$", options: .regularExpression) != nil,
+      !retainedSha256.contains(sha256),
+      !activeSha256.contains(sha256),
+      !openPaths.contains(entryURL.path)
+    else {
+      continue
+    }
+    let grace: TimeInterval
+    if name.hasSuffix(".bin") {
+      grace = firmwareArtifactFinalGrace
+    } else if name.hasSuffix(".partial") {
+      grace = firmwareArtifactPartialGrace
+    } else {
+      continue
+    }
+    guard
+      let modifiedAt = values.contentModificationDate,
+      now.timeIntervalSince(modifiedAt) >= grace
+    else {
+      continue
+    }
+    let size = Int64(values.fileSize ?? 0)
+    try fileManager.removeItem(at: entryURL)
+    deletedFiles += 1
+    deletedBytes += size
   }
+  return (deletedFiles, deletedBytes)
 }
 
 // MARK: - Dependency-free RangeDownloader logic (OCDS §4 / §5)