spu: don't leave garbage in capture buffers
[pcsx_rearmed.git] / deps / libchdr / deps / zlib-1.2.13 / contrib / minizip / unzip.c
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 /*
1291 ///////////////////////////////////////////
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 /*
1301 typedef 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?
1375 ///////////////////////////////////////////
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
1658 /** Addition for GDAL : START */
1659
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
1674 /** Addition for GDAL : END */
1675
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 /*
1950 Read extra field from the current file (opened by unzOpenCurrentFile)
1951 This is the local-header version of the extra field (sometimes, there is
1952 more 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 }