unzFile unzipopen (const char* path)
{
unzFile uf = NULL;
int err=UNZ_OK;
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
#endif
#ifdef USEWIN32IOAPI
fill_win32_filefunc(&ffunc);
uf = unzOpen2(path,&ffunc);
#else
uf = unzOpen(path);
#endif
if (uf == NULL) return NULL;
err = unzGoToFirstFile(uf);
if (err != UNZ_OK)
{
unzClose(uf);
return NULL;
}
err = unzOpenCurrentFile(uf);
if (err != UNZ_OK)
{
unzClose(uf);
return NULL;
}
return uf;
}
unzFile OpenHandleForUnzipping(HANDLE zip_handle)
{
zlib_filefunc_def zip_funcs;
fill_win32_filefunc(&zip_funcs);
zip_funcs.zopen_file = HandleOpenFileFunc;
zip_funcs.opaque = zip_handle;
return unzOpen2("fd", &zip_funcs);
}
unzFile OpenForUnzipping(const std::string& file_name_utf8)
{
zlib_filefunc_def* zip_func_ptrs = NULL;
zlib_filefunc_def zip_funcs;
fill_win32_filefunc(&zip_funcs);
zip_funcs.zopen_file = ZipOpenFunc;
zip_func_ptrs = &zip_funcs;
return unzOpen2(file_name_utf8.c_str(), zip_func_ptrs);
}
STDMETHODIMP CLarrysOpenOfficeandStarOfficeIndexerObj::HandleFile(BSTR RawFullPath, IDispatch* IFactory)
{
string FullPath = CW2A(RawFullPath);
// Open the zip file (since OpenOffice files are all zips. If you don't
// believe me, rename one to .zip and decompress it)
unzFile UnzipFile = NULL;
zlib_filefunc_def FileFunc;
fill_win32_filefunc(&FileFunc);
UnzipFile = unzOpen2(FullPath.c_str(), &FileFunc);
// Verify that the file was successfully opened
if (UnzipFile == NULL) {
return S_FALSE;
}
// Get data from the Content.xml which is inside of the archive
string ContentData;
ContentData = GetDataFromContentXML(UnzipFile);
// Close the file
unzClose(UnzipFile);
if (ContentData == "") {
return S_FALSE;
}
// Convert the XML into plain text
ContentData = HTMLToText(ContentData);
// Get the modification time of the file
HANDLE FileHandle;
FileHandle = CreateFile(FullPath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
FILETIME *ModifiedTime = (FILETIME *)malloc(sizeof FILETIME);
BOOL FileTimeResult = GetFileTime(FileHandle, 0, 0, ModifiedTime);
CloseHandle(FileHandle);
if (!FileTimeResult) {
return S_FALSE;
}
// Format modification date properly
SYSTEMTIME SystemTime;
FileTimeToSystemTime(ModifiedTime, &SystemTime);
// Index file
LarGDSPlugin GDSPlugin(PluginClassID);
if (!GDSPlugin.SendTextFileEvent(ContentData, FullPath, SystemTime)) {
return S_FALSE;
}
return S_OK;
}
zipFile OpenForZipping(const std::string& file_name_utf8, int append_flag)
{
zlib_filefunc_def* zip_func_ptrs = NULL;
zlib_filefunc_def zip_funcs;
fill_win32_filefunc(&zip_funcs);
zip_funcs.zopen_file = ZipOpenFunc;
zip_func_ptrs = &zip_funcs;
return zipOpen2(file_name_utf8.c_str(),
append_flag,
NULL, // global comment
zip_func_ptrs);
}
static unzFile
openUnzFile( const char* zipfilename )
{
unzFile uf = NULL;
if( zipfilename ){
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc( &ffunc );
uf = unzOpen2( zipfilename, &ffunc );
#else
uf = unzOpen( zipfilename );
#endif
}
return uf;
}
CArchiveZip::CArchiveZip(const std::string& name):
CArchiveBuffered(name),
curSearchHandle(1)
{
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zip = unzOpen2(name.c_str(),&ffunc);
#else
zip = unzOpen(name.c_str());
#endif
if (!zip) {
LogObject() << "Error opening " << name;
return;
}
// We need to map file positions to speed up opening later
for (int ret = unzGoToFirstFile(zip); ret == UNZ_OK; ret = unzGoToNextFile(zip)) {
unz_file_info info;
char fname[512];
unzGetCurrentFileInfo(zip, &info, fname, 512, NULL, 0, NULL, 0);
const std::string name = StringToLower(fname);
if (name.empty()) {
continue;
}
const char last = name[name.length() - 1];
if ((last == '/') || (last == '\\')) {
continue; // exclude directory names
}
FileData fd;
unzGetFilePos(zip, &fd.fp);
fd.size = info.uncompressed_size;
fd.origName = fname;
fd.crc = info.crc;
fileData[name] = fd;
}
}
CArchiveZip::CArchiveZip(const string& name) :
CArchiveBuffered(name),
curSearchHandle(1)
{
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zip = unzOpen2(name.c_str(),&ffunc);
#else
zip = unzOpen(name.c_str());
#endif
if (!zip)
return;
// We need to map file positions to speed up opening later
for (int ret = unzGoToFirstFile(zip); ret == UNZ_OK; ret = unzGoToNextFile(zip)) {
unz_file_info info;
char fname[512];
string name;
unzGetCurrentFileInfo(zip, &info, fname, 512, NULL, 0, NULL, 0);
if (info.uncompressed_size > 0) {
name = StringToLower(fname);
// SetSlashesForwardToBack(name);
FileData fd;
unzGetFilePos(zip, &fd.fp);
fd.size = info.uncompressed_size;
fd.origName = fname;
fd.crc = info.crc;
// SetSlashesForwardToBack(fd.origName);
fileData[name] = fd;
}
}
}
zipFile zipopen (const char* path, const char* filenameinzip, int append)
{
zipFile zf = NULL;
int err=ZIP_OK;
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zf = zipOpen2(path,append,NULL,&ffunc);
#else
zf = zipOpen(path, append);
#endif
if (zf == NULL) return NULL;
zip_fileinfo zi;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL,
Z_DEFLATED,
Z_DEFAULT_COMPRESSION);
if (err != ZIP_OK)
{
zipClose(zf, NULL);
return NULL;
}
return zf;
}
int RSAZCryptor::zipToFile(unsigned contentLength, void const *content, const char* fileToBeZipped, const char* fileOut)
{
unsigned len=(int)strlen(fileOut);
char* filename_try = (char*)malloc(len+16);
if (filename_try==NULL)
{
return ZIP_INTERNALERROR;
}
strcpy(filename_try, fileOut);
bool dot_found = false;
for (unsigned i=0; i<len; i++)
{
if (filename_try[i]=='.')
{
dot_found=true;
break;
}
}
if (!dot_found)
strcat(filename_try,".zip");
zipFile zf;
int opt_overwrite=0; //?1
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
#else
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
#endif
int err=0;
if (zf == NULL)
{
printf("error opening %s\n",filename_try);
err= ZIP_ERRNO;
}
zip_fileinfo zi;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
err = zipOpenNewFileInZip3(zf,fileToBeZipped,&zi,
NULL,0,NULL,0,NULL /* comment*/,
Z_DEFLATED,
Z_DEFAULT_COMPRESSION,0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
NULL, 0);
if (err != ZIP_OK)
printf("error in opening %s in zipfile\n",fileToBeZipped);
if (contentLength>0)
{
err = zipWriteInFileInZip (zf,content,contentLength);
if (err<0)
{
printf("error in writing %s in the zipfile\n", fileToBeZipped);
}
}
if (err<0)
err=ZIP_ERRNO;
else
{
err = zipCloseFileInZip(zf);
if (err!=ZIP_OK)
printf("error in closing %s in the zipfile\n", fileToBeZipped);
}
if (zipClose(zf,NULL) != ZIP_OK)
printf("error in closing %s\n",filename_try);
free(filename_try);
return 0;
}
int RSAZCryptor::zipToFile(const char* zipFileName, bool cleanFileListAfterUsed)
{
unsigned len=(int)strlen(zipFileName);
char* filename_try = (char*)malloc(len+16);
if (filename_try==NULL)
{
return ZIP_INTERNALERROR;
}
strcpy(filename_try, zipFileName);
bool dot_found = false;
for (unsigned i=0; i<len; i++)
{
if (filename_try[i]=='.')
{
dot_found=true;
break;
}
}
if (!dot_found)
strcat(filename_try,".zip");
zipFile zf;
int opt_overwrite=0; //?1
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
#else
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
#endif
int err=0;
if (zf == NULL)
{
printf("error opening %s\n",filename_try);
err= ZIP_ERRNO;
}
unsigned count = 0;
linkedlist_filetozip* pFileList = m_filesToBeZIP;
while (pFileList && (err==ZIP_OK))
{
count++;
unsigned contentLength = pFileList->content_length;
void const *content = pFileList->file_content;
char* fileName = NULL;
char fileName0[16];
if (pFileList->file_name)
fileName = pFileList->file_name;
else
{
sprintf(fileName0, "file%d", count);
fileName = fileName0;
}
struct tm * ts = gmtime(&pFileList->file_time);
zip_fileinfo zi;
zi.tmz_date.tm_sec = ts->tm_sec;
zi.tmz_date.tm_min = ts->tm_min;
zi.tmz_date.tm_hour = ts->tm_hour;
zi.tmz_date.tm_mday = ts->tm_mday;
zi.tmz_date.tm_mon = ts->tm_mon;
zi.tmz_date.tm_year = ts->tm_year;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
err = zipOpenNewFileInZip3(zf,fileName,&zi,
NULL,0,NULL,0,NULL /* comment*/,
Z_DEFLATED,
Z_DEFAULT_COMPRESSION,0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
NULL, 0);
if (err != ZIP_OK)
printf("error in opening %s in zipfile\n",fileName);
if (contentLength>0)
{
err = zipWriteInFileInZip (zf,content,contentLength);
if (err<0)
{
printf("error in writing %s in the zipfile\n", fileName);
}
}
if (err<0)
err=ZIP_ERRNO;
else
{
err = zipCloseFileInZip(zf);
if (err!=ZIP_OK)
printf("error in closing %s in the zipfile\n", fileName);
}
pFileList = pFileList->next_filetozip;
}
if (zipClose(zf,NULL) != ZIP_OK)
printf("error in closing %s\n",filename_try);
free(filename_try);
if (cleanFileListAfterUsed)
{
cleanFileList(m_filesToBeZIP);
m_filesToBeZIP = NULL;
}
return 0;
}
bool KAppRes::OpenResPack()
{
bool retval = false;
zlib_filefunc_def zip_funcs;
std::string strPathAnsi;
int nRetCode;
HRSRC hResInfo = NULL;
HGLOBAL hResDat = NULL;
PVOID pResBuffer = NULL;
DWORD dwResBuffer = 0;
fill_win32_filefunc(&zip_funcs);
strPathAnsi = UnicodeToAnsi(m_strResPackPath);
m_pResPackData = unzOpen2(strPathAnsi.c_str(), &zip_funcs);
if (m_pResPackData)
goto UNZRESPACKDATA;
if (strlen((const char*)&m_memZipRes) == 0)
{//防止.kui格式错误导致unzOpen2返回空的m_pResPackData
hResInfo = FindResourceW(_ModulePtr->GetResourceInstance(), L"kuires.dat", L"SKIN");
if (!hResInfo)
goto clean0;
hResDat = LoadResource(_ModulePtr->GetResourceInstance(), hResInfo);
if (!hResDat)
goto clean0;
pResBuffer = LockResource(hResDat);
if (!pResBuffer)
goto clean0;
dwResBuffer = SizeofResource(_ModulePtr->GetResourceInstance(), hResInfo);
m_memZipRes.SetData(pResBuffer, dwResBuffer);
}
zip_funcs.zopen_file = ZipOpenFunc;
zip_funcs.zread_file = ZipReadFunc;
zip_funcs.zwrite_file = ZipWriteFunc;
zip_funcs.ztell_file = ZipTellFunc;
zip_funcs.zseek_file = ZipSeekFunc;
zip_funcs.zclose_file = ZipCloseFunc;
zip_funcs.zerror_file = ZipErrorFunc;
zip_funcs.opaque=NULL;
m_pResPackData = unzOpen2((const char*)&m_memZipRes, &zip_funcs);
if (!m_pResPackData)
goto clean0;
UNZRESPACKDATA:
nRetCode = unzGoToFirstFile(m_pResPackData);
while (UNZ_OK == nRetCode)
{
char szCurrentFile[260];
unz_file_info fileInfo;
uLong dwSeekPos;
uLong dwSize;
nRetCode = unzGetCurrentFileInfo(
m_pResPackData,
&fileInfo,
szCurrentFile,
sizeof(szCurrentFile),
NULL,
0,
NULL,
0
);
if (nRetCode != UNZ_OK)
goto clean0;
dwSeekPos = unzGetOffset(m_pResPackData);
dwSize = fileInfo.uncompressed_size;
m_mapResOffset.insert(KResOffset::value_type(szCurrentFile, KResInfo(dwSeekPos, dwSize)));
nRetCode = unzGoToNextFile(m_pResPackData);
}
clean0:
return retval;
}
///////////////////////////////////////////////////////////////
//
// CResourceChecker::ReplaceFilesInZIP
//
// Based on example at http://www.winimage.com/zLibDll/minizip.html
// by Ivan A. Krestinin
//
///////////////////////////////////////////////////////////////
int CResourceChecker::ReplaceFilesInZIP( const string& strOrigZip, const string& strTempZip, const vector < string >& pathInArchiveList, const vector < string >& m_upgradedFullPathList )
{
// open source and destination file
zlib_filefunc_def ffunc;
#ifdef WIN32
fill_win32_filefunc(&ffunc);
#else
fill_fopen_filefunc(&ffunc);
#endif
zipFile szip = unzOpen2(strOrigZip.c_str(), &ffunc);
if (szip==NULL) { /*free(tmp_name);*/ return 0; }
zipFile dzip = zipOpen2(strTempZip.c_str(), APPEND_STATUS_CREATE, NULL, &ffunc);
if (dzip==NULL) { unzClose(szip); /*free(tmp_name);*/ return 0; }
// get global commentary
unz_global_info glob_info;
if (unzGetGlobalInfo(szip, &glob_info) != UNZ_OK) { zipClose(dzip, NULL); unzClose(szip); /*free(tmp_name);*/ return 0; }
char* glob_comment = NULL;
if (glob_info.size_comment > 0)
{
glob_comment = (char*)malloc(glob_info.size_comment+1);
if ((glob_comment==NULL)&&(glob_info.size_comment!=0)) { zipClose(dzip, NULL); unzClose(szip); /*free(tmp_name);*/ return 0; }
if ((unsigned int)unzGetGlobalComment(szip, glob_comment, glob_info.size_comment+1) != glob_info.size_comment) { zipClose(dzip, NULL); unzClose(szip); free(glob_comment); /*free(tmp_name);*/ return 0; }
}
// copying files
int n_files = 0;
int rv = unzGoToFirstFile(szip);
while (rv == UNZ_OK)
{
// get zipped file info
unz_file_info unzfi;
char dos_fn[MAX_PATH];
if (unzGetCurrentFileInfo(szip, &unzfi, dos_fn, MAX_PATH, NULL, 0, NULL, 0) != UNZ_OK) break;
char fn[MAX_PATH];
#ifdef WIN32
OemToChar(dos_fn, fn);
#endif
// See if file should be replaced
string fullPathReplacement;
for ( unsigned long i = 0 ; i < pathInArchiveList.size () ; i++ )
if ( stricmp ( fn, pathInArchiveList[i].c_str () ) == 0 )
fullPathReplacement = m_upgradedFullPathList[i];
// Replace file in zip
if ( fullPathReplacement.length () )
{
void* buf = NULL;
unsigned long ulLength = 0;
// Get new file into a buffer
if ( FILE* pFile = File::Fopen ( fullPathReplacement.c_str (), "rb" ) )
{
// Get the file size,
fseek( pFile, 0, SEEK_END );
ulLength = ftell( pFile );
fseek( pFile, 0, SEEK_SET );
// Load file into a buffer
buf = malloc( ulLength );
if ( fread ( buf, 1, ulLength, pFile ) != ulLength )
{
free( buf );
buf = NULL;
}
// Clean up
fclose ( pFile );
}
if( !buf )
break;
// open destination file
zip_fileinfo zfi;
memcpy (&zfi.tmz_date, &unzfi.tmu_date, sizeof(tm_unz));
zfi.dosDate = unzfi.dosDate;
zfi.internal_fa = unzfi.internal_fa;
zfi.external_fa = unzfi.external_fa;
char* extrafield = NULL;
char* commentary = NULL;
int size_local_extra = 0;
void* local_extra = NULL;
int unzfi_size_file_extra = 0;
int method = Z_DEFLATED;
int level = Z_DEFAULT_COMPRESSION;
if (zipOpenNewFileInZip(dzip, dos_fn, &zfi, local_extra, size_local_extra, extrafield, unzfi_size_file_extra, commentary, method, level )!=UNZ_OK)
{free(extrafield); free(commentary); free(local_extra); free(buf); break;}
// write file
if (zipWriteInFileInZip(dzip, buf, ulLength)!=UNZ_OK)
{free(extrafield); free(commentary); free(local_extra); free(buf); break;}
if (zipCloseFileInZip(dzip/*, unzfi.uncompressed_size, unzfi.crc*/)!=UNZ_OK)
{free(extrafield); free(commentary); free(local_extra); free(buf); break;}
free( buf );
}
// Copy file in zip
if ( !fullPathReplacement.length () )
{
char* extrafield = (char*)malloc(unzfi.size_file_extra);
if ((extrafield==NULL)&&(unzfi.size_file_extra!=0)) break;
char* commentary = (char*)malloc(unzfi.size_file_comment);
if ((commentary==NULL)&&(unzfi.size_file_comment!=0)) {free(extrafield); break;}
if (unzGetCurrentFileInfo(szip, &unzfi, dos_fn, MAX_PATH, extrafield, unzfi.size_file_extra, commentary, unzfi.size_file_comment) != UNZ_OK) {free(extrafield); free(commentary); break;}
// open file for RAW reading
int method;
int level;
if (unzOpenCurrentFile2(szip, &method, &level, 1)!=UNZ_OK) {free(extrafield); free(commentary); break;}
int size_local_extra = unzGetLocalExtrafield(szip, NULL, 0);
if (size_local_extra<0) {free(extrafield); free(commentary); break;}
void* local_extra = malloc(size_local_extra);
if ((local_extra==NULL)&&(size_local_extra!=0)) {free(extrafield); free(commentary); break;}
if (unzGetLocalExtrafield(szip, local_extra, size_local_extra)<0) {free(extrafield); free(commentary); free(local_extra); break;}
// this malloc may fail if file very large
void* buf = malloc(unzfi.compressed_size);
if ((buf==NULL)&&(unzfi.compressed_size!=0)) {free(extrafield); free(commentary); free(local_extra); break;}
// read file
int sz = unzReadCurrentFile(szip, buf, unzfi.compressed_size);
if ((unsigned int)sz != unzfi.compressed_size) {free(extrafield); free(commentary); free(local_extra); free(buf); break;}
// open destination file
zip_fileinfo zfi;
memcpy (&zfi.tmz_date, &unzfi.tmu_date, sizeof(tm_unz));
zfi.dosDate = unzfi.dosDate;
zfi.internal_fa = unzfi.internal_fa;
zfi.external_fa = unzfi.external_fa;
if (zipOpenNewFileInZip2(dzip, dos_fn, &zfi, local_extra, size_local_extra, extrafield, unzfi.size_file_extra, commentary, method, level, 1)!=UNZ_OK) {free(extrafield); free(commentary); free(local_extra); free(buf); break;}
// write file
if (zipWriteInFileInZip(dzip, buf, unzfi.compressed_size)!=UNZ_OK) {free(extrafield); free(commentary); free(local_extra); free(buf); break;}
if (zipCloseFileInZipRaw(dzip, unzfi.uncompressed_size, unzfi.crc)!=UNZ_OK) {free(extrafield); free(commentary); free(local_extra); free(buf); break;}
if (unzCloseCurrentFile(szip)==UNZ_CRCERROR) {free(extrafield); free(commentary); free(local_extra); free(buf); break;}
free(commentary);
free(buf);
free(extrafield);
free(local_extra);
n_files ++;
}
rv = unzGoToNextFile(szip);
}
zipClose(dzip, glob_comment);
unzClose(szip);
free(glob_comment);
return rv==UNZ_END_OF_LIST_OF_FILE;
}
int main__minizip(int argc,char *argv[])
{
int i;
int opt_overwrite=0;
int opt_compress_level=Z_DEFAULT_COMPRESSION;
int zipfilenamearg = 0;
char filename_try[MAXFILENAME+16];
int zipok;
int err=0;
int size_buf=0;
void* buf=NULL;
const char* password=NULL;
do_banner__minizip();
if (argc==1)
{
do_help__minizip();
return 0;
}
else
{
for (i=1;i<argc;i++)
{
if ((*argv[i])=='-')
{
const char *p=argv[i]+1;
while ((*p)!='\0')
{
char c=*(p++);;
if ((c=='o') || (c=='O'))
opt_overwrite = 1;
if ((c=='a') || (c=='A'))
opt_overwrite = 2;
if ((c>='0') && (c<='9'))
opt_compress_level = c-'0';
if (((c=='p') || (c=='P')) && (i+1<argc))
{
password=argv[i+1];
i++;
}
}
}
else
if (zipfilenamearg == 0)
zipfilenamearg = i ;
}
}
size_buf = WRITEBUFFERSIZE;
buf = (void*)malloc(size_buf);
if (buf==NULL)
{
printf("Error allocating memory\n");
return ZIP_INTERNALERROR;
}
if (zipfilenamearg==0)
zipok=0;
else
{
int i,len;
int dot_found=0;
zipok = 1 ;
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
/* strncpy doesnt append the trailing NULL, of the string is too long. */
filename_try[ MAXFILENAME ] = '\0';
len=(int)strlen(filename_try);
for (i=0;i<len;i++)
if (filename_try[i]=='.')
dot_found=1;
if (dot_found==0)
strcat(filename_try,".zip");
if (opt_overwrite==2)
{
/* if the file don't exist, we not append file */
if (check_exist_file__minizip(filename_try)==0)
opt_overwrite=1;
}
else
if (opt_overwrite==0)
if (check_exist_file__minizip(filename_try)!=0)
{
char rep=0;
do
{
char answer[128];
int ret;
printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
ret = scanf("%1s",answer);
if (ret != 1)
{
exit(EXIT_FAILURE);
}
rep = answer[0] ;
if ((rep>='a') && (rep<='z'))
rep -= 0x20;
}
while ((rep!='Y') && (rep!='N') && (rep!='A'));
if (rep=='N')
zipok = 0;
if (rep=='A')
opt_overwrite = 2;
}
}
if (zipok==1)
{
zipFile zf;
int errclose;
# ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
# else
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
# endif
if (zf == NULL)
{
printf("error opening %s\n",filename_try);
err= ZIP_ERRNO;
}
else
printf("creating %s\n",filename_try);
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
{
if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
((argv[i][1]=='o') || (argv[i][1]=='O') ||
(argv[i][1]=='a') || (argv[i][1]=='A') ||
(argv[i][1]=='p') || (argv[i][1]=='P') ||
((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
(strlen(argv[i]) == 2)))
{
FILE * fin;
int size_read;
const char* filenameinzip = argv[i];
zip_fileinfo zi;
unsigned long crcFile=0;
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
zi.dosDate = 0;
zi.internal_fa = 0;
zi.external_fa = 0;
filetime__minizip(filenameinzip,&zi.tmz_date,&zi.dosDate);
/*
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL / * comment * /,
(opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level);
*/
if ((password != NULL) && (err==ZIP_OK))
err = getFileCrc__minizip(filenameinzip,buf,size_buf,&crcFile);
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
NULL,0,NULL,0,NULL /* comment*/,
(opt_compress_level != 0) ? Z_DEFLATED : 0,
opt_compress_level,0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
password,crcFile);
if (err != ZIP_OK)
printf("error in opening %s in zipfile\n",filenameinzip);
else
{
fin = fopen(filenameinzip,"rb");
if (fin==NULL)
{
err=ZIP_ERRNO;
printf("error in opening %s for reading\n",filenameinzip);
}
}
if (err == ZIP_OK)
do
{
err = ZIP_OK;
size_read = (int)fread(buf,1,size_buf,fin);
if (size_read < size_buf)
if (feof(fin)==0)
{
printf("error in reading %s\n",filenameinzip);
err = ZIP_ERRNO;
}
if (size_read>0)
{
err = zipWriteInFileInZip (zf,buf,size_read);
if (err<0)
{
printf("error in writing %s in the zipfile\n",
filenameinzip);
}
}
} while ((err == ZIP_OK) && (size_read>0));
if (fin)
fclose(fin);
if (err<0)
err=ZIP_ERRNO;
else
{
err = zipCloseFileInZip(zf);
if (err!=ZIP_OK)
printf("error in closing %s in the zipfile\n",
filenameinzip);
}
}
}
errclose = zipClose(zf,NULL);
if (errclose != ZIP_OK)
printf("error in closing %s\n",filename_try);
}
else
{
do_help__minizip();
}
free(buf);
return 0;
}
int main(int argc, char *argv[])
{
const char *zipfilename=NULL;
const char *filename_to_extract=NULL;
const char *password=NULL;
char filename_try[MAXFILENAME+16] = "";
int i;
int opt_do_list=0;
int opt_do_extract=1;
int opt_do_extract_withoutpath=0;
int opt_overwrite=0;
int opt_extractdir=0;
const char *dirname=NULL;
unzFile uf=NULL;
do_banner();
if (argc==1)
{
do_help();
return 0;
}
else
{
for (i=1; i<argc; i++)
{
if ((*argv[i])=='-')
{
const char *p=argv[i]+1;
while ((*p)!='\0')
{
char c=*(p++);;
if ((c=='l') || (c=='L'))
opt_do_list = 1;
if ((c=='v') || (c=='V'))
opt_do_list = 1;
if ((c=='x') || (c=='X'))
opt_do_extract = 1;
if ((c=='e') || (c=='E'))
opt_do_extract = opt_do_extract_withoutpath = 1;
if ((c=='o') || (c=='O'))
opt_overwrite=1;
if ((c=='d') || (c=='D'))
{
opt_extractdir=1;
dirname=argv[i+1];
}
if (((c=='p') || (c=='P')) && (i+1<argc))
{
password=argv[i+1];
i++;
}
}
}
else
{
if (zipfilename == NULL)
zipfilename = argv[i];
else if ((filename_to_extract==NULL) && (!opt_extractdir))
filename_to_extract = argv[i] ;
}
}
}
if (zipfilename!=NULL)
{
# ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
# endif
strncpy(filename_try, zipfilename,MAXFILENAME-1);
/* strncpy doesnt append the trailing NULL, of the string is too long. */
filename_try[ MAXFILENAME ] = '\0';
# ifdef USEWIN32IOAPI
fill_win32_filefunc(&ffunc);
uf = unzOpen2(zipfilename,&ffunc);
# else
uf = unzOpen(zipfilename);
# endif
if (uf==NULL)
{
strcat(filename_try,".zip");
# ifdef USEWIN32IOAPI
uf = unzOpen2(filename_try,&ffunc);
# else
uf = unzOpen(filename_try);
# endif
}
}
if (uf==NULL)
{
printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
return 1;
}
printf("%s opened\n",filename_try);
if (opt_do_list==1)
return do_list(uf);
else if (opt_do_extract==1)
{
if (opt_extractdir && chdir(dirname))
{
printf("Error changing into %s, aborting\n", dirname);
exit(-1);
}
if (filename_to_extract == NULL)
return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password);
else
return do_extract_onefile(uf,filename_to_extract,
opt_do_extract_withoutpath,opt_overwrite,password);
}
unzCloseCurrentFile(uf);
return 0;
}
