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