bool zip::ZipArchiveInput::Open( String_t const& archiveName, bool caseSensitive )
{
m_archiveName = archiveName;
m_caseSensitive = caseSensitive;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
#endif
#ifdef USEWIN32IOAPI
# ifdef SCARAB_WCHAR_MODE
fill_win32_filefunc64W(&ffunc);
# else
fill_win32_filefunc64A(&ffunc);
# endif
uf = unzOpen2_64(m_archiveName.c_str(),&ffunc);
#else
uf = unzOpen64(m_archiveName.c_str());
#endif // USEWIN32IOAPI
if (uf==NULL)
{
m_errorMessage << _T("Can't open ") << m_archiveName << std::endl;
return false;
}
return Index();
}
int TRI_UnzipFile(char const* filename, char const* outPath,
bool skipPaths, bool overwrite,
char const* password, std::string& errorMessage) {
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
#endif
size_t bufferSize = 16384;
void* buffer = (void*)TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, bufferSize, false);
if (buffer == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
unzFile uf = unzOpen2_64(filename, &ffunc);
#else
unzFile uf = unzOpen64(filename);
#endif
if (uf == nullptr) {
errorMessage = std::string("unable to open zip file ") + filename;
return TRI_ERROR_INTERNAL;
}
int res = UnzipFile(uf, buffer, bufferSize, outPath, skipPaths, overwrite,
password, errorMessage);
unzClose(uf);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return res;
}
zipFile FileUtils::mzOpenOutputFile(const std::string &path)
{
#ifdef USEWIN32IOAPI
zlib_filefunc64_def zFunc;
memset(&zFunc, 0, sizeof(zFunc));
fill_win32_filefunc64A(&zFunc);
return zipOpen2_64(path.c_str(), 0, nullptr, &zFunc);
#else
return zipOpen64(path.c_str(), 0);
#endif
}
celix_status_t extractBundle(char * bundleName, char * revisionRoot) {
celix_status_t status = CELIX_SUCCESS;
char filename_try[MAXFILENAME+16] = "";
unzFile uf=NULL;
if (bundleName!=NULL)
{
# ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
# endif
strncpy(filename_try, bundleName,MAXFILENAME-1);
/* strncpy doesnt append the trailing NULL, of the string is too long. */
filename_try[ MAXFILENAME ] = '\0';
# ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
uf = unzOpen2_64(bundleName,&ffunc);
# else
uf = unzOpen64(bundleName);
# endif
if (uf==NULL)
{
strcat(filename_try,".zip");
# ifdef USEWIN32IOAPI
uf = unzOpen2_64(filename_try,&ffunc);
# else
uf = unzOpen64(filename_try);
# endif
}
}
if (uf==NULL)
{
printf("Cannot open %s or %s.zip\n",bundleName,bundleName);
status = CELIX_FILE_IO_EXCEPTION;
} else {
if (do_extract(uf, revisionRoot) != 0) {
status = CELIX_FILE_IO_EXCEPTION;
}
unzClose(uf);
}
return status;
}
int TRI_UnzipFile (const char* filename,
const char* outPath,
const bool skipPaths,
const bool overwrite,
const char* password) {
unzFile uf;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
#endif
void* buffer;
size_t bufferSize;
int res;
bufferSize = 16384;
buffer = (void*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, bufferSize, false);
if (buffer == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
uf = unzOpen2_64(filename, &ffunc);
#else
uf = unzOpen64(filename);
#endif
res = UnzipFile(uf, buffer, bufferSize, outPath, skipPaths, overwrite, password);
unzClose(uf);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return res;
}
int TRI_ZipFile (const char* filename,
const char* dir,
TRI_vector_string_t const* files,
const char* password) {
void* buffer;
size_t bufferSize;
zipFile zf;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
#endif
size_t i, n;
int res;
if (TRI_ExistsFile(filename)) {
return TRI_ERROR_CANNOT_OVERWRITE_FILE;
}
bufferSize = 16384;
buffer = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, bufferSize, false);
if (buffer == NULL) {
return TRI_ERROR_OUT_OF_MEMORY;
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(filename, 0, NULL, &ffunc);
#else
zf = zipOpen64(filename, 0);
#endif
if (zf == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return ZIP_ERRNO;
}
res = TRI_ERROR_NO_ERROR;
n = files->_length;
for (i = 0; i < n; ++i) {
FILE* fin;
char* file;
char* fullfile;
char* saveName;
zip_fileinfo zi;
uint32_t crc;
int isLarge;
file = TRI_AtVectorString(files, i);
if (*dir == '\0') {
fullfile = TRI_DuplicateString(file);
}
else {
fullfile = TRI_Concatenate2File(dir, file);
}
memset(&zi, 0, sizeof(zi));
res = TRI_Crc32File(fullfile, &crc);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
isLarge = (TRI_SizeFile(file) > 0xFFFFFFFFLL);
saveName = file;
while (*saveName == '\\' || *saveName == '/') {
++saveName;
}
if (zipOpenNewFileInZip3_64(zf,
saveName,
&zi,
NULL,
0,
NULL,
0,
NULL, /* comment*/
Z_DEFLATED,
Z_DEFAULT_COMPRESSION,
0,
-MAX_WBITS,
DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY,
password,
(unsigned long) crc,
isLarge) != ZIP_OK) {
}
fin = fopen(fullfile, "rb");
TRI_FreeString(TRI_CORE_MEM_ZONE, fullfile);
if (fin == NULL) {
break;
}
while (true) {
int sizeRead;
sizeRead = (int) fread(buffer, 1, bufferSize, fin);
if (sizeRead < bufferSize) {
if (feof(fin) == 0) {
res = TRI_set_errno(TRI_ERROR_SYS_ERROR);
break;
}
}
if (sizeRead > 0) {
res = zipWriteInFileInZip(zf, buffer, sizeRead);
if (res != 0) {
break;
}
}
else if (sizeRead <= 0) {
break;
}
}
fclose(fin);
zipCloseFileInZip(zf);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
}
zipClose(zf, NULL);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return res;
}
int main(int argc, char *argv[])
{
zipFile zf = NULL;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc = {0};
#endif
char *zipfilename = NULL;
const char* password = NULL;
void* buf = NULL;
int size_buf = WRITEBUFFERSIZE;
int zipfilenamearg = 0;
int errclose = 0;
int err = 0;
int i = 0;
int opt_overwrite = APPEND_STATUS_CREATE;
int opt_compress_level = Z_DEFAULT_COMPRESSION;
int opt_exclude_path = 0;
do_banner();
if (argc == 1)
{
do_help();
return 0;
}
/* Parse command line options */
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 = APPEND_STATUS_CREATEAFTER;
if ((c == 'a') || (c == 'A'))
opt_overwrite = APPEND_STATUS_ADDINZIP;
if ((c >= '0') && (c <= '9'))
opt_compress_level = (c - '0');
if ((c == 'j') || (c == 'J'))
opt_exclude_path = 1;
if (((c == 'p') || (c == 'P')) && (i+1 < argc))
{
password=argv[i+1];
i++;
}
}
}
else
{
if (zipfilenamearg == 0)
zipfilenamearg = i;
}
}
if (zipfilenamearg == 0)
{
do_help();
return 0;
}
zipfilename = argv[zipfilenamearg];
buf = (void*)malloc(size_buf);
if (buf == NULL)
{
printf("Error allocating memory\n");
return ZIP_INTERNALERROR;
}
if (opt_overwrite == 2)
{
/* If the file don't exist, we not append file */
if (check_file_exists(zipfilename) == 0)
opt_overwrite = 1;
}
else if (opt_overwrite == 0)
{
/* If ask the user what to do because append and overwrite args not set */
//if (check_file_exists(zipfilename) != 0)
//{
// char rep = 0;
// do
// {
// char answer[128];
// printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ", zipfilename);
// if (scanf("%1s", answer) != 1)
// exit(EXIT_FAILURE);
// rep = answer[0];
// if ((rep >= 'a') && (rep <= 'z'))
// rep -= 0x20;
// }
// while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
// if (rep == 'A')
// opt_overwrite = 2;
// else if (rep == 'N')
// {
// do_help();
// free(buf);
// return 0;
// }
//}
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(zipfilename, opt_overwrite, NULL, &ffunc);
#else
zf = zipOpen64(zipfilename, opt_overwrite);
#endif
if (zf == NULL)
{
printf("error opening %s\n", zipfilename);
err = ZIP_ERRNO;
}
else
printf("creating %s\n", zipfilename);
/* Go through command line args looking for files to add to zip */
for (i = zipfilenamearg + 1; (i < argc) && (err == ZIP_OK); i++)
{
FILE *fin = NULL;
int size_read = 0;
const char* filenameinzip = argv[i];
const char *savefilenameinzip;
zip_fileinfo zi = {0};
unsigned long crcFile = 0;
int zip64 = 0;
/* Skip command line options */
if ((((*(argv[i])) == '-') || ((*(argv[i])) == '/')) && (strlen(argv[i]) == 2) &&
((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'))))
continue;
/* Get information about the file on disk so we can store it in zip */
filetime(filenameinzip, &zi.tmz_date, &zi.dosDate);
if ((password != NULL) && (err == ZIP_OK))
err = get_file_crc(filenameinzip, buf, size_buf, &crcFile);
zip64 = is_large_file(filenameinzip);
/* Construct the filename that our file will be stored in the zip as.
The path name saved, should not include a leading slash.
If it did, windows/xp and dynazip couldn't read the zip file. */
savefilenameinzip = filenameinzip;
while (savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/')
savefilenameinzip++;
/* Should the file be stored with any path info at all? */
if (opt_exclude_path)
{
const char *tmpptr = NULL;
const char *lastslash = 0;
for (tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
{
if (*tmpptr == '\\' || *tmpptr == '/')
lastslash = tmpptr;
}
if (lastslash != NULL)
savefilenameinzip = lastslash + 1; /* base filename follows last slash. */
}
/* Add to zip file */
err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &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,
password, crcFile, zip64);
if (err != ZIP_OK)
printf("error in opening %s in zipfile (%d)\n", filenameinzip, err);
else
{
fin = FOPEN_FUNC(filenameinzip, "rb");
if (fin == NULL)
{
err = ZIP_ERRNO;
printf("error in opening %s for reading\n", filenameinzip);
}
}
if (err == ZIP_OK)
{
/* Read contents of file and write it to zip */
do
{
size_read = (int)fread(buf, 1, size_buf, fin);
if ((size_read < size_buf) && (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 (%d)\n", filenameinzip, err);
}
}
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 (%d)\n", filenameinzip, err);
}
}
errclose = zipClose(zf, NULL);
if (errclose != ZIP_OK)
printf("error in closing %s (%d)\n", zipfilename, errclose);
free(buf);
return err;
}
int _compress(const char** srcs, int src_num, const char** srcspath, int srcpath_num,
const char* dst, int level, const char* password, int exclude_path, PyObject* progress)
{
zipFile zf = NULL;
int size_buf = WRITEBUFFERSIZE;
int opt_overwrite = APPEND_STATUS_CREATE;
int err = ZIP_OK;
int errclose = 0;
int i;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc = {0};
#endif
void* buf = NULL;
buf = (void*)malloc(size_buf);
if (buf == NULL)
{
pyerr_msg = PyErr_Format(PyExc_MemoryError, "could not allocate memory");
return ZIP_ERRNO;
}
if (srcpath_num > 0)
assert(src_num == srcpath_num);
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(dst, opt_overwrite, NULL, &ffunc);
#else
zf = zipOpen64(dst, opt_overwrite);
#endif
if (zf == NULL)
{
pyerr_msg = PyErr_Format(PyExc_IOError, "error opening %s", dst);
err = ZIP_ERRNO;
}
for (i = 0; i < src_num && (err == ZIP_OK); i++) {
FILE *fin = NULL;
int size_read = 0;
const char* filenameinzip = srcs[i];
const char* filepathnameinzip;
const char *savefilenameinzip;
const char *savefilepathnameinzip = NULL;
char *fullpathfileinzip = NULL;
unsigned long crcFile = 0;
int zip64 = 0;
zip_fileinfo zi;
memset(&zi, 0, sizeof(zip_fileinfo));
if (srcpath_num > 0)
filepathnameinzip = srcspath[i];
/* Get information about the file on disk so we can store it in zip */
filetime(filenameinzip, &zi.tmz_date, &zi.dosDate);
if ((password != NULL) && (err == ZIP_OK))
err = get_file_crc(filenameinzip, buf, size_buf, &crcFile);
zip64 = is_large_file(filenameinzip);
/* Construct the filename that our file will be stored in the zip as.
The path name saved, should not include a leading slash.
If it did, windows/xp and dynazip couldn't read the zip file. */
savefilenameinzip = filenameinzip;
while (savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/')
savefilenameinzip++;
if (srcpath_num > 0) {
savefilepathnameinzip = filepathnameinzip;
while (savefilepathnameinzip[0] == '\\' || savefilepathnameinzip[0] == '/')
savefilepathnameinzip++;
}
/* Should the file be stored with any path info at all? */
if (exclude_path)
{
const char *tmpptr = NULL;
const char *lastslash = NULL;
for (tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
{
if (*tmpptr == '\\' || *tmpptr == '/')
lastslash = tmpptr;
}
if (lastslash != NULL)
savefilenameinzip = lastslash + 1; // base filename follows last slash.
if (srcpath_num > 0) {
/* prepend savefilepathnameinzip for each savefilenameinzip */
const char * slash;
#if (defined(_WIN32))
const char default_slash = '\\';
#else
const char default_slash = '/';
#endif
size_t extra_len = 0;
size_t filename_len = strlen(savefilenameinzip);
size_t filepathname_len = strlen(savefilepathnameinzip);
/* look for slash used in filepath */
slash = strchr(savefilepathnameinzip, '/');
if (slash == NULL) {
slash = strchr(savefilepathnameinzip, '\\');
if (slash == NULL) {
// no slash found.. use default
slash = &default_slash;
}
}
if (savefilepathnameinzip[filepathname_len-1] != *slash)
extra_len = 1;
/* allocate buffer */
fullpathfileinzip = (char *)malloc(filename_len + filepathname_len + extra_len + 1);
if (fullpathfileinzip == NULL) {
free(buf);
pyerr_msg = PyErr_Format(PyExc_MemoryError, "error allocating memory on minizip compress");
return ZIP_INTERNALERROR;
}
strncpy(fullpathfileinzip, savefilepathnameinzip, filepathname_len);
if (extra_len)
fullpathfileinzip[filepathname_len] = *slash;
strncpy(fullpathfileinzip + filepathname_len + extra_len, savefilenameinzip, filename_len);
/* terminate string */
fullpathfileinzip[filename_len + filepathname_len + extra_len] = '\0';
/* set pointer */
savefilenameinzip = fullpathfileinzip;
}
}
/* Add to zip file */
err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &zi,
NULL, 0, NULL, 0, NULL /* comment*/,
(level != 0) ? Z_DEFLATED : 0, level, 0,
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
password, crcFile, zip64);
if (err != ZIP_OK) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in opening %s in zipfile (%d)", filenameinzip, err);
err = ZIP_ERRNO;
}
else
{
fin = FOPEN_FUNC(filenameinzip, "rb");
if (fin == NULL)
{
pyerr_msg = PyErr_Format(PyExc_IOError, "error in opening %s for reading", filenameinzip);
err = ZIP_ERRNO;
}
}
if (err == ZIP_OK)
{
/* Read contents of file and write it to zip */
do
{
size_read = (int)fread(buf, 1, size_buf, fin);
if ((size_read < size_buf) && (feof(fin) == 0))
{
pyerr_msg = PyErr_Format(PyExc_IOError, "error in reading %s", filenameinzip);
err = ZIP_ERRNO;
}
if (0 < size_read)
{
err = zipWriteInFileInZip(zf, buf, size_read);
if (err < 0) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in writing %s in the zipfile (%d)", filenameinzip, err);
err = ZIP_ERRNO;
}
}
}
while ((err == ZIP_OK) && (size_read > 0));
}
if (fin)
fclose(fin);
if (err == ZIP_OK)
{
err = zipCloseFileInZip(zf);
if (err != ZIP_OK) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in closing %s in the zipfile (%d)", filenameinzip, err);
err = ZIP_ERRNO;
}
}
if (progress != NULL)
{
PyObject* args = Py_BuildValue("(I)", i + 1);
PyObject* result = PyObject_CallObject(progress, args);
if (PyErr_Occurred()) // Ignore errors in the callback, don't want them to crash this c module
{
PyErr_Clear();
}
Py_XDECREF(result);
Py_XDECREF(args);
}
if(srcpath_num > 0 && fullpathfileinzip)
free(fullpathfileinzip);
}
errclose = zipClose(zf, NULL);
if (errclose != ZIP_OK) {
pyerr_msg = PyErr_Format(PyExc_IOError, "error in closing %s (%d)", dst, errclose);
err = ZIP_ERRNO;
}
free(buf);
return err;
}
unsigned char * LoadFirstFileInZip(const char* path,unsigned int *length)
{
unzFile uf=NULL;
void* buf=NULL;
# ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
# endif
# ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
uf = unzOpen2_64(path,&ffunc);
# else
uf = unzOpen64(path);
# endif
if (uf==NULL)
{
printf("Cannot open %s as zip\n",path);
return 0;
}
// Was do Extract- -
{
uLong i;
unz_global_info64 gi;
int err;
err = unzGetGlobalInfo64(uf,&gi);
if (err!=UNZ_OK || gi.number_entry<1)
{
printf("error %d with zipfile in unzGetGlobalInfo \n",err);
return 0;
}
{
char filename_inzip[256];
char* filename_withoutpath;
char* p;
int err=UNZ_OK;
FILE *fout=NULL;
uInt size_buf;
unz_file_info64 file_info;
uLong ratio=0;
err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
if (err!=UNZ_OK)
{
printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
return 0;
}
size_buf=file_info.uncompressed_size;
buf = malloc(file_info.uncompressed_size);
if (buf==NULL)
{
printf("Error allocating memory\n");
return 0;
}
err = unzOpenCurrentFilePassword(uf,NULL);
if (err!=UNZ_OK)
{
printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
return 0;
}
do
{
err = unzReadCurrentFile(uf,buf,size_buf);
if (err<0)
{
printf("error %d with zipfile in unzReadCurrentFile\n",err);
return 0;
}
}
while (err>0);
if (err==UNZ_OK)
{
err = unzCloseCurrentFile (uf);
if (err!=UNZ_OK)
{
printf("error %d with zipfile in unzCloseCurrentFile\n",err);
return 0;
}
}
*length=size_buf;
}
}
unzClose(uf);
return buf;
}
int main(int argc,char *argv[])
{
char zipfilename[MAXFILENAME]= {0};
char filename_to_extract[MAXFILENAME]= {0};
const char *password=NULL;
char filename_try[MAXFILENAME+16] = "";
int i;
int ret_value=0;
int opt_do_list=0;
int opt_do_extract=1;
int opt_do_extract_withoutpath=0;
int opt_overwrite=0;
int opt_extractdir=0;
char dirname[MAXFILENAME]= {0};
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;
strcat(dirname,__DIR__);
strcat(dirname,"/");
strcat(dirname,argv[i+1]);
}
if (((c=='p') || (c=='P')) && (i+1<argc))
{
password=argv[i+1];
i++;
}
}
}
else
{
if (!strlen(zipfilename))
{
strcat(zipfilename,__DIR__);
strcat(zipfilename,"/");
strcat(zipfilename,argv[i]);
}
else if ((!strlen(filename_to_extract)) && (!opt_extractdir))
{
strcat(filename_to_extract,__DIR__);
strcat(filename_to_extract,"/");
strcat(filename_to_extract,argv[i]);
}
}
}
}
if (strlen(zipfilename))
{
# ifdef USEWIN32IOAPI
zlib_filefunc64_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_filefunc64A(&ffunc);
uf = unzOpen2_64(zipfilename,&ffunc);
# else
uf = unzOpen64(zipfilename);
# endif
if (uf==NULL)
{
strcat(filename_try,".zip");
# ifdef USEWIN32IOAPI
uf = unzOpen2_64(filename_try,&ffunc);
# else
uf = unzOpen64(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)
ret_value = do_list(uf);
else if (opt_do_extract==1)
{
chdir(__DIR__);
#ifdef _WIN32
if (opt_extractdir && _chdir(dirname))
#else
if (opt_extractdir && chdir(dirname))
#endif
{
printf("Error changing into %s, aborting\n", dirname);
exit(-1);
}
if (!strlen(filename_to_extract))
ret_value = do_extract(uf, opt_do_extract_withoutpath, opt_overwrite, password);
else
ret_value = do_extract_onefile(uf, filename_to_extract, opt_do_extract_withoutpath, opt_overwrite, password);
}
unzClose(uf);
return ret_value;
}
int TRI_ZipFile(char const* filename, char const* dir,
std::vector<std::string> const& files, char const* password) {
void* buffer;
#ifdef USEWIN32IOAPI
zlib_filefunc64_def ffunc;
#endif
if (TRI_ExistsFile(filename)) {
return TRI_ERROR_CANNOT_OVERWRITE_FILE;
}
int bufferSize = 16384;
buffer = TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, (size_t)bufferSize, false);
if (buffer == nullptr) {
return TRI_ERROR_OUT_OF_MEMORY;
}
#ifdef USEWIN32IOAPI
fill_win32_filefunc64A(&ffunc);
zipFile zf = zipOpen2_64(filename, 0, NULL, &ffunc);
#else
zipFile zf = zipOpen64(filename, 0);
#endif
if (zf == nullptr) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return ZIP_ERRNO;
}
int res = TRI_ERROR_NO_ERROR;
size_t n = files.size();
for (size_t i = 0; i < n; ++i) {
std::string fullfile;
if (*dir == '\0') {
fullfile = files[i];
} else {
fullfile = arangodb::basics::FileUtils::buildFilename(dir, files[i]);
}
zip_fileinfo zi;
memset(&zi, 0, sizeof(zi));
uint32_t crc;
res = TRI_Crc32File(fullfile.c_str(), &crc);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
int isLarge = (TRI_SizeFile(files[i].c_str()) > 0xFFFFFFFFLL);
char const* saveName = files[i].c_str();
while (*saveName == '\\' || *saveName == '/') {
++saveName;
}
if (zipOpenNewFileInZip3_64(
zf, saveName, &zi, NULL, 0, NULL, 0, NULL, /* comment*/
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL,
Z_DEFAULT_STRATEGY, password, (unsigned long)crc,
isLarge) != ZIP_OK) {
res = TRI_ERROR_INTERNAL;
break;
}
FILE* fin = fopen(fullfile.c_str(), "rb");
if (fin == nullptr) {
break;
}
while (true) {
int sizeRead = (int)fread(buffer, 1, bufferSize, fin);
if (sizeRead < bufferSize) {
if (feof(fin) == 0) {
res = TRI_set_errno(TRI_ERROR_SYS_ERROR);
break;
}
}
if (sizeRead > 0) {
res = zipWriteInFileInZip(zf, buffer, sizeRead);
if (res != 0) {
break;
}
} else /* if (sizeRead <= 0) */ {
break;
}
}
fclose(fin);
zipCloseFileInZip(zf);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
}
zipClose(zf, NULL);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, buffer);
return res;
}
int main(
int argc,
char *argv[])
{
int i;
int opt_overwrite=0;
int opt_compress_level=Z_DEFAULT_COMPRESSION;
int opt_exclude_path=0;
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();
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=='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=='j') || (c=='J'))
opt_exclude_path = 1;
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(filename_try)==0)
opt_overwrite=1;
}
else
if (opt_overwrite==0)
if (check_exist_file(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_filefunc64_def ffunc;
fill_win32_filefunc64A(&ffunc);
zf = zipOpen2_64(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
# else
zf = zipOpen64(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];
const char *savefilenameinzip;
zip_fileinfo zi;
unsigned long crcFile=0;
int zip64 = 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(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(filenameinzip,buf,size_buf,&crcFile);
zip64 = isLargeFile(filenameinzip);
/* The path name saved, should not include a leading slash. */
/*if it did, windows/xp and dynazip couldn't read the zip file. */
savefilenameinzip = filenameinzip;
while( savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/' )
{
savefilenameinzip++;
}
/*should the zip file contain any path at all?*/
if( opt_exclude_path )
{
const char *tmpptr;
const char *lastslash = 0;
for( tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
{
if( *tmpptr == '\\' || *tmpptr == '/')
{
lastslash = tmpptr;
}
}
if( lastslash != NULL )
{
savefilenameinzip = lastslash+1; // base filename follows last slash.
}
}
/**/
err = zipOpenNewFileInZip3_64(zf,savefilenameinzip,&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, zip64);
if (err != ZIP_OK)
printf("error in opening %s in zipfile\n",filenameinzip);
else
{
fin = FOPEN_FUNC(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();
}
free(buf);
return 0;
}