@bravemobile/react-native-code-push 12.4.1 → 13.1.0-beta.0

package/cpp/binarypatch/binarypatch_zstd_decompressor.c

@@ -0,0 +1,187 @@
+#include "binarypatch_zstd_decompressor.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "zstd.h"
+
+/*
+ * Largest window a decompression session will accept, pinned to the window that the
+ * `-c-zstd-21-24` generation options use: no patch this project produces declares a
+ * window above 2^24. Keeping the bound at the generation limit means a corrupted
+ * frame header that asks for a wider window is rejected before anything is
+ * allocated, instead of being answered with an allocation that large - and applying
+ * a patch keeps several decompression sessions open at once, so the bound applies
+ * several times over. Changing the generation options is a patch format version
+ * change, and this bound moves with them.
+ */
+#define BINARYPATCH_ZSTD_WINDOW_LOG_MAX 24
+
+/*
+ * One decompression session. The input and output buffers are allocated in the
+ * same block as the struct (`buffers` is their start) to keep the number of
+ * allocations per patch session down.
+ */
+typedef struct {
+    const hpatch_TStreamInput* codeStream;
+    hpatch_StreamPos_t         codeReadPos;
+    hpatch_StreamPos_t         codeEnd;
+
+    ZSTD_DStream*              dstream;
+    ZSTD_inBuffer              in;
+    size_t                     inCapacity;
+    ZSTD_outBuffer             out;
+    size_t                     outReadPos; /* bytes of `out` already handed to the caller */
+
+    hpatch_dec_error_t         decError;
+    unsigned char              buffers[1]; /* [inCapacity bytes][out.size bytes] */
+} binarypatch_zstd_session;
+
+static hpatch_BOOL _zstd_fail(binarypatch_zstd_session* self) {
+    if (self->decError == hpatch_dec_ok) {
+        self->decError = hpatch_dec_error;
+    }
+    return hpatch_FALSE;
+}
+
+static hpatch_BOOL _zstd_is_can_open(const char* compressType) {
+    return (0 == strcmp(compressType, BINARYPATCH_ZSTD_COMPRESS_TYPE)) ? hpatch_TRUE : hpatch_FALSE;
+}
+
+static hpatch_decompressHandle _zstd_open(struct hpatch_TDecompress* decompressPlugin,
+                                          hpatch_StreamPos_t dataSize,
+                                          const struct hpatch_TStreamInput* codeStream,
+                                          hpatch_StreamPos_t code_begin,
+                                          hpatch_StreamPos_t code_end) {
+    const size_t inCapacity = ZSTD_DStreamInSize();
+    const size_t outCapacity = ZSTD_DStreamOutSize();
+    binarypatch_zstd_session* self;
+
+    /* The uncompressed size is tracked by the caller's patch stream, not here. */
+    (void)dataSize;
+
+    self = (binarypatch_zstd_session*)malloc(sizeof(binarypatch_zstd_session) + inCapacity + outCapacity);
+    if (!self) {
+        _hpatch_update_decError(decompressPlugin, hpatch_dec_mem_error);
+        return 0;
+    }
+    memset(self, 0, sizeof(binarypatch_zstd_session));
+    self->codeStream = codeStream;
+    self->codeReadPos = code_begin;
+    self->codeEnd = code_end;
+    self->in.src = self->buffers;
+    self->in.size = 0;
+    self->in.pos = 0; /* pos == size: the input buffer starts empty and is refilled on demand */
+    self->inCapacity = inCapacity;
+    self->out.dst = self->buffers + inCapacity;
+    self->out.size = outCapacity;
+    self->out.pos = 0;
+    self->outReadPos = 0;
+
+    self->dstream = ZSTD_createDStream();
+    if (!self->dstream) {
+        free(self);
+        _hpatch_update_decError(decompressPlugin, hpatch_dec_open_error);
+        return 0;
+    }
+    /*
+     * The window bound is applied here rather than left at zstd's default, and a
+     * session that cannot take it is refused: without the bound a corrupted frame
+     * header could ask for a much larger window than any patch legitimately needs.
+     */
+    if (ZSTD_isError(ZSTD_initDStream(self->dstream)) ||
+        ZSTD_isError(ZSTD_DCtx_setParameter(self->dstream, ZSTD_d_windowLogMax,
+                                            BINARYPATCH_ZSTD_WINDOW_LOG_MAX))) {
+        ZSTD_freeDStream(self->dstream);
+        free(self);
+        _hpatch_update_decError(decompressPlugin, hpatch_dec_open_error);
+        return 0;
+    }
+    return self;
+}
+
+static hpatch_BOOL _zstd_close(struct hpatch_TDecompress* decompressPlugin,
+                               hpatch_decompressHandle decompressHandle) {
+    binarypatch_zstd_session* self = (binarypatch_zstd_session*)decompressHandle;
+    hpatch_BOOL result = hpatch_TRUE;
+    if (!self) {
+        return hpatch_TRUE;
+    }
+    /* Report the session's failure through the plugin so the caller can read it. */
+    if (self->decError != hpatch_dec_ok) {
+        _hpatch_update_decError(decompressPlugin, self->decError);
+    }
+    if (0 != ZSTD_freeDStream(self->dstream)) {
+        result = hpatch_FALSE;
+        _hpatch_update_decError(decompressPlugin, hpatch_dec_close_error);
+    }
+    free(self);
+    return result;
+}
+
+/*
+ * Must fill the whole `[out_part_data, out_part_data_end)` range; anything less is
+ * an error by the `hpatch_TDecompress` contract.
+ */
+static hpatch_BOOL _zstd_decompress_part(hpatch_decompressHandle decompressHandle,
+                                         unsigned char* out_part_data,
+                                         unsigned char* out_part_data_end) {
+    binarypatch_zstd_session* self = (binarypatch_zstd_session*)decompressHandle;
+
+    while (out_part_data < out_part_data_end) {
+        size_t ready = self->out.pos - self->outReadPos;
+        size_t ret;
+
+        if (ready > 0) {
+            const size_t wanted = (size_t)(out_part_data_end - out_part_data);
+            if (ready > wanted) {
+                ready = wanted;
+            }
+            memcpy(out_part_data, (const unsigned char*)self->out.dst + self->outReadPos, ready);
+            out_part_data += ready;
+            self->outReadPos += ready;
+            continue;
+        }
+
+        if (self->in.pos == self->in.size) {
+            const hpatch_StreamPos_t remaining = self->codeEnd - self->codeReadPos;
+            unsigned char* inBuf = (unsigned char*)self->in.src;
+            size_t toRead = self->inCapacity;
+            if (remaining < (hpatch_StreamPos_t)toRead) {
+                toRead = (size_t)remaining;
+            }
+            self->in.pos = 0;
+            self->in.size = toRead;
+            if (toRead > 0) {
+                if (!self->codeStream->read(self->codeStream, self->codeReadPos, inBuf, inBuf + toRead)) {
+                    return _zstd_fail(self);
+                }
+                self->codeReadPos += toRead;
+            }
+        }
+
+        self->out.pos = 0;
+        self->outReadPos = 0;
+        ret = ZSTD_decompressStream(self->dstream, &self->out, &self->in);
+        if (ZSTD_isError(ret)) {
+            return _zstd_fail(self);
+        }
+        /*
+         * No progress with no input left means the compressed stream ended before
+         * the patch asked for its last byte - a truncated or corrupt patch.
+         */
+        if (self->out.pos == 0) {
+            return _zstd_fail(self);
+        }
+    }
+    return hpatch_TRUE;
+}
+
+void binarypatch_zstd_decompressor_init(hpatch_TDecompress* out_decompressor) {
+    memset(out_decompressor, 0, sizeof(hpatch_TDecompress));
+    out_decompressor->is_can_open = _zstd_is_can_open;
+    out_decompressor->open = _zstd_open;
+    out_decompressor->close = _zstd_close;
+    out_decompressor->decompress_part = _zstd_decompress_part;
+    /* reset_code stays NULL: it is only needed for vcdiff style patches. */
+}

