react-native-update 10.34.1 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_client/sync_info_client.h

@@ -0,0 +1,137 @@
+//  sync_info_client.h
+//  sync_client
+//  Created by housisong on 2019-09-18.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2023 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 sync_info_client_h
+#define sync_info_client_h
+#include "sync_client_type.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include <vector>
+#endif
+
+typedef enum TSyncClient_resultType{
+    kSyncClient_ok=0,
+    kSyncClient_optionsError, //cmdline error
+    kSyncClient_memError,
+    kSyncClient_tempFileError,
+    kSyncClient_pathTypeError,
+    kSyncClient_overwritePathError,         // 5
+    kSyncClient_deleteFileError,
+    kSyncClient_renameFileError,
+
+    kSyncClient_getSyncDownloadPluginError=15,
+    kSyncClient_newSyncInfoCreateError,
+    kSyncClient_newSyncInfoCloseError,
+    kSyncClient_newSyncInfoDownloadError,
+    kSyncClient_newSyncInfoOpenError,
+    kSyncClient_newSyncInfoDataError,       // 20
+    kSyncClient_newSyncInfoChecksumError,
+    kSyncClient_newSyncInfoTypeError,    
+    kSyncClient_oldFileOpenError,
+    kSyncClient_oldFileCloseError,
+    kSyncClient_readOldDataError,           // 25
+    kSyncClient_newFileCreateError,
+    kSyncClient_newFileReopenWriteError,
+    kSyncClient_newFileReopenReadError,
+    kSyncClient_newFileCloseError,
+    kSyncClient_writeNewDataError,          // 30
+    kSyncClient_matchNewDataInOldError,
+    kSyncClient_syncDataDownloadError,
+    kSyncClient_syncDataCloseError,
+    kSyncClient_readSyncDataBeginError,
+    kSyncClient_readSyncDataError,          // 35
+    kSyncClient_noReadSyncDataError,
+    kSyncClient_noStrongChecksumPluginError,
+
+    kSyncClient_strongChecksumByteSizeError=40,
+    kSyncClient_strongChecksumOpenError,
+    kSyncClient_checksumSyncDataError,
+    kSyncClient_newDataCheckChecksumError,  // NOTE: safeBit not enough? You should re-download the original unabridged newData!
+    kSyncClient_noDecompressPluginError,
+    kSyncClient_decompressOpenError,        // 45
+    kSyncClient_decompressError,
+    kSyncClient_newDataSizeError,
+    kSyncClient_diffFileCreateError,
+    kSyncClient_diffFileReopenWriteError,   
+    kSyncClient_diffFileCloseError,         // 50
+    kSyncClient_diffFileOpenError,
+    kSyncClient_saveDiffError,             
+    kSyncClient_loadDiffError,
+    
+    //_IS_NEED_DIR_DIFF_PATCH
+    kSyncClient_oldDirOpenError=60,
+    kSyncClient_oldDirFilesOpenError,
+    kSyncClient_oldDirFilesCloseError,
+    kSyncClient_savedNewDirInfoDataError,
+    kSyncClient_newDirOpenInfoError,
+    kSyncClient_newDirOpenError,            // 65
+    kSyncClient_newDirCloseError, 
+    kSyncClient_newDirPatchBeginError,
+    kSyncClient_newDirPatchFinishError,
+
+    kSyncClient_newZsyncInfoTypeError=100,
+    kSyncClient_newZsyncInfoOpenError,
+    kSyncClient_newZsyncInfoCloseError,
+    kSyncClient_newZsyncInfoDataError,
+    kSyncClient_newZsyncInfoMinVersionError,
+    kSyncClient_newZsyncInfoBlockSizeTooSmallError, //105
+    kSyncClient_newZsyncInfoBlockSizeError,
+    kSyncClient_newZsyncInfoZmap2BlocksError,
+    kSyncClient_newZsyncInfoZmap2BlocksSmallError,
+    kSyncClient_newZsyncInfoZMap2DataError,
+
+    kSyncClient_ERROR_CODE_MAX = 200,
+} TSyncClient_resultType;
+
+typedef struct ISyncInfoListener{
+    void*                    infoImport;
+    hsync_TDictDecompress* (*findDecompressPlugin)(ISyncInfoListener* listener,const char* compressType,size_t dictSize);
+    hpatch_TChecksum*      (*findChecksumPlugin)  (ISyncInfoListener* listener,const char* strongChecksumType);
+    //onLoadedNewSyncInfo can null
+    void                   (*onLoadedNewSyncInfo) (ISyncInfoListener* listener,TNewDataSyncInfo* newSyncInfo);
+    //onNeedSyncInfo can null
+    void                   (*onNeedSyncInfo)      (ISyncInfoListener* listener,const TNeedSyncInfos* needSyncInfo);
+} ISyncInfoListener;
+
+hpatch_inline static
+void TNewDataSyncInfo_init(TNewDataSyncInfo* self) { memset(self,0,sizeof(*self)); }
+
+TSyncClient_resultType TNewDataSyncInfo_open_by_file(TNewDataSyncInfo* self,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                                     ISyncInfoListener* listener);
+TSyncClient_resultType TNewDataSyncInfo_open(TNewDataSyncInfo* self,const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL isIgnoreCompressInfo,
+                                             ISyncInfoListener* listener);
+void TNewDataSyncInfo_close(TNewDataSyncInfo* self);
+
+TSyncClient_resultType  checkNewSyncInfoType_by_file(const char* newSyncInfoFile,hpatch_BOOL* out_newIsDir);
+TSyncClient_resultType  checkNewSyncInfoType(const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL* out_newIsDir);
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+void TNewDataSyncInfo_dir_saveTo(TNewDataSyncInfo_dir* self,std::vector<hpatch_byte>& out_buf);
+TSyncClient_resultType TNewDataSyncInfo_dir_load(TNewDataSyncInfo_dir* outDirInfo,const hpatch_byte* buf,size_t bufSize);
+#endif
+
+#endif // sync_info_client_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/dict_compress_plugin.h

