react-native-bspatch 1.0.0

package/cpp/bzip2/huffman.c

@@ -0,0 +1,205 @@
+
+/*-------------------------------------------------------------*/
+/*--- Huffman coding low-level stuff                        ---*/
+/*---                                             huffman.c ---*/
+/*-------------------------------------------------------------*/
+
+/* ------------------------------------------------------------------
+   This file is part of bzip2/libbzip2, a program and library for
+   lossless, block-sorting data compression.
+
+   bzip2/libbzip2 version 1.0.8 of 13 July 2019
+   Copyright (C) 1996-2019 Julian Seward <jseward@acm.org>
+
+   Please read the WARNING, DISCLAIMER and PATENTS sections in the 
+   README file.
+
+   This program is released under the terms of the license contained
+   in the file LICENSE.
+   ------------------------------------------------------------------ */
+
+
+#include "bzlib_private.h"
+
+/*---------------------------------------------------*/
+#define WEIGHTOF(zz0)  ((zz0) & 0xffffff00)
+#define DEPTHOF(zz1)   ((zz1) & 0x000000ff)
+#define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3))
+
+#define ADDWEIGHTS(zw1,zw2)                           \
+   (WEIGHTOF(zw1)+WEIGHTOF(zw2)) |                    \
+   (1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2)))
+
+#define UPHEAP(z)                                     \
+{                                                     \
+   Int32 zz, tmp;                                     \
+   zz = z; tmp = heap[zz];                            \
+   while (weight[tmp] < weight[heap[zz >> 1]]) {      \
+      heap[zz] = heap[zz >> 1];                       \
+      zz >>= 1;                                       \
+   }                                                  \
+   heap[zz] = tmp;                                    \
+}
+
+#define DOWNHEAP(z)                                   \
+{                                                     \
+   Int32 zz, yy, tmp;                                 \
+   zz = z; tmp = heap[zz];                            \
+   while (True) {                                     \
+      yy = zz << 1;                                   \
+      if (yy > nHeap) break;                          \
+      if (yy < nHeap &&                               \
+          weight[heap[yy+1]] < weight[heap[yy]])      \
+         yy++;                                        \
+      if (weight[tmp] < weight[heap[yy]]) break;      \
+      heap[zz] = heap[yy];                            \
+      zz = yy;                                        \
+   }                                                  \
+   heap[zz] = tmp;                                    \
+}
+
+
+/*---------------------------------------------------*/
+void BZ2_hbMakeCodeLengths ( UChar *len, 
+                             Int32 *freq,
+                             Int32 alphaSize,
+                             Int32 maxLen )
+{
+   /*--
+      Nodes and heap entries run from 1.  Entry 0
+      for both the heap and nodes is a sentinel.
+   --*/
+   Int32 nNodes, nHeap, n1, n2, i, j, k;
+   Bool  tooLong;
+
+   Int32 heap   [ BZ_MAX_ALPHA_SIZE + 2 ];
+   Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
+   Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ]; 
+
+   for (i = 0; i < alphaSize; i++)
+      weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
+
+   while (True) {
+
+      nNodes = alphaSize;
+      nHeap = 0;
+
+      heap[0] = 0;
+      weight[0] = 0;
+      parent[0] = -2;
+
+      for (i = 1; i <= alphaSize; i++) {
+         parent[i] = -1;
+         nHeap++;
+         heap[nHeap] = i;
+         UPHEAP(nHeap);
+      }
+
+      AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
+   
+      while (nHeap > 1) {
+         n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
+         n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
+         nNodes++;
+         parent[n1] = parent[n2] = nNodes;
+         weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
+         parent[nNodes] = -1;
+         nHeap++;
+         heap[nHeap] = nNodes;
+         UPHEAP(nHeap);
+      }
+
+      AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
+
+      tooLong = False;
+      for (i = 1; i <= alphaSize; i++) {
+         j = 0;
+         k = i;
+         while (parent[k] >= 0) { k = parent[k]; j++; }
+         len[i-1] = j;
+         if (j > maxLen) tooLong = True;
+      }
+      
+      if (! tooLong) break;
+
+      /* 17 Oct 04: keep-going condition for the following loop used
+         to be 'i < alphaSize', which missed the last element,
+         theoretically leading to the possibility of the compressor
+         looping.  However, this count-scaling step is only needed if
+         one of the generated Huffman code words is longer than
+         maxLen, which up to and including version 1.0.2 was 20 bits,
+         which is extremely unlikely.  In version 1.0.3 maxLen was
+         changed to 17 bits, which has minimal effect on compression
+         ratio, but does mean this scaling step is used from time to
+         time, enough to verify that it works.
+
+         This means that bzip2-1.0.3 and later will only produce
+         Huffman codes with a maximum length of 17 bits.  However, in
+         order to preserve backwards compatibility with bitstreams
+         produced by versions pre-1.0.3, the decompressor must still
+         handle lengths of up to 20. */
+
+      for (i = 1; i <= alphaSize; i++) {
+         j = weight[i] >> 8;
+         j = 1 + (j / 2);
+         weight[i] = j << 8;
+      }
+   }
+}
+
+
+/*---------------------------------------------------*/
+void BZ2_hbAssignCodes ( Int32 *code,
+                         UChar *length,
+                         Int32 minLen,
+                         Int32 maxLen,
+                         Int32 alphaSize )
+{
+   Int32 n, vec, i;
+
+   vec = 0;
+   for (n = minLen; n <= maxLen; n++) {
+      for (i = 0; i < alphaSize; i++)
+         if (length[i] == n) { code[i] = vec; vec++; };
+      vec <<= 1;
+   }
+}
+
+
+/*---------------------------------------------------*/
+void BZ2_hbCreateDecodeTables ( Int32 *limit,
+                                Int32 *base,
+                                Int32 *perm,
+                                UChar *length,
+                                Int32 minLen,
+                                Int32 maxLen,
+                                Int32 alphaSize )
+{
+   Int32 pp, i, j, vec;
+
+   pp = 0;
+   for (i = minLen; i <= maxLen; i++)
+      for (j = 0; j < alphaSize; j++)
+         if (length[j] == i) { perm[pp] = j; pp++; };
+
+   for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
+   for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
+
+   for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
+
+   for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
+   vec = 0;
+
+   for (i = minLen; i <= maxLen; i++) {
+      vec += (base[i+1] - base[i]);
+      limit[i] = vec-1;
+      vec <<= 1;
+   }
+   for (i = minLen + 1; i <= maxLen; i++)
+      base[i] = ((limit[i-1] + 1) << 1) - base[i];
+}
+
+
+/*-------------------------------------------------------------*/
+/*--- end                                         huffman.c ---*/
+/*-------------------------------------------------------------*/

