@onekeyfe/react-native-sni-connect 3.0.85 → 3.0.86

package/android/src/test/java/com/sniconnect/SniConnectValidationTest.kt

@@ -28,6 +28,14 @@ class SniConnectValidationTest {
     assertEquals("/v1?q=1", SniConnectValidation.normalizePath("v1?q=1"))
   }
 
+  @Test
+  fun canonicalizesEquivalentPublicIpLiterals() {
+    assertEquals(
+      SniConnectValidation.canonicalizePublicIp("2001:4860:4860::8888"),
+      SniConnectValidation.canonicalizePublicIp("2001:4860:4860:0:0:0:0:8888"),
+    )
+  }
+
   @Test
   fun rejectsIpLiteralHostnames() {
     assertValidationFails { SniConnectValidation.validateHostname("93.184.216.34") }
@@ -57,6 +65,7 @@ class SniConnectValidationTest {
       "example.com",
       "93.184.216.34:443",
       " 93.184.216.34",
+      "093.184.216.034",
       "10.0.0.1",
       "127.0.0.1",
       "100.64.0.1",
@@ -117,8 +126,10 @@ class SniConnectValidationTest {
 
   @Test
   fun enforcesRequestIdTimeoutAndBodyLimits() {
+    SniConnectValidation.validateRequestId("界".repeat(42))
     assertValidationFails { SniConnectValidation.validateRequestId("") }
     assertValidationFails { SniConnectValidation.validateRequestId("x".repeat(129)) }
+    assertValidationFails { SniConnectValidation.validateRequestId("界".repeat(43)) }
     assertValidationFails { SniConnectValidation.validateRequestId("req\n1") }
     assertValidationFails { SniConnectValidation.validateTimeout(0) }
     assertValidationFails { SniConnectValidation.validateTimeout(120_001) }
@@ -184,32 +195,6 @@ class SniConnectValidationTest {
     SniConnectValidation.validateMethodBody("OPTIONS", null)
   }
 
-  @Test
-  fun requestLimiterEnforcesGlobalAndPerDestinationLimits() {
-    val limiter = SniConnectRequestLimiter(
-      maxActiveRequests = 2,
-      maxActiveRequestsPerPair = 1,
-    )
-
-    val firstToken = limiter.acquire("Example.com", "93.184.216.34")
-    assertValidationFails {
-      limiter.acquire("example.com", "93.184.216.34")
-    }
-
-    val secondToken = limiter.acquire("example.com", "93.184.216.35")
-    assertValidationFails {
-      limiter.acquire("example.net", "93.184.216.36")
-    }
-
-    firstToken.release()
-    val replacementToken = limiter.acquire("example.com", "93.184.216.34")
-    firstToken.release()
-    secondToken.release()
-    replacementToken.release()
-
-    assertTrue(true)
-  }
-
   @Test
   fun classifiesSecurityFailuresAsFailClosedErrorCodes() {
     assertEquals(
@@ -244,6 +229,18 @@ class SniConnectValidationTest {
       "SNI_REQUEST_FAILED",
       classifySniFailureCode(IOException("connection reset")),
     )
+    assertEquals(
+      "SNI_CANCELLED",
+      classifySniResponseFailureCode(IOException("cancelled"), true),
+    )
+    assertEquals(
+      "SNI_REQUEST_TIMEOUT",
+      classifySniResponseFailureCode(SocketTimeoutException("timeout"), false),
+    )
+    assertEquals(
+      "SNI_RESPONSE_FAILED",
+      classifySniResponseFailureCode(IOException("bad body"), false),
+    )
   }
 
   private fun assertValidationFails(block: () -> Unit) {

package/ios/SniConnect.mm

@@ -1,4 +1,5 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
 #import <React/RCTUtils.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -8,6 +9,7 @@
 // Forward declaration of the Swift implementation
 @interface SniConnectImpl : NSObject
 - (instancetype)init;
+- (void)invalidate;
 - (void)request:(NSDictionary *)config
         resolve:(RCTPromiseResolveBlock)resolve
          reject:(RCTPromiseRejectBlock)reject;
@@ -18,6 +20,9 @@
                    reject:(RCTPromiseRejectBlock)reject;
 - (void)clearDNSCache:(RCTPromiseResolveBlock)resolve
                reject:(RCTPromiseRejectBlock)reject;
+- (void)getDebugSnapshot:(NSDictionary *)target
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject;
 - (void)isProxyActiveForUrl:(NSString *)url
                     resolve:(RCTPromiseResolveBlock)resolve
                      reject:(RCTPromiseRejectBlock)reject;
@@ -25,9 +30,9 @@
 
 @interface SniConnect : NSObject
 #ifdef RCT_NEW_ARCH_ENABLED
-<NativeSniConnectSpec>
+<NativeSniConnectSpec, RCTInvalidating>
 #else
-<RCTBridgeModule>
+<RCTBridgeModule, RCTInvalidating>
 #endif
 @end
 
@@ -48,6 +53,10 @@ RCT_EXPORT_MODULE(SniConnect)
   return self;
 }
 
+- (void)invalidate {
+  [_implementation invalidate];
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 // TurboModule interface implementation
 - (void)request:(JS::NativeSniConnect::NativeSniConnectRequest &)config
@@ -89,6 +98,16 @@ RCT_EXPORT_MODULE(SniConnect)
   [_implementation clearDNSCache:resolve reject:reject];
 }
 
+- (void)getDebugSnapshot:(JS::NativeSniConnect::SniConnectDebugTarget &)target
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  NSDictionary *targetDict = @{
+    @"ip": target.ip() ?: @"",
+    @"hostname": target.hostname() ?: @"",
+  };
+  [_implementation getDebugSnapshot:targetDict resolve:resolve reject:reject];
+}
+
 - (void)isProxyActiveForUrl:(NSString *)url
                     resolve:(RCTPromiseResolveBlock)resolve
                      reject:(RCTPromiseRejectBlock)reject {
@@ -124,6 +143,12 @@ RCT_EXPORT_METHOD(clearDNSCache:(RCTPromiseResolveBlock)resolver
   [_implementation clearDNSCache:resolver reject:rejecter];
 }
 
+RCT_EXPORT_METHOD(getDebugSnapshot:(NSDictionary *)target
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter) {
+  [_implementation getDebugSnapshot:target resolve:resolver reject:rejecter];
+}
+
 RCT_EXPORT_METHOD(isProxyActiveForUrl:(NSString *)url
                   resolver:(RCTPromiseResolveBlock)resolver
                   rejecter:(RCTPromiseRejectBlock)rejecter) {

package/ios/SniConnect.swift

@@ -16,6 +16,11 @@ final class SniConnectImpl: NSObject {
     super.init()
   }
 
+  @objc
+  public func invalidate() {
+    client.invalidate()
+  }
+
   @objc
   public func request(
     _ config: NSDictionary,
@@ -133,6 +138,35 @@ final class SniConnectImpl: NSObject {
     resolve(["success": true])
   }
 
+  @objc
+  public func getDebugSnapshot(
+    _ target: NSDictionary,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      guard let ip = target["ip"] as? String, !ip.isEmpty else {
+        throw SniConnectError.invalidConfig("Missing ip")
+      }
+      guard let hostname = target["hostname"] as? String, !hostname.isEmpty else {
+        throw SniConnectError.invalidConfig("Missing hostname")
+      }
+      try SniConnectValidation.validatePublicIP(ip)
+      try SniConnectValidation.validateHostname(hostname)
+      let snapshot = client.debugSnapshot(hostname: hostname, ip: ip)
+      resolve([
+        "activeRequests": snapshot.activeRequests,
+        "activeRequestsForPair": snapshot.activeRequestsForPair,
+        "pendingRequests": snapshot.pendingRequests,
+        "pendingRequestsForPair": snapshot.pendingRequestsForPair,
+        "activeRequestIdsForPair": snapshot.activeRequestIdsForPair,
+        "pendingRequestIdsForPair": snapshot.pendingRequestIdsForPair,
+      ])
+    } catch {
+      reject("SNI_INVALID_CONFIG", "\(error)", error)
+    }
+  }
+
   @objc
   public func isProxyActiveForUrl(
     _ url: String,

package/ios/SniConnectClient.swift

@@ -83,7 +83,7 @@ final class SniConnectPinnedResolverLease {
     }
   }
 
-  private var isReleased: Bool {
+  var isReleased: Bool {
     queue.sync {
       didRelease
     }
@@ -186,8 +186,9 @@ final class SniConnectClient {
   // token so cancelAllRequests() also covers requests that do not have a requestId.
   private var activeTasksByToken: [UUID: Task<Response, Error>] = [:]
   private var requestTokensById: [String: UUID] = [:]
+  private var invalidated = false
   private let tasksQueue = DispatchQueue(label: "com.onekey.sni.connect.tasks", attributes: .concurrent)
-  private let requestLimiter = SniConnectRequestLimiter()
+  private let requestLimiter = SniConnectRequestLimiter.shared
 
   private struct SessionKey: Hashable {
     let hostname: String
@@ -215,10 +216,13 @@ final class SniConnectClient {
   }
 
   private static let maxCachedSessions = SniConnectPinnedResolverRegistry.defaultMaxEntries
-  private var sessionCache: [SessionKey: ManagedSession] = [:]
-  private var sessionAccessOrder: [SessionKey] = []
-  private var activeSessionCounts: [ObjectIdentifier: Int] = [:]
-  private let sessionsQueue = DispatchQueue(label: "com.onekey.sni.connect.sessions")
+  // The resolver registry is process-shared, so the cache and its slot accounting
+  // must have the same owner across every RN runtime.
+  private static var sessionCache: [SessionKey: ManagedSession] = [:]
+  private static var sessionAccessOrder: [SessionKey] = []
+  private static var activeSessionCounts: [ObjectIdentifier: Int] = [:]
+  private static var pendingResolverSlots: [SniConnectPinnedResolverLease] = []
+  private static let sessionsQueue = DispatchQueue(label: "com.onekey.sni.connect.sessions")
 
   // Token for the memory-warning observer (block-based observers are not removed
   // by `removeObserver(self)`, so the token must be retained and removed explicitly).
@@ -428,21 +432,26 @@ final class SniConnectClient {
   private func sessionLease(for config: RequestConfig) async throws -> SessionLease {
     let key = SessionKey(hostname: config.hostname.lowercased(), ip: config.ip)
     while true {
-      let acquisition = try sessionsQueue.sync { () throws -> SessionAcquisition in
-        if let managedSession = sessionCache[key] {
-          markSessionUsed(key)
-          return .ready(retainSession(managedSession.session))
+      let acquisition = try Self.sessionsQueue.sync { () throws -> SessionAcquisition in
+        Self.pendingResolverSlots.removeAll { $0.isReleased }
+        if let managedSession = Self.sessionCache[key] {
+          Self.markSessionUsed(key)
+          return .ready(Self.retainSession(managedSession.session))
+        }
+        if !Self.pendingResolverSlots.isEmpty {
+          return .waitForResolverSlots(Self.pendingResolverSlots)
         }
 
-        let pendingResolverSlots = evictSessionsIfNeeded(forPendingInsert: true)
+        let pendingResolverSlots = Self.evictSessionsIfNeeded(forPendingInsert: true)
         if !pendingResolverSlots.isEmpty {
+          Self.pendingResolverSlots.append(contentsOf: pendingResolverSlots)
           return .waitForResolverSlots(pendingResolverSlots)
         }
 
         let managedSession = try Self.makeURLSession(for: key)
-        sessionCache[key] = managedSession
-        markSessionUsed(key)
-        return .ready(retainSession(managedSession.session))
+        Self.sessionCache[key] = managedSession
+        Self.markSessionUsed(key)
+        return .ready(Self.retainSession(managedSession.session))
       }
 
       switch acquisition {
@@ -457,35 +466,40 @@ final class SniConnectClient {
         for resolverLease in resolverLeases {
           try await resolverLease.waitUntilReleased()
         }
+        Self.sessionsQueue.sync {
+          Self.pendingResolverSlots.removeAll { $0.isReleased }
+        }
       }
     }
   }
 
-  private func retainSession(_ session: URLSession) -> SessionLease {
+  private static func retainSession(_ session: URLSession) -> SessionLease {
     let sessionID = ObjectIdentifier(session)
     activeSessionCounts[sessionID, default: 0] += 1
     return SessionLease(session: session, sessionID: sessionID)
   }
 
   private func releaseSessionLease(_ lease: SessionLease) {
-    sessionsQueue.sync {
-      guard let count = activeSessionCounts[lease.sessionID] else {
+    Self.sessionsQueue.sync {
+      guard let count = Self.activeSessionCounts[lease.sessionID] else {
         return
       }
       if count > 1 {
-        activeSessionCounts[lease.sessionID] = count - 1
+        Self.activeSessionCounts[lease.sessionID] = count - 1
       } else {
-        activeSessionCounts.removeValue(forKey: lease.sessionID)
+        Self.activeSessionCounts.removeValue(forKey: lease.sessionID)
       }
     }
   }
 
-  private func markSessionUsed(_ key: SessionKey) {
+  private static func markSessionUsed(_ key: SessionKey) {
     sessionAccessOrder.removeAll { $0 == key }
     sessionAccessOrder.append(key)
   }
 
-  private func evictSessionsIfNeeded(forPendingInsert: Bool = false) -> [SniConnectPinnedResolverLease] {
+  private static func evictSessionsIfNeeded(
+    forPendingInsert: Bool = false
+  ) -> [SniConnectPinnedResolverLease] {
     var pendingResolverSlots: [SniConnectPinnedResolverLease] = []
     let limit = forPendingInsert ? Self.maxCachedSessions - 1 : Self.maxCachedSessions
     while sessionCache.count > limit, let evictedKey = sessionAccessOrder.first {
@@ -506,7 +520,7 @@ final class SniConnectClient {
     return pendingResolverSlots
   }
 
-  private func invalidateSession(
+  private static func invalidateSession(
     _ managedSession: ManagedSession,
     for key: SessionKey
   ) -> SniConnectPinnedResolverLease? {
@@ -524,15 +538,21 @@ final class SniConnectClient {
   /// slot immediately; sessions with active requests release it when invalidation
   /// completes.
   func clearDNSCache() {
-    let invalidations = sessionsQueue.sync { () -> [SessionInvalidation] in
-      let invalidations = sessionCache.map { _, managedSession in
+    let invalidations = Self.sessionsQueue.sync { () -> [SessionInvalidation] in
+      let invalidations = Self.sessionCache.map { _, managedSession in
         SessionInvalidation(
           managedSession: managedSession,
-          releaseResolverImmediately: activeSessionCounts[ObjectIdentifier(managedSession.session)] == nil
+          releaseResolverImmediately:
+            Self.activeSessionCounts[ObjectIdentifier(managedSession.session)] == nil
         )
       }
-      sessionCache.removeAll()
-      sessionAccessOrder.removeAll()
+      Self.sessionCache.removeAll()
+      Self.sessionAccessOrder.removeAll()
+      // Block new cache inserts until every registry entry removed by this
+      // process-wide clear has actually released its resolver slot.
+      Self.pendingResolverSlots.append(contentsOf: invalidations.map {
+        $0.managedSession.resolverLease
+      })
       return invalidations
     }
     var releasedResolverCount = 0
@@ -552,6 +572,10 @@ final class SniConnectClient {
     ]))
   }
 
+  func debugSnapshot(hostname: String, ip: String) -> SniConnectRequestLimiter.Snapshot {
+    requestLimiter.snapshot(hostname: hostname, ip: ip)
+  }
+
   /// Cancel a request by ID
   func cancelRequest(requestId: String) -> Bool {
     return tasksQueue.sync(flags: .barrier) { [weak self] in
@@ -574,15 +598,27 @@ final class SniConnectClient {
 
   /// Cancel all active requests
   func cancelAllRequests() {
+    cancelOwnedRequests(markInvalidated: false, logAction: "sni_cancel_all")
+  }
+
+  /// Permanently stop this runtime's client and cancel work racing with teardown.
+  func invalidate() {
+    cancelOwnedRequests(markInvalidated: true, logAction: "sni_runtime_invalidate")
+  }
+
+  private func cancelOwnedRequests(markInvalidated: Bool, logAction: String) {
     tasksQueue.sync(flags: .barrier) { [weak self] in
       guard let self = self else { return }
+      if markInvalidated {
+        self.invalidated = true
+      }
       let tasks = Array(self.activeTasksByToken.values)
       for task in tasks {
         task.cancel()
       }
       self.activeTasksByToken.removeAll()
       self.requestTokensById.removeAll()
-      SniConnectLog.info(SniConnectLog.event("sni_cancel_all", [
+      SniConnectLog.info(SniConnectLog.event(logAction, [
         ("cancelledCount", tasks.count),
         ("success", true),
       ]))
@@ -592,8 +628,13 @@ final class SniConnectClient {
   /// Register an active task immediately after creation, before JS can cancel it.
   func registerTask(_ task: Task<Response, Error>, for requestId: String?) -> UUID {
     let token = UUID()
+    var shouldCancel = false
     tasksQueue.sync(flags: .barrier) { [weak self] in
       guard let self = self else { return }
+      if self.invalidated {
+        shouldCancel = true
+        return
+      }
       if let requestId = requestId, let previousToken = self.requestTokensById[requestId],
          let previousTask = self.activeTasksByToken.removeValue(forKey: previousToken) {
         previousTask.cancel()
@@ -607,6 +648,9 @@ final class SniConnectClient {
         self.requestTokensById[requestId] = token
       }
     }
+    if shouldCancel {
+      task.cancel()
+    }
     return token
   }
 
@@ -656,11 +700,24 @@ final class SniConnectClient {
       throw sniError
     }
 
+    let deadline = SniConnectWallClockDeadline.makeDeadline(
+      timeoutMilliseconds: config.effectiveTotalTimeout
+    )
     let requestSlot: SniConnectRequestLimiter.Token
     do {
-      requestSlot = try requestLimiter.acquire(hostname: config.hostname, ip: config.ip)
+      // Admission wait and transport share one total wall-clock deadline.
+      let limiter = requestLimiter
+      requestSlot = try await SniConnectWallClockDeadline.run(
+        until: deadline
+      ) {
+        try await limiter.acquire(
+          hostname: config.hostname,
+          ip: config.ip,
+          requestId: config.requestId
+        )
+      }
     } catch {
-      let sniError = SniConnectError.resourceLimit("\(error)")
+      let sniError = SniConnectError.from(error)
       SniConnectLog.error(SniConnectLog.event("sni_request_result", [
         ("result", "error"),
         ("code", sniError.code),
@@ -678,6 +735,14 @@ final class SniConnectClient {
     defer {
       requestSlot.release()
     }
+    try Task.checkCancellation()
+
+    let queueWaitMilliseconds = SniConnectLog.elapsedMs(since: startedAt)
+    let remainingTimeoutMilliseconds =
+      SniConnectWallClockDeadline.remainingMilliseconds(until: deadline)
+    guard remainingTimeoutMilliseconds > 0 else {
+      throw SniConnectError.requestTimeout
+    }
 
     let url = try Self.buildURL(hostname: config.hostname, normalizedPath: normalizedPath)
 
@@ -685,8 +750,9 @@ final class SniConnectClient {
     mutableRequest.httpMethod = method
 
     // Convert milliseconds to seconds for timeout values
-    let totalTimeoutSeconds = config.effectiveTotalTimeout / 1000.0
-    let connectTimeoutSeconds = config.effectiveConnectTimeout / 1000.0
+    let totalTimeoutSeconds = remainingTimeoutMilliseconds / 1000.0
+    let connectTimeoutSeconds =
+      min(config.effectiveConnectTimeout, remainingTimeoutMilliseconds) / 1000.0
 
     // URLRequest.timeoutInterval is not a full request deadline. Keep it aligned
     // with the caller timeout as a transport guard; the wall-clock deadline below
@@ -716,12 +782,15 @@ final class SniConnectClient {
       ("method", method),
       ("timeoutMs", Int(config.effectiveTotalTimeout)),
       ("connectTimeoutMs", Int(config.effectiveConnectTimeout)),
+      ("queueWaitMs", queueWaitMilliseconds),
       ("headerCount", normalizedHeaders.count),
       ("bodyBytes", config.body?.data(using: .utf8)?.count ?? 0),
     ]))
 
     do {
-      return try await SniConnectWallClockDeadline.run(timeoutMilliseconds: config.effectiveTotalTimeout) {
+      return try await SniConnectWallClockDeadline.run(
+        until: deadline
+      ) {
         let lease = try await self.sessionLease(for: config)
         defer {
           self.releaseSessionLease(lease)

package/ios/SniConnectCore.swift

@@ -160,11 +160,37 @@ enum SniConnectTimeout: Error, Equatable {
 }
 
 enum SniConnectWallClockDeadline {
+  struct Deadline: Sendable {
+    fileprivate let uptimeNanoseconds: UInt64
+  }
+
+  static func makeDeadline(timeoutMilliseconds: TimeInterval) -> Deadline {
+    let now = DispatchTime.now().uptimeNanoseconds
+    let (deadline, overflow) = now.addingReportingOverflow(
+      timeoutNanoseconds(milliseconds: timeoutMilliseconds)
+    )
+    return Deadline(uptimeNanoseconds: overflow ? UInt64.max : deadline)
+  }
+
+  static func remainingMilliseconds(until deadline: Deadline) -> TimeInterval {
+    Double(remainingNanoseconds(until: deadline)) / 1_000_000.0
+  }
+
   static func run<T>(
     timeoutMilliseconds: TimeInterval,
     operation: @escaping @Sendable () async throws -> T
   ) async throws -> T {
-    let timeoutNanoseconds = UInt64(max(1.0, timeoutMilliseconds) * 1_000_000.0)
+    try await run(
+      until: makeDeadline(timeoutMilliseconds: timeoutMilliseconds),
+      operation: operation
+    )
+  }
+
+  static func run<T>(
+    until deadline: Deadline,
+    operation: @escaping @Sendable () async throws -> T
+  ) async throws -> T {
+    let timeoutNanoseconds = remainingNanoseconds(until: deadline)
     return try await withThrowingTaskGroup(of: T.self) { group in
       group.addTask {
         try await operation()
@@ -174,18 +200,38 @@ enum SniConnectWallClockDeadline {
         throw SniConnectTimeout.deadlineExceeded
       }
 
+      defer {
+        group.cancelAll()
+      }
       do {
         guard let result = try await group.next() else {
           throw SniConnectTimeout.deadlineExceeded
         }
-        group.cancelAll()
+        guard !hasExpired(deadline) else {
+          throw SniConnectTimeout.deadlineExceeded
+        }
         return result
       } catch {
-        group.cancelAll()
+        if hasExpired(deadline) {
+          throw SniConnectTimeout.deadlineExceeded
+        }
         throw error
       }
     }
   }
+
+  private static func remainingNanoseconds(until deadline: Deadline) -> UInt64 {
+    let now = DispatchTime.now().uptimeNanoseconds
+    return deadline.uptimeNanoseconds > now ? deadline.uptimeNanoseconds - now : 0
+  }
+
+  private static func hasExpired(_ deadline: Deadline) -> Bool {
+    DispatchTime.now().uptimeNanoseconds >= deadline.uptimeNanoseconds
+  }
+
+  private static func timeoutNanoseconds(milliseconds: TimeInterval) -> UInt64 {
+    UInt64(max(1.0, milliseconds) * 1_000_000.0)
+  }
 }
 
 struct SniConnectHeaderMaps: Equatable {