package/cpp/binarypatch/binarypatch_zstd_decompressor.h

@@ -0,0 +1,47 @@
+/*
+ * zstd decompressor for HDiffPatch.
+ *
+ * HDiffPatch's patch functions take the decompressor as a plugin, so every codec
+ * the appliers must understand has to be supplied through `hpatch_TDecompress`.
+ * CodePush patches are always produced with `hdiffz -f -m-6 -c-zstd-21-24`, so
+ * zstd is the only codec implemented here; upstream ships a demo header covering
+ * a dozen codecs, but pulling that in would drag along headers for codecs the
+ * appliers never see.
+ *
+ * `hpatch_TDecompress` carries a mutable `decError` field, so each patch session
+ * must own its instance. Callers therefore declare the struct themselves and
+ * initialize it through `binarypatch_zstd_decompressor_init()`.
+ *
+ * This file and the vendored sources next to it sit outside the platform
+ * directories because both platforms compile them: iOS through the podspec at the
+ * repository root, Android through externalNativeBuild. One shared copy is what
+ * keeps the two appliers from drifting apart.
+ */
+
+#ifndef BINARYPATCH_ZSTD_DECOMPRESSOR_H
+#define BINARYPATCH_ZSTD_DECOMPRESSOR_H
+
+#include "libHDiffPatch/HPatch/patch_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The `compressType` string that `hdiffz -c-zstd-...` writes into the patch
+ * header, and the only value this decompressor accepts.
+ */
+#define BINARYPATCH_ZSTD_COMPRESS_TYPE "zstd"
+
+/*
+ * Fills `out_decompressor` with the zstd plugin implementation. The struct is
+ * fully overwritten, so it needs no prior initialization, and it holds no state
+ * that must be released.
+ */
+void binarypatch_zstd_decompressor_init(hpatch_TDecompress* out_decompressor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BINARYPATCH_ZSTD_DECOMPRESSOR_H */

package/cpp/binarypatch/vendor/HDiffPatch/libHDiffPatch/HPatch/checksum_plugin.h

@@ -0,0 +1,52 @@
+//checksum_plugin.h
+//  checksum plugin type
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef HPatch_checksum_plugin_h
+#define HPatch_checksum_plugin_h
+#include "patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef void*  hpatch_checksumHandle;
+    typedef struct hpatch_TChecksum{
+        //return type tag; strlen(result)<=hpatch_kMaxPluginTypeLength; (Note:result lifetime)
+        const char*   (*checksumType)(void); //ascii cstring,cannot contain '&'
+        hpatch_size_t (*checksumByteSize)(void); //0<result<=hpatch_kStreamCacheSize
+        hpatch_checksumHandle (*open)(struct hpatch_TChecksum* plugin);
+        void                 (*close)(struct hpatch_TChecksum* plugin,hpatch_checksumHandle handle);
+        void                 (*begin)(hpatch_checksumHandle handle); //must support reset
+        void                (*append)(hpatch_checksumHandle handle,
+                                      const unsigned char* part_data,const unsigned char* part_data_end);
+        void                   (*end)(hpatch_checksumHandle handle,
+                                      unsigned char* checksum,unsigned char* checksum_end);
+    } hpatch_TChecksum;
+    
+#ifdef __cplusplus
+}
+#endif
+#endif

