react-native-update 10.34.3 → 10.34.5

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

@@ -1,697 +0,0 @@
-//  sync_client.cpp
-//  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.
- */
-#include "sync_client_private.h"
-#include "../../file_for_patch.h"
-#include "match_in_old.h"
-#include "sync_diff_data.h"
-#include <stdexcept>
-namespace sync_private{
-
-#define check(v,errorCode) \
-            do{ if (!(v)) { if (result==kSyncClient_ok) result=errorCode; \
-                            if (!_inClear) goto clear; } }while(0)
-void checkChecksumInit(unsigned char* checkChecksumBuf,size_t kStrongChecksumByteSize){
-        unsigned char* d_xor=checkChecksumBuf+kStrongChecksumByteSize;
-        assert(kStrongChecksumByteSize>0);
-        memset(d_xor,0xFF,kStrongChecksumByteSize); }
-
-    static hpatch_inline
-    void _writeUInt32(unsigned char* dst,uint32_t v){
-        dst[0]=(unsigned char)v;       dst[1]=(unsigned char)(v>>8);
-        dst[2]=(unsigned char)(v>>16); dst[3]=(unsigned char)(v>>24); }
-
-void checkChecksumAppendData(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
-                             hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
-                             const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize){
-    const size_t kStrongChecksumByteSize=checkChecksumPlugin->checksumByteSize();
-    unsigned char* d_xor=checkChecksumBuf+kStrongChecksumByteSize;
-    unsigned char* d_xor_end=d_xor+kStrongChecksumByteSize;
-    unsigned char* _ccBuf=checkChecksumBuf+kStrongChecksumByteSize*2;
-
-    unsigned char _checksumIndex[4*3];
-    _writeUInt32(&_checksumIndex[0],checksumIndex);
-    const uint64_t _fchecksum=fast_adler64_start(&_checksumIndex[0],4);
-    _writeUInt32(&_checksumIndex[4],(uint32_t)_fchecksum);
-    _writeUInt32(&_checksumIndex[4*2],(uint32_t)(_fchecksum>>32));
-
-    checkChecksumPlugin->begin(checkChecksum);
-    checkChecksumPlugin->append(checkChecksum,&_checksumIndex[0],(&_checksumIndex[0])+4*3);
-    checkChecksumPlugin->append(checkChecksum,blockChecksum,blockChecksum+kStrongChecksumByteSize);
-    checkChecksumPlugin->end(checkChecksum,_ccBuf,_ccBuf+kStrongChecksumByteSize);
-
-    while (d_xor<d_xor_end){
-        (*d_xor++)^=*_ccBuf++;
-    }
-}
-
-void checkChecksumEndTo(unsigned char* dst,unsigned char* checkChecksumBuf,
-                        hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum){
-    const size_t kStrongChecksumByteSize=checkChecksumPlugin->checksumByteSize();
-    const unsigned char* d_xor=checkChecksumBuf+kStrongChecksumByteSize;
-    const unsigned char* d_xor_end=d_xor+kStrongChecksumByteSize;
-    while (d_xor<d_xor_end){
-        *dst++=(*d_xor++);
-    }
-}
-
-
-bool _open_continue_out(hpatch_BOOL& isOutContinue,const char* outFile,hpatch_TFileStreamOutput* out_stream,
-                        hpatch_TStreamInput* continue_stream,hpatch_StreamPos_t maxContinueLength){
-    memset(continue_stream,0,sizeof(*continue_stream));
-    if ((isOutContinue)&&(hpatch_isPathExist(outFile))){
-        if (!hpatch_TFileStreamOutput_reopen(out_stream,outFile,(hpatch_StreamPos_t)(-1))) return false;
-        hpatch_TFileStreamOutput_setRandomOut(out_stream,hpatch_TRUE); //can rewrite
-        if (out_stream->out_length>maxContinueLength) return false;
-        if (out_stream->out_length>0){
-            assert(out_stream->base.read_writed!=0);
-            *continue_stream=*(hpatch_TStreamInput*)(void*)(&out_stream->base);
-            continue_stream->streamSize=out_stream->out_length;
-            out_stream->out_length=0;
-        }else{
-            isOutContinue=hpatch_FALSE;
-        }
-    }else{
-        isOutContinue=hpatch_FALSE;
-        if (!hpatch_TFileStreamOutput_open(out_stream,outFile,(hpatch_StreamPos_t)(-1))) return false;
-    }
-    return true;
-}
-    
-static void _indexOfCompressedSyncBlock(uint32_t* _followCompressedIndex,const TNewDataSyncInfo* self,
-                                        const hpatch_StreamPos_t* newBlockDataInOldPoss,uint32_t indexBegin){
-    const uint32_t blockCount=(uint32_t)TNewDataSyncInfo_blockCount(self);
-    uint32_t& followCompressedIndex=*_followCompressedIndex;
-    if (self->savedSizes&&(followCompressedIndex<blockCount)){
-        indexBegin=(indexBegin>=followCompressedIndex)?indexBegin:followCompressedIndex;
-        for (uint32_t i=indexBegin;i<blockCount;++i){
-            if ((self->savedSizes[i])&&(isNeedSyncByOldPos(newBlockDataInOldPoss[i]))){
-                followCompressedIndex=i;
-                return;
-            }
-        }
-    }
-    followCompressedIndex=blockCount;
-}
-
-    
-#define _checkSumNewDataBuf() { \
-    if (newDataSize<kSyncBlockSize)/*for backZeroLen*/ \
-        memset(dataBuf+newDataSize,0,kSyncBlockSize-newDataSize);  \
-    strongChecksumPlugin->begin(checksumSync);  \
-    strongChecksumPlugin->append(checksumSync,dataBuf,dataBuf+kSyncBlockSize); \
-    strongChecksumPlugin->end(checksumSync,checksumSync_buf+newSyncInfo->savedStrongChecksumByteSize,    \
-                              checksumSync_buf+newSyncInfo->savedStrongChecksumByteSize \
-                                  +kStrongChecksumByteSize);\
-    toPartChecksum(checksumSync_buf,newSyncInfo->savedStrongChecksumBits, \
-                   checksumSync_buf+newSyncInfo->savedStrongChecksumByteSize, \
-                   kStrongChecksumByteSize);   \
-    check(0==memcmp(checksumSync_buf,   \
-                    newSyncInfo->partChecksums+i*newSyncInfo->savedStrongChecksumByteSize,   \
-                    newSyncInfo->savedStrongChecksumByteSize),kSyncClient_checksumSyncDataError);    \
-}
-
-
-static TSyncClient_resultType writeToNewOrDiff(_TWriteDatas& wd) {
-    _IWriteToNewOrDiff_by wr_by={0};
-    wr_by.checkChecksumAppendData=checkChecksumAppendData;
-    return _writeToNewOrDiff_by(&wr_by,wd);
-}
-
-TSyncClient_resultType _writeToNewOrDiff_by(_IWriteToNewOrDiff_by* wr_by,_TWriteDatas& wd) {
-    const TNewDataSyncInfo* newSyncInfo=wd.newSyncInfo;
-    IReadSyncDataListener*  syncDataListener=wd.syncDataListener;
-    hpatch_TChecksum*       fileChecksumPlugin=newSyncInfo->fileChecksumPlugin;
-    const size_t fileChecksumByteSize=fileChecksumPlugin?fileChecksumPlugin->checksumByteSize():0;
-    hpatch_TChecksum*       strongChecksumPlugin=newSyncInfo->strongChecksumPlugin;
-    const size_t            kStrongChecksumByteSize=strongChecksumPlugin->checksumByteSize();
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(newSyncInfo);
-    const uint32_t kSyncBlockSize=newSyncInfo->kSyncBlockSize;
-    TByte*             _memBuf=0;
-    TByte*             dataBuf=0;
-    TByte*             checksumSync_buf=0;
-    hsync_dictDecompressHandle decompressHandle=0;
-    bool                       isNeedDecompress=(wd.decompressPlugin!=0);  
-    hpatch_checksumHandle checksumSync=0;
-    hpatch_StreamPos_t posInNewSyncData=newSyncInfo->newSyncDataOffsert;
-    hpatch_StreamPos_t posInNeedSyncData=0;
-    hpatch_StreamPos_t outNewDataPos=0;
-    const hpatch_StreamPos_t oldDataSize=wd.oldStream->streamSize;
-    bool isOnDiffContinue =(wd.continueDiffData!=0);
-    uint32_t isDiffContinueSwapped=0;
-    uint32_t followCompressedIndex=0;
-    _indexOfCompressedSyncBlock(&followCompressedIndex,newSyncInfo,wd.newBlockDataInOldPoss,
-                                (wd.newDataContinue!=0)?(uint32_t)(wd.newDataContinue->streamSize/kSyncBlockSize):0);
-    const size_t _kMaxCompressedSize=isNeedDecompress?(size_t)(wd.decompressPlugin->maxCompressedSize(kSyncBlockSize)+2):0;
-    if (followCompressedIndex>=kBlockCount)
-        isNeedDecompress=false;//no blocks need decompress
-    const size_t _memSize=(kSyncBlockSize+(isNeedDecompress?_kMaxCompressedSize:0)+1+1)
-                        +newSyncInfo->savedStrongChecksumByteSize+kStrongChecksumByteSize
-                        +(isNeedDecompress&&wd.decompressPlugin->needFillAlignCode?
-                                wd.decompressPlugin->needFillAlignCode(0,0):0);
-    _memBuf=(TByte*)malloc(_memSize);
-    check(_memBuf!=0,kSyncClient_memError);
-    checksumSync_buf=_memBuf;
-    dataBuf=_memBuf+(newSyncInfo->savedStrongChecksumByteSize+kStrongChecksumByteSize)+1;
-    {//checksum newSyncData
-        checksumSync=strongChecksumPlugin->open(strongChecksumPlugin);
-        check(checksumSync!=0,kSyncClient_strongChecksumOpenError);
-    }
-    if (isNeedDecompress){
-        decompressHandle=wd.decompressPlugin->dictDecompressOpen(wd.decompressPlugin,kBlockCount,kSyncBlockSize,
-                            newSyncInfo->decompressInfo,newSyncInfo->decompressInfo+newSyncInfo->decompressInfoSize);
-        check(decompressHandle,kSyncClient_decompressOpenError);
-    }
-    for (uint32_t backuped_nextBlocki=-1,i=0;i<kBlockCount;++i){
-        //note: all *bits* *half* naming are used for compressed code in zsync's .gz file; hsynz don't require these naming.
-        const bool isCompressedBlock=TNewDataSyncInfo_syncBlockIsCompressed(newSyncInfo,i);
-        hpatch_byte skipBitsInFirstCodeByte;
-        hpatch_byte lastByteHalfBits;
-        const uint32_t syncSize=TNewDataSyncInfo_syncBlockSize(newSyncInfo,i,&skipBitsInFirstCodeByte,&lastByteHalfBits);
-        const uint32_t newDataSize=TNewDataSyncInfo_newDataBlockSize(newSyncInfo,i);
-        check(syncSize<=(isCompressedBlock?_kMaxCompressedSize:kSyncBlockSize),kSyncClient_newSyncInfoDataError);
-        const hpatch_StreamPos_t curDataInOldPos=wd.newBlockDataInOldPoss[i];
-        const bool isNeedSync=isNeedSyncByOldPos(curDataInOldPos);
-        const uint32_t _isNeedBackupHalf=((isNeedSync && skipBitsInFirstCodeByte
-                                          &&(i>0)&&isNeedSyncByOldPos(wd.newBlockDataInOldPoss[i-1]))?1:0);
-        const bool isOnNewDataContinue=(wd.newDataContinue!=0)&&(outNewDataPos+newDataSize<=wd.newDataContinue->streamSize);
-        if (isOnNewDataContinue){ //copy from local newDataContinue
-            check(wd.newDataContinue->read(wd.newDataContinue,outNewDataPos,dataBuf,dataBuf+newDataSize),
-                  kSyncClient_newFileReopenReadError);
-        }else if (isNeedSync){ //download or read from diff data
-            TByte* const buf=isCompressedBlock?(dataBuf+kSyncBlockSize+1):dataBuf; //+1 for backup 1 byte compressed code when lastByteHalfBits!=0
-            const uint32_t _isBackupedHalf=(backuped_nextBlocki==i)?1:0; //buckuped byte code is hit
-            if (_isBackupedHalf) assert(skipBitsInFirstCodeByte);
-            {//download data
-                const uint32_t _isReLoadNewHalf=((skipBitsInFirstCodeByte&&(!_isBackupedHalf))?1:0);
-                const uint32_t _isReLoadDiffHalf=((_isNeedBackupHalf&&(!_isBackupedHalf))?1:0);
-                assert(_isNeedBackupHalf==_isReLoadDiffHalf+_isBackupedHalf);
-                if (isOnDiffContinue){ //read from local diff data
-                    if (!wd.continueDiffData->readSyncData(wd.continueDiffData,i,posInNewSyncData,_isReLoadNewHalf,
-                                                           posInNeedSyncData,_isReLoadDiffHalf,buf,syncSize-_isBackupedHalf))
-                        isOnDiffContinue=false; // swap to download
-                        isDiffContinueSwapped=1; // swap state only used once
-                }
-                if (!isOnDiffContinue){ //download data
-                    if (!wd.isNeed_readSyncDataEnd){//befor download
-                        wd.isNeed_readSyncDataEnd=true;
-                        if (syncDataListener->readSyncDataBegin)
-                            check(syncDataListener->readSyncDataBegin(syncDataListener,wd.needSyncInfo,i,
-                                                        posInNewSyncData,_isReLoadNewHalf,posInNeedSyncData,_isReLoadDiffHalf),kSyncClient_readSyncDataBeginError);
-                    }
-                    check(syncDataListener->readSyncData(syncDataListener,i,posInNewSyncData,_isReLoadNewHalf,
-                                                posInNeedSyncData,_isReLoadDiffHalf,buf,syncSize-_isBackupedHalf),kSyncClient_readSyncDataError);
-                }
-                if (wd.out_diffStream){ //write diff
-                    if (!isOnDiffContinue){ //save downloaded data
-                        const hpatch_uint32_t isReSavedHalfByte=isDiffContinueSwapped&_isReLoadDiffHalf;
-                        isDiffContinueSwapped=0;
-                        check(wd.out_diffStream->write(wd.out_diffStream,wd.outDiffDataPos+posInNeedSyncData-isReSavedHalfByte,
-                                                       buf+_isReLoadDiffHalf-isReSavedHalfByte,buf+syncSize-_isBackupedHalf),kSyncClient_saveDiffError);
-                    }
-                }
-            }
-            const hpatch_byte backup_last_code=buf[syncSize-_isBackupedHalf-1];
-            if (isCompressedBlock){// need deccompress
-                assert(followCompressedIndex==i);
-                size_t alignCodeSize=0;
-                if (lastByteHalfBits&&wd.decompressPlugin->needFillAlignCode)
-                    alignCodeSize=wd.decompressPlugin->needFillAlignCode(&buf[syncSize-_isBackupedHalf-1],lastByteHalfBits);
-                check(wd.decompressPlugin->dictDecompress(decompressHandle,i,buf-_isBackupedHalf,buf-_isBackupedHalf+syncSize+alignCodeSize,
-                                                          dataBuf,dataBuf+newDataSize,skipBitsInFirstCodeByte),kSyncClient_decompressError);
-                _indexOfCompressedSyncBlock(&followCompressedIndex,newSyncInfo,wd.newBlockDataInOldPoss,i+1);
-            }
-            buf[-1]=backup_last_code;//backup last half byte code for next block
-            backuped_nextBlocki=lastByteHalfBits?(i+1):-1;
-        }else{//copy from local old
-            uint32_t readSize=newDataSize;
-            assert(curDataInOldPos<oldDataSize);
-            if (curDataInOldPos+readSize>oldDataSize)
-                readSize=(uint32_t)(oldDataSize-curDataInOldPos);
-            check(wd.oldStream->read(wd.oldStream,curDataInOldPos,dataBuf,dataBuf+readSize),
-                    kSyncClient_readOldDataError);
-            if (readSize<newDataSize)
-                memset(dataBuf+readSize,0,newDataSize-readSize);
-        }
-
-        if (decompressHandle&&(followCompressedIndex<kBlockCount))
-            wd.decompressPlugin->dictUncompress(decompressHandle,i,followCompressedIndex,dataBuf,dataBuf+newDataSize);
-
-        {//write new
-            bool isNeedChecksumAppend=isNeedSync|wd.isLocalPatch|(wd.continueDiffData!=0);
-            if (isNeedChecksumAppend|isOnNewDataContinue)
-                _checkSumNewDataBuf();
-            if (newSyncInfo->fileChecksumPlugin&&
-                 (newSyncInfo->isNotCChecksumNewMTParallel||isNeedChecksumAppend))
-                wr_by->checkChecksumAppendData(newSyncInfo->savedNewDataCheckChecksum,i,
-                                               fileChecksumPlugin,wd.checkChecksum,
-                                               checksumSync_buf+wd.newSyncInfo->savedStrongChecksumByteSize,
-                                               dataBuf,newDataSize);
-            if ((!isOnNewDataContinue)&&wd.out_newStream){
-                check(wd.out_newStream->write(wd.out_newStream,outNewDataPos,dataBuf,
-                                              dataBuf+newDataSize), kSyncClient_writeNewDataError);
-            }
-        }
-        
-        outNewDataPos+=newDataSize;
-        posInNewSyncData+=syncSize-(skipBitsInFirstCodeByte?1:0);//delete one byte when adjacent blocks have half byte
-        posInNeedSyncData+=isNeedSync?(syncSize-_isNeedBackupHalf):0; //delete one byte when adjacent need sync blocks have half byte
-    }//for i
-    if (wd.out_diffStream) wd.outDiffDataPos+=posInNeedSyncData;
-    check(outNewDataPos==newSyncInfo->newDataSize,kSyncClient_newDataSizeError);
-    if (newSyncInfo->newSyncDataSize==0)
-        assert(posInNewSyncData<=newSyncInfo->newDataSize);
-    else
-        assert(posInNewSyncData<=newSyncInfo->newSyncDataSize);//checked in readSavedSizesTo()
-clear:
-    _inClear=1;
-    if (decompressHandle) wd.decompressPlugin->dictDecompressClose(wd.decompressPlugin,decompressHandle);
-    if (checksumSync) strongChecksumPlugin->close(strongChecksumPlugin,checksumSync);
-    if (_memBuf) free(_memBuf);
-    return result;
-}
-
-
-    struct TNeedSyncInfosImport:public TNeedSyncInfos{
-        const hpatch_StreamPos_t* newBlockDataInOldPoss;
-        const TNewDataSyncInfo*   newSyncInfo;  // opened .hsyni
-    };
-static void _getBlockInfoByIndex(const TNeedSyncInfos* needSyncInfos,uint32_t blockIndex,
-                                 hpatch_BOOL* out_isNeedSync,uint32_t* out_syncSize,
-                                 hpatch_byte* out_skipBitsInFirstCodeByte,hpatch_byte* out_lastByteHalfBits){
-    const TNeedSyncInfosImport* self=(const TNeedSyncInfosImport*)needSyncInfos->import;
-    assert(blockIndex<self->blockCount);
-    *out_isNeedSync=isNeedSyncByOldPos(self->newBlockDataInOldPoss[blockIndex]);
-    *out_syncSize=TNewDataSyncInfo_syncBlockSize(self->newSyncInfo,blockIndex,out_skipBitsInFirstCodeByte,out_lastByteHalfBits);
-}
-    
-static void getNeedSyncInfo(const hpatch_StreamPos_t* newBlockDataInOldPoss,
-                            const TNewDataSyncInfo* newSyncInfo,TNeedSyncInfosImport* out_nsi){
-    const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(newSyncInfo);
-    out_nsi->newBlockDataInOldPoss=newBlockDataInOldPoss;
-    out_nsi->newSyncInfo=newSyncInfo;
-    out_nsi->import=out_nsi; //self
-    
-    out_nsi->newDataSize=newSyncInfo->newDataSize;
-    out_nsi->newSyncDataSize=newSyncInfo->newSyncDataSize;
-    out_nsi->newSyncInfoSize=newSyncInfo->newSyncInfoSize;
-    out_nsi->kSyncBlockSize=newSyncInfo->kSyncBlockSize;
-    out_nsi->blockCount=kBlockCount;
-    out_nsi->blockCount=kBlockCount;
-    out_nsi->getBlockInfoByIndex=_getBlockInfoByIndex;
-    out_nsi->needSyncBlockCount=0;
-    out_nsi->needSyncSumSize=0;
-    
-    hpatch_BOOL isNeedSync_prev=hpatch_FALSE;
-    for (uint32_t i=0; i<kBlockCount; ++i){
-        hpatch_BOOL isNeedSync;
-        uint32_t syncSize;
-        hpatch_byte skipBitsInFirstCodeByte;
-        _getBlockInfoByIndex(out_nsi,i,&isNeedSync,&syncSize,&skipBitsInFirstCodeByte,0);
-        if (isNeedSync){
-            ++out_nsi->needSyncBlockCount;
-            const uint32_t _isNeedBackupHalf=(isNeedSync_prev && skipBitsInFirstCodeByte)?1:0;
-            out_nsi->needSyncSumSize+=syncSize-_isNeedBackupHalf;
-        }
-        isNeedSync_prev=isNeedSync;
-    }
-}
-
-TSyncClient_resultType 
-    _sync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,TSyncDiffData* diffData,
-                const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                const hpatch_TStreamInput* diffContinue,int threadNum){
-    _ISyncPatch_by sp_by={0};
-    sp_by.matchNewDataInOld=matchNewDataInOld;
-    sp_by.writeToNewOrDiff=writeToNewOrDiff;
-    sp_by.checkChecksumInit=checkChecksumInit;
-    sp_by.checkChecksumEndTo=checkChecksumEndTo;
-    return _sync_patch_by(&sp_by, listener,syncDataListener,diffData,oldStream,newSyncInfo,
-                          out_newStream,newDataContinue,out_diffStream,diffType,diffContinue,threadNum);
-}
-
-
-TSyncClient_resultType 
-    _sync_patch_by(_ISyncPatch_by* sp_by,
-                   ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,TSyncDiffData* diffData,
-                   const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                   const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                   const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                   const hpatch_TStreamInput* diffContinue,int threadNum){
-    assert(listener!=0);
-    hsync_TDictDecompress* decompressPlugin=0;
-    hpatch_TChecksum*   fileChecksumPlugin=newSyncInfo->fileChecksumPlugin;
-    const size_t fileChecksumByteSize=fileChecksumPlugin?fileChecksumPlugin->checksumByteSize():0;
-    hpatch_checksumHandle checkChecksum=0;
-    const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(newSyncInfo);
-    TNeedSyncInfosImport needSyncInfo; memset(&needSyncInfo,0,sizeof(needSyncInfo));
-    hpatch_StreamPos_t* newBlockDataInOldPoss=0;
-    hpatch_StreamPos_t  outDiffDataPos=0;
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    TSyncDiffData continueDiffData; memset(&continueDiffData,0,sizeof(continueDiffData));
-    const bool isNeedOut=(out_newStream!=0)||((out_diffStream!=0)&&(diffType!=kSyncDiff_info));
-    bool isLoadedOldPoss=false;
-    bool isReMatchInOld=false;
-    bool isNeed_readSyncDataEnd=false;
-    
-    //decompressPlugin
-    if (newSyncInfo->compressType){
-        if ((newSyncInfo->_decompressPlugin!=0)
-            &&(newSyncInfo->_decompressPlugin->is_can_open(newSyncInfo->compressType))){
-            decompressPlugin=newSyncInfo->_decompressPlugin;
-        }else{
-            decompressPlugin=listener->findDecompressPlugin(listener,newSyncInfo->compressType,newSyncInfo->dictSize);
-            check(decompressPlugin!=0,kSyncClient_noDecompressPluginError);
-        }
-    }
-    //fileChecksumPlugin
-    if (newSyncInfo->fileChecksumPlugin){
-        sp_by->checkChecksumInit(newSyncInfo->savedNewDataCheckChecksum,fileChecksumByteSize);
-        checkChecksum=fileChecksumPlugin->open(fileChecksumPlugin);
-        check(checkChecksum!=0,kSyncClient_strongChecksumOpenError);
-    }
-    //matched in oldData
-    newBlockDataInOldPoss=(hpatch_StreamPos_t*)malloc(kBlockCount*(size_t)sizeof(hpatch_StreamPos_t));
-    check(newBlockDataInOldPoss!=0,kSyncClient_memError);
-    if (diffData!=0){ //local patch
-        assert(syncDataListener==0);
-        assert(diffContinue==0);
-        check(_TSyncDiffData_readOldPoss(diffData,newBlockDataInOldPoss,kBlockCount,newSyncInfo->kSyncBlockSize,
-                                         oldStream->streamSize,newSyncInfo->savedNewDataCheckChecksum,
-                                         fileChecksumByteSize), kSyncClient_loadDiffError);
-        isLoadedOldPoss=(diffData->diffType!=kSyncDiff_data);
-        if (!isLoadedOldPoss) isReMatchInOld=true;
-        syncDataListener=diffData;
-    }else{
-        assert(syncDataListener!=0);
-        if (diffContinue!=0){ // try continue local diff
-            assert(out_diffStream!=0);
-            if (_TSyncDiffData_load(&continueDiffData,diffContinue)){
-                if (_TSyncDiffData_readOldPoss(&continueDiffData,newBlockDataInOldPoss,kBlockCount,
-                                               newSyncInfo->kSyncBlockSize,oldStream->streamSize,
-                                               newSyncInfo->savedNewDataCheckChecksum,fileChecksumByteSize)){
-                    isLoadedOldPoss=(continueDiffData.diffType!=kSyncDiff_data);//ok diffContinue
-                    if (!isLoadedOldPoss) isReMatchInOld=true;
-                }else
-                    diffContinue=0; // not use diffContinue
-            }else
-                diffContinue=0; // not use diffContinue
-        }
-    }
-    if (!isLoadedOldPoss){
-        try{
-            sp_by->matchNewDataInOld(newBlockDataInOldPoss,newSyncInfo,oldStream,
-                                     ((diffType==kSyncDiff_data)||isReMatchInOld)?1:threadNum);
-            if (isReMatchInOld){
-                sp_by->checkChecksumInit(newSyncInfo->savedNewDataCheckChecksum,
-                                         fileChecksumByteSize);
-            }
-        }catch(const std::exception& e){
-            fprintf(stderr,"matchNewDataInOld() run an error: %s",e.what());
-            result=kSyncClient_matchNewDataInOldError;
-        }
-    }
-
-    check(result==kSyncClient_ok,result);
-    if ((out_diffStream!=0)){
-        if (diffContinue==0){
-            check(_saveSyncDiffData(newBlockDataInOldPoss,kBlockCount,newSyncInfo->kSyncBlockSize,oldStream->streamSize,
-                                    newSyncInfo->savedNewDataCheckChecksum,fileChecksumByteSize,
-                                    out_diffStream,diffType,&outDiffDataPos),kSyncClient_saveDiffError);
-        }else{ // continue local diff
-            outDiffDataPos=continueDiffData.diffDataPos0;
-        }
-    }
-    getNeedSyncInfo(newBlockDataInOldPoss,newSyncInfo,&needSyncInfo);
-    if (diffContinue)
-        needSyncInfo.localDiffDataSize=(diffContinue->streamSize-continueDiffData.diffDataPos0);
-    if (newDataContinue)
-        needSyncInfo.localNewDataSize=newDataContinue->streamSize;
-
-    if (listener->onNeedSyncInfo)
-        listener->onNeedSyncInfo(listener,&needSyncInfo);
-    if (syncDataListener->onNeedSyncInfo)
-        syncDataListener->onNeedSyncInfo(syncDataListener,&needSyncInfo);
-    
-    if (isNeedOut) 
-        check(syncDataListener->readSyncData!=0,kSyncClient_noReadSyncDataError);
-    if (isNeedOut){
-        _TWriteDatas writeDatas;
-        writeDatas.out_newStream=out_newStream;
-        writeDatas.newDataContinue=newDataContinue;
-        writeDatas.out_diffStream=(diffType==kSyncDiff_info)?0:out_diffStream;
-        writeDatas.outDiffDataPos=outDiffDataPos;
-        writeDatas.oldStream=oldStream;
-        writeDatas.newSyncInfo=newSyncInfo;
-        writeDatas.needSyncInfo=&needSyncInfo;
-        writeDatas.newBlockDataInOldPoss=newBlockDataInOldPoss;
-        writeDatas.needSyncBlockCount=needSyncInfo.needSyncBlockCount;
-        writeDatas.decompressPlugin=decompressPlugin;
-        writeDatas.checkChecksum=checkChecksum;
-        writeDatas.syncDataListener=syncDataListener;
-        writeDatas.continueDiffData=diffContinue?&continueDiffData:0;
-        writeDatas.isLocalPatch=(diffData!=0);
-        writeDatas.isNeed_readSyncDataEnd=false;
-        result=sp_by->writeToNewOrDiff(writeDatas);
-        
-        if (writeDatas.isNeed_readSyncDataEnd&&(syncDataListener->readSyncDataEnd))
-            syncDataListener->readSyncDataEnd(syncDataListener);
-
-        if ((result==kSyncClient_ok)&&newSyncInfo->fileChecksumPlugin){
-            sp_by->checkChecksumEndTo(newSyncInfo->savedNewDataCheckChecksum+fileChecksumByteSize,
-                                      newSyncInfo->savedNewDataCheckChecksum,fileChecksumPlugin,checkChecksum);
-            check(0==memcmp(newSyncInfo->savedNewDataCheckChecksum+fileChecksumByteSize,
-                            newSyncInfo->savedNewDataCheckChecksum,fileChecksumByteSize),
-                  kSyncClient_newDataCheckChecksumError);
-        }
-    }
-    
-clear:
-    _inClear=1;
-    if (checkChecksum) fileChecksumPlugin->close(fileChecksumPlugin,checkChecksum);
-    if (newBlockDataInOldPoss) free(newBlockDataInOldPoss);
-    return result;
-}
-
-static TSyncClient_resultType
-    _sync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                          TSyncDiffData* diffData,const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                          const char* outNewFile,hpatch_BOOL isOutNewContinue,
-                          const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                          const hpatch_TStreamInput* diffContinue,int threadNum){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    TNewDataSyncInfo            newSyncInfo;
-    hpatch_TFileStreamInput     oldData;
-    hpatch_TFileStreamOutput    out_newData;
-    const hpatch_TStreamInput*  newDataContinue=0;
-    hpatch_TStreamInput         _newDataContinue;
-    const hpatch_TStreamInput*  oldStream=0;
-    bool isOldPathInputEmpty=(oldFile==0)||(strlen(oldFile)==0);
-    
-    TNewDataSyncInfo_init(&newSyncInfo);
-    hpatch_TFileStreamInput_init(&oldData);
-    hpatch_TFileStreamOutput_init(&out_newData);
-    result=TNewDataSyncInfo_open_by_file(&newSyncInfo,newSyncInfoFile,isIgnoreCompressInfo,listener);
-    check(result==kSyncClient_ok,result);
-    
-    if (!isOldPathInputEmpty)
-        check(hpatch_TFileStreamInput_open(&oldData,oldFile),kSyncClient_oldFileOpenError);
-    oldStream=&oldData.base;
-    if (outNewFile){
-        check(_open_continue_out(isOutNewContinue,outNewFile,&out_newData,&_newDataContinue,newSyncInfo.newDataSize),
-              isOutNewContinue?kSyncClient_newFileReopenWriteError:kSyncClient_newFileCreateError);
-        if (isOutNewContinue) newDataContinue=&_newDataContinue;
-    }
-    
-    result=_sync_patch(listener,syncDataListener,diffData,oldStream,&newSyncInfo,
-                       outNewFile?&out_newData.base:0,newDataContinue,
-                       out_diffStream,diffType,diffContinue,threadNum);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamOutput_close(&out_newData),kSyncClient_newFileCloseError);
-    check(hpatch_TFileStreamInput_close(&oldData),kSyncClient_oldFileCloseError);
-    TNewDataSyncInfo_close(&newSyncInfo);
-    return result;
-}
-
-    struct _TValidRange{ // range's data len=last-first+1; same as http range definition
-        hpatch_StreamPos_t first;
-        hpatch_StreamPos_t last;//is last valid byte offset
-    };
-    static const hpatch_StreamPos_t kEmptyEndPos=~(hpatch_StreamPos_t)0;
-    static inline bool _isCanCombine(const _TValidRange& back_range,hpatch_StreamPos_t rangeBegin){
-        return ((rangeBegin>0)&(back_range.last+1==rangeBegin));
-    }
-    static inline void _setRange(_TValidRange& next_ranges,hpatch_StreamPos_t rangeBegin,hpatch_StreamPos_t rangeEnd){
-        assert(rangeBegin<rangeEnd);
-        hpatch_StreamPos_t rangLast=(rangeEnd!=kEmptyEndPos)?(rangeEnd-1):kEmptyEndPos;
-        next_ranges.first=rangeBegin;
-        next_ranges.last=rangLast;
-    }
-
-} //namespace sync_private
-using namespace  sync_private;
-
-size_t TNeedSyncInfos_getNextRanges(const TNeedSyncInfos* nsi,hpatch_StreamPos_t* _dstRanges,size_t maxGetRangeLen,
-                                    uint32_t* _curBlockIndex,hpatch_StreamPos_t* _curPosInNewSyncData,uint32_t isReLoadNewHalf){
-    _TValidRange* out_ranges=(_TValidRange*)_dstRanges;
-    _TValidRange  backRange={0,0};
-    uint32_t& blockIndex=*_curBlockIndex;
-    hpatch_StreamPos_t& posInNewSyncData=*_curPosInNewSyncData;
-    size_t result=0;
-    assert(maxGetRangeLen>0);
-    while (blockIndex<nsi->blockCount){
-        hpatch_BOOL isNeedSync;
-        uint32_t    syncSize;
-        hpatch_byte skipBitsInFirstCodeByte;
-        nsi->getBlockInfoByIndex(nsi,blockIndex,&isNeedSync,&syncSize,&skipBitsInFirstCodeByte,0);
-        const uint32_t incNewSyncSize=syncSize-(skipBitsInFirstCodeByte?1:0);//delete one byte when adjacent blocks have half byte
-
-        if (skipBitsInFirstCodeByte) assert(posInNewSyncData>0);
-        if (isReLoadNewHalf==1) assert(isNeedSync&&skipBitsInFirstCodeByte);
-        if (isNeedSync){
-            if ((result>0)&&_isCanCombine(backRange,posInNewSyncData)){
-                backRange.last+=incNewSyncSize;
-            }else if (result>=maxGetRangeLen){
-                break; //finish
-            }else{
-                _setRange(backRange,posInNewSyncData-((isReLoadNewHalf&&skipBitsInFirstCodeByte)?1:0),
-                                    posInNewSyncData+incNewSyncSize);
-                ++result;
-            }
-            if (out_ranges) out_ranges[result-1]=backRange;
-        }
-        isReLoadNewHalf=-1; //only first block actual effect
-        posInNewSyncData+=incNewSyncSize;
-        ++blockIndex;
-    }
-    return result;
-}
-
-TSyncClient_resultType sync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                  const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                                  const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
-                                  const hpatch_TStreamOutput* out_diffInfoStream,const hpatch_TStreamInput* diffInfoContinue,int threadNum){
-    return _sync_patch(listener,syncDataListener,0,oldStream,newSyncInfo,out_newStream,newDataContinue,
-                       out_diffInfoStream,kSyncDiff_info,diffInfoContinue,threadNum);
-}
-
-TSyncClient_resultType sync_local_diff(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                       const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                                       const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
-                                       const hpatch_TStreamInput* diffContinue,int threadNum){
-    return _sync_patch(listener,syncDataListener,0,oldStream,newSyncInfo,0,0,
-                       out_diffStream,diffType,diffContinue,threadNum);
-}
-
-
-TSyncClient_resultType sync_local_patch(ISyncInfoListener* listener,const hpatch_TStreamInput* in_diffStream,
-                                        const hpatch_TStreamInput* oldStream,const TNewDataSyncInfo* newSyncInfo,
-                                        const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,int threadNum){
-    TSyncDiffData diffData;
-    if (!_TSyncDiffData_load(&diffData,in_diffStream)) return kSyncClient_loadDiffError;
-    return _sync_patch(listener,0,&diffData,oldStream,newSyncInfo,out_newStream,newDataContinue,
-                      0,kSyncDiff_default,0,threadNum);
-}
-
-
-TSyncClient_resultType sync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                            const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                            const char* outNewFile,hpatch_BOOL isOutNewContinue,
-                                            const char* cacheDiffInfoFile,int threadNum){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    hpatch_TFileStreamOutput out_diffInfo;
-    hpatch_TFileStreamOutput_init(&out_diffInfo);
-    const hpatch_TStreamInput* diffContinue=0;
-    hpatch_TStreamInput _diffContinue;
-    if (cacheDiffInfoFile){
-        hpatch_BOOL isOutDiffContinue=hpatch_TRUE;
-        check(_open_continue_out(isOutDiffContinue,cacheDiffInfoFile,&out_diffInfo,&_diffContinue),
-            isOutDiffContinue?kSyncClient_diffFileReopenWriteError:kSyncClient_diffFileCreateError);
-        if (isOutDiffContinue) diffContinue=&_diffContinue;
-    }
-
-    result=_sync_patch_file2file(listener,syncDataListener,0,oldFile,newSyncInfoFile,isIgnoreCompressInfo,
-                                 outNewFile,isOutNewContinue,
-                                 cacheDiffInfoFile?&out_diffInfo.base:0,kSyncDiff_info,diffContinue,threadNum);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamOutput_close(&out_diffInfo),kSyncClient_diffFileCloseError);
-    return result;
-}
-
-
-TSyncClient_resultType sync_local_diff_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
-                                                 const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                 const char* outDiffFile,TSyncDiffType diffType,
-                                                 hpatch_BOOL isOutDiffContinue,int threadNum){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    hpatch_TFileStreamOutput out_diff;
-    hpatch_TFileStreamOutput_init(&out_diff);
-    const hpatch_TStreamInput* diffContinue=0;
-    hpatch_TStreamInput _diffContinue;
-    
-    check(_open_continue_out(isOutDiffContinue,outDiffFile,&out_diff,&_diffContinue),
-          isOutDiffContinue?kSyncClient_diffFileReopenWriteError:kSyncClient_diffFileCreateError);
-    if (isOutDiffContinue) diffContinue=&_diffContinue;
-    
-    result=_sync_patch_file2file(listener,syncDataListener,0,oldFile,newSyncInfoFile,isIgnoreCompressInfo,0,hpatch_FALSE,
-                                 &out_diff.base,diffType,diffContinue,threadNum);
-    
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamOutput_close(&out_diff),kSyncClient_diffFileCloseError);
-    return result;
-}
-
-TSyncClient_resultType sync_local_patch_file2file(ISyncInfoListener* listener,const char* inDiffFile,
-                                                  const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                  const char* outNewFile,hpatch_BOOL isOutNewContinue,int threadNum){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    TSyncDiffData diffData;
-    hpatch_TFileStreamInput in_diffData;
-    hpatch_TFileStreamInput_init(&in_diffData);
-    check(hpatch_TFileStreamInput_open(&in_diffData,inDiffFile),
-          kSyncClient_diffFileOpenError);
-    check(_TSyncDiffData_load(&diffData,&in_diffData.base),kSyncClient_loadDiffError);
-    result=_sync_patch_file2file(listener,0,&diffData,oldFile,newSyncInfoFile,isIgnoreCompressInfo,outNewFile,isOutNewContinue,
-                                 0,kSyncDiff_default,0,threadNum);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamInput_close(&in_diffData),kSyncClient_diffFileCloseError);
-    return result;
-}