react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/file_for_patch.c

@@ -27,131 +27,14 @@
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
  */
-#define _LARGEFILE64_SOURCE
-#define _FILE_OFFSET_BITS 64
 #include "file_for_patch.h"
-#include <locale.h> // setlocale
 #include <sys/stat.h> //stat mkdir
-#ifdef _WIN32
-#   include <windows.h> //for file API, character encoding API
-#endif
-#ifndef _IS_FOR_WINXP
-#   ifdef _USING_V110_SDK71_
-#       define _IS_FOR_WINXP 1
-#   else
-#       define _IS_FOR_WINXP 0
-#   endif
-#endif
-#  ifdef _MSC_VER
-#   include <io.h>     //_chsize_s
-#   include <direct.h> // *mkdir *rmdir
-#  else
-#   include <unistd.h> // rmdir close ftruncate
-#  endif
-
-
-#if (_IS_NEED_BLOCK_DEV)
-#include <sys/types.h>
-#include <fcntl.h>
-#include <sys/ioctl.h> // ioctl
-#include <linux/fs.h> //BLKGETSIZE64
-
-static hpatch_BOOL _get_block_dev_size(const char* blkdev,hpatch_uint64_t* bsize){
-	int fd;
-    assert(blkdev&&bsize);
-
-    fd=open(blkdev,O_RDONLY);
-	if (fd == -1){
-		LOG_ERR("%s","_get_block_dev_size() open");
-		return hpatch_FALSE;
-	}
-
-	if (ioctl(fd,BLKGETSIZE64,bsize) == -1) {
-		LOG_ERR("%s","_get_block_dev_size() ioctl");
-		close(fd);
-		return hpatch_FALSE;
-	}
-
-	close(fd);
-	return hpatch_TRUE;
-}
-#endif
-
-#ifdef _WIN32
-#define  _setFileErrNo_iconv() _set_errno_new(GetLastError()==ERROR_INSUFFICIENT_BUFFER?ENAMETOOLONG:EILSEQ)
-
-int _utf8FileName_to_w(const char* fileName_utf8,wchar_t* out_fileName_w,size_t out_wSize){
-    int result=MultiByteToWideChar(_hpatch_kMultiBytePage,0,fileName_utf8,-1,out_fileName_w,(int)out_wSize);
-    if (result<=0) _setFileErrNo_iconv();
-    return result; }
-int _wFileName_to_utf8(const wchar_t* fileName_w,char* out_fileName_utf8,size_t out_bSize){
-    int result=WideCharToMultiByte(_hpatch_kMultiBytePage,0,fileName_w,-1,out_fileName_utf8,(int)out_bSize,0,0);
-    if (result<=0) _setFileErrNo_iconv();
-    return result; }
-
-hpatch_BOOL _wFileNames_to_utf8(const wchar_t** fileNames_w,size_t fileCount,
-                                char** out_fileNames_utf8,size_t out_byteSize){
-    char*   _bufEnd=((char*)out_fileNames_utf8)+out_byteSize;
-    char*   _bufCur=(char*)(&out_fileNames_utf8[fileCount]);
-    size_t i;
-    for (i=0; i<fileCount; ++i) {
-        int csize;
-        if (_bufCur>=_bufEnd) { _set_errno_new(ENAMETOOLONG); return hpatch_FALSE; } //error 
-        csize=_wFileName_to_utf8(fileNames_w[i],_bufCur,_bufEnd-_bufCur);
-        if (csize<=0) return hpatch_FALSE; //error
-        out_fileNames_utf8[i]=_bufCur;
-        _bufCur+=csize;
-    }
-    return hpatch_TRUE;
-}
-#endif
-
-#if (_IS_USED_WIN32_UTF8_WAPI)
-void SetDefaultStringLocale(){
-    setlocale(LC_CTYPE,"");
-}
-#endif
-
-int hpatch_printPath_utf8(const char* pathTxt_utf8){
-#if (_IS_USED_WIN32_UTF8_WAPI)
-    wchar_t pathTxt_w[hpatch_kPathMaxSize];
-    int wsize=_utf8FileName_to_w(pathTxt_utf8,pathTxt_w,hpatch_kPathMaxSize);
-    if (wsize>0)
-        return printf("%ls",pathTxt_w);
-    else //view unknow
-        return printf("%s",pathTxt_utf8);
-#else
-    return printf("%s",pathTxt_utf8);
-#endif
-}
-
-int hpatch_printStdErrPath_utf8(const char* pathTxt_utf8){
-#if (_IS_USED_WIN32_UTF8_WAPI)
-    wchar_t pathTxt_w[hpatch_kPathMaxSize];
-    int wsize=_utf8FileName_to_w(pathTxt_utf8,pathTxt_w,hpatch_kPathMaxSize);
-    if (wsize>0)
-        return LOG_ERR("%ls",pathTxt_w);
-    else //view unknow
-        return LOG_ERR("%s",pathTxt_utf8);
-#else
-    return LOG_ERR("%s",pathTxt_utf8);
-#endif
-}
-
-#if (_IS_FOR_WINXP)
-    #define _getStatByAttributes(_path,s,rt,_getFileAttributesFunc) {       \
-        WIN32_FILE_ATTRIBUTE_DATA fad={0};   \
-        BOOL ret=_getFileAttributesFunc(_path,GetFileExInfoStandard,&fad); \
-        if (!ret) { \
-            _set_errno_new(ENOENT); \
-            rt=-1;  \
-        }else{      \
-            s.st_mode=(fad.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)?S_IFDIR:S_IFREG;  \
-            s.st_size=fad.nFileSizeLow | (((hpatch_StreamPos_t)fad.nFileSizeHigh)<<32); \
-            rt=0;   \
-        }           \
-    }
+#include <errno.h>    //errno
+/*
+#ifdef _MSC_VER
+#   include <io.h>    //_chsize_s
 #endif
+*/
 
 hpatch_BOOL _hpatch_getPathStat_noEndDirSeparator(const char* path_utf8,hpatch_TPathType* out_type,
                                                   hpatch_StreamPos_t* out_fileSize,size_t* out_st_mode){
@@ -173,23 +56,14 @@ hpatch_BOOL _hpatch_getPathStat_noEndDirSeparator(const char* path_utf8,hpatch_T
 #if (_IS_USED_WIN32_UTF8_WAPI)
     wsize=_utf8FileName_to_w(path_utf8,path_w,hpatch_kPathMaxSize);
     if (wsize<=0) return hpatch_FALSE;
-    #if (_IS_FOR_WINXP)
-        _getStatByAttributes(path_w,s,rt,GetFileAttributesExW);
-    #else
-        rt = _wstat64(path_w,&s);
-    #endif
+    rt = _wstat64(path_w,&s);
 #else
 #   ifdef _MSC_VER
-    #if (_IS_FOR_WINXP)
-        _getStatByAttributes(path_utf8,s,rt,GetFileAttributesExA);
-    #else
-        rt = _stat64(path_utf8,&s);
-    #endif
+    rt = _stat64(path_utf8,&s);
 #   else
     rt = stat(path_utf8,&s);
 #   endif
 #endif
-    if (out_st_mode) *out_st_mode=s.st_mode;
     
     if(rt!=0){
         if (errno==ENOENT){
@@ -200,20 +74,13 @@ hpatch_BOOL _hpatch_getPathStat_noEndDirSeparator(const char* path_utf8,hpatch_T
     }else if ((s.st_mode&S_IFMT)==S_IFREG){
         *out_type=kPathType_file;
         if (out_fileSize) *out_fileSize=s.st_size;
+        if (out_st_mode) *out_st_mode=s.st_mode;
         return hpatch_TRUE;
     }else if ((s.st_mode&S_IFMT)==S_IFDIR){
         *out_type=kPathType_dir;
         if (out_fileSize) *out_fileSize=0;
+        if (out_st_mode) *out_st_mode=s.st_mode;
         return hpatch_TRUE;
-#if (_IS_NEED_BLOCK_DEV)
-    }else if ((s.st_mode&S_IFMT)==S_IFBLK){
-        hpatch_uint64_t bsize=0;
-        if (!_get_block_dev_size(path_utf8, &bsize))
-            return hpatch_FALSE;
-        *out_type=kPathType_file;
-        if (out_fileSize) *out_fileSize=bsize;
-        return hpatch_TRUE;
-#endif
     }else{
         return hpatch_FALSE; //as error; unknow how to dispose
     }
@@ -226,7 +93,7 @@ hpatch_BOOL hpatch_getTempPathName(const char* path_utf8,char* out_tempPath_utf8
     size_t i;
     size_t len=strlen(path_utf8);
     if ((len>0)&&(path_utf8[len-1]==kPatch_dirSeparator)) --len; //without '/'
-    if (len+(4+_AddingLen)>(size_t)(out_tempPath_end-out_tempPath_utf8)) { _set_errno_new(ENAMETOOLONG); return hpatch_FALSE; }
+    if (len+(4+_AddingLen)>(size_t)(out_tempPath_end-out_tempPath_utf8)) return hpatch_FALSE;
     memcpy(out_tempPath_utf8,path_utf8,len);
     out_tempPath_utf8+=len;
     for (i=1; i<1000; ++i) {
@@ -306,7 +173,7 @@ hpatch_BOOL hpatch_makeNewDir(const char* dirName_utf8){
     if (!_hpatch_getPathStat_noEndDirSeparator(path,&type,0,0)) return hpatch_FALSE; //error
     switch (type) {
         case kPathType_dir :{ return hpatch_TRUE; } break; //exist
-        case kPathType_file:{ _set_errno_new(EPERM); return hpatch_FALSE; } break; //error, not overwite
+        case kPathType_file:{ return hpatch_FALSE; } break; //error, not overwite
         case kPathType_notExist:{
 #if (_IS_USED_WIN32_UTF8_WAPI)
             int     wsize;
@@ -318,12 +185,8 @@ hpatch_BOOL hpatch_makeNewDir(const char* dirName_utf8){
 #   ifdef _MSC_VER
             return 0==_mkdir(path);
 #   else
-#       if defined(__MINGW32__) && defined(_WIN32)
-            return 0==mkdir(path);
-#       else
             const mode_t kDefalutMode=S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;//0755
             return 0==mkdir(path,kDefalutMode);
-#       endif
 #   endif
 #endif
         } break;
@@ -356,77 +219,32 @@ hpatch_BOOL hpatch_setIsExecuteFile(const char* fileName){
 #endif
 }
 
-hpatch_BOOL hpatch_getIsAtty(hpatch_FileHandle fileHandle){
-#ifdef _WIN32
-    int fno=_fileno(fileHandle);
-    if (fno==-1) return hpatch_FALSE;
-    return (_isatty(fno)!=0);
-#else
-    int fno=fileno(fileHandle);
-    if (fno==-1) return hpatch_FALSE;
-    return (isatty(fno)!=0);
-#endif
-}
-
-#if defined(ANDROID) && (__ANDROID_API__ < 24)
-#include <sys/types.h>
-#include <unistd.h>
-static off64_t _import_lseek64(hpatch_FileHandle file,hpatch_StreamPos_t seekPos,int whence){
-    int fd;
-    if (feof(file)){
-        if (whence==SEEK_CUR)
-            return -1;
-        rewind(file);
-    }
-    setbuf(file,NULL);
-    fd = fileno(file);
-    if (fd<0) return -1;
-    return lseek64(fd,seekPos,whence);
-}
-#endif
 
 hpatch_inline static
-hpatch_BOOL _import_fileSeek64(hpatch_FileHandle file,hpatch_StreamPos_t seekPos,int whence){
+hpatch_BOOL _import_fileTell64(hpatch_FileHandle file,hpatch_StreamPos_t* out_pos){
 #ifdef _MSC_VER
-    return _fseeki64(file,seekPos,whence)==0;
+    __int64 fpos=_ftelli64(file);
 #else
-# ifdef ANDROID
-#  if __ANDROID_API__ >= 24
-    return fseeko64(file,seekPos,whence)==0;
-#  else
-    if ((((off64_t)seekPos)==((long)seekPos))&&(whence==SEEK_SET)) return fseek(file,(long)seekPos,whence)==0;
-    else return _import_lseek64(file,seekPos,whence)>=0;
-#  endif
-# else
-    return fseeko(file,seekPos,whence)==0;
-# endif
+    off_t fpos=ftello(file);
 #endif
+    hpatch_BOOL result=(fpos>=0);
+    if (result) *out_pos=fpos;
+    return result;
 }
 
 hpatch_inline static
-hpatch_BOOL _import_fileSeek64To(hpatch_FileHandle file,hpatch_StreamPos_t seekPos){
-    return _import_fileSeek64(file,seekPos,SEEK_SET);
-}
-
-hpatch_inline static
-hpatch_BOOL _import_fileTell64(hpatch_FileHandle file,hpatch_StreamPos_t* outPos){
+hpatch_BOOL _import_fileSeek64(hpatch_FileHandle file,hpatch_StreamPos_t seekPos,int whence){
 #ifdef _MSC_VER
-    __int64 pos=_ftelli64(file);
+    int ret=_fseeki64(file,seekPos,whence);
 #else
-# ifdef ANDROID
-#  if __ANDROID_API__ >= 24
-    off64_t pos=ftello64(file);
-#  else
-    off64_t pos=_import_lseek64(file,0,SEEK_CUR);
-#  endif
-# else
-    off_t pos=ftello(file);
-# endif
+    off_t fpos=seekPos;
+    if ((fpos<0)||((hpatch_StreamPos_t)fpos!=seekPos)) return hpatch_FALSE;
+    int ret=fseeko(file,fpos,whence);
 #endif
-    *outPos=(hpatch_StreamPos_t)pos;
-    return (pos>=0);
+    return (ret==0);
 }
 
+
 hpatch_inline static
 hpatch_BOOL _import_fileClose(hpatch_FileHandle* pfile){
     hpatch_FileHandle file=*pfile;
@@ -437,17 +255,6 @@ hpatch_BOOL _import_fileClose(hpatch_FileHandle* pfile){
     }
     return hpatch_TRUE;
 }
-#if (_HPATCH_IS_USED_errno)
-    hpatch_inline static
-    hpatch_BOOL _import_fileClose_No_errno(hpatch_FileHandle* pfile){
-        int err=errno;
-        hpatch_BOOL result=_import_fileClose(pfile); 
-        if (err) _set_errno_new(err);
-        return result;
-    }
-#else
-#   define  _import_fileClose_No_errno(pfile) _import_fileClose(pfile)
-#endif
 
 hpatch_BOOL _import_fileRead(hpatch_FileHandle file,TByte* buf,TByte* buf_end){
     while (buf<buf_end) {
@@ -474,6 +281,7 @@ hpatch_BOOL _import_fileFlush(hpatch_FileHandle writedFile){
     return (0==fflush(writedFile));
 }
 
+/* // retained data error
 hpatch_BOOL _import_fileTruncate(hpatch_FileHandle file,hpatch_StreamPos_t new_file_length){
 #ifdef _MSC_VER
     int fno=_fileno(file);
@@ -485,105 +293,96 @@ hpatch_BOOL _import_fileTruncate(hpatch_FileHandle file,hpatch_StreamPos_t new_f
     if (ftruncate(fno,new_file_length)!=0) return hpatch_FALSE;
 #endif
     return hpatch_TRUE;
-}
+}*/
 
 #if (_IS_USED_WIN32_UTF8_WAPI)
-#   define _FileModeType const wchar_t*
 #   define _kFileReadMode  L"rb"
 #   define _kFileWriteMode L"wb+"
 #   define _kFileReadWriteMode L"rb+"
 #else
-#   define _FileModeType const char*
 #   define _kFileReadMode  "rb"
 #   define _kFileWriteMode "wb+"
 #   define _kFileReadWriteMode "rb+"
 #endif
 
 #if (_IS_USED_WIN32_UTF8_WAPI)
-hpatch_force_inline static
-hpatch_FileHandle __import_fileOpen(const char* fileName_utf8,_FileModeType mode_w){
+static hpatch_FileHandle _import_fileOpenByMode(const char* fileName_utf8,const wchar_t* mode_w){
     wchar_t fileName_w[hpatch_kPathMaxSize];
     int wsize=_utf8FileName_to_w(fileName_utf8,fileName_w,hpatch_kPathMaxSize);
-    if (wsize>0)
-        return _wfsopen(fileName_w,mode_w,_SH_DENYNO);
-    else
+    if (wsize>0) {
+# if (_MSC_VER>=1400) // VC2005
+        hpatch_FileHandle file=0;
+        errno_t err=_wfopen_s(&file,fileName_w,mode_w);
+        return (err==0)?file:0;
+# else
+        return _wfopen(fileName_w,mode_w);
+# endif
+    }else{
         return 0;
+    }
 }
 #else
-hpatch_force_inline static
-hpatch_FileHandle __import_fileOpen(const char* fileName_utf8,_FileModeType mode){
+hpatch_inline static
+hpatch_FileHandle _import_fileOpenByMode(const char* fileName_utf8,const char* mode){
     return fopen(fileName_utf8,mode); }
 #endif
 
-hpatch_force_inline static
-hpatch_FileHandle _import_fileOpen(const char* fileName_utf8,_FileModeType mode){
-    hpatch_FileHandle result=__import_fileOpen(fileName_utf8,mode); 
-    //used default vbuf?  if (result) setvbuf(result,0,_IONBF,0);
-    return result;
-}
-
-static hpatch_FileHandle _import_fileOpenWithSize(const char* fileName_utf8,_FileModeType mode,hpatch_StreamPos_t* out_fileSize){
-    hpatch_FileHandle file=0;
-    file=_import_fileOpen(fileName_utf8,mode);
-    if ((out_fileSize==0)||(file==0)) return file;
-    
-    if (_import_fileSeek64(file,0,SEEK_END)){
-        if (_import_fileTell64(file,out_fileSize)){
-            if (_import_fileSeek64(file,0,SEEK_SET)){
-                return file;
-            }
-        }
-    }
-
-    //error clear
-    _import_fileClose(&file);
-    return 0;
+#define _file_error(fileHandle){ \
+    if (fileHandle) _import_fileClose(&fileHandle); \
+    return hpatch_FALSE; \
 }
 
-static hpatch_inline
 hpatch_BOOL _import_fileOpenRead(const char* fileName_utf8,hpatch_FileHandle* out_fileHandle,
-                                 hpatch_StreamPos_t* out_fileSize){
+                                 hpatch_StreamPos_t* out_fileLength){
     hpatch_FileHandle file=0;
     assert(out_fileHandle!=0);
-    if (out_fileHandle==0) { _set_errno_new(EINVAL); return hpatch_FALSE; }
-    file=_import_fileOpenWithSize(fileName_utf8,_kFileReadMode,out_fileSize);
-    if (file==0) return hpatch_FALSE;
+    if (out_fileHandle==0) _file_error(file);
+    file=_import_fileOpenByMode(fileName_utf8,_kFileReadMode);
+    if (file==0) _file_error(file);
+    if (out_fileLength!=0){
+        hpatch_StreamPos_t file_length=0;
+        if (!_import_fileSeek64(file,0,SEEK_END)) _file_error(file);
+        if (!_import_fileTell64(file,&file_length)) _file_error(file);
+        if (!_import_fileSeek64(file,0,SEEK_SET)) _file_error(file);
+        *out_fileLength=file_length;
+    }
     *out_fileHandle=file;
     return hpatch_TRUE;
 }
 
-static hpatch_inline
 hpatch_BOOL _import_fileOpenCreateOrReWrite(const char* fileName_utf8,hpatch_FileHandle* out_fileHandle){
     hpatch_FileHandle file=0;
     assert(out_fileHandle!=0);
-    if (out_fileHandle==0) { _set_errno_new(EINVAL); return hpatch_FALSE; }
-    file=_import_fileOpen(fileName_utf8,_kFileWriteMode);
-    if (file==0) return hpatch_FALSE;
+    if (out_fileHandle==0) _file_error(file);
+    file=_import_fileOpenByMode(fileName_utf8,_kFileWriteMode);
+    if (file==0) _file_error(file);
     *out_fileHandle=file;
     return hpatch_TRUE;
 }
 
-static
 hpatch_BOOL _import_fileReopenWrite(const char* fileName_utf8,hpatch_FileHandle* out_fileHandle,
                                     hpatch_StreamPos_t* out_curFileWritePos){
     hpatch_FileHandle file=0;
-    hpatch_StreamPos_t curFileSize=0;
     assert(out_fileHandle!=0);
-    if (out_fileHandle==0) { _set_errno_new(EINVAL); return hpatch_FALSE; }
-    file=_import_fileOpenWithSize(fileName_utf8,_kFileReadWriteMode,&curFileSize);
-    if (file==0) return hpatch_FALSE;
-    if (out_curFileWritePos!=0) *out_curFileWritePos=curFileSize;
-    if (!_import_fileSeek64To(file,curFileSize))  
-        { _import_fileClose_No_errno(&file); return hpatch_FALSE; }
+    if (out_fileHandle==0) _file_error(file);
+    file=_import_fileOpenByMode(fileName_utf8,_kFileReadWriteMode);
+    if (file==0) _file_error(file);
+    if (!_import_fileSeek64(file,0,SEEK_END)) _file_error(file);
+    if (out_curFileWritePos!=0){
+        hpatch_StreamPos_t file_length=0;
+        if (!_import_fileTell64(file,&file_length)) _file_error(file);
+        *out_curFileWritePos=file_length;
+    }
     *out_fileHandle=file;
     return hpatch_TRUE;
 }
 
 
-#define _ferr_return()          { _update_ferr(self->fileError);   return hpatch_FALSE; }
-#define _ferr_returnv(v)        { _update_ferrv(self->fileError,v); return hpatch_FALSE; }
-#define _rw_ferr_return()       { self->m_fpos=hpatch_kNullStreamPos; _ferr_return(); }
-#define _rw_ferr_returnv(v)     { self->m_fpos=hpatch_kNullStreamPos; _ferr_returnv(v); }
+
+#undef _file_error
+
+
+#define _fileError_return { self->fileError=hpatch_TRUE; self->m_fpos=~(hpatch_StreamPos_t)0; return hpatch_FALSE; }
 
     static hpatch_BOOL _TFileStreamInput_read_file(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
                                                    TByte* out_data,TByte* out_data_end){
@@ -593,45 +392,43 @@ hpatch_BOOL _import_fileReopenWrite(const char* fileName_utf8,hpatch_FileHandle*
         readLen=(size_t)(out_data_end-out_data);
         if (readLen==0) return hpatch_TRUE;
         if ((readLen>self->base.streamSize)
-            ||(readFromPos>self->base.streamSize-readLen)) _ferr_returnv(EFBIG);
+            ||(readFromPos>self->base.streamSize-readLen)) _fileError_return;
         if (self->m_fpos!=readFromPos+self->m_offset){
-            if (!_import_fileSeek64To(self->m_file,readFromPos+self->m_offset)) _rw_ferr_return();
+            if (!_import_fileSeek64(self->m_file,readFromPos+self->m_offset,SEEK_SET)) _fileError_return;
         }
-        if (!_import_fileRead(self->m_file,out_data,out_data+readLen)) _rw_ferr_return();
+        if (!_import_fileRead(self->m_file,out_data,out_data+readLen)) _fileError_return;
         self->m_fpos=readFromPos+self->m_offset+readLen;
         return hpatch_TRUE;
     }
 
 hpatch_BOOL hpatch_TFileStreamInput_open(hpatch_TFileStreamInput* self,const char* fileName_utf8){
     assert(self->m_file==0);
-    self->fileError=hpatch_FALSE;
-    if (self->m_file) _ferr_returnv(EINVAL);
-    if (!_import_fileOpenRead(fileName_utf8,&self->m_file,&self->base.streamSize))
-        _ferr_return();
+    if (self->m_file) return hpatch_FALSE;
+    if (!_import_fileOpenRead(fileName_utf8,&self->m_file,&self->base.streamSize)) return hpatch_FALSE;
     
     self->base.streamImport=self;
     self->base.read=_TFileStreamInput_read_file;
     self->m_fpos=0;
     self->m_offset=0;
+    self->fileError=hpatch_FALSE;
     return hpatch_TRUE;
 }
 
 hpatch_BOOL hpatch_TFileStreamInput_setOffset(hpatch_TFileStreamInput* self,hpatch_StreamPos_t offset){
     if (self->base.streamSize<offset)
-        _ferr_returnv(EFBIG);
+        return hpatch_FALSE;
     self->m_offset+=offset;
     self->base.streamSize-=offset;
     return hpatch_TRUE;
 }
 
 hpatch_BOOL hpatch_TFileStreamInput_close(hpatch_TFileStreamInput* self){
-    if (!_import_fileClose(&self->m_file)) _ferr_return();
-    return hpatch_TRUE;
+    return _import_fileClose(&self->m_file);
 }
 
 
     static hpatch_BOOL _TFileStreamOutput_write_file(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
-                                                     const TByte* data,const TByte* data_end){
+                                   const TByte* data,const TByte* data_end){
         size_t writeLen;
         hpatch_TFileStreamOutput* self=(hpatch_TFileStreamOutput*)stream->streamImport;
         assert(data<=data_end);
@@ -639,45 +436,42 @@ hpatch_BOOL hpatch_TFileStreamInput_close(hpatch_TFileStreamInput* self){
         writeLen=(size_t)(data_end-data);
         if (writeLen==0) return hpatch_TRUE;
         if ((writeLen>self->base.streamSize)
-            ||(writeToPos>self->base.streamSize-writeLen)) _ferr_returnv(EFBIG);
+            ||(writeToPos>self->base.streamSize-writeLen)) _fileError_return;
         if (self->is_in_readModel){
             self->is_in_readModel=hpatch_FALSE;
-            self->m_fpos=hpatch_kNullStreamPos;
+            self->m_fpos=~(hpatch_StreamPos_t)0;
         }
         if (writeToPos!=self->m_fpos){
             if (self->is_random_out){
-                if (!_import_fileFlush(self->m_file)) _rw_ferr_return(); //for lseek64 safe
-                if (!_import_fileSeek64To(self->m_file,writeToPos)) _rw_ferr_return();
+                if (!_import_fileSeek64(self->m_file,writeToPos,SEEK_SET)) _fileError_return;
                 self->m_fpos=writeToPos;
             }else{
-                _ferr_returnv(ERANGE); //must continue write at self->m_fpos
+                _fileError_return;
             }
         }
-        if (!_import_fileWrite(self->m_file,data,data+writeLen)) _rw_ferr_return();
+        if (!_import_fileWrite(self->m_file,data,data+writeLen)) _fileError_return;
         self->m_fpos=writeToPos+writeLen;
         self->out_length=(self->out_length>=self->m_fpos)?self->out_length:self->m_fpos;
         return hpatch_TRUE;
     }
     static hpatch_BOOL _hpatch_TFileStreamOutput_read_file(const hpatch_TStreamOutput* stream,
-                                                           hpatch_StreamPos_t readFromPos,
-                                                           TByte* out_data,TByte* out_data_end){
+                                                    hpatch_StreamPos_t readFromPos,
+                                                    TByte* out_data,TByte* out_data_end){
          //hpatch_TFileStreamOutput is A hpatch_TFileStreamInput !
         hpatch_TFileStreamOutput* self=(hpatch_TFileStreamOutput*)stream->streamImport;
         const hpatch_TStreamInput* in_stream=(const hpatch_TStreamInput*)stream;
         if (!self->is_in_readModel){
-            if (!hpatch_TFileStreamOutput_flush(self)) _rw_ferr_return();
+            if (!hpatch_TFileStreamOutput_flush(self)) return hpatch_FALSE;
             self->is_in_readModel=hpatch_TRUE;
-            self->m_fpos=hpatch_kNullStreamPos;
+            self->m_fpos=~(hpatch_StreamPos_t)0;
         }
         return _TFileStreamInput_read_file(in_stream,readFromPos,out_data,out_data_end);
     }
 hpatch_BOOL hpatch_TFileStreamOutput_open(hpatch_TFileStreamOutput* self,const char* fileName_utf8,
                                           hpatch_StreamPos_t max_file_length){
     assert(self->m_file==0);
-    self->fileError=hpatch_FALSE;
-    if (self->m_file) _ferr_returnv(EINVAL);
-    if (!_import_fileOpenCreateOrReWrite(fileName_utf8,&self->m_file))
-        _ferr_return();
+    if (self->m_file) return hpatch_FALSE;
+    if (!_import_fileOpenCreateOrReWrite(fileName_utf8,&self->m_file)) return hpatch_FALSE;
     
     self->base.streamImport=self;
     self->base.streamSize=max_file_length;
@@ -685,6 +479,7 @@ hpatch_BOOL hpatch_TFileStreamOutput_open(hpatch_TFileStreamOutput* self,const c
     self->base.write=_TFileStreamOutput_write_file;
     self->m_fpos=0;
     self->m_offset=0;
+    self->fileError=hpatch_FALSE;
     self->is_in_readModel=hpatch_FALSE;
     self->is_random_out=hpatch_FALSE;
     self->out_length=0;
@@ -694,14 +489,13 @@ hpatch_BOOL hpatch_TFileStreamOutput_reopen(hpatch_TFileStreamOutput* self,const
                                             hpatch_StreamPos_t max_file_length){
     hpatch_StreamPos_t curFileWritePos=0;
     assert(self->m_file==0);
-    self->fileError=hpatch_FALSE;
-    if (self->m_file) _ferr_returnv(EINVAL);
+    if (self->m_file) return hpatch_FALSE;
     if (!_import_fileReopenWrite(fileName_utf8,&self->m_file,&curFileWritePos))
-       _ferr_return();
+        return hpatch_FALSE;
     if (curFileWritePos>max_file_length){
         //note: now not support reset file length to max_file_length
         _import_fileClose(&self->m_file);
-        _ferr_returnv(EFBIG);
+        return hpatch_FALSE;
     }
     self->base.streamImport=self;
     self->base.streamSize=max_file_length;
@@ -709,27 +503,22 @@ hpatch_BOOL hpatch_TFileStreamOutput_reopen(hpatch_TFileStreamOutput* self,const
     self->base.write=_TFileStreamOutput_write_file;
     self->m_fpos=curFileWritePos;
     self->m_offset=0;
+    self->fileError=hpatch_FALSE;
     self->is_in_readModel=hpatch_FALSE;
     self->is_random_out=hpatch_FALSE;
     self->out_length=curFileWritePos;
     return hpatch_TRUE;
 }
 
-
+/*
 hpatch_BOOL hpatch_TFileStreamOutput_truncate(hpatch_TFileStreamOutput* self,hpatch_StreamPos_t new_file_length){
-    if (!_import_fileTruncate(self->m_file,new_file_length)) 
-        _ferr_return();
-    return hpatch_TRUE;
-}
+    return _import_fileTruncate(self->m_file,new_file_length);
+}*/
 
 hpatch_BOOL hpatch_TFileStreamOutput_flush(hpatch_TFileStreamOutput* self){
-    if (!_import_fileFlush(self->m_file)) 
-        _ferr_return();
-    return hpatch_TRUE;
+    return _import_fileFlush(self->m_file);
 }
 
 hpatch_BOOL hpatch_TFileStreamOutput_close(hpatch_TFileStreamOutput* self){
-    if (!_import_fileClose(&self->m_file))
-        _ferr_return();
-    return hpatch_TRUE;
+    return _import_fileClose(&self->m_file);
 }