//----------------------------------------------------------------------- size_t ZipDataStream::tell(void) const { zzip_off_t pos = zzip_tell(mZzipFile); if (pos<0) return (size_t)(-1); return static_cast<size_t>(pos) - mCache.avail(); }
size_t getEntry(const char *name, char *contentFile, char **ptr) { size_t size=0; ZZIP_DIR *dir; ZZIP_DIRENT entry; ZZIP_FILE *file; char *buf; dir = zzip_dir_open(name, 0); if (!dir) { fprintf(stderr, "failed to open %s\n", name); return 0; } zzip_dir_read(dir, &entry); file = zzip_file_open(dir, contentFile, 0); (void)zzip_seek(file, 0, SEEK_END); size = zzip_tell(file); (void)zzip_seek(file, 0, SEEK_SET); buf = (char *)malloc(size+1); (void)zzip_read(file, buf, size); buf[size] = '\0'; *ptr = buf; zzip_file_close(file); zzip_dir_close(dir); return size; }
/** => zzip_tell * This function is provided for users who can not use any largefile-mode. */ long zzip_tell32(ZZIP_FILE * fp) { if (sizeof(zzip_off_t) == sizeof(long)) { return zzip_tell(fp); } else { off_t off = zzip_tell(fp); if (off >= 0) { register long off32 = off; if (off32 == off) return off32; #ifdef ZZIP_DISABLED errno = EOVERFLOW; #endif /* ZZIP_DISABLED */ } return -1; } }
int ACEXML_ZipCharStream::available (void) { if (this->infile_ == 0) return -1; long curr; if ((curr = zzip_tell (this->infile_)) < 0) return -1; return (this->size_ - curr); }
u32 ZIPROMReaderSize(void * file) { u32 size; zzip_seek((ZZIP_FILE*)file, 0, SEEK_END); size = zzip_tell((ZZIP_FILE*)file); zzip_seek((ZZIP_FILE*)file, 0, SEEK_SET); return size; }
// Reads line from UTF-8 encoded text file. // File must be open in binary read mode. // ATTENTION: if buffer is not large enough, the zzip_fread will fail // and ReadULine will return , but you will not be able to know if it returned // for a string overflow (managed) or because it reached EOF! bool ReadULine(ZZIP_FILE* fp, TCHAR *unicode, int maxChars) { // This is a char, and we need space for at least MAX_HELP TCHARS! // unsigned char buf[1500 * 2]; long startPos = zzip_tell(fp); if (startPos < 0) { StartupStore(_T(". ftell() error = %d%s"), errno, NEWLINE); return(false); } size_t nbRead = zzip_fread(buf, 1, sizeof(buf) - 1, fp); if (nbRead == 0) return(false); buf[nbRead] = '\0'; // find new line (CR/LF/CRLF) in the string and terminate string at that position size_t i; for (i = 0; i < nbRead; i++) { if (buf[i] == '\n') { buf[i++] = '\0'; if (buf[i] == '\r') i++; break; } if (buf[i] == '\r') { buf[i++] = '\0'; if (buf[i] == '\n') i++; break; } } // next reading will continue after new line zzip_seek(fp, startPos + i, SEEK_SET); // skip leading BOM char* begin = (char*) buf; if (buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF) begin += 3; return(utf2unicode(begin, unicode, maxChars) >= 0); }
std::future<void*> ResourceManager::LoadSound(const char* filepath, void* _fSystem) { #ifdef _CACH_PARSED_DATA_ for (std::map<const char*, SoundData*>::iterator it = mSoundResource.begin(); it != mSoundResource.end(); it++) { if (it->first == filepath) return mThreadPool.AddTask<LoadSoundTask>(it->second->buffer, it->second->bufferSize, &mGlLock, _fSystem); } #endif unsigned int bufferSize; unsigned char* buffer; switch (mAssetPacketExtension) { case PACA: bufferSize = mPacaReader.GetResourceSize(filepath); buffer = new unsigned char[bufferSize]; if (mPacaReader.GetResource(filepath, buffer, bufferSize)) { #ifdef _CACH_PARSED_DATA_ SoundData* sd = new SoundData(); sd->buffer = buffer; sd->bufferSize = bufferSize; mSoundResource.insert(std::pair<const char*, SoundData*>(filepath, sd)); #endif return mThreadPool.AddTask<LoadSoundTask>(buffer, bufferSize, &mGlLock, _fSystem); } break; case ZIP: ZZIP_FILE* fp = zzip_file_open(mDir, filepath, 0); zzip_seek(fp, 0, SEEK_END); bufferSize = zzip_tell(fp); zzip_rewind(fp); buffer = new unsigned char[bufferSize]; bufferSize = zzip_file_read(fp, buffer, static_cast<int>(bufferSize)); zzip_file_close(fp); #ifdef _CACH_PARSED_DATA_ SoundData* sd = new SoundData(); sd->buffer = buffer; sd->bufferSize = bufferSize; mSoundResource.insert(std::pair<const char*, SoundData*>(filepath, sd)); #endif return mThreadPool.AddTask<LoadSoundTask>(buffer, bufferSize, &mGlLock, _fSystem); } }
static int ff_seek (lua_State *L) { static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END}; static const char *const modenames[] = {"set", "cur", "end", NULL}; ZZIP_FILE *f = tointernalfile(L, 1); int op = luaL_checkoption(L, 2, "cur", modenames); long offset = luaL_optlong(L, 3, 0); luaL_argcheck(L, op != -1, 2, "invalid mode"); op = zzip_seek(f, offset, mode[op]); if (op < 0) return pushresult(L, 0, NULL); /* error */ else { lua_pushnumber(L, zzip_tell(f)); return 1; } }
TextureResource* ResourceManager::LoadTexture( const char* file) { #ifdef _CACH_PARSED_DATA_ for (std::map<const char*, TextureResource*>::iterator it = mTextureResource.begin(); it != mTextureResource.end(); it++) { if (it->first == file) return it->second; } #endif unsigned int bufferSize; unsigned char* buffer; switch ( mAssetPacketExtension ) { case PACA: bufferSize = mPacaReader.GetResourceSize(file); buffer = new unsigned char[bufferSize]; if ( mPacaReader.GetResource(file, buffer, bufferSize ) ) { TextureResource* textureResource = new TextureResource(); textureResource->future = mThreadPool.AddTask<LoadTextureTask>(buffer, bufferSize, &mGlLock); #ifdef _CACH_PARSED_DATA_ mTextureResource.insert(std::pair<const char*, TextureResource*>(file, textureResource)); #endif return textureResource; } break; case ZIP: ZZIP_FILE* fp = zzip_file_open( mDir, file, 0 ); zzip_seek( fp, 0, SEEK_END ); bufferSize = zzip_tell( fp ); zzip_rewind( fp ); buffer = new unsigned char[bufferSize]; bufferSize = zzip_file_read( fp, buffer, static_cast<int>( bufferSize ) ); zzip_file_close( fp ); TextureResource* textureResource = new TextureResource(); textureResource->future = mThreadPool.AddTask<LoadTextureTask>(buffer, bufferSize, &mGlLock); #ifdef _CACH_PARSED_DATA_ mTextureResource.insert(std::pair<const char*, TextureResource*>(file, textureResource)); #endif return textureResource; } }
BOOL ReadString(ZZIP_FILE *zFile, int Max, TCHAR *String) { char sTmp[READLINE_LENGTH+1]; char FileBuffer[READLINE_LENGTH+1]; long dwNumBytesRead=0; long dwTotalNumBytesRead=0; long dwFilePos; String[0] = '\0'; sTmp[0] = 0; #if BUGSTOP LKASSERT((unsigned)Max<sizeof(sTmp)); #endif if (Max >= (int)(sizeof(sTmp))) return(FALSE); if (!zFile) return(FALSE); dwFilePos = zzip_tell(zFile); dwNumBytesRead = zzip_fread(FileBuffer, 1, Max, zFile); if (dwNumBytesRead <= 0) return(FALSE); int i = 0; int j = 0; while((i<Max) && (j<(int)dwNumBytesRead)) { char c = FileBuffer[j]; j++; dwTotalNumBytesRead++; if((c == '\n')){ break; } sTmp[i] = c; i++; } sTmp[i] = 0; zzip_seek(zFile, dwFilePos+j, SEEK_SET); sTmp[Max-1] = '\0'; mbstowcs(String, sTmp, strlen(sTmp)+1); return (dwTotalNumBytesRead>0); }
PSAR_ENTRY *LPP_PsarDecoder_getEntry(const char *filename) { if(!initialized) return NULL; zzip_strings_t ext[] = {"", 0}; ZZIP_FILE *fd = zzip_open_ext_io(filename, O_RDONLY | (0x0), ZZIP_ONLYZIP, ext, &psar_handlers); if(fd == NULL) { #ifdef DEBUG dwrite_output("Function %s Line %d : Cannot open the file '%s' for read.\n", __FUNCTION__, __LINE__, filename); #endif return NULL; } PSAR_ENTRY *entry = (PSAR_ENTRY*)malloc(sizeof(PSAR_ENTRY)); if(!entry) { #ifdef DEBUG dwrite_output("Function %s Line %d : Cannot allocate 'entry' to memory.\n", __FUNCTION__, __LINE__); #endif zzip_close(fd); return NULL; } memset(entry, 0, sizeof(PSAR_ENTRY)); zzip_seek(fd, 0, SEEK_END); entry->len = zzip_tell(fd); zzip_rewind(fd); if(entry->len <= 0) { free(entry); zzip_fclose(fd); #ifdef DEBUG dwrite_output("Function %s Line %d : file len is lower than zero.\n", __FUNCTION__, __LINE__); #endif return NULL; } entry->data = (u8*)malloc(entry->len); zzip_fread(entry->data, 1, entry->len, fd); zzip_fclose(fd); return(entry); }
size_t getEntry(const char *name, char *contentFile, char **ptr) { size_t size=0; ZZIP_DIR *dir; ZZIP_DIRENT entry; ZZIP_FILE *file; zzip_error_t error; char *buf; o_log(DEBUGM, "opening %s", name); dir = zzip_dir_open(name, &error); if (!dir) { o_log(ERROR, "failed to open %s", name); return 0; } while(zzip_dir_read(dir, &entry)) { if( 0 == strcmp(entry.d_name, contentFile) ) { file = zzip_file_open(dir, contentFile, O_RDONLY); (void)zzip_seek(file, 0, SEEK_END); size = zzip_tell(file); (void)zzip_seek(file, 0, SEEK_SET); buf = (char *)malloc(size+1); (void)zzip_read(file, buf, size); buf[size] = '\0'; *ptr = buf; zzip_file_close(file); } } zzip_dir_close(dir); return size; }
//----------------------------------------------------------------------- bool ZipDataStream::eof(void) const { return (zzip_tell(mZzipFile) >= static_cast<zzip_off_t>(mSize)); }
//----------------------------------------------------------------------- size_t ZipDataStream::tell(void) const { return zzip_tell(mZzipFile); }
bool CZipIOAccess::Eof( void ) const {GUCEF_TRACE; return (zzip_tell( m_zzipFile ) >= static_cast<zzip_off_t>( m_size ) ); }
CORE::UInt32 CZipIOAccess::Tell( void ) const {GUCEF_TRACE; return (CORE::UInt32) zzip_tell( m_zzipFile ); }
static void ReadAirspace(AirspaceDatabase &airspace_database, ZZIP_FILE *fp) { StartupStore(TEXT("ReadAirspace\n")); int Tock = 0; DWORD dwStep; DWORD dwPos; DWORD dwOldPos = 0L; int nLineType; unsigned NumberOfAirspacePointsPass[2] = { 0, 0 }; unsigned NumberOfAirspaceAreasPass[2] = { 0, 0 }; unsigned NumberOfAirspaceCirclesPass[2] = { 0, 0 }; LineCount = 0; airspace_database.SetQNH(QNH); XCSoarInterface::CreateProgressDialog(gettext(TEXT("Loading Airspace File..."))); // Need step size finer than default 10 XCSoarInterface::SetProgressStepSize(5); dwStep = zzip_file_size(fp) / 10L; TempArea.FirstPoint = airspace_database.NumberOfAirspacePoints; bFillMode = false; bWaiting = true; XCSoarInterface::StepProgressDialog(); while((nLineType = GetNextLine(fp, TempString)) >= 0) { Tock++; Tock %= 50; if (Tock == 0) { dwPos = zzip_tell(fp); if ((dwPos - dwOldPos) >= dwStep) { XCSoarInterface::StepProgressDialog(); dwOldPos = dwPos; } } if (!ParseLine(airspace_database, nLineType, NumberOfAirspacePointsPass[0], NumberOfAirspaceAreasPass[0], NumberOfAirspaceCirclesPass[0])) { CloseAirspace(airspace_database); return; } } // Process final area (if any). bFillMode is false. JG 10-Nov-2005 if (!bWaiting) NumberOfAirspaceAreasPass[0]++; // ???? // allocate new memory size_t screen_point_size = (airspace_database.NumberOfAirspacePoints + NumberOfAirspacePointsPass[0]) * sizeof(AirspaceScreenPoint[0]); POINT *new_points = AirspaceScreenPoint == NULL ? (POINT *)LocalAlloc(LMEM_FIXED, screen_point_size) : (POINT *)LocalReAlloc(AirspaceScreenPoint, LMEM_FIXED, screen_point_size); if (new_points != NULL) AirspaceScreenPoint = new_points; if ((screen_point_size > 0 && new_points == NULL) || !airspace_database.GrowPoints(NumberOfAirspacePointsPass[0]) || !airspace_database.GrowAreas(NumberOfAirspaceAreasPass[0]) || !airspace_database.GrowCircles(NumberOfAirspaceCirclesPass[0])) { // can't allocate memory, so delete everything airspace_database.Clear(); if (AirspaceScreenPoint != NULL) { LocalFree((HLOCAL)AirspaceScreenPoint); AirspaceScreenPoint = NULL; } return; } // ok, start the read TempArea.FirstPoint = airspace_database.NumberOfAirspacePoints; zzip_seek(fp, 0, SEEK_SET ); LineCount = -1; bFillMode = true; bWaiting = true; dwOldPos = 0L; XCSoarInterface::StepProgressDialog(); CenterY = CenterX = 0; Rotation = 1; while((nLineType = GetNextLine(fp, TempString)) >= 0) { Tock++; Tock %= 50; if (Tock == 0) { dwPos = zzip_tell(fp); if ((dwPos - dwOldPos) >= dwStep) { XCSoarInterface::StepProgressDialog(); dwOldPos = dwPos; } } ParseLine(airspace_database, nLineType, NumberOfAirspacePointsPass[1], NumberOfAirspaceAreasPass[1], NumberOfAirspaceCirclesPass[1]); } // Process final area (if any). bFillMode is true. JG 10-Nov-2005 if (!bWaiting) AddArea(airspace_database, &TempArea, NumberOfAirspaceAreasPass[1]); if (NumberOfAirspacePointsPass[0] != NumberOfAirspacePointsPass[1] || NumberOfAirspaceAreasPass[0] != NumberOfAirspaceAreasPass[1] || NumberOfAirspaceCirclesPass[0] != NumberOfAirspaceCirclesPass[1]){ if (MessageBoxX(gettext(TEXT("Internal Airspace Parser Error!\r\nPlease send this Airspacefile to Support")), gettext(TEXT("Airspace")), MB_OKCANCEL) == IDCANCEL) { } } #ifndef NDEBUG // only do this if debugging DumpAirspaceFile(airspace_database); #endif // if(AirspacePoint != NULL) LocalFree((HLOCAL)AirspacePoint); }
ModelFileParser* ResourceManager::LoadModel(const char* file) { #ifdef _CACH_PARSED_DATA_ for (std::map<const char*, ModelFileParser*>::iterator it = mModelFileParsers.begin(); it != mModelFileParsers.end(); it++) { if (it->first == file) return it->second; } #endif unsigned int bufferSize; char* buffer; switch ( mAssetPacketExtension ) { case PACA: { bufferSize = mPacaReader.GetResourceSize( file ); buffer = new char[bufferSize]; if ( !mPacaReader.GetResource( file, buffer, bufferSize ) ) return nullptr; break; } break; case ZIP: { ZZIP_FILE* fp = zzip_file_open( mDir, file, 0 ); zzip_seek( fp, 0, SEEK_END ); bufferSize = zzip_tell( fp ); zzip_rewind( fp ); buffer = new char[bufferSize]; bufferSize = zzip_file_read( fp, buffer, bufferSize ); zzip_file_close( fp ); } break; } addToMemCount(bufferSize); ModelFileParser* mParser; std::string fileString; fileString = std::string(file); if (fileString.substr(fileString.find_last_of(".") + 1) == "mesh") { mParser = new MeshParser(); addToMemCount(sizeof(mParser)); } else if (fileString.substr(fileString.find_last_of(".") + 1) == "obj") { mParser = new ObjParser(); addToMemCount(sizeof(mParser)); } else { delete[] buffer; addToMemCount(-bufferSize); return NULL; } mParser->Load(buffer, bufferSize); addToMemCount(mParser->memory); delete[] buffer; addToMemCount(-bufferSize); #ifdef _CACH_PARSED_DATA_ mModelFileParsers.insert(std::pair<const char*, ModelFileParser*>(file, mParser)); #endif return mParser; }
/** 检查ZIP文件指针是否到达末尾 */ bool FZipFileStream::Eof(void) const { return zzip_tell(m_pZipFile) >= static_cast<zzip_off_t>(m_nStreamSize); }
/** * This function will perform a => lseek(2) operation on a real/zipped file * * It will try to seek to the offset specified by offset, relative to whence, * which is one of SEEK_SET, SEEK_CUR or SEEK_END. * * If the file-handle is wrapping a stat'able file then it will actually just * perform a normal => lseek(2)-call. Otherwise the relative offset * is calculated, negative offsets are transformed into positive ones * by rewinding the file, and then data is read until the offset is * reached. This can make the function terribly slow, but this is * how gzio implements it, so I'm not sure there is a better way * without using the internals of the algorithm. */ zzip_off_t zzip_seek(ZZIP_FILE * fp, zzip_off_t offset, int whence) { zzip_off_t cur_pos, rel_ofs, read_size, ofs; ZZIP_DIR *dir; if (! fp) return -1; if (! fp->dir) { /* stat fd */ return fp->io->fd.seeks(fp->fd, offset, whence); } cur_pos = zzip_tell(fp); /* calculate relative offset */ switch (whence) { case SEEK_SET: /* from beginning */ rel_ofs = offset - cur_pos; break; case SEEK_CUR: /* from current */ rel_ofs = offset; break; case SEEK_END: /* from end */ rel_ofs = fp->usize + offset - cur_pos; break; default: /* something wrong */ return -1; } if (rel_ofs == 0) return cur_pos; /* don't have to move */ if (rel_ofs < 0) { /* convert backward into forward */ if (zzip_rewind(fp) == -1) return -1; read_size = cur_pos + rel_ofs; cur_pos = 0; } else { /* amount to read is positive relative offset */ read_size = rel_ofs; } if (read_size < 0) /* bad offset, before beginning of file */ return -1; if (read_size + cur_pos > (zzip_off_t)fp->usize) /* bad offset, past EOF */ return -1; if (read_size == 0) /* nothing to read */ return cur_pos; dir = fp->dir; /* * If this is other handle than previous, save current seek pointer * and read the file position of `this' handle. */ if (dir->currentfp != fp) { if (zzip_file_saveoffset(dir->currentfp) < 0 || dir->currentfp->io->fd.seeks(dir->fd, fp->offset, SEEK_SET) < 0) { dir->errcode = ZZIP_DIR_SEEK; return -1; } else { dir->currentfp = fp; } } if (fp->method == 0) { /* unstore, just lseek relatively */ ofs = fp->io->fd.tells(dir->fd); ofs = fp->io->fd.seeks(dir->fd,read_size,SEEK_CUR); if (ofs > 0) { /* readjust from beginning of file */ ofs -= fp->dataoffset; fp->restlen = fp->usize - ofs; } return ofs; } else { /* method == 8, inflate */ char *buf; /*FIXME: use a static buffer! */ buf = (char *)malloc(ZZIP_32K); if (! buf) return -1; while (read_size > 0) { zzip_off_t size = ZZIP_32K; if (read_size < size/*32K*/) size = read_size; size = zzip_file_read(fp, buf, (zzip_size_t)size); if (size <= 0) { free(buf); return -1; } read_size -= size; } free (buf); } return zzip_tell(fp); }
/** 获取当前ZIP文件指针的位置 */ size_t FZipFileStream::Tell(void) const { return zzip_tell( m_pZipFile ); }
int CZipArchive::CZipFile::getPos(){ return zzip_tell(m_zipfile); }
// Rescale automatically dialogs, using negative values to force rescaling // Notice: SHOULD BE CALLED ONLY IF rWidth is negative, in order to avoid useless SetWindowPos int RescaleWidth(const int rWidth) { // Always rescale negative widths if (rWidth <-1) { // Special case is when width is also the scale unit, which demonstrate we have a bug to fix here! #if USEIBOX if (rWidth == (int)(-246*InfoBoxLayout::dscale)){ #else if (rWidth == (int)(-246*ScreenDScale)){ #endif return LKwdlgConfig; } double i=(246.0 / abs(rWidth)); if (i==0) { FailStore(_T("INTERNAL ERROR RESCALEWIDTH rWidth=%d"),rWidth); DoStatusMessage(_T("RESCALE ERR-001")); return rWidth; } #if USEIBOX int ri=(int)( (LKwdlgConfig/i) *InfoBoxLayout::dscale ); #else int ri=(int)( (LKwdlgConfig/i) *ScreenDScale ); #endif // StartupStore(_T("... RescaleWidth(): rescale %d to %d\n"),rWidth, ri); if (ri>ScreenSizeX) return(ScreenSizeX); return (ri); } // else use the incoming rWidth but it is clearly an error DoStatusMessage(_T("RESCALE WARN-001")); return rWidth; } void ChangeWindCalcSpeed(const int newspeed) { WindCalcSpeed += (double)newspeed/SPEEDMODIFY; } // runmode 0: exec inside LocalPath home of LK8000 // runmode 1: exec inside bool LKRun(const TCHAR *prog, const int runmode, const DWORD dwaitime) { if (_tcslen(prog) <5) { StartupStore(_T("... LKRun failure: invalid exec path <%s>%s"),prog,NEWLINE); return false; } TCHAR path[MAX_PATH]; if (runmode<0 || runmode>1) { StartupStore(_T("... LKRun failure: invalid runmode=%d %s"),runmode,NEWLINE); return false; } // mode 0: localpath , forced execution, with warnings if something goes wrong // mode 1: optional execution, no warnings if nothing found if (runmode<2) { LocalPath(path,prog); if (runmode==0) StartupStore(_T(". LKRun: exec <%s> background=%u%s"),path,dwaitime,NEWLINE); PROCESS_INFORMATION pi; STARTUPINFO si; ZeroMemory(&si,sizeof(STARTUPINFO)); si.cb=sizeof(STARTUPINFO); si.wShowWindow= SW_SHOWNORMAL; si.dwFlags = STARTF_USESHOWWINDOW; // if (!::CreateProcess(_T("C:\\WINDOWS\\notepad.exe"),_T(""), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) if (!::CreateProcess(path,_T(""), NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) { if (runmode==0) StartupStore(_T("... LKRun exec FAILED%s"),NEWLINE); return false; } ::WaitForSingleObject(pi.hProcess, dwaitime); StartupStore(_T(". LKRun exec terminated%s"),NEWLINE); return true; } return false; } void GotoWaypoint(const int wpnum) { if (!ValidWayPoint(wpnum)) { DoStatusMessage(_T("ERR-639 INVALID GOTO WPT")); return; } if (ValidTaskPoint(ActiveWayPoint) && ValidTaskPoint(1)) { TCHAR wpname[NAME_SIZE+1]; _tcscpy(wpname,WayPointList[wpnum].Name); wpname[10] = '\0'; if (MessageBoxX(hWndMapWindow, // LKTOKEN _@M158_ = "CONFIRM GOTO, ABORTING TASK?" gettext(TEXT("_@M158_")), // LKTOKEN _@M40_ = "A task is running!" gettext(TEXT("_@M40_")), MB_YESNO|MB_ICONQUESTION) == IDYES) { LockTaskData(); FlyDirectTo(wpnum); OvertargetMode=OVT_TASK; UnlockTaskData(); } } else { LockTaskData(); FlyDirectTo(wpnum); OvertargetMode=OVT_TASK; UnlockTaskData(); } } void ToggleBaroAltitude() { if (!GPS_INFO.BaroAltitudeAvailable) { // LKTOKEN _@M121_ = "BARO ALTITUDE NOT AVAILABLE" DoStatusMessage(gettext(TEXT("_@M121_"))); return; } EnableNavBaroAltitude=!EnableNavBaroAltitude; if (EnableNavBaroAltitude) // LKTOKEN _@M756_ = "USING BARO ALTITUDE" DoStatusMessage(gettext(TEXT("_@M756_"))); else // LKTOKEN _@M757_ = "USING GPS ALTITUDE" DoStatusMessage(gettext(TEXT("_@M757_"))); } TCHAR * GetSizeSuffix(void) { static TCHAR suffixname[12]; _stprintf(suffixname,_T("%03dx%03d"),ScreenSizeX,ScreenSizeY); return(suffixname); } void LKRunStartEnd(bool start) { if (start) { LKRun(_T("PREROTATE1.EXE"),1,5000); LKRun(_T("PREROTATE2.EXE"),1,5000); LKRun(_T("PREROTATE3.EXE"),1,5000); LKRun(_T("PRELOAD_00.EXE"),1,0); LKRun(_T("PRELOAD_05.EXE"),1,5000); LKRun(_T("PRELOAD_30.EXE"),1,30000); LKRun(_T("PRELOAD_60.EXE"),1,60000); LKRun(_T("PRELOAD_99.EXE"),1,INFINITE); } else { LKRun(_T("ENDLOAD_00.EXE"),1,0); LKRun(_T("ENDLOAD_05.EXE"),1,5000); LKRun(_T("ENDLOAD_30.EXE"),1,30000); LKRun(_T("ENDLOAD_60.EXE"),1,60000); LKRun(_T("ENDROTATE1.EXE"),1,5000); LKRun(_T("ENDROTATE2.EXE"),1,5000); LKRun(_T("ENDROTATE3.EXE"),1,5000); LKRun(_T("ENDLOAD_99.EXE"),1,INFINITE); } } // Reads line from UTF-8 encoded text file. // File must be open in binary read mode. bool ReadULine(ZZIP_FILE* fp, TCHAR *unicode, int maxChars) { unsigned char buf[READLINE_LENGTH * 2]; long startPos = zzip_tell(fp); if (startPos < 0) { StartupStore(_T(". ftell() error = %d%s"), errno, NEWLINE); return(false); } size_t nbRead = zzip_fread(buf, 1, sizeof(buf) - 1, fp); if (nbRead == 0) return(false); buf[nbRead] = '\0'; // find new line (CR/LF/CRLF) in the string and terminate string at that position size_t i; for (i = 0; i < nbRead; i++) { if (buf[i] == '\n') { buf[i++] = '\0'; if (buf[i] == '\r') i++; break; } if (buf[i] == '\r') { buf[i++] = '\0'; if (buf[i] == '\n') i++; break; } } // next reading will continue after new line zzip_seek(fp, startPos + i, SEEK_SET); // skip leading BOM char* begin = (char*) buf; if (buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF) begin += 3; return(utf2unicode(begin, unicode, maxChars) >= 0); }
//从zip文件中读取全部文件内容到文件中或者内存中, //zip文件必须是通过addPatchFile加入的patch文件, bool Updater::_readContentsFromZip(const char* szZipFile, const char* szFileName, const char* szDiskFileName, char** ppMemoryBuf, unsigned int& nFileSize) { //参数检查 assert(szZipFile && szFileName && (szDiskFileName || ppMemoryBuf) ); if(!szZipFile || szZipFile[0]==0 || !szFileName || szFileName[0]==0 || (!szDiskFileName && !ppMemoryBuf)) { setLastError(AXP_ERR_PARAM); return false; } //搜索加入的zip文件 PATCHFILE_MAP::iterator itPatch = m_mapPatchFile.find(normaliseName(szZipFile)); //无法找到zip文件 assert(itPatch != m_mapPatchFile.end()); if(itPatch == m_mapPatchFile.end()) { setLastError(AXP_ERR_PARAM, "%s not inserted", szZipFile); return false; } //获得ZIP句柄 ZZIP_DIR* mZzipDir = (ZZIP_DIR*)(itPatch->second); assert(mZzipDir); std::string norFileName = normaliseName(szFileName, false, true); //得到文件信息 ZZIP_STAT zstat; memset(&zstat, 0, sizeof(ZZIP_STAT)); //打开文件,如果打不开,是空文件 ZZIP_FILE* zzipFile = zzip_file_open(mZzipDir, norFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS); if(zzipFile) { int zip_err = zzip_dir_stat(mZzipDir, norFileName.c_str(), &zstat, ZZIP_CASEINSENSITIVE); if(zip_err!=0) { zzip_file_close(zzipFile); setLastError(AXP_ERR_ZIPFILE, "ziperr=%d", mZzipDir->errcode); return false; } } //如果需要写入文件 if(szDiskFileName) { //确认文件所在目录存在 char szDiskFilePath[MAX_PATH] = {0}; strncpy(szDiskFilePath, szDiskFileName, MAX_PATH); PathRemoveFileSpec(szDiskFilePath); if(szDiskFilePath[0]!=0 && !forceCreatePath(szDiskFilePath)) { if(zzipFile)zzip_file_close(zzipFile); setLastError(AXP_ERR_FILE_ACCESS, "Path=%s, WinErr=%d", szDiskFilePath, ::GetLastError()); return false; } //创建该文件 HANDLE hDiskFile = ::CreateFile(szDiskFileName, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, 0); if(hDiskFile == INVALID_HANDLE_VALUE) { if(zzipFile)zzip_file_close(zzipFile); setLastError(AXP_ERR_FILE_ACCESS, "File=%s, WinErr=%d", szDiskFileName, ::GetLastError()); return false; } if(zstat.st_size > 0) { const int MAX_BUFFER_SIZE = 4096; char buffer[MAX_BUFFER_SIZE] = {0}; zzip_seek(zzipFile, 0, SEEK_SET); zzip_ssize_t zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer)); //实际已经写入的尺寸 unsigned int nActWriteSize = 0; //分块读写文件内容 do { //文件结束 if(zReadSize==0) break; //写入磁盘文件 DWORD dwBytesWrite; if(!WriteFile(hDiskFile, buffer, (DWORD)zReadSize, &dwBytesWrite, 0) || dwBytesWrite != (DWORD)zReadSize) { zzip_file_close(zzipFile); CloseHandle(hDiskFile); setLastError(AXP_ERR_FILE_WRITE, "File=%s, WinErr: %d", szDiskFileName, GetLastError()); return false; } //文件结束 if(zzip_tell(zzipFile) >=zstat.st_size) break; zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer)); }while(true); } //关闭句柄 CloseHandle(hDiskFile); hDiskFile=0; } //如果需要读入内存 if(ppMemoryBuf) { //所需要的内存 unsigned int nMemoryNeed = (unsigned int)zstat.st_size+1; while(nMemoryNeed%4)nMemoryNeed++; //upbound 4 //扩大静态内存大小 static std::vector< unsigned char > s_autoMemory; if(s_autoMemory.size() < nMemoryNeed) { s_autoMemory.resize(nMemoryNeed); } s_autoMemory.assign(s_autoMemory.size(), 0); //读入文件内容 if(zstat.st_size > 0) { zzip_seek(zzipFile, 0, SEEK_SET); zzip_ssize_t nZipSize = zzip_file_read(zzipFile, (char*)&(s_autoMemory[0]), zstat.st_size); if(nZipSize != zstat.st_size) { zzip_file_close(zzipFile); setLastError(AXP_ERR_ZIPFILE, "ziperr=%d", mZzipDir->errcode); return false; } } //返回内容 *ppMemoryBuf = (char *)(&(s_autoMemory[0])); } //关闭句柄 if(zzipFile)zzip_file_close(zzipFile); zzipFile=0; nFileSize = (unsigned int)zstat.st_size; return true; }
int64 ZipStream::getPosition() const { return zzip_tell(handle); }
bool ExtractFileFromZip(AXP::IUpdater* pUpdater, const char* szZipFile, const char* szFileInZip, const char* szFileInDisk) { //打开zip文件 zzip_error_t zzipError; ZZIP_DIR* mZzipDir = zzip_dir_open_ext_io(szZipFile, &zzipError, 0, (zzip_plugin_io_t)(pUpdater->getEncryptZipPluginIO(szZipFile))); if (zzipError != ZZIP_NO_ERROR) { return false; } //得到文件信息 ZZIP_STAT zstat; memset(&zstat, 0, sizeof(ZZIP_STAT)); //打开文件,如果打不开,是空文件 ZZIP_FILE* zzipFile = zzip_file_open(mZzipDir, szFileInZip, ZZIP_ONLYZIP | ZZIP_CASELESS); if(!zzipFile) { zzip_dir_close(mZzipDir); return false; } //获得文件信息 int zip_err = zzip_dir_stat(mZzipDir, szFileInZip, &zstat, ZZIP_CASEINSENSITIVE); if(zip_err!=0) { zzip_file_close(zzipFile); zzip_dir_close(mZzipDir); return false; } //创建该文件 HANDLE hDiskFile = ::CreateFile(szFileInDisk, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, 0); if(hDiskFile == INVALID_HANDLE_VALUE) { zzip_file_close(zzipFile); zzip_dir_close(mZzipDir); return false; } if(zstat.st_size > 0) { const int MAX_BUFFER_SIZE = 4096; char buffer[MAX_BUFFER_SIZE] = {0}; zzip_seek(zzipFile, 0, SEEK_SET); zzip_ssize_t zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer)); //实际已经写入的尺寸 unsigned int nActWriteSize = 0; //分块读写文件内容 do { //文件结束 if(zReadSize==0) break; //写入磁盘文件 DWORD dwBytesWrite; if(!WriteFile(hDiskFile, buffer, (DWORD)zReadSize, &dwBytesWrite, 0) || dwBytesWrite != (DWORD)zReadSize) { zzip_file_close(zzipFile); zzip_dir_close(mZzipDir); CloseHandle(hDiskFile); return false; } //文件结束 if(zzip_tell(zzipFile) >=zstat.st_size) break; zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer)); }while(true); } //关闭句柄 CloseHandle(hDiskFile); hDiskFile=0; zzip_file_close(zzipFile); zzipFile=0; zzip_dir_close(mZzipDir); mZzipDir=0; return true; }
bool CZipArchive::CZipFile::eof(){ return (zzip_tell(m_zipfile) >= static_cast<zzip_off_t>(length())); }