@bravemobile/react-native-code-push 13.0.0 → 13.1.0-beta.1

package/cpp/binarypatch/vendor/zstd/zstd_errors.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_ERRORS_H_398273423
+#define ZSTD_ERRORS_H_398273423
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
+#ifndef ZSTDERRORLIB_VISIBLE
+   /* Backwards compatibility with old macro name */
+#  ifdef ZSTDERRORLIB_VISIBILITY
+#    define ZSTDERRORLIB_VISIBLE ZSTDERRORLIB_VISIBILITY
+#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_VISIBLE __attribute__ ((visibility ("default")))
+#  else
+#    define ZSTDERRORLIB_VISIBLE
+#  endif
+#endif
+
+#ifndef ZSTDERRORLIB_HIDDEN
+#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_HIDDEN __attribute__ ((visibility ("hidden")))
+#  else
+#    define ZSTDERRORLIB_HIDDEN
+#  endif
+#endif
+
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBLE
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBLE
+#endif
+
+/*-*********************************************
+ *  Error codes list
+ *-*********************************************
+ *  Error codes _values_ are pinned down since v1.3.1 only.
+ *  Therefore, don't rely on values if you may link to any version < v1.3.1.
+ *
+ *  Only values < 100 are considered stable.
+ *
+ *  note 1 : this API shall be used with static linking only.
+ *           dynamic linking is not yet officially supported.
+ *  note 2 : Prefer relying on the enum than on its value whenever possible
+ *           This is the only supported way to use the error list < v1.3.1
+ *  note 3 : ZSTD_isError() is always correct, whatever the library version.
+ **********************************************/
+typedef enum {
+  ZSTD_error_no_error = 0,
+  ZSTD_error_GENERIC  = 1,
+  ZSTD_error_prefix_unknown                = 10,
+  ZSTD_error_version_unsupported           = 12,
+  ZSTD_error_frameParameter_unsupported    = 14,
+  ZSTD_error_frameParameter_windowTooLarge = 16,
+  ZSTD_error_corruption_detected = 20,
+  ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_literals_headerWrong = 24,
+  ZSTD_error_dictionary_corrupted      = 30,
+  ZSTD_error_dictionary_wrong          = 32,
+  ZSTD_error_dictionaryCreation_failed = 34,
+  ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_combination_unsupported = 41,
+  ZSTD_error_parameter_outOfBound    = 42,
+  ZSTD_error_tableLog_tooLarge       = 44,
+  ZSTD_error_maxSymbolValue_tooLarge = 46,
+  ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_cannotProduce_uncompressedBlock = 49,
+  ZSTD_error_stabilityCondition_notRespected = 50,
+  ZSTD_error_stage_wrong       = 60,
+  ZSTD_error_init_missing      = 62,
+  ZSTD_error_memory_allocation = 64,
+  ZSTD_error_workSpace_tooSmall= 66,
+  ZSTD_error_dstSize_tooSmall = 70,
+  ZSTD_error_srcSize_wrong    = 72,
+  ZSTD_error_dstBuffer_null   = 74,
+  ZSTD_error_noForwardProgress_destFull = 80,
+  ZSTD_error_noForwardProgress_inputEmpty = 82,
+  /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
+  ZSTD_error_frameIndex_tooLarge = 100,
+  ZSTD_error_seekableIO          = 102,
+  ZSTD_error_dstBuffer_wrong     = 104,
+  ZSTD_error_srcBuffer_wrong     = 105,
+  ZSTD_error_sequenceProducer_failed = 106,
+  ZSTD_error_externalSequences_invalid = 107,
+  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
+} ZSTD_ErrorCode;
+
+ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_ERRORS_H_398273423 */

package/ios/CodePush/CodePush.h

@@ -163,11 +163,16 @@ failCallback:(void (^)(NSError *err))failCallback;
 
 @interface CodePushPackage : NSObject
 
+/*
+ * doneCallback is given what the attempt at installing the update from its binary patch
+ * archive ended in, or nil when the update had no patch archive to attempt. The result
+ * describes the download and not the update: it is never part of the update's metadata.
+ */
 + (void)downloadPackage:(NSDictionary *)updatePackage
  expectedBundleFileName:(NSString *)expectedBundleFileName
          operationQueue:(dispatch_queue_t)operationQueue
        progressCallback:(void (^)(long long, long long))progressCallback
-           doneCallback:(void (^)())doneCallback
+           doneCallback:(void (^)(NSDictionary *binaryPatchResult))doneCallback
            failCallback:(void (^)(NSError *err))failCallback;
 
 + (NSDictionary *)getCurrentPackage:(NSError **)error;
@@ -206,6 +211,18 @@ failCallback:(void (^)(NSError *err))failCallback;
 
 @interface CodePushUpdateUtils : NSObject
 
+/*
+ * The SHA-256 of some bytes, written the way every hash of an update's
+ * contents is: lower case hex.
+ */
++ (NSString *)computeHashForData:(NSData *)inputData;
+
+/*
+ * The same hash, of the contents of a file. Returns nil when the file
+ * cannot be read.
+ */
++ (NSString *)computeHashForFileAtPath:(NSString *)filePath;
+
 + (BOOL)copyEntriesInFolder:(NSString *)sourceFolder
                  destFolder:(NSString *)destFolder
                       error:(NSError **)error;

package/ios/CodePush/CodePush.mm

@@ -61,6 +61,10 @@ static NSString *const BinaryBundleDateKey = @"binaryDate";
 static NSString *const PackageHashKey = @"packageHash";
 static NSString *const PackageIsPendingKey = @"isPending";
 
