?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Second attempt to fix compilation of dvdread (I don't really like this but it might...
[vlc/asuraparaju-public.git] / libs / unzip / unzip.c
blob72f2dff331f2982f1f9459de48e73a6c871ab78b
1 /* unzip.c -- IO for uncompress .zip files using zlib
2 Version 1.01e, February 12th, 2005
3
4 Copyright (C) 1998-2005 Gilles Vollant
5
6 Read unzip.h for more info
7 */
8
9 /* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
10 compatibility with older software. The following is from the original crypt.c. Code
11 woven in by Terry Thorsen 1/2003.
12 */
13 /*
14 Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
15
16 See the accompanying file LICENSE, version 2000-Apr-09 or later
17 (the contents of which are also included in zip.h) for terms of use.
18 If, for some reason, all these files are missing, the Info-ZIP license
19 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
20 */
21 /*
22 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
23
24 The encryption/decryption parts of this source code (as opposed to the
25 non-echoing password parts) were originally written in Europe. The
26 whole source package can be freely distributed, including from the USA.
27 (Prior to January 2000, re-export from the US was a violation of US law.)
28 */
29
30 /*
31 This encryption code is a direct transcription of the algorithm from
32 Roger Schlafly, described by Phil Katz in the file appnote.txt. This
33 file (appnote.txt) is distributed with the PKZIP program (even in the
34 version without encryption capabilities).
35 */
36
37
38 #include "zlib.h"
39 #include "unzip.h"
40
41 #ifdef STDC
42 # include <stddef.h>
43 # include <string.h>
44 # include <stdlib.h>
45 #endif
46 #ifdef NO_ERRNO_H
47 extern int errno;
48 #else
49 # include <errno.h>
50 #endif
51
52 #include <assert.h>
53
54 #ifndef local
55 # define local static
56 #endif
57 /* compile with -Dlocal if your debugger can't find static symbols */
58
59
60 #ifndef CASESENSITIVITYDEFAULT_NO
61 # if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
62 # define CASESENSITIVITYDEFAULT_NO
63 # endif
64 #endif
65
66
67 #ifndef UNZ_BUFSIZE
68 #define UNZ_BUFSIZE (16384)
69 #endif
70
71 #ifndef UNZ_MAXFILENAMEINZIP
72 #define UNZ_MAXFILENAMEINZIP (256)
73 #endif
74
75 #ifndef ALLOC
76 # define ALLOC(size) (malloc(size))
77 #endif
78 #ifndef TRYFREE
79 # define TRYFREE(p) {free(p);}
80 #endif
81
82 #define SIZECENTRALDIRITEM (0x2e)
83 #define SIZEZIPLOCALHEADER (0x1e)
84
85
86
87
88 const char unz_copyright[] =
89 " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
90
91 /* unz_file_info_interntal contain internal info about a file in zipfile*/
92 typedef struct unz_file_info_internal_s
93 {
94 uLong offset_curfile;/* relative offset of local header 4 bytes */
95 } unz_file_info_internal;
96
97
98 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
99 when reading and decompress it */
100 typedef struct
101 {
102 char *read_buffer; /* internal buffer for compressed data */
103 z_stream stream; /* zLib stream structure for inflate */
104
105 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
106 uLong stream_initialised; /* flag set if stream structure is initialised*/
107
108 uLong offset_local_extrafield;/* offset of the local extra field */
109 uInt size_local_extrafield;/* size of the local extra field */
110 uLong pos_local_extrafield; /* position in the local extra field in read*/
111
112 uLong crc32; /* crc32 of all data uncompressed */
113 uLong crc32_wait; /* crc32 we must obtain after decompress all */
114 uLong rest_read_compressed; /* number of byte to be decompressed */
115 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
116 zlib_filefunc_def z_filefunc;
117 voidpf filestream; /* io structore of the zipfile */
118 uLong compression_method; /* compression method (0==store) */
119 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
120 int raw;
121 } file_in_zip_read_info_s;
122
123
124 /* unz_s contain internal information about the zipfile
125 */
126 typedef struct
127 {
128 zlib_filefunc_def z_filefunc;
129 voidpf filestream; /* io structore of the zipfile */
130 unz_global_info gi; /* public global information */
131 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
132 uLong num_file; /* number of the current file in the zipfile*/
133 uLong pos_in_central_dir; /* pos of the current file in the central dir*/
134 uLong current_file_ok; /* flag about the usability of the current file*/
135 uLong central_pos; /* position of the beginning of the central dir*/
136
137 uLong size_central_dir; /* size of the central directory */
138 uLong offset_central_dir; /* offset of start of central directory with
139 respect to the starting disk number */
140
141 unz_file_info cur_file_info; /* public info about the current file in zip*/
142 unz_file_info_internal cur_file_info_internal; /* private info about it*/
143 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
144 file if we are decompressing it */
145 int encrypted;
146 # ifndef NOUNCRYPT
147 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
148 const unsigned long* pcrc_32_tab;
149 # endif
150 } unz_s;
151
152
153 #ifndef NOUNCRYPT
154 #include "crypt.h"
155 #endif
156
157 /* ===========================================================================
158 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
159 for end of file.
160 IN assertion: the stream s has been sucessfully opened for reading.
161 */
162
163
164 local int unzlocal_getByte OF((
165 const zlib_filefunc_def* pzlib_filefunc_def,
166 voidpf filestream,
167 int *pi));
168
169 local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
170 const zlib_filefunc_def* pzlib_filefunc_def;
171 voidpf filestream;
172 int *pi;
173 {
174 unsigned char c;
175 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
176 if (err==1)
177 {
178 *pi = (int)c;
179 return UNZ_OK;
180 }
181 else
182 {
183 if (ZERROR(*pzlib_filefunc_def,filestream))
184 return UNZ_ERRNO;
185 else
186 return UNZ_EOF;
187 }
188 }
189
190
191 /* ===========================================================================
192 Reads a long in LSB order from the given gz_stream. Sets
193 */
194 local int unzlocal_getShort OF((
195 const zlib_filefunc_def* pzlib_filefunc_def,
196 voidpf filestream,
197 uLong *pX));
198
199 local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
200 const zlib_filefunc_def* pzlib_filefunc_def;
201 voidpf filestream;
202 uLong *pX;
203 {
204 uLong x ;
205 int i = 0;
206 int err;
207
208 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
209 x = (uLong)i;
210
211 if (err==UNZ_OK)
212 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
213 x += ((uLong)i)<<8;
214
215 if (err==UNZ_OK)
216 *pX = x;
217 else
218 *pX = 0;
219 return err;
220 }
221
222 local int unzlocal_getLong OF((
223 const zlib_filefunc_def* pzlib_filefunc_def,
224 voidpf filestream,
225 uLong *pX));
226
227 local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
228 const zlib_filefunc_def* pzlib_filefunc_def;
229 voidpf filestream;
230 uLong *pX;
231 {
232 uLong x ;
233 int i = 0;
234 int err;
235
236 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
237 x = (uLong)i;
238
239 if (err==UNZ_OK)
240 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
241 x += ((uLong)i)<<8;
242
243 if (err==UNZ_OK)
244 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
245 x += ((uLong)i)<<16;
246
247 if (err==UNZ_OK)
248 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
249 x += ((uLong)i)<<24;
250
251 if (err==UNZ_OK)
252 *pX = x;
253 else
254 *pX = 0;
255 return err;
256 }
257
258
259 /* My own strcmpi / strcasecmp */
260 local int strcmpcasenosensitive_internal (fileName1,fileName2)
261 const char* fileName1;
262 const char* fileName2;
263 {
264 for (;;)
265 {
266 char c1=*(fileName1++);
267 char c2=*(fileName2++);
268 if ((c1>='a') && (c1<='z'))
269 c1 -= 0x20;
270 if ((c2>='a') && (c2<='z'))
271 c2 -= 0x20;
272 if (c1=='\0')
273 return ((c2=='\0') ? 0 : -1);
274 if (c2=='\0')
275 return 1;
276 if (c1<c2)
277 return -1;
278 if (c1>c2)
279 return 1;
280 }
281 }
282
283
284 #ifdef CASESENSITIVITYDEFAULT_NO
285 #define CASESENSITIVITYDEFAULTVALUE 2
286 #else
287 #define CASESENSITIVITYDEFAULTVALUE 1
288 #endif
289
290 #ifndef STRCMPCASENOSENTIVEFUNCTION
291 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
292 #endif
293
294 /*
295 Compare two filename (fileName1,fileName2).
296 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
297 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
298 or strcasecmp)
299 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
300 (like 1 on Unix, 2 on Windows)
301
302 */
303 extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
304 const char* fileName1;
305 const char* fileName2;
306 int iCaseSensitivity;
307 {
308 if (iCaseSensitivity==0)
309 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
310
311 if (iCaseSensitivity==1)
312 return strcmp(fileName1,fileName2);
313
314 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
315 }
316
317 #ifndef BUFREADCOMMENT
318 #define BUFREADCOMMENT (0x400)
319 #endif
320
321 /*
322 Locate the Central directory of a zipfile (at the end, just before
323 the global comment)
324 */
325 local uLong unzlocal_SearchCentralDir OF((
326 const zlib_filefunc_def* pzlib_filefunc_def,
327 voidpf filestream));
328
329 local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
330 const zlib_filefunc_def* pzlib_filefunc_def;
331 voidpf filestream;
332 {
333 unsigned char* buf;
334 uLong uSizeFile;
335 uLong uBackRead;
336 uLong uMaxBack=0xffff; /* maximum size of global comment */
337 uLong uPosFound=0;
338
339 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
340 return 0;
341
342
343 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
344
345 if (uMaxBack>uSizeFile)
346 uMaxBack = uSizeFile;
347
348 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
349 if (buf==NULL)
350 return 0;
351
352 uBackRead = 4;
353 while (uBackRead<uMaxBack)
354 {
355 uLong uReadSize,uReadPos ;
356 int i;
357 if (uBackRead+BUFREADCOMMENT>uMaxBack)
358 uBackRead = uMaxBack;
359 else
360 uBackRead+=BUFREADCOMMENT;
361 uReadPos = uSizeFile-uBackRead ;
362
363 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
364 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
365 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
366 break;
367
368 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
369 break;
370
371 for (i=(int)uReadSize-3; (i--)>0;)
372 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
373 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
374 {
375 uPosFound = uReadPos+i;
376 break;
377 }
378
379 if (uPosFound!=0)
380 break;
381 }
382 TRYFREE(buf);
383 return uPosFound;
384 }
385
386 /*
387 Open a Zip file. path contain the full pathname (by example,
388 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
389 "zlib/zlib114.zip".
390 If the zipfile cannot be opened (file doesn't exist or in not valid), the
391 return value is NULL.
392 Else, the return value is a unzFile Handle, usable with other function
393 of this unzip package.
394 */
395 extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
396 const char *path;
397 zlib_filefunc_def* pzlib_filefunc_def;
398 {
399 unz_s us;
400 unz_s *s;
401 uLong central_pos,uL;
402
403 uLong number_disk; /* number of the current dist, used for
404 spaning ZIP, unsupported, always 0*/
405 uLong number_disk_with_CD; /* number the the disk with central dir, used
406 for spaning ZIP, unsupported, always 0*/
407 uLong number_entry_CD; /* total number of entries in
408 the central dir
409 (same than number_entry on nospan) */
410
411 int err=UNZ_OK;
412
413 if (unz_copyright[0]!=' ')
414 return NULL;
415
416 if (pzlib_filefunc_def==NULL)
417 fill_fopen_filefunc(&us.z_filefunc);
418 else
419 us.z_filefunc = *pzlib_filefunc_def;
420
421 us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
422 path,
423 ZLIB_FILEFUNC_MODE_READ |
424 ZLIB_FILEFUNC_MODE_EXISTING);
425 if (us.filestream==NULL)
426 return NULL;
427
428 central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
429 if (central_pos==0)
430 err=UNZ_ERRNO;
431
432 if (ZSEEK(us.z_filefunc, us.filestream,
433 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
434 err=UNZ_ERRNO;
435
436 /* the signature, already checked */
437 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
438 err=UNZ_ERRNO;
439
440 /* number of this disk */
441 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
442 err=UNZ_ERRNO;
443
444 /* number of the disk with the start of the central directory */
445 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
446 err=UNZ_ERRNO;
447
448 /* total number of entries in the central dir on this disk */
449 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
450 err=UNZ_ERRNO;
451
452 /* total number of entries in the central dir */
453 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
454 err=UNZ_ERRNO;
455
456 if ((number_entry_CD!=us.gi.number_entry) ||
457 (number_disk_with_CD!=0) ||
458 (number_disk!=0))
459 err=UNZ_BADZIPFILE;
460
461 /* size of the central directory */
462 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
463 err=UNZ_ERRNO;
464
465 /* offset of start of central directory with respect to the
466 starting disk number */
467 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
468 err=UNZ_ERRNO;
469
470 /* zipfile comment length */
471 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
472 err=UNZ_ERRNO;
473
474 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
475 (err==UNZ_OK))
476 err=UNZ_BADZIPFILE;
477
478 if (err!=UNZ_OK)
479 {
480 ZCLOSE(us.z_filefunc, us.filestream);
481 return NULL;
482 }
483
484 us.byte_before_the_zipfile = central_pos -
485 (us.offset_central_dir+us.size_central_dir);
486 us.central_pos = central_pos;
487 us.pfile_in_zip_read = NULL;
488 us.encrypted = 0;
489
490
491 s=(unz_s*)ALLOC(sizeof(unz_s));
492 *s=us;
493 unzGoToFirstFile((unzFile)s);
494 return (unzFile)s;
495 }
496
497
498 extern unzFile ZEXPORT unzOpen (path)
499 const char *path;
500 {
501 return unzOpen2(path, NULL);
502 }
503
504 /*
505 Close a ZipFile opened with unzipOpen.
506 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
507 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
508 return UNZ_OK if there is no problem. */
509 extern int ZEXPORT unzClose (file)
510 unzFile file;
511 {
512 unz_s* s;
513 if (file==NULL)
514 return UNZ_PARAMERROR;
515 s=(unz_s*)file;
516
517 if (s->pfile_in_zip_read!=NULL)
518 unzCloseCurrentFile(file);
519
520 ZCLOSE(s->z_filefunc, s->filestream);
521 TRYFREE(s);
522 return UNZ_OK;
523 }
524
525
526 /*
527 Write info about the ZipFile in the *pglobal_info structure.
528 No preparation of the structure is needed
529 return UNZ_OK if there is no problem. */
530 extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
531 unzFile file;
532 unz_global_info *pglobal_info;
533 {
534 unz_s* s;
535 if (file==NULL)
536 return UNZ_PARAMERROR;
537 s=(unz_s*)file;
538 *pglobal_info=s->gi;
539 return UNZ_OK;
540 }
541
542
543 /*
544 Translate date/time from Dos format to tm_unz (readable more easilty)
545 */
546 local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
547 uLong ulDosDate;
548 tm_unz* ptm;
549 {
550 uLong uDate;
551 uDate = (uLong)(ulDosDate>>16);
552 ptm->tm_mday = (uInt)(uDate&0x1f) ;
553 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
554 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
555
556 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
557 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
558 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
559 }
560
561 /*
562 Get Info about the current file in the zipfile, with internal only info
563 */
564 local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
565 unz_file_info *pfile_info,
566 unz_file_info_internal
567 *pfile_info_internal,
568 char *szFileName,
569 uLong fileNameBufferSize,
570 void *extraField,
571 uLong extraFieldBufferSize,
572 char *szComment,
573 uLong commentBufferSize));
574
575 local int unzlocal_GetCurrentFileInfoInternal (file,
576 pfile_info,
577 pfile_info_internal,
578 szFileName, fileNameBufferSize,
579 extraField, extraFieldBufferSize,
580 szComment, commentBufferSize)
581 unzFile file;
582 unz_file_info *pfile_info;
583 unz_file_info_internal *pfile_info_internal;
584 char *szFileName;
585 uLong fileNameBufferSize;
586 void *extraField;
587 uLong extraFieldBufferSize;
588 char *szComment;
589 uLong commentBufferSize;
590 {
591 unz_s* s;
592 unz_file_info file_info;
593 unz_file_info_internal file_info_internal;
594 int err=UNZ_OK;
595 uLong uMagic;
596 long lSeek=0;
597
598 if (file==NULL)
599 return UNZ_PARAMERROR;
600 s=(unz_s*)file;
601 if (ZSEEK(s->z_filefunc, s->filestream,
602 s->pos_in_central_dir+s->byte_before_the_zipfile,
603 ZLIB_FILEFUNC_SEEK_SET)!=0)
604 err=UNZ_ERRNO;
605
606
607 /* we check the magic */
608 if (err==UNZ_OK)
609 {
610 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
611 err=UNZ_ERRNO;
612 else if (uMagic!=0x02014b50)
613 err=UNZ_BADZIPFILE;
614 }
615
616 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
617 err=UNZ_ERRNO;
618
619 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
620 err=UNZ_ERRNO;
621
622 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
623 err=UNZ_ERRNO;
624
625 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
626 err=UNZ_ERRNO;
627
628 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
629 err=UNZ_ERRNO;
630
631 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
632
633 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
634 err=UNZ_ERRNO;
635
636 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
637 err=UNZ_ERRNO;
638
639 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
640 err=UNZ_ERRNO;
641
642 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
643 err=UNZ_ERRNO;
644
645 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
646 err=UNZ_ERRNO;
647
648 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
649 err=UNZ_ERRNO;
650
651 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
652 err=UNZ_ERRNO;
653
654 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
655 err=UNZ_ERRNO;
656
657 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
658 err=UNZ_ERRNO;
659
660 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
661 err=UNZ_ERRNO;
662
663 lSeek+=file_info.size_filename;
664 if ((err==UNZ_OK) && (szFileName!=NULL))
665 {
666 uLong uSizeRead ;
667 if (file_info.size_filename<fileNameBufferSize)
668 {
669 *(szFileName+file_info.size_filename)='\0';
670 uSizeRead = file_info.size_filename;
671 }
672 else
673 uSizeRead = fileNameBufferSize;
674
675 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
676 if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
677 err=UNZ_ERRNO;
678 lSeek -= uSizeRead;
679 }
680
681
682 if ((err==UNZ_OK) && (extraField!=NULL))
683 {
684 uLong uSizeRead ;
685 if (file_info.size_file_extra<extraFieldBufferSize)
686 uSizeRead = file_info.size_file_extra;
687 else
688 uSizeRead = extraFieldBufferSize;
689
690 if (lSeek!=0)
691 {
692 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
693 lSeek=0;
694 else
695 err=UNZ_ERRNO;
696 }
697 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
698 if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
699 err=UNZ_ERRNO;
700 lSeek += file_info.size_file_extra - uSizeRead;
701 }
702 else
703 lSeek+=file_info.size_file_extra;
704
705
706 if ((err==UNZ_OK) && (szComment!=NULL))
707 {
708 uLong uSizeRead ;
709 if (file_info.size_file_comment<commentBufferSize)
710 {
711 *(szComment+file_info.size_file_comment)='\0';
712 uSizeRead = file_info.size_file_comment;
713 }
714 else
715 uSizeRead = commentBufferSize;
716
717 if (lSeek!=0)
718 {
719 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
720 lSeek=0;
721 else
722 err=UNZ_ERRNO;
723 }
724 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
725 if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
726 err=UNZ_ERRNO;
727 lSeek+=file_info.size_file_comment - uSizeRead;
728 }
729 else
730 lSeek+=file_info.size_file_comment;
731
732 if ((err==UNZ_OK) && (pfile_info!=NULL))
733 *pfile_info=file_info;
734
735 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
736 *pfile_info_internal=file_info_internal;
737
738 return err;
739 }
740
741
742
743 /*
744 Write info about the ZipFile in the *pglobal_info structure.
745 No preparation of the structure is needed
746 return UNZ_OK if there is no problem.
747 */
748 extern int ZEXPORT unzGetCurrentFileInfo (file,
749 pfile_info,
750 szFileName, fileNameBufferSize,
751 extraField, extraFieldBufferSize,
752 szComment, commentBufferSize)
753 unzFile file;
754 unz_file_info *pfile_info;
755 char *szFileName;
756 uLong fileNameBufferSize;
757 void *extraField;
758 uLong extraFieldBufferSize;
759 char *szComment;
760 uLong commentBufferSize;
761 {
762 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
763 szFileName,fileNameBufferSize,
764 extraField,extraFieldBufferSize,
765 szComment,commentBufferSize);
766 }
767
768 /*
769 Set the current file of the zipfile to the first file.
770 return UNZ_OK if there is no problem
771 */
772 extern int ZEXPORT unzGoToFirstFile (file)
773 unzFile file;
774 {
775 int err=UNZ_OK;
776 unz_s* s;
777 if (file==NULL)
778 return UNZ_PARAMERROR;
779 s=(unz_s*)file;
780 s->pos_in_central_dir=s->offset_central_dir;
781 s->num_file=0;
782 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
783 &s->cur_file_info_internal,
784 NULL,0,NULL,0,NULL,0);
785 s->current_file_ok = (err == UNZ_OK);
786 return err;
787 }
788
789 /*
790 Set the current file of the zipfile to the next file.
791 return UNZ_OK if there is no problem
792 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
793 */
794 extern int ZEXPORT unzGoToNextFile (file)
795 unzFile file;
796 {
797 unz_s* s;
798 int err;
799
800 if (file==NULL)
801 return UNZ_PARAMERROR;
802 s=(unz_s*)file;
803 if (!s->current_file_ok)
804 return UNZ_END_OF_LIST_OF_FILE;
805 if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
806 if (s->num_file+1==s->gi.number_entry)
807 return UNZ_END_OF_LIST_OF_FILE;
808
809 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
810 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
811 s->num_file++;
812 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
813 &s->cur_file_info_internal,
814 NULL,0,NULL,0,NULL,0);
815 s->current_file_ok = (err == UNZ_OK);
816 return err;
817 }
818
819
820 /*
821 Try locate the file szFileName in the zipfile.
822 For the iCaseSensitivity signification, see unzipStringFileNameCompare
823
824 return value :
825 UNZ_OK if the file is found. It becomes the current file.
826 UNZ_END_OF_LIST_OF_FILE if the file is not found
827 */
828 extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
829 unzFile file;
830 const char *szFileName;
831 int iCaseSensitivity;
832 {
833 unz_s* s;
834 int err;
835
836 /* We remember the 'current' position in the file so that we can jump
837 * back there if we fail.
838 */
839 unz_file_info cur_file_infoSaved;
840 unz_file_info_internal cur_file_info_internalSaved;
841 uLong num_fileSaved;
842 uLong pos_in_central_dirSaved;
843
844
845 if (file==NULL)
846 return UNZ_PARAMERROR;
847
848 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
849 return UNZ_PARAMERROR;
850
851 s=(unz_s*)file;
852 if (!s->current_file_ok)
853 return UNZ_END_OF_LIST_OF_FILE;
854
855 /* Save the current state */
856 num_fileSaved = s->num_file;
857 pos_in_central_dirSaved = s->pos_in_central_dir;
858 cur_file_infoSaved = s->cur_file_info;
859 cur_file_info_internalSaved = s->cur_file_info_internal;
860
861 err = unzGoToFirstFile(file);
862
863 while (err == UNZ_OK)
864 {
865 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
866 err = unzGetCurrentFileInfo(file,NULL,
867 szCurrentFileName,sizeof(szCurrentFileName)-1,
868 NULL,0,NULL,0);
869 if (err == UNZ_OK)
870 {
871 if (unzStringFileNameCompare(szCurrentFileName,
872 szFileName,iCaseSensitivity)==0)
873 return UNZ_OK;
874 err = unzGoToNextFile(file);
875 }
876 }
877
878 /* We failed, so restore the state of the 'current file' to where we
879 * were.
880 */
881 s->num_file = num_fileSaved ;
882 s->pos_in_central_dir = pos_in_central_dirSaved ;
883 s->cur_file_info = cur_file_infoSaved;
884 s->cur_file_info_internal = cur_file_info_internalSaved;
885 return err;
886 }
887
888
889 /*
890 ///////////////////////////////////////////
891 // Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
892 // I need random access
893 //
894 // Further optimization could be realized by adding an ability
895 // to cache the directory in memory. The goal being a single
896 // comprehensive file read to put the file I need in a memory.
897 */
898
899 /*
900 typedef struct unz_file_pos_s
901 {
902 uLong pos_in_zip_directory; // offset in file
903 uLong num_of_file; // # of file
904 } unz_file_pos;
905 */
906
907 extern int ZEXPORT unzGetFilePos(file, file_pos)
908 unzFile file;
909 unz_file_pos* file_pos;
910 {
911 unz_s* s;
912
913 if (file==NULL || file_pos==NULL)
914 return UNZ_PARAMERROR;
915 s=(unz_s*)file;
916 if (!s->current_file_ok)
917 return UNZ_END_OF_LIST_OF_FILE;
918
919 file_pos->pos_in_zip_directory = s->pos_in_central_dir;
920 file_pos->num_of_file = s->num_file;
921
922 return UNZ_OK;
923 }
924
925 extern int ZEXPORT unzGoToFilePos(file, file_pos)
926 unzFile file;
927 unz_file_pos* file_pos;
928 {
929 unz_s* s;
930 int err;
931
932 if (file==NULL || file_pos==NULL)
933 return UNZ_PARAMERROR;
934 s=(unz_s*)file;
935
936 /* jump to the right spot */
937 s->pos_in_central_dir = file_pos->pos_in_zip_directory;
938 s->num_file = file_pos->num_of_file;
939
940 /* set the current file */
941 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
942 &s->cur_file_info_internal,
943 NULL,0,NULL,0,NULL,0);
944 /* return results */
945 s->current_file_ok = (err == UNZ_OK);
946 return err;
947 }
948
949 /*
950 // Unzip Helper Functions - should be here?
951 ///////////////////////////////////////////
952 */
953
954 /*
955 Read the local header of the current zipfile
956 Check the coherency of the local header and info in the end of central
957 directory about this file
958 store in *piSizeVar the size of extra info in local header
959 (filename and size of extra field data)
960 */
961 local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
962 poffset_local_extrafield,
963 psize_local_extrafield)
964 unz_s* s;
965 uInt* piSizeVar;
966 uLong *poffset_local_extrafield;
967 uInt *psize_local_extrafield;
968 {
969 uLong uMagic,uData,uFlags;
970 uLong size_filename;
971 uLong size_extra_field;
972 int err=UNZ_OK;
973
974 *piSizeVar = 0;
975 *poffset_local_extrafield = 0;
976 *psize_local_extrafield = 0;
977
978 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
979 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
980 return UNZ_ERRNO;
981
982
983 if (err==UNZ_OK)
984 {
985 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
986 err=UNZ_ERRNO;
987 else if (uMagic!=0x04034b50)
988 err=UNZ_BADZIPFILE;
989 }
990 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
991 err=UNZ_ERRNO;
992 /*
993 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
994 err=UNZ_BADZIPFILE;
995 */
996 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
997 err=UNZ_ERRNO;
998
999 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
1000 err=UNZ_ERRNO;
1001 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
1002 err=UNZ_BADZIPFILE;
1003
1004 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1005 (s->cur_file_info.compression_method!=Z_DEFLATED))
1006 err=UNZ_BADZIPFILE;
1007
1008 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
1009 err=UNZ_ERRNO;
1010
1011 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
1012 err=UNZ_ERRNO;
1013 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
1014 ((uFlags & 8)==0))
1015 err=UNZ_BADZIPFILE;
1016
1017 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
1018 err=UNZ_ERRNO;
1019 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
1020 ((uFlags & 8)==0))
1021 err=UNZ_BADZIPFILE;
1022
1023 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1024 err=UNZ_ERRNO;
1025 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
1026 ((uFlags & 8)==0))
1027 err=UNZ_BADZIPFILE;
1028
1029
1030 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1031 err=UNZ_ERRNO;
1032 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1033 err=UNZ_BADZIPFILE;
1034
1035 *piSizeVar += (uInt)size_filename;
1036
1037 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1038 err=UNZ_ERRNO;
1039 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1040 SIZEZIPLOCALHEADER + size_filename;
1041 *psize_local_extrafield = (uInt)size_extra_field;
1042
1043 *piSizeVar += (uInt)size_extra_field;
1044
1045 return err;
1046 }
1047
1048 /*
1049 Open for reading data the current file in the zipfile.
1050 If there is no error and the file is opened, the return value is UNZ_OK.
1051 */
1052 extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
1053 unzFile file;
1054 int* method;
1055 int* level;
1056 int raw;
1057 const char* password;
1058 {
1059 int err=UNZ_OK;
1060 uInt iSizeVar;
1061 unz_s* s;
1062 file_in_zip_read_info_s* pfile_in_zip_read_info;
1063 uLong offset_local_extrafield; /* offset of the local extra field */
1064 uInt size_local_extrafield; /* size of the local extra field */
1065 # ifndef NOUNCRYPT
1066 char source[12];
1067 # else
1068 if (password != NULL)
1069 return UNZ_PARAMERROR;
1070 # endif
1071
1072 if (file==NULL)
1073 return UNZ_PARAMERROR;
1074 s=(unz_s*)file;
1075 if (!s->current_file_ok)
1076 return UNZ_PARAMERROR;
1077
1078 if (s->pfile_in_zip_read != NULL)
1079 unzCloseCurrentFile(file);
1080
1081 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
1082 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1083 return UNZ_BADZIPFILE;
1084
1085 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
1086 ALLOC(sizeof(file_in_zip_read_info_s));
1087 if (pfile_in_zip_read_info==NULL)
1088 return UNZ_INTERNALERROR;
1089
1090 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1091 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1092 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1093 pfile_in_zip_read_info->pos_local_extrafield=0;
1094 pfile_in_zip_read_info->raw=raw;
1095
1096 if (pfile_in_zip_read_info->read_buffer==NULL)
1097 {
1098 TRYFREE(pfile_in_zip_read_info);
1099 return UNZ_INTERNALERROR;
1100 }
1101
1102 pfile_in_zip_read_info->stream_initialised=0;
1103
1104 if (method!=NULL)
1105 *method = (int)s->cur_file_info.compression_method;
1106
1107 if (level!=NULL)
1108 {
1109 *level = 6;
1110 switch (s->cur_file_info.flag & 0x06)
1111 {
1112 case 6 : *level = 1; break;
1113 case 4 : *level = 2; break;
1114 case 2 : *level = 9; break;
1115 }
1116 }
1117
1118 if ((s->cur_file_info.compression_method!=0) &&
1119 (s->cur_file_info.compression_method!=Z_DEFLATED))
1120 err=UNZ_BADZIPFILE;
1121
1122 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1123 pfile_in_zip_read_info->crc32=0;
1124 pfile_in_zip_read_info->compression_method =
1125 s->cur_file_info.compression_method;
1126 pfile_in_zip_read_info->filestream=s->filestream;
1127 pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1128 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1129
1130 pfile_in_zip_read_info->stream.total_out = 0;
1131
1132 if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
1133 (!raw))
1134 {
1135 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1136 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1137 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1138 pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1139 pfile_in_zip_read_info->stream.avail_in = 0;
1140
1141 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1142 if (err == Z_OK)
1143 pfile_in_zip_read_info->stream_initialised=1;
1144 else
1145 {
1146 TRYFREE(pfile_in_zip_read_info);
1147 return err;
1148 }
1149 /* windowBits is passed < 0 to tell that there is no zlib header.
1150 * Note that in this case inflate *requires* an extra "dummy" byte
1151 * after the compressed stream in order to complete decompression and
1152 * return Z_STREAM_END.
1153 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1154 * size of both compressed and uncompressed data
1155 */
1156 }
1157 pfile_in_zip_read_info->rest_read_compressed =
1158 s->cur_file_info.compressed_size ;
1159 pfile_in_zip_read_info->rest_read_uncompressed =
1160 s->cur_file_info.uncompressed_size ;
1161
1162
1163 pfile_in_zip_read_info->pos_in_zipfile =
1164 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1165 iSizeVar;
1166
1167 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1168
1169 s->pfile_in_zip_read = pfile_in_zip_read_info;
1170
1171 # ifndef NOUNCRYPT
1172 if (password != NULL)
1173 {
1174 int i;
1175 s->pcrc_32_tab = get_crc_table();
1176 init_keys(password,s->keys,s->pcrc_32_tab);
1177 if (ZSEEK(s->z_filefunc, s->filestream,
1178 s->pfile_in_zip_read->pos_in_zipfile +
1179 s->pfile_in_zip_read->byte_before_the_zipfile,
1180 SEEK_SET)!=0)
1181 return UNZ_INTERNALERROR;
1182 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
1183 return UNZ_INTERNALERROR;
1184
1185 for (i = 0; i<12; i++)
1186 zdecode(s->keys,s->pcrc_32_tab,source[i]);
1187
1188 s->pfile_in_zip_read->pos_in_zipfile+=12;
1189 s->encrypted=1;
1190 }
1191 # endif
1192
1193
1194 return UNZ_OK;
1195 }
1196
1197 extern int ZEXPORT unzOpenCurrentFile (file)
1198 unzFile file;
1199 {
1200 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1201 }
1202
1203 extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
1204 unzFile file;
1205 const char* password;
1206 {
1207 return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1208 }
1209
1210 extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
1211 unzFile file;
1212 int* method;
1213 int* level;
1214 int raw;
1215 {
1216 return unzOpenCurrentFile3(file, method, level, raw, NULL);
1217 }
1218
1219 /*
1220 Read bytes from the current file.
1221 buf contain buffer where data must be copied
1222 len the size of buf.
1223
1224 return the number of byte copied if somes bytes are copied
1225 return 0 if the end of file was reached
1226 return <0 with error code if there is an error
1227 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1228 */
1229 extern int ZEXPORT unzReadCurrentFile (file, buf, len)
1230 unzFile file;
1231 voidp buf;
1232 unsigned len;
1233 {
1234 int err=UNZ_OK;
1235 uInt iRead = 0;
1236 unz_s* s;
1237 file_in_zip_read_info_s* pfile_in_zip_read_info;
1238 if (file==NULL)
1239 return UNZ_PARAMERROR;
1240 s=(unz_s*)file;
1241 pfile_in_zip_read_info=s->pfile_in_zip_read;
1242
1243 if (pfile_in_zip_read_info==NULL)
1244 return UNZ_PARAMERROR;
1245
1246
1247 if ((pfile_in_zip_read_info->read_buffer == NULL))
1248 return UNZ_END_OF_LIST_OF_FILE;
1249 if (len==0)
1250 return 0;
1251
1252 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1253
1254 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1255
1256 if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
1257 (!(pfile_in_zip_read_info->raw)))
1258 pfile_in_zip_read_info->stream.avail_out =
1259 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1260
1261 if ((len>pfile_in_zip_read_info->rest_read_compressed+
1262 pfile_in_zip_read_info->stream.avail_in) &&
1263 (pfile_in_zip_read_info->raw))
1264 pfile_in_zip_read_info->stream.avail_out =
1265 (uInt)pfile_in_zip_read_info->rest_read_compressed+
1266 pfile_in_zip_read_info->stream.avail_in;
1267
1268 while (pfile_in_zip_read_info->stream.avail_out>0)
1269 {
1270 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1271 (pfile_in_zip_read_info->rest_read_compressed>0))
1272 {
1273 uInt uReadThis = UNZ_BUFSIZE;
1274 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1275 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1276 if (uReadThis == 0)
1277 return UNZ_EOF;
1278 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1279 pfile_in_zip_read_info->filestream,
1280 pfile_in_zip_read_info->pos_in_zipfile +
1281 pfile_in_zip_read_info->byte_before_the_zipfile,
1282 ZLIB_FILEFUNC_SEEK_SET)!=0)
1283 return UNZ_ERRNO;
1284 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1285 pfile_in_zip_read_info->filestream,
1286 pfile_in_zip_read_info->read_buffer,
1287 uReadThis)!=uReadThis)
1288 return UNZ_ERRNO;
1289
1290
1291 # ifndef NOUNCRYPT
1292 if(s->encrypted)
1293 {
1294 uInt i;
1295 for(i=0;i<uReadThis;i++)
1296 pfile_in_zip_read_info->read_buffer[i] =
1297 zdecode(s->keys,s->pcrc_32_tab,
1298 pfile_in_zip_read_info->read_buffer[i]);
1299 }
1300 # endif
1301
1302
1303 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1304
1305 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1306
1307 pfile_in_zip_read_info->stream.next_in =
1308 (Bytef*)pfile_in_zip_read_info->read_buffer;
1309 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1310 }
1311
1312 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1313 {
1314 uInt uDoCopy,i ;
1315
1316 if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1317 (pfile_in_zip_read_info->rest_read_compressed == 0))
1318 return (iRead==0) ? UNZ_EOF : iRead;
1319
1320 if (pfile_in_zip_read_info->stream.avail_out <
1321 pfile_in_zip_read_info->stream.avail_in)
1322 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1323 else
1324 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1325
1326 for (i=0;i<uDoCopy;i++)
1327 *(pfile_in_zip_read_info->stream.next_out+i) =
1328 *(pfile_in_zip_read_info->stream.next_in+i);
1329
1330 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1331 pfile_in_zip_read_info->stream.next_out,
1332 uDoCopy);
1333 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1334 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1335 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1336 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1337 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1338 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1339 iRead += uDoCopy;
1340 }
1341 else
1342 {
1343 uLong uTotalOutBefore,uTotalOutAfter;
1344 const Bytef *bufBefore;
1345 uLong uOutThis;
1346 int flush=Z_SYNC_FLUSH;
1347
1348 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1349 bufBefore = pfile_in_zip_read_info->stream.next_out;
1350
1351 /*
1352 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1353 pfile_in_zip_read_info->stream.avail_out) &&
1354 (pfile_in_zip_read_info->rest_read_compressed == 0))
1355 flush = Z_FINISH;
1356 */
1357 err=inflate(&pfile_in_zip_read_info->stream,flush);
1358
1359 if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
1360 err = Z_DATA_ERROR;
1361
1362 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1363 uOutThis = uTotalOutAfter-uTotalOutBefore;
1364
1365 pfile_in_zip_read_info->crc32 =
1366 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1367 (uInt)(uOutThis));
1368
1369 pfile_in_zip_read_info->rest_read_uncompressed -=
1370 uOutThis;
1371
1372 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1373
1374 if (err==Z_STREAM_END)
1375 return (iRead==0) ? UNZ_EOF : iRead;
1376 if (err!=Z_OK)
1377 break;
1378 }
1379 }
1380
1381 if (err==Z_OK)
1382 return iRead;
1383 return err;
1384 }
1385
1386
1387 /*
1388 Give the current position in uncompressed data
1389 */
1390 extern z_off_t ZEXPORT unztell (file)
1391 unzFile file;
1392 {
1393 unz_s* s;
1394 file_in_zip_read_info_s* pfile_in_zip_read_info;
1395 if (file==NULL)
1396 return UNZ_PARAMERROR;
1397 s=(unz_s*)file;
1398 pfile_in_zip_read_info=s->pfile_in_zip_read;
1399
1400 if (pfile_in_zip_read_info==NULL)
1401 return UNZ_PARAMERROR;
1402
1403 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1404 }
1405
1406
1407 /*
1408 return 1 if the end of file was reached, 0 elsewhere
1409 */
1410 extern int ZEXPORT unzeof (file)
1411 unzFile file;
1412 {
1413 unz_s* s;
1414 file_in_zip_read_info_s* pfile_in_zip_read_info;
1415 if (file==NULL)
1416 return UNZ_PARAMERROR;
1417 s=(unz_s*)file;
1418 pfile_in_zip_read_info=s->pfile_in_zip_read;
1419
1420 if (pfile_in_zip_read_info==NULL)
1421 return UNZ_PARAMERROR;
1422
1423 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1424 return 1;
1425 else
1426 return 0;
1427 }
1428
1429
1430
1431 /*
1432 Read extra field from the current file (opened by unzOpenCurrentFile)
1433 This is the local-header version of the extra field (sometimes, there is
1434 more info in the local-header version than in the central-header)
1435
1436 if buf==NULL, it return the size of the local extra field that can be read
1437
1438 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1439 buf.
1440 the return value is the number of bytes copied in buf, or (if <0)
1441 the error code
1442 */
1443 extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1444 unzFile file;
1445 voidp buf;
1446 unsigned len;
1447 {
1448 unz_s* s;
1449 file_in_zip_read_info_s* pfile_in_zip_read_info;
1450 uInt read_now;
1451 uLong size_to_read;
1452
1453 if (file==NULL)
1454 return UNZ_PARAMERROR;
1455 s=(unz_s*)file;
1456 pfile_in_zip_read_info=s->pfile_in_zip_read;
1457
1458 if (pfile_in_zip_read_info==NULL)
1459 return UNZ_PARAMERROR;
1460
1461 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1462 pfile_in_zip_read_info->pos_local_extrafield);
1463
1464 if (buf==NULL)
1465 return (int)size_to_read;
1466
1467 if (len>size_to_read)
1468 read_now = (uInt)size_to_read;
1469 else
1470 read_now = (uInt)len ;
1471
1472 if (read_now==0)
1473 return 0;
1474
1475 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1476 pfile_in_zip_read_info->filestream,
1477 pfile_in_zip_read_info->offset_local_extrafield +
1478 pfile_in_zip_read_info->pos_local_extrafield,
1479 ZLIB_FILEFUNC_SEEK_SET)!=0)
1480 return UNZ_ERRNO;
1481
1482 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1483 pfile_in_zip_read_info->filestream,
1484 buf,read_now)!=read_now)
1485 return UNZ_ERRNO;
1486
1487 return (int)read_now;
1488 }
1489
1490 /*
1491 Close the file in zip opened with unzipOpenCurrentFile
1492 Return UNZ_CRCERROR if all the file was read but the CRC is not good
1493 */
1494 extern int ZEXPORT unzCloseCurrentFile (file)
1495 unzFile file;
1496 {
1497 int err=UNZ_OK;
1498
1499 unz_s* s;
1500 file_in_zip_read_info_s* pfile_in_zip_read_info;
1501 if (file==NULL)
1502 return UNZ_PARAMERROR;
1503 s=(unz_s*)file;
1504 pfile_in_zip_read_info=s->pfile_in_zip_read;
1505
1506 if (pfile_in_zip_read_info==NULL)
1507 return UNZ_PARAMERROR;
1508
1509
1510 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
1511 (!pfile_in_zip_read_info->raw))
1512 {
1513 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1514 err=UNZ_CRCERROR;
1515 }
1516
1517
1518 TRYFREE(pfile_in_zip_read_info->read_buffer);
1519 pfile_in_zip_read_info->read_buffer = NULL;
1520 if (pfile_in_zip_read_info->stream_initialised)
1521 inflateEnd(&pfile_in_zip_read_info->stream);
1522
1523 pfile_in_zip_read_info->stream_initialised = 0;
1524 TRYFREE(pfile_in_zip_read_info);
1525
1526 s->pfile_in_zip_read=NULL;
1527
1528 return err;
1529 }
1530
1531
1532 /*
1533 Get the global comment string of the ZipFile, in the szComment buffer.
1534 uSizeBuf is the size of the szComment buffer.
1535 return the number of byte copied or an error code <0
1536 */
1537 extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1538 unzFile file;
1539 char *szComment;
1540 uLong uSizeBuf;
1541 {
1542 unz_s* s;
1543 uLong uReadThis ;
1544 if (file==NULL)
1545 return UNZ_PARAMERROR;
1546 s=(unz_s*)file;
1547
1548 uReadThis = uSizeBuf;
1549 if (uReadThis>s->gi.size_comment)
1550 uReadThis = s->gi.size_comment;
1551
1552 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
1553 return UNZ_ERRNO;
1554
1555 if (uReadThis>0)
1556 {
1557 *szComment='\0';
1558 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
1559 return UNZ_ERRNO;
1560 }
1561
1562 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1563 *(szComment+s->gi.size_comment)='\0';
1564 return (int)uReadThis;
1565 }
1566
1567 /* Additions by RX '2004 */
1568 extern uLong ZEXPORT unzGetOffset (file)
1569 unzFile file;
1570 {
1571 unz_s* s;
1572
1573 if (file==NULL)
1574 return UNZ_PARAMERROR;
1575 s=(unz_s*)file;
1576 if (!s->current_file_ok)
1577 return 0;
1578 if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
1579 if (s->num_file==s->gi.number_entry)
1580 return 0;
1581 return s->pos_in_central_dir;
1582 }
1583
1584 extern int ZEXPORT unzSetOffset (file, pos)
1585 unzFile file;
1586 uLong pos;
1587 {
1588 unz_s* s;
1589 int err;
1590
1591 if (file==NULL)
1592 return UNZ_PARAMERROR;
1593 s=(unz_s*)file;
1594
1595 s->pos_in_central_dir = pos;
1596 s->num_file = s->gi.number_entry; /* hack */
1597 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1598 &s->cur_file_info_internal,
1599 NULL,0,NULL,0,NULL,0);
1600 s->current_file_ok = (err == UNZ_OK);
1601 return err;
1602 }