react-native-update 10.34.3 → 10.34.5

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

@@ -1,680 +0,0 @@
-//  sync_info_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_info_client.h"
-#include "sync_client_type_private.h"
-#include "../../file_for_patch.h"
-#include "../../libHDiffPatch/HPatch/patch_private.h"
-#if (_IS_NEED_DIR_DIFF_PATCH)
-#include "../../dirDiffPatch/dir_patch/dir_patch_tools.h"
-#include "../../dirDiffPatch/dir_diff/dir_diff_tools.h"
-#endif
-#if (_IS_NEED_DIR_DIFF_PATCH)
-void TNewDataSyncInfo_dir_saveTo(TNewDataSyncInfo_dir* self,std::vector<hpatch_byte>& out_buf){
-    self->dir_newPathSumCharSize=0;
-    {
-        hdiff_private::packIncList(out_buf,self->dir_newExecuteIndexList,self->dir_newExecuteCount);
-        hdiff_private::packList(out_buf,self->dir_newSizeList,self->dir_newPathCount);
-        checkv(!self->dir_newNameList_isCString);
-        self->dir_newPathSumCharSize=hdiff_private::pushNameList(out_buf,self->dir_utf8NewRootPath,
-                                        (std::string*)self->dir_utf8NewNameList,self->dir_newPathCount);
-    }
-}
-#endif
-
-namespace sync_private{
-#ifdef  check
-# undef check
-#endif
-#define check(v,errorCode) \
-            do{ if (!(v)) { if (result==kSyncClient_ok) result=errorCode; \
-                            if (!_inClear) goto clear; } }while(0)
-
-#define _clip_unpackUIntTo(puint,sclip) \
-    _TStreamCacheClip_unpackUIntWithTag(sclip,puint,0)
-
-template<class Type_t>
-static hpatch_BOOL __clip_unpackToType_t(Type_t* out_v,TStreamCacheClip* clip,hpatch_uint kTagBit=0){
-    if (sizeof(Type_t)==sizeof(hpatch_StreamPos_t)){
-        return _TStreamCacheClip_unpackUIntWithTag(clip,(hpatch_StreamPos_t*)out_v,kTagBit);
-    }else{
-        hpatch_StreamPos_t v;
-        hpatch_BOOL ret=_TStreamCacheClip_unpackUIntWithTag(clip,&v,kTagBit);
-        Type_t tv=(Type_t)v;
-        *out_v=tv;
-        return ret&&(tv==v);
-    }
-}
-
-inline static hpatch_BOOL _clip_unpackToUInt32(uint32_t* out_v,TStreamCacheClip* clip,hpatch_uint kTagBit=0){
-    return __clip_unpackToType_t<uint32_t>(out_v,clip,kTagBit);
-}
-inline static hpatch_BOOL _clip_unpackToSize_t(size_t* out_v,TStreamCacheClip* clip){
-    return __clip_unpackToType_t<size_t>(out_v,clip);
-}
-inline static hpatch_BOOL _clip_unpackToByte(hpatch_byte* out_v,TStreamCacheClip* clip){
-    return _TStreamCacheClip_readDataTo(clip,out_v,out_v+1);
-}
-
-struct TChecksumInputStream:public hpatch_TStreamInput {
-    inline TChecksumInputStream()
-        :_base(0),_checksumPlugin(0),_checksum(0),_curReadPos(0),_checksumByteSize(0),_checksumBuf(0) {
-        memset((hpatch_TStreamInput*)this,0,sizeof(hpatch_TStreamInput));
-    }
-    inline ~TChecksumInputStream(){
-        if (_checksum) _checksumPlugin->close(_checksumPlugin,_checksum);
-        if (_checksumBuf) free(_checksumBuf);
-    }
-    bool open(const hpatch_TStreamInput* base,hpatch_StreamPos_t newStreamSize,
-              hpatch_TChecksum* checksumPlugin){
-        assert(_checksum==0);
-        if (newStreamSize>base->streamSize)
-            return false;
-        _base=base;
-        _checksumPlugin=checksumPlugin;
-        this->streamImport=this;
-        this->streamSize=newStreamSize;
-        this->read=_read;
-        
-        _checksumByteSize=_checksumPlugin->checksumByteSize();
-        _checksum=_checksumPlugin->open(_checksumPlugin);
-        _checksumBuf=(TByte*)malloc(_checksumByteSize);
-        if (_checksum)
-            _checksumPlugin->begin(_checksum);
-        return _checksum!=0;
-    }
-    bool reopen(hpatch_StreamPos_t newStreamSize){
-        if (newStreamSize>_base->streamSize)
-            return false;
-        this->streamSize=newStreamSize;
-        if (_checksum)
-            _checksumPlugin->begin(_checksum);
-        return _checksum!=0;
-    }
-    TByte* finish(){
-        _checksumPlugin->end(_checksum,_checksumBuf,_checksumBuf+_checksumByteSize);
-        return _checksumBuf;
-    }
-    inline size_t checksumByteSize()const{ return _checksumByteSize; }
-private:
-    hpatch_BOOL _read_(hpatch_StreamPos_t readFromPos,unsigned char* out_data,unsigned char* out_data_end){
-        hpatch_BOOL result=_base->read(_base,readFromPos,out_data,out_data_end);
-        if (result){
-            size_t readSize=(size_t)(out_data_end-out_data);
-            if (readFromPos>_curReadPos) { assert(false); return hpatch_FALSE; }
-            //    _curReadPos|
-            //      [    readSize    ]
-            if (readFromPos+readSize>_curReadPos){
-                _checksumPlugin->append(_checksum,out_data+(_curReadPos-readFromPos),out_data_end);
-                _curReadPos=readFromPos+readSize;
-            }
-        }
-        return result;
-    }
-    static hpatch_BOOL _read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
-                      unsigned char* out_data,unsigned char* out_data_end){
-        TChecksumInputStream* self=(TChecksumInputStream*)stream->streamImport;
-        return self->_read_(readFromPos,out_data,out_data_end);
-    }
-    const hpatch_TStreamInput*  _base;
-    hpatch_TChecksum*           _checksumPlugin;
-    hpatch_checksumHandle       _checksum;
-    hpatch_StreamPos_t          _curReadPos;
-    size_t                      _checksumByteSize;
-    TByte*                      _checksumBuf;
-};
-
-template<class TUInt>
-hpatch_inline static
-hpatch_BOOL _clip_readUIntTo(TUInt* result,TStreamCacheClip* sclip){
-    hpatch_StreamPos_t v;
-    hpatch_BOOL rt=_TStreamCacheClip_unpackUIntWithTag(sclip,&v,0);
-    if (rt){
-        *result=(TUInt)v;
-        if ((sizeof(TUInt)<sizeof(hpatch_StreamPos_t))&&((*result)!=v))
-            return hpatch_FALSE;
-    }
-    return rt;
-}
-
-} //namespace sync_private
-using namespace sync_private;
-
-static
-TSyncClient_resultType _checkNewSyncInfoType(TStreamCacheClip* newSyncInfo_clip,hpatch_BOOL* out_newIsDir){
-    char  tempType[hpatch_kMaxPluginTypeLength+1];
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    check(_TStreamCacheClip_readType_end(newSyncInfo_clip,'&',tempType),
-          kSyncClient_newSyncInfoTypeError);
-    if (0==strcmp(tempType,"HSyni23"))
-        *out_newIsDir=hpatch_FALSE;
-#if (_IS_NEED_DIR_DIFF_PATCH)
-    else if (0==strcmp(tempType,"HDirSyni23"))
-        *out_newIsDir=hpatch_TRUE;
-#endif
-    else //unknow type
-        check(hpatch_FALSE,kSyncClient_newSyncInfoTypeError);
-clear:
-    _inClear=1;
-    return result;
-}
-
-TSyncClient_resultType checkNewSyncInfoType(const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL* out_newIsDir){
-    TStreamCacheClip    clip;
-    TByte temp_cache[hpatch_kStreamCacheSize];
-    _TStreamCacheClip_init(&clip,newSyncInfo,0,newSyncInfo->streamSize,temp_cache,sizeof(temp_cache));
-    return _checkNewSyncInfoType(&clip,out_newIsDir);
-}
-
-TSyncClient_resultType checkNewSyncInfoType_by_file(const char* newSyncInfoFile,hpatch_BOOL* out_newIsDir){
-    hpatch_TFileStreamInput  newSyncInfo;
-    hpatch_TFileStreamInput_init(&newSyncInfo);
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    check(hpatch_TFileStreamInput_open(&newSyncInfo,newSyncInfoFile), kSyncClient_newSyncInfoOpenError);
-    result=checkNewSyncInfoType(&newSyncInfo.base,out_newIsDir);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamInput_close(&newSyncInfo), kSyncClient_newSyncInfoCloseError);
-    return result;
-}
-
-static bool readSamePairListTo(TStreamCacheClip* codeClip,TSameNewBlockPair* samePairList,
-                               size_t samePairCount,uint32_t kBlockCount){
-    uint32_t pre=0;
-    for (size_t i=0;i<samePairCount;++i){
-        TSameNewBlockPair& sp=samePairList[i];
-        uint32_t v;
-        if (!_clip_unpackToUInt32(&v,codeClip)) return false;
-        sp.curIndex=v+pre;
-        if (sp.curIndex>=kBlockCount) return false;
-        if (!_clip_unpackToUInt32(&v,codeClip)) return false;
-        if (v>sp.curIndex) return false;
-        sp.sameIndex=sp.curIndex-v;
-        pre=sp.curIndex;
-    }
-    return true;
-}
-
-static bool _clip_readSavedSize(uint32_t* value,uint32_t* tag,TStreamCacheClip* codeClip){
-    const hpatch_byte* buf=_TStreamCacheClip_accessData(codeClip,1);
-    if (buf==0) return false;
-    *tag=buf[0]>>7;
-    return _clip_unpackToUInt32(value,codeClip,1);
-}
-static bool readSavedSizesTo(TStreamCacheClip* codeClip,TNewDataSyncInfo* self,hpatch_BOOL isIgnoreCompressInfo){
-    uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(self);
-    uint32_t backSize=0;
-    hpatch_StreamPos_t sumSavedSize=0;
-    for (uint32_t i=0; i<kBlockCount; ++i){
-        uint32_t savedSize;
-        uint32_t highTag;
-        if (!_clip_readSavedSize(&savedSize,&highTag,codeClip)) return false;
-        if (highTag==0){
-            savedSize+=backSize;
-            backSize=savedSize;
-        }else if (savedSize>0){
-            savedSize=backSize-savedSize;
-            backSize=savedSize;
-        }else{
-            backSize=self->kSyncBlockSize;
-        }
-        if (!isIgnoreCompressInfo)
-            self->savedSizes[i]=savedSize;
-        sumSavedSize+=(savedSize>0)?savedSize:TNewDataSyncInfo_newDataBlockSize(self,i);
-    }
-    if (sumSavedSize>self->newSyncDataSize) return false;
-    return true;
-}
-
-static bool readPartHashTo(TStreamCacheClip* clip,TByte* partHash,size_t partBits,
-                           TSameNewBlockPair* samePairList,size_t samePairCount,uint32_t kBlockCount){
-    uint32_t curPair=0;
-    TByte* curPartChecksum=partHash;
-    const size_t partBytes=_bitsToBytes(partBits);
-    size_t bitsValue=0;
-    size_t bitsCount=0;
-    const size_t highBit=(partBits&7)?(partBits&7):8;
-    for (size_t i=0; i<kBlockCount; ++i,curPartChecksum+=partBytes){
-        if ((curPair<samePairCount)&&(i==samePairList[curPair].curIndex)){
-            size_t sameIndex=samePairList[curPair].sameIndex;
-            memcpy(curPartChecksum,partHash+sameIndex*partBytes,partBytes);
-            ++curPair;
-        }else{
-            for (size_t j=0;j<partBytes;++j){
-                if (bitsCount<8){//read a byte
-                    hpatch_byte v;
-                    if (!_TStreamCacheClip_readDataTo(clip,&v,(&v)+1))
-                            return false;
-                    bitsValue|=(((size_t)v)<<bitsCount);
-                    bitsCount+=8;
-                }
-                if (j==0){
-                    curPartChecksum[j]=bitsValue&((1<<highBit)-1);
-                    bitsValue>>=highBit;
-                    bitsCount-=highBit;
-                }else{
-                    curPartChecksum[j]=(hpatch_byte)bitsValue;
-                    bitsValue>>=8;
-                    bitsCount-=8;
-                }
-            }
-        }
-    }
-    if (bitsValue!=0) return false;
-    if (curPair!=samePairCount) return false;
-    return true;
-}
-
-    typedef struct{
-        hsync_TDictDecompress*     decompressPlugin;
-        hsync_dictDecompressHandle decompressHandle;
-    } _TDictDecompressInputStream;
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-static hpatch_BOOL _readDirHead(TNewDataSyncInfo_dir* dirInfo,TStreamCacheClip* clip){
-    if (!_clip_unpackToSize_t(&dirInfo->dir_newExecuteCount,clip)) return hpatch_FALSE;
-    if (!_clip_unpackToSize_t(&dirInfo->dir_newPathCount,clip)) return hpatch_FALSE;
-    if (!_clip_unpackToSize_t(&dirInfo->dir_newPathSumCharSize,clip)) return hpatch_FALSE;
-    return hpatch_TRUE;
-}
-#endif
-
-static TSyncClient_resultType
-    _TNewDataSyncInfo_open(TNewDataSyncInfo* self,const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL isIgnoreCompressInfo,
-                           ISyncInfoListener *listener){
-    assert((self->_import==0)&&(self->_extraMem==0));
-    hsync_TDictDecompress* decompressPlugin=0;
-    hpatch_TChecksum*   strongChecksumPlugin=0;
-    TStreamCacheClip    clip;
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-
-    hpatch_BOOL newIsDir_byType=hpatch_FALSE;
-    uint32_t    kBlockCount=0;
-    const char* checksumType=0;
-    char  compressType[hpatch_kMaxPluginTypeLength+1];
-    hpatch_StreamPos_t headEndPos=0;
-    hpatch_StreamPos_t privateExternDataSize=0;
-    hpatch_StreamPos_t externDataSize=0;
-    hpatch_StreamPos_t uncompressDataSize=0;
-    hpatch_StreamPos_t compressDataSize=0;
-    size_t kStrongChecksumByteSize=0;
-    _TDictDecompressInputStream decompresser;
-    TChecksumInputStream  checksumInputStream;
-    const bool isChecksumNewSyncInfo=true;
-    uint8_t isSavedSizes=0;
-    const size_t kFileIOBufBetterSize=hpatch_kFileIOBufBetterSize;
-    TByte* temp_cache=(TByte*)malloc(kFileIOBufBetterSize);
-    check(temp_cache!=0,kSyncClient_memError);
-    memset(&decompresser,0,sizeof(decompresser));
-    {//head
-        char  tempType[hpatch_kMaxPluginTypeLength+1];
-        const size_t kHeadCacheSize =1024*2;
-        assert(kFileIOBufBetterSize>=kHeadCacheSize);
-        _TStreamCacheClip_init(&clip,newSyncInfo,0,newSyncInfo->streamSize,
-                               temp_cache,isChecksumNewSyncInfo?kHeadCacheSize:kFileIOBufBetterSize);
-        {//type
-            result=_checkNewSyncInfoType(&clip,&newIsDir_byType);
-            check(result==kSyncClient_ok,result);
-        }
-        {//read compressType
-            check(_TStreamCacheClip_readType_end(&clip,'&',compressType),kSyncClient_noDecompressPluginError);
-
-        }
-        {//read strongChecksumType
-            check(_TStreamCacheClip_readType_end(&clip,'\0',tempType),kSyncClient_noStrongChecksumPluginError);
-            strongChecksumPlugin=listener->findChecksumPlugin(listener,tempType);
-            check(strongChecksumPlugin!=0,kSyncClient_noStrongChecksumPluginError);
-            checksumType=strongChecksumPlugin->checksumType();
-            check(0==strcmp(tempType,checksumType),kSyncClient_noStrongChecksumPluginError);
-            self->strongChecksumPlugin=strongChecksumPlugin;
-            self->fileChecksumPlugin=strongChecksumPlugin;
-        }
-        check(_clip_unpackToSize_t(&self->dictSize,&clip), kSyncClient_newSyncInfoDataError);
-        if (strlen(compressType)>0){
-            decompressPlugin=listener->findDecompressPlugin(listener,compressType,self->dictSize);
-            check(decompressPlugin!=0,kSyncClient_noDecompressPluginError);
-            self->_decompressPlugin=decompressPlugin;
-        }
-        
-        check(_clip_unpackToByte(&self->decompressInfoSize,&clip),kSyncClient_newSyncInfoDataError);
-        check(self->decompressInfoSize<=kDecompressInfoMaxSize,kSyncClient_newSyncInfoDataError);
-        check(_TStreamCacheClip_readDataTo(&clip,self->decompressInfo,
-                self->decompressInfo+self->decompressInfoSize),kSyncClient_newSyncInfoDataError);
-        
-        check(_clip_unpackUIntTo(&self->newSyncDataSize,&clip),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackUIntTo(&self->newSyncDataOffsert,&clip),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackUIntTo(&self->newDataSize,&clip),kSyncClient_newSyncInfoDataError);
-        if (self->_decompressPlugin){
-            static const hpatch_StreamPos_t _kDictSizeSafeLimit =(1<<20)*16;
-            check((self->dictSize/2)<(self->newDataSize>=_kDictSizeSafeLimit?self->newDataSize:_kDictSizeSafeLimit),
-                kSyncClient_newSyncInfoDataError);
-        }
-
-        check(_clip_unpackToUInt32(&self->kSyncBlockSize,&clip),kSyncClient_newSyncInfoDataError);
-        check((self->kSyncBlockSize<=(self->newDataSize<=_kSyncBlockSize_min_limit?_kSyncBlockSize_min_limit:self->newDataSize))
-              &&(self->kSyncBlockSize>=_kSyncBlockSize_min_limit),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackToSize_t(&kStrongChecksumByteSize,&clip),kSyncClient_newSyncInfoDataError);
-        check(strongChecksumPlugin->checksumByteSize()==kStrongChecksumByteSize,
-              kSyncClient_strongChecksumByteSizeError);
-        check(_clip_unpackToSize_t(&self->savedStrongChecksumBits,&clip),kSyncClient_newSyncInfoDataError);
-        self->savedStrongChecksumByteSize=_bitsToBytes(self->savedStrongChecksumBits);
-        check((self->savedStrongChecksumByteSize<=kStrongChecksumByteSize),
-              kSyncClient_strongChecksumByteSizeError);
-        check(_clip_unpackToSize_t(&self->savedRollHashBits,&clip),kSyncClient_newSyncInfoDataError);
-        check((size_t)(self->savedRollHashBits-1)<sizeof(uint64_t)*8,kSyncClient_newSyncInfoDataError);
-        self->savedRollHashByteSize=_bitsToBytes(self->savedRollHashBits);
-        check(_clip_unpackToUInt32(&self->samePairCount,&clip),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackToByte(&isSavedSizes,&clip),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackUIntTo(&privateExternDataSize,&clip),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackUIntTo(&externDataSize,&clip),kSyncClient_newSyncInfoDataError);
-        
-        check(_clip_unpackUIntTo(&uncompressDataSize,&clip),kSyncClient_newSyncInfoDataError);
-        check(_clip_unpackUIntTo(&compressDataSize,&clip),kSyncClient_newSyncInfoDataError);
-        check((compressDataSize==0)||(compressDataSize<uncompressDataSize),kSyncClient_newSyncInfoDataError);
-        if (compressDataSize>0) check(decompressPlugin!=0,kSyncClient_newSyncInfoDataError);
-        
-        check(_clip_unpackToByte(&self->isDirSyncInfo,&clip),kSyncClient_newSyncInfoDataError);
-        check(newIsDir_byType==self->isDirSyncInfo, kSyncClient_newSyncInfoTypeError);
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        if (self->isDirSyncInfo){
-            check(_clip_unpackToSize_t(&self->dirInfoSavedSize,&clip),kSyncClient_newSyncInfoDataError);
-            check(self->dirInfoSavedSize<self->newDataSize,kSyncClient_newSyncInfoDataError);
-            check(_readDirHead(&self->dirInfo,&clip),kSyncClient_newSyncInfoDataError);
-        }
-#endif
-        check(_clip_unpackUIntTo(&self->newSyncInfoSize,&clip),kSyncClient_newSyncInfoDataError);
-        check(newSyncInfo->streamSize==self->newSyncInfoSize,kSyncClient_newSyncInfoDataError);
-        {
-            hpatch_StreamPos_t v=TNewDataSyncInfo_blockCount(self);
-            kBlockCount=(uint32_t)v;
-            check((kBlockCount==v),kSyncClient_newSyncInfoDataError);
-        }
-        headEndPos=_TStreamCacheClip_readPosOfSrcStream(&clip);
-        self->infoChecksumEndPos= headEndPos + privateExternDataSize + externDataSize
-                                 + ((compressDataSize>0)?compressDataSize:uncompressDataSize)
-                                 + kStrongChecksumByteSize*2;
-    }
-    hpatch_StreamPos_t memSize;
-    {//mem
-        size_t headMaxSize=sizeof(hpatch_StreamPos_t)*5+ strlen(compressType)+1+strlen(checksumType)+1
-                +kStrongChecksumByteSize*2+checkChecksumBufByteSize(kStrongChecksumByteSize);
-        TByte* curMem=0;
-        memSize=headMaxSize;
-        memSize+=self->samePairCount*sizeof(TSameNewBlockPair);
-        if (isSavedSizes&&(!isIgnoreCompressInfo))
-            memSize+=sizeof(uint32_t)*(hpatch_StreamPos_t)kBlockCount;
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        if (self->isDirSyncInfo){
-            self->dirInfo.dir_newNameList_isCString=hpatch_TRUE;
-            memSize+=self->dirInfo.dir_newPathSumCharSize + sizeof(const char*)*self->dirInfo.dir_newPathCount
-                    +sizeof(hpatch_StreamPos_t)*self->dirInfo.dir_newPathCount
-                    +sizeof(size_t)*self->dirInfo.dir_newExecuteCount;
-        }
-#endif
-        memSize+=(self->savedRollHashByteSize+self->savedStrongChecksumByteSize)*(hpatch_StreamPos_t)kBlockCount;
-
-        const hpatch_StreamPos_t _kSafeTempMemSize=uncompressDataSize+compressDataSize+headMaxSize+1024;
-        if ((compressDataSize>0)&&(memSize<_kSafeTempMemSize))
-            memSize=_kSafeTempMemSize;
-        check(memSize==(size_t)memSize,kSyncClient_memError);
-        curMem=(TByte*)malloc((size_t)memSize);
-        check(curMem!=0,kSyncClient_memError);
-        self->_import=curMem;
-
-        if (decompressPlugin!=0){
-            self->compressType=(const char*)curMem;
-            curMem+=strlen(compressType)+1;
-            memcpy((TByte*)self->compressType,compressType,strlen(compressType)+1);
-        }
-        self->strongChecksumType=(const char*)curMem;
-        curMem+=strlen(checksumType)+1;
-        memcpy((TByte*)self->strongChecksumType,checksumType,curMem-(TByte*)self->strongChecksumType);
-
-        curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-        self->infoChecksum=curMem;
-        curMem+=kStrongChecksumByteSize;
-        self->infoPartHashChecksum=curMem;
-        curMem+=kStrongChecksumByteSize;
-        self->savedNewDataCheckChecksum=curMem;
-        curMem+=checkChecksumBufByteSize(kStrongChecksumByteSize);
-        
-        curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-        self->samePairList=(TSameNewBlockPair*)curMem;
-        curMem+=self->samePairCount*sizeof(TSameNewBlockPair);
-        if ((isSavedSizes)&&(!isIgnoreCompressInfo)){
-            self->savedSizes=(uint32_t*)curMem;
-            curMem+=sizeof(uint32_t)*(size_t)kBlockCount;
-        }
-#if (_IS_NEED_DIR_DIFF_PATCH)
-        if (self->isDirSyncInfo){
-            curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-            self->dirInfo.dir_newSizeList=(hpatch_StreamPos_t*)curMem;
-            curMem+=sizeof(hpatch_StreamPos_t)*self->dirInfo.dir_newPathCount;
-            self->dirInfo.dir_utf8NewNameList=(const char**)curMem;
-            curMem+=sizeof(const char*)*self->dirInfo.dir_newPathCount;
-            self->dirInfo.dir_newExecuteIndexList=(size_t*)curMem;
-            curMem+=sizeof(size_t)*self->dirInfo.dir_newExecuteCount;
-            if (self->dirInfo.dir_newPathCount>0){
-                ((const char**)self->dirInfo.dir_utf8NewNameList)[0]=(char*)curMem;
-                curMem+=self->dirInfo.dir_newPathSumCharSize;
-            }
-        }
-#endif
-
-        curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-        self->rollHashs=curMem;
-        curMem+=self->savedRollHashByteSize*(size_t)kBlockCount;
-        curMem=(TByte*)_hpatch_align_upper(curMem,sizeof(hpatch_StreamPos_t));
-        self->partChecksums=curMem;
-        curMem+=self->savedStrongChecksumByteSize*(size_t)kBlockCount;
-        assert(curMem<=(TByte*)self->_import+memSize);
-    }
-    if (isChecksumNewSyncInfo){
-        //reload clip for infoFullChecksum
-        check(checksumInputStream.open(newSyncInfo,self->infoChecksumEndPos-kStrongChecksumByteSize,
-                                       strongChecksumPlugin), kSyncClient_strongChecksumOpenError);
-        _TStreamCacheClip_init(&clip,&checksumInputStream,0,checksumInputStream.streamSize,
-                               temp_cache,kFileIOBufBetterSize);
-        check(_TStreamCacheClip_skipData(&clip,headEndPos), //checksum head data[0--headEndPos)
-              kSyncClient_newSyncInfoDataError);
-    }
-    {//load saved newDataCheckChecksum
-        check(_TStreamCacheClip_readDataTo(&clip,self->savedNewDataCheckChecksum,self->savedNewDataCheckChecksum
-                                           +kStrongChecksumByteSize),kSyncClient_newSyncInfoDataError);
-    }
-    if (privateExternDataSize>0){
-        check(_TStreamCacheClip_skipData(&clip,privateExternDataSize), //reserved ,now unknow
-              kSyncClient_newSyncInfoDataError);
-    }
-    if (externDataSize>0){
-        check(_TStreamCacheClip_skipData(&clip,externDataSize), //reserved ,now unknow
-              kSyncClient_newSyncInfoDataError);
-    }
-    
-    {// compressed? buf
-        #define _clear_decompresser(_decompresser) \
-                    if (_decompresser.decompressHandle){   \
-                        decompressPlugin->dictDecompressClose(decompressPlugin,_decompresser.decompressHandle); \
-                        _decompresser.decompressHandle=0; }
-        TStreamCacheClip _cmCodeClip;
-        TStreamCacheClip* codeClip=0;
-        if (compressDataSize>0) {
-            TByte*  decompressBuf=(TByte*)self->_import+(memSize-uncompressDataSize);
-            hpatch_byte* codeBuf=decompressBuf-compressDataSize;
-            hpatch_StreamPos_t curPos=_TStreamCacheClip_readPosOfSrcStream(&clip);
-            const hpatch_TStreamInput* inStream=isChecksumNewSyncInfo?&checksumInputStream:newSyncInfo;
-            
-            check(inStream->read(inStream,curPos,codeBuf,codeBuf+compressDataSize),kSyncClient_newSyncInfoDataError);
-            decompresser.decompressPlugin=decompressPlugin;
-            decompresser.decompressHandle=decompressPlugin->dictDecompressOpen(decompressPlugin,1,(size_t)uncompressDataSize,0,0);
-            check((decompresser.decompressHandle!=0),kSyncClient_decompressOpenError);
-            check(decompressPlugin->dictDecompress(decompresser.decompressHandle,0,codeBuf,codeBuf+compressDataSize,
-                                                   decompressBuf,decompressBuf+uncompressDataSize,0),
-                  kSyncClient_decompressError);
-            
-            codeClip=&_cmCodeClip;
-            _TStreamCacheClip_init(codeClip,0,0,0,decompressBuf,(size_t)uncompressDataSize);
-            codeClip->cacheBegin=0;
-        }else{
-            codeClip=&clip;
-        }
-        
-        //samePairList
-        check(readSamePairListTo(codeClip,self->samePairList,self->samePairCount,kBlockCount),
-              kSyncClient_newSyncInfoDataError);
-        if (isSavedSizes) //savedSizes
-            check(readSavedSizesTo(codeClip,self,isIgnoreCompressInfo),kSyncClient_newSyncInfoDataError);
-        else
-            assert(self->savedSizes==0);
-        if (compressDataSize>0)
-            _clear_decompresser(decompresser);
-    }
-    if (isChecksumNewSyncInfo){//info Checksum
-        check(newSyncInfo->read(newSyncInfo,checksumInputStream.streamSize,self->infoChecksum,
-                                self->infoChecksum+kStrongChecksumByteSize),
-              kSyncClient_newSyncInfoDataError);
-
-        TByte* strongChecksumInfo=checksumInputStream.finish();
-        assert(kStrongChecksumByteSize==checksumInputStream.checksumByteSize());
-        check(0==memcmp(strongChecksumInfo,self->infoChecksum,kStrongChecksumByteSize),
-              kSyncClient_newSyncInfoChecksumError);
-
-        check(checksumInputStream.reopen(newSyncInfo->streamSize-kStrongChecksumByteSize),
-              kSyncClient_strongChecksumOpenError);
-    }
-    {
-        hpatch_StreamPos_t curPos=_TStreamCacheClip_readPosOfSrcStream(&clip);
-        const hpatch_TStreamInput* inStream=isChecksumNewSyncInfo?&checksumInputStream:newSyncInfo;
-        _TStreamCacheClip_init(&clip,inStream,curPos+compressDataSize,inStream->streamSize,
-                               temp_cache,kFileIOBufBetterSize);
-
-        _TStreamCacheClip_skipData(&clip,kStrongChecksumByteSize);
-    }
-
-    //rollHashs
-    check(readPartHashTo(&clip,self->rollHashs,self->savedRollHashBits,self->samePairList,
-                         self->samePairCount,kBlockCount), kSyncClient_newSyncInfoDataError);
-    //partStrongChecksums
-    check(readPartHashTo(&clip,self->partChecksums,self->savedStrongChecksumBits,
-                         self->samePairList,self->samePairCount,
-                         kBlockCount), kSyncClient_newSyncInfoDataError);
-
-    if (isChecksumNewSyncInfo){ //info partHash Checksum
-        const hpatch_StreamPos_t infoChecksumPos=_TStreamCacheClip_readPosOfSrcStream(&clip);
-        check(newSyncInfo->read(newSyncInfo,infoChecksumPos,self->infoPartHashChecksum,
-                                self->infoPartHashChecksum+kStrongChecksumByteSize),
-              kSyncClient_newSyncInfoDataError);
-        
-        TByte* strongChecksumInfo=checksumInputStream.finish();
-        assert(kStrongChecksumByteSize==checksumInputStream.checksumByteSize());
-        check(0==memcmp(strongChecksumInfo,self->infoPartHashChecksum,kStrongChecksumByteSize),
-              kSyncClient_newSyncInfoChecksumError);
-    }
-    check(_TStreamCacheClip_readPosOfSrcStream(&clip)+kStrongChecksumByteSize
-          ==newSyncInfo->streamSize, kSyncClient_newSyncInfoDataError);
-    if (isIgnoreCompressInfo){
-        self->compressType=0;
-        self->_decompressPlugin=0;
-    }
-
-clear:
-    _inClear=1;
-    _clear_decompresser(decompresser);
-    if (result!=kSyncClient_ok) TNewDataSyncInfo_close(self);
-    if (temp_cache) free(temp_cache);
-    return result;
-}
-
-#if (_IS_NEED_DIR_DIFF_PATCH)
-TSyncClient_resultType TNewDataSyncInfo_dir_load(TNewDataSyncInfo_dir* self,const hpatch_byte* buf,size_t bufSize){
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    TStreamCacheClip _clip;
-    TStreamCacheClip* clip=&_clip;
-    _TStreamCacheClip_init(clip,0,0,0,(hpatch_byte*)buf,bufSize);
-    clip->cacheBegin=0;
-
-    check(_readDirHead(self,clip),kSyncClient_savedNewDirInfoDataError);
-
-    //dir_newExecuteIndexList
-    check(readIncListTo(clip,self->dir_newExecuteIndexList,self->dir_newExecuteCount,
-                        self->dir_newPathCount),kSyncClient_savedNewDirInfoDataError);
-    //dir_newSizeList
-    check(readListTo(clip,self->dir_newSizeList,self->dir_newPathCount),
-            kSyncClient_savedNewDirInfoDataError);
-    //dir_utf8NewNameList
-    if (self->dir_newPathCount>0){
-        char* charsBuf=((char**)self->dir_utf8NewNameList)[0];
-        check(_TStreamCacheClip_readDataTo(clip,(TByte*)charsBuf,
-                                           (TByte*)charsBuf+self->dir_newPathSumCharSize),
-              kSyncClient_savedNewDirInfoDataError);
-        formatDirTagForLoad(charsBuf,charsBuf+self->dir_newPathSumCharSize);
-        check(clipCStrsTo(charsBuf,charsBuf+self->dir_newPathSumCharSize,
-                            (const char**)self->dir_utf8NewNameList,self->dir_newPathCount),
-                kSyncClient_savedNewDirInfoDataError);
-    }
-clear:
-    _inClear=1;
-    return result;
-}
-#endif
-
-void TNewDataSyncInfo_close(TNewDataSyncInfo* self){
-    if (self==0) return;
-    if (self->_import!=0) free(self->_import);
-    if (self->_extraMem!=0) free(self->_extraMem);
-    TNewDataSyncInfo_init(self);
-}
-
-TSyncClient_resultType TNewDataSyncInfo_open(TNewDataSyncInfo* self,const hpatch_TStreamInput* newSyncInfo,hpatch_BOOL isIgnoreCompressInfo,
-                                             ISyncInfoListener* listener){
-    TSyncClient_resultType result=_TNewDataSyncInfo_open(self,newSyncInfo,isIgnoreCompressInfo,listener);
-    if ((result==kSyncClient_ok)&&listener->onLoadedNewSyncInfo)
-        listener->onLoadedNewSyncInfo(listener,self);
-    return result;
-}
-
-TSyncClient_resultType TNewDataSyncInfo_open_by_file(TNewDataSyncInfo* self,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
-                                                     ISyncInfoListener *listener){
-    hpatch_TFileStreamInput  newSyncInfo;
-    hpatch_TFileStreamInput_init(&newSyncInfo);
-    TSyncClient_resultType result=kSyncClient_ok;
-    int _inClear=0;
-    check(hpatch_TFileStreamInput_open(&newSyncInfo,newSyncInfoFile), kSyncClient_newSyncInfoOpenError);
-    result=_TNewDataSyncInfo_open(self,&newSyncInfo.base,isIgnoreCompressInfo,listener);
-clear:
-    _inClear=1;
-    check(hpatch_TFileStreamInput_close(&newSyncInfo), kSyncClient_newSyncInfoCloseError);
-    if ((result==kSyncClient_ok)&&listener->onLoadedNewSyncInfo)
-        listener->onLoadedNewSyncInfo(listener,self);
-    return result;
-}
-