react-native-update 7.4.2 → 7.4.3

package/android/jni/HDiffPatch/dirDiffPatch/dir_patch/new_dir_output.c

@@ -0,0 +1,331 @@
+// new_dir_output.c
+// hdiffz dir patch
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "new_dir_output.h"
+#include "../../file_for_patch.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "dir_patch_tools.h"
+#include <stdio.h>
+#include <string.h>
+
+#define TUInt hpatch_StreamPos_t
+
+#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n");  \
+                                       result=hpatch_FALSE; goto clear; } }
+
+static hpatch_BOOL _TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
+                                         hpatch_ICopyDataListener* copyListener){
+#define _tempCacheSize (hpatch_kStreamCacheSize*4)
+    hpatch_BOOL result=hpatch_TRUE;
+    TByte        temp_cache[_tempCacheSize];
+    hpatch_StreamPos_t pos=0;
+    hpatch_TFileStreamInput   oldFile;
+    hpatch_TFileStreamOutput  newFile;
+    hpatch_TFileStreamInput_init(&oldFile);
+    hpatch_TFileStreamOutput_init(&newFile);
+    
+    check(hpatch_TFileStreamInput_open(&oldFile,oldFileName_utf8));
+    if (newFileName_utf8)
+        check(hpatch_TFileStreamOutput_open(&newFile,newFileName_utf8,oldFile.base.streamSize));
+    while (pos<oldFile.base.streamSize) {
+        size_t copyLen=_tempCacheSize;
+        if (pos+copyLen>oldFile.base.streamSize)
+            copyLen=(size_t)(oldFile.base.streamSize-pos);
+        check(oldFile.base.read(&oldFile.base,pos,temp_cache,temp_cache+copyLen));
+        if (newFileName_utf8)
+            check(newFile.base.write(&newFile.base,pos,temp_cache,temp_cache+copyLen));
+        if (copyListener)
+            copyListener->copyedData(copyListener,temp_cache,temp_cache+copyLen);
+        pos+=copyLen;
+    }
+    check(!oldFile.fileError);
+    check(!newFile.fileError);
+    if (newFileName_utf8)
+        check(newFile.out_length==newFile.base.streamSize);
+clear:
+    hpatch_TFileStreamOutput_close(&newFile);
+    hpatch_TFileStreamInput_close(&oldFile);
+    return result;
+#undef _tempCacheSize
+}
+
+hpatch_BOOL TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
+                                 hpatch_ICopyDataListener* copyListener){
+    hpatch_BOOL result=hpatch_TRUE;
+    check(newFileName_utf8!=0);
+    result=_TDirPatcher_copyFile(oldFileName_utf8,newFileName_utf8,copyListener);
+clear:
+    return result;
+}
+hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener){
+    return _TDirPatcher_copyFile(oldFileName_utf8,0,copyListener);
+}
+
+static hpatch_BOOL _makeNewDirOrEmptyFile(hpatch_INewStreamListener* listener,size_t newPathIndex){
+    hpatch_BOOL  result=hpatch_TRUE;
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    const char*  pathName=TNewDirOutput_getNewPathByIndex(self,newPathIndex);
+    check(pathName!=0);
+    if (hpatch_getIsDirName(pathName)){ //
+        check(self->_listener->makeNewDir(self->_listener,pathName));
+    }else{ //empty file
+        check(self->_listener->openNewFile(self->_listener,self->_curNewFile,pathName,0));
+        check(!self->_curNewFile->fileError);
+        check(self->_listener->closeNewFile(self->_listener,self->_curNewFile));
+    }
+clear:
+    return result;
+}
+
+static const char* _getOldPathByIndex(TNewDirOutput* self,size_t oldPathIndex){
+    assert(self->_oldPathListener.getOldPathByIndex!=0);
+    return self->_oldPathListener.getOldPathByIndex(&self->_oldPathListener,oldPathIndex);
+}
+
+static hpatch_BOOL _copySameFile(hpatch_INewStreamListener* listener,size_t newPathIndex,size_t oldPathIndex){
+    hpatch_BOOL  result=hpatch_TRUE;
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    const char*  newFileName=0;
+    const char*  oldFileName=0;
+    assert(newPathIndex<self->newPathCount);
+    newFileName=TNewDirOutput_getNewPathByIndex(self,newPathIndex);
+    check(newFileName!=0);
+    check(self->_oldPathListener.getOldPathByIndex!=0);
+    oldFileName=_getOldPathByIndex(self,oldPathIndex);
+    check(oldFileName!=0);
+    check(self->_listener->copySameFile(self->_listener,oldFileName,newFileName,
+                                        self->isCheck_copyFileData?(&self->_sameFileCopyListener):0));
+clear:
+    return result;
+}
+
+static hpatch_BOOL _openNewFile(hpatch_INewStreamListener* listener,size_t newRefIndex,
+                                const hpatch_TStreamOutput** out_newFileStream){
+    hpatch_BOOL  result=hpatch_TRUE;
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    const char*  utf8fileName=0;
+    hpatch_StreamPos_t fileSize=self->newRefSizeList[newRefIndex];
+    assert(newRefIndex<self->newRefFileCount);
+    assert(self->_curNewFile->m_file==0);
+    if (fileSize==0){
+        size_t newPathIndex=self->newRefList?self->newRefList[newRefIndex]:newRefIndex;
+        check(_makeNewDirOrEmptyFile(listener,newPathIndex));
+        *out_newFileStream=0;
+    }else{
+        utf8fileName=TNewDirOutput_getNewPathByRefIndex(self,newRefIndex);
+        check(utf8fileName!=0);
+        check(self->_listener->openNewFile(self->_listener,self->_curNewFile,
+                                           utf8fileName,fileSize));
+        *out_newFileStream=&self->_curNewFile->base;
+    }
+clear:
+    return result;
+}
+static hpatch_BOOL _closeNewFile(hpatch_INewStreamListener* listener,const hpatch_TStreamOutput* newFileStream){
+    hpatch_BOOL  result=hpatch_TRUE;
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    assert(self->_curNewFile!=0);
+    assert(newFileStream==&self->_curNewFile->base);
+    check(!self->_curNewFile->fileError);
+    check(self->_listener->closeNewFile(self->_listener,self->_curNewFile));
+    hpatch_TFileStreamOutput_init(self->_curNewFile);
+clear:
+    return result;
+}
+
+static void _writedNewRefData(struct hpatch_INewStreamListener* listener,const unsigned char* data,
+                             const unsigned char* dataEnd){
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    if (self->isCheck_newRefData)
+        self->_checksumPlugin->append(self->_newRefChecksumHandle,data,dataEnd);
+}
+
+static hpatch_BOOL _do_checksumEnd(TNewDirOutput* self,const TByte* checksumTest,TByte* checksumTemp,
+                                   hpatch_checksumHandle* pcsHandle){
+    size_t checksumByteSize=self->_checksumPlugin->checksumByteSize();
+    hpatch_checksumHandle* csHandle=*pcsHandle;
+    assert(csHandle!=0);
+    *pcsHandle=0;
+    self->_checksumPlugin->end(csHandle,checksumTemp,checksumTemp+checksumByteSize);
+    self->_checksumPlugin->close(self->_checksumPlugin,csHandle);
+    return (0==memcmp(checksumTest,checksumTemp,checksumByteSize));
+}
+
+#define _pchecksumNewRef(_self)     ((_self)->_pChecksum_newRefData_copyFileData)
+#define _pchecksumCopyFile(_self)   ((_self)->_pChecksum_newRefData_copyFileData+(_self)->checksumByteSize)
+#define _pchecksumTemp(_self)       ((_self)->_pChecksum_temp)
+
+static hpatch_BOOL _writedFinish(struct hpatch_INewStreamListener* listener){
+    hpatch_BOOL  result=hpatch_TRUE;
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    //checksum newRefData end
+    if (self->isCheck_newRefData){
+        if (!_do_checksumEnd(self,_pchecksumNewRef(self),_pchecksumTemp(self),&self->_newRefChecksumHandle))
+            self->_isNewRefDataChecksumError=hpatch_TRUE;
+    }
+    //checksum sameFileData end
+    if (self->isCheck_copyFileData){
+        if (!_do_checksumEnd(self,_pchecksumCopyFile(self),_pchecksumTemp(self),&self->_sameFileChecksumHandle))
+            self->_isCopyDataChecksumError=hpatch_TRUE;
+    }
+    check(!self->_isNewRefDataChecksumError);
+    check(!self->_isCopyDataChecksumError);
+clear:
+    return result;
+}
+
+static void _sameFile_copyedData(hpatch_ICopyDataListener* listener,const unsigned char* data,
+                                 const unsigned char* dataEnd){
+    TNewDirOutput* self=(TNewDirOutput*)listener->listenerImport;
+    if (self->isCheck_copyFileData)
+        self->_checksumPlugin->append(self->_sameFileChecksumHandle,data,dataEnd);
+}
+
+hpatch_BOOL TNewDirOutput_openDir(TNewDirOutput* self,IDirPatchListener* listener,
+                                  size_t kAlignSize,const hpatch_TStreamOutput** out_newDirStream){
+    hpatch_BOOL result=hpatch_TRUE;
+    size_t      refCount=self->newRefFileCount;
+    assert(self->_pmem==0);
+    assert(self->_newDirStream.stream==0);
+    assert(self->_newDirStreamListener.listenerImport==0);
+    self->_listener=listener;
+    {//open new
+        size_t      memSize=sizeof(hpatch_TFileStreamOutput);
+        self->_pmem=malloc(memSize);
+        check(self->_pmem!=0);
+        self->_curNewFile=(hpatch_TFileStreamOutput*)self->_pmem;
+        hpatch_TFileStreamOutput_init(self->_curNewFile);
+        
+        self->_newDirStreamListener.listenerImport=self;
+        self->_newDirStreamListener.makeNewDirOrEmptyFile=_makeNewDirOrEmptyFile;
+        self->_newDirStreamListener.copySameFile=_copySameFile;
+        self->_newDirStreamListener.openNewFile=_openNewFile;
+        self->_newDirStreamListener.closeNewFile=_closeNewFile;
+        self->_newDirStreamListener.writedNewRefData=_writedNewRefData;
+        self->_newDirStreamListener.writedFinish=_writedFinish;
+    }
+    //checksum newRefData begin
+    if (self->isCheck_newRefData){
+        assert(self->_newRefChecksumHandle==0);
+        self->_newRefChecksumHandle=self->_checksumPlugin->open(self->_checksumPlugin);
+        check(self->_newRefChecksumHandle!=0);
+        self->_checksumPlugin->begin(self->_newRefChecksumHandle);
+    }
+    //checksum sameFileData begin
+    if (self->isCheck_copyFileData){
+        assert(self->_sameFileChecksumHandle==0);
+        self->_sameFileChecksumHandle=self->_checksumPlugin->open(self->_checksumPlugin);
+        check(self->_sameFileChecksumHandle!=0);
+        self->_checksumPlugin->begin(self->_sameFileChecksumHandle);
+        
+        if (self->isCheck_copyFileData){
+            self->_sameFileCopyListener.listenerImport=self;
+            self->_sameFileCopyListener.copyedData=_sameFile_copyedData;
+        }
+    }
+    check(hpatch_TNewStream_open(&self->_newDirStream,&self->_newDirStreamListener,
+                                 self->newDataSize,self->newPathCount,
+                                 self->newRefList,refCount,self->dataSamePairList,
+                                 self->sameFilePairCount,kAlignSize));
+    *out_newDirStream=self->_newDirStream.stream;
+clear:
+    return result;
+}
+
+
+hpatch_BOOL TNewDirOutput_closeNewDirHandles(TNewDirOutput* self){
+    hpatch_BOOL result=hpatch_TNewStream_closeFileHandles(&self->_newDirStream);
+    if (self->_curNewFile){
+        if (!hpatch_TFileStreamOutput_close(self->_curNewFile))
+            result=hpatch_FALSE;
+        hpatch_TFileStreamOutput_init(self->_curNewFile);
+    }
+    return result;
+}
+
+hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self){
+    hpatch_BOOL result=TNewDirOutput_closeNewDirHandles(self);
+    hpatch_TChecksum* checksumPlugin=self->_checksumPlugin;
+    if (!hpatch_TNewStream_close(&self->_newDirStream))
+        result=hpatch_FALSE;
+    self->_newRootDir=0;
+    self->_newRootDir_end=0;
+    self->_newRootDir_bufEnd=0;
+    self->_curNewFile=0;
+    if (self->_newRefChecksumHandle){
+        checksumPlugin->close(checksumPlugin,self->_newRefChecksumHandle);
+        self->_newRefChecksumHandle=0;
+    }
+    if (self->_sameFileChecksumHandle){
+        checksumPlugin->close(checksumPlugin,self->_sameFileChecksumHandle);
+        self->_sameFileChecksumHandle=0;
+    }
+    if (self->_pmem) {
+        free(self->_pmem);
+        self->_pmem=0;
+    }
+    return result;
+}
+
+const char* TNewDirOutput_getNewPathRoot(TNewDirOutput* self){
+    if (!setPath(self->_newRootDir_end,self->_newRootDir_bufEnd,"")) return 0; //error
+    return self->_newRootDir;
+}
+
+const char* TNewDirOutput_getNewPathByIndex(TNewDirOutput* self,size_t newPathIndex){
+    assert(newPathIndex<self->newPathCount);
+    if (!setPath(self->_newRootDir_end,self->_newRootDir_bufEnd,
+                 self->newUtf8PathList[newPathIndex])) return 0; //error
+    return self->_newRootDir;
+}
+
+const char* TNewDirOutput_getNewPathByRefIndex(TNewDirOutput* self,size_t newRefIndex){
+    size_t newPathIndex;
+    assert(newRefIndex<self->newRefFileCount);
+    newPathIndex=self->newRefList?self->newRefList[newRefIndex]:newRefIndex;
+    return TNewDirOutput_getNewPathByIndex(self,newPathIndex);
+}
+
+const char* TNewDirOutput_getNewExecuteFileByIndex(TNewDirOutput* self,size_t newExecuteIndex){
+    assert(newExecuteIndex<self->newExecuteCount);
+    return TNewDirOutput_getNewPathByIndex(self,self->newExecuteList[newExecuteIndex]);
+}
+
+const char* TNewDirOutput_getOldPathBySameIndex(TNewDirOutput* self,size_t sameIndex){
+    assert(sameIndex<self->sameFilePairCount);
+    assert(self->dataSamePairList!=0);
+    return _getOldPathByIndex(self,self->dataSamePairList[sameIndex].oldIndex);
+}
+
+const char* TNewDirOutput_getNewPathBySameIndex(TNewDirOutput* self,size_t sameIndex){
+    assert(sameIndex<self->sameFilePairCount);
+    assert(self->dataSamePairList!=0);
+    return TNewDirOutput_getNewPathByIndex(self,self->dataSamePairList[sameIndex].newIndex);
+}
+
+#endif