@@ -0,0 +1,83 @@
+//  dict_compress_plugin.h
+//  sync_make
+//  Created by housisong on 2020-03-08.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2020-2023 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 dict_compress_plugin_h
+#define dict_compress_plugin_h
+#include "../../libHDiffPatch/HPatch/patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef void*  hsync_dictCompressHandle;
+    
+    //dict compress plugin
+    typedef struct hsync_TDictCompress{
+        //return type tag; strlen(result)<=hpatch_kMaxPluginTypeLength; (Note:result lifetime)
+        const char*                  (*compressType)(void);//ascii cstring,cannot contain '&'
+        //return the max compressed size, if input dataSize data;
+        hpatch_StreamPos_t      (*maxCompressedSize)(hpatch_StreamPos_t in_dataSize);
+        size_t                (*limitDictSizeByData)(struct hsync_TDictCompress* compressPlugin,size_t blockCount,size_t blockSize);
+        size_t              (*getBestWorkBlockCount)(struct hsync_TDictCompress* compressPlugin,size_t blockCount,
+                                                     size_t blockSize,size_t defaultWorkBlockCount);
+        size_t                        (*getDictSize)(struct hsync_TDictCompress* compressPlugin);
+        hsync_dictCompressHandle (*dictCompressOpen)(struct hsync_TDictCompress* compressPlugin,size_t blockCount,size_t blockSize);
+        void                    (*dictCompressClose)(struct hsync_TDictCompress* compressPlugin,
+                                                     hsync_dictCompressHandle dictHandle);
+        //if not need send info to decompressor, dictCompressInfo can NULL
+        size_t                   (*dictCompressInfo)(const struct hsync_TDictCompress* compressPlugin,hsync_dictCompressHandle dictHandle,
+                                                     hpatch_byte* out_info,hpatch_byte* out_infoEnd);
+        hpatch_byte*           (*getResetDictBuffer)(hsync_dictCompressHandle dictHandle,size_t blockIndex,
+                                                     size_t* out_dictSize);
+        size_t                       (*dictCompress)(hsync_dictCompressHandle dictHandle,size_t blockIndex,
+                                                     hpatch_byte* out_code,hpatch_byte* out_codeEnd,
+                                                     const hpatch_byte* in_dataBegin,size_t in_dataSize,size_t in_borderSize);
+        const char*        (*compressTypeForDisplay)(void);//like compressType but just for display,can NULL
+        size_t              (*getDictCompressBorder)(void);//if 0,can NULL
+    } hsync_TDictCompress;
+
+    #define  kDictCompressCancel   (~(size_t)0)
+    #define  kDictCompressError     ((size_t)0)
+
+    
+    static hpatch_byte* _CacheBlockDict_getResetDictBuffer(_CacheBlockDict_t* self,size_t blockIndex,
+                                                           size_t* out_dictSize){
+        size_t dictSize=self->dictSize;
+        hpatch_StreamPos_t prefixSize=((hpatch_StreamPos_t)blockIndex)*self->blockSize;
+        assert(self->uncompress);
+        assert(prefixSize>=0);
+        if (dictSize>prefixSize) dictSize=(size_t)prefixSize;
+        self->block_cache_i=blockIndex;
+        *out_dictSize=dictSize;
+        self->uncompressCur=self->uncompress+dictSize;
+        return self->uncompress;
+    }
+
+#ifdef __cplusplus
+}
+#endif
+#endif // dict_compress_plugin_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/dir_sync_make.cpp

