|
|
@@ -1,2384 +0,0 @@
|
|
|
-//patch.c
|
|
|
-//
|
|
|
-/*
|
|
|
- The MIT License (MIT)
|
|
|
- Copyright (c) 2012-2018 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 "patch.h"
|
|
|
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
|
|
|
-# include <stdlib.h> //qsort
|
|
|
-#endif
|
|
|
-#include "patch_private.h"
|
|
|
-
|
|
|
-#ifndef _IS_RUN_MEM_SAFE_CHECK
|
|
|
-# define _IS_RUN_MEM_SAFE_CHECK 1
|
|
|
-#endif
|
|
|
-
|
|
|
-#if (_IS_RUN_MEM_SAFE_CHECK)
|
|
|
-//__RUN_MEM_SAFE_CHECK用来启动内存访问越界检查,用以防御可能被意外或故意损坏的数据.
|
|
|
-# define __RUN_MEM_SAFE_CHECK
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
-# define _SAFE_CHECK_DO(code) do{ if (!(code)) return _hpatch_FALSE; }while(0)
|
|
|
-#else
|
|
|
-# define _SAFE_CHECK_DO(code) do{ code; }while(0)
|
|
|
-#endif
|
|
|
-
|
|
|
-#define _hpatch_FALSE hpatch_FALSE
|
|
|
-//hpatch_uint __hpatch_debug_check_false_x=0; //for debug
|
|
|
-//#define _hpatch_FALSE (1/__hpatch_debug_check_false_x)
|
|
|
-
|
|
|
-typedef unsigned char TByte;
|
|
|
-
|
|
|
-
|
|
|
-//变长正整数编码方案(x bit额外类型标志位,x<=7),从高位开始输出1--n byte:
|
|
|
-// x0* 7-x bit
|
|
|
-// x1* 0* 7+7-x bit
|
|
|
-// x1* 1* 0* 7+7+7-x bit
|
|
|
-// x1* 1* 1* 0* 7+7+7+7-x bit
|
|
|
-// x1* 1* 1* 1* 0* 7+7+7+7+7-x bit
|
|
|
-// ......
|
|
|
-hpatch_BOOL hpatch_packUIntWithTag(TByte** out_code,TByte* out_code_end,
|
|
|
- hpatch_StreamPos_t uValue,hpatch_uint highTag,
|
|
|
- const hpatch_uint kTagBit){//写入整数并前进指针.
|
|
|
- TByte* pcode=*out_code;
|
|
|
- const hpatch_StreamPos_t kMaxValueWithTag=((hpatch_StreamPos_t)1<<(7-kTagBit))-1;
|
|
|
- TByte codeBuf[hpatch_kMaxPackedUIntBytes];
|
|
|
- TByte* codeEnd=codeBuf;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- //static const hpatch_uint kPackMaxTagBit=7;
|
|
|
- //assert((0<=kTagBit)&&(kTagBit<=kPackMaxTagBit));
|
|
|
- //assert((highTag>>kTagBit)==0);
|
|
|
-#endif
|
|
|
- while (uValue>kMaxValueWithTag) {
|
|
|
- *codeEnd=uValue&((1<<7)-1); ++codeEnd;
|
|
|
- uValue>>=7;
|
|
|
- }
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ((out_code_end-pcode)<(1+(codeEnd-codeBuf))) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- *pcode=(TByte)( (TByte)uValue | (highTag<<(8-kTagBit))
|
|
|
- | (((codeBuf!=codeEnd)?1:0)<<(7-kTagBit)) );
|
|
|
- ++pcode;
|
|
|
- while (codeBuf!=codeEnd) {
|
|
|
- --codeEnd;
|
|
|
- *pcode=(*codeEnd) | (((codeBuf!=codeEnd)?1:0)<<7);
|
|
|
- ++pcode;
|
|
|
- }
|
|
|
- *out_code=pcode;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_uint hpatch_packUIntWithTag_size(hpatch_StreamPos_t uValue,const hpatch_uint kTagBit){
|
|
|
- const hpatch_StreamPos_t kMaxValueWithTag=((hpatch_StreamPos_t)1<<(7-kTagBit))-1;
|
|
|
- hpatch_uint size=0;
|
|
|
- while (uValue>kMaxValueWithTag) {
|
|
|
- ++size;
|
|
|
- uValue>>=7;
|
|
|
- }
|
|
|
- ++size;
|
|
|
- return size;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL hpatch_unpackUIntWithTag(const TByte** src_code,const TByte* src_code_end,
|
|
|
- hpatch_StreamPos_t* result,const hpatch_uint kTagBit){//读出整数并前进指针.
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- //const hpatch_uint kPackMaxTagBit=7;
|
|
|
-#endif
|
|
|
- hpatch_StreamPos_t value;
|
|
|
- TByte code;
|
|
|
- const TByte* pcode=*src_code;
|
|
|
-
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- //assert(kTagBit<=kPackMaxTagBit);
|
|
|
- if (src_code_end<=pcode) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- code=*pcode; ++pcode;
|
|
|
- value=code&((1<<(7-kTagBit))-1);
|
|
|
- if ((code&(1<<(7-kTagBit)))!=0){
|
|
|
- do {
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ((value>>(sizeof(value)*8-7))!=0) return _hpatch_FALSE;//cannot save 7bit
|
|
|
- if (src_code_end==pcode) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- code=*pcode; ++pcode;
|
|
|
- value=(value<<7) | (code&((1<<7)-1));
|
|
|
- } while ((code&(1<<7))!=0);
|
|
|
- }
|
|
|
- (*src_code)=pcode;
|
|
|
- *result=value;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
- static hpatch_BOOL _read_mem_stream(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end){
|
|
|
- const unsigned char* src=(const unsigned char*)stream->streamImport;
|
|
|
- hpatch_size_t readLen=out_data_end-out_data;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (readFromPos>stream->streamSize) return _hpatch_FALSE;
|
|
|
- if (readLen>(hpatch_StreamPos_t)(stream->streamSize-readFromPos)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- memcpy(out_data,src+readFromPos,readLen);
|
|
|
- return hpatch_TRUE;
|
|
|
- }
|
|
|
-const hpatch_TStreamInput* mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
|
|
|
- const unsigned char* mem,const unsigned char* mem_end){
|
|
|
- out_stream->streamImport=(void*)mem;
|
|
|
- out_stream->streamSize=mem_end-mem;
|
|
|
- out_stream->read=_read_mem_stream;
|
|
|
- return out_stream;
|
|
|
-}
|
|
|
-
|
|
|
- static hpatch_BOOL _write_mem_stream(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
|
|
|
- const unsigned char* data,const unsigned char* data_end){
|
|
|
- unsigned char* out_dst=(unsigned char*)stream->streamImport;
|
|
|
- hpatch_size_t writeLen=data_end-data;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (writeToPos>stream->streamSize) return _hpatch_FALSE;
|
|
|
- if (writeLen>(hpatch_StreamPos_t)(stream->streamSize-writeToPos)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- memcpy(out_dst+writeToPos,data,writeLen);
|
|
|
- return hpatch_TRUE;
|
|
|
- }
|
|
|
- typedef hpatch_BOOL (*_read_mem_stream_t)(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end);
|
|
|
-const hpatch_TStreamOutput* mem_as_hStreamOutput(hpatch_TStreamOutput* out_stream,
|
|
|
- unsigned char* mem,unsigned char* mem_end){
|
|
|
- out_stream->streamImport=mem;
|
|
|
- out_stream->streamSize=mem_end-mem;
|
|
|
- out_stream->read_writed=(_read_mem_stream_t)_read_mem_stream;
|
|
|
- out_stream->write=_write_mem_stream;
|
|
|
- return out_stream;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL hpatch_deccompress_mem(hpatch_TDecompress* decompressPlugin,
|
|
|
- const unsigned char* code,const unsigned char* code_end,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end){
|
|
|
- hpatch_decompressHandle dec=0;
|
|
|
- hpatch_BOOL result,colose_rt;
|
|
|
- hpatch_TStreamInput codeStream;
|
|
|
- mem_as_hStreamInput(&codeStream,code,code_end);
|
|
|
- dec=decompressPlugin->open(decompressPlugin,(out_data_end-out_data),
|
|
|
- &codeStream,0,codeStream.streamSize);
|
|
|
- if (dec==0) return _hpatch_FALSE;
|
|
|
- result=decompressPlugin->decompress_part(dec,out_data,out_data_end);
|
|
|
- colose_rt=decompressPlugin->close(decompressPlugin,dec);
|
|
|
- assert(colose_rt);
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-////////
|
|
|
-//patch by memory
|
|
|
-
|
|
|
-static const hpatch_uint kSignTagBit=1;
|
|
|
-
|
|
|
-static hpatch_BOOL _bytesRle_load(TByte* out_data,TByte* out_dataEnd,
|
|
|
- const TByte* rle_code,const TByte* rle_code_end);
|
|
|
-static void addData(TByte* dst,const TByte* src,hpatch_size_t length);
|
|
|
-hpatch_inline
|
|
|
-static hpatch_BOOL _unpackUIntWithTag(const TByte** src_code,const TByte* src_code_end,
|
|
|
- hpatch_size_t* result,const hpatch_uint kTagBit){
|
|
|
- if (sizeof(hpatch_size_t)==sizeof(hpatch_StreamPos_t)){
|
|
|
- return hpatch_unpackUIntWithTag(src_code,src_code_end,(hpatch_StreamPos_t*)result,kTagBit);
|
|
|
- }else{
|
|
|
- hpatch_StreamPos_t u64=0;
|
|
|
- hpatch_BOOL rt=hpatch_unpackUIntWithTag(src_code,src_code_end,&u64,kTagBit);
|
|
|
- hpatch_size_t u=(hpatch_size_t)u64;
|
|
|
- *result=u;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- return rt&(u==u64);
|
|
|
-#else
|
|
|
- return rt;
|
|
|
-#endif
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-#define unpackUIntWithTagTo(puint,src_code,src_code_end,kTagBit) \
|
|
|
- _SAFE_CHECK_DO(_unpackUIntWithTag(src_code,src_code_end,puint,kTagBit))
|
|
|
-#define unpackUIntTo(puint,src_code,src_code_end) \
|
|
|
- unpackUIntWithTagTo(puint,src_code,src_code_end,0)
|
|
|
-
|
|
|
-hpatch_BOOL patch(TByte* out_newData,TByte* out_newData_end,
|
|
|
- const TByte* oldData,const TByte* oldData_end,
|
|
|
- const TByte* serializedDiff,const TByte* serializedDiff_end){
|
|
|
- const TByte *code_lengths, *code_lengths_end,
|
|
|
- *code_inc_newPos, *code_inc_newPos_end,
|
|
|
- *code_inc_oldPos, *code_inc_oldPos_end,
|
|
|
- *code_newDataDiff, *code_newDataDiff_end;
|
|
|
- hpatch_size_t coverCount;
|
|
|
-
|
|
|
- assert(out_newData<=out_newData_end);
|
|
|
- assert(oldData<=oldData_end);
|
|
|
- assert(serializedDiff<=serializedDiff_end);
|
|
|
- unpackUIntTo(&coverCount,&serializedDiff, serializedDiff_end);
|
|
|
- { //head
|
|
|
- hpatch_size_t lengthSize,inc_newPosSize,inc_oldPosSize,newDataDiffSize;
|
|
|
- unpackUIntTo(&lengthSize,&serializedDiff, serializedDiff_end);
|
|
|
- unpackUIntTo(&inc_newPosSize,&serializedDiff, serializedDiff_end);
|
|
|
- unpackUIntTo(&inc_oldPosSize,&serializedDiff, serializedDiff_end);
|
|
|
- unpackUIntTo(&newDataDiffSize,&serializedDiff, serializedDiff_end);
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (lengthSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- code_lengths=serializedDiff; serializedDiff+=lengthSize;
|
|
|
- code_lengths_end=serializedDiff;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (inc_newPosSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- code_inc_newPos=serializedDiff; serializedDiff+=inc_newPosSize;
|
|
|
- code_inc_newPos_end=serializedDiff;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (inc_oldPosSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- code_inc_oldPos=serializedDiff; serializedDiff+=inc_oldPosSize;
|
|
|
- code_inc_oldPos_end=serializedDiff;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (newDataDiffSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- code_newDataDiff=serializedDiff; serializedDiff+=newDataDiffSize;
|
|
|
- code_newDataDiff_end=serializedDiff;
|
|
|
- }
|
|
|
-
|
|
|
- //decode rle ; rle data begin==cur serializedDiff;
|
|
|
- _SAFE_CHECK_DO(_bytesRle_load(out_newData, out_newData_end, serializedDiff, serializedDiff_end));
|
|
|
-
|
|
|
- { //patch
|
|
|
- const hpatch_size_t newDataSize=(hpatch_size_t)(out_newData_end-out_newData);
|
|
|
- hpatch_size_t oldPosBack=0;
|
|
|
- hpatch_size_t newPosBack=0;
|
|
|
- hpatch_size_t i;
|
|
|
- for (i=0; i<coverCount; ++i){
|
|
|
- hpatch_size_t copyLength,addLength, oldPos,inc_oldPos,inc_oldPos_sign;
|
|
|
- unpackUIntTo(©Length,&code_inc_newPos, code_inc_newPos_end);
|
|
|
- unpackUIntTo(&addLength,&code_lengths, code_lengths_end);
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (code_inc_oldPos>=code_inc_oldPos_end) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- inc_oldPos_sign=(*code_inc_oldPos)>>(8-kSignTagBit);
|
|
|
- unpackUIntWithTagTo(&inc_oldPos,&code_inc_oldPos, code_inc_oldPos_end, kSignTagBit);
|
|
|
- if (inc_oldPos_sign==0)
|
|
|
- oldPos=oldPosBack+inc_oldPos;
|
|
|
- else
|
|
|
- oldPos=oldPosBack-inc_oldPos;
|
|
|
- if (copyLength>0){
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (copyLength>(hpatch_size_t)(newDataSize-newPosBack)) return _hpatch_FALSE;
|
|
|
- if (copyLength>(hpatch_size_t)(code_newDataDiff_end-code_newDataDiff)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- memcpy(out_newData+newPosBack,code_newDataDiff,copyLength);
|
|
|
- code_newDataDiff+=copyLength;
|
|
|
- newPosBack+=copyLength;
|
|
|
- }
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ( (addLength>(hpatch_size_t)(newDataSize-newPosBack)) ) return _hpatch_FALSE;
|
|
|
- if ( (oldPos>(hpatch_size_t)(oldData_end-oldData)) ||
|
|
|
- (addLength>(hpatch_size_t)(oldData_end-oldData-oldPos)) ) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- addData(out_newData+newPosBack,oldData+oldPos,addLength);
|
|
|
- oldPosBack=oldPos;
|
|
|
- newPosBack+=addLength;
|
|
|
- }
|
|
|
-
|
|
|
- if (newPosBack<newDataSize){
|
|
|
- hpatch_size_t copyLength=newDataSize-newPosBack;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (copyLength>(hpatch_size_t)(code_newDataDiff_end-code_newDataDiff)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- memcpy(out_newData+newPosBack,code_newDataDiff,copyLength);
|
|
|
- code_newDataDiff+=copyLength;
|
|
|
- //newPosBack=newDataSize;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ( (code_lengths==code_lengths_end)
|
|
|
- &&(code_inc_newPos==code_inc_newPos_end)
|
|
|
- &&(code_inc_oldPos==code_inc_oldPos_end)
|
|
|
- &&(code_newDataDiff==code_newDataDiff_end))
|
|
|
- return hpatch_TRUE;
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_inline static void addData(TByte* dst,const TByte* src,hpatch_size_t length){
|
|
|
- while (length--) { *dst++ += *src++; }
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _bytesRle_load(TByte* out_data,TByte* out_dataEnd,
|
|
|
- const TByte* rle_code,const TByte* rle_code_end){
|
|
|
- const TByte* ctrlBuf,*ctrlBuf_end;
|
|
|
- hpatch_size_t ctrlSize;
|
|
|
- unpackUIntTo(&ctrlSize,&rle_code,rle_code_end);
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (ctrlSize>(hpatch_size_t)(rle_code_end-rle_code)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- ctrlBuf=rle_code;
|
|
|
- rle_code+=ctrlSize;
|
|
|
- ctrlBuf_end=rle_code;
|
|
|
- while (ctrlBuf_end-ctrlBuf>0){
|
|
|
- enum TByteRleType type=(enum TByteRleType)((*ctrlBuf)>>(8-kByteRleType_bit));
|
|
|
- hpatch_size_t length;
|
|
|
- unpackUIntWithTagTo(&length,&ctrlBuf,ctrlBuf_end,kByteRleType_bit);
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (length>=(hpatch_size_t)(out_dataEnd-out_data)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- ++length;
|
|
|
- switch (type){
|
|
|
- case kByteRleType_rle0:{
|
|
|
- memset(out_data,0,length);
|
|
|
- out_data+=length;
|
|
|
- }break;
|
|
|
- case kByteRleType_rle255:{
|
|
|
- memset(out_data,255,length);
|
|
|
- out_data+=length;
|
|
|
- }break;
|
|
|
- case kByteRleType_rle:{
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (1>(hpatch_size_t)(rle_code_end-rle_code)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- memset(out_data,*rle_code,length);
|
|
|
- ++rle_code;
|
|
|
- out_data+=length;
|
|
|
- }break;
|
|
|
- case kByteRleType_unrle:{
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (length>(hpatch_size_t)(rle_code_end-rle_code)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- memcpy(out_data,rle_code,length);
|
|
|
- rle_code+=length;
|
|
|
- out_data+=length;
|
|
|
- }break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ( (ctrlBuf==ctrlBuf_end)
|
|
|
- &&(rle_code==rle_code_end)
|
|
|
- &&(out_data==out_dataEnd))
|
|
|
- return hpatch_TRUE;
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-//----------------------
|
|
|
-//patch by stream
|
|
|
-
|
|
|
- static hpatch_BOOL _TStreamInputClip_read(const hpatch_TStreamInput* stream,
|
|
|
- hpatch_StreamPos_t readFromPos,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end){
|
|
|
- TStreamInputClip* self=(TStreamInputClip*)stream->streamImport;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (readFromPos+(out_data_end-out_data)>self->base.streamSize) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- return self->srcStream->read(self->srcStream,readFromPos+self->clipBeginPos,out_data,out_data_end);
|
|
|
- }
|
|
|
-void TStreamInputClip_init(TStreamInputClip* self,const hpatch_TStreamInput* srcStream,
|
|
|
- hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos){
|
|
|
- assert(self!=0);
|
|
|
- assert(srcStream!=0);
|
|
|
- assert(clipBeginPos<=clipEndPos);
|
|
|
- assert(clipEndPos<=srcStream->streamSize);
|
|
|
- self->srcStream=srcStream;
|
|
|
- self->clipBeginPos=clipBeginPos;
|
|
|
- self->base.streamImport=self;
|
|
|
- self->base.streamSize=clipEndPos-clipBeginPos;
|
|
|
- self->base.read=_TStreamInputClip_read;
|
|
|
-}
|
|
|
-
|
|
|
- static hpatch_BOOL _TStreamOutputClip_write(const hpatch_TStreamOutput* stream,
|
|
|
- hpatch_StreamPos_t writePos,
|
|
|
- const unsigned char* data,const unsigned char* data_end){
|
|
|
- TStreamOutputClip* self=(TStreamOutputClip*)stream->streamImport;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (writePos+(data_end-data)>self->base.streamSize) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- return self->srcStream->write(self->srcStream,writePos+self->clipBeginPos,data,data_end);
|
|
|
-}
|
|
|
-
|
|
|
-void TStreamOutputClip_init(TStreamOutputClip* self,const hpatch_TStreamOutput* srcStream,
|
|
|
- hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos){
|
|
|
- assert(self!=0);
|
|
|
- assert(srcStream!=0);
|
|
|
- assert(clipBeginPos<=clipEndPos);
|
|
|
- assert(clipEndPos<=srcStream->streamSize);
|
|
|
- self->srcStream=srcStream;
|
|
|
- self->clipBeginPos=clipBeginPos;
|
|
|
- self->base.streamImport=self;
|
|
|
- self->base.streamSize=clipEndPos-clipBeginPos;
|
|
|
- ((TStreamInputClip*)self)->base.read=_TStreamInputClip_read;
|
|
|
- self->base.write=_TStreamOutputClip_write;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-//assert(hpatch_kStreamCacheSize>=hpatch_kMaxPluginTypeLength+1);
|
|
|
-struct __private_hpatch_check_kMaxCompressTypeLength {
|
|
|
- char _[(hpatch_kStreamCacheSize>=(hpatch_kMaxPluginTypeLength+1))?1:-1];};
|
|
|
-
|
|
|
-hpatch_BOOL _TStreamCacheClip_readType_end(TStreamCacheClip* sclip,TByte endTag,
|
|
|
- char out_type[hpatch_kMaxPluginTypeLength+1]){
|
|
|
- const TByte* type_begin;
|
|
|
- hpatch_size_t i;
|
|
|
- hpatch_size_t readLen=hpatch_kMaxPluginTypeLength+1;
|
|
|
- if (readLen>_TStreamCacheClip_leaveSize(sclip))
|
|
|
- readLen=(hpatch_size_t)_TStreamCacheClip_leaveSize(sclip);
|
|
|
- type_begin=_TStreamCacheClip_accessData(sclip,readLen);
|
|
|
- if (type_begin==0) return _hpatch_FALSE;//not found
|
|
|
- for (i=0; i<readLen; ++i) {
|
|
|
- if (type_begin[i]!=endTag)
|
|
|
- continue;
|
|
|
- else{
|
|
|
- memcpy(out_type,type_begin,i); out_type[i]='\0';
|
|
|
- _TStreamCacheClip_skipData_noCheck(sclip,i+1);
|
|
|
- return hpatch_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- return _hpatch_FALSE;//not found
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TStreamCacheClip_updateCache(TStreamCacheClip* sclip){
|
|
|
- TByte* buf0=&sclip->cacheBuf[0];
|
|
|
- const hpatch_StreamPos_t streamSize=sclip->streamPos_end-sclip->streamPos;
|
|
|
- hpatch_size_t readSize=sclip->cacheBegin;
|
|
|
- if (readSize>streamSize)
|
|
|
- readSize=(hpatch_size_t)streamSize;
|
|
|
- if (readSize==0) return hpatch_TRUE;
|
|
|
- if (!_TStreamCacheClip_isCacheEmpty(sclip)){
|
|
|
- memmove(buf0+(hpatch_size_t)(sclip->cacheBegin-readSize),
|
|
|
- buf0+sclip->cacheBegin,_TStreamCacheClip_cachedSize(sclip));
|
|
|
- }
|
|
|
- if (!sclip->srcStream->read(sclip->srcStream,sclip->streamPos,
|
|
|
- buf0+(sclip->cacheEnd-readSize),buf0+sclip->cacheEnd))
|
|
|
- return _hpatch_FALSE;//read error
|
|
|
- sclip->cacheBegin-=readSize;
|
|
|
- sclip->streamPos+=readSize;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TStreamCacheClip_skipData(TStreamCacheClip* sclip,hpatch_StreamPos_t skipLongSize){
|
|
|
- while (skipLongSize>0) {
|
|
|
- hpatch_size_t len=sclip->cacheEnd;
|
|
|
- if (len>skipLongSize)
|
|
|
- len=(hpatch_size_t)skipLongSize;
|
|
|
- if (_TStreamCacheClip_accessData(sclip,len)){
|
|
|
- _TStreamCacheClip_skipData_noCheck(sclip,len);
|
|
|
- skipLongSize-=len;
|
|
|
- }else{
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-//assert(hpatch_kStreamCacheSize>=hpatch_kMaxPackedUIntBytes);
|
|
|
-struct __private_hpatch_check_hpatch_kMaxPackedUIntBytes {
|
|
|
- char _[(hpatch_kStreamCacheSize>=hpatch_kMaxPackedUIntBytes)?1:-1]; };
|
|
|
-
|
|
|
-hpatch_BOOL _TStreamCacheClip_unpackUIntWithTag(TStreamCacheClip* sclip,hpatch_StreamPos_t* result,const hpatch_uint kTagBit){
|
|
|
- TByte* curCode,*codeBegin;
|
|
|
- hpatch_size_t readSize=hpatch_kMaxPackedUIntBytes;
|
|
|
- const hpatch_StreamPos_t dataSize=_TStreamCacheClip_leaveSize(sclip);
|
|
|
- if (readSize>dataSize)
|
|
|
- readSize=(hpatch_size_t)dataSize;
|
|
|
- codeBegin=_TStreamCacheClip_accessData(sclip,readSize);
|
|
|
- if (codeBegin==0) return _hpatch_FALSE;
|
|
|
- curCode=codeBegin;
|
|
|
- _SAFE_CHECK_DO(hpatch_unpackUIntWithTag((const TByte**)&curCode,codeBegin+readSize,result,kTagBit));
|
|
|
- _TStreamCacheClip_skipData_noCheck(sclip,(hpatch_size_t)(curCode-codeBegin));
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TStreamCacheClip_readDataTo(TStreamCacheClip* sclip,TByte* out_buf,TByte* bufEnd){
|
|
|
- hpatch_size_t readLen=_TStreamCacheClip_cachedSize(sclip);
|
|
|
- hpatch_size_t outLen=bufEnd-out_buf;
|
|
|
- if (readLen>=outLen)
|
|
|
- readLen=outLen;
|
|
|
- memcpy(out_buf,&sclip->cacheBuf[sclip->cacheBegin],readLen);
|
|
|
- sclip->cacheBegin+=readLen;
|
|
|
- outLen-=readLen;
|
|
|
- if (outLen){
|
|
|
- out_buf += readLen;
|
|
|
- if (outLen<(sclip->cacheEnd>>1)){
|
|
|
- if (!_TStreamCacheClip_updateCache(sclip)) return _hpatch_FALSE;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (outLen>_TStreamCacheClip_cachedSize(sclip)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- return _TStreamCacheClip_readDataTo(sclip, out_buf, bufEnd);
|
|
|
- }else{
|
|
|
- if (!sclip->srcStream->read(sclip->srcStream,sclip->streamPos,
|
|
|
- out_buf,bufEnd)) return _hpatch_FALSE;
|
|
|
- sclip->streamPos+=outLen;
|
|
|
- }
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TStreamCacheClip_addDataTo(TStreamCacheClip* self,unsigned char* dst,hpatch_size_t addLen){
|
|
|
- const unsigned char* src=_TStreamCacheClip_readData(self,addLen);
|
|
|
- if (src==0) return _hpatch_FALSE;
|
|
|
- addData(dst,src,addLen);
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
- static hpatch_BOOL _decompress_read(const hpatch_TStreamInput* stream,
|
|
|
- const hpatch_StreamPos_t readFromPos,
|
|
|
- TByte* out_data,TByte* out_data_end){
|
|
|
- _TDecompressInputStream* self=(_TDecompressInputStream*)stream->streamImport;
|
|
|
- return self->decompressPlugin->decompress_part(self->decompressHandle,out_data,out_data_end);
|
|
|
- }
|
|
|
-hpatch_BOOL getStreamClip(TStreamCacheClip* out_clip,_TDecompressInputStream* out_stream,
|
|
|
- hpatch_StreamPos_t dataSize,hpatch_StreamPos_t compressedSize,
|
|
|
- const hpatch_TStreamInput* stream,hpatch_StreamPos_t* pCurStreamPos,
|
|
|
- hpatch_TDecompress* decompressPlugin,TByte* aCache,hpatch_size_t cacheSize){
|
|
|
- hpatch_StreamPos_t curStreamPos=*pCurStreamPos;
|
|
|
- if (compressedSize==0){
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ((curStreamPos+dataSize)<curStreamPos) return _hpatch_FALSE;
|
|
|
- if ((curStreamPos+dataSize)>stream->streamSize) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- if (out_clip)
|
|
|
- _TStreamCacheClip_init(out_clip,stream,curStreamPos,curStreamPos+dataSize,aCache,cacheSize);
|
|
|
- curStreamPos+=dataSize;
|
|
|
- }else{
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ((curStreamPos+compressedSize)<curStreamPos) return _hpatch_FALSE;
|
|
|
- if ((curStreamPos+compressedSize)>stream->streamSize) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- if (out_clip){
|
|
|
- out_stream->IInputStream.streamImport=out_stream;
|
|
|
- out_stream->IInputStream.streamSize=dataSize;
|
|
|
- out_stream->IInputStream.read=_decompress_read;
|
|
|
- out_stream->decompressPlugin=decompressPlugin;
|
|
|
- if (out_stream->decompressHandle==0){
|
|
|
- out_stream->decompressHandle=decompressPlugin->open(decompressPlugin,dataSize,stream,
|
|
|
- curStreamPos,curStreamPos+compressedSize);
|
|
|
- if (!out_stream->decompressHandle) return _hpatch_FALSE;
|
|
|
- }else{
|
|
|
- if (decompressPlugin->reset_code==0) return _hpatch_FALSE;
|
|
|
- if (!decompressPlugin->reset_code(out_stream->decompressHandle,dataSize,stream,curStreamPos,
|
|
|
- curStreamPos+compressedSize)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- _TStreamCacheClip_init(out_clip,&out_stream->IInputStream,0,
|
|
|
- out_stream->IInputStream.streamSize,aCache,cacheSize);
|
|
|
- }
|
|
|
- curStreamPos+=compressedSize;
|
|
|
- }
|
|
|
- *pCurStreamPos=curStreamPos;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-///////
|
|
|
-
|
|
|
-static hpatch_inline hpatch_BOOL __TOutStreamCache_writeStream(_TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
|
|
|
- if (!self->dstStream->write(self->dstStream,self->writeToPos,data,data+dataSize))
|
|
|
- return _hpatch_FALSE;
|
|
|
- self->writeToPos+=dataSize;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TOutStreamCache_flush(_TOutStreamCache* self){
|
|
|
- hpatch_size_t curSize=self->cacheCur;
|
|
|
- if (curSize>0){
|
|
|
- if (!__TOutStreamCache_writeStream(self,self->cacheBuf,curSize))
|
|
|
- return _hpatch_FALSE;
|
|
|
- self->cacheCur=0;
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TOutStreamCache_write(_TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
|
|
|
- while (dataSize>0) {
|
|
|
- hpatch_size_t copyLen;
|
|
|
- hpatch_size_t curSize=self->cacheCur;
|
|
|
- if ((dataSize>=self->cacheEnd)&&(curSize==0)){
|
|
|
- return __TOutStreamCache_writeStream(self,data,dataSize);
|
|
|
- }
|
|
|
- copyLen=self->cacheEnd-curSize;
|
|
|
- copyLen=(copyLen<=dataSize)?copyLen:dataSize;
|
|
|
- memcpy(self->cacheBuf+curSize,data,copyLen);
|
|
|
- self->cacheCur=curSize+copyLen;
|
|
|
- data+=copyLen;
|
|
|
- dataSize-=copyLen;
|
|
|
- if (self->cacheCur==self->cacheEnd){
|
|
|
- if (!_TOutStreamCache_flush(self))
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TOutStreamCache_fill(_TOutStreamCache* self,hpatch_byte fillValue,hpatch_StreamPos_t fillLength){
|
|
|
- while (fillLength>0){
|
|
|
- hpatch_size_t curSize=self->cacheCur;
|
|
|
- hpatch_size_t runStep=self->cacheEnd-curSize;
|
|
|
- runStep=(runStep<=fillLength)?runStep:(hpatch_size_t)fillLength;
|
|
|
- memset(self->cacheBuf+curSize,fillValue,runStep);
|
|
|
- self->cacheCur=curSize+runStep;
|
|
|
- fillLength-=runStep;
|
|
|
- if (self->cacheCur==self->cacheEnd){
|
|
|
- if (!_TOutStreamCache_flush(self))
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TOutStreamCache_copyFromStream(_TOutStreamCache* self,const hpatch_TStreamInput* src,
|
|
|
- hpatch_StreamPos_t srcPos,hpatch_StreamPos_t copyLength){
|
|
|
- while (copyLength>0){
|
|
|
- hpatch_size_t curSize=self->cacheCur;
|
|
|
- hpatch_size_t runStep=self->cacheEnd-curSize;
|
|
|
- hpatch_byte* buf=self->cacheBuf+curSize;
|
|
|
- runStep=(runStep<=copyLength)?runStep:(hpatch_size_t)copyLength;
|
|
|
- if (!src->read(src,srcPos,buf,buf+runStep))
|
|
|
- return _hpatch_FALSE;
|
|
|
- srcPos+=runStep;
|
|
|
- self->cacheCur=curSize+runStep;
|
|
|
- copyLength-=runStep;
|
|
|
- if (self->cacheCur==self->cacheEnd){
|
|
|
- if (!_TOutStreamCache_flush(self))
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TOutStreamCache_copyFromClip(_TOutStreamCache* self,TStreamCacheClip* src,hpatch_StreamPos_t copyLength){
|
|
|
- while (copyLength>0){
|
|
|
- const TByte* data;
|
|
|
- hpatch_size_t runStep=(src->cacheEnd<=copyLength)?src->cacheEnd:(hpatch_size_t)copyLength;
|
|
|
- data=_TStreamCacheClip_readData(src,runStep);
|
|
|
- if (data==0) return
|
|
|
- _hpatch_FALSE;
|
|
|
- if (!_TOutStreamCache_write(self,data,runStep))
|
|
|
- return _hpatch_FALSE;
|
|
|
- copyLength-=runStep;
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL _TOutStreamCache_copyFromSelf(_TOutStreamCache* self,hpatch_StreamPos_t aheadLength,hpatch_StreamPos_t copyLength){
|
|
|
- // [ writed ]
|
|
|
- // [ cached buf | empty buf ]
|
|
|
- const hpatch_TStreamInput* src=(const hpatch_TStreamInput*)self->dstStream;
|
|
|
- hpatch_StreamPos_t srcPos=self->writeToPos+self->cacheCur-aheadLength;
|
|
|
- if (src->read==0) //can't read
|
|
|
- return _hpatch_FALSE;
|
|
|
- if ((aheadLength<1)|(aheadLength>self->writeToPos+self->cacheCur))
|
|
|
- return _hpatch_FALSE;
|
|
|
-
|
|
|
- if (srcPos+copyLength<=self->writeToPos){//copy from stream
|
|
|
- // [ copyLength ]
|
|
|
-__copy_in_stream:
|
|
|
- return _TOutStreamCache_copyFromStream(self,src,srcPos,copyLength);
|
|
|
- }else if (srcPos>=self->writeToPos){ //copy in mem
|
|
|
- // [ copyLength ]
|
|
|
-__copy_in_mem:
|
|
|
- while (copyLength>0){
|
|
|
- hpatch_byte* dstBuf=self->cacheBuf+self->cacheCur;
|
|
|
- hpatch_byte* srcBuf=dstBuf-(hpatch_size_t)aheadLength;
|
|
|
- hpatch_size_t runLen=(self->cacheCur+copyLength<=self->cacheEnd)?(hpatch_size_t)copyLength:(self->cacheEnd-self->cacheCur);
|
|
|
- hpatch_size_t i;
|
|
|
- for (i=0;i<runLen;i++)
|
|
|
- dstBuf[i]=srcBuf[i];
|
|
|
- copyLength-=runLen;
|
|
|
- self->cacheCur+=runLen;
|
|
|
- if (self->cacheCur==self->cacheEnd){
|
|
|
- if (!_TOutStreamCache_flush(self))
|
|
|
- return _hpatch_FALSE;
|
|
|
- runLen=(hpatch_size_t)((aheadLength<=copyLength)?aheadLength:copyLength);
|
|
|
- memmove(self->cacheBuf,self->cacheBuf+self->cacheEnd-(hpatch_size_t)aheadLength,runLen);
|
|
|
- self->cacheCur=runLen;
|
|
|
- copyLength-=runLen;
|
|
|
- }else{
|
|
|
- assert(copyLength==0);
|
|
|
- }
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
- }else if (self->writeToPos+self->cacheCur<=srcPos+self->cacheEnd){
|
|
|
- // small data in stream，can as copy in mem
|
|
|
- hpatch_byte* dstBuf=self->cacheBuf+self->cacheCur;
|
|
|
- hpatch_size_t runLen=(hpatch_size_t)(self->writeToPos-srcPos);
|
|
|
- if (!src->read(src,srcPos,dstBuf,dstBuf+runLen))
|
|
|
- return _hpatch_FALSE;
|
|
|
- //srcPos+=runLen; //not used
|
|
|
- copyLength-=runLen;
|
|
|
- self->cacheCur+=runLen;
|
|
|
- if (self->cacheCur==self->cacheEnd){
|
|
|
- while (hpatch_TRUE){
|
|
|
- if (self->cacheCur==self->cacheEnd){
|
|
|
- if (!_TOutStreamCache_flush(self))
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
- if (copyLength>0){
|
|
|
- runLen=(self->cacheEnd<=copyLength)?self->cacheEnd:(hpatch_size_t)copyLength;
|
|
|
- //srcPos+=runLen; //not used
|
|
|
- copyLength-=runLen;
|
|
|
- self->cacheCur=runLen;
|
|
|
- }else{
|
|
|
- return hpatch_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- }else{
|
|
|
- goto __copy_in_mem;
|
|
|
- }
|
|
|
- }else{
|
|
|
- goto __copy_in_stream;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-typedef struct _TBytesRle_load_stream{
|
|
|
- hpatch_StreamPos_t memCopyLength;
|
|
|
- hpatch_StreamPos_t memSetLength;
|
|
|
- TByte memSetValue;
|
|
|
- TStreamCacheClip ctrlClip;
|
|
|
- TStreamCacheClip rleCodeClip;
|
|
|
-} _TBytesRle_load_stream;
|
|
|
-
|
|
|
-hpatch_inline
|
|
|
-static void _TBytesRle_load_stream_init(_TBytesRle_load_stream* loader){
|
|
|
- loader->memSetLength=0;
|
|
|
- loader->memSetValue=0;//nil;
|
|
|
- loader->memCopyLength=0;
|
|
|
- _TStreamCacheClip_init(&loader->ctrlClip,0,0,0,0,0);
|
|
|
- _TStreamCacheClip_init(&loader->rleCodeClip,0,0,0,0,0);
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_inline static void memSet_add(TByte* dst,const TByte src,hpatch_size_t length){
|
|
|
- while (length--) { (*dst++) += src; }
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _TBytesRle_load_stream_mem_add(_TBytesRle_load_stream* loader,
|
|
|
- hpatch_size_t* _decodeSize,TByte** _out_data){
|
|
|
- hpatch_size_t decodeSize=*_decodeSize;
|
|
|
- TByte* out_data=*_out_data;
|
|
|
- TStreamCacheClip* rleCodeClip=&loader->rleCodeClip;
|
|
|
-
|
|
|
- hpatch_StreamPos_t memSetLength=loader->memSetLength;
|
|
|
- if (memSetLength!=0){
|
|
|
- hpatch_size_t memSetStep=((memSetLength<=decodeSize)?(hpatch_size_t)memSetLength:decodeSize);
|
|
|
- const TByte byteSetValue=loader->memSetValue;
|
|
|
- if (out_data!=0){
|
|
|
- if (byteSetValue!=0)
|
|
|
- memSet_add(out_data,byteSetValue,memSetStep);
|
|
|
- out_data+=memSetStep;
|
|
|
- }
|
|
|
- decodeSize-=memSetStep;
|
|
|
- loader->memSetLength=memSetLength-memSetStep;
|
|
|
- }
|
|
|
- while ((loader->memCopyLength>0)&&(decodeSize>0)) {
|
|
|
- TByte* rleData;
|
|
|
- hpatch_size_t decodeStep=rleCodeClip->cacheEnd;
|
|
|
- if (decodeStep>loader->memCopyLength)
|
|
|
- decodeStep=(hpatch_size_t)loader->memCopyLength;
|
|
|
- if (decodeStep>decodeSize)
|
|
|
- decodeStep=decodeSize;
|
|
|
- rleData=_TStreamCacheClip_readData(rleCodeClip,decodeStep);
|
|
|
- if (rleData==0) return _hpatch_FALSE;
|
|
|
- if (out_data){
|
|
|
- addData(out_data,rleData,decodeStep);
|
|
|
- out_data+=decodeStep;
|
|
|
- }
|
|
|
- decodeSize-=decodeStep;
|
|
|
- loader->memCopyLength-=decodeStep;
|
|
|
- }
|
|
|
- *_decodeSize=decodeSize;
|
|
|
- *_out_data=out_data;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_inline
|
|
|
-static hpatch_BOOL _TBytesRle_load_stream_isFinish(const _TBytesRle_load_stream* loader){
|
|
|
- return(loader->memSetLength==0)
|
|
|
- &&(loader->memCopyLength==0)
|
|
|
- &&(_TStreamCacheClip_isFinish(&loader->rleCodeClip))
|
|
|
- &&(_TStreamCacheClip_isFinish(&loader->ctrlClip));
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-#define _clip_unpackUIntWithTagTo(puint,sclip,kTagBit) \
|
|
|
- { if (!_TStreamCacheClip_unpackUIntWithTag(sclip,puint,kTagBit)) return _hpatch_FALSE; }
|
|
|
-#define _clip_unpackUIntTo(puint,sclip) _clip_unpackUIntWithTagTo(puint,sclip,0)
|
|
|
-
|
|
|
-static hpatch_BOOL _TBytesRle_load_stream_decode_add(_TBytesRle_load_stream* loader,
|
|
|
- TByte* out_data,hpatch_size_t decodeSize){
|
|
|
- if (!_TBytesRle_load_stream_mem_add(loader,&decodeSize,&out_data))
|
|
|
- return _hpatch_FALSE;
|
|
|
-
|
|
|
- while ((decodeSize>0)&&(!_TStreamCacheClip_isFinish(&loader->ctrlClip))){
|
|
|
- enum TByteRleType type;
|
|
|
- hpatch_StreamPos_t length;
|
|
|
- const TByte* pType=_TStreamCacheClip_accessData(&loader->ctrlClip,1);
|
|
|
- if (pType==0) return _hpatch_FALSE;
|
|
|
- type=(enum TByteRleType)((*pType)>>(8-kByteRleType_bit));
|
|
|
- _clip_unpackUIntWithTagTo(&length,&loader->ctrlClip,kByteRleType_bit);
|
|
|
- ++length;
|
|
|
- switch (type){
|
|
|
- case kByteRleType_rle0:{
|
|
|
- loader->memSetLength=length;
|
|
|
- loader->memSetValue=0;
|
|
|
- }break;
|
|
|
- case kByteRleType_rle255:{
|
|
|
- loader->memSetLength=length;
|
|
|
- loader->memSetValue=255;
|
|
|
- }break;
|
|
|
- case kByteRleType_rle:{
|
|
|
- const TByte* pSetValue=_TStreamCacheClip_readData(&loader->rleCodeClip,1);
|
|
|
- if (pSetValue==0) return _hpatch_FALSE;
|
|
|
- loader->memSetValue=*pSetValue;
|
|
|
- loader->memSetLength=length;
|
|
|
- }break;
|
|
|
- case kByteRleType_unrle:{
|
|
|
- loader->memCopyLength=length;
|
|
|
- }break;
|
|
|
- }
|
|
|
- if (!_TBytesRle_load_stream_mem_add(loader,&decodeSize,&out_data)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if (decodeSize==0)
|
|
|
- return hpatch_TRUE;
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-#define _TBytesRle_load_stream_decode_skip(loader,decodeSize) \
|
|
|
- _TBytesRle_load_stream_decode_add(loader,0,decodeSize)
|
|
|
-
|
|
|
-static hpatch_BOOL _patch_add_old_with_rle(_TOutStreamCache* outCache,_TBytesRle_load_stream* rle_loader,
|
|
|
- const hpatch_TStreamInput* old,hpatch_StreamPos_t oldPos,
|
|
|
- hpatch_StreamPos_t addLength,TByte* aCache,hpatch_size_t aCacheSize){
|
|
|
- while (addLength>0){
|
|
|
- hpatch_size_t decodeStep=aCacheSize;
|
|
|
- if (decodeStep>addLength)
|
|
|
- decodeStep=(hpatch_size_t)addLength;
|
|
|
- if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
|
|
|
- if (!_TBytesRle_load_stream_decode_add(rle_loader,aCache,decodeStep)) return _hpatch_FALSE;
|
|
|
- if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
|
|
|
- oldPos+=decodeStep;
|
|
|
- addLength-=decodeStep;
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-typedef struct _TCovers{
|
|
|
- hpatch_TCovers ICovers;
|
|
|
- hpatch_StreamPos_t coverCount;
|
|
|
- hpatch_StreamPos_t oldPosBack;
|
|
|
- hpatch_StreamPos_t newPosBack;
|
|
|
- TStreamCacheClip* code_inc_oldPosClip;
|
|
|
- TStreamCacheClip* code_inc_newPosClip;
|
|
|
- TStreamCacheClip* code_lengthsClip;
|
|
|
- hpatch_BOOL isOldPosBackNeedAddLength;
|
|
|
-} _TCovers;
|
|
|
-
|
|
|
-static hpatch_StreamPos_t _covers_leaveCoverCount(const hpatch_TCovers* covers){
|
|
|
- const _TCovers* self=(const _TCovers*)covers;
|
|
|
- return self->coverCount;
|
|
|
-}
|
|
|
-static hpatch_BOOL _covers_close_nil(hpatch_TCovers* covers){
|
|
|
- //empty
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _covers_read_cover(hpatch_TCovers* covers,hpatch_TCover* out_cover){
|
|
|
- _TCovers* self=(_TCovers*)covers;
|
|
|
- hpatch_StreamPos_t oldPosBack=self->oldPosBack;
|
|
|
- hpatch_StreamPos_t newPosBack=self->newPosBack;
|
|
|
- hpatch_StreamPos_t coverCount=self->coverCount;
|
|
|
- if (coverCount>0)
|
|
|
- self->coverCount=coverCount-1;
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
-
|
|
|
- {
|
|
|
- hpatch_StreamPos_t copyLength,coverLength, oldPos,inc_oldPos;
|
|
|
- TByte inc_oldPos_sign;
|
|
|
- const TByte* pSign=_TStreamCacheClip_accessData(self->code_inc_oldPosClip,1);
|
|
|
- if (pSign)
|
|
|
- inc_oldPos_sign=(*pSign)>>(8-kSignTagBit);
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
- _clip_unpackUIntWithTagTo(&inc_oldPos,self->code_inc_oldPosClip,kSignTagBit);
|
|
|
- oldPos=(inc_oldPos_sign==0)?(oldPosBack+inc_oldPos):(oldPosBack-inc_oldPos);
|
|
|
- _clip_unpackUIntTo(©Length,self->code_inc_newPosClip);
|
|
|
- _clip_unpackUIntTo(&coverLength,self->code_lengthsClip);
|
|
|
- newPosBack+=copyLength;
|
|
|
- oldPosBack=oldPos;
|
|
|
- oldPosBack+=(self->isOldPosBackNeedAddLength)?coverLength:0;
|
|
|
-
|
|
|
- out_cover->oldPos=oldPos;
|
|
|
- out_cover->newPos=newPosBack;
|
|
|
- out_cover->length=coverLength;
|
|
|
- newPosBack+=coverLength;
|
|
|
- }
|
|
|
- self->oldPosBack=oldPosBack;
|
|
|
- self->newPosBack=newPosBack;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _covers_is_finish(const struct hpatch_TCovers* covers){
|
|
|
- _TCovers* self=(_TCovers*)covers;
|
|
|
- return _TStreamCacheClip_isFinish(self->code_lengthsClip)
|
|
|
- && _TStreamCacheClip_isFinish(self->code_inc_newPosClip)
|
|
|
- && _TStreamCacheClip_isFinish(self->code_inc_oldPosClip);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-static void _covers_init(_TCovers* covers,hpatch_StreamPos_t coverCount,
|
|
|
- TStreamCacheClip* code_inc_oldPosClip,
|
|
|
- TStreamCacheClip* code_inc_newPosClip,
|
|
|
- TStreamCacheClip* code_lengthsClip,
|
|
|
- hpatch_BOOL isOldPosBackNeedAddLength){
|
|
|
- covers->ICovers.leave_cover_count=_covers_leaveCoverCount;
|
|
|
- covers->ICovers.read_cover=_covers_read_cover;
|
|
|
- covers->ICovers.is_finish=_covers_is_finish;
|
|
|
- covers->ICovers.close=_covers_close_nil;
|
|
|
- covers->coverCount=coverCount;
|
|
|
- covers->newPosBack=0;
|
|
|
- covers->oldPosBack=0;
|
|
|
- covers->code_inc_oldPosClip=code_inc_oldPosClip;
|
|
|
- covers->code_inc_newPosClip=code_inc_newPosClip;
|
|
|
- covers->code_lengthsClip=code_lengthsClip;
|
|
|
- covers->isOldPosBackNeedAddLength=isOldPosBackNeedAddLength;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _rle_decode_skip(struct _TBytesRle_load_stream* rle_loader,hpatch_StreamPos_t copyLength){
|
|
|
- while (copyLength>0) {
|
|
|
- hpatch_size_t len=(~(hpatch_size_t)0);
|
|
|
- if (len>copyLength)
|
|
|
- len=(hpatch_size_t)copyLength;
|
|
|
- if (!_TBytesRle_load_stream_decode_skip(rle_loader,len)) return _hpatch_FALSE;
|
|
|
- copyLength-=len;
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL patchByClip(_TOutStreamCache* outCache,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- hpatch_TCovers* covers,
|
|
|
- TStreamCacheClip* code_newDataDiffClip,
|
|
|
- struct _TBytesRle_load_stream* rle_loader,
|
|
|
- TByte* temp_cache,hpatch_size_t cache_size){
|
|
|
- const hpatch_StreamPos_t newDataSize=_TOutStreamCache_leaveSize(outCache);
|
|
|
- const hpatch_StreamPos_t oldDataSize=oldData->streamSize;
|
|
|
- hpatch_StreamPos_t coverCount=covers->leave_cover_count(covers);
|
|
|
- hpatch_StreamPos_t newPosBack=0;
|
|
|
- assert(cache_size>=hpatch_kMaxPackedUIntBytes);
|
|
|
-
|
|
|
- while (coverCount--){
|
|
|
- hpatch_TCover cover;
|
|
|
- if(!covers->read_cover(covers,&cover)) return _hpatch_FALSE;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (cover.newPos<newPosBack) return _hpatch_FALSE;
|
|
|
- if (cover.length>(hpatch_StreamPos_t)(newDataSize-cover.newPos)) return _hpatch_FALSE;
|
|
|
- if (cover.oldPos>oldDataSize) return _hpatch_FALSE;
|
|
|
- if (cover.length>(hpatch_StreamPos_t)(oldDataSize-cover.oldPos)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- if (newPosBack<cover.newPos){
|
|
|
- hpatch_StreamPos_t copyLength=cover.newPos-newPosBack;
|
|
|
- if (!_TOutStreamCache_copyFromClip(outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
|
|
|
- if (!_rle_decode_skip(rle_loader,copyLength)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- if (!_patch_add_old_with_rle(outCache,rle_loader,oldData,cover.oldPos,cover.length,
|
|
|
- temp_cache,cache_size)) return _hpatch_FALSE;
|
|
|
- newPosBack=cover.newPos+cover.length;
|
|
|
- }
|
|
|
-
|
|
|
- if (newPosBack<newDataSize){
|
|
|
- hpatch_StreamPos_t copyLength=newDataSize-newPosBack;
|
|
|
- if (!_TOutStreamCache_copyFromClip(outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
|
|
|
- if (!_rle_decode_skip(rle_loader,copyLength)) return _hpatch_FALSE;
|
|
|
- newPosBack=newDataSize;
|
|
|
- }
|
|
|
- if (!_TOutStreamCache_flush(outCache))
|
|
|
- return _hpatch_FALSE;
|
|
|
- if ( _TBytesRle_load_stream_isFinish(rle_loader)
|
|
|
- && covers->is_finish(covers)
|
|
|
- && _TOutStreamCache_isFinish(outCache)
|
|
|
- && _TStreamCacheClip_isFinish(code_newDataDiffClip)
|
|
|
- && (newPosBack==newDataSize) )
|
|
|
- return hpatch_TRUE;
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-#define _kCachePatCount 8
|
|
|
-
|
|
|
-#define _cache_alloc(dst,dst_type,memSize,temp_cache,temp_cache_end){ \
|
|
|
- if ((hpatch_size_t)(temp_cache_end-temp_cache) < \
|
|
|
- sizeof(hpatch_StreamPos_t)+(memSize)) return hpatch_FALSE; \
|
|
|
- (dst)=(dst_type*)_hpatch_align_upper(temp_cache,sizeof(hpatch_StreamPos_t));\
|
|
|
- temp_cache=(TByte*)(dst)+(hpatch_size_t)(memSize); \
|
|
|
-}
|
|
|
-
|
|
|
-typedef struct _TPackedCovers{
|
|
|
- _TCovers base;
|
|
|
- TStreamCacheClip code_inc_oldPosClip;
|
|
|
- TStreamCacheClip code_inc_newPosClip;
|
|
|
- TStreamCacheClip code_lengthsClip;
|
|
|
-} _TPackedCovers;
|
|
|
-
|
|
|
-typedef struct _THDiffHead{
|
|
|
- hpatch_StreamPos_t coverCount;
|
|
|
- hpatch_StreamPos_t lengthSize;
|
|
|
- hpatch_StreamPos_t inc_newPosSize;
|
|
|
- hpatch_StreamPos_t inc_oldPosSize;
|
|
|
- hpatch_StreamPos_t newDataDiffSize;
|
|
|
- hpatch_StreamPos_t headEndPos;
|
|
|
- hpatch_StreamPos_t coverEndPos;
|
|
|
-} _THDiffHead;
|
|
|
-
|
|
|
-static hpatch_BOOL read_diff_head(_THDiffHead* out_diffHead,
|
|
|
- const hpatch_TStreamInput* serializedDiff){
|
|
|
- hpatch_StreamPos_t diffPos0;
|
|
|
- const hpatch_StreamPos_t diffPos_end=serializedDiff->streamSize;
|
|
|
- TByte temp_cache[hpatch_kStreamCacheSize];
|
|
|
- TStreamCacheClip diffHeadClip;
|
|
|
- _TStreamCacheClip_init(&diffHeadClip,serializedDiff,0,diffPos_end,temp_cache,hpatch_kStreamCacheSize);
|
|
|
- _clip_unpackUIntTo(&out_diffHead->coverCount,&diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffHead->lengthSize,&diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffHead->inc_newPosSize,&diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffHead->inc_oldPosSize,&diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffHead->newDataDiffSize,&diffHeadClip);
|
|
|
- diffPos0=(hpatch_StreamPos_t)(_TStreamCacheClip_readPosOfSrcStream(&diffHeadClip));
|
|
|
- out_diffHead->headEndPos=diffPos0;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (out_diffHead->lengthSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- diffPos0+=out_diffHead->lengthSize;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (out_diffHead->inc_newPosSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- diffPos0+=out_diffHead->inc_newPosSize;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (out_diffHead->inc_oldPosSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- diffPos0+=out_diffHead->inc_oldPosSize;
|
|
|
- out_diffHead->coverEndPos=diffPos0;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (out_diffHead->newDataDiffSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _packedCovers_open(_TPackedCovers** out_self,
|
|
|
- _THDiffHead* out_diffHead,
|
|
|
- const hpatch_TStreamInput* serializedDiff,
|
|
|
- TByte* temp_cache,TByte* temp_cache_end){
|
|
|
- hpatch_size_t cacheSize;
|
|
|
- _TPackedCovers* self=0;
|
|
|
- _cache_alloc(self,_TPackedCovers,sizeof(_TPackedCovers),temp_cache,temp_cache_end);
|
|
|
- cacheSize=(temp_cache_end-temp_cache)/3;
|
|
|
- {
|
|
|
- hpatch_StreamPos_t diffPos0;
|
|
|
- if (!read_diff_head(out_diffHead,serializedDiff)) return _hpatch_FALSE;
|
|
|
- diffPos0=out_diffHead->headEndPos;
|
|
|
- _TStreamCacheClip_init(&self->code_lengthsClip,serializedDiff,diffPos0,
|
|
|
- diffPos0+out_diffHead->lengthSize,temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- diffPos0+=out_diffHead->lengthSize;
|
|
|
- _TStreamCacheClip_init(&self->code_inc_newPosClip,serializedDiff,diffPos0,
|
|
|
- diffPos0+out_diffHead->inc_newPosSize,temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- diffPos0+=out_diffHead->inc_newPosSize;
|
|
|
- _TStreamCacheClip_init(&self->code_inc_oldPosClip,serializedDiff,diffPos0,
|
|
|
- diffPos0+out_diffHead->inc_oldPosSize,temp_cache,cacheSize);
|
|
|
- }
|
|
|
-
|
|
|
- _covers_init(&self->base,out_diffHead->coverCount,&self->code_inc_oldPosClip,
|
|
|
- &self->code_inc_newPosClip,&self->code_lengthsClip,hpatch_FALSE);
|
|
|
- *out_self=self;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _patch_stream_with_cache(const hpatch_TStreamOutput* out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* serializedDiff,
|
|
|
- hpatch_TCovers* cached_covers,
|
|
|
- TByte* temp_cache,TByte* temp_cache_end){
|
|
|
- struct _THDiffHead diffHead;
|
|
|
- TStreamCacheClip code_newDataDiffClip;
|
|
|
- struct _TBytesRle_load_stream rle_loader;
|
|
|
- hpatch_TCovers* pcovers=0;
|
|
|
- hpatch_StreamPos_t diffPos0;
|
|
|
- const hpatch_StreamPos_t diffPos_end=serializedDiff->streamSize;
|
|
|
- const hpatch_size_t cacheSize=(temp_cache_end-temp_cache)/(cached_covers?(_kCachePatCount-3):_kCachePatCount);
|
|
|
-
|
|
|
- assert(out_newData!=0);
|
|
|
- assert(out_newData->write!=0);
|
|
|
- assert(oldData!=0);
|
|
|
- assert(oldData->read!=0);
|
|
|
- assert(serializedDiff!=0);
|
|
|
- assert(serializedDiff->read!=0);
|
|
|
-
|
|
|
- //covers
|
|
|
- if (cached_covers==0){
|
|
|
- struct _TPackedCovers* packedCovers;
|
|
|
- if (!_packedCovers_open(&packedCovers,&diffHead,serializedDiff,temp_cache+cacheSize*(_kCachePatCount-3),
|
|
|
- temp_cache_end)) return _hpatch_FALSE;
|
|
|
- pcovers=&packedCovers->base.ICovers; //not need close before return
|
|
|
- }else{
|
|
|
- pcovers=cached_covers;
|
|
|
- if (!read_diff_head(&diffHead,serializedDiff)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- //newDataDiff
|
|
|
- diffPos0=diffHead.coverEndPos;
|
|
|
- _TStreamCacheClip_init(&code_newDataDiffClip,serializedDiff,diffPos0,
|
|
|
- diffPos0+diffHead.newDataDiffSize,temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- diffPos0+=diffHead.newDataDiffSize;
|
|
|
-
|
|
|
- {//rle
|
|
|
- hpatch_StreamPos_t rleCtrlSize;
|
|
|
- hpatch_StreamPos_t rlePos0;
|
|
|
- TStreamCacheClip* rleHeadClip=&rle_loader.ctrlClip;//rename, share address
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (cacheSize<hpatch_kMaxPackedUIntBytes) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- _TStreamCacheClip_init(rleHeadClip,serializedDiff,diffPos0,diffPos_end,
|
|
|
- temp_cache,hpatch_kMaxPackedUIntBytes);
|
|
|
- _clip_unpackUIntTo(&rleCtrlSize,rleHeadClip);
|
|
|
- rlePos0=(hpatch_StreamPos_t)(_TStreamCacheClip_readPosOfSrcStream(rleHeadClip));
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (rleCtrlSize>(hpatch_StreamPos_t)(diffPos_end-rlePos0)) return _hpatch_FALSE;
|
|
|
-#endif
|
|
|
- _TBytesRle_load_stream_init(&rle_loader);
|
|
|
- _TStreamCacheClip_init(&rle_loader.ctrlClip,serializedDiff,rlePos0,rlePos0+rleCtrlSize,
|
|
|
- temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- _TStreamCacheClip_init(&rle_loader.rleCodeClip,serializedDiff,rlePos0+rleCtrlSize,diffPos_end,
|
|
|
- temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- }
|
|
|
- {
|
|
|
- _TOutStreamCache outCache;
|
|
|
- _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- return patchByClip(&outCache,oldData,pcovers,&code_newDataDiffClip,
|
|
|
- &rle_loader,temp_cache,cacheSize);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-hpatch_BOOL read_diffz_head(hpatch_compressedDiffInfo* out_diffInfo,_THDiffzHead* out_head,
|
|
|
- const hpatch_TStreamInput* compressedDiff){
|
|
|
- TStreamCacheClip _diffHeadClip;
|
|
|
- TStreamCacheClip* diffHeadClip=&_diffHeadClip;
|
|
|
- TByte temp_cache[hpatch_kStreamCacheSize];
|
|
|
- _TStreamCacheClip_init(&_diffHeadClip,compressedDiff,0,compressedDiff->streamSize,
|
|
|
- temp_cache,hpatch_kStreamCacheSize);
|
|
|
- {//type
|
|
|
- const char* kVersionType="HDIFF13";
|
|
|
- char* tempType=out_diffInfo->compressType;
|
|
|
- if (!_TStreamCacheClip_readType_end(diffHeadClip,'&',tempType)) return _hpatch_FALSE;
|
|
|
- if (0!=strcmp(tempType,kVersionType)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- {//read compressType
|
|
|
- if (!_TStreamCacheClip_readType_end(diffHeadClip,'\0',
|
|
|
- out_diffInfo->compressType)) return _hpatch_FALSE;
|
|
|
- out_head->typesEndPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
|
|
|
- }
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->newDataSize,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->oldDataSize,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->coverCount,diffHeadClip);
|
|
|
- out_head->compressSizeBeginPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->cover_buf_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->compress_cover_buf_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->rle_ctrlBuf_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->compress_rle_ctrlBuf_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->rle_codeBuf_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->compress_rle_codeBuf_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->newDataDiff_size,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_head->compress_newDataDiff_size,diffHeadClip);
|
|
|
- out_head->headEndPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
|
|
|
-
|
|
|
- out_diffInfo->compressedCount=((out_head->compress_cover_buf_size)?1:0)
|
|
|
- +((out_head->compress_rle_ctrlBuf_size)?1:0)
|
|
|
- +((out_head->compress_rle_codeBuf_size)?1:0)
|
|
|
- +((out_head->compress_newDataDiff_size)?1:0);
|
|
|
- if (out_head->compress_cover_buf_size>0)
|
|
|
- out_head->coverEndPos=out_head->headEndPos+out_head->compress_cover_buf_size;
|
|
|
- else
|
|
|
- out_head->coverEndPos=out_head->headEndPos+out_head->cover_buf_size;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL getCompressedDiffInfo(hpatch_compressedDiffInfo* out_diffInfo,
|
|
|
- const hpatch_TStreamInput* compressedDiff){
|
|
|
- _THDiffzHead head;
|
|
|
- assert(out_diffInfo!=0);
|
|
|
- assert(compressedDiff!=0);
|
|
|
- assert(compressedDiff->read!=0);
|
|
|
- return read_diffz_head(out_diffInfo,&head,compressedDiff);
|
|
|
-}
|
|
|
-
|
|
|
-#define _clear_return(exitValue) { result=exitValue; goto clear; }
|
|
|
-
|
|
|
-#define _kCacheDecCount 6
|
|
|
-
|
|
|
-static
|
|
|
-hpatch_BOOL _patch_decompress_cache(const hpatch_TStreamOutput* out_newData,
|
|
|
- hpatch_TStreamInput* once_in_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* compressedDiff,
|
|
|
- hpatch_TDecompress* decompressPlugin,
|
|
|
- hpatch_TCovers* cached_covers,
|
|
|
- TByte* temp_cache, TByte* temp_cache_end){
|
|
|
- TStreamCacheClip coverClip;
|
|
|
- TStreamCacheClip code_newDataDiffClip;
|
|
|
- struct _TBytesRle_load_stream rle_loader;
|
|
|
- _THDiffzHead head;
|
|
|
- hpatch_compressedDiffInfo diffInfo;
|
|
|
- _TDecompressInputStream decompressers[4];
|
|
|
- hpatch_size_t i;
|
|
|
- hpatch_StreamPos_t coverCount;
|
|
|
- hpatch_BOOL result=hpatch_TRUE;
|
|
|
- hpatch_StreamPos_t diffPos0=0;
|
|
|
- const hpatch_StreamPos_t diffPos_end=compressedDiff->streamSize;
|
|
|
- const hpatch_size_t cacheSize=(temp_cache_end-temp_cache)/(cached_covers?(_kCacheDecCount-1):_kCacheDecCount);
|
|
|
- if (cacheSize<=hpatch_kMaxPluginTypeLength) return _hpatch_FALSE;
|
|
|
- assert(out_newData!=0);
|
|
|
- assert(out_newData->write!=0);
|
|
|
- assert(oldData!=0);
|
|
|
- assert(oldData->read!=0);
|
|
|
- assert(compressedDiff!=0);
|
|
|
- assert(compressedDiff->read!=0);
|
|
|
- {//head
|
|
|
- if (!read_diffz_head(&diffInfo,&head,compressedDiff)) return _hpatch_FALSE;
|
|
|
- if ((diffInfo.oldDataSize!=oldData->streamSize)
|
|
|
- ||(diffInfo.newDataSize!=out_newData->streamSize)) return _hpatch_FALSE;
|
|
|
-
|
|
|
- if ((decompressPlugin==0)&&(diffInfo.compressedCount!=0)) return _hpatch_FALSE;
|
|
|
- if ((decompressPlugin)&&(diffInfo.compressedCount>0))
|
|
|
- if (!decompressPlugin->is_can_open(diffInfo.compressType)) return _hpatch_FALSE;
|
|
|
- diffPos0=head.headEndPos;
|
|
|
- }
|
|
|
-
|
|
|
- for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i)
|
|
|
- decompressers[i].decompressHandle=0;
|
|
|
- _TBytesRle_load_stream_init(&rle_loader);
|
|
|
-
|
|
|
- if (cached_covers){
|
|
|
- diffPos0=head.coverEndPos;
|
|
|
- }else{
|
|
|
- if (!getStreamClip(&coverClip,&decompressers[0],
|
|
|
- head.cover_buf_size,head.compress_cover_buf_size,compressedDiff,&diffPos0,
|
|
|
- decompressPlugin,temp_cache+cacheSize*(_kCacheDecCount-1),cacheSize)) _clear_return(_hpatch_FALSE);
|
|
|
- }
|
|
|
- if (!getStreamClip(&rle_loader.ctrlClip,&decompressers[1],
|
|
|
- head.rle_ctrlBuf_size,head.compress_rle_ctrlBuf_size,compressedDiff,&diffPos0,
|
|
|
- decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- if (!getStreamClip(&rle_loader.rleCodeClip,&decompressers[2],
|
|
|
- head.rle_codeBuf_size,head.compress_rle_codeBuf_size,compressedDiff,&diffPos0,
|
|
|
- decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- if (!getStreamClip(&code_newDataDiffClip,&decompressers[3],
|
|
|
- head.newDataDiff_size,head.compress_newDataDiff_size,compressedDiff,&diffPos0,
|
|
|
- decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
|
|
|
- temp_cache+=cacheSize;
|
|
|
-#ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (diffPos0!=diffPos_end) _clear_return(_hpatch_FALSE);
|
|
|
-#endif
|
|
|
-
|
|
|
- coverCount=head.coverCount;
|
|
|
- {
|
|
|
- _TCovers covers;
|
|
|
- hpatch_TCovers* pcovers=0;
|
|
|
- _TOutStreamCache outCache;
|
|
|
- _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
|
|
|
- temp_cache+=cacheSize;
|
|
|
- if (cached_covers){
|
|
|
- pcovers=cached_covers;
|
|
|
- }else{
|
|
|
- _covers_init(&covers,coverCount,&coverClip,&coverClip,&coverClip,hpatch_TRUE);
|
|
|
- pcovers=&covers.ICovers; //not need close before return
|
|
|
- }
|
|
|
- result=patchByClip(&outCache,oldData,pcovers,&code_newDataDiffClip,&rle_loader,
|
|
|
- temp_cache,cacheSize);
|
|
|
- //if ((pcovers!=cached_covers)&&(!pcovers->close(pcovers))) result=_hpatch_FALSE;
|
|
|
- }
|
|
|
-clear:
|
|
|
- for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i) {
|
|
|
- if (decompressers[i].decompressHandle){
|
|
|
- if (!decompressPlugin->close(decompressPlugin,decompressers[i].decompressHandle))
|
|
|
- result=_hpatch_FALSE;
|
|
|
- decompressers[i].decompressHandle=0;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-hpatch_inline static hpatch_BOOL _cache_load_all(const hpatch_TStreamInput* data,
|
|
|
- TByte* cache,TByte* cache_end){
|
|
|
- assert((hpatch_size_t)(cache_end-cache)==data->streamSize);
|
|
|
- return data->read(data,0,cache,cache_end);
|
|
|
-}
|
|
|
-
|
|
|
-typedef struct _TCompressedCovers{
|
|
|
- _TCovers base;
|
|
|
- TStreamCacheClip coverClip;
|
|
|
- _TDecompressInputStream decompresser;
|
|
|
-} _TCompressedCovers;
|
|
|
-
|
|
|
-static hpatch_BOOL _compressedCovers_close(hpatch_TCovers* covers){
|
|
|
- hpatch_BOOL result=hpatch_TRUE;
|
|
|
- _TCompressedCovers* self=(_TCompressedCovers*)covers;
|
|
|
- if (self){
|
|
|
- if (self->decompresser.decompressHandle){
|
|
|
- result=self->decompresser.decompressPlugin->close(self->decompresser.decompressPlugin,
|
|
|
- self->decompresser.decompressHandle);
|
|
|
- self->decompresser.decompressHandle=0;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _compressedCovers_open(_TCompressedCovers** out_self,
|
|
|
- hpatch_compressedDiffInfo* out_diffInfo,
|
|
|
- const hpatch_TStreamInput* compressedDiff,
|
|
|
- hpatch_TDecompress* decompressPlugin,
|
|
|
- TByte* temp_cache,TByte* temp_cache_end){
|
|
|
- _THDiffzHead head;
|
|
|
- hpatch_StreamPos_t diffPos0=0;
|
|
|
- _TCompressedCovers* self=0;
|
|
|
- _cache_alloc(self,_TCompressedCovers,sizeof(_TCompressedCovers),temp_cache,temp_cache_end);
|
|
|
- if (!read_diffz_head(out_diffInfo,&head,compressedDiff)) return _hpatch_FALSE;
|
|
|
- diffPos0=head.headEndPos;
|
|
|
- if (head.compress_cover_buf_size>0){
|
|
|
- if (decompressPlugin==0) return _hpatch_FALSE;
|
|
|
- if (!decompressPlugin->is_can_open(out_diffInfo->compressType)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- _covers_init(&self->base,head.coverCount,&self->coverClip,
|
|
|
- &self->coverClip,&self->coverClip,hpatch_TRUE);
|
|
|
- self->base.ICovers.close=_compressedCovers_close;
|
|
|
- memset(&self->decompresser,0, sizeof(self->decompresser));
|
|
|
- if (!getStreamClip(&self->coverClip,&self->decompresser,
|
|
|
- head.cover_buf_size,head.compress_cover_buf_size,
|
|
|
- compressedDiff,&diffPos0,decompressPlugin,
|
|
|
- temp_cache,temp_cache_end-temp_cache)) {
|
|
|
- return _hpatch_FALSE;
|
|
|
- };
|
|
|
- *out_self=self;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
|
|
|
-
|
|
|
-typedef struct _TArrayCovers{
|
|
|
- hpatch_TCovers ICovers;
|
|
|
- void* pCCovers;
|
|
|
- hpatch_size_t coverCount;
|
|
|
- hpatch_size_t cur_index;
|
|
|
- hpatch_BOOL is32;
|
|
|
-} _TArrayCovers;
|
|
|
-
|
|
|
-
|
|
|
-typedef struct hpatch_TCCover32{
|
|
|
- hpatch_uint32_t oldPos;
|
|
|
- hpatch_uint32_t newPos;
|
|
|
- hpatch_uint32_t length;
|
|
|
- hpatch_uint32_t cachePos; //todo:放到临时内存中,用完释放?逻辑会比较复杂;
|
|
|
-} hpatch_TCCover32;
|
|
|
-
|
|
|
-typedef struct hpatch_TCCover64{
|
|
|
- hpatch_StreamPos_t oldPos;
|
|
|
- hpatch_StreamPos_t newPos;
|
|
|
- hpatch_StreamPos_t length;
|
|
|
- hpatch_StreamPos_t cachePos;
|
|
|
-} hpatch_TCCover64;
|
|
|
-
|
|
|
-#define _arrayCovers_get(self,i,item) (((self)->is32)? \
|
|
|
- ((const hpatch_uint32_t*)(self)->pCCovers)[(i)*4+(item)]:\
|
|
|
- ((const hpatch_StreamPos_t*)(self)->pCCovers)[(i)*4+(item)])
|
|
|
-#define _arrayCovers_get_oldPos(self,i) _arrayCovers_get(self,i,0)
|
|
|
-#define _arrayCovers_get_len(self,i) _arrayCovers_get(self,i,2)
|
|
|
-#define _arrayCovers_get_cachePos(self,i) _arrayCovers_get(self,i,3)
|
|
|
-
|
|
|
-#define _arrayCovers_set(self,i,item,v) { if ((self)->is32){ \
|
|
|
- ((hpatch_uint32_t*)(self)->pCCovers)[(i)*4+(item)]=(hpatch_uint32_t)(v); }else{ \
|
|
|
- ((hpatch_StreamPos_t*)(self)->pCCovers)[(i)*4+(item)]=(v); } }
|
|
|
-#define _arrayCovers_set_cachePos(self,i,v) _arrayCovers_set(self,i,3,v)
|
|
|
-
|
|
|
-hpatch_inline static hpatch_StreamPos_t arrayCovers_memSize(hpatch_StreamPos_t coverCount,hpatch_BOOL is32){
|
|
|
- return coverCount*(is32?sizeof(hpatch_TCCover32):sizeof(hpatch_TCCover64));
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _arrayCovers_is_finish(const hpatch_TCovers* covers){
|
|
|
- const _TArrayCovers* self=(const _TArrayCovers*)covers;
|
|
|
- return (self->coverCount==self->cur_index);
|
|
|
-}
|
|
|
-static hpatch_StreamPos_t _arrayCovers_leaveCoverCount(const hpatch_TCovers* covers){
|
|
|
- const _TArrayCovers* self=(const _TArrayCovers*)covers;
|
|
|
- return self->coverCount-self->cur_index;
|
|
|
-}
|
|
|
-static hpatch_BOOL _arrayCovers_read_cover(struct hpatch_TCovers* covers,hpatch_TCover* out_cover){
|
|
|
- _TArrayCovers* self=(_TArrayCovers*)covers;
|
|
|
- hpatch_size_t i=self->cur_index;
|
|
|
- if (i<self->coverCount){
|
|
|
- if (self->is32){
|
|
|
- const hpatch_TCCover32* pCover=((const hpatch_TCCover32*)self->pCCovers)+i;
|
|
|
- out_cover->oldPos=pCover->oldPos;
|
|
|
- out_cover->newPos=pCover->newPos;
|
|
|
- out_cover->length=pCover->length;
|
|
|
- }else{
|
|
|
- const hpatch_TCCover64* pCover=((const hpatch_TCCover64*)self->pCCovers)+i;
|
|
|
- out_cover->oldPos=pCover->oldPos;
|
|
|
- out_cover->newPos=pCover->newPos;
|
|
|
- out_cover->length=pCover->length;
|
|
|
- }
|
|
|
- self->cur_index=i+1;
|
|
|
- return hpatch_TRUE;
|
|
|
- }else{
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _arrayCovers_load(_TArrayCovers** out_self,hpatch_TCovers* src_covers,
|
|
|
- hpatch_BOOL isUsedCover32,hpatch_BOOL* out_isReadError,
|
|
|
- TByte** ptemp_cache,TByte* temp_cache_end){
|
|
|
- TByte* temp_cache=*ptemp_cache;
|
|
|
- hpatch_StreamPos_t _coverCount=src_covers->leave_cover_count(src_covers);
|
|
|
- hpatch_StreamPos_t memSize=arrayCovers_memSize(_coverCount,isUsedCover32);
|
|
|
- hpatch_size_t i;
|
|
|
- void* pCovers;
|
|
|
- _TArrayCovers* self=0;
|
|
|
- hpatch_size_t coverCount=(hpatch_size_t)_coverCount;
|
|
|
-
|
|
|
- *out_isReadError=hpatch_FALSE;
|
|
|
- if (coverCount!=_coverCount) return hpatch_FALSE;
|
|
|
-
|
|
|
- _cache_alloc(self,_TArrayCovers,sizeof(_TArrayCovers),temp_cache,temp_cache_end);
|
|
|
- _cache_alloc(pCovers,void,memSize,temp_cache,temp_cache_end);
|
|
|
- if (isUsedCover32){
|
|
|
- hpatch_TCCover32* pdst=(hpatch_TCCover32*)pCovers;
|
|
|
- for (i=0;i<coverCount;++i,++pdst) {
|
|
|
- hpatch_TCover cover;
|
|
|
- if (!src_covers->read_cover(src_covers,&cover))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
- pdst->oldPos=(hpatch_uint32_t)cover.oldPos;
|
|
|
- pdst->newPos=(hpatch_uint32_t)cover.newPos;
|
|
|
- pdst->length=(hpatch_uint32_t)cover.length;
|
|
|
- }
|
|
|
- }else{
|
|
|
- hpatch_TCCover64* pdst=(hpatch_TCCover64*)pCovers;
|
|
|
- for (i=0;i<coverCount;++i,++pdst) {
|
|
|
- if (!src_covers->read_cover(src_covers,(hpatch_TCover*)pdst))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!src_covers->is_finish(src_covers))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
-
|
|
|
- self->pCCovers=pCovers;
|
|
|
- self->is32=isUsedCover32;
|
|
|
- self->coverCount=coverCount;
|
|
|
- self->cur_index=0;
|
|
|
- self->ICovers.close=_covers_close_nil;
|
|
|
- self->ICovers.is_finish=_arrayCovers_is_finish;
|
|
|
- self->ICovers.leave_cover_count=_arrayCovers_leaveCoverCount;
|
|
|
- self->ICovers.read_cover=_arrayCovers_read_cover;
|
|
|
- *out_self=self;
|
|
|
- *ptemp_cache=temp_cache;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-#define _arrayCovers_comp(_uint_t,_x,_y,item){ \
|
|
|
- _uint_t x=((const _uint_t*)_x)[item]; \
|
|
|
- _uint_t y=((const _uint_t*)_y)[item]; \
|
|
|
- return (x<y)?(-1):((x>y)?1:0); \
|
|
|
-}
|
|
|
-#ifdef _MSC_VER
|
|
|
-# define __CALL_BACK_C __cdecl
|
|
|
-#else
|
|
|
-# define __CALL_BACK_C
|
|
|
-#endif
|
|
|
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_old_32(const void* _x, const void *_y){
|
|
|
- _arrayCovers_comp(hpatch_uint32_t,_x,_y,0);
|
|
|
-}
|
|
|
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_old(const void* _x, const void *_y){
|
|
|
- _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,0);
|
|
|
-}
|
|
|
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_new_32(const void* _x, const void *_y){
|
|
|
- _arrayCovers_comp(hpatch_uint32_t,_x,_y,1);
|
|
|
-}
|
|
|
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_new(const void* _x, const void *_y){
|
|
|
- _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,1);
|
|
|
-}
|
|
|
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_len_32(const void* _x, const void *_y){
|
|
|
- _arrayCovers_comp(hpatch_uint32_t,_x,_y,2);
|
|
|
-}
|
|
|
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_len(const void* _x, const void *_y){
|
|
|
- _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,2);
|
|
|
-}
|
|
|
-
|
|
|
-static void _arrayCovers_sort_by_old(_TArrayCovers* self){
|
|
|
- if (self->is32)
|
|
|
- qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_old_32);
|
|
|
- else
|
|
|
- qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_old);
|
|
|
-}
|
|
|
-static void _arrayCovers_sort_by_new(_TArrayCovers* self){
|
|
|
- if (self->is32)
|
|
|
- qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_new_32);
|
|
|
- else
|
|
|
- qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_new);
|
|
|
-}
|
|
|
-static void _arrayCovers_sort_by_len(_TArrayCovers* self){
|
|
|
- if (self->is32)
|
|
|
- qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_len_32);
|
|
|
- else
|
|
|
- qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_len);
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_size_t _getMaxCachedLen(const _TArrayCovers* src_covers,
|
|
|
- TByte* temp_cache,TByte* temp_cache_end,TByte* cache_buf_end){
|
|
|
- const hpatch_size_t kMaxCachedLen =~((hpatch_size_t)0);//允许缓存的最长单个数据长度;
|
|
|
- hpatch_StreamPos_t mlen=0;
|
|
|
- hpatch_StreamPos_t sum=0;
|
|
|
- const hpatch_size_t coverCount=src_covers->coverCount;
|
|
|
- hpatch_size_t i;
|
|
|
- _TArrayCovers cur_covers=*src_covers;
|
|
|
- hpatch_size_t cacheSize=temp_cache_end-temp_cache;
|
|
|
- hpatch_StreamPos_t memSize=arrayCovers_memSize(src_covers->coverCount,src_covers->is32);
|
|
|
- _cache_alloc(cur_covers.pCCovers,void,memSize,temp_cache,temp_cache_end); //fail return 0
|
|
|
- memcpy(cur_covers.pCCovers,src_covers->pCCovers,(hpatch_size_t)memSize);
|
|
|
- _arrayCovers_sort_by_len(&cur_covers);
|
|
|
-
|
|
|
- for (i=0; i<coverCount;++i) {
|
|
|
- mlen=_arrayCovers_get_len(&cur_covers,i);
|
|
|
- sum+=mlen;
|
|
|
- if (sum<=cacheSize){
|
|
|
- continue;
|
|
|
- }else{
|
|
|
- --mlen;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (mlen>kMaxCachedLen)
|
|
|
- mlen=kMaxCachedLen;
|
|
|
- return (hpatch_size_t)mlen;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_size_t _set_cache_pos(_TArrayCovers* covers,hpatch_size_t maxCachedLen,
|
|
|
- hpatch_StreamPos_t* poldPosBegin,hpatch_StreamPos_t* poldPosEnd){
|
|
|
- const hpatch_size_t coverCount=covers->coverCount;
|
|
|
- const hpatch_size_t kMinCacheCoverCount=coverCount/8+1; //控制最小缓存数量,否则缓存的意义太小;
|
|
|
- hpatch_StreamPos_t oldPosBegin=hpatch_kNullStreamPos;
|
|
|
- hpatch_StreamPos_t oldPosEnd=0;
|
|
|
- hpatch_size_t cacheCoverCount=0;
|
|
|
- hpatch_size_t sum=0;//result
|
|
|
- hpatch_size_t i;
|
|
|
- for (i=0; i<coverCount;++i) {
|
|
|
- hpatch_StreamPos_t clen=_arrayCovers_get_len(covers,i);
|
|
|
- if (clen<=maxCachedLen){
|
|
|
- hpatch_StreamPos_t oldPos;
|
|
|
- _arrayCovers_set_cachePos(covers,i,sum);
|
|
|
- sum+=(hpatch_size_t)clen;
|
|
|
- ++cacheCoverCount;
|
|
|
-
|
|
|
- oldPos=_arrayCovers_get_oldPos(covers,i);
|
|
|
- if (oldPos<oldPosBegin) oldPosBegin=oldPos;
|
|
|
- if (oldPos+clen>oldPosEnd) oldPosEnd=oldPos+clen;
|
|
|
- }
|
|
|
- }
|
|
|
- if (cacheCoverCount<kMinCacheCoverCount)
|
|
|
- return 0;//fail
|
|
|
- *poldPosBegin=oldPosBegin;
|
|
|
- *poldPosEnd=oldPosEnd;
|
|
|
- return sum;
|
|
|
-}
|
|
|
-
|
|
|
-//一个比较简单的缓存策略:
|
|
|
-// 1. 根据缓冲区大小限制，选择出最短的一批覆盖线来缓存;
|
|
|
-// 2. 顺序访问一次oldData文件，填充这些缓存;
|
|
|
-// 3. 顺序访问时跳过中间过大的对缓存无用的区域;
|
|
|
-
|
|
|
-static hpatch_BOOL _cache_old_load(const hpatch_TStreamInput*oldData,
|
|
|
- hpatch_StreamPos_t oldPos,hpatch_StreamPos_t oldPosAllEnd,
|
|
|
- _TArrayCovers* arrayCovers,hpatch_size_t maxCachedLen,hpatch_size_t sumCacheLen,
|
|
|
- TByte* old_cache,TByte* old_cache_end,TByte* cache_buf_end){
|
|
|
- const hpatch_size_t kMinSpaceLen =(1<<(20+2));//跳过seekTime*speed长度的空间(SSD可以更小)时间上划得来,否则就顺序访问;
|
|
|
- const hpatch_size_t kAccessPageSize=(1<<(10+2));//页面对齐访问;
|
|
|
- hpatch_BOOL result=hpatch_TRUE;
|
|
|
- hpatch_size_t cur_i=0,i;
|
|
|
- const hpatch_size_t coverCount=arrayCovers->coverCount;
|
|
|
- TByte* cache_buf=old_cache_end;
|
|
|
- assert((hpatch_size_t)(old_cache_end-old_cache)>=sumCacheLen);
|
|
|
-
|
|
|
- if ((hpatch_size_t)(cache_buf_end-cache_buf)>=kAccessPageSize*2){
|
|
|
- cache_buf=(TByte*)_hpatch_align_upper(cache_buf,kAccessPageSize);
|
|
|
- if ((hpatch_size_t)(cache_buf_end-cache_buf)>=(kMinSpaceLen>>1))
|
|
|
- cache_buf_end=cache_buf+(kMinSpaceLen>>1);
|
|
|
- else
|
|
|
- cache_buf_end=(TByte*)_hpatch_align_lower(cache_buf_end,kAccessPageSize);
|
|
|
- }
|
|
|
- oldPos=_hpatch_align_type_lower(hpatch_StreamPos_t,oldPos,kAccessPageSize);
|
|
|
- if (oldPos<kMinSpaceLen) oldPos=0;
|
|
|
-
|
|
|
- _arrayCovers_sort_by_old(arrayCovers);
|
|
|
- while ((oldPos<oldPosAllEnd)&(cur_i<coverCount)) {
|
|
|
- hpatch_StreamPos_t oldPosEnd;
|
|
|
- hpatch_size_t readLen=(cache_buf_end-cache_buf);
|
|
|
- if (readLen>(oldPosAllEnd-oldPos)) readLen=(hpatch_size_t)(oldPosAllEnd-oldPos);
|
|
|
- if (!oldData->read(oldData,oldPos,cache_buf,
|
|
|
- cache_buf+readLen)) { result=_hpatch_FALSE; break; } //error
|
|
|
- oldPosEnd=oldPos+readLen;
|
|
|
- for (i=cur_i;i<coverCount;++i){
|
|
|
- hpatch_StreamPos_t ioldPos,ioldPosEnd;
|
|
|
- hpatch_StreamPos_t ilen=_arrayCovers_get_len(arrayCovers,i);
|
|
|
- if (ilen>maxCachedLen){//覆盖线比较长不需要缓存,下一个覆盖线;
|
|
|
- if (i==cur_i)
|
|
|
- ++cur_i;
|
|
|
- continue;
|
|
|
- }
|
|
|
- ioldPos=_arrayCovers_get_oldPos(arrayCovers,i);
|
|
|
- ioldPosEnd=ioldPos+ilen;
|
|
|
- if (ioldPosEnd>oldPos){
|
|
|
- // [oldPos oldPosEnd]
|
|
|
- // ioldPosEnd]----or----]
|
|
|
- if (ioldPos<oldPosEnd){//有交集,需要cache
|
|
|
- // [----or----[ioldPos ioldPosEnd]----or----]
|
|
|
- hpatch_StreamPos_t from;
|
|
|
- hpatch_size_t copyLen;
|
|
|
- hpatch_StreamPos_t dstPos=_arrayCovers_get_cachePos(arrayCovers,i);
|
|
|
- //assert(dstPos<=(hpatch_size_t)(old_cache_end-old_cache));
|
|
|
- if (ioldPos>=oldPos){
|
|
|
- // [ioldPos ioldPosEnd]----or----]
|
|
|
- from=ioldPos;
|
|
|
- }else{
|
|
|
- // [ioldPos ioldPosEnd]----or----]
|
|
|
- from=oldPos;
|
|
|
- dstPos+=(oldPos-ioldPos);
|
|
|
- }
|
|
|
- copyLen=(hpatch_size_t)(((ioldPosEnd<=oldPosEnd)?ioldPosEnd:oldPosEnd)-from);
|
|
|
- //assert(dstPos+copyLen<=(hpatch_size_t)(old_cache_end-old_cache));
|
|
|
- //assert(sumCacheLen>=copyLen);
|
|
|
- memcpy(old_cache+(hpatch_size_t)dstPos,cache_buf+(from-oldPos),copyLen);
|
|
|
- sumCacheLen-=copyLen;
|
|
|
- if ((i==cur_i)&(oldPosEnd>=ioldPosEnd))
|
|
|
- ++cur_i;
|
|
|
- }else{//后面覆盖线暂时都不会与当前数据有交集了,下一块数据;
|
|
|
- // [oldPos oldPosEnd]
|
|
|
- // [ioldPos ioldPosEnd]
|
|
|
- if ((i==cur_i)&&(ioldPos-oldPosEnd>=kMinSpaceLen))
|
|
|
- oldPosEnd=_hpatch_align_type_lower(hpatch_StreamPos_t,ioldPos,kAccessPageSize);
|
|
|
- break;
|
|
|
- }
|
|
|
- }else{//当前覆盖线已经落后于当前数据,下一个覆盖线;
|
|
|
- // [oldPos oldPosEnd]
|
|
|
- // [ioldPos ioldPosEnd]
|
|
|
- if (i==cur_i)
|
|
|
- ++cur_i;
|
|
|
- }
|
|
|
- }
|
|
|
- oldPos=oldPosEnd;
|
|
|
- }
|
|
|
- _arrayCovers_sort_by_new(arrayCovers);
|
|
|
- assert(sumCacheLen==0);
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-typedef struct _cache_old_TStreamInput{
|
|
|
- _TArrayCovers arrayCovers;
|
|
|
- hpatch_BOOL isInHitCache;
|
|
|
- hpatch_size_t maxCachedLen;
|
|
|
- hpatch_StreamPos_t readFromPos;
|
|
|
- hpatch_StreamPos_t readFromPosEnd;
|
|
|
- const TByte* caches;
|
|
|
- const TByte* cachesEnd;
|
|
|
- const hpatch_TStreamInput* oldData;
|
|
|
-} _cache_old_TStreamInput;
|
|
|
-
|
|
|
-static hpatch_BOOL _cache_old_StreamInput_read(const hpatch_TStreamInput* stream,
|
|
|
- hpatch_StreamPos_t readFromPos,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end){
|
|
|
- _cache_old_TStreamInput* self=(_cache_old_TStreamInput*)stream->streamImport;
|
|
|
- hpatch_StreamPos_t dataLen=(hpatch_size_t)(self->readFromPosEnd-self->readFromPos);
|
|
|
- hpatch_size_t readLen;
|
|
|
- if (dataLen==0){//next cover
|
|
|
- hpatch_StreamPos_t oldPos;
|
|
|
- hpatch_size_t i=self->arrayCovers.cur_index++;
|
|
|
- if (i>=self->arrayCovers.coverCount) return _hpatch_FALSE;//error;
|
|
|
- oldPos=_arrayCovers_get_oldPos(&self->arrayCovers,i);
|
|
|
- dataLen=_arrayCovers_get_len(&self->arrayCovers,i);
|
|
|
- self->isInHitCache=(dataLen<=self->maxCachedLen);
|
|
|
- self->readFromPos=oldPos;
|
|
|
- self->readFromPosEnd=oldPos+dataLen;
|
|
|
- }
|
|
|
- readLen=out_data_end-out_data;
|
|
|
- if ((readLen>dataLen)||(self->readFromPos!=readFromPos)) return _hpatch_FALSE; //error
|
|
|
- self->readFromPos=readFromPos+readLen;
|
|
|
- if (self->isInHitCache){
|
|
|
- assert(readLen<=(hpatch_size_t)(self->cachesEnd-self->caches));
|
|
|
- memcpy(out_data,self->caches,readLen);
|
|
|
- self->caches+=readLen;
|
|
|
- return hpatch_TRUE;
|
|
|
- }else{
|
|
|
- return self->oldData->read(self->oldData,readFromPos,out_data,out_data_end);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _cache_old(hpatch_TStreamInput** out_cachedOld,const hpatch_TStreamInput* oldData,
|
|
|
- _TArrayCovers* arrayCovers,hpatch_BOOL* out_isReadError,
|
|
|
- TByte* temp_cache,TByte** ptemp_cache_end,TByte* cache_buf_end){
|
|
|
- _cache_old_TStreamInput* self;
|
|
|
- TByte* temp_cache_end=*ptemp_cache_end;
|
|
|
- hpatch_StreamPos_t oldPosBegin;
|
|
|
- hpatch_StreamPos_t oldPosEnd;
|
|
|
- hpatch_size_t sumCacheLen;
|
|
|
- hpatch_size_t maxCachedLen;
|
|
|
- *out_isReadError=hpatch_FALSE;
|
|
|
- _cache_alloc(*out_cachedOld,hpatch_TStreamInput,sizeof(hpatch_TStreamInput),
|
|
|
- temp_cache,temp_cache_end);
|
|
|
- _cache_alloc(self,_cache_old_TStreamInput,sizeof(_cache_old_TStreamInput),
|
|
|
- temp_cache,temp_cache_end);
|
|
|
-
|
|
|
- maxCachedLen=_getMaxCachedLen(arrayCovers,temp_cache,temp_cache_end,cache_buf_end);
|
|
|
- if (maxCachedLen==0) return hpatch_FALSE;
|
|
|
- sumCacheLen=_set_cache_pos(arrayCovers,maxCachedLen,&oldPosBegin,&oldPosEnd);
|
|
|
- if (sumCacheLen==0) return hpatch_FALSE;
|
|
|
- temp_cache_end=temp_cache+sumCacheLen;
|
|
|
-
|
|
|
- if (!_cache_old_load(oldData,oldPosBegin,oldPosEnd,arrayCovers,maxCachedLen,sumCacheLen,
|
|
|
- temp_cache,temp_cache_end,cache_buf_end))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
-
|
|
|
- {//out
|
|
|
- self->arrayCovers=*arrayCovers;
|
|
|
- self->arrayCovers.cur_index=0;
|
|
|
- self->isInHitCache=hpatch_FALSE;
|
|
|
- self->maxCachedLen=maxCachedLen;
|
|
|
- self->caches=temp_cache;
|
|
|
- self->cachesEnd=temp_cache_end;
|
|
|
- self->readFromPos=0;
|
|
|
- self->readFromPosEnd=0;
|
|
|
- self->oldData=oldData;
|
|
|
- (*out_cachedOld)->streamImport=self;
|
|
|
- (*out_cachedOld)->streamSize=oldData->streamSize;
|
|
|
- (*out_cachedOld)->read=_cache_old_StreamInput_read;
|
|
|
- *ptemp_cache_end=temp_cache_end;
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-#endif //_IS_NEED_CACHE_OLD_BY_COVERS
|
|
|
-
|
|
|
-
|
|
|
-static hpatch_BOOL _patch_cache(hpatch_TCovers** out_covers,
|
|
|
- const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,
|
|
|
- const hpatch_TStreamInput* diffData,hpatch_BOOL isCompressedDiff,
|
|
|
- hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
|
|
|
- TByte** ptemp_cache,TByte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
|
|
|
- const hpatch_TStreamInput* oldData=*poldData;
|
|
|
- const hpatch_size_t kMinCacheSize=hpatch_kStreamCacheSize*kCacheCount;
|
|
|
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
|
|
|
- const hpatch_size_t kBestACacheSize=hpatch_kFileIOBufBetterSize; //内存足够时比较好的hpatch_kStreamCacheSize值;
|
|
|
- const hpatch_size_t _minActiveSize=(1<<20)*8;
|
|
|
- const hpatch_StreamPos_t _betterActiveSize=kBestACacheSize*kCacheCount*2+oldData->streamSize/8;
|
|
|
- const hpatch_size_t kActiveCacheOldMemorySize = //尝试激活CacheOld功能的内存下限;
|
|
|
- (_betterActiveSize>_minActiveSize)?_minActiveSize:(hpatch_size_t)_betterActiveSize;
|
|
|
-#endif //_IS_NEED_CACHE_OLD_BY_COVERS
|
|
|
- TByte* temp_cache=*ptemp_cache;
|
|
|
- TByte* temp_cache_end=*ptemp_cache_end;
|
|
|
- *out_isReadError=hpatch_FALSE;
|
|
|
- if ((hpatch_size_t)(temp_cache_end-temp_cache)>=oldData->streamSize+kMinCacheSize
|
|
|
- +sizeof(hpatch_TStreamInput)+sizeof(hpatch_StreamPos_t)){//load all oldData
|
|
|
- hpatch_TStreamInput* replace_oldData=0;
|
|
|
- _cache_alloc(replace_oldData,hpatch_TStreamInput,sizeof(hpatch_TStreamInput),
|
|
|
- temp_cache,temp_cache_end);
|
|
|
- if (!_cache_load_all(oldData,temp_cache_end-oldData->streamSize,
|
|
|
- temp_cache_end)){ *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
-
|
|
|
- mem_as_hStreamInput(replace_oldData,temp_cache_end-oldData->streamSize,temp_cache_end);
|
|
|
- temp_cache_end-=oldData->streamSize;
|
|
|
- // [ patch cache | oldData cache ]
|
|
|
- // [ (cacheSize-oldData->streamSize) | (oldData->streamSize) ]
|
|
|
- *out_covers=0;
|
|
|
- *poldData=replace_oldData;
|
|
|
- *ptemp_cache=temp_cache;
|
|
|
- *ptemp_cache_end=temp_cache_end;
|
|
|
- return hpatch_TRUE;
|
|
|
- }
|
|
|
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
|
|
|
- else if ((hpatch_size_t)(temp_cache_end-temp_cache)>=kActiveCacheOldMemorySize) {
|
|
|
- hpatch_BOOL isUsedCover32;
|
|
|
- TByte* temp_cache_end_back=temp_cache_end;
|
|
|
- _TArrayCovers* arrayCovers=0;
|
|
|
- assert((hpatch_size_t)(temp_cache_end-temp_cache)>kBestACacheSize*kCacheCount);
|
|
|
- assert(kBestACacheSize>sizeof(_TCompressedCovers)+sizeof(_TPackedCovers));
|
|
|
- if (isCompressedDiff){
|
|
|
- hpatch_compressedDiffInfo diffInfo;
|
|
|
- _TCompressedCovers* compressedCovers=0;
|
|
|
- if (!_compressedCovers_open(&compressedCovers,&diffInfo,diffData,decompressPlugin,
|
|
|
- temp_cache_end-kBestACacheSize-sizeof(_TCompressedCovers),temp_cache_end))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
- if ((oldData->streamSize!=diffInfo.oldDataSize)||(newDataSize!=diffInfo.newDataSize))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
- temp_cache_end-=kBestACacheSize+sizeof(_TCompressedCovers);
|
|
|
- // [ ... | compressedCovers cache ]
|
|
|
- // [ (cacheSize-kBestACacheSize) | (kBestACacheSize) ]
|
|
|
- *out_covers=&compressedCovers->base.ICovers;
|
|
|
- isUsedCover32=(diffInfo.oldDataSize|diffInfo.newDataSize)<((hpatch_StreamPos_t)1<<32);
|
|
|
- }else{
|
|
|
- _TPackedCovers* packedCovers=0;
|
|
|
- _THDiffHead diffHead;
|
|
|
- hpatch_StreamPos_t oldDataSize=oldData->streamSize;
|
|
|
- if (!_packedCovers_open(&packedCovers,&diffHead,diffData,
|
|
|
- temp_cache_end-kBestACacheSize*3-sizeof(_TPackedCovers),temp_cache_end))
|
|
|
- { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
|
|
|
- temp_cache_end-=kBestACacheSize*3+sizeof(_TPackedCovers);
|
|
|
- // [ ... | packedCovers cache ]
|
|
|
- // [ (cacheSize-kBestACacheSize*3) | (kBestACacheSize*3) ]
|
|
|
- *out_covers=&packedCovers->base.ICovers;
|
|
|
- isUsedCover32=(oldDataSize|newDataSize)<((hpatch_StreamPos_t)1<<32);
|
|
|
- }
|
|
|
-
|
|
|
- if (!_arrayCovers_load(&arrayCovers,*out_covers,isUsedCover32,
|
|
|
- out_isReadError,&temp_cache,temp_cache_end-kBestACacheSize)){
|
|
|
- if (*out_isReadError) return _hpatch_FALSE;
|
|
|
- // [ patch cache | *edCovers cache ]
|
|
|
- // [ (cacheSize-kBestACacheSize*?) | (kBestACacheSize*?) ]
|
|
|
- *ptemp_cache=temp_cache;
|
|
|
- *ptemp_cache_end=temp_cache_end;
|
|
|
- return hpatch_FALSE;
|
|
|
- }else{
|
|
|
- // [ arrayCovers cache | ... ]
|
|
|
- // [((new temp_cache)-(old temp_cache))| (cacheSize-(arrayCovers cache size)) ]
|
|
|
- TByte* old_cache_end;
|
|
|
- hpatch_TStreamInput* replace_oldData=0;
|
|
|
- assert(!(*out_isReadError));
|
|
|
- if (!((*out_covers)->close(*out_covers))) return _hpatch_FALSE;
|
|
|
- *out_covers=&arrayCovers->ICovers;
|
|
|
- temp_cache_end=temp_cache_end_back; //free compressedCovers or packedCovers memory
|
|
|
- old_cache_end=temp_cache_end-kBestACacheSize*kCacheCount;
|
|
|
- // [ arrayCovers cache | ... | patch reserve cache ]
|
|
|
- // [ | ... | (kBestACacheSize*kCacheCount) ]
|
|
|
- if (((hpatch_size_t)(temp_cache_end-temp_cache)<=kBestACacheSize*kCacheCount)
|
|
|
- ||(!_cache_old(&replace_oldData,oldData,arrayCovers,out_isReadError,
|
|
|
- temp_cache,&old_cache_end,temp_cache_end))){
|
|
|
- if (*out_isReadError) return _hpatch_FALSE;
|
|
|
- // [ arrayCovers cache | patch cache ]
|
|
|
- *ptemp_cache=temp_cache;
|
|
|
- *ptemp_cache_end=temp_cache_end;
|
|
|
- return hpatch_FALSE;
|
|
|
- }else{
|
|
|
- // [ arrayCovers cache | oldData cache | patch cache ]
|
|
|
- // [ | |(temp_cache_end-(new old_cache_end))]
|
|
|
- assert(!(*out_isReadError));
|
|
|
- assert((hpatch_size_t)(temp_cache_end-old_cache_end)>=kBestACacheSize*kCacheCount);
|
|
|
- temp_cache=old_cache_end;
|
|
|
-
|
|
|
- *poldData=replace_oldData;
|
|
|
- *ptemp_cache=temp_cache;
|
|
|
- *ptemp_cache_end=temp_cache_end;
|
|
|
- return hpatch_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-#endif//_IS_NEED_CACHE_OLD_BY_COVERS
|
|
|
- return hpatch_FALSE;//not cache oldData
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL patch_stream_with_cache(const struct hpatch_TStreamOutput* out_newData,
|
|
|
- const struct hpatch_TStreamInput* oldData,
|
|
|
- const struct hpatch_TStreamInput* serializedDiff,
|
|
|
- TByte* temp_cache,TByte* temp_cache_end){
|
|
|
- hpatch_BOOL result;
|
|
|
- hpatch_TCovers* covers=0;//not need close before return
|
|
|
- hpatch_BOOL isReadError=hpatch_FALSE;
|
|
|
- _patch_cache(&covers,&oldData,out_newData->streamSize,serializedDiff,hpatch_FALSE,0,
|
|
|
- _kCachePatCount,&temp_cache,&temp_cache_end,&isReadError);
|
|
|
- if (isReadError) return _hpatch_FALSE;
|
|
|
- result=_patch_stream_with_cache(out_newData,oldData,serializedDiff,covers,
|
|
|
- temp_cache,temp_cache_end);
|
|
|
- //if ((covers!=0)&&(!covers->close(covers))) result=_hpatch_FALSE;
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL patch_stream(const hpatch_TStreamOutput* out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* serializedDiff){
|
|
|
- TByte temp_cache[hpatch_kStreamCacheSize*_kCachePatCount];
|
|
|
- return _patch_stream_with_cache(out_newData,oldData,serializedDiff,0,
|
|
|
- temp_cache,temp_cache+sizeof(temp_cache)/sizeof(TByte));
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL patch_decompress_with_cache(const hpatch_TStreamOutput* out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* compressedDiff,
|
|
|
- hpatch_TDecompress* decompressPlugin,
|
|
|
- TByte* temp_cache,TByte* temp_cache_end){
|
|
|
- hpatch_BOOL result;
|
|
|
- hpatch_TCovers* covers=0; //need close before return
|
|
|
- hpatch_BOOL isReadError=hpatch_FALSE;
|
|
|
- _patch_cache(&covers,&oldData,out_newData->streamSize,compressedDiff,hpatch_TRUE,
|
|
|
- decompressPlugin,_kCacheDecCount,&temp_cache,&temp_cache_end,&isReadError);
|
|
|
- if (isReadError) return _hpatch_FALSE;
|
|
|
- result=_patch_decompress_cache(out_newData,0,oldData,compressedDiff,decompressPlugin,
|
|
|
- covers,temp_cache,temp_cache_end);
|
|
|
- if ((covers!=0)&&(!covers->close(covers))) result=_hpatch_FALSE;
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL patch_decompress(const hpatch_TStreamOutput* out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* compressedDiff,
|
|
|
- hpatch_TDecompress* decompressPlugin){
|
|
|
- TByte temp_cache[hpatch_kStreamCacheSize*_kCacheDecCount];
|
|
|
- return _patch_decompress_cache(out_newData,0,oldData,compressedDiff,decompressPlugin,
|
|
|
- 0,temp_cache,temp_cache+sizeof(temp_cache)/sizeof(TByte));
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL hpatch_coverList_open_serializedDiff(hpatch_TCoverList* out_coverList,
|
|
|
- const hpatch_TStreamInput* serializedDiff){
|
|
|
- TByte* temp_cache;
|
|
|
- TByte* temp_cache_end;
|
|
|
- _TPackedCovers* packedCovers=0;
|
|
|
- _THDiffHead diffHead;
|
|
|
- assert((out_coverList!=0)&&(out_coverList->ICovers==0));
|
|
|
- temp_cache=out_coverList->_buf;
|
|
|
- temp_cache_end=temp_cache+sizeof(out_coverList->_buf);
|
|
|
- if (!_packedCovers_open(&packedCovers,&diffHead,serializedDiff,
|
|
|
- temp_cache,temp_cache_end))
|
|
|
- return _hpatch_FALSE;
|
|
|
- out_coverList->ICovers=&packedCovers->base.ICovers;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL hpatch_coverList_open_compressedDiff(hpatch_TCoverList* out_coverList,
|
|
|
- const hpatch_TStreamInput* compressedDiff,
|
|
|
- hpatch_TDecompress* decompressPlugin){
|
|
|
- TByte* temp_cache;
|
|
|
- TByte* temp_cache_end;
|
|
|
- _TCompressedCovers* compressedCovers=0;
|
|
|
- hpatch_compressedDiffInfo diffInfo;
|
|
|
- assert((out_coverList!=0)&&(out_coverList->ICovers==0));
|
|
|
- temp_cache=out_coverList->_buf;
|
|
|
- temp_cache_end=temp_cache+sizeof(out_coverList->_buf);
|
|
|
- if (!_compressedCovers_open(&compressedCovers,&diffInfo,compressedDiff,decompressPlugin,
|
|
|
- temp_cache,temp_cache_end))
|
|
|
- return _hpatch_FALSE;
|
|
|
- out_coverList->ICovers=&compressedCovers->base.ICovers;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-//
|
|
|
-
|
|
|
-#define _kCacheSgCount 3
|
|
|
-
|
|
|
-hpatch_BOOL patch_single_compressed_diff(const hpatch_TStreamOutput* out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* singleCompressedDiff,
|
|
|
- hpatch_StreamPos_t diffData_pos,
|
|
|
- hpatch_StreamPos_t uncompressedSize,
|
|
|
- hpatch_StreamPos_t compressedSize,
|
|
|
- hpatch_TDecompress* decompressPlugin,
|
|
|
- hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
|
|
|
- unsigned char* temp_cache,unsigned char* temp_cache_end,
|
|
|
- sspatch_coversListener_t* coversListener){
|
|
|
- hpatch_BOOL result;
|
|
|
- hpatch_TUncompresser_t uncompressedStream;
|
|
|
- hpatch_StreamPos_t diffData_posEnd;
|
|
|
- memset(&uncompressedStream,0,sizeof(uncompressedStream));
|
|
|
- if (compressedSize==0){
|
|
|
- decompressPlugin=0;
|
|
|
- }else{
|
|
|
- if (decompressPlugin==0) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- diffData_posEnd=(decompressPlugin?compressedSize:uncompressedSize)+diffData_pos;
|
|
|
- if (diffData_posEnd>singleCompressedDiff->streamSize) return _hpatch_FALSE;
|
|
|
- if (decompressPlugin){
|
|
|
- if (!compressed_stream_as_uncompressed(&uncompressedStream,uncompressedSize,decompressPlugin,singleCompressedDiff,
|
|
|
- diffData_pos,diffData_posEnd)) return _hpatch_FALSE;
|
|
|
- singleCompressedDiff=&uncompressedStream.base;
|
|
|
- diffData_pos=0;
|
|
|
- diffData_posEnd=singleCompressedDiff->streamSize;
|
|
|
- }
|
|
|
- result=patch_single_stream_diff(out_newData,oldData,singleCompressedDiff,diffData_pos,diffData_posEnd,
|
|
|
- coverCount,stepMemSize,temp_cache,temp_cache_end,coversListener);
|
|
|
- if (decompressPlugin)
|
|
|
- close_compressed_stream_as_uncompressed(&uncompressedStream);
|
|
|
- return result;
|
|
|
-}
|
|
|
-
|
|
|
-static const size_t _kStepMemSizeSafeLimit =(1<<20)*16;
|
|
|
-hpatch_BOOL getSingleCompressedDiffInfo(hpatch_singleCompressedDiffInfo* out_diffInfo,
|
|
|
- const hpatch_TStreamInput* singleCompressedDiff,
|
|
|
- hpatch_StreamPos_t diffInfo_pos){
|
|
|
- TStreamCacheClip _diffHeadClip;
|
|
|
- TStreamCacheClip* diffHeadClip=&_diffHeadClip;
|
|
|
- TByte temp_cache[hpatch_kStreamCacheSize];
|
|
|
- _TStreamCacheClip_init(&_diffHeadClip,singleCompressedDiff,diffInfo_pos,singleCompressedDiff->streamSize,
|
|
|
- temp_cache,hpatch_kStreamCacheSize);
|
|
|
- {//type
|
|
|
- const char* kVersionType="HDIFFSF20";
|
|
|
- char* tempType=out_diffInfo->compressType;
|
|
|
- if (!_TStreamCacheClip_readType_end(diffHeadClip,'&',tempType)) return _hpatch_FALSE;
|
|
|
- if (0!=strcmp(tempType,kVersionType)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- {//read compressType
|
|
|
- if (!_TStreamCacheClip_readType_end(diffHeadClip,'\0',
|
|
|
- out_diffInfo->compressType)) return _hpatch_FALSE;
|
|
|
- }
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->newDataSize,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->oldDataSize,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->coverCount,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->stepMemSize,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->uncompressedSize,diffHeadClip);
|
|
|
- _clip_unpackUIntTo(&out_diffInfo->compressedSize,diffHeadClip);
|
|
|
- out_diffInfo->diffDataPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip)-diffInfo_pos;
|
|
|
- if (out_diffInfo->compressedSize>out_diffInfo->uncompressedSize)
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (out_diffInfo->stepMemSize>(out_diffInfo->newDataSize>=_kStepMemSizeSafeLimit?out_diffInfo->newDataSize:_kStepMemSizeSafeLimit))
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (out_diffInfo->stepMemSize>out_diffInfo->uncompressedSize)
|
|
|
- return _hpatch_FALSE;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _TUncompresser_read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end){
|
|
|
- hpatch_TUncompresser_t* self=(hpatch_TUncompresser_t*)stream->streamImport;
|
|
|
- return self->_decompressPlugin->decompress_part(self->_decompressHandle,out_data,out_data_end);
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream,hpatch_StreamPos_t uncompressedSize,
|
|
|
- hpatch_TDecompress* decompressPlugin,const hpatch_TStreamInput* compressedStream,
|
|
|
- hpatch_StreamPos_t compressed_pos,hpatch_StreamPos_t compressed_end){
|
|
|
- hpatch_TUncompresser_t* self=uncompressedStream;
|
|
|
- assert(decompressPlugin!=0);
|
|
|
- assert(self->_decompressHandle==0);
|
|
|
- self->_decompressHandle=decompressPlugin->open(decompressPlugin,uncompressedSize,compressedStream,
|
|
|
- compressed_pos,compressed_end);
|
|
|
- if (self->_decompressHandle==0) return _hpatch_FALSE;
|
|
|
- self->_decompressPlugin=decompressPlugin;
|
|
|
-
|
|
|
- self->base.streamImport=self;
|
|
|
- self->base.streamSize=uncompressedSize;
|
|
|
- self->base.read=_TUncompresser_read;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-void close_compressed_stream_as_uncompressed(hpatch_TUncompresser_t* uncompressedStream){
|
|
|
- hpatch_TUncompresser_t* self=uncompressedStream;
|
|
|
- if (self==0) return;
|
|
|
- if (self->_decompressHandle==0) return;
|
|
|
- self->_decompressPlugin->close(self->_decompressPlugin,self->_decompressHandle);
|
|
|
- self->_decompressHandle=0;
|
|
|
-}
|
|
|
-
|
|
|
-typedef struct{
|
|
|
- const unsigned char* code;
|
|
|
- const unsigned char* code_end;
|
|
|
- hpatch_size_t len0;
|
|
|
- hpatch_size_t lenv;
|
|
|
- hpatch_BOOL isNeedDecode0;
|
|
|
-} rle0_decoder_t;
|
|
|
-
|
|
|
-static void _rle0_decoder_init(rle0_decoder_t* self,const unsigned char* code,const unsigned char* code_end){
|
|
|
- self->code=code;
|
|
|
- self->code_end=code_end;
|
|
|
- self->len0=0;
|
|
|
- self->lenv=0;
|
|
|
- self->isNeedDecode0=hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-static hpatch_BOOL _rle0_decoder_add(rle0_decoder_t* self,TByte* out_data,hpatch_size_t decodeSize){
|
|
|
- if (self->len0){
|
|
|
- _0_process:
|
|
|
- if (self->len0>=decodeSize){
|
|
|
- self->len0-=decodeSize;
|
|
|
- return hpatch_TRUE;
|
|
|
- }else{
|
|
|
- decodeSize-=self->len0;
|
|
|
- out_data+=self->len0;
|
|
|
- self->len0=0;
|
|
|
- goto _decode_v_process;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (self->lenv){
|
|
|
- _v_process:
|
|
|
- if (self->lenv>=decodeSize){
|
|
|
- addData(out_data,self->code,decodeSize);
|
|
|
- self->code+=decodeSize;
|
|
|
- self->lenv-=decodeSize;
|
|
|
- return hpatch_TRUE;
|
|
|
- }else{
|
|
|
- addData(out_data,self->code,self->lenv);
|
|
|
- out_data+=self->lenv;
|
|
|
- decodeSize-=self->lenv;
|
|
|
- self->code+=self->lenv;
|
|
|
- self->lenv=0;
|
|
|
- goto _decode_0_process;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- assert(decodeSize>0);
|
|
|
- if (self->isNeedDecode0){
|
|
|
- hpatch_StreamPos_t len0;
|
|
|
- _decode_0_process:
|
|
|
- self->isNeedDecode0=hpatch_FALSE;
|
|
|
- if (!hpatch_unpackUInt(&self->code,self->code_end,&len0)) return _hpatch_FALSE;
|
|
|
- if (len0!=(hpatch_size_t)len0) return _hpatch_FALSE;
|
|
|
- self->len0=(hpatch_size_t)len0;
|
|
|
- goto _0_process;
|
|
|
- }else{
|
|
|
- hpatch_StreamPos_t lenv;
|
|
|
- _decode_v_process:
|
|
|
- self->isNeedDecode0=hpatch_TRUE;
|
|
|
- if (!hpatch_unpackUInt(&self->code,self->code_end,&lenv)) return _hpatch_FALSE;
|
|
|
- if (lenv>(size_t)(self->code_end-self->code)) return _hpatch_FALSE;
|
|
|
- self->lenv=(hpatch_size_t)lenv;
|
|
|
- goto _v_process;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-static hpatch_BOOL _patch_add_old_with_rle0(_TOutStreamCache* outCache,rle0_decoder_t* rle0_decoder,
|
|
|
- const hpatch_TStreamInput* old,hpatch_StreamPos_t oldPos,
|
|
|
- hpatch_StreamPos_t addLength,TByte* aCache,hpatch_size_t aCacheSize){
|
|
|
- while (addLength>0){
|
|
|
- hpatch_size_t decodeStep=aCacheSize;
|
|
|
- if (decodeStep>addLength)
|
|
|
- decodeStep=(hpatch_size_t)addLength;
|
|
|
- if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
|
|
|
- if (!_rle0_decoder_add(rle0_decoder,aCache,decodeStep)) return _hpatch_FALSE;
|
|
|
- if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
|
|
|
- oldPos+=decodeStep;
|
|
|
- addLength-=decodeStep;
|
|
|
- }
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL sspatch_covers_nextCover(sspatch_covers_t* self){
|
|
|
- hpatch_BOOL inc_oldPos_sign=(*(self->covers_cache))>>(8-1);
|
|
|
- self->lastOldEnd=self->cover.oldPos+self->cover.length;
|
|
|
- self->lastNewEnd=self->cover.newPos+self->cover.length;
|
|
|
- if (!hpatch_unpackUIntWithTag(&self->covers_cache,self->covers_cacheEnd,&self->cover.oldPos,1)) return _hpatch_FALSE;
|
|
|
- if (inc_oldPos_sign==0)
|
|
|
- self->cover.oldPos+=self->lastOldEnd;
|
|
|
- else
|
|
|
- self->cover.oldPos=self->lastOldEnd-self->cover.oldPos;
|
|
|
- if (!hpatch_unpackUInt(&self->covers_cache,self->covers_cacheEnd,&self->cover.newPos)) return _hpatch_FALSE;
|
|
|
- self->cover.newPos+=self->lastNewEnd;
|
|
|
- if (!hpatch_unpackUInt(&self->covers_cache,self->covers_cacheEnd,&self->cover.length)) return _hpatch_FALSE;
|
|
|
- return hpatch_TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-hpatch_BOOL patch_single_stream_diff(const hpatch_TStreamOutput* out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* uncompressedDiffData,
|
|
|
- hpatch_StreamPos_t diffData_pos,
|
|
|
- hpatch_StreamPos_t diffData_posEnd,
|
|
|
- hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
|
|
|
- unsigned char* temp_cache,unsigned char* temp_cache_end,
|
|
|
- sspatch_coversListener_t* coversListener){
|
|
|
- unsigned char* step_cache=temp_cache;
|
|
|
- hpatch_size_t cache_size;
|
|
|
- TStreamCacheClip inClip;
|
|
|
- _TOutStreamCache outCache;
|
|
|
- sspatch_covers_t covers;
|
|
|
- assert(diffData_posEnd<=uncompressedDiffData->streamSize);
|
|
|
- sspatch_covers_init(&covers);
|
|
|
- if (coversListener) assert(coversListener->onStepCovers);
|
|
|
- {//cache
|
|
|
- if ((size_t)(temp_cache_end-temp_cache)<stepMemSize+hpatch_kStreamCacheSize*_kCacheSgCount) return _hpatch_FALSE;
|
|
|
- temp_cache+=stepMemSize;
|
|
|
- cache_size=(temp_cache_end-temp_cache)/_kCacheSgCount;
|
|
|
- _TStreamCacheClip_init(&inClip,uncompressedDiffData,diffData_pos,diffData_posEnd,
|
|
|
- temp_cache,cache_size);
|
|
|
- temp_cache+=cache_size;
|
|
|
- _TOutStreamCache_init(&outCache,out_newData,temp_cache+cache_size,cache_size);
|
|
|
- }
|
|
|
- while (coverCount) {//step loop
|
|
|
- rle0_decoder_t rle0_decoder;
|
|
|
- {//read step info
|
|
|
- unsigned char* covers_cacheEnd;
|
|
|
- unsigned char* bufRle_cache_end;
|
|
|
- {
|
|
|
- hpatch_StreamPos_t bufCover_size;
|
|
|
- hpatch_StreamPos_t bufRle_size;
|
|
|
- _clip_unpackUIntTo(&bufCover_size,&inClip);
|
|
|
- _clip_unpackUIntTo(&bufRle_size,&inClip);
|
|
|
- #ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ((bufCover_size>stepMemSize)|(bufRle_size>stepMemSize)|
|
|
|
- (bufCover_size+bufRle_size>stepMemSize)) return _hpatch_FALSE;
|
|
|
- #endif
|
|
|
- covers_cacheEnd=step_cache+(size_t)bufCover_size;
|
|
|
- bufRle_cache_end=covers_cacheEnd+(size_t)bufRle_size;
|
|
|
- }
|
|
|
- if (coversListener&&coversListener->onStepCoversReset)
|
|
|
- coversListener->onStepCoversReset(coversListener,coverCount);
|
|
|
- if (!_TStreamCacheClip_readDataTo(&inClip,step_cache,bufRle_cache_end))
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (coversListener)
|
|
|
- coversListener->onStepCovers(coversListener,step_cache,covers_cacheEnd);
|
|
|
- sspatch_covers_setCoversCache(&covers,step_cache,covers_cacheEnd);
|
|
|
- _rle0_decoder_init(&rle0_decoder,covers_cacheEnd,bufRle_cache_end);
|
|
|
- }
|
|
|
- while (sspatch_covers_isHaveNextCover(&covers)) {//cover loop
|
|
|
- if (!sspatch_covers_nextCover(&covers))
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (covers.cover.newPos>covers.lastNewEnd){
|
|
|
- if (!_TOutStreamCache_copyFromClip(&outCache,&inClip,covers.cover.newPos-covers.lastNewEnd))
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- --coverCount;
|
|
|
- if (covers.cover.length){
|
|
|
- #ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if ((covers.cover.oldPos>oldData->streamSize)|
|
|
|
- (covers.cover.length>(hpatch_StreamPos_t)(oldData->streamSize-covers.cover.oldPos))) return _hpatch_FALSE;
|
|
|
- #endif
|
|
|
- if (!_patch_add_old_with_rle0(&outCache,&rle0_decoder,oldData,covers.cover.oldPos,covers.cover.length,
|
|
|
- temp_cache,cache_size)) return _hpatch_FALSE;
|
|
|
- }else{
|
|
|
- #ifdef __RUN_MEM_SAFE_CHECK
|
|
|
- if (coverCount!=0) return _hpatch_FALSE;
|
|
|
- #endif
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!_TOutStreamCache_flush(&outCache))
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (_TStreamCacheClip_isFinish(&inClip)&_TOutStreamCache_isFinish(&outCache)&(coverCount==0))
|
|
|
- return hpatch_TRUE;
|
|
|
- else
|
|
|
- return _hpatch_FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-static hpatch_BOOL _TDiffToSingleStream_read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
|
|
|
- unsigned char* out_data,unsigned char* out_data_end){
|
|
|
- //[ |readedSize ]
|
|
|
- // [ |cachedBufBegin _TDiffToSingleStream_kBufSize]
|
|
|
- // readFromPos[out_data out_data_end]
|
|
|
- TDiffToSingleStream* self=(TDiffToSingleStream*)stream->streamImport;
|
|
|
- hpatch_StreamPos_t readedSize=self->readedSize;
|
|
|
- while (1){
|
|
|
- size_t rLen=out_data_end-out_data;
|
|
|
- if (readFromPos==readedSize){
|
|
|
- hpatch_BOOL result=self->diffStream->read(self->diffStream,readedSize,out_data,out_data_end);
|
|
|
- self->readedSize=readedSize+rLen;
|
|
|
- if ((self->isInSingleStream)||(rLen>_TDiffToSingleStream_kBufSize)){
|
|
|
- self->cachedBufBegin=_TDiffToSingleStream_kBufSize;
|
|
|
- }else{
|
|
|
- //cache
|
|
|
- if (rLen>=_TDiffToSingleStream_kBufSize){
|
|
|
- memcpy(self->buf,out_data_end-_TDiffToSingleStream_kBufSize,_TDiffToSingleStream_kBufSize);
|
|
|
- self->cachedBufBegin = 0;
|
|
|
- }else{
|
|
|
- size_t new_cachedBufBegin;
|
|
|
- if (self->cachedBufBegin>=rLen){
|
|
|
- new_cachedBufBegin=self->cachedBufBegin-rLen;
|
|
|
- memmove(self->buf+new_cachedBufBegin,self->buf+self->cachedBufBegin,_TDiffToSingleStream_kBufSize-self->cachedBufBegin);
|
|
|
- }else{
|
|
|
- new_cachedBufBegin=0;
|
|
|
- memmove(self->buf,self->buf+rLen,_TDiffToSingleStream_kBufSize-rLen);
|
|
|
- }
|
|
|
- memcpy(self->buf+(_TDiffToSingleStream_kBufSize-rLen),out_data,rLen);
|
|
|
- self->cachedBufBegin=new_cachedBufBegin;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- }else{
|
|
|
- size_t cachedSize=_TDiffToSingleStream_kBufSize-self->cachedBufBegin;
|
|
|
- size_t bufSize=(size_t)(readedSize-readFromPos);
|
|
|
- if ((readFromPos<readedSize)&(bufSize<=cachedSize)){
|
|
|
- if (rLen>bufSize)
|
|
|
- rLen=bufSize;
|
|
|
- memcpy(out_data,self->buf+(_TDiffToSingleStream_kBufSize-bufSize),rLen);
|
|
|
- out_data+=rLen;
|
|
|
- readFromPos+=rLen;
|
|
|
- if (out_data==out_data_end)
|
|
|
- return hpatch_TRUE;
|
|
|
- else
|
|
|
- continue;
|
|
|
- }else{
|
|
|
- return _hpatch_FALSE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-void TDiffToSingleStream_init(TDiffToSingleStream* self,const hpatch_TStreamInput* diffStream){
|
|
|
- self->base.streamImport=self;
|
|
|
- self->base.streamSize=diffStream->streamSize;
|
|
|
- self->base.read=_TDiffToSingleStream_read;
|
|
|
- self->base._private_reserved=0;
|
|
|
- self->diffStream=diffStream;
|
|
|
- self->readedSize=0;
|
|
|
- self->cachedBufBegin=_TDiffToSingleStream_kBufSize;
|
|
|
- self->isInSingleStream=hpatch_FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-hpatch_BOOL patch_single_stream(sspatch_listener_t* listener,
|
|
|
- const hpatch_TStreamOutput* __out_newData,
|
|
|
- const hpatch_TStreamInput* oldData,
|
|
|
- const hpatch_TStreamInput* singleCompressedDiff,
|
|
|
- hpatch_StreamPos_t diffInfo_pos,
|
|
|
- sspatch_coversListener_t* coversListener){
|
|
|
- hpatch_BOOL result=hpatch_TRUE;
|
|
|
- hpatch_TDecompress* decompressPlugin=0;
|
|
|
- unsigned char* temp_cache=0;
|
|
|
- unsigned char* temp_cacheEnd=0;
|
|
|
- hpatch_singleCompressedDiffInfo diffInfo;
|
|
|
- hpatch_TStreamOutput _out_newData=*__out_newData;
|
|
|
- hpatch_TStreamOutput* out_newData=&_out_newData;
|
|
|
- TDiffToSingleStream _toSStream;
|
|
|
- assert((listener)&&(listener->onDiffInfo));
|
|
|
- TDiffToSingleStream_init(&_toSStream,singleCompressedDiff);
|
|
|
- singleCompressedDiff=&_toSStream.base;
|
|
|
-
|
|
|
- if (!getSingleCompressedDiffInfo(&diffInfo,singleCompressedDiff,diffInfo_pos))
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (diffInfo.newDataSize>out_newData->streamSize)
|
|
|
- return _hpatch_FALSE;
|
|
|
- out_newData->streamSize=diffInfo.newDataSize;
|
|
|
- if (diffInfo.oldDataSize!=oldData->streamSize)
|
|
|
- return _hpatch_FALSE;
|
|
|
- if (!listener->onDiffInfo(listener,&diffInfo,&decompressPlugin,&temp_cache,&temp_cacheEnd))
|
|
|
- return _hpatch_FALSE;
|
|
|
-
|
|
|
- if ((temp_cache==0)||(temp_cache>=temp_cacheEnd))
|
|
|
- result=_hpatch_FALSE;
|
|
|
- if (result){
|
|
|
- result=patch_single_compressed_diff(out_newData,oldData,singleCompressedDiff,diffInfo.diffDataPos,
|
|
|
- diffInfo.uncompressedSize,diffInfo.compressedSize,decompressPlugin,
|
|
|
- diffInfo.coverCount,(size_t)diffInfo.stepMemSize,
|
|
|
- temp_cache,temp_cacheEnd,coversListener);
|
|
|
- }
|
|
|
- if (listener->onPatchFinish)
|
|
|
- listener->onPatchFinish(listener,temp_cache,temp_cacheEnd);
|
|
|
- return result;
|
|
|
-}
|
sulfurandcu