mirror of https://github.com/madler/zlib.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
420 lines
11 KiB
420 lines
11 KiB
/* |
|
minizip.c |
|
Version 1.01e, February 12th, 2005 |
|
|
|
Copyright (C) 1998-2005 Gilles Vollant |
|
*/ |
|
|
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
#include <time.h> |
|
#include <errno.h> |
|
#include <fcntl.h> |
|
|
|
#ifdef unix |
|
# include <unistd.h> |
|
# include <utime.h> |
|
# include <sys/types.h> |
|
# include <sys/stat.h> |
|
#else |
|
# include <direct.h> |
|
# include <io.h> |
|
#endif |
|
|
|
#include "zip.h" |
|
|
|
#ifdef WIN32 |
|
#define USEWIN32IOAPI |
|
#include "iowin32.h" |
|
#endif |
|
|
|
|
|
|
|
#define WRITEBUFFERSIZE (16384) |
|
#define MAXFILENAME (256) |
|
|
|
#ifdef WIN32 |
|
uLong filetime(f, tmzip, dt) |
|
char *f; /* name of file to get info on */ |
|
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
|
uLong *dt; /* dostime */ |
|
{ |
|
int ret = 0; |
|
{ |
|
FILETIME ftLocal; |
|
HANDLE hFind; |
|
WIN32_FIND_DATA ff32; |
|
|
|
hFind = FindFirstFile(f,&ff32); |
|
if (hFind != INVALID_HANDLE_VALUE) |
|
{ |
|
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal); |
|
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0); |
|
FindClose(hFind); |
|
ret = 1; |
|
} |
|
} |
|
return ret; |
|
} |
|
#else |
|
#ifdef unix |
|
uLong filetime(f, tmzip, dt) |
|
char *f; /* name of file to get info on */ |
|
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
|
uLong *dt; /* dostime */ |
|
{ |
|
int ret=0; |
|
struct stat s; /* results of stat() */ |
|
struct tm* filedate; |
|
time_t tm_t=0; |
|
|
|
if (strcmp(f,"-")!=0) |
|
{ |
|
char name[MAXFILENAME+1]; |
|
int len = strlen(f); |
|
if (len > MAXFILENAME) |
|
len = MAXFILENAME; |
|
|
|
strncpy(name, f,MAXFILENAME-1); |
|
/* strncpy doesnt append the trailing NULL, of the string is too long. */ |
|
name[ MAXFILENAME ] = '\0'; |
|
|
|
if (name[len - 1] == '/') |
|
name[len - 1] = '\0'; |
|
/* not all systems allow stat'ing a file with / appended */ |
|
if (stat(name,&s)==0) |
|
{ |
|
tm_t = s.st_mtime; |
|
ret = 1; |
|
} |
|
} |
|
filedate = localtime(&tm_t); |
|
|
|
tmzip->tm_sec = filedate->tm_sec; |
|
tmzip->tm_min = filedate->tm_min; |
|
tmzip->tm_hour = filedate->tm_hour; |
|
tmzip->tm_mday = filedate->tm_mday; |
|
tmzip->tm_mon = filedate->tm_mon ; |
|
tmzip->tm_year = filedate->tm_year; |
|
|
|
return ret; |
|
} |
|
#else |
|
uLong filetime(f, tmzip, dt) |
|
char *f; /* name of file to get info on */ |
|
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
|
uLong *dt; /* dostime */ |
|
{ |
|
return 0; |
|
} |
|
#endif |
|
#endif |
|
|
|
|
|
|
|
|
|
int check_exist_file(filename) |
|
const char* filename; |
|
{ |
|
FILE* ftestexist; |
|
int ret = 1; |
|
ftestexist = fopen(filename,"rb"); |
|
if (ftestexist==NULL) |
|
ret = 0; |
|
else |
|
fclose(ftestexist); |
|
return ret; |
|
} |
|
|
|
void do_banner() |
|
{ |
|
printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n"); |
|
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); |
|
} |
|
|
|
void do_help() |
|
{ |
|
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \ |
|
" -o Overwrite existing file.zip\n" \ |
|
" -a Append to existing file.zip\n" \ |
|
" -0 Store only\n" \ |
|
" -1 Compress faster\n" \ |
|
" -9 Compress better\n\n"); |
|
} |
|
|
|
/* calculate the CRC32 of a file, |
|
because to encrypt a file, we need known the CRC32 of the file before */ |
|
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) |
|
{ |
|
unsigned long calculate_crc=0; |
|
int err=ZIP_OK; |
|
FILE * fin = fopen(filenameinzip,"rb"); |
|
unsigned long size_read = 0; |
|
unsigned long total_read = 0; |
|
if (fin==NULL) |
|
{ |
|
err = ZIP_ERRNO; |
|
} |
|
|
|
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) |
|
calculate_crc = crc32(calculate_crc,buf,size_read); |
|
total_read += size_read; |
|
|
|
} while ((err == ZIP_OK) && (size_read>0)); |
|
|
|
if (fin) |
|
fclose(fin); |
|
|
|
*result_crc=calculate_crc; |
|
printf("file %s crc %x\n",filenameinzip,calculate_crc); |
|
return err; |
|
} |
|
|
|
int main(argc,argv) |
|
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(); |
|
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=='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_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(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); |
|
|
|
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(); |
|
} |
|
|
|
free(buf); |
|
return 0; |
|
}
|
|
|