@@ -0,0 +1,125 @@
+//  dir_sync_make.cpp
+//  sync_make
+//  Created by housisong on 2019-10-01.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2023 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.
+ */
+#include "dir_sync_make.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../../dirDiffPatch/dir_diff/dir_diff_tools.h"
+#include "sync_make_hash_clash.h"
+#include "sync_info_make.h"
+#include "sync_make_private.h"
+using namespace hdiff_private;
+using namespace sync_private;
+
+static void getRefList(const std::vector<std::string>& newList,
+                       std::vector<hpatch_StreamPos_t>& out_newSizeList){
+    out_newSizeList.assign(newList.size(),0);
+    for (size_t newi=0; newi<newList.size(); ++newi){
+        const std::string& fileName=newList[newi];
+        if (isDirName(fileName)) continue;
+        out_newSizeList[newi]=getFileSize(fileName);
+    }
+}
+
+void create_dir_sync_data(IDirSyncListener*         listener,
+                          const TManifest&          newManifest,
+                          const char*               out_hsyni_file,
+                          const char*               out_hsynz_file,
+                          size_t                    kMaxOpenFileNumber,
+                          hpatch_TChecksum*         strongChecksumPlugin,
+                          hsync_TDictCompress*      compressPlugin,
+                          hsync_THsynz*             hsynzPlugin,
+                          uint32_t kSyncBlockSize,size_t kSafeHashClashBit,size_t threadNum){
+    assert(listener!=0);
+    assert((out_hsynz_file!=0)&&(strlen(out_hsynz_file)>0));
+    assert(kMaxOpenFileNumber>=kMaxOpenFileNumber_limit_min);
+    kMaxOpenFileNumber-=2; // for out_hsyni_file & out_hsynz_file
+    const std::vector<std::string>& newList=newManifest.pathList;
+    std::vector<hpatch_StreamPos_t> newSizeList;
+    std::vector<size_t> newExecuteList; //for linux etc
+
+    for (size_t newi=0; newi<newList.size(); ++newi) {
+        if ((!isDirName(newList[newi]))&&(listener->isExecuteFile(newList[newi])))
+            newExecuteList.push_back(newi);
+    }
+    getRefList(newList,newSizeList);
+
+    TNewDataSyncInfo_dir     dirInfo={0};
+    std::vector<hpatch_byte> dirInfoSavedData;
+    dirInfo.dir_newPathCount=newList.size();
+    dirInfo.dir_newNameList_isCString=hpatch_FALSE;
+    dirInfo.dir_utf8NewNameList=newList.data();
+    dirInfo.dir_utf8NewRootPath=newManifest.rootPath.c_str();
+    dirInfo.dir_newSizeList=newSizeList.data();
+    dirInfo.dir_newExecuteCount=newExecuteList.size();
+    dirInfo.dir_newExecuteIndexList=newExecuteList.data();
+    TNewDataSyncInfo_dirWithHead_saveTo(&dirInfo,dirInfoSavedData);
+
+    CFileResHandleLimit resLimit(kMaxOpenFileNumber,newList.size()+1);
+    hpatch_StreamPos_t maxNewSize=dirInfoSavedData.size();
+    {
+        resLimit.addBufRes(dirInfoSavedData.data(),dirInfoSavedData.size());
+        for (size_t i=0; i<newSizeList.size(); ++i) {
+            hpatch_StreamPos_t newSize=newSizeList[i];
+            maxNewSize=(newSize>maxNewSize)?newSize:maxNewSize;
+            resLimit.addRes(newList[i],newSize);
+        }
+    }
+    if (kSyncBlockSize>maxNewSize){
+        kSyncBlockSize=(uint32_t)maxNewSize;
+        if (kSyncBlockSize<kSyncBlockSize_min)
+            kSyncBlockSize=kSyncBlockSize_min;
+    }
+    
+    resLimit.open();
+    CRefStream newRefStream;
+    const size_t kAlignSize=kSyncBlockSize;
+    newRefStream.open(resLimit.limit.streamList,resLimit.limit.streamCount,kAlignSize);
+    
+    bool isSafeHashClash=getStrongForHashClash(kSafeHashClashBit,newRefStream.stream->streamSize,kSyncBlockSize,
+                                               strongChecksumPlugin->checksumByteSize()*8);
+    listener->syncRefInfo(newManifest.rootPath.c_str(),newList.size(),newRefStream.stream->streamSize,
+                          kSyncBlockSize,isSafeHashClash);
+    checkv(isSafeHashClash); //warning as error
+
+    CNewDataSyncInfo  newDataSyncInfo(strongChecksumPlugin,compressPlugin,
+                                      newRefStream.stream->streamSize,kSyncBlockSize,kSafeHashClashBit);
+    newDataSyncInfo.isDirSyncInfo=hpatch_TRUE;
+    newDataSyncInfo.dirInfo=dirInfo;
+    newDataSyncInfo.dirInfoSavedSize=dirInfoSavedData.size();
+    
+    CFileStreamOutput out_newSyncInfo(out_hsyni_file,~(hpatch_StreamPos_t)0);
+    CFileStreamOutput out_newSyncData(out_hsynz_file,~(hpatch_StreamPos_t)0);
+    
+    _private_create_sync_data(&newDataSyncInfo, newRefStream.stream,&out_newSyncInfo.base,
+                              &out_newSyncData.base, compressPlugin,hsynzPlugin,threadNum);
+}
+
+
+
+#endif
+

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/dir_sync_make.h

