Ruby: ext/zlib/zlib-1.2.13/contrib/minizip/unzip.c Source File

Ruby 3.0.5p211 (2022-11-24 revision ba5cf0f7c52d4d35cc6a173c89eda98ceffa2dcf)

unzip.c
Go to the documentation of this file.
1/* unzip.c -- IO for uncompress .zip files using zlib
2 Version 1.1, February 14h, 2010
3 part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
4
5 Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
6
7 Modifications of Unzip for Zip64
8 Copyright (C) 2007-2008 Even Rouault
9
10 Modifications for Zip64 support on both zip and unzip
11 Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
12
13 For more info read MiniZip_info.txt
14
15
16 ------------------------------------------------------------------------------------
17 Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
18 compatibility with older software. The following is from the original crypt.c.
19 Code woven in by Terry Thorsen 1/2003.
20
21 Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
22
23 See the accompanying file LICENSE, version 2000-Apr-09 or later
24 (the contents of which are also included in zip.h) for terms of use.
25 If, for some reason, all these files are missing, the Info-ZIP license
26 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
27
28 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
29
30 The encryption/decryption parts of this source code (as opposed to the
31 non-echoing password parts) were originally written in Europe. The
32 whole source package can be freely distributed, including from the USA.
33 (Prior to January 2000, re-export from the US was a violation of US law.)
34
35 This encryption code is a direct transcription of the algorithm from
36 Roger Schlafly, described by Phil Katz in the file appnote.txt. This
37 file (appnote.txt) is distributed with the PKZIP program (even in the
38 version without encryption capabilities).
39
40 ------------------------------------------------------------------------------------
41
42 Changes in unzip.c
43
44 2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
45 2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
46 2007-2008 - Even Rouault - Remove old C style function prototypes
47 2007-2008 - Even Rouault - Add unzip support for ZIP64
48
49 Copyright (C) 2007-2008 Even Rouault
50
51
52 Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
53 Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
54 should only read the compressed/uncompressed size from the Zip64 format if
55 the size from normal header was 0xFFFFFFFF
56 Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
57 Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
58 Patch created by Daniel Borca
59
60 Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
61
62 Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
63
64*/
65
66
67#include <stdio.h>
68#include <stdlib.h>
69#include <string.h>
70
71#ifndef NOUNCRYPT
72 #define NOUNCRYPT
73#endif
74
75#include "zlib.h"
76#include "unzip.h"
77
78#ifdef STDC
79# include <stddef.h>
80# include <string.h>
81# include <stdlib.h>
82#endif
83#ifdef NO_ERRNO_H
84 extern int errno;
85#else
86# include <errno.h>
87#endif
88
89
90#ifndef local
91# define local static
92#endif
93/* compile with -Dlocal if your debugger can't find static symbols */
94
95
96#ifndef CASESENSITIVITYDEFAULT_NO
97# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
98# define CASESENSITIVITYDEFAULT_NO
99# endif
100#endif
101
102
103#ifndef UNZ_BUFSIZE
104#define UNZ_BUFSIZE (16384)
105#endif
106
107#ifndef UNZ_MAXFILENAMEINZIP
108#define UNZ_MAXFILENAMEINZIP (256)
109#endif
110
111#ifndef ALLOC
112# define ALLOC(size) (malloc(size))
113#endif
114#ifndef TRYFREE
115# define TRYFREE(p) { free(p);}
116#endif
117
118#define SIZECENTRALDIRITEM (0x2e)
119#define SIZEZIPLOCALHEADER (0x1e)
120
121
122 const char unz_copyright[] =
123 " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
124
125/* unz_file_info_interntal contain internal info about a file in zipfile*/
126 typedef struct unz_file_info64_internal_s
127{
128 ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
129} unz_file_info64_internal;
130
131
132/* file_in_zip_read_info_s contain internal information about a file in zipfile,
133 when reading and decompress it */
134 typedef struct
135{
136 char *read_buffer; /* internal buffer for compressed data */
137 z_stream stream; /* zLib stream structure for inflate */
138
139#ifdef HAVE_BZIP2
140 bz_stream bstream; /* bzLib stream structure for bziped */
141#endif
142
143 ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
144 uLong stream_initialised; /* flag set if stream structure is initialised*/
145
146 ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
147 uInt size_local_extrafield;/* size of the local extra field */
148 ZPOS64_T pos_local_extrafield; /* position in the local extra field in read*/
149 ZPOS64_T total_out_64;
150
151 uLong crc32; /* crc32 of all data uncompressed */
152 uLong crc32_wait; /* crc32 we must obtain after decompress all */
153 ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
154 ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
155 zlib_filefunc64_32_def z_filefunc;
156 voidpf filestream; /* io structore of the zipfile */
157 uLong compression_method; /* compression method (0==store) */
158 ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
159 int raw;
160} file_in_zip64_read_info_s;
161
162
163/* unz64_s contain internal information about the zipfile
164*/
165 typedef struct
166{
167 zlib_filefunc64_32_def z_filefunc;
168 int is64bitOpenFunction;
169 voidpf filestream; /* io structore of the zipfile */
170 unz_global_info64 gi; /* public global information */
171 ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
172 ZPOS64_T num_file; /* number of the current file in the zipfile*/
173 ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/
174 ZPOS64_T current_file_ok; /* flag about the usability of the current file*/
175 ZPOS64_T central_pos; /* position of the beginning of the central dir*/
176
177 ZPOS64_T size_central_dir; /* size of the central directory */
178 ZPOS64_T offset_central_dir; /* offset of start of central directory with
179 respect to the starting disk number */
180
181 unz_file_info64 cur_file_info; /* public info about the current file in zip*/
182 unz_file_info64_internal cur_file_info_internal; /* private info about it*/
183 file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
184 file if we are decompressing it */
185 int encrypted;
186
187 int isZip64;
188
189# ifndef NOUNCRYPT
190 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
191 const z_crc_t* pcrc_32_tab;
192# endif
193} unz64_s;
194
195
196#ifndef NOUNCRYPT
197#include "crypt.h"
198#endif
199
200/* ===========================================================================
201 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
202 for end of file.
203 IN assertion: the stream s has been successfully opened for reading.
204*/
205
206
207 local int unz64local_getByte OF((
208 const zlib_filefunc64_32_def* pzlib_filefunc_def,
209 voidpf filestream,
210 int *pi));
211
212 local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)
213{
214 unsigned char c;
215 int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
216 if (err==1)
217 {
218 *pi = (int)c;
219 return UNZ_OK;
220 }
221 else
222 {
223 if (ZERROR64(*pzlib_filefunc_def,filestream))
224 return UNZ_ERRNO;
225 else
226 return UNZ_EOF;
227 }
228}
229
230
231/* ===========================================================================
232 Reads a long in LSB order from the given gz_stream. Sets
233*/
234 local int unz64local_getShort OF((
235 const zlib_filefunc64_32_def* pzlib_filefunc_def,
236 voidpf filestream,
237 uLong *pX));
238
239 local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
240 voidpf filestream,
241 uLong *pX)
242{
243 uLong x ;
244 int i = 0;
245 int err;
246
247 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
248 x = (uLong)i;
249
250 if (err==UNZ_OK)
251 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
252 x |= ((uLong)i)<<8;
253
254 if (err==UNZ_OK)
255 *pX = x;
256 else
257 *pX = 0;
258 return err;
259}
260
261 local int unz64local_getLong OF((
262 const zlib_filefunc64_32_def* pzlib_filefunc_def,
263 voidpf filestream,
264 uLong *pX));
265
266 local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
267 voidpf filestream,
268 uLong *pX)
269{
270 uLong x ;
271 int i = 0;
272 int err;
273
274 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
275 x = (uLong)i;
276
277 if (err==UNZ_OK)
278 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
279 x |= ((uLong)i)<<8;
280
281 if (err==UNZ_OK)
282 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
283 x |= ((uLong)i)<<16;
284
285 if (err==UNZ_OK)
286 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
287 x += ((uLong)i)<<24;
288
289 if (err==UNZ_OK)
290 *pX = x;
291 else
292 *pX = 0;
293 return err;
294}
295
296 local int unz64local_getLong64 OF((
297 const zlib_filefunc64_32_def* pzlib_filefunc_def,
298 voidpf filestream,
299 ZPOS64_T *pX));
300
301
302 local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
303 voidpf filestream,
304 ZPOS64_T *pX)
305{
306 ZPOS64_T x ;
307 int i = 0;
308 int err;
309
310 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
311 x = (ZPOS64_T)i;
312
313 if (err==UNZ_OK)
314 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
315 x |= ((ZPOS64_T)i)<<8;
316
317 if (err==UNZ_OK)
318 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
319 x |= ((ZPOS64_T)i)<<16;
320
321 if (err==UNZ_OK)
322 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
323 x |= ((ZPOS64_T)i)<<24;
324
325 if (err==UNZ_OK)
326 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
327 x |= ((ZPOS64_T)i)<<32;
328
329 if (err==UNZ_OK)
330 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
331 x |= ((ZPOS64_T)i)<<40;
332
333 if (err==UNZ_OK)
334 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
335 x |= ((ZPOS64_T)i)<<48;
336
337 if (err==UNZ_OK)
338 err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
339 x |= ((ZPOS64_T)i)<<56;
340
341 if (err==UNZ_OK)
342 *pX = x;
343 else
344 *pX = 0;
345 return err;
346}
347
348/* My own strcmpi / strcasecmp */
349 local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
350{
351 for (;;)
352 {
353 char c1=*(fileName1++);
354 char c2=*(fileName2++);
355 if ((c1>='a') && (c1<='z'))
356 c1 -= 0x20;
357 if ((c2>='a') && (c2<='z'))
358 c2 -= 0x20;
359 if (c1=='\0')
360 return ((c2=='\0') ? 0 : -1);
361 if (c2=='\0')
362 return 1;
363 if (c1<c2)
364 return -1;
365 if (c1>c2)
366 return 1;
367 }
368}
369
370
371#ifdef CASESENSITIVITYDEFAULT_NO
372#define CASESENSITIVITYDEFAULTVALUE 2
373#else
374#define CASESENSITIVITYDEFAULTVALUE 1
375#endif
376
377#ifndef STRCMPCASENOSENTIVEFUNCTION
378#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
379#endif
380
381/*
382 Compare two filename (fileName1,fileName2).
383 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
384 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
385 or strcasecmp)
386 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
387 (like 1 on Unix, 2 on Windows)
388
389*/
390 extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,
391 const char* fileName2,
392 int iCaseSensitivity)
393
394{
395 if (iCaseSensitivity==0)
396 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
397
398 if (iCaseSensitivity==1)
399 return strcmp(fileName1,fileName2);
400
401 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
402}
403
404#ifndef BUFREADCOMMENT
405#define BUFREADCOMMENT (0x400)
406#endif
407
408/*
409 Locate the Central directory of a zipfile (at the end, just before
410 the global comment)
411*/
412 local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
413 local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
414{
415 unsigned char* buf;
416 ZPOS64_T uSizeFile;
417 ZPOS64_T uBackRead;
418 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
419 ZPOS64_T uPosFound=0;
420
421 if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
422 return 0;
423
424
425 uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
426
427 if (uMaxBack>uSizeFile)
428 uMaxBack = uSizeFile;
429
430 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
431 if (buf==NULL)
432 return 0;
433
434 uBackRead = 4;
435 while (uBackRead<uMaxBack)
436 {
437 uLong uReadSize;
438 ZPOS64_T uReadPos ;
439 int i;
440 if (uBackRead+BUFREADCOMMENT>uMaxBack)
441 uBackRead = uMaxBack;
442 else
443 uBackRead+=BUFREADCOMMENT;
444 uReadPos = uSizeFile-uBackRead ;
445
446 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
447 (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
448 if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
449 break;
450
451 if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
452 break;
453
454 for (i=(int)uReadSize-3; (i--)>0;)
455 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
456 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
457 {
458 uPosFound = uReadPos+(unsigned)i;
459 break;
460 }
461
462 if (uPosFound!=0)
463 break;
464 }
465 TRYFREE(buf);
466 return uPosFound;
467}
468
469
470/*
471 Locate the Central directory 64 of a zipfile (at the end, just before
472 the global comment)
473*/
474 local ZPOS64_T unz64local_SearchCentralDir64 OF((
475 const zlib_filefunc64_32_def* pzlib_filefunc_def,
476 voidpf filestream));
477
478 local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
479 voidpf filestream)
480{
481 unsigned char* buf;
482 ZPOS64_T uSizeFile;
483 ZPOS64_T uBackRead;
484 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
485 ZPOS64_T uPosFound=0;
486 uLong uL;
487 ZPOS64_T relativeOffset;
488
489 if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
490 return 0;
491
492
493 uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
494
495 if (uMaxBack>uSizeFile)
496 uMaxBack = uSizeFile;
497
498 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
499 if (buf==NULL)
500 return 0;
501
502 uBackRead = 4;
503 while (uBackRead<uMaxBack)
504 {
505 uLong uReadSize;
506 ZPOS64_T uReadPos;
507 int i;
508 if (uBackRead+BUFREADCOMMENT>uMaxBack)
509 uBackRead = uMaxBack;
510 else
511 uBackRead+=BUFREADCOMMENT;
512 uReadPos = uSizeFile-uBackRead ;
513
514 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
515 (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
516 if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
517 break;
518
519 if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
520 break;
521
522 for (i=(int)uReadSize-3; (i--)>0;)
523 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
524 ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
525 {
526 uPosFound = uReadPos+(unsigned)i;
527 break;
528 }
529
530 if (uPosFound!=0)
531 break;
532 }
533 TRYFREE(buf);
534 if (uPosFound == 0)
535 return 0;
536
537 /* Zip64 end of central directory locator */
538 if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
539 return 0;
540
541 /* the signature, already checked */
542 if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
543 return 0;
544
545 /* number of the disk with the start of the zip64 end of central directory */
546 if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
547 return 0;
548 if (uL != 0)
549 return 0;
550
551 /* relative offset of the zip64 end of central directory record */
552 if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
553 return 0;
554
555 /* total number of disks */
556 if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
557 return 0;
558 if (uL != 1)
559 return 0;
560
561 /* Goto end of central directory record */
562 if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
563 return 0;
564
565 /* the signature */
566 if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
567 return 0;
568
569 if (uL != 0x06064b50)
570 return 0;
571
572 return relativeOffset;
573}
574
575/*
576 Open a Zip file. path contain the full pathname (by example,
577 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
578 "zlib/zlib114.zip".
579 If the zipfile cannot be opened (file doesn't exist or in not valid), the
580 return value is NULL.
581 Else, the return value is a unzFile Handle, usable with other function
582 of this unzip package.
583*/
584 local unzFile unzOpenInternal (const void *path,
585 zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
586 int is64bitOpenFunction)
587{
588 unz64_s us;
589 unz64_s *s;
590 ZPOS64_T central_pos;
591 uLong uL;
592
593 uLong number_disk; /* number of the current dist, used for
594 spaning ZIP, unsupported, always 0*/
595 uLong number_disk_with_CD; /* number the the disk with central dir, used
596 for spaning ZIP, unsupported, always 0*/
597 ZPOS64_T number_entry_CD; /* total number of entries in
598 the central dir
599 (same than number_entry on nospan) */
600
601 int err=UNZ_OK;
602
603 if (unz_copyright[0]!=' ')
604 return NULL;
605
606 us.z_filefunc.zseek32_file = NULL;
607 us.z_filefunc.ztell32_file = NULL;
608 if (pzlib_filefunc64_32_def==NULL)
609 fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
610 else
611 us.z_filefunc = *pzlib_filefunc64_32_def;
612 us.is64bitOpenFunction = is64bitOpenFunction;
613
614
615
616 us.filestream = ZOPEN64(us.z_filefunc,
617 path,
618 ZLIB_FILEFUNC_MODE_READ |
619 ZLIB_FILEFUNC_MODE_EXISTING);
620 if (us.filestream==NULL)
621 return NULL;
622
623 central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
624 if (central_pos)
625 {
626 uLong uS;
627 ZPOS64_T uL64;
628
629 us.isZip64 = 1;
630
631 if (ZSEEK64(us.z_filefunc, us.filestream,
632 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
633 err=UNZ_ERRNO;
634
635 /* the signature, already checked */
636 if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
637 err=UNZ_ERRNO;
638
639 /* size of zip64 end of central directory record */
640 if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
641 err=UNZ_ERRNO;
642
643 /* version made by */
644 if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
645 err=UNZ_ERRNO;
646
647 /* version needed to extract */
648 if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
649 err=UNZ_ERRNO;
650
651 /* number of this disk */
652 if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
653 err=UNZ_ERRNO;
654
655 /* number of the disk with the start of the central directory */
656 if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
657 err=UNZ_ERRNO;
658
659 /* total number of entries in the central directory on this disk */
660 if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
661 err=UNZ_ERRNO;
662
663 /* total number of entries in the central directory */
664 if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
665 err=UNZ_ERRNO;
666
667 if ((number_entry_CD!=us.gi.number_entry) ||
668 (number_disk_with_CD!=0) ||
669 (number_disk!=0))
670 err=UNZ_BADZIPFILE;
671
672 /* size of the central directory */
673 if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
674 err=UNZ_ERRNO;
675
676 /* offset of start of central directory with respect to the
677 starting disk number */
678 if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
679 err=UNZ_ERRNO;
680
681 us.gi.size_comment = 0;
682 }
683 else
684 {
685 central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
686 if (central_pos==0)
687 err=UNZ_ERRNO;
688
689 us.isZip64 = 0;
690
691 if (ZSEEK64(us.z_filefunc, us.filestream,
692 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
693 err=UNZ_ERRNO;
694
695 /* the signature, already checked */
696 if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
697 err=UNZ_ERRNO;
698
699 /* number of this disk */
700 if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
701 err=UNZ_ERRNO;
702
703 /* number of the disk with the start of the central directory */
704 if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
705 err=UNZ_ERRNO;
706
707 /* total number of entries in the central dir on this disk */
708 if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
709 err=UNZ_ERRNO;
710 us.gi.number_entry = uL;
711
712 /* total number of entries in the central dir */
713 if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
714 err=UNZ_ERRNO;
715 number_entry_CD = uL;
716
717 if ((number_entry_CD!=us.gi.number_entry) ||
718 (number_disk_with_CD!=0) ||
719 (number_disk!=0))
720 err=UNZ_BADZIPFILE;
721
722 /* size of the central directory */
723 if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
724 err=UNZ_ERRNO;
725 us.size_central_dir = uL;
726
727 /* offset of start of central directory with respect to the
728 starting disk number */
729 if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
730 err=UNZ_ERRNO;
731 us.offset_central_dir = uL;
732
733 /* zipfile comment length */
734 if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
735 err=UNZ_ERRNO;
736 }
737
738 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
739 (err==UNZ_OK))
740 err=UNZ_BADZIPFILE;
741
742 if (err!=UNZ_OK)
743 {
744 ZCLOSE64(us.z_filefunc, us.filestream);
745 return NULL;
746 }
747
748 us.byte_before_the_zipfile = central_pos -
749 (us.offset_central_dir+us.size_central_dir);
750 us.central_pos = central_pos;
751 us.pfile_in_zip_read = NULL;
752 us.encrypted = 0;
753
754
755 s=(unz64_s*)ALLOC(sizeof(unz64_s));
756 if( s != NULL)
757 {
758 *s=us;
759 unzGoToFirstFile((unzFile)s);
760 }
761 return (unzFile)s;
762}
763
764
765 extern unzFile ZEXPORT unzOpen2 (const char *path,
766 zlib_filefunc_def* pzlib_filefunc32_def)
767{
768 if (pzlib_filefunc32_def != NULL)
769 {
770 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
771 fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
772 return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
773 }
774 else
775 return unzOpenInternal(path, NULL, 0);
776}
777
778 extern unzFile ZEXPORT unzOpen2_64 (const void *path,
779 zlib_filefunc64_def* pzlib_filefunc_def)
780{
781 if (pzlib_filefunc_def != NULL)
782 {
783 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
784 zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
785 zlib_filefunc64_32_def_fill.ztell32_file = NULL;
786 zlib_filefunc64_32_def_fill.zseek32_file = NULL;
787 return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
788 }
789 else
790 return unzOpenInternal(path, NULL, 1);
791}
792
793 extern unzFile ZEXPORT unzOpen (const char *path)
794{
795 return unzOpenInternal(path, NULL, 0);
796}
797
798 extern unzFile ZEXPORT unzOpen64 (const void *path)
799{
800 return unzOpenInternal(path, NULL, 1);
801}
802
803/*
804 Close a ZipFile opened with unzOpen.
805 If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
806 these files MUST be closed with unzCloseCurrentFile before call unzClose.
807 return UNZ_OK if there is no problem. */
808 extern int ZEXPORT unzClose (unzFile file)
809{
810 unz64_s* s;
811 if (file==NULL)
812 return UNZ_PARAMERROR;
813 s=(unz64_s*)file;
814
815 if (s->pfile_in_zip_read!=NULL)
816 unzCloseCurrentFile(file);
817
818 ZCLOSE64(s->z_filefunc, s->filestream);
819 TRYFREE(s);
820 return UNZ_OK;
821}
822
823
824/*
825 Write info about the ZipFile in the *pglobal_info structure.
826 No preparation of the structure is needed
827 return UNZ_OK if there is no problem. */
828 extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
829{
830 unz64_s* s;
831 if (file==NULL)
832 return UNZ_PARAMERROR;
833 s=(unz64_s*)file;
834 *pglobal_info=s->gi;
835 return UNZ_OK;
836}
837
838 extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
839{
840 unz64_s* s;
841 if (file==NULL)
842 return UNZ_PARAMERROR;
843 s=(unz64_s*)file;
844 /* to do : check if number_entry is not truncated */
845 pglobal_info32->number_entry = (uLong)s->gi.number_entry;
846 pglobal_info32->size_comment = s->gi.size_comment;
847 return UNZ_OK;
848}
849/*
850 Translate date/time from Dos format to tm_unz (readable more easilty)
851*/
852 local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
853{
854 ZPOS64_T uDate;
855 uDate = (ZPOS64_T)(ulDosDate>>16);
856 ptm->tm_mday = (int)(uDate&0x1f) ;
857 ptm->tm_mon = (int)((((uDate)&0x1E0)/0x20)-1) ;
858 ptm->tm_year = (int)(((uDate&0x0FE00)/0x0200)+1980) ;
859
860 ptm->tm_hour = (int) ((ulDosDate &0xF800)/0x800);
861 ptm->tm_min = (int) ((ulDosDate&0x7E0)/0x20) ;
862 ptm->tm_sec = (int) (2*(ulDosDate&0x1f)) ;
863}
864
865/*
866 Get Info about the current file in the zipfile, with internal only info
867*/
868 local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
869 unz_file_info64 *pfile_info,
870 unz_file_info64_internal
871 *pfile_info_internal,
872 char *szFileName,
873 uLong fileNameBufferSize,
874 void *extraField,
875 uLong extraFieldBufferSize,
876 char *szComment,
877 uLong commentBufferSize));
878
879 local int unz64local_GetCurrentFileInfoInternal (unzFile file,
880 unz_file_info64 *pfile_info,
881 unz_file_info64_internal
882 *pfile_info_internal,
883 char *szFileName,
884 uLong fileNameBufferSize,
885 void *extraField,
886 uLong extraFieldBufferSize,
887 char *szComment,
888 uLong commentBufferSize)
889{
890 unz64_s* s;
891 unz_file_info64 file_info;
892 unz_file_info64_internal file_info_internal;
893 int err=UNZ_OK;
894 uLong uMagic;
895 long lSeek=0;
896 uLong uL;
897
898 if (file==NULL)
899 return UNZ_PARAMERROR;
900 s=(unz64_s*)file;
901 if (ZSEEK64(s->z_filefunc, s->filestream,
902 s->pos_in_central_dir+s->byte_before_the_zipfile,
903 ZLIB_FILEFUNC_SEEK_SET)!=0)
904 err=UNZ_ERRNO;
905
906
907 /* we check the magic */
908 if (err==UNZ_OK)
909 {
910 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
911 err=UNZ_ERRNO;
912 else if (uMagic!=0x02014b50)
913 err=UNZ_BADZIPFILE;
914 }
915
916 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
917 err=UNZ_ERRNO;
918
919 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
920 err=UNZ_ERRNO;
921
922 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
923 err=UNZ_ERRNO;
924
925 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
926 err=UNZ_ERRNO;
927
928 if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
929 err=UNZ_ERRNO;
930
931 unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
932
933 if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
934 err=UNZ_ERRNO;
935
936 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
937 err=UNZ_ERRNO;
938 file_info.compressed_size = uL;
939
940 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
941 err=UNZ_ERRNO;
942 file_info.uncompressed_size = uL;
943
944 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
945 err=UNZ_ERRNO;
946
947 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
948 err=UNZ_ERRNO;
949
950 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
951 err=UNZ_ERRNO;
952
953 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
954 err=UNZ_ERRNO;
955
956 if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
957 err=UNZ_ERRNO;
958
959 if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
960 err=UNZ_ERRNO;
961
962 // relative offset of local header
963 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
964 err=UNZ_ERRNO;
965 file_info_internal.offset_curfile = uL;
966
967 lSeek+=file_info.size_filename;
968 if ((err==UNZ_OK) && (szFileName!=NULL))
969 {
970 uLong uSizeRead ;
971 if (file_info.size_filename<fileNameBufferSize)
972 {
973 *(szFileName+file_info.size_filename)='\0';
974 uSizeRead = file_info.size_filename;
975 }
976 else
977 uSizeRead = fileNameBufferSize;
978
979 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
980 if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
981 err=UNZ_ERRNO;
982 lSeek -= uSizeRead;
983 }
984
985 // Read extrafield
986 if ((err==UNZ_OK) && (extraField!=NULL))
987 {
988 ZPOS64_T uSizeRead ;
989 if (file_info.size_file_extra<extraFieldBufferSize)
990 uSizeRead = file_info.size_file_extra;
991 else
992 uSizeRead = extraFieldBufferSize;
993
994 if (lSeek!=0)
995 {
996 if (ZSEEK64(s->z_filefunc, s->filestream,(ZPOS64_T)lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
997 lSeek=0;
998 else
999 err=UNZ_ERRNO;
1000 }
1001
1002 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
1003 if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
1004 err=UNZ_ERRNO;
1005
1006 lSeek += file_info.size_file_extra - (uLong)uSizeRead;
1007 }
1008 else
1009 lSeek += file_info.size_file_extra;
1010
1011
1012 if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
1013 {
1014 uLong acc = 0;
1015
1016 // since lSeek now points to after the extra field we need to move back
1017 lSeek -= file_info.size_file_extra;
1018
1019 if (lSeek!=0)
1020 {
1021 if (ZSEEK64(s->z_filefunc, s->filestream,(ZPOS64_T)lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
1022 lSeek=0;
1023 else
1024 err=UNZ_ERRNO;
1025 }
1026
1027 while(acc < file_info.size_file_extra)
1028 {
1029 uLong headerId;
1030 uLong dataSize;
1031
1032 if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
1033 err=UNZ_ERRNO;
1034
1035 if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
1036 err=UNZ_ERRNO;
1037
1038 /* ZIP64 extra fields */
1039 if (headerId == 0x0001)
1040 {
1041 uLong uL;
1042
1043 if(file_info.uncompressed_size == MAXU32)
1044 {
1045 if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
1046 err=UNZ_ERRNO;
1047 }
1048
1049 if(file_info.compressed_size == MAXU32)
1050 {
1051 if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
1052 err=UNZ_ERRNO;
1053 }
1054
1055 if(file_info_internal.offset_curfile == MAXU32)
1056 {
1057 /* Relative Header offset */
1058 if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
1059 err=UNZ_ERRNO;
1060 }
1061
1062 if(file_info.disk_num_start == MAXU32)
1063 {
1064 /* Disk Start Number */
1065 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
1066 err=UNZ_ERRNO;
1067 }
1068
1069 }
1070 else
1071 {
1072 if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
1073 err=UNZ_ERRNO;
1074 }
1075
1076 acc += 2 + 2 + dataSize;
1077 }
1078 }
1079
1080 if ((err==UNZ_OK) && (szComment!=NULL))
1081 {
1082 uLong uSizeRead ;
1083 if (file_info.size_file_comment<commentBufferSize)
1084 {
1085 *(szComment+file_info.size_file_comment)='\0';
1086 uSizeRead = file_info.size_file_comment;
1087 }
1088 else
1089 uSizeRead = commentBufferSize;
1090
1091 if (lSeek!=0)
1092 {
1093 if (ZSEEK64(s->z_filefunc, s->filestream,(ZPOS64_T)lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
1094 lSeek=0;
1095 else
1096 err=UNZ_ERRNO;
1097 }
1098
1099 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
1100 if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
1101 err=UNZ_ERRNO;
1102 lSeek+=file_info.size_file_comment - uSizeRead;
1103 }
1104 else
1105 lSeek+=file_info.size_file_comment;
1106
1107
1108 if ((err==UNZ_OK) && (pfile_info!=NULL))
1109 *pfile_info=file_info;
1110
1111 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
1112 *pfile_info_internal=file_info_internal;
1113
1114 return err;
1115}
1116
1117
1118
1119/*
1120 Write info about the ZipFile in the *pglobal_info structure.
1121 No preparation of the structure is needed
1122 return UNZ_OK if there is no problem.
1123*/
1124 extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
1125 unz_file_info64 * pfile_info,
1126 char * szFileName, uLong fileNameBufferSize,
1127 void *extraField, uLong extraFieldBufferSize,
1128 char* szComment, uLong commentBufferSize)
1129{
1130 return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
1131 szFileName,fileNameBufferSize,
1132 extraField,extraFieldBufferSize,
1133 szComment,commentBufferSize);
1134}
1135
1136 extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
1137 unz_file_info * pfile_info,
1138 char * szFileName, uLong fileNameBufferSize,
1139 void *extraField, uLong extraFieldBufferSize,
1140 char* szComment, uLong commentBufferSize)
1141{
1142 int err;
1143 unz_file_info64 file_info64;
1144 err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
1145 szFileName,fileNameBufferSize,
1146 extraField,extraFieldBufferSize,
1147 szComment,commentBufferSize);
1148 if ((err==UNZ_OK) && (pfile_info != NULL))
1149 {
1150 pfile_info->version = file_info64.version;
1151 pfile_info->version_needed = file_info64.version_needed;
1152 pfile_info->flag = file_info64.flag;
1153 pfile_info->compression_method = file_info64.compression_method;
1154 pfile_info->dosDate = file_info64.dosDate;
1155 pfile_info->crc = file_info64.crc;
1156
1157 pfile_info->size_filename = file_info64.size_filename;
1158 pfile_info->size_file_extra = file_info64.size_file_extra;
1159 pfile_info->size_file_comment = file_info64.size_file_comment;
1160
1161 pfile_info->disk_num_start = file_info64.disk_num_start;
1162 pfile_info->internal_fa = file_info64.internal_fa;
1163 pfile_info->external_fa = file_info64.external_fa;
1164
1165 pfile_info->tmu_date = file_info64.tmu_date,
1166
1167
1168 pfile_info->compressed_size = (uLong)file_info64.compressed_size;
1169 pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
1170
1171 }
1172 return err;
1173}
1174/*
1175 Set the current file of the zipfile to the first file.
1176 return UNZ_OK if there is no problem
1177*/
1178 extern int ZEXPORT unzGoToFirstFile (unzFile file)
1179{
1180 int err=UNZ_OK;
1181 unz64_s* s;
1182 if (file==NULL)
1183 return UNZ_PARAMERROR;
1184 s=(unz64_s*)file;
1185 s->pos_in_central_dir=s->offset_central_dir;
1186 s->num_file=0;
1187 err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1188 &s->cur_file_info_internal,
1189 NULL,0,NULL,0,NULL,0);
1190 s->current_file_ok = (err == UNZ_OK);
1191 return err;
1192}
1193
1194/*
1195 Set the current file of the zipfile to the next file.
1196 return UNZ_OK if there is no problem
1197 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
1198*/
1199 extern int ZEXPORT unzGoToNextFile (unzFile file)
1200{
1201 unz64_s* s;
1202 int err;
1203
1204 if (file==NULL)
1205 return UNZ_PARAMERROR;
1206 s=(unz64_s*)file;
1207 if (!s->current_file_ok)
1208 return UNZ_END_OF_LIST_OF_FILE;
1209 if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
1210 if (s->num_file+1==s->gi.number_entry)
1211 return UNZ_END_OF_LIST_OF_FILE;
1212
1213 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
1214 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
1215 s->num_file++;
1216 err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1217 &s->cur_file_info_internal,
1218 NULL,0,NULL,0,NULL,0);
1219 s->current_file_ok = (err == UNZ_OK);
1220 return err;
1221}
1222
1223
1224/*
1225 Try locate the file szFileName in the zipfile.
1226 For the iCaseSensitivity signification, see unzStringFileNameCompare
1227
1228 return value :
1229 UNZ_OK if the file is found. It becomes the current file.
1230 UNZ_END_OF_LIST_OF_FILE if the file is not found
1231*/
1232 extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
1233{
1234 unz64_s* s;
1235 int err;
1236
1237 /* We remember the 'current' position in the file so that we can jump
1238 * back there if we fail.
1239 */
1240 unz_file_info64 cur_file_infoSaved;
1241 unz_file_info64_internal cur_file_info_internalSaved;
1242 ZPOS64_T num_fileSaved;
1243 ZPOS64_T pos_in_central_dirSaved;
1244
1245
1246 if (file==NULL)
1247 return UNZ_PARAMERROR;
1248
1249 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
1250 return UNZ_PARAMERROR;
1251
1252 s=(unz64_s*)file;
1253 if (!s->current_file_ok)
1254 return UNZ_END_OF_LIST_OF_FILE;
1255
1256 /* Save the current state */
1257 num_fileSaved = s->num_file;
1258 pos_in_central_dirSaved = s->pos_in_central_dir;
1259 cur_file_infoSaved = s->cur_file_info;
1260 cur_file_info_internalSaved = s->cur_file_info_internal;
1261
1262 err = unzGoToFirstFile(file);
1263
1264 while (err == UNZ_OK)
1265 {
1266 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
1267 err = unzGetCurrentFileInfo64(file,NULL,
1268 szCurrentFileName,sizeof(szCurrentFileName)-1,
1269 NULL,0,NULL,0);
1270 if (err == UNZ_OK)
1271 {
1272 if (unzStringFileNameCompare(szCurrentFileName,
1273 szFileName,iCaseSensitivity)==0)
1274 return UNZ_OK;
1275 err = unzGoToNextFile(file);
1276 }
1277 }
1278
1279 /* We failed, so restore the state of the 'current file' to where we
1280 * were.
1281 */
1282 s->num_file = num_fileSaved ;
1283 s->pos_in_central_dir = pos_in_central_dirSaved ;
1284 s->cur_file_info = cur_file_infoSaved;
1285 s->cur_file_info_internal = cur_file_info_internalSaved;
1286 return err;
1287}
1288
1289
1290/*
1292// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
1293// I need random access
1294//
1295// Further optimization could be realized by adding an ability
1296// to cache the directory in memory. The goal being a single
1297// comprehensive file read to put the file I need in a memory.
1298*/
1299
1300/*
1301typedef struct unz_file_pos_s
1302{
1303 ZPOS64_T pos_in_zip_directory; // offset in file
1304 ZPOS64_T num_of_file; // # of file
1305} unz_file_pos;
1306*/
1307
1308 extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)
1309{
1310 unz64_s* s;
1311
1312 if (file==NULL || file_pos==NULL)
1313 return UNZ_PARAMERROR;
1314 s=(unz64_s*)file;
1315 if (!s->current_file_ok)
1316 return UNZ_END_OF_LIST_OF_FILE;
1317
1318 file_pos->pos_in_zip_directory = s->pos_in_central_dir;
1319 file_pos->num_of_file = s->num_file;
1320
1321 return UNZ_OK;
1322}
1323
1324 extern int ZEXPORT unzGetFilePos(
1325 unzFile file,
1326 unz_file_pos* file_pos)
1327{
1328 unz64_file_pos file_pos64;
1329 int err = unzGetFilePos64(file,&file_pos64);
1330 if (err==UNZ_OK)
1331 {
1332 file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
1333 file_pos->num_of_file = (uLong)file_pos64.num_of_file;
1334 }
1335 return err;
1336}
1337
1338 extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
1339{
1340 unz64_s* s;
1341 int err;
1342
1343 if (file==NULL || file_pos==NULL)
1344 return UNZ_PARAMERROR;
1345 s=(unz64_s*)file;
1346
1347 /* jump to the right spot */
1348 s->pos_in_central_dir = file_pos->pos_in_zip_directory;
1349 s->num_file = file_pos->num_of_file;
1350
1351 /* set the current file */
1352 err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1353 &s->cur_file_info_internal,
1354 NULL,0,NULL,0,NULL,0);
1355 /* return results */
1356 s->current_file_ok = (err == UNZ_OK);
1357 return err;
1358}
1359
1360 extern int ZEXPORT unzGoToFilePos(
1361 unzFile file,
1362 unz_file_pos* file_pos)
1363{
1364 unz64_file_pos file_pos64;
1365 if (file_pos == NULL)
1366 return UNZ_PARAMERROR;
1367
1368 file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
1369 file_pos64.num_of_file = file_pos->num_of_file;
1370 return unzGoToFilePos64(file,&file_pos64);
1371}
1372
1373/*
1374// Unzip Helper Functions - should be here?
1376*/
1377
1378/*
1379 Read the local header of the current zipfile
1380 Check the coherency of the local header and info in the end of central
1381 directory about this file
1382 store in *piSizeVar the size of extra info in local header
1383 (filename and size of extra field data)
1384*/
1385 local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
1386 ZPOS64_T * poffset_local_extrafield,
1387 uInt * psize_local_extrafield)
1388{
1389 uLong uMagic,uData,uFlags;
1390 uLong size_filename;
1391 uLong size_extra_field;
1392 int err=UNZ_OK;
1393
1394 *piSizeVar = 0;
1395 *poffset_local_extrafield = 0;
1396 *psize_local_extrafield = 0;
1397
1398 if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
1399 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
1400 return UNZ_ERRNO;
1401
1402
1403 if (err==UNZ_OK)
1404 {
1405 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
1406 err=UNZ_ERRNO;
1407 else if (uMagic!=0x04034b50)
1408 err=UNZ_BADZIPFILE;
1409 }
1410
1411 if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
1412 err=UNZ_ERRNO;
1413/*
1414 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1415 err=UNZ_BADZIPFILE;
1416*/
1417 if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
1418 err=UNZ_ERRNO;
1419
1420 if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
1421 err=UNZ_ERRNO;
1422 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
1423 err=UNZ_BADZIPFILE;
1424
1425 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1426/* #ifdef HAVE_BZIP2 */
1427 (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
1428/* #endif */
1429 (s->cur_file_info.compression_method!=Z_DEFLATED))
1430 err=UNZ_BADZIPFILE;
1431
1432 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
1433 err=UNZ_ERRNO;
1434
1435 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
1436 err=UNZ_ERRNO;
1437 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
1438 err=UNZ_BADZIPFILE;
1439
1440 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
1441 err=UNZ_ERRNO;
1442 else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
1443 err=UNZ_BADZIPFILE;
1444
1445 if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1446 err=UNZ_ERRNO;
1447 else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
1448 err=UNZ_BADZIPFILE;
1449
1450 if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1451 err=UNZ_ERRNO;
1452 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1453 err=UNZ_BADZIPFILE;
1454
1455 *piSizeVar += (uInt)size_filename;
1456
1457 if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1458 err=UNZ_ERRNO;
1459 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1460 SIZEZIPLOCALHEADER + size_filename;
1461 *psize_local_extrafield = (uInt)size_extra_field;
1462
1463 *piSizeVar += (uInt)size_extra_field;
1464
1465 return err;
1466}
1467
1468/*
1469 Open for reading data the current file in the zipfile.
1470 If there is no error and the file is opened, the return value is UNZ_OK.
1471*/
1472 extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
1473 int* level, int raw, const char* password)
1474{
1475 int err=UNZ_OK;
1476 uInt iSizeVar;
1477 unz64_s* s;
1478 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1479 ZPOS64_T offset_local_extrafield; /* offset of the local extra field */
1480 uInt size_local_extrafield; /* size of the local extra field */
1481# ifndef NOUNCRYPT
1482 char source[12];
1483# else
1484 if (password != NULL)
1485 return UNZ_PARAMERROR;
1486# endif
1487
1488 if (file==NULL)
1489 return UNZ_PARAMERROR;
1490 s=(unz64_s*)file;
1491 if (!s->current_file_ok)
1492 return UNZ_PARAMERROR;
1493
1494 if (s->pfile_in_zip_read != NULL)
1495 unzCloseCurrentFile(file);
1496
1497 if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1498 return UNZ_BADZIPFILE;
1499
1500 pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
1501 if (pfile_in_zip_read_info==NULL)
1502 return UNZ_INTERNALERROR;
1503
1504 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1505 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1506 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1507 pfile_in_zip_read_info->pos_local_extrafield=0;
1508 pfile_in_zip_read_info->raw=raw;
1509
1510 if (pfile_in_zip_read_info->read_buffer==NULL)
1511 {
1512 TRYFREE(pfile_in_zip_read_info);
1513 return UNZ_INTERNALERROR;
1514 }
1515
1516 pfile_in_zip_read_info->stream_initialised=0;
1517
1518 if (method!=NULL)
1519 *method = (int)s->cur_file_info.compression_method;
1520
1521 if (level!=NULL)
1522 {
1523 *level = 6;
1524 switch (s->cur_file_info.flag & 0x06)
1525 {
1526 case 6 : *level = 1; break;
1527 case 4 : *level = 2; break;
1528 case 2 : *level = 9; break;
1529 }
1530 }
1531
1532 if ((s->cur_file_info.compression_method!=0) &&
1533/* #ifdef HAVE_BZIP2 */
1534 (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
1535/* #endif */
1536 (s->cur_file_info.compression_method!=Z_DEFLATED))
1537
1538 err=UNZ_BADZIPFILE;
1539
1540 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1541 pfile_in_zip_read_info->crc32=0;
1542 pfile_in_zip_read_info->total_out_64=0;
1543 pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;
1544 pfile_in_zip_read_info->filestream=s->filestream;
1545 pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1546 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1547
1548 pfile_in_zip_read_info->stream.total_out = 0;
1549
1550 if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))
1551 {
1552#ifdef HAVE_BZIP2
1553 pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
1554 pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
1555 pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
1556 pfile_in_zip_read_info->bstream.state = (voidpf)0;
1557
1558 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1559 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1560 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1561 pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1562 pfile_in_zip_read_info->stream.avail_in = 0;
1563
1564 err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
1565 if (err == Z_OK)
1566 pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
1567 else
1568 {
1569 TRYFREE(pfile_in_zip_read_info->read_buffer);
1570 TRYFREE(pfile_in_zip_read_info);
1571 return err;
1572 }
1573#else
1574 pfile_in_zip_read_info->raw=1;
1575#endif
1576 }
1577 else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))
1578 {
1579 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1580 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1581 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1582 pfile_in_zip_read_info->stream.next_in = 0;
1583 pfile_in_zip_read_info->stream.avail_in = 0;
1584
1585 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1586 if (err == Z_OK)
1587 pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
1588 else
1589 {
1590 TRYFREE(pfile_in_zip_read_info->read_buffer);
1591 TRYFREE(pfile_in_zip_read_info);
1592 return err;
1593 }
1594 /* windowBits is passed < 0 to tell that there is no zlib header.
1595 * Note that in this case inflate *requires* an extra "dummy" byte
1596 * after the compressed stream in order to complete decompression and
1597 * return Z_STREAM_END.
1598 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1599 * size of both compressed and uncompressed data
1600 */
1601 }
1602 pfile_in_zip_read_info->rest_read_compressed =
1603 s->cur_file_info.compressed_size ;
1604 pfile_in_zip_read_info->rest_read_uncompressed =
1605 s->cur_file_info.uncompressed_size ;
1606
1607
1608 pfile_in_zip_read_info->pos_in_zipfile =
1609 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1610 iSizeVar;
1611
1612 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1613
1614 s->pfile_in_zip_read = pfile_in_zip_read_info;
1615 s->encrypted = 0;
1616
1617# ifndef NOUNCRYPT
1618 if (password != NULL)
1619 {
1620 int i;
1621 s->pcrc_32_tab = get_crc_table();
1622 init_keys(password,s->keys,s->pcrc_32_tab);
1623 if (ZSEEK64(s->z_filefunc, s->filestream,
1624 s->pfile_in_zip_read->pos_in_zipfile +
1625 s->pfile_in_zip_read->byte_before_the_zipfile,
1626 SEEK_SET)!=0)
1627 return UNZ_INTERNALERROR;
1628 if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
1629 return UNZ_INTERNALERROR;
1630
1631 for (i = 0; i<12; i++)
1632 zdecode(s->keys,s->pcrc_32_tab,source[i]);
1633
1634 s->pfile_in_zip_read->pos_in_zipfile+=12;
1635 s->encrypted=1;
1636 }
1637# endif
1638
1639
1640 return UNZ_OK;
1641}
1642
1643 extern int ZEXPORT unzOpenCurrentFile (unzFile file)
1644{
1645 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1646}
1647
1648 extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password)
1649{
1650 return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1651}
1652
1653 extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)
1654{
1655 return unzOpenCurrentFile3(file, method, level, raw, NULL);
1656}
1657
1660 extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)
1661{
1662 unz64_s* s;
1663 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1664 s=(unz64_s*)file;
1665 if (file==NULL)
1666 return 0; //UNZ_PARAMERROR;
1667 pfile_in_zip_read_info=s->pfile_in_zip_read;
1668 if (pfile_in_zip_read_info==NULL)
1669 return 0; //UNZ_PARAMERROR;
1670 return pfile_in_zip_read_info->pos_in_zipfile +
1671 pfile_in_zip_read_info->byte_before_the_zipfile;
1672}
1673
1676/*
1677 Read bytes from the current file.
1678 buf contain buffer where data must be copied
1679 len the size of buf.
1680
1681 return the number of byte copied if somes bytes are copied
1682 return 0 if the end of file was reached
1683 return <0 with error code if there is an error
1684 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1685*/
1686 extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)
1687{
1688 int err=UNZ_OK;
1689 uInt iRead = 0;
1690 unz64_s* s;
1691 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1692 if (file==NULL)
1693 return UNZ_PARAMERROR;
1694 s=(unz64_s*)file;
1695 pfile_in_zip_read_info=s->pfile_in_zip_read;
1696
1697 if (pfile_in_zip_read_info==NULL)
1698 return UNZ_PARAMERROR;
1699
1700
1701 if (pfile_in_zip_read_info->read_buffer == NULL)
1702 return UNZ_END_OF_LIST_OF_FILE;
1703 if (len==0)
1704 return 0;
1705
1706 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1707
1708 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1709
1710 if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
1711 (!(pfile_in_zip_read_info->raw)))
1712 pfile_in_zip_read_info->stream.avail_out =
1713 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1714
1715 if ((len>pfile_in_zip_read_info->rest_read_compressed+
1716 pfile_in_zip_read_info->stream.avail_in) &&
1717 (pfile_in_zip_read_info->raw))
1718 pfile_in_zip_read_info->stream.avail_out =
1719 (uInt)pfile_in_zip_read_info->rest_read_compressed+
1720 pfile_in_zip_read_info->stream.avail_in;
1721
1722 while (pfile_in_zip_read_info->stream.avail_out>0)
1723 {
1724 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1725 (pfile_in_zip_read_info->rest_read_compressed>0))
1726 {
1727 uInt uReadThis = UNZ_BUFSIZE;
1728 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1729 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1730 if (uReadThis == 0)
1731 return UNZ_EOF;
1732 if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
1733 pfile_in_zip_read_info->filestream,
1734 pfile_in_zip_read_info->pos_in_zipfile +
1735 pfile_in_zip_read_info->byte_before_the_zipfile,
1736 ZLIB_FILEFUNC_SEEK_SET)!=0)
1737 return UNZ_ERRNO;
1738 if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
1739 pfile_in_zip_read_info->filestream,
1740 pfile_in_zip_read_info->read_buffer,
1741 uReadThis)!=uReadThis)
1742 return UNZ_ERRNO;
1743
1744
1745# ifndef NOUNCRYPT
1746 if(s->encrypted)
1747 {
1748 uInt i;
1749 for(i=0;i<uReadThis;i++)
1750 pfile_in_zip_read_info->read_buffer[i] =
1751 zdecode(s->keys,s->pcrc_32_tab,
1752 pfile_in_zip_read_info->read_buffer[i]);
1753 }
1754# endif
1755
1756
1757 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1758
1759 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1760
1761 pfile_in_zip_read_info->stream.next_in =
1762 (Bytef*)pfile_in_zip_read_info->read_buffer;
1763 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1764 }
1765
1766 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1767 {
1768 uInt uDoCopy,i ;
1769
1770 if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1771 (pfile_in_zip_read_info->rest_read_compressed == 0))
1772 return (iRead==0) ? UNZ_EOF : (int)iRead;
1773
1774 if (pfile_in_zip_read_info->stream.avail_out <
1775 pfile_in_zip_read_info->stream.avail_in)
1776 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1777 else
1778 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1779
1780 for (i=0;i<uDoCopy;i++)
1781 *(pfile_in_zip_read_info->stream.next_out+i) =
1782 *(pfile_in_zip_read_info->stream.next_in+i);
1783
1784 pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
1785
1786 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1787 pfile_in_zip_read_info->stream.next_out,
1788 uDoCopy);
1789 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1790 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1791 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1792 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1793 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1794 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1795 iRead += uDoCopy;
1796 }
1797 else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)
1798 {
1799#ifdef HAVE_BZIP2
1800 uLong uTotalOutBefore,uTotalOutAfter;
1801 const Bytef *bufBefore;
1802 uLong uOutThis;
1803
1804 pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in;
1805 pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in;
1806 pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in;
1807 pfile_in_zip_read_info->bstream.total_in_hi32 = 0;
1808 pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out;
1809 pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out;
1810 pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
1811 pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
1812
1813 uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
1814 bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
1815
1816 err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
1817
1818 uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
1819 uOutThis = uTotalOutAfter-uTotalOutBefore;
1820
1821 pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
1822
1823 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
1824 pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
1825 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1826
1827 pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
1828 pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in;
1829 pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32;
1830 pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
1831 pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
1832 pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
1833
1834 if (err==BZ_STREAM_END)
1835 return (iRead==0) ? UNZ_EOF : iRead;
1836 if (err!=BZ_OK)
1837 break;
1838#endif
1839 } // end Z_BZIP2ED
1840 else
1841 {
1842 ZPOS64_T uTotalOutBefore,uTotalOutAfter;
1843 const Bytef *bufBefore;
1844 ZPOS64_T uOutThis;
1845 int flush=Z_SYNC_FLUSH;
1846
1847 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1848 bufBefore = pfile_in_zip_read_info->stream.next_out;
1849
1850 /*
1851 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1852 pfile_in_zip_read_info->stream.avail_out) &&
1853 (pfile_in_zip_read_info->rest_read_compressed == 0))
1854 flush = Z_FINISH;
1855 */
1856 err=inflate(&pfile_in_zip_read_info->stream,flush);
1857
1858 if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
1859 err = Z_DATA_ERROR;
1860
1861 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1862 /* Detect overflow, because z_stream.total_out is uLong (32 bits) */
1863 if (uTotalOutAfter<uTotalOutBefore)
1864 uTotalOutAfter += 1LL << 32; /* Add maximum value of uLong + 1 */
1865 uOutThis = uTotalOutAfter-uTotalOutBefore;
1866
1867 pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
1868
1869 pfile_in_zip_read_info->crc32 =
1870 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1871 (uInt)(uOutThis));
1872
1873 pfile_in_zip_read_info->rest_read_uncompressed -=
1874 uOutThis;
1875
1876 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1877
1878 if (err==Z_STREAM_END)
1879 return (iRead==0) ? UNZ_EOF : (int)iRead;
1880 if (err!=Z_OK)
1881 break;
1882 }
1883 }
1884
1885 if (err==Z_OK)
1886 return (int)iRead;
1887 return err;
1888}
1889
1890
1891/*
1892 Give the current position in uncompressed data
1893*/
1894 extern z_off_t ZEXPORT unztell (unzFile file)
1895{
1896 unz64_s* s;
1897 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1898 if (file==NULL)
1899 return UNZ_PARAMERROR;
1900 s=(unz64_s*)file;
1901 pfile_in_zip_read_info=s->pfile_in_zip_read;
1902
1903 if (pfile_in_zip_read_info==NULL)
1904 return UNZ_PARAMERROR;
1905
1906 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1907}
1908
1909 extern ZPOS64_T ZEXPORT unztell64 (unzFile file)
1910{
1911
1912 unz64_s* s;
1913 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1914 if (file==NULL)
1915 return (ZPOS64_T)-1;
1916 s=(unz64_s*)file;
1917 pfile_in_zip_read_info=s->pfile_in_zip_read;
1918
1919 if (pfile_in_zip_read_info==NULL)
1920 return (ZPOS64_T)-1;
1921
1922 return pfile_in_zip_read_info->total_out_64;
1923}
1924
1925
1926/*
1927 return 1 if the end of file was reached, 0 elsewhere
1928*/
1929 extern int ZEXPORT unzeof (unzFile file)
1930{
1931 unz64_s* s;
1932 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1933 if (file==NULL)
1934 return UNZ_PARAMERROR;
1935 s=(unz64_s*)file;
1936 pfile_in_zip_read_info=s->pfile_in_zip_read;
1937
1938 if (pfile_in_zip_read_info==NULL)
1939 return UNZ_PARAMERROR;
1940
1941 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1942 return 1;
1943 else
1944 return 0;
1945}
1946
1947
1948
1949/*
1950Read extra field from the current file (opened by unzOpenCurrentFile)
1951This is the local-header version of the extra field (sometimes, there is
1952more info in the local-header version than in the central-header)
1953
1954 if buf==NULL, it return the size of the local extra field that can be read
1955
1956 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1957 buf.
1958 the return value is the number of bytes copied in buf, or (if <0)
1959 the error code
1960*/
1961 extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)
1962{
1963 unz64_s* s;
1964 file_in_zip64_read_info_s* pfile_in_zip_read_info;
1965 uInt read_now;
1966 ZPOS64_T size_to_read;
1967
1968 if (file==NULL)
1969 return UNZ_PARAMERROR;
1970 s=(unz64_s*)file;
1971 pfile_in_zip_read_info=s->pfile_in_zip_read;
1972
1973 if (pfile_in_zip_read_info==NULL)
1974 return UNZ_PARAMERROR;
1975
1976 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1977 pfile_in_zip_read_info->pos_local_extrafield);
1978
1979 if (buf==NULL)
1980 return (int)size_to_read;
1981
1982 if (len>size_to_read)
1983 read_now = (uInt)size_to_read;
1984 else
1985 read_now = (uInt)len ;
1986
1987 if (read_now==0)
1988 return 0;
1989
1990 if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
1991 pfile_in_zip_read_info->filestream,
1992 pfile_in_zip_read_info->offset_local_extrafield +
1993 pfile_in_zip_read_info->pos_local_extrafield,
1994 ZLIB_FILEFUNC_SEEK_SET)!=0)
1995 return UNZ_ERRNO;
1996
1997 if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
1998 pfile_in_zip_read_info->filestream,
1999 buf,read_now)!=read_now)
2000 return UNZ_ERRNO;
2001
2002 return (int)read_now;
2003}
2004
2005/*
2006 Close the file in zip opened with unzOpenCurrentFile
2007 Return UNZ_CRCERROR if all the file was read but the CRC is not good
2008*/
2009 extern int ZEXPORT unzCloseCurrentFile (unzFile file)
2010{
2011 int err=UNZ_OK;
2012
2013 unz64_s* s;
2014 file_in_zip64_read_info_s* pfile_in_zip_read_info;
2015 if (file==NULL)
2016 return UNZ_PARAMERROR;
2017 s=(unz64_s*)file;
2018 pfile_in_zip_read_info=s->pfile_in_zip_read;
2019
2020 if (pfile_in_zip_read_info==NULL)
2021 return UNZ_PARAMERROR;
2022
2023
2024 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
2025 (!pfile_in_zip_read_info->raw))
2026 {
2027 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
2028 err=UNZ_CRCERROR;
2029 }
2030
2031
2032 TRYFREE(pfile_in_zip_read_info->read_buffer);
2033 pfile_in_zip_read_info->read_buffer = NULL;
2034 if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
2035 inflateEnd(&pfile_in_zip_read_info->stream);
2036#ifdef HAVE_BZIP2
2037 else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
2038 BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
2039#endif
2040
2041
2042 pfile_in_zip_read_info->stream_initialised = 0;
2043 TRYFREE(pfile_in_zip_read_info);
2044
2045 s->pfile_in_zip_read=NULL;
2046
2047 return err;
2048}
2049
2050
2051/*
2052 Get the global comment string of the ZipFile, in the szComment buffer.
2053 uSizeBuf is the size of the szComment buffer.
2054 return the number of byte copied or an error code <0
2055*/
2056 extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)
2057{
2058 unz64_s* s;
2059 uLong uReadThis ;
2060 if (file==NULL)
2061 return (int)UNZ_PARAMERROR;
2062 s=(unz64_s*)file;
2063
2064 uReadThis = uSizeBuf;
2065 if (uReadThis>s->gi.size_comment)
2066 uReadThis = s->gi.size_comment;
2067
2068 if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
2069 return UNZ_ERRNO;
2070
2071 if (uReadThis>0)
2072 {
2073 *szComment='\0';
2074 if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
2075 return UNZ_ERRNO;
2076 }
2077
2078 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
2079 *(szComment+s->gi.size_comment)='\0';
2080 return (int)uReadThis;
2081}
2082
2083/* Additions by RX '2004 */
2084 extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
2085{
2086 unz64_s* s;
2087
2088 if (file==NULL)
2089 return 0; //UNZ_PARAMERROR;
2090 s=(unz64_s*)file;
2091 if (!s->current_file_ok)
2092 return 0;
2093 if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
2094 if (s->num_file==s->gi.number_entry)
2095 return 0;
2096 return s->pos_in_central_dir;
2097}
2098
2099 extern uLong ZEXPORT unzGetOffset (unzFile file)
2100{
2101 ZPOS64_T offset64;
2102
2103 if (file==NULL)
2104 return 0; //UNZ_PARAMERROR;
2105 offset64 = unzGetOffset64(file);
2106 return (uLong)offset64;
2107}
2108
2109 extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
2110{
2111 unz64_s* s;
2112 int err;
2113
2114 if (file==NULL)
2115 return UNZ_PARAMERROR;
2116 s=(unz64_s*)file;
2117
2118 s->pos_in_central_dir = pos;
2119 s->num_file = s->gi.number_entry; /* hack */
2120 err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
2121 &s->cur_file_info_internal,
2122 NULL,0,NULL,0,NULL,0);
2123 s->current_file_ok = (err == UNZ_OK);
2124 return err;
2125}
2126
2127 extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)
2128{
2129 return unzSetOffset64(file,pos);
2130}
get_crc_table
const z_crc_t FAR *ZEXPORT get_crc_table()
Definition: crc32.c:595
crc32
unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, uInt len)
Definition: crc32.c:1072
len
uint8_t len
Definition: escape.c:17
zdecode
#define zdecode(pkeys, pcrc_32_tab, c)
Definition: crypt.h:77
inflate
int ZEXPORT inflate(z_streamp strm, int flush)
Definition: inflate.c:625
inflateEnd
int ZEXPORT inflateEnd(z_streamp strm)
Definition: inflate.c:1304
fill_zlib_filefunc64_32_def_from_filefunc32
void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32)
Definition: ioapi.c:69
fill_fopen64_filefunc
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)
Definition: ioapi.c:247
ZERROR64
#define ZERROR64(filefunc, filestream)
Definition: ioapi.h:194
ZPOS64_T
unsigned __int64 ZPOS64_T
Definition: ioapi.h:97
ZLIB_FILEFUNC_MODE_EXISTING
#define ZLIB_FILEFUNC_MODE_EXISTING
Definition: ioapi.h:122
ZOPEN64
#define ZOPEN64(filefunc, filename, mode)
Definition: ioapi.h:202
ZLIB_FILEFUNC_SEEK_CUR
#define ZLIB_FILEFUNC_SEEK_CUR
Definition: ioapi.h:114
int
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
buf
voidpf void * buf
Definition: ioapi.h:138
ZSEEK64
#define ZSEEK64(filefunc, filestream, pos, mode)
Definition: ioapi.h:204
ZLIB_FILEFUNC_SEEK_SET
#define ZLIB_FILEFUNC_SEEK_SET
Definition: ioapi.h:116
MAXU32
#define MAXU32
Definition: ioapi.h:106
ZREAD64
#define ZREAD64(filefunc, filestream, buf, size)
Definition: ioapi.h:189
ZCLOSE64
#define ZCLOSE64(filefunc, filestream)
Definition: ioapi.h:193
ZTELL64
#define ZTELL64(filefunc, filestream)
Definition: ioapi.h:203
ZLIB_FILEFUNC_SEEK_END
#define ZLIB_FILEFUNC_SEEK_END
Definition: ioapi.h:115
ZLIB_FILEFUNC_MODE_READ
#define ZLIB_FILEFUNC_MODE_READ
Definition: ioapi.h:118
NULL
#define NULL
Definition: regenc.h:69
strlen
size_t strlen(const char *)
file_in_zip64_read_info_s
Definition: unzip.c:135
file_in_zip64_read_info_s::stream
z_stream stream
Definition: unzip.c:137
file_in_zip64_read_info_s::total_out_64
ZPOS64_T total_out_64
Definition: unzip.c:149
file_in_zip64_read_info_s::byte_before_the_zipfile
ZPOS64_T byte_before_the_zipfile
Definition: unzip.c:158
file_in_zip64_read_info_s::raw
int raw
Definition: unzip.c:159
file_in_zip64_read_info_s::rest_read_uncompressed
ZPOS64_T rest_read_uncompressed
Definition: unzip.c:154
file_in_zip64_read_info_s::read_buffer
char * read_buffer
Definition: unzip.c:136
file_in_zip64_read_info_s::offset_local_extrafield
ZPOS64_T offset_local_extrafield
Definition: unzip.c:146
file_in_zip64_read_info_s::pos_in_zipfile
ZPOS64_T pos_in_zipfile
Definition: unzip.c:143
file_in_zip64_read_info_s::rest_read_compressed
ZPOS64_T rest_read_compressed
Definition: unzip.c:153
file_in_zip64_read_info_s::compression_method
uLong compression_method
Definition: unzip.c:157
file_in_zip64_read_info_s::z_filefunc
zlib_filefunc64_32_def z_filefunc
Definition: unzip.c:155
file_in_zip64_read_info_s::crc32_wait
uLong crc32_wait
Definition: unzip.c:152
file_in_zip64_read_info_s::size_local_extrafield
uInt size_local_extrafield
Definition: unzip.c:147
file_in_zip64_read_info_s::crc32
uLong crc32
Definition: unzip.c:151
file_in_zip64_read_info_s::filestream
voidpf filestream
Definition: unzip.c:156
file_in_zip64_read_info_s::stream_initialised
uLong stream_initialised
Definition: unzip.c:144
file_in_zip64_read_info_s::pos_local_extrafield
ZPOS64_T pos_local_extrafield
Definition: unzip.c:148
file
Definition: gzappend.c:170
tm_unz_s
Definition: unzip.h:85
tm_unz_s::tm_mday
int tm_mday
Definition: unzip.h:89
tm_unz_s::tm_mon
int tm_mon
Definition: unzip.h:90
tm_unz_s::tm_hour
int tm_hour
Definition: unzip.h:88
tm_unz_s::tm_year
int tm_year
Definition: unzip.h:91
tm_unz_s::tm_sec
int tm_sec
Definition: unzip.h:86
tm_unz_s::tm_min
int tm_min
Definition: unzip.h:87
unz64_file_pos_s
Definition: unzip.h:273
unz64_file_pos_s::num_of_file
ZPOS64_T num_of_file
Definition: unzip.h:275
unz64_file_pos_s::pos_in_zip_directory
ZPOS64_T pos_in_zip_directory
Definition: unzip.h:274
unz64_s
Definition: unzip.c:166
unz64_s::z_filefunc
zlib_filefunc64_32_def z_filefunc
Definition: unzip.c:167
unz64_s::cur_file_info
unz_file_info64 cur_file_info
Definition: unzip.c:181
unz64_s::pos_in_central_dir
ZPOS64_T pos_in_central_dir
Definition: unzip.c:173
unz64_s::current_file_ok
ZPOS64_T current_file_ok
Definition: unzip.c:174
unz64_s::is64bitOpenFunction
int is64bitOpenFunction
Definition: unzip.c:168
unz64_s::gi
unz_global_info64 gi
Definition: unzip.c:170
unz64_s::central_pos
ZPOS64_T central_pos
Definition: unzip.c:175
unz64_s::cur_file_info_internal
unz_file_info64_internal cur_file_info_internal
Definition: unzip.c:182
unz64_s::num_file
ZPOS64_T num_file
Definition: unzip.c:172
unz64_s::pfile_in_zip_read
file_in_zip64_read_info_s * pfile_in_zip_read
Definition: unzip.c:183
unz64_s::offset_central_dir
ZPOS64_T offset_central_dir
Definition: unzip.c:178
unz64_s::size_central_dir
ZPOS64_T size_central_dir
Definition: unzip.c:177
unz64_s::encrypted
int encrypted
Definition: unzip.c:185
unz64_s::filestream
voidpf filestream
Definition: unzip.c:169
unz64_s::byte_before_the_zipfile
ZPOS64_T byte_before_the_zipfile
Definition: unzip.c:171
unz64_s::isZip64
int isZip64
Definition: unzip.c:187
unz_file_info64_internal_s
Definition: unzip.c:127
unz_file_info64_internal_s::offset_curfile
ZPOS64_T offset_curfile
Definition: unzip.c:128
unz_file_info64_s
Definition: unzip.h:112
unz_file_info64_s::size_file_extra
uLong size_file_extra
Definition: unzip.h:122
unz_file_info64_s::crc
uLong crc
Definition: unzip.h:118
unz_file_info64_s::internal_fa
uLong internal_fa
Definition: unzip.h:126
unz_file_info64_s::version
uLong version
Definition: unzip.h:113
unz_file_info64_s::uncompressed_size
ZPOS64_T uncompressed_size
Definition: unzip.h:120
unz_file_info64_s::flag
uLong flag
Definition: unzip.h:115
unz_file_info64_s::dosDate
uLong dosDate
Definition: unzip.h:117
unz_file_info64_s::tmu_date
tm_unz tmu_date
Definition: unzip.h:129
unz_file_info64_s::size_filename
uLong size_filename
Definition: unzip.h:121
unz_file_info64_s::compression_method
uLong compression_method
Definition: unzip.h:116
unz_file_info64_s::external_fa
uLong external_fa
Definition: unzip.h:127
unz_file_info64_s::version_needed
uLong version_needed
Definition: unzip.h:114
unz_file_info64_s::disk_num_start
uLong disk_num_start
Definition: unzip.h:125
unz_file_info64_s::compressed_size
ZPOS64_T compressed_size
Definition: unzip.h:119
unz_file_info64_s::size_file_comment
uLong size_file_comment
Definition: unzip.h:123
unz_file_info_s
Definition: unzip.h:133
unz_file_info_s::dosDate
uLong dosDate
Definition: unzip.h:138
unz_file_info_s::version_needed
uLong version_needed
Definition: unzip.h:135
unz_file_info_s::compressed_size
uLong compressed_size
Definition: unzip.h:140
unz_file_info_s::size_file_extra
uLong size_file_extra
Definition: unzip.h:143
unz_file_info_s::version
uLong version
Definition: unzip.h:134
unz_file_info_s::crc
uLong crc
Definition: unzip.h:139
unz_file_info_s::uncompressed_size
uLong uncompressed_size
Definition: unzip.h:141
unz_file_info_s::internal_fa
uLong internal_fa
Definition: unzip.h:147
unz_file_info_s::compression_method
uLong compression_method
Definition: unzip.h:137
unz_file_info_s::disk_num_start
uLong disk_num_start
Definition: unzip.h:146
unz_file_info_s::tmu_date
tm_unz tmu_date
Definition: unzip.h:150
unz_file_info_s::flag
uLong flag
Definition: unzip.h:136
unz_file_info_s::external_fa
uLong external_fa
Definition: unzip.h:148
unz_file_info_s::size_filename
uLong size_filename
Definition: unzip.h:142
unz_file_info_s::size_file_comment
uLong size_file_comment
Definition: unzip.h:144
unz_file_pos_s
Definition: unzip.h:259
unz_file_pos_s::num_of_file
uLong num_of_file
Definition: unzip.h:261
unz_file_pos_s::pos_in_zip_directory
uLong pos_in_zip_directory
Definition: unzip.h:260
unz_global_info64_s
Definition: unzip.h:97
unz_global_info64_s::number_entry
ZPOS64_T number_entry
Definition: unzip.h:98
unz_global_info64_s::size_comment
uLong size_comment
Definition: unzip.h:100
unz_global_info_s
Definition: unzip.h:104
unz_global_info_s::size_comment
uLong size_comment
Definition: unzip.h:107
unz_global_info_s::number_entry
uLong number_entry
Definition: unzip.h:105
z_stream_s
Definition: zlib.h:86
z_stream_s::avail_in
uInt avail_in
Definition: zlib.h:88
z_stream_s::zalloc
alloc_func zalloc
Definition: zlib.h:98
z_stream_s::avail_out
uInt avail_out
Definition: zlib.h:92
z_stream_s::next_in
z_const Bytef * next_in
Definition: zlib.h:87
z_stream_s::zfree
free_func zfree
Definition: zlib.h:99
z_stream_s::total_in
uLong total_in
Definition: zlib.h:89
z_stream_s::opaque
voidpf opaque
Definition: zlib.h:100
z_stream_s::total_out
uLong total_out
Definition: zlib.h:93
z_stream_s::next_out
Bytef * next_out
Definition: zlib.h:91
z_stream_s::msg
z_const char * msg
Definition: zlib.h:95
zlib_filefunc64_32_def_s
Definition: ioapi.h:181
zlib_filefunc64_32_def_s::zseek32_file
seek_file_func zseek32_file
Definition: ioapi.h:185
zlib_filefunc64_32_def_s::zfile_func64
zlib_filefunc64_def zfile_func64
Definition: ioapi.h:182
zlib_filefunc64_32_def_s::ztell32_file
tell_file_func ztell32_file
Definition: ioapi.h:184
zlib_filefunc64_def_s
Definition: ioapi.h:165
zlib_filefunc_def_s
Definition: ioapi.h:149
unzGetLocalExtrafield
int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, unsigned len)
Definition: unzip.c:1961
local
#define local
Definition: unzip.c:91
unzOpenCurrentFilePassword
int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password)
Definition: unzip.c:1648
BUFREADCOMMENT
#define BUFREADCOMMENT
Definition: unzip.c:405
unzSetOffset
int ZEXPORT unzSetOffset(unzFile file, uLong pos)
Definition: unzip.c:2127
unztell
z_off_t ZEXPORT unztell(unzFile file)
Definition: unzip.c:1894
unzGetOffset
uLong ZEXPORT unzGetOffset(unzFile file)
Definition: unzip.c:2099
CASESENSITIVITYDEFAULTVALUE
#define CASESENSITIVITYDEFAULTVALUE
Definition: unzip.c:372
unzLocateFile
int ZEXPORT unzLocateFile(unzFile file, const char *szFileName, int iCaseSensitivity)
Definition: unzip.c:1232
unzGetFilePos
int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos)
Definition: unzip.c:1324
STRCMPCASENOSENTIVEFUNCTION
#define STRCMPCASENOSENTIVEFUNCTION
Definition: unzip.c:378
unzStringFileNameCompare
int ZEXPORT unzStringFileNameCompare(const char *fileName1, const char *fileName2, int iCaseSensitivity)
Definition: unzip.c:390
unztell64
ZPOS64_T ZEXPORT unztell64(unzFile file)
Definition: unzip.c:1909
unz64local_getByte
int unz64local_getByte(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, int *pi)
Definition: unzip.c:212
unzOpen2_64
unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def)
Definition: unzip.c:778
SIZEZIPLOCALHEADER
#define SIZEZIPLOCALHEADER
Definition: unzip.c:119
unzGetFilePos64
int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos)
Definition: unzip.c:1308
unz64local_DosDateToTmuDate
void unz64local_DosDateToTmuDate(ZPOS64_T ulDosDate, tm_unz *ptm)
Definition: unzip.c:852
unzOpen
unzFile ZEXPORT unzOpen(const char *path)
Definition: unzip.c:793
unz64local_SearchCentralDir
ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream)
Definition: unzip.c:413
unzGetCurrentFileInfo64
int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *szFileName, uLong fileNameBufferSize, void *extraField, uLong extraFieldBufferSize, char *szComment, uLong commentBufferSize)
Definition: unzip.c:1124
unzGoToFirstFile
int ZEXPORT unzGoToFirstFile(unzFile file)
Definition: unzip.c:1178
unzeof
int ZEXPORT unzeof(unzFile file)
Definition: unzip.c:1929
unz64local_SearchCentralDir64
ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream)
Definition: unzip.c:478
unzOpenCurrentFile2
int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw)
Definition: unzip.c:1653
unzOpenCurrentFile3
int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password)
Definition: unzip.c:1472
TRYFREE
#define TRYFREE(p)
Definition: unzip.c:115
unzGetOffset64
ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
Definition: unzip.c:2084
unzOpenCurrentFile
int ZEXPORT unzOpenCurrentFile(unzFile file)
Definition: unzip.c:1643
unzGoToFilePos64
int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos)
Definition: unzip.c:1338
unzGoToFilePos
int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos)
Definition: unzip.c:1360
unzReadCurrentFile
int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, unsigned len)
Addition for GDAL : END.
Definition: unzip.c:1686
unzGetGlobalInfo64
int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
Definition: unzip.c:828
unz64local_CheckCurrentFileCoherencyHeader
int unz64local_CheckCurrentFileCoherencyHeader(unz64_s *s, uInt *piSizeVar, ZPOS64_T *poffset_local_extrafield, uInt *psize_local_extrafield)
Definition: unzip.c:1385
unz64local_getLong64
int unz64local_getLong64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
Definition: unzip.c:302
unzOpen2
unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc32_def)
Definition: unzip.c:765
unz64local_getLong
int unz64local_getLong(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uLong *pX)
Definition: unzip.c:266
UNZ_MAXFILENAMEINZIP
#define UNZ_MAXFILENAMEINZIP
Definition: unzip.c:108
unzSetOffset64
int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
Definition: unzip.c:2109
unzGetGlobalInfo
int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info32)
Definition: unzip.c:838
unzGetCurrentFileZStreamPos64
ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64(unzFile file)
Addition for GDAL : START.
Definition: unzip.c:1660
unzOpen64
unzFile ZEXPORT unzOpen64(const void *path)
Definition: unzip.c:798
unz64local_getShort
int unz64local_getShort(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uLong *pX)
Definition: unzip.c:239
unz64local_GetCurrentFileInfoInternal
int unz64local_GetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info, unz_file_info64_internal *pfile_info_internal, char *szFileName, uLong fileNameBufferSize, void *extraField, uLong extraFieldBufferSize, char *szComment, uLong commentBufferSize)
Definition: unzip.c:879
unzCloseCurrentFile
int ZEXPORT unzCloseCurrentFile(unzFile file)
Definition: unzip.c:2009
ALLOC
#define ALLOC(size)
Definition: unzip.c:112
UNZ_BUFSIZE
#define UNZ_BUFSIZE
Definition: unzip.c:104
unzGetCurrentFileInfo
int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *szFileName, uLong fileNameBufferSize, void *extraField, uLong extraFieldBufferSize, char *szComment, uLong commentBufferSize)
Definition: unzip.c:1136
unzGoToNextFile
int ZEXPORT unzGoToNextFile(unzFile file)
Definition: unzip.c:1199
SIZECENTRALDIRITEM
#define SIZECENTRALDIRITEM
Definition: unzip.c:118
unzGetGlobalComment
int ZEXPORT unzGetGlobalComment(unzFile file, char *szComment, uLong uSizeBuf)
Definition: unzip.c:2056
strcmpcasenosensitive_internal
int strcmpcasenosensitive_internal(const char *fileName1, const char *fileName2)
Definition: unzip.c:349
unz_copyright
const char unz_copyright[]
Definition: unzip.c:122
unzOpenInternal
unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def *pzlib_filefunc64_32_def, int is64bitOpenFunction)
Definition: unzip.c:584
unz_file_info64_internal
struct unz_file_info64_internal_s unz_file_info64_internal
unzClose
int ZEXPORT unzClose(unzFile file)
Definition: unzip.c:808
unzip.h
UNZ_EOF
#define UNZ_EOF
Definition: unzip.h:77
UNZ_BADZIPFILE
#define UNZ_BADZIPFILE
Definition: unzip.h:79
UNZ_INTERNALERROR
#define UNZ_INTERNALERROR
Definition: unzip.h:80
UNZ_ERRNO
#define UNZ_ERRNO
Definition: unzip.h:76
UNZ_END_OF_LIST_OF_FILE
#define UNZ_END_OF_LIST_OF_FILE
Definition: unzip.h:75
UNZ_PARAMERROR
#define UNZ_PARAMERROR
Definition: unzip.h:78
unzFile
voidp unzFile
Definition: unzip.h:70
UNZ_OK
#define UNZ_OK
Definition: unzip.h:74
Z_BZIP2ED
#define Z_BZIP2ED
Definition: unzip.h:62
UNZ_CRCERROR
#define UNZ_CRCERROR
Definition: unzip.h:81
err
int err
Definition: win32.c:142
if
if((ID)(DISPID) nameid !=nameid)
Definition: win32ole.c:357
uLong
unsigned long uLong
Definition: zconf.h:400
ZEXPORT
#define ZEXPORT
Definition: zconf.h:386
z_crc_t
unsigned long z_crc_t
Definition: zconf.h:437
voidpf
void FAR * voidpf
Definition: zconf.h:415
uInt
unsigned int uInt
Definition: zconf.h:399
z_off_t
#define z_off_t
Definition: zconf.h:517
OF
#define OF(args)
Definition: zconf.h:293
MAX_WBITS
#define MAX_WBITS
Definition: zconf.h:273
Bytef
Byte FAR Bytef
Definition: zconf.h:406
voidp
void * voidp
Definition: zconf.h:416
SEEK_SET
#define SEEK_SET
Definition: zip.c:88
zlib.h
Z_DEFLATED
#define Z_DEFLATED
Definition: zlib.h:209
inflateInit2
#define inflateInit2(strm, windowBits)
Definition: zlib.h:1817
Z_STREAM_END
#define Z_STREAM_END
Definition: zlib.h:178
Z_OK
#define Z_OK
Definition: zlib.h:177
Z_DATA_ERROR
#define Z_DATA_ERROR
Definition: zlib.h:182
Z_SYNC_FLUSH
#define Z_SYNC_FLUSH
Definition: zlib.h:170