//-----------------------------------------------------------------------
DataStreamPtr ZipArchive::open(const String& filename) const
{
// Format not used here (always binary)
ZZIP_FILE* zzipFile =
zzip_file_open(mZzipDir, filename.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS);
if (!zzipFile)
{
int zerr = zzip_error(mZzipDir);
String zzDesc = getZzipErrorDescription((zzip_error_t)zerr);
LogManager::getSingleton().logMessage(
mName + " - Unable to open file " + filename + ", error was '" + zzDesc + "'");
// return null pointer
return DataStreamPtr();
}
// Get uncompressed size too
ZZIP_STAT zstat;
zzip_dir_stat(mZzipDir, filename.c_str(), &zstat, ZZIP_CASEINSENSITIVE);
// Construct & return stream
return DataStreamPtr(new ZipDataStream(filename, zzipFile, static_cast<size_t>(zstat.st_size)));
}
//-----------------------------------------------------------------------
bool ZipArchive::exists(const String& filename)
{
ZZIP_STAT zstat;
int res = zzip_dir_stat(mZzipDir, filename.c_str(), &zstat, ZZIP_CASEINSENSITIVE);
return (res == ZZIP_NO_ERROR);
}
bool
RasterWeather::ExistsItem(struct zzip_dir *dir, const TCHAR* name,
unsigned time_index) const
{
char filename[MAX_PATH];
NarrowWeatherFilename(filename, name, time_index);
ZZIP_STAT st;
return zzip_dir_stat(dir, filename, &st, 0) == 0;
}
bool
RasterWeatherStore::ExistsItem(struct zzip_dir *dir, Path name,
unsigned time_index)
{
char filename[MAX_PATH];
if (!NarrowWeatherFilename(filename, name, time_index))
return false;
ZZIP_STAT st;
return zzip_dir_stat(dir, filename, &st, 0) == 0;
}
bool ArchiveZip::existsFile(const Path& path)
{
if (!isValid)
return false;
ZZIP_DIR* zip = (ZZIP_DIR*) handle;
ZZIP_STAT zstat;
Path normalized = PathNormalize(path);
int res = zzip_dir_stat(zip, normalized.c_str(), &zstat, ZZIP_CASEINSENSITIVE | ZZIP_IGNOREPATH);
return (res == ZZIP_NO_ERROR);
}
//-----------------------------------------------------------------------
DataStreamPtr ZipArchive::open(const String& filename, bool readOnly) const
{
// zziplib is not threadsafe
OGRE_LOCK_AUTO_MUTEX;
String lookUpFileName = filename;
#if OGRE_RESOURCEMANAGER_STRICT
const int flags = 0;
#else
const int flags = ZZIP_CASELESS;
#endif
// Format not used here (always binary)
ZZIP_FILE* zzipFile =
zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | flags);
#if !OGRE_RESOURCEMANAGER_STRICT
if (!zzipFile) // Try if we find the file
{
String basename, path;
StringUtil::splitFilename(lookUpFileName, basename, path);
const FileInfoListPtr fileNfo = findFileInfo(basename, true);
if (fileNfo->size() == 1) // If there are more files with the same do not open anyone
{
Ogre::FileInfo info = fileNfo->at(0);
lookUpFileName = info.path + info.basename;
zzipFile = zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | flags); // When an error happens here we will catch it below
}
}
#endif
if (!zzipFile)
{
int zerr = zzip_error(mZzipDir);
String zzDesc = getZzipErrorDescription((zzip_error_t)zerr);
OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND,
mName+ " Cannot open file: " + lookUpFileName + " - "+zzDesc, "ZipArchive::open");
}
// Get uncompressed size too
ZZIP_STAT zstat;
zzip_dir_stat(mZzipDir, lookUpFileName.c_str(), &zstat, flags);
// Construct & return stream
return DataStreamPtr(OGRE_NEW ZipDataStream(lookUpFileName, zzipFile, static_cast<size_t>(zstat.st_size)));
}
//-----------------------------------------------------------------------
DataStreamPtr ZipArchive::open(const String& filename, bool readOnly)
{
// zziplib is not threadsafe
OGRE_LOCK_AUTO_MUTEX;
String lookUpFileName = filename;
// Format not used here (always binary)
ZZIP_FILE* zzipFile =
zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS);
if (!zzipFile) // Try if we find the file
{
const Ogre::FileInfoListPtr fileNfo = findFileInfo(lookUpFileName, true);
if (fileNfo->size() == 1) // If there are more files with the same do not open anyone
{
Ogre::FileInfo info = fileNfo->at(0);
lookUpFileName = info.path + info.basename;
zzipFile = zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS); // When an error happens here we will catch it below
}
}
if (!zzipFile)
{
int zerr = zzip_error(mZzipDir);
String zzDesc = getZzipErrorDescription((zzip_error_t)zerr);
LogManager::getSingleton().logMessage(
mName + " - Unable to open file " + lookUpFileName + ", error was '" + zzDesc + "'", LML_CRITICAL);
// return null pointer
return DataStreamPtr();
}
// Get uncompressed size too
ZZIP_STAT zstat;
zzip_dir_stat(mZzipDir, lookUpFileName.c_str(), &zstat, ZZIP_CASEINSENSITIVE);
// Construct & return stream
return DataStreamPtr(OGRE_NEW ZipDataStream(lookUpFileName, zzipFile, static_cast<size_t>(zstat.st_size)));
}
/** 打开一个ZIP文件
@Param 文件的名字
*/
FVFileStream* FZipFilePack::Open( const AString& filename )
{
ZZIP_FILE* pFile = zzip_file_open( m_pZipDir,filename.c_str(),
ZZIP_ONLYZIP|ZZIP_CASELESS );
if( !pFile )
{
AString errDesc;
int zipError = zzip_error( m_pZipDir );
if( zipError != ZZIP_NO_ERROR )
{
GetZipErrorDesc( zipError,errDesc );
FLOG_WARNINGF( "FZipFilePack::Open(), Open file (%s) from ZIP package(%s) failed!",filename.c_str(),m_sName.c_str() );
}
return NULL;
}
ZZIP_STAT zipStat;
zzip_dir_stat( m_pZipDir,filename.c_str(),&zipStat,ZZIP_CASEINSENSITIVE );
// 创建一个ZIP文件流
return new FZipFileStream( filename,pFile,zipStat.st_size );
}
static int zipread_showfile(request_rec *r, const char *fname)
{
char *zipfile, *name;
ZZIP_DIR *dir;
unsigned int itnum;
if (!r->path_info) return HTTP_NOT_FOUND;
zipfile = r->filename;
if (!fname || !*fname)
{
name = apr_pstrdup(r->pool, r->path_info);
}
else
{
name = apr_pstrcat(r->pool, r->path_info, fname, NULL);
}
r->content_type = zipread_getcontenttype(r, name);
if (*name == '/') name++;
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile: %s - %s - %s", zipfile, fname, name);
for(itnum = 0; itnum < 5; itnum++)
{
dir = zzip_dir_open(zipfile, 0);
if (dir)
{
ZZIP_STAT st;
// fetch stat info of filename, before opening it
if (zzip_dir_stat(dir, name, &st, 0) != 0)
{
// check if a directory entry is available for that name.
name = apr_pstrcat(r->pool, name, "/", NULL);
if (zzip_dir_stat(dir, name, &st, 0) != 0)
{
zzip_dir_close(dir);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile stat failed: %d - %s",
zzip_error(dir), zzip_strerror(zzip_error(dir)));
return HTTP_NOT_FOUND;
}
// found a directory entry, do an external redirect to get the
// links in the directory listing right.
name = apr_pstrcat(r->pool, r->uri, "/", NULL);
apr_table_setn(r->headers_out, "Location", name);
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile directory entry.");
return HTTP_MOVED_PERMANENTLY;
}
ap_set_content_length(r, st.st_size);
// cannot check last-modified date of the file itself here, because
// zziplib doesnt extract it. instead we use the zip file's date
r->mtime = r->finfo.mtime;
ap_set_last_modified(r);
if (!r->header_only)
{
ZZIP_FILE *fp = zzip_file_open(dir, name, 0);
if (fp)
{
int len;
char buf[32769];
while ((len = zzip_file_read (fp, buf, 32768)))
{
ap_rwrite(buf, len, r);
}
zzip_file_close(fp);
zzip_dir_close(dir);
return OK;
}
else
{
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile file open failed: %d - %s.",
zzip_error(dir), zzip_strerror(zzip_error(dir)));
if (zzip_dir_stat(dir, name, &st, 0) != 0)
{
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile after stat failed: %d - %s",
zzip_error(dir), zzip_strerror(zzip_error(dir)));
break;
}
zzip_dir_close(dir);
continue;
}
}
zzip_dir_close(dir);
return OK;
}
else
{
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "mod_zipread showfile zip file not open.");
return HTTP_NOT_FOUND;
}
}
zzip_dir_close (dir);
return HTTP_NOT_FOUND;
}
//从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;
}
/** 检测是否存在指定文件
@Param 指定的文件名
*/
bool FZipFilePack::Exists( const AString& filename )
{
ZZIP_STAT zipStat;
int ret = zzip_dir_stat( m_pZipDir,filename.c_str(),&zipStat,ZZIP_CASEINSENSITIVE );
return (ret == ZZIP_NO_ERROR);
}
bool CZipArchive::loadArchive(){
static mchar tempBuff[128];
if(!m_zipDir){
zzip_error_t err;
//m_file=gFileSystem.openFile(getName());
//if(!m_file || !m_file->getFD())return 0;
//m_zipDir = zzip_dir_fdopen(m_file->getFD()->_file,&err);
core::stringc fileName;
core::string_to_char(getName(),fileName);
m_zipDir = zzip_dir_open(fileName.c_str(),&err);
if(checkForError(err,mT(" loadArchive()")))return false;
ZZIP_DIRENT zipEntry;
sFileEntry entry;
core::string tstr;
core::string zipName;
core::stringc tmpc;
while(zzip_dir_read(m_zipDir,&zipEntry)){
zipName=zipEntry.d_name;
zipName.replaceChar('\\','/');
int x=zipName.findlast('/');
if(x==zipName.length()){
// entry.dirPath=zipName;
// entry.filePath=zipName;
entry.dirPath=mT("");
entry.filePath=mT("");
zipName[zipName.length()]='\0';
x=zipName.findlast('/');
tstr=zipName.substr(x,zipName.length()-x+1);
entry.fileName=tstr;
entry.isfolder=true;
entry.fileData=0;
}else{
//entry.filePath=zipName;
entry.dirPath=mT("");
entry.filePath=mT("");
tstr=zipName.substr(x+1,zipName.length());
entry.fileName=tstr;
core::string_to_char(zipName,tmpc);
zzip_file*zipFile=zzip_file_open(m_zipDir,tmpc.c_str(),ZZIP_ONLYZIP | ZZIP_CASELESS);
if(!zipFile){
int zerr = zzip_error(m_zipDir);
checkForError(zerr,mT("open zip file"));
entry.fileData=0;
}else{
ZZIP_STAT zstate;
zzip_dir_stat(m_zipDir,tmpc.c_str(),&zstate,ZZIP_CASEINSENSITIVE);
entry.fileData=new CZipFile(entry.fileName.c_str(),zipFile,zstate.st_size);
}
int s=zipName.find('/');
tstr=zipName.substr(s+1,x-s);
entry.dirPath=tstr;
entry.filePath=tstr+entry.fileName;
entry.isfolder=false;
}
entry.compressSize=zipEntry.d_csize;
entry.uncompressSize=zipEntry.st_size;
m_files.push_back(entry);
}
}
return 1;
}
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;
}