@@ -0,0 +1,56 @@
+//  dir_sync_make.h
+//  sync_make
+//  Created by housisong on 2019-10-01.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2020 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 dir_sync_make_h
+#define dir_sync_make_h
+#include "sync_make.h"
+#include "../../dirDiffPatch/dir_patch/dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../../dirDiffPatch/dir_diff/dir_manifest.h"
+
+struct IDirSyncListener{
+    virtual ~IDirSyncListener(){}
+    virtual bool isExecuteFile(const std::string& fileName) { return false; }
+    virtual void syncRefInfo(const char* rootDirPath,size_t pathCount,hpatch_StreamPos_t refFileSize,
+                             uint32_t kSyncBlockSize,bool isSafeHashClash){}
+};
+
+void create_dir_sync_data(IDirSyncListener*         listener,
+                          const TManifest&          newManifest,
+                          const char*               out_hsyni_file, // .hsyni
+                          const char*               out_hsynz_file, // .hsynz
+                          size_t                    kMaxOpenFileNumber,
+                          hpatch_TChecksum*         strongChecksumPlugin,
+                          hsync_TDictCompress*      compressPlugin,
+                          hsync_THsynz*             hsynzPlugin=0,
+                          uint32_t kSyncBlockSize=kSyncBlockSize_default,
+                          size_t kSafeHashClashBit=kSafeHashClashBit_default,
+                          size_t threadNum=1);
+
+#endif
+#endif // dir_sync_make_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/hsynz_plugin.h

