projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
move more dlls
[reactos.git] / reactos / dll / zlib / contrib / minizip / unzip.c
1 /* unzip.c -- IO on .zip files using zlib
2 Version 0.15 beta, Mar 19th, 1998,
3
4 Read unzip.h for more info
5 */
6
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include "zlib.h"
12 #include "unzip.h"
13
14 #ifdef STDC
15 # include <stddef.h>
16 # include <string.h>
17 # include <stdlib.h>
18 #endif
19 #ifdef NO_ERRNO_H
20 extern int errno;
21 #else
22 # include <errno.h>
23 #endif
24
25
26 #ifndef local
27 # define local static
28 #endif
29 /* compile with -Dlocal if your debugger can't find static symbols */
30
31
32
33 #if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
34 !defined(CASESENSITIVITYDEFAULT_NO)
35 #define CASESENSITIVITYDEFAULT_NO
36 #endif
37
38
39 #ifndef UNZ_BUFSIZE
40 #define UNZ_BUFSIZE (16384)
41 #endif
42
43 #ifndef UNZ_MAXFILENAMEINZIP
44 #define UNZ_MAXFILENAMEINZIP (256)
45 #endif
46
47 #ifndef ALLOC
48 # define ALLOC(size) (malloc(size))
49 #endif
50 #ifndef TRYFREE
51 # define TRYFREE(p) {if (p) free(p);}
52 #endif
53
54 #define SIZECENTRALDIRITEM (0x2e)
55 #define SIZEZIPLOCALHEADER (0x1e)
56
57
58 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
59
60 #ifndef SEEK_CUR
61 #define SEEK_CUR 1
62 #endif
63
64 #ifndef SEEK_END
65 #define SEEK_END 2
66 #endif
67
68 #ifndef SEEK_SET
69 #define SEEK_SET 0
70 #endif
71
72 const char unz_copyright[] =
73 " unzip 0.15 Copyright 1998 Gilles Vollant ";
74
75 /* unz_file_info_interntal contain internal info about a file in zipfile*/
76 typedef struct unz_file_info_internal_s
77 {
78 uLong offset_curfile;/* relative offset of local header 4 bytes */
79 } unz_file_info_internal;
80
81
82 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
83 when reading and decompress it */
84 typedef struct
85 {
86 char *read_buffer; /* internal buffer for compressed data */
87 z_stream stream; /* zLib stream structure for inflate */
88
89 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
90 uLong stream_initialised; /* flag set if stream structure is initialised*/
91
92 uLong offset_local_extrafield;/* offset of the local extra field */
93 uInt size_local_extrafield;/* size of the local extra field */
94 uLong pos_local_extrafield; /* position in the local extra field in read*/
95
96 uLong crc32; /* crc32 of all data uncompressed */
97 uLong crc32_wait; /* crc32 we must obtain after decompress all */
98 uLong rest_read_compressed; /* number of byte to be decompressed */
99 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
100 FILE* file; /* io structore of the zipfile */
101 uLong compression_method; /* compression method (0==store) */
102 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
103 } file_in_zip_read_info_s;
104
105
106 /* unz_s contain internal information about the zipfile
107 */
108 typedef struct
109 {
110 FILE* file; /* io structore of the zipfile */
111 unz_global_info gi; /* public global information */
112 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
113 uLong num_file; /* number of the current file in the zipfile*/
114 uLong pos_in_central_dir; /* pos of the current file in the central dir*/
115 uLong current_file_ok; /* flag about the usability of the current file*/
116 uLong central_pos; /* position of the beginning of the central dir*/
117
118 uLong size_central_dir; /* size of the central directory */
119 uLong offset_central_dir; /* offset of start of central directory with
120 respect to the starting disk number */
121
122 unz_file_info cur_file_info; /* public info about the current file in zip*/
123 unz_file_info_internal cur_file_info_internal; /* private info about it*/
124 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
125 file if we are decompressing it */
126 } unz_s;
127
128
129 /* ===========================================================================
130 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
131 for end of file.
132 IN assertion: the stream s has been sucessfully opened for reading.
133 */
134
135
136 local int unzlocal_getByte(fin,pi)
137 FILE *fin;
138 int *pi;
139 {
140 unsigned char c;
141 int err = fread(&c, 1, 1, fin);
142 if (err==1)
143 {
144 *pi = (int)c;
145 return UNZ_OK;
146 }
147 else
148 {
149 if (ferror(fin))
150 return UNZ_ERRNO;
151 else
152 return UNZ_EOF;
153 }
154 }
155
156
157 /* ===========================================================================
158 Reads a long in LSB order from the given gz_stream. Sets
159 */
160 local int unzlocal_getShort (fin,pX)
161 FILE* fin;
162 uLong *pX;
163 {
164 uLong x ;
165 int i;
166 int err;
167
168 err = unzlocal_getByte(fin,&i);
169 x = (uLong)i;
170
171 if (err==UNZ_OK)
172 err = unzlocal_getByte(fin,&i);
173 x += ((uLong)i)<<8;
174
175 if (err==UNZ_OK)
176 *pX = x;
177 else
178 *pX = 0;
179 return err;
180 }
181
182 local int unzlocal_getLong (fin,pX)
183 FILE* fin;
184 uLong *pX;
185 {
186 uLong x ;
187 int i;
188 int err;
189
190 err = unzlocal_getByte(fin,&i);
191 x = (uLong)i;
192
193 if (err==UNZ_OK)
194 err = unzlocal_getByte(fin,&i);
195 x += ((uLong)i)<<8;
196
197 if (err==UNZ_OK)
198 err = unzlocal_getByte(fin,&i);
199 x += ((uLong)i)<<16;
200
201 if (err==UNZ_OK)
202 err = unzlocal_getByte(fin,&i);
203 x += ((uLong)i)<<24;
204
205 if (err==UNZ_OK)
206 *pX = x;
207 else
208 *pX = 0;
209 return err;
210 }
211
212
213 /* My own strcmpi / strcasecmp */
214 local int strcmpcasenosensitive_internal (fileName1,fileName2)
215 const char* fileName1;
216 const char* fileName2;
217 {
218 for (;;)
219 {
220 char c1=*(fileName1++);
221 char c2=*(fileName2++);
222 if ((c1>='a') && (c1<='z'))
223 c1 -= 0x20;
224 if ((c2>='a') && (c2<='z'))
225 c2 -= 0x20;
226 if (c1=='\0')
227 return ((c2=='\0') ? 0 : -1);
228 if (c2=='\0')
229 return 1;
230 if (c1<c2)
231 return -1;
232 if (c1>c2)
233 return 1;
234 }
235 }
236
237
238 #ifdef CASESENSITIVITYDEFAULT_NO
239 #define CASESENSITIVITYDEFAULTVALUE 2
240 #else
241 #define CASESENSITIVITYDEFAULTVALUE 1
242 #endif
243
244 #ifndef STRCMPCASENOSENTIVEFUNCTION
245 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
246 #endif
247
248 /*
249 Compare two filename (fileName1,fileName2).
250 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
251 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
252 or strcasecmp)
253 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
254 (like 1 on Unix, 2 on Windows)
255
256 */
257 extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
258 const char* fileName1;
259 const char* fileName2;
260 int iCaseSensitivity;
261 {
262 if (iCaseSensitivity==0)
263 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
264
265 if (iCaseSensitivity==1)
266 return strcmp(fileName1,fileName2);
267
268 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
269 }
270
271 #define BUFREADCOMMENT (0x400)
272
273 /*
274 Locate the Central directory of a zipfile (at the end, just before
275 the global comment)
276 */
277 local uLong unzlocal_SearchCentralDir(fin)
278 FILE *fin;
279 {
280 unsigned char* buf;
281 uLong uSizeFile;
282 uLong uBackRead;
283 uLong uMaxBack=0xffff; /* maximum size of global comment */
284 uLong uPosFound=0;
285
286 if (fseek(fin,0,SEEK_END) != 0)
287 return 0;
288
289
290 uSizeFile = ftell( fin );
291
292 if (uMaxBack>uSizeFile)
293 uMaxBack = uSizeFile;
294
295 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
296 if (buf==NULL)
297 return 0;
298
299 uBackRead = 4;
300 while (uBackRead<uMaxBack)
301 {
302 uLong uReadSize,uReadPos ;
303 int i;
304 if (uBackRead+BUFREADCOMMENT>uMaxBack)
305 uBackRead = uMaxBack;
306 else
307 uBackRead+=BUFREADCOMMENT;
308 uReadPos = uSizeFile-uBackRead ;
309
310 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
311 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
312 if (fseek(fin,uReadPos,SEEK_SET)!=0)
313 break;
314
315 if (fread(buf,(uInt)uReadSize,1,fin)!=1)
316 break;
317
318 for (i=(int)uReadSize-3; (i--)>0;)
319 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
320 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
321 {
322 uPosFound = uReadPos+i;
323 break;
324 }
325
326 if (uPosFound!=0)
327 break;
328 }
329 TRYFREE(buf);
330 return uPosFound;
331 }
332
333 /*
334 Open a Zip file. path contain the full pathname (by example,
335 on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
336 "zlib/zlib109.zip".
337 If the zipfile cannot be opened (file don't exist or in not valid), the
338 return value is NULL.
339 Else, the return value is a unzFile Handle, usable with other function
340 of this unzip package.
341 */
342 extern unzFile ZEXPORT unzOpen (path)
343 const char *path;
344 {
345 unz_s us;
346 unz_s *s;
347 uLong central_pos,uL;
348 FILE * fin ;
349
350 uLong number_disk; /* number of the current dist, used for
351 spaning ZIP, unsupported, always 0*/
352 uLong number_disk_with_CD; /* number the the disk with central dir, used
353 for spaning ZIP, unsupported, always 0*/
354 uLong number_entry_CD; /* total number of entries in
355 the central dir
356 (same than number_entry on nospan) */
357
358 int err=UNZ_OK;
359
360 if (unz_copyright[0]!=' ')
361 return NULL;
362
363 fin=fopen(path,"rb");
364 if (fin==NULL)
365 return NULL;
366
367 central_pos = unzlocal_SearchCentralDir(fin);
368 if (central_pos==0)
369 err=UNZ_ERRNO;
370
371 if (fseek(fin,central_pos,SEEK_SET)!=0)
372 err=UNZ_ERRNO;
373
374 /* the signature, already checked */
375 if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
376 err=UNZ_ERRNO;
377
378 /* number of this disk */
379 if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
380 err=UNZ_ERRNO;
381
382 /* number of the disk with the start of the central directory */
383 if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
384 err=UNZ_ERRNO;
385
386 /* total number of entries in the central dir on this disk */
387 if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
388 err=UNZ_ERRNO;
389
390 /* total number of entries in the central dir */
391 if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
392 err=UNZ_ERRNO;
393
394 if ((number_entry_CD!=us.gi.number_entry) ||
395 (number_disk_with_CD!=0) ||
396 (number_disk!=0))
397 err=UNZ_BADZIPFILE;
398
399 /* size of the central directory */
400 if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
401 err=UNZ_ERRNO;
402
403 /* offset of start of central directory with respect to the
404 starting disk number */
405 if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
406 err=UNZ_ERRNO;
407
408 /* zipfile comment length */
409 if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
410 err=UNZ_ERRNO;
411
412 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
413 (err==UNZ_OK))
414 err=UNZ_BADZIPFILE;
415
416 if (err!=UNZ_OK)
417 {
418 fclose(fin);
419 return NULL;
420 }
421
422 us.file=fin;
423 us.byte_before_the_zipfile = central_pos -
424 (us.offset_central_dir+us.size_central_dir);
425 us.central_pos = central_pos;
426 us.pfile_in_zip_read = NULL;
427
428
429 s=(unz_s*)ALLOC(sizeof(unz_s));
430 *s=us;
431 unzGoToFirstFile((unzFile)s);
432 return (unzFile)s;
433 }
434
435
436 /*
437 Close a ZipFile opened with unzipOpen.
438 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
439 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
440 return UNZ_OK if there is no problem. */
441 extern int ZEXPORT unzClose (file)
442 unzFile file;
443 {
444 unz_s* s;
445 if (file==NULL)
446 return UNZ_PARAMERROR;
447 s=(unz_s*)file;
448
449 if (s->pfile_in_zip_read!=NULL)
450 unzCloseCurrentFile(file);
451
452 fclose(s->file);
453 TRYFREE(s);
454 return UNZ_OK;
455 }
456
457
458 /*
459 Write info about the ZipFile in the *pglobal_info structure.
460 No preparation of the structure is needed
461 return UNZ_OK if there is no problem. */
462 extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
463 unzFile file;
464 unz_global_info *pglobal_info;
465 {
466 unz_s* s;
467 if (file==NULL)
468 return UNZ_PARAMERROR;
469 s=(unz_s*)file;
470 *pglobal_info=s->gi;
471 return UNZ_OK;
472 }
473
474
475 /*
476 Translate date/time from Dos format to tm_unz (readable more easilty)
477 */
478 local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
479 uLong ulDosDate;
480 tm_unz* ptm;
481 {
482 uLong uDate;
483 uDate = (uLong)(ulDosDate>>16);
484 ptm->tm_mday = (uInt)(uDate&0x1f) ;
485 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
486 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
487
488 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
489 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
490 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
491 }
492
493 /*
494 Get Info about the current file in the zipfile, with internal only info
495 */
496 local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
497 unz_file_info *pfile_info,
498 unz_file_info_internal
499 *pfile_info_internal,
500 char *szFileName,
501 uLong fileNameBufferSize,
502 void *extraField,
503 uLong extraFieldBufferSize,
504 char *szComment,
505 uLong commentBufferSize));
506
507 local int unzlocal_GetCurrentFileInfoInternal (file,
508 pfile_info,
509 pfile_info_internal,
510 szFileName, fileNameBufferSize,
511 extraField, extraFieldBufferSize,
512 szComment, commentBufferSize)
513 unzFile file;
514 unz_file_info *pfile_info;
515 unz_file_info_internal *pfile_info_internal;
516 char *szFileName;
517 uLong fileNameBufferSize;
518 void *extraField;
519 uLong extraFieldBufferSize;
520 char *szComment;
521 uLong commentBufferSize;
522 {
523 unz_s* s;
524 unz_file_info file_info;
525 unz_file_info_internal file_info_internal;
526 int err=UNZ_OK;
527 uLong uMagic;
528 long lSeek=0;
529
530 if (file==NULL)
531 return UNZ_PARAMERROR;
532 s=(unz_s*)file;
533 if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
534 err=UNZ_ERRNO;
535
536
537 /* we check the magic */
538 if (err==UNZ_OK)
539 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
540 err=UNZ_ERRNO;
541 else if (uMagic!=0x02014b50)
542 err=UNZ_BADZIPFILE;
543
544 if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
545 err=UNZ_ERRNO;
546
547 if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
548 err=UNZ_ERRNO;
549
550 if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
551 err=UNZ_ERRNO;
552
553 if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
554 err=UNZ_ERRNO;
555
556 if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
557 err=UNZ_ERRNO;
558
559 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
560
561 if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
562 err=UNZ_ERRNO;
563
564 if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
565 err=UNZ_ERRNO;
566
567 if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
568 err=UNZ_ERRNO;
569
570 if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
571 err=UNZ_ERRNO;
572
573 if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
574 err=UNZ_ERRNO;
575
576 if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
577 err=UNZ_ERRNO;
578
579 if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
580 err=UNZ_ERRNO;
581
582 if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
583 err=UNZ_ERRNO;
584
585 if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
586 err=UNZ_ERRNO;
587
588 if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
589 err=UNZ_ERRNO;
590
591 lSeek+=file_info.size_filename;
592 if ((err==UNZ_OK) && (szFileName!=NULL))
593 {
594 uLong uSizeRead ;
595 if (file_info.size_filename<fileNameBufferSize)
596 {
597 *(szFileName+file_info.size_filename)='\0';
598 uSizeRead = file_info.size_filename;
599 }
600 else
601 uSizeRead = fileNameBufferSize;
602
603 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
604 if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
605 err=UNZ_ERRNO;
606 lSeek -= uSizeRead;
607 }
608
609
610 if ((err==UNZ_OK) && (extraField!=NULL))
611 {
612 uLong uSizeRead ;
613 if (file_info.size_file_extra<extraFieldBufferSize)
614 uSizeRead = file_info.size_file_extra;
615 else
616 uSizeRead = extraFieldBufferSize;
617
618 if (lSeek!=0)
619 if (fseek(s->file,lSeek,SEEK_CUR)==0)
620 lSeek=0;
621 else
622 err=UNZ_ERRNO;
623 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
624 if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
625 err=UNZ_ERRNO;
626 lSeek += file_info.size_file_extra - uSizeRead;
627 }
628 else
629 lSeek+=file_info.size_file_extra;
630
631
632 if ((err==UNZ_OK) && (szComment!=NULL))
633 {
634 uLong uSizeRead ;
635 if (file_info.size_file_comment<commentBufferSize)
636 {
637 *(szComment+file_info.size_file_comment)='\0';
638 uSizeRead = file_info.size_file_comment;
639 }
640 else
641 uSizeRead = commentBufferSize;
642
643 if (lSeek!=0)
644 if (fseek(s->file,lSeek,SEEK_CUR)==0)
645 lSeek=0;
646 else
647 err=UNZ_ERRNO;
648 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
649 if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
650 err=UNZ_ERRNO;
651 lSeek+=file_info.size_file_comment - uSizeRead;
652 }
653 else
654 lSeek+=file_info.size_file_comment;
655
656 if ((err==UNZ_OK) && (pfile_info!=NULL))
657 *pfile_info=file_info;
658
659 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
660 *pfile_info_internal=file_info_internal;
661
662 return err;
663 }
664
665
666
667 /*
668 Write info about the ZipFile in the *pglobal_info structure.
669 No preparation of the structure is needed
670 return UNZ_OK if there is no problem.
671 */
672 extern int ZEXPORT unzGetCurrentFileInfo (file,
673 pfile_info,
674 szFileName, fileNameBufferSize,
675 extraField, extraFieldBufferSize,
676 szComment, commentBufferSize)
677 unzFile file;
678 unz_file_info *pfile_info;
679 char *szFileName;
680 uLong fileNameBufferSize;
681 void *extraField;
682 uLong extraFieldBufferSize;
683 char *szComment;
684 uLong commentBufferSize;
685 {
686 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
687 szFileName,fileNameBufferSize,
688 extraField,extraFieldBufferSize,
689 szComment,commentBufferSize);
690 }
691
692 /*
693 Set the current file of the zipfile to the first file.
694 return UNZ_OK if there is no problem
695 */
696 extern int ZEXPORT unzGoToFirstFile (file)
697 unzFile file;
698 {
699 int err=UNZ_OK;
700 unz_s* s;
701 if (file==NULL)
702 return UNZ_PARAMERROR;
703 s=(unz_s*)file;
704 s->pos_in_central_dir=s->offset_central_dir;
705 s->num_file=0;
706 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
707 &s->cur_file_info_internal,
708 NULL,0,NULL,0,NULL,0);
709 s->current_file_ok = (err == UNZ_OK);
710 return err;
711 }
712
713
714 /*
715 Set the current file of the zipfile to the next file.
716 return UNZ_OK if there is no problem
717 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
718 */
719 extern int ZEXPORT unzGoToNextFile (file)
720 unzFile file;
721 {
722 unz_s* s;
723 int err;
724
725 if (file==NULL)
726 return UNZ_PARAMERROR;
727 s=(unz_s*)file;
728 if (!s->current_file_ok)
729 return UNZ_END_OF_LIST_OF_FILE;
730 if (s->num_file+1==s->gi.number_entry)
731 return UNZ_END_OF_LIST_OF_FILE;
732
733 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
734 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
735 s->num_file++;
736 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
737 &s->cur_file_info_internal,
738 NULL,0,NULL,0,NULL,0);
739 s->current_file_ok = (err == UNZ_OK);
740 return err;
741 }
742
743
744 /*
745 Try locate the file szFileName in the zipfile.
746 For the iCaseSensitivity signification, see unzipStringFileNameCompare
747
748 return value :
749 UNZ_OK if the file is found. It becomes the current file.
750 UNZ_END_OF_LIST_OF_FILE if the file is not found
751 */
752 extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
753 unzFile file;
754 const char *szFileName;
755 int iCaseSensitivity;
756 {
757 unz_s* s;
758 int err;
759
760
761 uLong num_fileSaved;
762 uLong pos_in_central_dirSaved;
763
764
765 if (file==NULL)
766 return UNZ_PARAMERROR;
767
768 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
769 return UNZ_PARAMERROR;
770
771 s=(unz_s*)file;
772 if (!s->current_file_ok)
773 return UNZ_END_OF_LIST_OF_FILE;
774
775 num_fileSaved = s->num_file;
776 pos_in_central_dirSaved = s->pos_in_central_dir;
777
778 err = unzGoToFirstFile(file);
779
780 while (err == UNZ_OK)
781 {
782 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
783 unzGetCurrentFileInfo(file,NULL,
784 szCurrentFileName,sizeof(szCurrentFileName)-1,
785 NULL,0,NULL,0);
786 if (unzStringFileNameCompare(szCurrentFileName,
787 szFileName,iCaseSensitivity)==0)
788 return UNZ_OK;
789 err = unzGoToNextFile(file);
790 }
791
792 s->num_file = num_fileSaved ;
793 s->pos_in_central_dir = pos_in_central_dirSaved ;
794 return err;
795 }
796
797
798 /*
799 Read the local header of the current zipfile
800 Check the coherency of the local header and info in the end of central
801 directory about this file
802 store in *piSizeVar the size of extra info in local header
803 (filename and size of extra field data)
804 */
805 local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
806 poffset_local_extrafield,
807 psize_local_extrafield)
808 unz_s* s;
809 uInt* piSizeVar;
810 uLong *poffset_local_extrafield;
811 uInt *psize_local_extrafield;
812 {
813 uLong uMagic,uData,uFlags;
814 uLong size_filename;
815 uLong size_extra_field;
816 int err=UNZ_OK;
817
818 *piSizeVar = 0;
819 *poffset_local_extrafield = 0;
820 *psize_local_extrafield = 0;
821
822 if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
823 s->byte_before_the_zipfile,SEEK_SET)!=0)
824 return UNZ_ERRNO;
825
826
827 if (err==UNZ_OK)
828 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
829 err=UNZ_ERRNO;
830 else if (uMagic!=0x04034b50)
831 err=UNZ_BADZIPFILE;
832
833 if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
834 err=UNZ_ERRNO;
835 /*
836 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
837 err=UNZ_BADZIPFILE;
838 */
839 if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
840 err=UNZ_ERRNO;
841
842 if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
843 err=UNZ_ERRNO;
844 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
845 err=UNZ_BADZIPFILE;
846
847 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
848 (s->cur_file_info.compression_method!=Z_DEFLATED))
849 err=UNZ_BADZIPFILE;
850
851 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
852 err=UNZ_ERRNO;
853
854 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
855 err=UNZ_ERRNO;
856 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
857 ((uFlags & 8)==0))
858 err=UNZ_BADZIPFILE;
859
860 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
861 err=UNZ_ERRNO;
862 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
863 ((uFlags & 8)==0))
864 err=UNZ_BADZIPFILE;
865
866 if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
867 err=UNZ_ERRNO;
868 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
869 ((uFlags & 8)==0))
870 err=UNZ_BADZIPFILE;
871
872
873 if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
874 err=UNZ_ERRNO;
875 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
876 err=UNZ_BADZIPFILE;
877
878 *piSizeVar += (uInt)size_filename;
879
880 if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
881 err=UNZ_ERRNO;
882 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
883 SIZEZIPLOCALHEADER + size_filename;
884 *psize_local_extrafield = (uInt)size_extra_field;
885
886 *piSizeVar += (uInt)size_extra_field;
887
888 return err;
889 }
890
891 /*
892 Open for reading data the current file in the zipfile.
893 If there is no error and the file is opened, the return value is UNZ_OK.
894 */
895 extern int ZEXPORT unzOpenCurrentFile (file)
896 unzFile file;
897 {
898 int err=UNZ_OK;
899 int Store;
900 uInt iSizeVar;
901 unz_s* s;
902 file_in_zip_read_info_s* pfile_in_zip_read_info;
903 uLong offset_local_extrafield; /* offset of the local extra field */
904 uInt size_local_extrafield; /* size of the local extra field */
905
906 if (file==NULL)
907 return UNZ_PARAMERROR;
908 s=(unz_s*)file;
909 if (!s->current_file_ok)
910 return UNZ_PARAMERROR;
911
912 if (s->pfile_in_zip_read != NULL)
913 unzCloseCurrentFile(file);
914
915 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
916 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
917 return UNZ_BADZIPFILE;
918
919 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
920 ALLOC(sizeof(file_in_zip_read_info_s));
921 if (pfile_in_zip_read_info==NULL)
922 return UNZ_INTERNALERROR;
923
924 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
925 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
926 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
927 pfile_in_zip_read_info->pos_local_extrafield=0;
928
929 if (pfile_in_zip_read_info->read_buffer==NULL)
930 {
931 TRYFREE(pfile_in_zip_read_info);
932 return UNZ_INTERNALERROR;
933 }
934
935 pfile_in_zip_read_info->stream_initialised=0;
936
937 if ((s->cur_file_info.compression_method!=0) &&
938 (s->cur_file_info.compression_method!=Z_DEFLATED))
939 err=UNZ_BADZIPFILE;
940 Store = s->cur_file_info.compression_method==0;
941
942 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
943 pfile_in_zip_read_info->crc32=0;
944 pfile_in_zip_read_info->compression_method =
945 s->cur_file_info.compression_method;
946 pfile_in_zip_read_info->file=s->file;
947 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
948
949 pfile_in_zip_read_info->stream.total_out = 0;
950
951 if (!Store)
952 {
953 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
954 pfile_in_zip_read_info->stream.zfree = (free_func)0;
955 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
956
957 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
958 if (err == Z_OK)
959 pfile_in_zip_read_info->stream_initialised=1;
960 /* windowBits is passed < 0 to tell that there is no zlib header.
961 * Note that in this case inflate *requires* an extra "dummy" byte
962 * after the compressed stream in order to complete decompression and
963 * return Z_STREAM_END.
964 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
965 * size of both compressed and uncompressed data
966 */
967 }
968 pfile_in_zip_read_info->rest_read_compressed =
969 s->cur_file_info.compressed_size ;
970 pfile_in_zip_read_info->rest_read_uncompressed =
971 s->cur_file_info.uncompressed_size ;
972
973
974 pfile_in_zip_read_info->pos_in_zipfile =
975 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
976 iSizeVar;
977
978 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
979
980
981 s->pfile_in_zip_read = pfile_in_zip_read_info;
982 return UNZ_OK;
983 }
984
985
986 /*
987 Read bytes from the current file.
988 buf contain buffer where data must be copied
989 len the size of buf.
990
991 return the number of byte copied if somes bytes are copied
992 return 0 if the end of file was reached
993 return <0 with error code if there is an error
994 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
995 */
996 extern int ZEXPORT unzReadCurrentFile (file, buf, len)
997 unzFile file;
998 voidp buf;
999 unsigned len;
1000 {
1001 int err=UNZ_OK;
1002 uInt iRead = 0;
1003 unz_s* s;
1004 file_in_zip_read_info_s* pfile_in_zip_read_info;
1005 if (file==NULL)
1006 return UNZ_PARAMERROR;
1007 s=(unz_s*)file;
1008 pfile_in_zip_read_info=s->pfile_in_zip_read;
1009
1010 if (pfile_in_zip_read_info==NULL)
1011 return UNZ_PARAMERROR;
1012
1013
1014 if ((pfile_in_zip_read_info->read_buffer == NULL))
1015 return UNZ_END_OF_LIST_OF_FILE;
1016 if (len==0)
1017 return 0;
1018
1019 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1020
1021 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1022
1023 if (len>pfile_in_zip_read_info->rest_read_uncompressed)
1024 pfile_in_zip_read_info->stream.avail_out =
1025 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1026
1027 while (pfile_in_zip_read_info->stream.avail_out>0)
1028 {
1029 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1030 (pfile_in_zip_read_info->rest_read_compressed>0))
1031 {
1032 uInt uReadThis = UNZ_BUFSIZE;
1033 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1034 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1035 if (uReadThis == 0)
1036 return UNZ_EOF;
1037 if (fseek(pfile_in_zip_read_info->file,
1038 pfile_in_zip_read_info->pos_in_zipfile +
1039 pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
1040 return UNZ_ERRNO;
1041 if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
1042 pfile_in_zip_read_info->file)!=1)
1043 return UNZ_ERRNO;
1044 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1045
1046 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1047
1048 pfile_in_zip_read_info->stream.next_in =
1049 (Bytef*)pfile_in_zip_read_info->read_buffer;
1050 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1051 }
1052
1053 if (pfile_in_zip_read_info->compression_method==0)
1054 {
1055 uInt uDoCopy,i ;
1056 if (pfile_in_zip_read_info->stream.avail_out <
1057 pfile_in_zip_read_info->stream.avail_in)
1058 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1059 else
1060 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1061
1062 for (i=0;i<uDoCopy;i++)
1063 *(pfile_in_zip_read_info->stream.next_out+i) =
1064 *(pfile_in_zip_read_info->stream.next_in+i);
1065
1066 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1067 pfile_in_zip_read_info->stream.next_out,
1068 uDoCopy);
1069 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1070 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1071 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1072 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1073 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1074 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1075 iRead += uDoCopy;
1076 }
1077 else
1078 {
1079 uLong uTotalOutBefore,uTotalOutAfter;
1080 const Bytef *bufBefore;
1081 uLong uOutThis;
1082 int flush=Z_SYNC_FLUSH;
1083
1084 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1085 bufBefore = pfile_in_zip_read_info->stream.next_out;
1086
1087 /*
1088 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1089 pfile_in_zip_read_info->stream.avail_out) &&
1090 (pfile_in_zip_read_info->rest_read_compressed == 0))
1091 flush = Z_FINISH;
1092 */
1093 err=inflate(&pfile_in_zip_read_info->stream,flush);
1094
1095 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1096 uOutThis = uTotalOutAfter-uTotalOutBefore;
1097
1098 pfile_in_zip_read_info->crc32 =
1099 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1100 (uInt)(uOutThis));
1101
1102 pfile_in_zip_read_info->rest_read_uncompressed -=
1103 uOutThis;
1104
1105 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1106
1107 if (err==Z_STREAM_END)
1108 return (iRead==0) ? UNZ_EOF : iRead;
1109 if (err!=Z_OK)
1110 break;
1111 }
1112 }
1113
1114 if (err==Z_OK)
1115 return iRead;
1116 return err;
1117 }
1118
1119
1120 /*
1121 Give the current position in uncompressed data
1122 */
1123 extern z_off_t ZEXPORT unztell (file)
1124 unzFile file;
1125 {
1126 unz_s* s;
1127 file_in_zip_read_info_s* pfile_in_zip_read_info;
1128 if (file==NULL)
1129 return UNZ_PARAMERROR;
1130 s=(unz_s*)file;
1131 pfile_in_zip_read_info=s->pfile_in_zip_read;
1132
1133 if (pfile_in_zip_read_info==NULL)
1134 return UNZ_PARAMERROR;
1135
1136 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1137 }
1138
1139
1140 /*
1141 return 1 if the end of file was reached, 0 elsewhere
1142 */
1143 extern int ZEXPORT unzeof (file)
1144 unzFile file;
1145 {
1146 unz_s* s;
1147 file_in_zip_read_info_s* pfile_in_zip_read_info;
1148 if (file==NULL)
1149 return UNZ_PARAMERROR;
1150 s=(unz_s*)file;
1151 pfile_in_zip_read_info=s->pfile_in_zip_read;
1152
1153 if (pfile_in_zip_read_info==NULL)
1154 return UNZ_PARAMERROR;
1155
1156 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1157 return 1;
1158 else
1159 return 0;
1160 }
1161
1162
1163
1164 /*
1165 Read extra field from the current file (opened by unzOpenCurrentFile)
1166 This is the local-header version of the extra field (sometimes, there is
1167 more info in the local-header version than in the central-header)
1168
1169 if buf==NULL, it return the size of the local extra field that can be read
1170
1171 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1172 buf.
1173 the return value is the number of bytes copied in buf, or (if <0)
1174 the error code
1175 */
1176 extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1177 unzFile file;
1178 voidp buf;
1179 unsigned len;
1180 {
1181 unz_s* s;
1182 file_in_zip_read_info_s* pfile_in_zip_read_info;
1183 uInt read_now;
1184 uLong size_to_read;
1185
1186 if (file==NULL)
1187 return UNZ_PARAMERROR;
1188 s=(unz_s*)file;
1189 pfile_in_zip_read_info=s->pfile_in_zip_read;
1190
1191 if (pfile_in_zip_read_info==NULL)
1192 return UNZ_PARAMERROR;
1193
1194 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1195 pfile_in_zip_read_info->pos_local_extrafield);
1196
1197 if (buf==NULL)
1198 return (int)size_to_read;
1199
1200 if (len>size_to_read)
1201 read_now = (uInt)size_to_read;
1202 else
1203 read_now = (uInt)len ;
1204
1205 if (read_now==0)
1206 return 0;
1207
1208 if (fseek(pfile_in_zip_read_info->file,
1209 pfile_in_zip_read_info->offset_local_extrafield +
1210 pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
1211 return UNZ_ERRNO;
1212
1213 if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
1214 return UNZ_ERRNO;
1215
1216 return (int)read_now;
1217 }
1218
1219 /*
1220 Close the file in zip opened with unzipOpenCurrentFile
1221 Return UNZ_CRCERROR if all the file was read but the CRC is not good
1222 */
1223 extern int ZEXPORT unzCloseCurrentFile (file)
1224 unzFile file;
1225 {
1226 int err=UNZ_OK;
1227
1228 unz_s* s;
1229 file_in_zip_read_info_s* pfile_in_zip_read_info;
1230 if (file==NULL)
1231 return UNZ_PARAMERROR;
1232 s=(unz_s*)file;
1233 pfile_in_zip_read_info=s->pfile_in_zip_read;
1234
1235 if (pfile_in_zip_read_info==NULL)
1236 return UNZ_PARAMERROR;
1237
1238
1239 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1240 {
1241 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1242 err=UNZ_CRCERROR;
1243 }
1244
1245
1246 TRYFREE(pfile_in_zip_read_info->read_buffer);
1247 pfile_in_zip_read_info->read_buffer = NULL;
1248 if (pfile_in_zip_read_info->stream_initialised)
1249 inflateEnd(&pfile_in_zip_read_info->stream);
1250
1251 pfile_in_zip_read_info->stream_initialised = 0;
1252 TRYFREE(pfile_in_zip_read_info);
1253
1254 s->pfile_in_zip_read=NULL;
1255
1256 return err;
1257 }
1258
1259
1260 /*
1261 Get the global comment string of the ZipFile, in the szComment buffer.
1262 uSizeBuf is the size of the szComment buffer.
1263 return the number of byte copied or an error code <0
1264 */
1265 extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1266 unzFile file;
1267 char *szComment;
1268 uLong uSizeBuf;
1269 {
1270 int err=UNZ_OK;
1271 unz_s* s;
1272 uLong uReadThis ;
1273 if (file==NULL)
1274 return UNZ_PARAMERROR;
1275 s=(unz_s*)file;
1276
1277 uReadThis = uSizeBuf;
1278 if (uReadThis>s->gi.size_comment)
1279 uReadThis = s->gi.size_comment;
1280
1281 if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
1282 return UNZ_ERRNO;
1283
1284 if (uReadThis>0)
1285 {
1286 *szComment='\0';
1287 if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
1288 return UNZ_ERRNO;
1289 }
1290
1291 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1292 *(szComment+s->gi.size_comment)='\0';
1293 return (int)uReadThis;
1294 }
A free Windows-compatible Operating System