+// Not one of those keys: the field a download that tried a binary patch reports its outcome
+// under, on the package it resolves with and on no package it stores.
+static NSString *const BinaryPatchResultKey = @"binaryPatchResult";
+
 #pragma mark - Static variables
 
 static BOOL isRunningBinaryVersion = NO;
@@ -735,6 +739,14 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
         operationQueue:_methodQueue
         // The download is progressing forward
         progressCallback:^(long long expectedContentLength, long long receivedContentLength) {
+            // Received bytes only run backwards when a new download starts a stream of its
+            // own - the full archive after a binary patch fallback. The pause left over
+            // from the finished patch download would swallow that whole stream, so frame
+            // observation resumes here and the throttle forgets the previous stream.
+            if (notifyProgress && receivedContentLength < _latestReceivedConentLength) {
+                self.paused = NO;
+                _lastProgressEventTime = 0;
+            }
             // Update the download progress so that the frame observer can notify the JS side
             _latestExpectedContentLength = expectedContentLength;
             _latestReceivedConentLength = receivedContentLength;
@@ -755,13 +767,24 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
             }
         }
         // The download completed
-        doneCallback:^{
+        doneCallback:^(NSDictionary *binaryPatchResult) {
             NSError *err;
             NSDictionary *newPackage = [CodePushPackage getPackage:mutableUpdatePackage[PackageHashKey] error:&err];
 
             if (err) {
                 return reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
             }
+
+            if (binaryPatchResult) {
+                // The result describes this download rather than the update, so it is put on
+                // what this call resolves with and nowhere else: the metadata that was
+                // written for the update knows nothing about it, and whoever asked for the
+                // download decides what the result is worth.
+                NSMutableDictionary *downloadedPackage = [newPackage mutableCopy];
+                downloadedPackage[BinaryPatchResultKey] = binaryPatchResult;
+                return resolve(downloadedPackage);
+            }
+
             resolve(newPackage);
         }
         // The download failed

package/ios/CodePush/CodePushBinaryPatch.h

@@ -0,0 +1,80 @@
+#import <Foundation/Foundation.h>
+
+/*
+ * Why an update that was downloaded as a binary patch has to be downloaded in full
+ * instead.
+ *
+ * A failed restore is not an error the user ever hears about: it is the signal to
+ * download the update's full archive. These reasons are the vocabulary the appliers of
+ * every platform report, and the logs a rollout is judged from are read for exactly
+ * these words, so they must not be reworded.
+ */
+
+/** The bundle inside the app binary could not be opened or read. */
+extern NSString *const CodePushBinaryPatchReasonBaseBundleUnavailable;
+
+/** The bundle inside the app binary is not the one the patch was computed against. */
+extern NSString *const CodePushBinaryPatchReasonBaseHashMismatch;
+
+/** The manifest is missing, malformed, points outside the archive, or asks for too much. */
+extern NSString *const CodePushBinaryPatchReasonInvalidManifest;
+
+/** The patch was produced by a format or a codec this client cannot apply. */
+extern NSString *const CodePushBinaryPatchReasonUnsupportedFormat;
+
+/** The applier refused the patch, or the restored bundle could not be written. */
+extern NSString *const CodePushBinaryPatchReasonPatchApplyFailed;
+
+/** The restored bundle is not the one the manifest promised. */
+extern NSString *const CodePushBinaryPatchReasonTargetVerificationFailed;
+
+/**
+ * The update restored from the patch did not pass the checks every update passes before
+ * it is installed - the folder hash above all.
+ *
+ * This one is reported by the caller rather than by the applier: by the time it applies,
+ * the applier has already handed back a bundle it was happy with.
+ */
+extern NSString *const CodePushBinaryPatchReasonPackageVerificationFailed;
+
+/**
+ * Rebuilds the JS bundle of an update that was downloaded as a binary patch archive.
+ *
+ * A patch archive holds everything the full archive holds except the JS bundle, which it
+ * carries as a patch against the bundle that shipped inside the app binary, plus a
+ * manifest describing how to rebuild it. Restoring means applying that patch, verifying
+ * the result, moving it to where the bundle belongs and deleting the two patch-only
+ * files. What is left is byte for byte the contents of the full archive, so the folder
+ * hash check that follows the install is unchanged and stays the last line of defence.
+ *
+ * Nothing here trusts the patch. Neither the diff format nor the zstd streams inside it
+ * carry a checksum of the data they produce, so an apply that reports success is not
+ * proof of a correct result: a base bundle of the right size but the wrong content, or a
+ * corrupted patch body, both produce wrong bytes without any error. The base bundle is
+ * hashed before the patch is applied and the restored bundle is hashed afterwards, and
+ * the restored bytes only reach the update contents once both checks have passed.
+ *
+ * Every failure is reported as a reason, never as an exception: the caller answers all
+ * of them the same way, by downloading the full archive instead.
+ */
+@interface CodePushBinaryPatch : NSObject
+
+/**
+ * Turns the contents of a downloaded patch archive into the contents of the full one.
+ *
+ * This reads and hashes whole bundles, so it belongs on the queue the download runs on
+ * and never on the main queue.
+ *
+ * @param unzippedFolderPath the unzipped archive, which is modified in place
+ * @param workingFolderPath  scratch directory for the restored bundle, emptied before
+ *                           and after the attempt so an interrupted run leaves nothing
+ * @param baseBundleURL      the JS bundle that shipped inside the app binary
+ * @param failureReason      set to the reason the full archive has to be downloaded
+ *                           instead, whenever this returns NO
+ */
++ (BOOL)restoreBundleInUnzippedFolder:(NSString *)unzippedFolderPath
+                        workingFolder:(NSString *)workingFolderPath
+                        baseBundleURL:(NSURL *)baseBundleURL
+                        failureReason:(NSString **)failureReason;
+
+@end