@@ -0,0 +1,55 @@
+//  hsynz_plugin.h
+//  sync_make
+//  Created by housisong on 2022-12-15.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2022 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 hsynz_plugin_h
+#define hsynz_plugin_h
+#include "../../libHDiffPatch/HPatch/patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    //hsynz plugin
+    typedef struct hsync_THsynz{
+        //return new curOutPos
+        hpatch_StreamPos_t (*hsynz_write_head)(struct hsync_THsynz* zPlugin,
+                                               const hpatch_TStreamOutput* out_stream,hpatch_StreamPos_t curOutPos,
+                                               bool isDirSync,hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize,
+                                               hpatch_TChecksum* strongChecksumPlugin,hsync_TDictCompress* compressPlugin);
+        //hsynz_readed_data can null
+        void              (*hsynz_readed_data)(struct hsync_THsynz* zPlugin,
+                                               const hpatch_byte* newData,size_t dataSize);
+        //return new curOutPos
+        hpatch_StreamPos_t (*hsynz_write_foot)(struct hsync_THsynz* zPlugin,
+                                               const hpatch_TStreamOutput* out_stream,hpatch_StreamPos_t curOutPos,
+                                               const hpatch_byte* newDataCheckChecksum,size_t checksumSize);
+    } hsync_THsynz;
+
+#ifdef __cplusplus
+}
+#endif
+#endif // hsynz_plugin_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/match_in_new.cpp