package/android/jni/HDiffPatch/dirDiffPatch/dir_patch/new_dir_output.h

@@ -0,0 +1,144 @@
+// new_dir_output.h
+// hdiffz dir patch
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef DirPatch_new_dir_output_h
+#define DirPatch_new_dir_output_h
+#include "dir_patch_types.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
+#include "ref_stream.h"
+#include "new_stream.h"
+#include "res_handle_limit.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef struct hpatch_ICopyDataListener{
+        void* listenerImport;
+        void    (*copyedData)(struct hpatch_ICopyDataListener* listener,const unsigned char* data,
+                              const unsigned char* dataEnd);
+    } hpatch_ICopyDataListener;
+    
+hpatch_BOOL TDirPatcher_copyFile(const char* oldFileName_utf8,const char* newFileName_utf8,
+                                 hpatch_ICopyDataListener* copyListener);
+hpatch_BOOL TDirPatcher_readFile(const char* oldFileName_utf8,hpatch_ICopyDataListener* copyListener);
+
+
+    struct hpatch_TFileStreamOutput;
+    
+    typedef struct IDirPatchListener{
+        void*       listenerImport;
+        hpatch_BOOL   (*makeNewDir)(struct IDirPatchListener* listener,const char* newDir);
+        hpatch_BOOL (*copySameFile)(struct IDirPatchListener* listener,const char* oldFileName,
+                                    const char* newFileName,hpatch_ICopyDataListener* copyListener);
+        hpatch_BOOL  (*openNewFile)(struct IDirPatchListener* listener,struct hpatch_TFileStreamOutput*  out_curNewFile,
+                                    const char* newFileName,hpatch_StreamPos_t newFileSize);
+        hpatch_BOOL (*closeNewFile)(struct IDirPatchListener* listener,struct hpatch_TFileStreamOutput* curNewFile);
+    } IDirPatchListener;
+    
+    
+    typedef struct hpatch_IOldPathListener{
+        void* listenerImport;
+        const char* (*getOldPathByIndex)(struct hpatch_IOldPathListener* listener,size_t oldPathIndex);
+    } hpatch_IOldPathListener;
+    
+    typedef struct TNewDirOutput{
+        //input:
+        const char* const *         newUtf8PathList;
+        const size_t*               newRefList;
+        const size_t*               newExecuteList;
+        const hpatch_StreamPos_t*   newRefSizeList;
+        const hpatch_TSameFilePair* dataSamePairList; //new map to old index
+        hpatch_StreamPos_t          newDataSize;
+        size_t                      newPathCount;
+        size_t                      newRefFileCount;
+        size_t                      newExecuteCount;
+        size_t                      sameFilePairCount;
+        size_t                      checksumByteSize;
+        hpatch_BOOL                 isCheck_newRefData;
+        hpatch_BOOL                 isCheck_copyFileData;
+        //private input:
+        hpatch_IOldPathListener     _oldPathListener;
+        char*                       _newRootDir;
+        char*                       _newRootDir_end;
+        char*                       _newRootDir_bufEnd;
+        const unsigned char*        _pChecksum_newRefData_copyFileData;
+        unsigned char*              _pChecksum_temp;
+        hpatch_TChecksum*           _checksumPlugin;
+        //private:
+        hpatch_ICopyDataListener    _sameFileCopyListener;
+        hpatch_TNewStream           _newDirStream;
+        IDirPatchListener*          _listener;
+        hpatch_INewStreamListener   _newDirStreamListener;
+        hpatch_checksumHandle       _newRefChecksumHandle;
+        hpatch_checksumHandle       _sameFileChecksumHandle;
+        hpatch_BOOL                 _isNewRefDataChecksumError;
+        hpatch_BOOL                 _isCopyDataChecksumError;
+        struct hpatch_TFileStreamOutput*   _curNewFile;
+        void*                       _pmem;
+    } TNewDirOutput;
+
+hpatch_inline
+static void TNewDirOutput_init(TNewDirOutput* self)  { memset(self,0,sizeof(*self)); }
+hpatch_BOOL TNewDirOutput_openDir(TNewDirOutput* self,IDirPatchListener* listener,
+                                  size_t kAlignSize,const hpatch_TStreamOutput** out_newDirStream);
+
+hpatch_BOOL TNewDirOutput_closeNewDirHandles(TNewDirOutput* self);//for TNewDirOutput_openDir
+hpatch_BOOL TNewDirOutput_close(TNewDirOutput* self);
+
+const char* TNewDirOutput_getNewPathRoot(TNewDirOutput* self);
+const char* TNewDirOutput_getNewPathByIndex(TNewDirOutput* self,size_t newPathIndex);
+const char* TNewDirOutput_getNewExecuteFileByIndex(TNewDirOutput* self,size_t newExecuteIndex);
+const char* TNewDirOutput_getNewPathByRefIndex(TNewDirOutput* self,size_t newRefIndex);
+const char* TNewDirOutput_getOldPathBySameIndex(TNewDirOutput* self,size_t sameIndex);
+const char* TNewDirOutput_getNewPathBySameIndex(TNewDirOutput* self,size_t sameIndex);
+
+//ExecuteList
+typedef const char* (*IDirPathList_getPathNameByIndex)(void* import,size_t index);
+typedef struct IDirPathList{
+    void*                   import;
+    size_t                  pathCount;
+    IDirPathList_getPathNameByIndex getPathNameByIndex;
+} IDirPathList;
+
+static hpatch_inline void TNewDirOutput_getExecuteList(TNewDirOutput* self,IDirPathList* out_executeList) {
+    out_executeList->import=self;
+    out_executeList->pathCount=self->newExecuteCount;
+    out_executeList->getPathNameByIndex=(IDirPathList_getPathNameByIndex)TNewDirOutput_getNewExecuteFileByIndex;
+}
+static hpatch_inline void TNewDirOutput_getNewDirPathList(TNewDirOutput* self,IDirPathList* out_newPathList) {
+    out_newPathList->import=self;
+    out_newPathList->pathCount=self->newPathCount;
+    out_newPathList->getPathNameByIndex=(IDirPathList_getPathNameByIndex)TNewDirOutput_getNewPathByIndex;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif //DirPatch_new_dir_output_h

package/android/jni/HDiffPatch/dirDiffPatch/dir_patch/new_stream.c

@@ -0,0 +1,176 @@
+//  new_stream.cpp
+//  dir patch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "new_stream.h"
+#if (_IS_NEED_DIR_DIFF_PATCH)
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h> //printf
+
+
+hpatch_BOOL hpatch_TNewStream_closeFileHandles(hpatch_TNewStream* self){
+    hpatch_BOOL result=hpatch_TRUE;
+    const hpatch_TStreamOutput* curNewFile=self->_curNewFile;
+    if (curNewFile){
+        self->_curNewFile=0;
+        result=self->_listener->closeNewFile(self->_listener,curNewFile);
+    }
+    return result;
+}
+
+hpatch_BOOL hpatch_TNewStream_close(hpatch_TNewStream* self){
+    return hpatch_TNewStream_closeFileHandles(self);
+}
+
+static hpatch_BOOL _file_entry_end(hpatch_TNewStream* self);
+static hpatch_BOOL _file_append_ready(hpatch_TNewStream* self);
+static hpatch_BOOL _file_append_part(hpatch_TNewStream* self,hpatch_StreamPos_t writeToPos,
+                                     const unsigned char* data,const unsigned char* data_end);
+static hpatch_BOOL _file_append_end(hpatch_TNewStream* self);
+
+#define  check(value) { if (!(value)){ fprintf(stderr,"check "#value" error!\n"); return hpatch_FALSE; } }
+
+static hpatch_BOOL _TNewStream_write(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
+                                     const unsigned char* data,const unsigned char* data_end){
+    hpatch_TNewStream* self=(hpatch_TNewStream*)stream->streamImport;
+    self->_listener->writedNewRefData(self->_listener,data,data_end);
+    while (data!=data_end) {
+        size_t writeLen=(size_t)(data_end-data);
+        check(!self->isFinish);
+        check(writeToPos<self->_curWriteToPosEnd);
+        if (writeToPos+writeLen>self->_curWriteToPosEnd)
+            writeLen=(size_t)(self->_curWriteToPosEnd-writeToPos);
+        check(self->_curPathIndex<self->_pathCount);
+        check(_file_append_part(self,writeToPos,data,data+writeLen));
+        data+=writeLen;
+        writeToPos+=writeLen;
+        
+        if (writeToPos==self->_curWriteToPosEnd){//write one file end?
+            check(_file_append_end(self));
+            ++self->_curPathIndex;
+            check(_file_append_ready(self));
+        }
+    }
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _file_append_ready(hpatch_TNewStream* self){
+    assert(self->_curNewFile==0);
+    assert(self->_curWriteToPos==self->_curWriteToPosEnd);
+    while (self->_curPathIndex<self->_pathCount) {
+        if((self->_curNewRefIndex<self->_newRefCount) //write file ?
+           &&(self->_curPathIndex==(self->_newRefList?self->_newRefList[self->_curNewRefIndex]
+                                    :self->_curNewRefIndex))){
+            check(self->_listener->openNewFile(self->_listener,self->_curNewRefIndex,&self->_curNewFile));
+            ++self->_curNewRefIndex;
+            if (self->_curNewFile){//new file
+                self->_curWriteToPosEnd+=toAlignRangeSize(self->_curNewFile->streamSize,self->kAlignSize);
+                return hpatch_TRUE;
+            }else{ //make dir or empty file
+                ++self->_curPathIndex;
+            }
+        }else if ((self->_curSamePairIndex<self->_samePairCount) //copy file ?
+            &&(self->_curPathIndex==self->_samePairList[self->_curSamePairIndex].newIndex)){
+            const hpatch_TSameFilePair* pair=self->_samePairList+self->_curSamePairIndex;
+            check(self->_listener->copySameFile(self->_listener,pair->newIndex,pair->oldIndex));
+            ++self->_curSamePairIndex;
+            ++self->_curPathIndex;
+        }else{ //make dir or empty file
+            check(self->_listener->makeNewDirOrEmptyFile(self->_listener,self->_curPathIndex));
+            ++self->_curPathIndex;
+        }
+    }
+    //file entry end
+    check(_file_entry_end(self));
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _file_append_part(hpatch_TNewStream* self,hpatch_StreamPos_t g_writeToPos,
+                                     const unsigned char* data,const unsigned char* data_end){
+    hpatch_StreamPos_t curFilePos;
+    hpatch_StreamPos_t alignRangeSize;
+    assert(self->_curNewFile!=0);
+    assert((g_writeToPos<=self->_curWriteToPosEnd)&&(g_writeToPos==self->_curWriteToPos));
+    alignRangeSize=toAlignRangeSize(self->_curNewFile->streamSize,self->kAlignSize);
+    curFilePos=g_writeToPos-(self->_curWriteToPosEnd-alignRangeSize);
+    self->_curWriteToPos=g_writeToPos+(size_t)(data_end-data);
+    if (curFilePos>=self->_curNewFile->streamSize)
+        return hpatch_TRUE;
+    if (curFilePos+(size_t)(data_end-data)>self->_curNewFile->streamSize)
+        data_end=data+(size_t)(self->_curNewFile->streamSize-curFilePos);
+    return self->_curNewFile->write(self->_curNewFile,curFilePos,data,data_end);
+}
+
+static hpatch_BOOL _file_append_end(hpatch_TNewStream* self){
+    const hpatch_TStreamOutput* curNewFile=self->_curNewFile;
+    assert(curNewFile!=0);
+    assert(self->_curWriteToPos==self->_curWriteToPosEnd);
+    self->_curNewFile=0;
+    return self->_listener->closeNewFile(self->_listener,curNewFile);
+}
+
+static hpatch_BOOL _file_entry_end(hpatch_TNewStream* self){
+    check(!self->isFinish);
+    check(self->_curPathIndex==self->_pathCount);
+    check(self->_curSamePairIndex==self->_samePairCount);
+    self->isFinish=hpatch_TRUE;
+    check(self->_listener->writedFinish(self->_listener));
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL hpatch_TNewStream_open(hpatch_TNewStream* self,hpatch_INewStreamListener* listener,
+                                   hpatch_StreamPos_t newRefDataSize, size_t newPathCount,
+                                   const size_t* newRefList,size_t newRefCount,
+                                   const hpatch_TSameFilePair* samePairList,size_t samePairCount,
+                                   size_t kAlignSize){
+    assert(self->_listener==0);
+    assert(self->stream==0);
+    assert(self->_curNewFile==0);
+    self->_listener=listener;
+    self->isFinish=hpatch_FALSE;
+    self->kAlignSize=kAlignSize;
+    self->_pathCount=newPathCount;
+    self->_newRefList=newRefList;
+    self->_newRefCount=newRefCount;
+    self->_samePairList=samePairList;
+    self->_samePairCount=samePairCount;
+    
+    self->_stream.streamImport=self;
+    self->_stream.streamSize=newRefDataSize;
+    self->_stream.read_writed=0;
+    self->_stream.write=_TNewStream_write;
+    self->stream=&self->_stream;
+    
+    self->_curPathIndex=0;
+    self->_curWriteToPos=0;
+    self->_curWriteToPosEnd=0;
+    self->_curNewRefIndex=0;
+    self->_curSamePairIndex=0;
+    return _file_append_ready(self);
+}
+
+#endif