package/cpp/bzip2/randtable.c

@@ -0,0 +1,84 @@
+
+/*-------------------------------------------------------------*/
+/*--- Table for randomising repetitive blocks               ---*/
+/*---                                           randtable.c ---*/
+/*-------------------------------------------------------------*/
+
+/* ------------------------------------------------------------------
+   This file is part of bzip2/libbzip2, a program and library for
+   lossless, block-sorting data compression.
+
+   bzip2/libbzip2 version 1.0.8 of 13 July 2019
+   Copyright (C) 1996-2019 Julian Seward <jseward@acm.org>
+
+   Please read the WARNING, DISCLAIMER and PATENTS sections in the 
+   README file.
+
+   This program is released under the terms of the license contained
+   in the file LICENSE.
+   ------------------------------------------------------------------ */
+
+
+#include "bzlib_private.h"
+
+
+/*---------------------------------------------*/
+Int32 BZ2_rNums[512] = { 
+   619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 
+   985, 724, 205, 454, 863, 491, 741, 242, 949, 214, 
+   733, 859, 335, 708, 621, 574, 73, 654, 730, 472, 
+   419, 436, 278, 496, 867, 210, 399, 680, 480, 51, 
+   878, 465, 811, 169, 869, 675, 611, 697, 867, 561, 
+   862, 687, 507, 283, 482, 129, 807, 591, 733, 623, 
+   150, 238, 59, 379, 684, 877, 625, 169, 643, 105, 
+   170, 607, 520, 932, 727, 476, 693, 425, 174, 647, 
+   73, 122, 335, 530, 442, 853, 695, 249, 445, 515, 
+   909, 545, 703, 919, 874, 474, 882, 500, 594, 612, 
+   641, 801, 220, 162, 819, 984, 589, 513, 495, 799, 
+   161, 604, 958, 533, 221, 400, 386, 867, 600, 782, 
+   382, 596, 414, 171, 516, 375, 682, 485, 911, 276, 
+   98, 553, 163, 354, 666, 933, 424, 341, 533, 870, 
+   227, 730, 475, 186, 263, 647, 537, 686, 600, 224, 
+   469, 68, 770, 919, 190, 373, 294, 822, 808, 206, 
+   184, 943, 795, 384, 383, 461, 404, 758, 839, 887, 
+   715, 67, 618, 276, 204, 918, 873, 777, 604, 560, 
+   951, 160, 578, 722, 79, 804, 96, 409, 713, 940, 
+   652, 934, 970, 447, 318, 353, 859, 672, 112, 785, 
+   645, 863, 803, 350, 139, 93, 354, 99, 820, 908, 
+   609, 772, 154, 274, 580, 184, 79, 626, 630, 742, 
+   653, 282, 762, 623, 680, 81, 927, 626, 789, 125, 
+   411, 521, 938, 300, 821, 78, 343, 175, 128, 250, 
+   170, 774, 972, 275, 999, 639, 495, 78, 352, 126, 
+   857, 956, 358, 619, 580, 124, 737, 594, 701, 612, 
+   669, 112, 134, 694, 363, 992, 809, 743, 168, 974, 
+   944, 375, 748, 52, 600, 747, 642, 182, 862, 81, 
+   344, 805, 988, 739, 511, 655, 814, 334, 249, 515, 
+   897, 955, 664, 981, 649, 113, 974, 459, 893, 228, 
+   433, 837, 553, 268, 926, 240, 102, 654, 459, 51, 
+   686, 754, 806, 760, 493, 403, 415, 394, 687, 700, 
+   946, 670, 656, 610, 738, 392, 760, 799, 887, 653, 
+   978, 321, 576, 617, 626, 502, 894, 679, 243, 440, 
+   680, 879, 194, 572, 640, 724, 926, 56, 204, 700, 
+   707, 151, 457, 449, 797, 195, 791, 558, 945, 679, 
+   297, 59, 87, 824, 713, 663, 412, 693, 342, 606, 
+   134, 108, 571, 364, 631, 212, 174, 643, 304, 329, 
+   343, 97, 430, 751, 497, 314, 983, 374, 822, 928, 
+   140, 206, 73, 263, 980, 736, 876, 478, 430, 305, 
+   170, 514, 364, 692, 829, 82, 855, 953, 676, 246, 
+   369, 970, 294, 750, 807, 827, 150, 790, 288, 923, 
+   804, 378, 215, 828, 592, 281, 565, 555, 710, 82, 
+   896, 831, 547, 261, 524, 462, 293, 465, 502, 56, 
+   661, 821, 976, 991, 658, 869, 905, 758, 745, 193, 
+   768, 550, 608, 933, 378, 286, 215, 979, 792, 961, 
+   61, 688, 793, 644, 986, 403, 106, 366, 905, 644, 
+   372, 567, 466, 434, 645, 210, 389, 550, 919, 135, 
+   780, 773, 635, 389, 707, 100, 626, 958, 165, 504, 
+   920, 176, 193, 713, 857, 265, 203, 50, 668, 108, 
+   645, 990, 626, 197, 510, 357, 358, 850, 858, 364, 
+   936, 638
+};
+
+
+/*-------------------------------------------------------------*/
+/*--- end                                       randtable.c ---*/
+/*-------------------------------------------------------------*/