@@ -0,0 +1,147 @@
+//  match_in_new.cpp
+//  sync_make
+//  Created by housisong on 2019-09-25.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2020 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.
+ */
+#include "match_in_new.h"
+#include <algorithm> //sort, equal_range lower_bound
+#include "../sync_client/sync_client_type_private.h"
+#include "../../libHDiffPatch/HDiff/private_diff/mem_buf.h"
+
+using namespace hdiff_private;
+namespace sync_private{
+
+typedef uint64_t tm_roll_uint;
+
+struct TIndex_comp{
+    inline explicit TIndex_comp(const uint8_t* _hashs,size_t _byteSize)
+    :hashs(_hashs),byteSize(_byteSize){ }
+    typedef uint32_t TIndex;
+    struct TDigest{
+        const uint8_t*  hashs;
+        TIndex          index;
+        inline explicit TDigest(const uint8_t* _hashs,TIndex _index)
+        :hashs(_hashs),index(_index){}
+    };
+    inline bool operator()(const TIndex x,const TDigest& y)const { //for equal_range
+        int cmp=_cmp(hashs+x*byteSize,y.hashs+y.index*byteSize,byteSize);
+        if (cmp!=0)
+            return cmp<0; //value
+        else
+            return y.index<=x; //for: assert(newBlockIndex<i);
+    }
+    bool operator()(const TDigest& x,const TIndex y)const { //for equal_range
+        int cmp=_cmp(x.hashs+x.index*byteSize,hashs+y*byteSize,byteSize);
+        if (cmp!=0)
+            return cmp<0; //value
+        else
+            return x.index<=y; //for: assert(newBlockIndex<i);
+    }
+    
+    inline bool operator()(const TIndex x, const TIndex y)const {//for sort
+        int cmp=_cmp(hashs+x*byteSize,hashs+y*byteSize,byteSize);
+        if (cmp!=0)
+            return cmp<0; //value sort
+        else
+            return x>y; //index sort
+    }
+protected:
+    const uint8_t*  hashs;
+    size_t          byteSize;
+    inline static int _cmp(const uint8_t* px,const uint8_t* py,size_t byteSize){
+        const uint8_t* px_end=px+byteSize;
+        for (;px!=px_end;++px,++py){
+            int sub=(int)(*px)-(*py);
+            if (sub!=0) return sub; //value sort
+        }
+        return 0;
+    }
+};
+
+void matchNewDataInNew(TNewDataSyncInfo* newSyncInfo){
+    uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(newSyncInfo);
+    const unsigned char* partChecksums=newSyncInfo->partChecksums;
+    TSameNewBlockPair* samePairList=newSyncInfo->samePairList;
+
+    TAutoMem _mem(kBlockCount*(size_t)sizeof(uint32_t));
+    uint32_t* sorted_newIndexs=(uint32_t*)_mem.data();
+    for (uint32_t i=0; i<kBlockCount; ++i){
+        sorted_newIndexs[i]=i;
+    }
+    const size_t savedRollHashByteSize=newSyncInfo->savedRollHashByteSize;
+    const size_t savedRollHashBits=newSyncInfo->savedRollHashBits;
+    TIndex_comp icomp(newSyncInfo->rollHashs,savedRollHashByteSize);
+    std::sort(sorted_newIndexs,sorted_newIndexs+kBlockCount,icomp);
+    
+    //optimize for std::equal_range
+    unsigned int kTableBit =getBetterCacheBlockTableBit(kBlockCount);
+    if (kTableBit>savedRollHashBits) kTableBit=(unsigned int)savedRollHashBits;
+    const unsigned int kTableHashShlBit=(unsigned int)(savedRollHashBits-kTableBit);
+    TAutoMem _mem_table((size_t)sizeof(uint32_t)*((1<<kTableBit)+1));
+    uint32_t* sorted_newIndexs_table=(uint32_t*)_mem_table.data();
+    {
+        uint32_t* pos=sorted_newIndexs;
+        uint8_t part[sizeof(tm_roll_uint)]={0};
+        for (uint32_t i=0; i<((uint32_t)1<<kTableBit); ++i) {
+            tm_roll_uint digest=((tm_roll_uint)i)<<kTableHashShlBit;
+            writeRollHashBytes(part,digest,savedRollHashByteSize);
+            TIndex_comp::TDigest digest_value(part,0);
+            pos=std::lower_bound(pos,sorted_newIndexs+kBlockCount,digest_value,icomp);
+            sorted_newIndexs_table[i]=(uint32_t)(pos-sorted_newIndexs);
+        }
+        sorted_newIndexs_table[((size_t)1<<kTableBit)]=kBlockCount;
+    }
+
+    TIndex_comp dcomp(newSyncInfo->rollHashs,savedRollHashByteSize);
+    uint32_t matchedCount=0;
+    const unsigned char* curChecksum=partChecksums;
+    for (uint32_t i=0; i<kBlockCount; ++i,curChecksum+=newSyncInfo->savedStrongChecksumByteSize){
+        TIndex_comp::TDigest digest_value(newSyncInfo->rollHashs,i);
+        tm_roll_uint digest=readRollHashBytes(newSyncInfo->rollHashs+i*savedRollHashByteSize,
+                                              savedRollHashByteSize);
+        const uint32_t* ti_pos=&sorted_newIndexs_table[digest>>kTableHashShlBit];
+        std::pair<const uint32_t*,const uint32_t*>
+            //range=std::equal_range(sorted_newIndexs,sorted_newIndexs+kBlockCount,digest_value,dcomp);
+            range=std::equal_range(sorted_newIndexs+ti_pos[0],
+                                   sorted_newIndexs+ti_pos[1],digest_value,dcomp);
+        for (;range.first!=range.second; ++range.first) {
+            uint32_t newBlockIndex=*range.first;
+            assert(newBlockIndex<i);
+            const unsigned char* newChecksum=partChecksums+newBlockIndex*newSyncInfo->savedStrongChecksumByteSize;
+            if (0==memcmp(newChecksum,curChecksum,newSyncInfo->savedStrongChecksumByteSize)){
+                samePairList[matchedCount].curIndex=i;
+                samePairList[matchedCount].sameIndex=newBlockIndex;
+                ++matchedCount;
+                break;
+            }
+        }
+    }
+    //printf("matchedCount: %d\n",matchedCount);
+    newSyncInfo->samePairCount=matchedCount;
+}
+
+}//namespace sync_private
+

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/match_in_new.h

@@ -0,0 +1,38 @@
+//  match_in_new.h
+//  sync_make
+//  Created by housisong on 2019-09-25.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2020 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 match_in_new_h
+#define match_in_new_h
+#include "../sync_client/sync_client_type.h"
+namespace sync_private{
+    
+    //get samePairList\samePairCount
+    void matchNewDataInNew(TNewDataSyncInfo* newSyncInfo);
+
+}//namespace sync_private
+#endif // match_in_new_h