support/minizip/unzip.c

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