package/ios/OtaBundleResolver.swift

@@ -0,0 +1,241 @@
+import Foundation
+
+/**
+ * OtaBundleResolver — encapsulates OTA bundle path resolution for iOS with
+ * crash detection and automatic rollback.
+ *
+ * IMPORTANT: This runs BEFORE any JS code. If the OTA bundle is corrupted,
+ * Hermes crashes before React Native boots. This native resolver handles
+ * crash detection so the app can recover without JS ever running.
+ *
+ * Lifecycle:
+ *   1. Read metadata.json
+ *   2. If lastLaunchSuccessful == false → rollback to previous version
+ *   3. Mark current launch as pending (lastLaunchSuccessful = false)
+ *   4. Return the bundle path (or nil for IPA default)
+ *   5. JS calls markAsHealthy() → sets lastLaunchSuccessful = true
+ *   6. If crash before markAsHealthy → next boot sees false → rollback
+ *
+ * Usage in AppDelegate.swift:
+ * ```swift
+ * override func bundleURL() -> URL? {
+ *     if let otaBundle = OtaBundleResolver.resolve() {
+ *         return otaBundle
+ *     }
+ *     // Default RCTBundleURLProvider ...
+ * }
+ * ```
+ */
+@objcMembers
+public class OtaBundleResolver: NSObject {
+
+    private static let otaDirName = "ota"
+    private static let metadataFile = "metadata.json"
+    public static let defaultBaseVersion = 1
+    private static let maxRollback = 3
+    private static let maxRollbackIterations = 10 // Safety limit to prevent infinite loops
+
+    /// Resolves the JS bundle path from OTA metadata.
+    /// Handles crash detection and rollback entirely on the native side.
+    ///
+    /// - Parameter baseVersion: The OTA version baked into the IPA (default: 1)
+    /// - Returns: URL to the OTA bundle, or nil to use the IPA default.
+    @objc public static func resolve(baseVersion: Int = defaultBaseVersion) -> URL? {
+        guard let documentsDir = FileManager.default.urls(
+            for: .documentDirectory,
+            in: .userDomainMask
+        ).first else {
+            return nil
+        }
+
+        let otaDir = documentsDir.appendingPathComponent(otaDirName)
+        let metadataURL = otaDir.appendingPathComponent(metadataFile)
+
+        guard FileManager.default.fileExists(atPath: metadataURL.path) else {
+            NSLog("[OtaBundleResolver] No OTA metadata → IPA bundle")
+            return nil
+        }
+
+        do {
+            let data = try Data(contentsOf: metadataURL)
+            guard var metadata = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                return nil
+            }
+
+            let currentVersion = metadata["currentVersion"] as? Int ?? baseVersion
+            let lastLaunchOk = metadata["lastLaunchSuccessful"] as? Bool ?? true
+            let rollbackCount = metadata["rollbackCount"] as? Int ?? 0
+
+            // ── Step 1: Crash detection & rollback ──────────────────────────
+            if !lastLaunchOk && currentVersion > baseVersion {
+                NSLog("[OtaBundleResolver] Previous launch failed! Rolling back from V\(currentVersion)...")
+                
+                metadata = performRollback(metadata: metadata, baseVersion: baseVersion, currentRollbackCount: rollbackCount, otaDir: otaDir)
+                writeMetadata(url: metadataURL, metadata: metadata)
+
+                let newVersion = metadata["currentVersion"] as? Int ?? baseVersion
+                if newVersion <= baseVersion {
+                    NSLog("[OtaBundleResolver] Rolled back to factory IPA bundle")
+                    return nil
+                }
+
+                let rollbackVDir = otaDir.appendingPathComponent("v\(newVersion)")
+                let rollbackBundle = rollbackVDir.appendingPathComponent("main.jsbundle")
+                if !FileManager.default.fileExists(atPath: rollbackBundle.path) {
+                    NSLog("[OtaBundleResolver] Rollback target main.jsbundle missing in V\(newVersion) → factory")
+                    resetToFactory(url: metadataURL, baseVersion: baseVersion)
+                    return nil
+                }
+
+                // Mark this rollback attempt as pending
+                metadata["lastLaunchSuccessful"] = false
+                writeMetadata(url: metadataURL, metadata: metadata)
+
+                NSLog("[OtaBundleResolver] Trying rollback bundle: \(rollbackBundle.path)")
+                return rollbackBundle
+            }
+
+            // ── Step 2: Normal boot — no OTA bundle needed ──────────────────
+            if currentVersion <= baseVersion {
+                NSLog("[OtaBundleResolver] OTA v\(currentVersion) ≤ base v\(baseVersion) → IPA bundle")
+                return nil
+            }
+
+            // ── Step 3: OTA bundle — mark as pending verification ───────────
+            let vDir = otaDir.appendingPathComponent("v\(currentVersion)")
+            let bundleURL = vDir.appendingPathComponent("main.jsbundle")
+            if !FileManager.default.fileExists(atPath: bundleURL.path) {
+                NSLog("[OtaBundleResolver] main.jsbundle missing in V\(currentVersion) → IPA bundle")
+                resetToFactory(url: metadataURL, baseVersion: baseVersion)
+                return nil
+            }
+
+            // Mark launch as pending
+            metadata["lastLaunchSuccessful"] = false
+            writeMetadata(url: metadataURL, metadata: metadata)
+
+            NSLog("[OtaBundleResolver] Loading OTA bundle: \(bundleURL.path)")
+            return bundleURL
+
+        } catch {
+            NSLog("[OtaBundleResolver] Error: \(error.localizedDescription)")
+            return nil
+        }
+    }
+
+    private static func performRollback(metadata: [String: Any], baseVersion: Int, currentRollbackCount: Int, otaDir: URL) -> [String: Any] {
+        var rollbackCount = currentRollbackCount + 1
+        var prevVersions = metadata["previousVersions"] as? [Int] ?? []
+        var current = metadata
+        var iteration = 0
+
+        while iteration < maxRollbackIterations {
+            iteration += 1
+
+            if rollbackCount >= maxRollback {
+                NSLog("[OtaBundleResolver] Max rollback (\(maxRollback)) reached → factory reset")
+                return [
+                    "currentVersion": baseVersion,
+                    "previousVersions": [Int](),
+                    "rollbackCount": 0,
+                    "lastLaunchSuccessful": true
+                ]
+            }
+
+            guard !prevVersions.isEmpty else {
+                NSLog("[OtaBundleResolver] No previous versions to rollback to → factory reset")
+                return [
+                    "currentVersion": baseVersion,
+                    "previousVersions": [Int](),
+                    "rollbackCount": rollbackCount,
+                    "lastLaunchSuccessful": true
+                ]
+            }
+
+            let rollbackTo = prevVersions[0]
+            prevVersions = Array(prevVersions.dropFirst())
+
+            NSLog("[OtaBundleResolver] Rolling back: V\(current["currentVersion"] as? Int ?? baseVersion) → V\(rollbackTo) (attempt \(rollbackCount))")
+
+            let vDir = otaDir.appendingPathComponent("v\(rollbackTo)")
+            let targetBundle = vDir.appendingPathComponent("main.jsbundle")
+            if !FileManager.default.fileExists(atPath: targetBundle.path) && rollbackTo > baseVersion {
+                NSLog("[OtaBundleResolver] main.jsbundle not found in V\(rollbackTo), trying deeper rollback...")
+                current = [
+                    "currentVersion": rollbackTo,
+                    "previousVersions": prevVersions,
+                    "rollbackCount": rollbackCount,
+                    "lastLaunchSuccessful": false
+                ]
+                rollbackCount += 1
+                continue
+            }
+
+            return [
+                "currentVersion": rollbackTo,
+                "previousVersions": prevVersions,
+                "rollbackCount": rollbackCount,
+                "lastLaunchSuccessful": true
+            ]
+        }
+
+        // Safety: if we somehow exit the loop without returning, do factory reset
+        NSLog("[OtaBundleResolver] Max rollback iterations (\(maxRollbackIterations)) exceeded → factory reset")
+        return [
+            "currentVersion": baseVersion,
+            "previousVersions": [Int](),
+            "rollbackCount": 0,
+            "lastLaunchSuccessful": true
+        ]
+    }
+
+    private static func resetToFactory(url: URL, baseVersion: Int) {
+        let factory: [String: Any] = [
+            "currentVersion": baseVersion,
+            "previousVersions": [Int](),
+            "rollbackCount": 0,
+            "lastLaunchSuccessful": true
+        ]
+        writeMetadata(url: url, metadata: factory)
+    }
+
+    @objc public static func markAsHealthy() {
+        guard let documentsDir = FileManager.default.urls(
+            for: .documentDirectory, 
+            in: .userDomainMask
+        ).first else {
+            return
+        }
+
+        let otaDir = documentsDir.appendingPathComponent(otaDirName)
+        let metadataURL = otaDir.appendingPathComponent(metadataFile)
+
+        guard FileManager.default.fileExists(atPath: metadataURL.path) else {
+            return
+        }
+
+        do {
+            let data = try Data(contentsOf: metadataURL)
+            guard var metadata = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                return
+            }
+
+            metadata["lastLaunchSuccessful"] = true
+            metadata["rollbackCount"] = 0
+            
+            writeMetadata(url: metadataURL, metadata: metadata)
+            NSLog("[OtaBundleResolver] App marked as healthy")
+        } catch {
+            NSLog("[OtaBundleResolver] Failed to mark as healthy: \(error.localizedDescription)")
+        }
+    }
+
+    private static func writeMetadata(url: URL, metadata: [String: Any]) {
+        do {
+            let data = try JSONSerialization.data(withJSONObject: metadata, options: .prettyPrinted)
+            try data.write(to: url)
+        } catch {
+            NSLog("[OtaBundleResolver] Failed to write metadata: \(error.localizedDescription)")
+        }
+    }
+}

package/ios/RNBsPatch.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RNBsPatch : NSObject <RCTBridgeModule>
+
+- (void)markAsHealthy;
+
+@end