diff options
Diffstat (limited to 'contrib/minizip/miniunz.c')
-rw-r--r-- | contrib/minizip/miniunz.c | 1170 |
1 files changed, 585 insertions, 585 deletions
diff --git a/contrib/minizip/miniunz.c b/contrib/minizip/miniunz.c index 82d8702..f599938 100644 --- a/contrib/minizip/miniunz.c +++ b/contrib/minizip/miniunz.c | |||
@@ -1,585 +1,585 @@ | |||
1 | /* | 1 | /* |
2 | miniunz.c | 2 | miniunz.c |
3 | Version 1.01e, February 12th, 2005 | 3 | Version 1.01e, February 12th, 2005 |
4 | 4 | ||
5 | Copyright (C) 1998-2005 Gilles Vollant | 5 | Copyright (C) 1998-2005 Gilles Vollant |
6 | */ | 6 | */ |
7 | 7 | ||
8 | 8 | ||
9 | #include <stdio.h> | 9 | #include <stdio.h> |
10 | #include <stdlib.h> | 10 | #include <stdlib.h> |
11 | #include <string.h> | 11 | #include <string.h> |
12 | #include <time.h> | 12 | #include <time.h> |
13 | #include <errno.h> | 13 | #include <errno.h> |
14 | #include <fcntl.h> | 14 | #include <fcntl.h> |
15 | 15 | ||
16 | #ifdef unix | 16 | #ifdef unix |
17 | # include <unistd.h> | 17 | # include <unistd.h> |
18 | # include <utime.h> | 18 | # include <utime.h> |
19 | #else | 19 | #else |
20 | # include <direct.h> | 20 | # include <direct.h> |
21 | # include <io.h> | 21 | # include <io.h> |
22 | #endif | 22 | #endif |
23 | 23 | ||
24 | #include "unzip.h" | 24 | #include "unzip.h" |
25 | 25 | ||
26 | #define CASESENSITIVITY (0) | 26 | #define CASESENSITIVITY (0) |
27 | #define WRITEBUFFERSIZE (8192) | 27 | #define WRITEBUFFERSIZE (8192) |
28 | #define MAXFILENAME (256) | 28 | #define MAXFILENAME (256) |
29 | 29 | ||
30 | #ifdef WIN32 | 30 | #ifdef WIN32 |
31 | #define USEWIN32IOAPI | 31 | #define USEWIN32IOAPI |
32 | #include "iowin32.h" | 32 | #include "iowin32.h" |
33 | #endif | 33 | #endif |
34 | /* | 34 | /* |
35 | mini unzip, demo of unzip package | 35 | mini unzip, demo of unzip package |
36 | 36 | ||
37 | usage : | 37 | usage : |
38 | Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir] | 38 | Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir] |
39 | 39 | ||
40 | list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT | 40 | list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT |
41 | if it exists | 41 | if it exists |
42 | */ | 42 | */ |
43 | 43 | ||
44 | 44 | ||
45 | /* change_file_date : change the date/time of a file | 45 | /* change_file_date : change the date/time of a file |
46 | filename : the filename of the file where date/time must be modified | 46 | filename : the filename of the file where date/time must be modified |
47 | dosdate : the new date at the MSDos format (4 bytes) | 47 | dosdate : the new date at the MSDos format (4 bytes) |
48 | tmu_date : the SAME new date at the tm_unz format */ | 48 | tmu_date : the SAME new date at the tm_unz format */ |
49 | void change_file_date(filename,dosdate,tmu_date) | 49 | void change_file_date(filename,dosdate,tmu_date) |
50 | const char *filename; | 50 | const char *filename; |
51 | uLong dosdate; | 51 | uLong dosdate; |
52 | tm_unz tmu_date; | 52 | tm_unz tmu_date; |
53 | { | 53 | { |
54 | #ifdef WIN32 | 54 | #ifdef WIN32 |
55 | HANDLE hFile; | 55 | HANDLE hFile; |
56 | FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite; | 56 | FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite; |
57 | 57 | ||
58 | hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE, | 58 | hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE, |
59 | 0,NULL,OPEN_EXISTING,0,NULL); | 59 | 0,NULL,OPEN_EXISTING,0,NULL); |
60 | GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite); | 60 | GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite); |
61 | DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal); | 61 | DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal); |
62 | LocalFileTimeToFileTime(&ftLocal,&ftm); | 62 | LocalFileTimeToFileTime(&ftLocal,&ftm); |
63 | SetFileTime(hFile,&ftm,&ftLastAcc,&ftm); | 63 | SetFileTime(hFile,&ftm,&ftLastAcc,&ftm); |
64 | CloseHandle(hFile); | 64 | CloseHandle(hFile); |
65 | #else | 65 | #else |
66 | #ifdef unix | 66 | #ifdef unix |
67 | struct utimbuf ut; | 67 | struct utimbuf ut; |
68 | struct tm newdate; | 68 | struct tm newdate; |
69 | newdate.tm_sec = tmu_date.tm_sec; | 69 | newdate.tm_sec = tmu_date.tm_sec; |
70 | newdate.tm_min=tmu_date.tm_min; | 70 | newdate.tm_min=tmu_date.tm_min; |
71 | newdate.tm_hour=tmu_date.tm_hour; | 71 | newdate.tm_hour=tmu_date.tm_hour; |
72 | newdate.tm_mday=tmu_date.tm_mday; | 72 | newdate.tm_mday=tmu_date.tm_mday; |
73 | newdate.tm_mon=tmu_date.tm_mon; | 73 | newdate.tm_mon=tmu_date.tm_mon; |
74 | if (tmu_date.tm_year > 1900) | 74 | if (tmu_date.tm_year > 1900) |
75 | newdate.tm_year=tmu_date.tm_year - 1900; | 75 | newdate.tm_year=tmu_date.tm_year - 1900; |
76 | else | 76 | else |
77 | newdate.tm_year=tmu_date.tm_year ; | 77 | newdate.tm_year=tmu_date.tm_year ; |
78 | newdate.tm_isdst=-1; | 78 | newdate.tm_isdst=-1; |
79 | 79 | ||
80 | ut.actime=ut.modtime=mktime(&newdate); | 80 | ut.actime=ut.modtime=mktime(&newdate); |
81 | utime(filename,&ut); | 81 | utime(filename,&ut); |
82 | #endif | 82 | #endif |
83 | #endif | 83 | #endif |
84 | } | 84 | } |
85 | 85 | ||
86 | 86 | ||
87 | /* mymkdir and change_file_date are not 100 % portable | 87 | /* mymkdir and change_file_date are not 100 % portable |
88 | As I don't know well Unix, I wait feedback for the unix portion */ | 88 | As I don't know well Unix, I wait feedback for the unix portion */ |
89 | 89 | ||
90 | int mymkdir(dirname) | 90 | int mymkdir(dirname) |
91 | const char* dirname; | 91 | const char* dirname; |
92 | { | 92 | { |
93 | int ret=0; | 93 | int ret=0; |
94 | #ifdef WIN32 | 94 | #ifdef WIN32 |
95 | ret = mkdir(dirname); | 95 | ret = mkdir(dirname); |
96 | #else | 96 | #else |
97 | #ifdef unix | 97 | #ifdef unix |
98 | ret = mkdir (dirname,0775); | 98 | ret = mkdir (dirname,0775); |
99 | #endif | 99 | #endif |
100 | #endif | 100 | #endif |
101 | return ret; | 101 | return ret; |
102 | } | 102 | } |
103 | 103 | ||
104 | int makedir (newdir) | 104 | int makedir (newdir) |
105 | char *newdir; | 105 | char *newdir; |
106 | { | 106 | { |
107 | char *buffer ; | 107 | char *buffer ; |
108 | char *p; | 108 | char *p; |
109 | int len = (int)strlen(newdir); | 109 | int len = (int)strlen(newdir); |
110 | 110 | ||
111 | if (len <= 0) | 111 | if (len <= 0) |
112 | return 0; | 112 | return 0; |
113 | 113 | ||
114 | buffer = (char*)malloc(len+1); | 114 | buffer = (char*)malloc(len+1); |
115 | strcpy(buffer,newdir); | 115 | strcpy(buffer,newdir); |
116 | 116 | ||
117 | if (buffer[len-1] == '/') { | 117 | if (buffer[len-1] == '/') { |
118 | buffer[len-1] = '\0'; | 118 | buffer[len-1] = '\0'; |
119 | } | 119 | } |
120 | if (mymkdir(buffer) == 0) | 120 | if (mymkdir(buffer) == 0) |
121 | { | 121 | { |
122 | free(buffer); | 122 | free(buffer); |
123 | return 1; | 123 | return 1; |
124 | } | 124 | } |
125 | 125 | ||
126 | p = buffer+1; | 126 | p = buffer+1; |
127 | while (1) | 127 | while (1) |
128 | { | 128 | { |
129 | char hold; | 129 | char hold; |
130 | 130 | ||
131 | while(*p && *p != '\\' && *p != '/') | 131 | while(*p && *p != '\\' && *p != '/') |
132 | p++; | 132 | p++; |
133 | hold = *p; | 133 | hold = *p; |
134 | *p = 0; | 134 | *p = 0; |
135 | if ((mymkdir(buffer) == -1) && (errno == ENOENT)) | 135 | if ((mymkdir(buffer) == -1) && (errno == ENOENT)) |
136 | { | 136 | { |
137 | printf("couldn't create directory %s\n",buffer); | 137 | printf("couldn't create directory %s\n",buffer); |
138 | free(buffer); | 138 | free(buffer); |
139 | return 0; | 139 | return 0; |
140 | } | 140 | } |
141 | if (hold == 0) | 141 | if (hold == 0) |
142 | break; | 142 | break; |
143 | *p++ = hold; | 143 | *p++ = hold; |
144 | } | 144 | } |
145 | free(buffer); | 145 | free(buffer); |
146 | return 1; | 146 | return 1; |
147 | } | 147 | } |
148 | 148 | ||
149 | void do_banner() | 149 | void do_banner() |
150 | { | 150 | { |
151 | printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n"); | 151 | printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n"); |
152 | printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); | 152 | printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); |
153 | } | 153 | } |
154 | 154 | ||
155 | void do_help() | 155 | void do_help() |
156 | { | 156 | { |
157 | printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \ | 157 | printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \ |
158 | " -e Extract without pathname (junk paths)\n" \ | 158 | " -e Extract without pathname (junk paths)\n" \ |
159 | " -x Extract with pathname\n" \ | 159 | " -x Extract with pathname\n" \ |
160 | " -v list files\n" \ | 160 | " -v list files\n" \ |
161 | " -l list files\n" \ | 161 | " -l list files\n" \ |
162 | " -d directory to extract into\n" \ | 162 | " -d directory to extract into\n" \ |
163 | " -o overwrite files without prompting\n" \ | 163 | " -o overwrite files without prompting\n" \ |
164 | " -p extract crypted file using password\n\n"); | 164 | " -p extract crypted file using password\n\n"); |
165 | } | 165 | } |
166 | 166 | ||
167 | 167 | ||
168 | int do_list(uf) | 168 | int do_list(uf) |
169 | unzFile uf; | 169 | unzFile uf; |
170 | { | 170 | { |
171 | uLong i; | 171 | uLong i; |
172 | unz_global_info gi; | 172 | unz_global_info gi; |
173 | int err; | 173 | int err; |
174 | 174 | ||
175 | err = unzGetGlobalInfo (uf,&gi); | 175 | err = unzGetGlobalInfo (uf,&gi); |
176 | if (err!=UNZ_OK) | 176 | if (err!=UNZ_OK) |
177 | printf("error %d with zipfile in unzGetGlobalInfo \n",err); | 177 | printf("error %d with zipfile in unzGetGlobalInfo \n",err); |
178 | printf(" Length Method Size Ratio Date Time CRC-32 Name\n"); | 178 | printf(" Length Method Size Ratio Date Time CRC-32 Name\n"); |
179 | printf(" ------ ------ ---- ----- ---- ---- ------ ----\n"); | 179 | printf(" ------ ------ ---- ----- ---- ---- ------ ----\n"); |
180 | for (i=0;i<gi.number_entry;i++) | 180 | for (i=0;i<gi.number_entry;i++) |
181 | { | 181 | { |
182 | char filename_inzip[256]; | 182 | char filename_inzip[256]; |
183 | unz_file_info file_info; | 183 | unz_file_info file_info; |
184 | uLong ratio=0; | 184 | uLong ratio=0; |
185 | const char *string_method; | 185 | const char *string_method; |
186 | char charCrypt=' '; | 186 | char charCrypt=' '; |
187 | err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); | 187 | err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); |
188 | if (err!=UNZ_OK) | 188 | if (err!=UNZ_OK) |
189 | { | 189 | { |
190 | printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); | 190 | printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); |
191 | break; | 191 | break; |
192 | } | 192 | } |
193 | if (file_info.uncompressed_size>0) | 193 | if (file_info.uncompressed_size>0) |
194 | ratio = (file_info.compressed_size*100)/file_info.uncompressed_size; | 194 | ratio = (file_info.compressed_size*100)/file_info.uncompressed_size; |
195 | 195 | ||
196 | /* display a '*' if the file is crypted */ | 196 | /* display a '*' if the file is crypted */ |
197 | if ((file_info.flag & 1) != 0) | 197 | if ((file_info.flag & 1) != 0) |
198 | charCrypt='*'; | 198 | charCrypt='*'; |
199 | 199 | ||
200 | if (file_info.compression_method==0) | 200 | if (file_info.compression_method==0) |
201 | string_method="Stored"; | 201 | string_method="Stored"; |
202 | else | 202 | else |
203 | if (file_info.compression_method==Z_DEFLATED) | 203 | if (file_info.compression_method==Z_DEFLATED) |
204 | { | 204 | { |
205 | uInt iLevel=(uInt)((file_info.flag & 0x6)/2); | 205 | uInt iLevel=(uInt)((file_info.flag & 0x6)/2); |
206 | if (iLevel==0) | 206 | if (iLevel==0) |
207 | string_method="Defl:N"; | 207 | string_method="Defl:N"; |
208 | else if (iLevel==1) | 208 | else if (iLevel==1) |
209 | string_method="Defl:X"; | 209 | string_method="Defl:X"; |
210 | else if ((iLevel==2) || (iLevel==3)) | 210 | else if ((iLevel==2) || (iLevel==3)) |
211 | string_method="Defl:F"; /* 2:fast , 3 : extra fast*/ | 211 | string_method="Defl:F"; /* 2:fast , 3 : extra fast*/ |
212 | } | 212 | } |
213 | else | 213 | else |
214 | string_method="Unkn. "; | 214 | string_method="Unkn. "; |
215 | 215 | ||
216 | printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n", | 216 | printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n", |
217 | file_info.uncompressed_size,string_method, | 217 | file_info.uncompressed_size,string_method, |
218 | charCrypt, | 218 | charCrypt, |
219 | file_info.compressed_size, | 219 | file_info.compressed_size, |
220 | ratio, | 220 | ratio, |
221 | (uLong)file_info.tmu_date.tm_mon + 1, | 221 | (uLong)file_info.tmu_date.tm_mon + 1, |
222 | (uLong)file_info.tmu_date.tm_mday, | 222 | (uLong)file_info.tmu_date.tm_mday, |
223 | (uLong)file_info.tmu_date.tm_year % 100, | 223 | (uLong)file_info.tmu_date.tm_year % 100, |
224 | (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min, | 224 | (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min, |
225 | (uLong)file_info.crc,filename_inzip); | 225 | (uLong)file_info.crc,filename_inzip); |
226 | if ((i+1)<gi.number_entry) | 226 | if ((i+1)<gi.number_entry) |
227 | { | 227 | { |
228 | err = unzGoToNextFile(uf); | 228 | err = unzGoToNextFile(uf); |
229 | if (err!=UNZ_OK) | 229 | if (err!=UNZ_OK) |
230 | { | 230 | { |
231 | printf("error %d with zipfile in unzGoToNextFile\n",err); | 231 | printf("error %d with zipfile in unzGoToNextFile\n",err); |
232 | break; | 232 | break; |
233 | } | 233 | } |
234 | } | 234 | } |
235 | } | 235 | } |
236 | 236 | ||
237 | return 0; | 237 | return 0; |
238 | } | 238 | } |
239 | 239 | ||
240 | 240 | ||
241 | int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password) | 241 | int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password) |
242 | unzFile uf; | 242 | unzFile uf; |
243 | const int* popt_extract_without_path; | 243 | const int* popt_extract_without_path; |
244 | int* popt_overwrite; | 244 | int* popt_overwrite; |
245 | const char* password; | 245 | const char* password; |
246 | { | 246 | { |
247 | char filename_inzip[256]; | 247 | char filename_inzip[256]; |
248 | char* filename_withoutpath; | 248 | char* filename_withoutpath; |
249 | char* p; | 249 | char* p; |
250 | int err=UNZ_OK; | 250 | int err=UNZ_OK; |
251 | FILE *fout=NULL; | 251 | FILE *fout=NULL; |
252 | void* buf; | 252 | void* buf; |
253 | uInt size_buf; | 253 | uInt size_buf; |
254 | 254 | ||
255 | unz_file_info file_info; | 255 | unz_file_info file_info; |
256 | uLong ratio=0; | 256 | uLong ratio=0; |
257 | err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); | 257 | err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); |
258 | 258 | ||
259 | if (err!=UNZ_OK) | 259 | if (err!=UNZ_OK) |
260 | { | 260 | { |
261 | printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); | 261 | printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); |
262 | return err; | 262 | return err; |
263 | } | 263 | } |
264 | 264 | ||
265 | size_buf = WRITEBUFFERSIZE; | 265 | size_buf = WRITEBUFFERSIZE; |
266 | buf = (void*)malloc(size_buf); | 266 | buf = (void*)malloc(size_buf); |
267 | if (buf==NULL) | 267 | if (buf==NULL) |
268 | { | 268 | { |
269 | printf("Error allocating memory\n"); | 269 | printf("Error allocating memory\n"); |
270 | return UNZ_INTERNALERROR; | 270 | return UNZ_INTERNALERROR; |
271 | } | 271 | } |
272 | 272 | ||
273 | p = filename_withoutpath = filename_inzip; | 273 | p = filename_withoutpath = filename_inzip; |
274 | while ((*p) != '\0') | 274 | while ((*p) != '\0') |
275 | { | 275 | { |
276 | if (((*p)=='/') || ((*p)=='\\')) | 276 | if (((*p)=='/') || ((*p)=='\\')) |
277 | filename_withoutpath = p+1; | 277 | filename_withoutpath = p+1; |
278 | p++; | 278 | p++; |
279 | } | 279 | } |
280 | 280 | ||
281 | if ((*filename_withoutpath)=='\0') | 281 | if ((*filename_withoutpath)=='\0') |
282 | { | 282 | { |
283 | if ((*popt_extract_without_path)==0) | 283 | if ((*popt_extract_without_path)==0) |
284 | { | 284 | { |
285 | printf("creating directory: %s\n",filename_inzip); | 285 | printf("creating directory: %s\n",filename_inzip); |
286 | mymkdir(filename_inzip); | 286 | mymkdir(filename_inzip); |
287 | } | 287 | } |
288 | } | 288 | } |
289 | else | 289 | else |
290 | { | 290 | { |
291 | const char* write_filename; | 291 | const char* write_filename; |
292 | int skip=0; | 292 | int skip=0; |
293 | 293 | ||
294 | if ((*popt_extract_without_path)==0) | 294 | if ((*popt_extract_without_path)==0) |
295 | write_filename = filename_inzip; | 295 | write_filename = filename_inzip; |
296 | else | 296 | else |
297 | write_filename = filename_withoutpath; | 297 | write_filename = filename_withoutpath; |
298 | 298 | ||
299 | err = unzOpenCurrentFilePassword(uf,password); | 299 | err = unzOpenCurrentFilePassword(uf,password); |
300 | if (err!=UNZ_OK) | 300 | if (err!=UNZ_OK) |
301 | { | 301 | { |
302 | printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err); | 302 | printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err); |
303 | } | 303 | } |
304 | 304 | ||
305 | if (((*popt_overwrite)==0) && (err==UNZ_OK)) | 305 | if (((*popt_overwrite)==0) && (err==UNZ_OK)) |
306 | { | 306 | { |
307 | char rep=0; | 307 | char rep=0; |
308 | FILE* ftestexist; | 308 | FILE* ftestexist; |
309 | ftestexist = fopen(write_filename,"rb"); | 309 | ftestexist = fopen(write_filename,"rb"); |
310 | if (ftestexist!=NULL) | 310 | if (ftestexist!=NULL) |
311 | { | 311 | { |
312 | fclose(ftestexist); | 312 | fclose(ftestexist); |
313 | do | 313 | do |
314 | { | 314 | { |
315 | char answer[128]; | 315 | char answer[128]; |
316 | int ret; | 316 | int ret; |
317 | 317 | ||
318 | printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename); | 318 | printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename); |
319 | ret = scanf("%1s",answer); | 319 | ret = scanf("%1s",answer); |
320 | if (ret != 1) | 320 | if (ret != 1) |
321 | { | 321 | { |
322 | exit(EXIT_FAILURE); | 322 | exit(EXIT_FAILURE); |
323 | } | 323 | } |
324 | rep = answer[0] ; | 324 | rep = answer[0] ; |
325 | if ((rep>='a') && (rep<='z')) | 325 | if ((rep>='a') && (rep<='z')) |
326 | rep -= 0x20; | 326 | rep -= 0x20; |
327 | } | 327 | } |
328 | while ((rep!='Y') && (rep!='N') && (rep!='A')); | 328 | while ((rep!='Y') && (rep!='N') && (rep!='A')); |
329 | } | 329 | } |
330 | 330 | ||
331 | if (rep == 'N') | 331 | if (rep == 'N') |
332 | skip = 1; | 332 | skip = 1; |
333 | 333 | ||
334 | if (rep == 'A') | 334 | if (rep == 'A') |
335 | *popt_overwrite=1; | 335 | *popt_overwrite=1; |
336 | } | 336 | } |
337 | 337 | ||
338 | if ((skip==0) && (err==UNZ_OK)) | 338 | if ((skip==0) && (err==UNZ_OK)) |
339 | { | 339 | { |
340 | fout=fopen(write_filename,"wb"); | 340 | fout=fopen(write_filename,"wb"); |
341 | 341 | ||
342 | /* some zipfile don't contain directory alone before file */ | 342 | /* some zipfile don't contain directory alone before file */ |
343 | if ((fout==NULL) && ((*popt_extract_without_path)==0) && | 343 | if ((fout==NULL) && ((*popt_extract_without_path)==0) && |
344 | (filename_withoutpath!=(char*)filename_inzip)) | 344 | (filename_withoutpath!=(char*)filename_inzip)) |
345 | { | 345 | { |
346 | char c=*(filename_withoutpath-1); | 346 | char c=*(filename_withoutpath-1); |
347 | *(filename_withoutpath-1)='\0'; | 347 | *(filename_withoutpath-1)='\0'; |
348 | makedir(write_filename); | 348 | makedir(write_filename); |
349 | *(filename_withoutpath-1)=c; | 349 | *(filename_withoutpath-1)=c; |
350 | fout=fopen(write_filename,"wb"); | 350 | fout=fopen(write_filename,"wb"); |
351 | } | 351 | } |
352 | 352 | ||
353 | if (fout==NULL) | 353 | if (fout==NULL) |
354 | { | 354 | { |
355 | printf("error opening %s\n",write_filename); | 355 | printf("error opening %s\n",write_filename); |
356 | } | 356 | } |
357 | } | 357 | } |
358 | 358 | ||
359 | if (fout!=NULL) | 359 | if (fout!=NULL) |
360 | { | 360 | { |
361 | printf(" extracting: %s\n",write_filename); | 361 | printf(" extracting: %s\n",write_filename); |
362 | 362 | ||
363 | do | 363 | do |
364 | { | 364 | { |
365 | err = unzReadCurrentFile(uf,buf,size_buf); | 365 | err = unzReadCurrentFile(uf,buf,size_buf); |
366 | if (err<0) | 366 | if (err<0) |
367 | { | 367 | { |
368 | printf("error %d with zipfile in unzReadCurrentFile\n",err); | 368 | printf("error %d with zipfile in unzReadCurrentFile\n",err); |
369 | break; | 369 | break; |
370 | } | 370 | } |
371 | if (err>0) | 371 | if (err>0) |
372 | if (fwrite(buf,err,1,fout)!=1) | 372 | if (fwrite(buf,err,1,fout)!=1) |
373 | { | 373 | { |
374 | printf("error in writing extracted file\n"); | 374 | printf("error in writing extracted file\n"); |
375 | err=UNZ_ERRNO; | 375 | err=UNZ_ERRNO; |
376 | break; | 376 | break; |
377 | } | 377 | } |
378 | } | 378 | } |
379 | while (err>0); | 379 | while (err>0); |
380 | if (fout) | 380 | if (fout) |
381 | fclose(fout); | 381 | fclose(fout); |
382 | 382 | ||
383 | if (err==0) | 383 | if (err==0) |
384 | change_file_date(write_filename,file_info.dosDate, | 384 | change_file_date(write_filename,file_info.dosDate, |
385 | file_info.tmu_date); | 385 | file_info.tmu_date); |
386 | } | 386 | } |
387 | 387 | ||
388 | if (err==UNZ_OK) | 388 | if (err==UNZ_OK) |
389 | { | 389 | { |
390 | err = unzCloseCurrentFile (uf); | 390 | err = unzCloseCurrentFile (uf); |
391 | if (err!=UNZ_OK) | 391 | if (err!=UNZ_OK) |
392 | { | 392 | { |
393 | printf("error %d with zipfile in unzCloseCurrentFile\n",err); | 393 | printf("error %d with zipfile in unzCloseCurrentFile\n",err); |
394 | } | 394 | } |
395 | } | 395 | } |
396 | else | 396 | else |
397 | unzCloseCurrentFile(uf); /* don't lose the error */ | 397 | unzCloseCurrentFile(uf); /* don't lose the error */ |
398 | } | 398 | } |
399 | 399 | ||
400 | free(buf); | 400 | free(buf); |
401 | return err; | 401 | return err; |
402 | } | 402 | } |
403 | 403 | ||
404 | 404 | ||
405 | int do_extract(uf,opt_extract_without_path,opt_overwrite,password) | 405 | int do_extract(uf,opt_extract_without_path,opt_overwrite,password) |
406 | unzFile uf; | 406 | unzFile uf; |
407 | int opt_extract_without_path; | 407 | int opt_extract_without_path; |
408 | int opt_overwrite; | 408 | int opt_overwrite; |
409 | const char* password; | 409 | const char* password; |
410 | { | 410 | { |
411 | uLong i; | 411 | uLong i; |
412 | unz_global_info gi; | 412 | unz_global_info gi; |
413 | int err; | 413 | int err; |
414 | FILE* fout=NULL; | 414 | FILE* fout=NULL; |
415 | 415 | ||
416 | err = unzGetGlobalInfo (uf,&gi); | 416 | err = unzGetGlobalInfo (uf,&gi); |
417 | if (err!=UNZ_OK) | 417 | if (err!=UNZ_OK) |
418 | printf("error %d with zipfile in unzGetGlobalInfo \n",err); | 418 | printf("error %d with zipfile in unzGetGlobalInfo \n",err); |
419 | 419 | ||
420 | for (i=0;i<gi.number_entry;i++) | 420 | for (i=0;i<gi.number_entry;i++) |
421 | { | 421 | { |
422 | if (do_extract_currentfile(uf,&opt_extract_without_path, | 422 | if (do_extract_currentfile(uf,&opt_extract_without_path, |
423 | &opt_overwrite, | 423 | &opt_overwrite, |
424 | password) != UNZ_OK) | 424 | password) != UNZ_OK) |
425 | break; | 425 | break; |
426 | 426 | ||
427 | if ((i+1)<gi.number_entry) | 427 | if ((i+1)<gi.number_entry) |
428 | { | 428 | { |
429 | err = unzGoToNextFile(uf); | 429 | err = unzGoToNextFile(uf); |
430 | if (err!=UNZ_OK) | 430 | if (err!=UNZ_OK) |
431 | { | 431 | { |
432 | printf("error %d with zipfile in unzGoToNextFile\n",err); | 432 | printf("error %d with zipfile in unzGoToNextFile\n",err); |
433 | break; | 433 | break; |
434 | } | 434 | } |
435 | } | 435 | } |
436 | } | 436 | } |
437 | 437 | ||
438 | return 0; | 438 | return 0; |
439 | } | 439 | } |
440 | 440 | ||
441 | int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password) | 441 | int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password) |
442 | unzFile uf; | 442 | unzFile uf; |
443 | const char* filename; | 443 | const char* filename; |
444 | int opt_extract_without_path; | 444 | int opt_extract_without_path; |
445 | int opt_overwrite; | 445 | int opt_overwrite; |
446 | const char* password; | 446 | const char* password; |
447 | { | 447 | { |
448 | int err = UNZ_OK; | 448 | int err = UNZ_OK; |
449 | if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) | 449 | if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) |
450 | { | 450 | { |
451 | printf("file %s not found in the zipfile\n",filename); | 451 | printf("file %s not found in the zipfile\n",filename); |
452 | return 2; | 452 | return 2; |
453 | } | 453 | } |
454 | 454 | ||
455 | if (do_extract_currentfile(uf,&opt_extract_without_path, | 455 | if (do_extract_currentfile(uf,&opt_extract_without_path, |
456 | &opt_overwrite, | 456 | &opt_overwrite, |
457 | password) == UNZ_OK) | 457 | password) == UNZ_OK) |
458 | return 0; | 458 | return 0; |
459 | else | 459 | else |
460 | return 1; | 460 | return 1; |
461 | } | 461 | } |
462 | 462 | ||
463 | 463 | ||
464 | int main(argc,argv) | 464 | int main(argc,argv) |
465 | int argc; | 465 | int argc; |
466 | char *argv[]; | 466 | char *argv[]; |
467 | { | 467 | { |
468 | const char *zipfilename=NULL; | 468 | const char *zipfilename=NULL; |
469 | const char *filename_to_extract=NULL; | 469 | const char *filename_to_extract=NULL; |
470 | const char *password=NULL; | 470 | const char *password=NULL; |
471 | char filename_try[MAXFILENAME+16] = ""; | 471 | char filename_try[MAXFILENAME+16] = ""; |
472 | int i; | 472 | int i; |
473 | int opt_do_list=0; | 473 | int opt_do_list=0; |
474 | int opt_do_extract=1; | 474 | int opt_do_extract=1; |
475 | int opt_do_extract_withoutpath=0; | 475 | int opt_do_extract_withoutpath=0; |
476 | int opt_overwrite=0; | 476 | int opt_overwrite=0; |
477 | int opt_extractdir=0; | 477 | int opt_extractdir=0; |
478 | const char *dirname=NULL; | 478 | const char *dirname=NULL; |
479 | unzFile uf=NULL; | 479 | unzFile uf=NULL; |
480 | 480 | ||
481 | do_banner(); | 481 | do_banner(); |
482 | if (argc==1) | 482 | if (argc==1) |
483 | { | 483 | { |
484 | do_help(); | 484 | do_help(); |
485 | return 0; | 485 | return 0; |
486 | } | 486 | } |
487 | else | 487 | else |
488 | { | 488 | { |
489 | for (i=1;i<argc;i++) | 489 | for (i=1;i<argc;i++) |
490 | { | 490 | { |
491 | if ((*argv[i])=='-') | 491 | if ((*argv[i])=='-') |
492 | { | 492 | { |
493 | const char *p=argv[i]+1; | 493 | const char *p=argv[i]+1; |
494 | 494 | ||
495 | while ((*p)!='\0') | 495 | while ((*p)!='\0') |
496 | { | 496 | { |
497 | char c=*(p++);; | 497 | char c=*(p++);; |
498 | if ((c=='l') || (c=='L')) | 498 | if ((c=='l') || (c=='L')) |
499 | opt_do_list = 1; | 499 | opt_do_list = 1; |
500 | if ((c=='v') || (c=='V')) | 500 | if ((c=='v') || (c=='V')) |
501 | opt_do_list = 1; | 501 | opt_do_list = 1; |
502 | if ((c=='x') || (c=='X')) | 502 | if ((c=='x') || (c=='X')) |
503 | opt_do_extract = 1; | 503 | opt_do_extract = 1; |
504 | if ((c=='e') || (c=='E')) | 504 | if ((c=='e') || (c=='E')) |
505 | opt_do_extract = opt_do_extract_withoutpath = 1; | 505 | opt_do_extract = opt_do_extract_withoutpath = 1; |
506 | if ((c=='o') || (c=='O')) | 506 | if ((c=='o') || (c=='O')) |
507 | opt_overwrite=1; | 507 | opt_overwrite=1; |
508 | if ((c=='d') || (c=='D')) | 508 | if ((c=='d') || (c=='D')) |
509 | { | 509 | { |
510 | opt_extractdir=1; | 510 | opt_extractdir=1; |
511 | dirname=argv[i+1]; | 511 | dirname=argv[i+1]; |
512 | } | 512 | } |
513 | 513 | ||
514 | if (((c=='p') || (c=='P')) && (i+1<argc)) | 514 | if (((c=='p') || (c=='P')) && (i+1<argc)) |
515 | { | 515 | { |
516 | password=argv[i+1]; | 516 | password=argv[i+1]; |
517 | i++; | 517 | i++; |
518 | } | 518 | } |
519 | } | 519 | } |
520 | } | 520 | } |
521 | else | 521 | else |
522 | { | 522 | { |
523 | if (zipfilename == NULL) | 523 | if (zipfilename == NULL) |
524 | zipfilename = argv[i]; | 524 | zipfilename = argv[i]; |
525 | else if ((filename_to_extract==NULL) && (!opt_extractdir)) | 525 | else if ((filename_to_extract==NULL) && (!opt_extractdir)) |
526 | filename_to_extract = argv[i] ; | 526 | filename_to_extract = argv[i] ; |
527 | } | 527 | } |
528 | } | 528 | } |
529 | } | 529 | } |
530 | 530 | ||
531 | if (zipfilename!=NULL) | 531 | if (zipfilename!=NULL) |
532 | { | 532 | { |
533 | 533 | ||
534 | # ifdef USEWIN32IOAPI | 534 | # ifdef USEWIN32IOAPI |
535 | zlib_filefunc_def ffunc; | 535 | zlib_filefunc_def ffunc; |
536 | # endif | 536 | # endif |
537 | 537 | ||
538 | strncpy(filename_try, zipfilename,MAXFILENAME-1); | 538 | strncpy(filename_try, zipfilename,MAXFILENAME-1); |
539 | /* strncpy doesnt append the trailing NULL, of the string is too long. */ | 539 | /* strncpy doesnt append the trailing NULL, of the string is too long. */ |
540 | filename_try[ MAXFILENAME ] = '\0'; | 540 | filename_try[ MAXFILENAME ] = '\0'; |
541 | 541 | ||
542 | # ifdef USEWIN32IOAPI | 542 | # ifdef USEWIN32IOAPI |
543 | fill_win32_filefunc(&ffunc); | 543 | fill_win32_filefunc(&ffunc); |
544 | uf = unzOpen2(zipfilename,&ffunc); | 544 | uf = unzOpen2(zipfilename,&ffunc); |
545 | # else | 545 | # else |
546 | uf = unzOpen(zipfilename); | 546 | uf = unzOpen(zipfilename); |
547 | # endif | 547 | # endif |
548 | if (uf==NULL) | 548 | if (uf==NULL) |
549 | { | 549 | { |
550 | strcat(filename_try,".zip"); | 550 | strcat(filename_try,".zip"); |
551 | # ifdef USEWIN32IOAPI | 551 | # ifdef USEWIN32IOAPI |
552 | uf = unzOpen2(filename_try,&ffunc); | 552 | uf = unzOpen2(filename_try,&ffunc); |
553 | # else | 553 | # else |
554 | uf = unzOpen(filename_try); | 554 | uf = unzOpen(filename_try); |
555 | # endif | 555 | # endif |
556 | } | 556 | } |
557 | } | 557 | } |
558 | 558 | ||
559 | if (uf==NULL) | 559 | if (uf==NULL) |
560 | { | 560 | { |
561 | printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename); | 561 | printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename); |
562 | return 1; | 562 | return 1; |
563 | } | 563 | } |
564 | printf("%s opened\n",filename_try); | 564 | printf("%s opened\n",filename_try); |
565 | 565 | ||
566 | if (opt_do_list==1) | 566 | if (opt_do_list==1) |
567 | return do_list(uf); | 567 | return do_list(uf); |
568 | else if (opt_do_extract==1) | 568 | else if (opt_do_extract==1) |
569 | { | 569 | { |
570 | if (opt_extractdir && chdir(dirname)) | 570 | if (opt_extractdir && chdir(dirname)) |
571 | { | 571 | { |
572 | printf("Error changing into %s, aborting\n", dirname); | 572 | printf("Error changing into %s, aborting\n", dirname); |
573 | exit(-1); | 573 | exit(-1); |
574 | } | 574 | } |
575 | 575 | ||
576 | if (filename_to_extract == NULL) | 576 | if (filename_to_extract == NULL) |
577 | return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password); | 577 | return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password); |
578 | else | 578 | else |
579 | return do_extract_onefile(uf,filename_to_extract, | 579 | return do_extract_onefile(uf,filename_to_extract, |
580 | opt_do_extract_withoutpath,opt_overwrite,password); | 580 | opt_do_extract_withoutpath,opt_overwrite,password); |
581 | } | 581 | } |
582 | unzCloseCurrentFile(uf); | 582 | unzCloseCurrentFile(uf); |
583 | 583 | ||
584 | return 0; | 584 | return 0; |
585 | } | 585 | } |