package/cpp/binarypatch/vendor/HDiffPatch/libHDiffPatch/HPatch/hpatch_mt/hpatch_mt.h

@@ -0,0 +1,147 @@
+//  hpatch_mt.h
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+#ifndef hpatch_mt_h
+#define hpatch_mt_h
+#include "../patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct{
+    hpatch_byte     writeNew_isMT;          //0 or 1; if 1, start a thread for write to newData
+    hpatch_byte     readOld_isMT;           //0 or 1; if 1, start a thread for read from oldData
+    hpatch_byte     readDiff_isMT;          //0 or 1; if 1, start a thread for read from diffData
+    hpatch_byte     decompressDiff_isMT;    //0 or 1; if 1, start a thread for decompress diffData
+    //patch func run in main thread
+} hpatchMTSets_t;
+
+static const hpatchMTSets_t hpatchMTSets_no  ={0,0,0,0};
+static const hpatchMTSets_t hpatchMTSets_full={1,1,1,1};
+static hpatch_force_inline
+size_t _hpatchMTSets_threadNum(const hpatchMTSets_t mtsets){
+            return mtsets.writeNew_isMT+mtsets.readOld_isMT+mtsets.readDiff_isMT+mtsets.decompressDiff_isMT+1; }
+
+static hpatch_force_inline 
+hpatchMTSets_t hpatch_getMTSets(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                               const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,size_t stepMemSize,
+                               size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets){
+#if (_IS_USED_MULTITHREAD)
+    hpatchMTSets_t _hpatch_getMTSets(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                                     const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
+                                     hpatch_size_t windowOldBufSize,size_t stepMemSize,
+                                     size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets,hpatch_BOOL isWindow);
+    if (maxThreadNum<=1) return hpatchMTSets_no;
+    return _hpatch_getMTSets(newSize,oldSize,diffSize,decompressPlugin,kCacheCount,0,stepMemSize,
+                             temp_cacheSumSize,maxThreadNum,mtsets,hpatch_FALSE);
+#else
+    return hpatchMTSets_no;
+#endif
+}
+
+
+#define     _kCacheSgCount  3  //patch for singleCompressedDiff need cache count
+hpatch_BOOL _patch_single_stream_mt(sspatch_listener_t* listener,
+                                    const hpatch_TStreamOutput* __out_newData,
+                                    const hpatch_TStreamInput*  oldData,
+                                    const hpatch_TStreamInput*  singleCompressedDiff, 
+                                    hpatch_StreamPos_t  diffInfo_pos,
+                                    sspatch_coversListener_t* coversListener,
+                                    size_t maxThreadNum,hpatchMTSets_t hpatchMTSets);
+hpatch_BOOL _patch_single_compressed_diff_mt(const hpatch_TStreamOutput* out_newData,
+                                             const hpatch_TStreamInput*  oldData,
+                                             const hpatch_TStreamInput*  singleCompressedDiff,
+                                             hpatch_StreamPos_t          diffData_pos,
+                                             hpatch_StreamPos_t          uncompressedSize,
+                                             hpatch_StreamPos_t          compressedSize,
+                                             hpatch_TDecompress*         decompressPlugin,
+                                             hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
+                                             unsigned char* temp_cache,unsigned char* temp_cache_end,
+                                             sspatch_coversListener_t* coversListener,
+                                             size_t maxThreadNum,hpatchMTSets_t mtsets);
+
+#if (_IS_USED_MULTITHREAD)
+
+struct hpatch_mt_manager_t;
+
+struct hpatch_mt_manager_t* hpatch_mt_manager_open(const hpatch_TStreamOutput** pout_newData,
+                                                   const hpatch_TStreamInput**  poldData,
+                                                   const hpatch_TStreamInput**  psingleCompressedDiff,
+                                                   hpatch_StreamPos_t*          pdiffData_pos,
+                                                   hpatch_StreamPos_t*          pdiffData_posEnd,
+                                                   hpatch_StreamPos_t           uncompressedSize,
+                                                   hpatch_TDecompress**         pdecompressPlugin,
+                                                   size_t                       stepMemSize,
+                                                   unsigned char** ptemp_cache,unsigned char** ptemp_cache_end,
+                                                   sspatch_coversListener_t**   pcoversListener,
+                                                   hpatch_BOOL                  isOnStepCoversInThread,
+                                                   size_t                       kCacheCount,
+                                                   hpatchMTSets_t               mtsets);
+
+hpatch_BOOL                 hpatch_mt_manager_close(struct hpatch_mt_manager_t* self,hpatch_BOOL isOnError);
+
+
+
+struct hpatch_mt_manager_win_t;
+struct hcache_window_old_mt_t;
+
+static hpatch_force_inline 
+hpatchMTSets_t hpatch_getMTSets_win(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                                    const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
+                                    hpatch_size_t windowOldBufSize, hpatch_size_t stepMemSize,
+                                    size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets){
+#if (_IS_USED_MULTITHREAD)
+    if (maxThreadNum<=1) return hpatchMTSets_no;
+    hpatchMTSets_t _hpatch_getMTSets(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                                     const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
+                                     hpatch_size_t windowOldBufSize,size_t stepMemSize,
+                                     size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets,hpatch_BOOL isWindow);
+    return _hpatch_getMTSets(newSize,oldSize,diffSize,decompressPlugin,kCacheCount,windowOldBufSize,stepMemSize,
+                             temp_cacheSumSize,maxThreadNum,mtsets,hpatch_TRUE);
+#else
+    return hpatchMTSets_no;
+#endif
+}
+
+struct hpatch_mt_manager_win_t* hpatch_mt_manager_win_open(const hpatch_TStreamOutput** pout_newData,
+            const hpatch_TStreamInput**  poldData,const hpatch_TStreamInput**     pwindowDiffStream,
+            hpatch_StreamPos_t*          pdiffData_pos, hpatch_StreamPos_t*       pdiffData_posEnd,
+            hpatch_StreamPos_t           uncompressedSize, hpatch_TDecompress**   pdecompressPlugin,
+            hpatch_StreamPos_t windowCount,hpatch_size_t windowOldBufSize, hpatch_size_t stepMemSize,
+            unsigned char**              ptemp_cache, unsigned char**             ptemp_cache_end,
+            size_t                       kCacheCount, hpatchMTSets_t              mtsets);
+
+struct hcache_window_old_mt_t* hpatch_mt_manager_win_oldCache(struct hpatch_mt_manager_win_t* self);
+
+hpatch_BOOL hpatch_mt_manager_win_close(struct hpatch_mt_manager_win_t* self,hpatch_BOOL isOnError);
+
+#endif // _IS_USED_MULTITHREAD
+
+#ifdef __cplusplus
+}
+#endif
+#endif //hpatch_mt_h