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