MythTV: unzip.c Source File

00001 /* unzip.c -- IO on .zip files using zlib 
00002    Version 0.15 beta, Mar 19th, 1998,
00003 
00004    Read unzip.h for more info
00005 */
00006 
00007 
00008 #include <stdio.h>
00009 #include <stdlib.h>
00010 #include <string.h>
00011 #include "zlib.h"
00012 #include "unzip.h"
00013 
00014 #ifdef STDC
00015 #  include <stddef.h>
00016 #  include <string.h>
00017 #  include <stdlib.h>
00018 #endif
00019 #ifdef NO_ERRNO_H
00020     extern int errno;
00021 #else
00022 #   include <errno.h>
00023 #endif
00024 
00025 
00026 #ifndef local
00027 #  define local static
00028 #endif
00029 /* compile with -Dlocal if your debugger can't find static symbols */
00030 
00031 
00032 
00033 #if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
00034                       !defined(CASESENSITIVITYDEFAULT_NO)
00035 #define CASESENSITIVITYDEFAULT_NO
00036 #endif
00037 
00038 
00039 #ifndef UNZ_BUFSIZE
00040 #define UNZ_BUFSIZE (16384)
00041 #endif
00042 
00043 #ifndef UNZ_MAXFILENAMEINZIP
00044 #define UNZ_MAXFILENAMEINZIP (256)
00045 #endif
00046 
00047 #ifndef ALLOC
00048 # define ALLOC(size) (malloc(size))
00049 #endif
00050 #ifndef TRYFREE
00051 # define TRYFREE(p) {if (p) free(p);}
00052 #endif
00053 
00054 #define SIZECENTRALDIRITEM (0x2e)
00055 #define SIZEZIPLOCALHEADER (0x1e)
00056 
00057 
00058 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
00059 
00060 #ifndef SEEK_CUR
00061 #define SEEK_CUR    1
00062 #endif
00063 
00064 #ifndef SEEK_END
00065 #define SEEK_END    2
00066 #endif
00067 
00068 #ifndef SEEK_SET
00069 #define SEEK_SET    0
00070 #endif
00071 
00072 const char unz_copyright[] =
00073    " unzip 0.15 Copyright 1998 Gilles Vollant ";
00074 
00075 /* unz_file_info_interntal contain internal info about a file in zipfile*/
00076 typedef struct unz_file_info_internal_s
00077 {
00078     uLong offset_curfile;/* relative offset of local header 4 bytes */
00079 } unz_file_info_internal;
00080 
00081 
00082 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
00083     when reading and decompress it */
00084 typedef struct
00085 {
00086         char  *read_buffer;         /* internal buffer for compressed data */
00087         z_stream stream;            /* zLib stream structure for inflate */
00088 
00089         uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
00090         uLong stream_initialised;   /* flag set if stream structure is initialised*/
00091 
00092         uLong offset_local_extrafield;/* offset of the local extra field */
00093         uInt  size_local_extrafield;/* size of the local extra field */
00094         uLong pos_local_extrafield;   /* position in the local extra field in read*/
00095 
00096         uLong crc32;                /* crc32 of all data uncompressed */
00097         uLong crc32_wait;           /* crc32 we must obtain after decompress all */
00098         uLong rest_read_compressed; /* number of byte to be decompressed */
00099         uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
00100         FILE* file;                 /* io structore of the zipfile */
00101         uLong compression_method;   /* compression method (0==store) */
00102         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
00103 } file_in_zip_read_info_s;
00104 
00105 
00106 /* unz_s contain internal information about the zipfile
00107 */
00108 typedef struct
00109 {
00110         FILE* file;                 /* io structore of the zipfile */
00111         unz_global_info gi;       /* public global information */
00112         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
00113         uLong num_file;             /* number of the current file in the zipfile*/
00114         uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
00115         uLong current_file_ok;      /* flag about the usability of the current file*/
00116         uLong central_pos;          /* position of the beginning of the central dir*/
00117 
00118         uLong size_central_dir;     /* size of the central directory  */
00119         uLong offset_central_dir;   /* offset of start of central directory with
00120                                                                    respect to the starting disk number */
00121 
00122         unz_file_info cur_file_info; /* public info about the current file in zip*/
00123         unz_file_info_internal cur_file_info_internal; /* private info about it*/
00124     file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
00125                                             file if we are decompressing it */
00126 } unz_s;
00127 
00128 
00129 /* ===========================================================================
00130      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
00131    for end of file.
00132    IN assertion: the stream s has been sucessfully opened for reading.
00133 */
00134 
00135 
00136 local int unzlocal_getByte(fin,pi)
00137         FILE *fin;
00138         int *pi;
00139 {
00140     unsigned char c;
00141         int err = fread(&c, 1, 1, fin);
00142     if (err==1)
00143     {
00144         *pi = (int)c;
00145         return UNZ_OK;
00146     }
00147     else
00148     {
00149         if (ferror(fin)) 
00150             return UNZ_ERRNO;
00151         else
00152             return UNZ_EOF;
00153     }
00154 }
00155 
00156 
00157 /* ===========================================================================
00158    Reads a long in LSB order from the given gz_stream. Sets 
00159 */
00160 local int unzlocal_getShort (fin,pX)
00161         FILE* fin;
00162     uLong *pX;
00163 {
00164     uLong x ;
00165     int i = 0;
00166     int err;
00167 
00168     err = unzlocal_getByte(fin,&i);
00169     x = (uLong)i;
00170     
00171     if (err==UNZ_OK)
00172         err = unzlocal_getByte(fin,&i);
00173     x += ((uLong)i)<<8;
00174    
00175     if (err==UNZ_OK)
00176         *pX = x;
00177     else
00178         *pX = 0;
00179     return err;
00180 }
00181 
00182 local int unzlocal_getLong (fin,pX)
00183         FILE* fin;
00184     uLong *pX;
00185 {
00186     uLong x ;
00187     int i = 0;
00188     int err;
00189 
00190     err = unzlocal_getByte(fin,&i);
00191     x = (uLong)i;
00192     
00193     if (err==UNZ_OK)
00194         err = unzlocal_getByte(fin,&i);
00195     x += ((uLong)i)<<8;
00196 
00197     if (err==UNZ_OK)
00198         err = unzlocal_getByte(fin,&i);
00199     x += ((uLong)i)<<16;
00200 
00201     if (err==UNZ_OK)
00202         err = unzlocal_getByte(fin,&i);
00203     x += ((uLong)i)<<24;
00204    
00205     if (err==UNZ_OK)
00206         *pX = x;
00207     else
00208         *pX = 0;
00209     return err;
00210 }
00211 
00212 
00213 /* My own strcmpi / strcasecmp */
00214 local int strcmpcasenosensitive_internal (fileName1,fileName2)
00215         const char* fileName1;
00216         const char* fileName2;
00217 {
00218         for (;;)
00219         {
00220                 char c1=*(fileName1++);
00221                 char c2=*(fileName2++);
00222                 if ((c1>='a') && (c1<='z'))
00223                         c1 -= 0x20;
00224                 if ((c2>='a') && (c2<='z'))
00225                         c2 -= 0x20;
00226                 if (c1=='\0')
00227                         return ((c2=='\0') ? 0 : -1);
00228                 if (c2=='\0')
00229                         return 1;
00230                 if (c1<c2)
00231                         return -1;
00232                 if (c1>c2)
00233                         return 1;
00234         }
00235 }
00236 
00237 
00238 #ifdef  CASESENSITIVITYDEFAULT_NO
00239 #define CASESENSITIVITYDEFAULTVALUE 2
00240 #else
00241 #define CASESENSITIVITYDEFAULTVALUE 1
00242 #endif
00243 
00244 #ifndef STRCMPCASENOSENTIVEFUNCTION
00245 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
00246 #endif
00247 
00248 /* 
00249    Compare two filename (fileName1,fileName2).
00250    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
00251    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
00252                                                                 or strcasecmp)
00253    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
00254         (like 1 on Unix, 2 on Windows)
00255 
00256 */
00257 extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
00258         const char* fileName1;
00259         const char* fileName2;
00260         int iCaseSensitivity;
00261 {
00262         if (iCaseSensitivity==0)
00263                 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
00264 
00265         if (iCaseSensitivity==1)
00266                 return strcmp(fileName1,fileName2);
00267 
00268         return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
00269 } 
00270 
00271 #define BUFREADCOMMENT (0x400)
00272 
00273 /*
00274   Locate the Central directory of a zipfile (at the end, just before
00275     the global comment)
00276 */
00277 local uLong unzlocal_SearchCentralDir(fin)
00278         FILE *fin;
00279 {
00280         unsigned char* buf;
00281         uLong uSizeFile;
00282         uLong uBackRead;
00283         uLong uMaxBack=0xffff; /* maximum size of global comment */
00284         uLong uPosFound=0;
00285         
00286         if (fseek(fin,0,SEEK_END) != 0)
00287                 return 0;
00288 
00289 
00290         uSizeFile = ftell( fin );
00291         
00292         if (uMaxBack>uSizeFile)
00293                 uMaxBack = uSizeFile;
00294 
00295         buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
00296         if (buf==NULL)
00297                 return 0;
00298 
00299         uBackRead = 4;
00300         while (uBackRead<uMaxBack)
00301         {
00302                 uLong uReadSize,uReadPos ;
00303                 int i;
00304                 if (uBackRead+BUFREADCOMMENT>uMaxBack) 
00305                         uBackRead = uMaxBack;
00306                 else
00307                         uBackRead+=BUFREADCOMMENT;
00308                 uReadPos = uSizeFile-uBackRead ;
00309                 
00310                 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 
00311                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
00312                 if (fseek(fin,uReadPos,SEEK_SET)!=0)
00313                         break;
00314 
00315                 if (fread(buf,(uInt)uReadSize,1,fin)!=1)
00316                         break;
00317 
00318                 for (i=(int)uReadSize-3; (i--)>0;)
00319                         if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 
00320                                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
00321                         {
00322                                 uPosFound = uReadPos+i;
00323                                 break;
00324                         }
00325 
00326                 if (uPosFound!=0)
00327                         break;
00328         }
00329         TRYFREE(buf);
00330         return uPosFound;
00331 }
00332 
00333 /*
00334   Open a Zip file. path contain the full pathname (by example,
00335      on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
00336          "zlib/zlib109.zip".
00337          If the zipfile cannot be opened (file don't exist or in not valid), the
00338            return value is NULL.
00339      Else, the return value is a unzFile Handle, usable with other function
00340            of this unzip package.
00341 */
00342 extern unzFile ZEXPORT unzOpen (path)
00343         const char *path;
00344 {
00345         unz_s us;
00346         unz_s *s;
00347         uLong central_pos,uL;
00348         FILE * fin ;
00349 
00350         uLong number_disk;          /* number of the current dist, used for 
00351                                                                    spaning ZIP, unsupported, always 0*/
00352         uLong number_disk_with_CD;  /* number the the disk with central dir, used
00353                                                                    for spaning ZIP, unsupported, always 0*/
00354         uLong number_entry_CD;      /* total number of entries in
00355                                        the central dir 
00356                                        (same than number_entry on nospan) */
00357 
00358         int err=UNZ_OK;
00359 
00360     if (unz_copyright[0]!=' ')
00361         return NULL;
00362 
00363     fin=fopen(path,"rb");
00364         if (fin==NULL)
00365                 return NULL;
00366 
00367         central_pos = unzlocal_SearchCentralDir(fin);
00368         if (central_pos==0)
00369                 err=UNZ_ERRNO;
00370 
00371         if (fseek(fin,central_pos,SEEK_SET)!=0)
00372                 err=UNZ_ERRNO;
00373 
00374         /* the signature, already checked */
00375         if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
00376                 err=UNZ_ERRNO;
00377 
00378         /* number of this disk */
00379         if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
00380                 err=UNZ_ERRNO;
00381 
00382         /* number of the disk with the start of the central directory */
00383         if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
00384                 err=UNZ_ERRNO;
00385 
00386         /* total number of entries in the central dir on this disk */
00387         if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
00388                 err=UNZ_ERRNO;
00389 
00390         /* total number of entries in the central dir */
00391         if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
00392                 err=UNZ_ERRNO;
00393 
00394         if ((number_entry_CD!=us.gi.number_entry) ||
00395                 (number_disk_with_CD!=0) ||
00396                 (number_disk!=0))
00397                 err=UNZ_BADZIPFILE;
00398 
00399         /* size of the central directory */
00400         if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
00401                 err=UNZ_ERRNO;
00402 
00403         /* offset of start of central directory with respect to the 
00404               starting disk number */
00405         if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
00406                 err=UNZ_ERRNO;
00407 
00408         /* zipfile comment length */
00409         if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
00410                 err=UNZ_ERRNO;
00411 
00412         if ((central_pos<us.offset_central_dir+us.size_central_dir) && 
00413                 (err==UNZ_OK))
00414                 err=UNZ_BADZIPFILE;
00415 
00416         if (err!=UNZ_OK)
00417         {
00418                 fclose(fin);
00419                 return NULL;
00420         }
00421 
00422         us.file=fin;
00423         us.byte_before_the_zipfile = central_pos -
00424                                     (us.offset_central_dir+us.size_central_dir);
00425         us.central_pos = central_pos;
00426     us.pfile_in_zip_read = NULL;
00427         
00428 
00429         s=(unz_s*)ALLOC(sizeof(unz_s));
00430         *s=us;
00431         unzGoToFirstFile((unzFile)s);   
00432         return (unzFile)s;      
00433 }
00434 
00435 
00436 /*
00437   Close a ZipFile opened with unzipOpen.
00438   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
00439     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
00440   return UNZ_OK if there is no problem. */
00441 extern int ZEXPORT unzClose (file)
00442         unzFile file;
00443 {
00444         unz_s* s;
00445         if (file==NULL)
00446                 return UNZ_PARAMERROR;
00447         s=(unz_s*)file;
00448 
00449     if (s->pfile_in_zip_read!=NULL)
00450         unzCloseCurrentFile(file);
00451 
00452         fclose(s->file);
00453         TRYFREE(s);
00454         return UNZ_OK;
00455 }
00456 
00457 
00458 /*
00459   Write info about the ZipFile in the *pglobal_info structure.
00460   No preparation of the structure is needed
00461   return UNZ_OK if there is no problem. */
00462 extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
00463         unzFile file;
00464         unz_global_info *pglobal_info;
00465 {
00466         unz_s* s;
00467         if (file==NULL)
00468                 return UNZ_PARAMERROR;
00469         s=(unz_s*)file;
00470         *pglobal_info=s->gi;
00471         return UNZ_OK;
00472 }
00473 
00474 
00475 /*
00476    Translate date/time from Dos format to tm_unz (readable more easilty)
00477 */
00478 local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
00479     uLong ulDosDate;
00480     tm_unz* ptm;
00481 {
00482     uLong uDate;
00483     uDate = (uLong)(ulDosDate>>16);
00484     ptm->tm_mday = (uInt)(uDate&0x1f) ;
00485     ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
00486     ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
00487 
00488     ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
00489     ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
00490     ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
00491 }
00492 
00493 /*
00494   Get Info about the current file in the zipfile, with internal only info
00495 */
00496 local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
00497                                                   unz_file_info *pfile_info,
00498                                                   unz_file_info_internal 
00499                                                   *pfile_info_internal,
00500                                                   char *szFileName,
00501                                                                                                   uLong fileNameBufferSize,
00502                                                   void *extraField,
00503                                                                                                   uLong extraFieldBufferSize,
00504                                                   char *szComment,
00505                                                                                                   uLong commentBufferSize));
00506 
00507 local int unzlocal_GetCurrentFileInfoInternal (file,
00508                                               pfile_info,
00509                                               pfile_info_internal,
00510                                               szFileName, fileNameBufferSize,
00511                                               extraField, extraFieldBufferSize,
00512                                               szComment,  commentBufferSize)
00513         unzFile file;
00514         unz_file_info *pfile_info;
00515         unz_file_info_internal *pfile_info_internal;
00516         char *szFileName;
00517         uLong fileNameBufferSize;
00518         void *extraField;
00519         uLong extraFieldBufferSize;
00520         char *szComment;
00521         uLong commentBufferSize;
00522 {
00523         unz_s* s;
00524         unz_file_info file_info;
00525         unz_file_info_internal file_info_internal;
00526         int err=UNZ_OK;
00527         uLong uMagic;
00528         long lSeek=0;
00529 
00530         if (file==NULL)
00531                 return UNZ_PARAMERROR;
00532         s=(unz_s*)file;
00533         if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
00534                 err=UNZ_ERRNO;
00535 
00536 
00537         /* we check the magic */
00538         if (err==UNZ_OK){ 
00539                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK) {
00540                         err=UNZ_ERRNO;
00541                 } else if (uMagic!=0x02014b50) {
00542                         err=UNZ_BADZIPFILE;
00543                 }
00544         }
00545 
00546         if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
00547                 err=UNZ_ERRNO;
00548 
00549         if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
00550                 err=UNZ_ERRNO;
00551 
00552         if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
00553                 err=UNZ_ERRNO;
00554 
00555         if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
00556                 err=UNZ_ERRNO;
00557 
00558         if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
00559                 err=UNZ_ERRNO;
00560 
00561     unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
00562 
00563         if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
00564                 err=UNZ_ERRNO;
00565 
00566         if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
00567                 err=UNZ_ERRNO;
00568 
00569         if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
00570                 err=UNZ_ERRNO;
00571 
00572         if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
00573                 err=UNZ_ERRNO;
00574 
00575         if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
00576                 err=UNZ_ERRNO;
00577 
00578         if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
00579                 err=UNZ_ERRNO;
00580 
00581         if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
00582                 err=UNZ_ERRNO;
00583 
00584         if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
00585                 err=UNZ_ERRNO;
00586 
00587         if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
00588                 err=UNZ_ERRNO;
00589 
00590         if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
00591                 err=UNZ_ERRNO;
00592 
00593         lSeek+=file_info.size_filename;
00594         if ((err==UNZ_OK) && (szFileName!=NULL))
00595         {
00596                 uLong uSizeRead ;
00597                 if (file_info.size_filename<fileNameBufferSize)
00598                 {
00599                         *(szFileName+file_info.size_filename)='\0';
00600                         uSizeRead = file_info.size_filename;
00601                 } else {
00602                         uSizeRead = fileNameBufferSize;
00603                 }
00604 
00605                 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
00606                         if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
00607                                 err=UNZ_ERRNO;
00608                 lSeek -= uSizeRead;
00609         }
00610 
00611         
00612         if ((err==UNZ_OK) && (extraField!=NULL))
00613         {
00614                 uLong uSizeRead ;
00615                 if (file_info.size_file_extra<extraFieldBufferSize)
00616                         uSizeRead = file_info.size_file_extra;
00617                 else
00618                         uSizeRead = extraFieldBufferSize;
00619 
00620                 if (lSeek!=0) {
00621                         if (fseek(s->file,lSeek,SEEK_CUR)==0) {
00622                                 lSeek=0;
00623                         } else {
00624                                 err=UNZ_ERRNO;
00625                         }
00626                 }
00627                 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
00628                         if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
00629                                 err=UNZ_ERRNO;
00630                 lSeek += file_info.size_file_extra - uSizeRead;
00631         }
00632         else
00633                 lSeek+=file_info.size_file_extra; 
00634 
00635         
00636         if ((err==UNZ_OK) && (szComment!=NULL))
00637         {
00638                 uLong uSizeRead ;
00639                 if (file_info.size_file_comment<commentBufferSize)
00640                 {
00641                         *(szComment+file_info.size_file_comment)='\0';
00642                         uSizeRead = file_info.size_file_comment;
00643                 }
00644                 else
00645                         uSizeRead = commentBufferSize;
00646 
00647                 if (lSeek!=0) {
00648                         if (fseek(s->file,lSeek,SEEK_CUR)==0)
00649                             lSeek=0;
00650                         else
00651                             err=UNZ_ERRNO;
00652                 }
00653                 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
00654                         if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
00655                                 err=UNZ_ERRNO;
00656                 lSeek+=file_info.size_file_comment - uSizeRead;
00657         }
00658         else
00659                 lSeek+=file_info.size_file_comment;
00660 
00661         if ((err==UNZ_OK) && (pfile_info!=NULL))
00662                 *pfile_info=file_info;
00663 
00664         if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
00665                 *pfile_info_internal=file_info_internal;
00666 
00667         return err;
00668 }
00669 
00670 
00671 
00672 /*
00673   Write info about the ZipFile in the *pglobal_info structure.
00674   No preparation of the structure is needed
00675   return UNZ_OK if there is no problem.
00676 */
00677 extern int ZEXPORT unzGetCurrentFileInfo (file,
00678                                                   pfile_info,
00679                                                   szFileName, fileNameBufferSize,
00680                                                   extraField, extraFieldBufferSize,
00681                                                   szComment,  commentBufferSize)
00682         unzFile file;
00683         unz_file_info *pfile_info;
00684         char *szFileName;
00685         uLong fileNameBufferSize;
00686         void *extraField;
00687         uLong extraFieldBufferSize;
00688         char *szComment;
00689         uLong commentBufferSize;
00690 {
00691         return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
00692                                                                                                 szFileName,fileNameBufferSize,
00693                                                                                                 extraField,extraFieldBufferSize,
00694                                                                                                 szComment,commentBufferSize);
00695 }
00696 
00697 /*
00698   Set the current file of the zipfile to the first file.
00699   return UNZ_OK if there is no problem
00700 */
00701 extern int ZEXPORT unzGoToFirstFile (file)
00702         unzFile file;
00703 {
00704         int err=UNZ_OK;
00705         unz_s* s;
00706         if (file==NULL)
00707                 return UNZ_PARAMERROR;
00708         s=(unz_s*)file;
00709         s->pos_in_central_dir=s->offset_central_dir;
00710         s->num_file=0;
00711         err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
00712                                                                                          &s->cur_file_info_internal,
00713                                                                                          NULL,0,NULL,0,NULL,0);
00714         s->current_file_ok = (err == UNZ_OK);
00715         return err;
00716 }
00717 
00718 
00719 /*
00720   Set the current file of the zipfile to the next file.
00721   return UNZ_OK if there is no problem
00722   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
00723 */
00724 extern int ZEXPORT unzGoToNextFile (file)
00725         unzFile file;
00726 {
00727         unz_s* s;       
00728         int err;
00729 
00730         if (file==NULL)
00731                 return UNZ_PARAMERROR;
00732         s=(unz_s*)file;
00733         if (!s->current_file_ok)
00734                 return UNZ_END_OF_LIST_OF_FILE;
00735         if (s->num_file+1==s->gi.number_entry)
00736                 return UNZ_END_OF_LIST_OF_FILE;
00737 
00738         s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
00739                         s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
00740         s->num_file++;
00741         err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
00742                                                                                            &s->cur_file_info_internal,
00743                                                                                            NULL,0,NULL,0,NULL,0);
00744         s->current_file_ok = (err == UNZ_OK);
00745         return err;
00746 }
00747 
00748 
00749 /*
00750   Try locate the file szFileName in the zipfile.
00751   For the iCaseSensitivity signification, see unzipStringFileNameCompare
00752 
00753   return value :
00754   UNZ_OK if the file is found. It becomes the current file.
00755   UNZ_END_OF_LIST_OF_FILE if the file is not found
00756 */
00757 extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
00758         unzFile file;
00759         const char *szFileName;
00760         int iCaseSensitivity;
00761 {
00762         unz_s* s;       
00763         int err;
00764 
00765         
00766         uLong num_fileSaved;
00767         uLong pos_in_central_dirSaved;
00768 
00769 
00770         if (file==NULL)
00771                 return UNZ_PARAMERROR;
00772 
00773     if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
00774         return UNZ_PARAMERROR;
00775 
00776         s=(unz_s*)file;
00777         if (!s->current_file_ok)
00778                 return UNZ_END_OF_LIST_OF_FILE;
00779 
00780         num_fileSaved = s->num_file;
00781         pos_in_central_dirSaved = s->pos_in_central_dir;
00782 
00783         err = unzGoToFirstFile(file);
00784 
00785         while (err == UNZ_OK)
00786         {
00787                 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
00788                 unzGetCurrentFileInfo(file,NULL,
00789                                                                 szCurrentFileName,sizeof(szCurrentFileName)-1,
00790                                                                 NULL,0,NULL,0);
00791                 if (unzStringFileNameCompare(szCurrentFileName,
00792                                                                                 szFileName,iCaseSensitivity)==0)
00793                         return UNZ_OK;
00794                 err = unzGoToNextFile(file);
00795         }
00796 
00797         s->num_file = num_fileSaved ;
00798         s->pos_in_central_dir = pos_in_central_dirSaved ;
00799         return err;
00800 }
00801 
00802 
00803 /*
00804   Read the local header of the current zipfile
00805   Check the coherency of the local header and info in the end of central
00806         directory about this file
00807   store in *piSizeVar the size of extra info in local header
00808         (filename and size of extra field data)
00809 */
00810 local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
00811                                                                                                         poffset_local_extrafield,
00812                                                                                                         psize_local_extrafield)
00813         unz_s* s;
00814         uInt* piSizeVar;
00815         uLong *poffset_local_extrafield;
00816         uInt  *psize_local_extrafield;
00817 {
00818         uLong uMagic,uData,uFlags;
00819         uLong size_filename;
00820         uLong size_extra_field;
00821         int err=UNZ_OK;
00822 
00823         *piSizeVar = 0;
00824         *poffset_local_extrafield = 0;
00825         *psize_local_extrafield = 0;
00826 
00827         if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
00828                                                                 s->byte_before_the_zipfile,SEEK_SET)!=0)
00829                 return UNZ_ERRNO;
00830 
00831 
00832         if (err==UNZ_OK) {
00833                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
00834                         err=UNZ_ERRNO;
00835                 else if (uMagic!=0x04034b50)
00836                         err=UNZ_BADZIPFILE;
00837         }
00838 
00839         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
00840                 err=UNZ_ERRNO;
00841 /*
00842         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
00843                 err=UNZ_BADZIPFILE;
00844 */
00845         if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
00846                 err=UNZ_ERRNO;
00847 
00848         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
00849                 err=UNZ_ERRNO;
00850         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
00851                 err=UNZ_BADZIPFILE;
00852 
00853     if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
00854                          (s->cur_file_info.compression_method!=Z_DEFLATED))
00855         err=UNZ_BADZIPFILE;
00856 
00857         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
00858                 err=UNZ_ERRNO;
00859 
00860         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
00861                 err=UNZ_ERRNO;
00862         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
00863                                       ((uFlags & 8)==0))
00864                 err=UNZ_BADZIPFILE;
00865 
00866         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
00867                 err=UNZ_ERRNO;
00868         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
00869                                                           ((uFlags & 8)==0))
00870                 err=UNZ_BADZIPFILE;
00871 
00872         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
00873                 err=UNZ_ERRNO;
00874         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 
00875                                                           ((uFlags & 8)==0))
00876                 err=UNZ_BADZIPFILE;
00877 
00878 
00879         if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
00880                 err=UNZ_ERRNO;
00881         else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
00882                 err=UNZ_BADZIPFILE;
00883 
00884         *piSizeVar += (uInt)size_filename;
00885 
00886         if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
00887                 err=UNZ_ERRNO;
00888         *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
00889                                                                         SIZEZIPLOCALHEADER + size_filename;
00890         *psize_local_extrafield = (uInt)size_extra_field;
00891 
00892         *piSizeVar += (uInt)size_extra_field;
00893 
00894         return err;
00895 }
00896                                                                                                 
00897 /*
00898   Open for reading data the current file in the zipfile.
00899   If there is no error and the file is opened, the return value is UNZ_OK.
00900 */
00901 extern int ZEXPORT unzOpenCurrentFile (file)
00902         unzFile file;
00903 {
00904         int err=UNZ_OK;
00905         int Store;
00906         uInt iSizeVar;
00907         unz_s* s;
00908         file_in_zip_read_info_s* pfile_in_zip_read_info;
00909         uLong offset_local_extrafield;  /* offset of the local extra field */
00910         uInt  size_local_extrafield;    /* size of the local extra field */
00911 
00912         if (file==NULL)
00913                 return UNZ_PARAMERROR;
00914         s=(unz_s*)file;
00915         if (!s->current_file_ok)
00916                 return UNZ_PARAMERROR;
00917 
00918     if (s->pfile_in_zip_read != NULL)
00919         unzCloseCurrentFile(file);
00920 
00921         if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
00922                                 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
00923                 return UNZ_BADZIPFILE;
00924 
00925         pfile_in_zip_read_info = (file_in_zip_read_info_s*)
00926                                                                             ALLOC(sizeof(file_in_zip_read_info_s));
00927         if (pfile_in_zip_read_info==NULL)
00928                 return UNZ_INTERNALERROR;
00929 
00930         pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
00931         pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
00932         pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
00933         pfile_in_zip_read_info->pos_local_extrafield=0;
00934 
00935         if (pfile_in_zip_read_info->read_buffer==NULL)
00936         {
00937                 TRYFREE(pfile_in_zip_read_info);
00938                 return UNZ_INTERNALERROR;
00939         }
00940 
00941         pfile_in_zip_read_info->stream_initialised=0;
00942         
00943         if ((s->cur_file_info.compression_method!=0) &&
00944         (s->cur_file_info.compression_method!=Z_DEFLATED))
00945                 err=UNZ_BADZIPFILE;
00946         Store = s->cur_file_info.compression_method==0;
00947 
00948         pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
00949         pfile_in_zip_read_info->crc32=0;
00950         pfile_in_zip_read_info->compression_method =
00951             s->cur_file_info.compression_method;
00952         pfile_in_zip_read_info->file=s->file;
00953         pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
00954 
00955     pfile_in_zip_read_info->stream.total_out = 0;
00956 
00957         if (!Store)
00958         {
00959           pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
00960           pfile_in_zip_read_info->stream.zfree = (free_func)0;
00961           pfile_in_zip_read_info->stream.opaque = (voidpf)0; 
00962       
00963           err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
00964           if (err == Z_OK)
00965             pfile_in_zip_read_info->stream_initialised=1;
00966         /* windowBits is passed < 0 to tell that there is no zlib header.
00967          * Note that in this case inflate *requires* an extra "dummy" byte
00968          * after the compressed stream in order to complete decompression and
00969          * return Z_STREAM_END. 
00970          * In unzip, i don't wait absolutely Z_STREAM_END because I known the 
00971          * size of both compressed and uncompressed data
00972          */
00973         }
00974         pfile_in_zip_read_info->rest_read_compressed = 
00975             s->cur_file_info.compressed_size ;
00976         pfile_in_zip_read_info->rest_read_uncompressed = 
00977             s->cur_file_info.uncompressed_size ;
00978 
00979         
00980         pfile_in_zip_read_info->pos_in_zipfile = 
00981             s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 
00982                           iSizeVar;
00983         
00984         pfile_in_zip_read_info->stream.avail_in = (uInt)0;
00985 
00986 
00987         s->pfile_in_zip_read = pfile_in_zip_read_info;
00988     return UNZ_OK;
00989 }
00990 
00991 
00992 /*
00993   Read bytes from the current file.
00994   buf contain buffer where data must be copied
00995   len the size of buf.
00996 
00997   return the number of byte copied if somes bytes are copied
00998   return 0 if the end of file was reached
00999   return <0 with error code if there is an error
01000     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
01001 */
01002 extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
01003         unzFile file;
01004         voidp buf;
01005         unsigned len;
01006 {
01007         int err=UNZ_OK;
01008         uInt iRead = 0;
01009         unz_s* s;
01010         file_in_zip_read_info_s* pfile_in_zip_read_info;
01011         if (file==NULL)
01012                 return UNZ_PARAMERROR;
01013         s=(unz_s*)file;
01014     pfile_in_zip_read_info=s->pfile_in_zip_read;
01015 
01016         if (pfile_in_zip_read_info==NULL)
01017                 return UNZ_PARAMERROR;
01018 
01019 
01020         if ((pfile_in_zip_read_info->read_buffer == NULL))
01021                 return UNZ_END_OF_LIST_OF_FILE;
01022         if (len==0)
01023                 return 0;
01024 
01025         pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
01026 
01027         pfile_in_zip_read_info->stream.avail_out = (uInt)len;
01028         
01029         if (len>pfile_in_zip_read_info->rest_read_uncompressed)
01030                 pfile_in_zip_read_info->stream.avail_out = 
01031                   (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
01032 
01033         while (pfile_in_zip_read_info->stream.avail_out>0)
01034         {
01035                 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
01036             (pfile_in_zip_read_info->rest_read_compressed>0))
01037                 {
01038                         uInt uReadThis = UNZ_BUFSIZE;
01039                         if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
01040                                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
01041                         if (uReadThis == 0)
01042                                 return UNZ_EOF;
01043                         if (fseek(pfile_in_zip_read_info->file,
01044                       pfile_in_zip_read_info->pos_in_zipfile + 
01045                          pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
01046                                 return UNZ_ERRNO;
01047                         if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
01048                          pfile_in_zip_read_info->file)!=1)
01049                                 return UNZ_ERRNO;
01050                         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
01051 
01052                         pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
01053                         
01054                         pfile_in_zip_read_info->stream.next_in = 
01055                 (Bytef*)pfile_in_zip_read_info->read_buffer;
01056                         pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
01057                 }
01058 
01059                 if (pfile_in_zip_read_info->compression_method==0)
01060                 {
01061                         uInt uDoCopy,i ;
01062                         if (pfile_in_zip_read_info->stream.avail_out < 
01063                             pfile_in_zip_read_info->stream.avail_in)
01064                                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
01065                         else
01066                                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
01067                                 
01068                         for (i=0;i<uDoCopy;i++)
01069                                 *(pfile_in_zip_read_info->stream.next_out+i) =
01070                         *(pfile_in_zip_read_info->stream.next_in+i);
01071                                         
01072                         pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
01073                                                                 pfile_in_zip_read_info->stream.next_out,
01074                                                                 uDoCopy);
01075                         pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
01076                         pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
01077                         pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
01078                         pfile_in_zip_read_info->stream.next_out += uDoCopy;
01079                         pfile_in_zip_read_info->stream.next_in += uDoCopy;
01080             pfile_in_zip_read_info->stream.total_out += uDoCopy;
01081                         iRead += uDoCopy;
01082                 }
01083                 else
01084                 {
01085                         uLong uTotalOutBefore,uTotalOutAfter;
01086                         const Bytef *bufBefore;
01087                         uLong uOutThis;
01088                         int flush=Z_SYNC_FLUSH;
01089 
01090                         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
01091                         bufBefore = pfile_in_zip_read_info->stream.next_out;
01092 
01093                         /*
01094                         if ((pfile_in_zip_read_info->rest_read_uncompressed ==
01095                                  pfile_in_zip_read_info->stream.avail_out) &&
01096                                 (pfile_in_zip_read_info->rest_read_compressed == 0))
01097                                 flush = Z_FINISH;
01098                         */
01099                         err=inflate(&pfile_in_zip_read_info->stream,flush);
01100 
01101                         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
01102                         uOutThis = uTotalOutAfter-uTotalOutBefore;
01103                         
01104                         pfile_in_zip_read_info->crc32 = 
01105                 crc32(pfile_in_zip_read_info->crc32,bufBefore,
01106                         (uInt)(uOutThis));
01107 
01108                         pfile_in_zip_read_info->rest_read_uncompressed -=
01109                 uOutThis;
01110 
01111                         iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
01112             
01113                         if (err==Z_STREAM_END)
01114                                 return (iRead==0) ? UNZ_EOF : iRead;
01115                         if (err!=Z_OK) 
01116                                 break;
01117                 }
01118         }
01119 
01120         if (err==Z_OK)
01121                 return iRead;
01122         return err;
01123 }
01124 
01125 
01126 /*
01127   Give the current position in uncompressed data
01128 */
01129 extern z_off_t ZEXPORT unztell (file)
01130         unzFile file;
01131 {
01132         unz_s* s;
01133         file_in_zip_read_info_s* pfile_in_zip_read_info;
01134         if (file==NULL)
01135                 return UNZ_PARAMERROR;
01136         s=(unz_s*)file;
01137     pfile_in_zip_read_info=s->pfile_in_zip_read;
01138 
01139         if (pfile_in_zip_read_info==NULL)
01140                 return UNZ_PARAMERROR;
01141 
01142         return (z_off_t)pfile_in_zip_read_info->stream.total_out;
01143 }
01144 
01145 
01146 /*
01147   return 1 if the end of file was reached, 0 elsewhere 
01148 */
01149 extern int ZEXPORT unzeof (file)
01150         unzFile file;
01151 {
01152         unz_s* s;
01153         file_in_zip_read_info_s* pfile_in_zip_read_info;
01154         if (file==NULL)
01155                 return UNZ_PARAMERROR;
01156         s=(unz_s*)file;
01157     pfile_in_zip_read_info=s->pfile_in_zip_read;
01158 
01159         if (pfile_in_zip_read_info==NULL)
01160                 return UNZ_PARAMERROR;
01161         
01162         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
01163                 return 1;
01164         else
01165                 return 0;
01166 }
01167 
01168 
01169 
01170 /*
01171   Read extra field from the current file (opened by unzOpenCurrentFile)
01172   This is the local-header version of the extra field (sometimes, there is
01173     more info in the local-header version than in the central-header)
01174 
01175   if buf==NULL, it return the size of the local extra field that can be read
01176 
01177   if buf!=NULL, len is the size of the buffer, the extra header is copied in
01178         buf.
01179   the return value is the number of bytes copied in buf, or (if <0) 
01180         the error code
01181 */
01182 extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
01183         unzFile file;
01184         voidp buf;
01185         unsigned len;
01186 {
01187         unz_s* s;
01188         file_in_zip_read_info_s* pfile_in_zip_read_info;
01189         uInt read_now;
01190         uLong size_to_read;
01191 
01192         if (file==NULL)
01193                 return UNZ_PARAMERROR;
01194         s=(unz_s*)file;
01195     pfile_in_zip_read_info=s->pfile_in_zip_read;
01196 
01197         if (pfile_in_zip_read_info==NULL)
01198                 return UNZ_PARAMERROR;
01199 
01200         size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 
01201                                 pfile_in_zip_read_info->pos_local_extrafield);
01202 
01203         if (buf==NULL)
01204                 return (int)size_to_read;
01205         
01206         if (len>size_to_read)
01207                 read_now = (uInt)size_to_read;
01208         else
01209                 read_now = (uInt)len ;
01210 
01211         if (read_now==0)
01212                 return 0;
01213         
01214         if (fseek(pfile_in_zip_read_info->file,
01215               pfile_in_zip_read_info->offset_local_extrafield + 
01216                           pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
01217                 return UNZ_ERRNO;
01218 
01219         if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
01220                 return UNZ_ERRNO;
01221 
01222         return (int)read_now;
01223 }
01224 
01225 /*
01226   Close the file in zip opened with unzipOpenCurrentFile
01227   Return UNZ_CRCERROR if all the file was read but the CRC is not good
01228 */
01229 extern int ZEXPORT unzCloseCurrentFile (file)
01230         unzFile file;
01231 {
01232         int err=UNZ_OK;
01233 
01234         unz_s* s;
01235         file_in_zip_read_info_s* pfile_in_zip_read_info;
01236         if (file==NULL)
01237                 return UNZ_PARAMERROR;
01238         s=(unz_s*)file;
01239     pfile_in_zip_read_info=s->pfile_in_zip_read;
01240 
01241         if (pfile_in_zip_read_info==NULL)
01242                 return UNZ_PARAMERROR;
01243 
01244 
01245         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
01246         {
01247                 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
01248                         err=UNZ_CRCERROR;
01249         }
01250 
01251 
01252         TRYFREE(pfile_in_zip_read_info->read_buffer);
01253         pfile_in_zip_read_info->read_buffer = NULL;
01254         if (pfile_in_zip_read_info->stream_initialised)
01255                 inflateEnd(&pfile_in_zip_read_info->stream);
01256 
01257         pfile_in_zip_read_info->stream_initialised = 0;
01258         TRYFREE(pfile_in_zip_read_info);
01259 
01260     s->pfile_in_zip_read=NULL;
01261 
01262         return err;
01263 }
01264 
01265 
01266 /*
01267   Get the global comment string of the ZipFile, in the szComment buffer.
01268   uSizeBuf is the size of the szComment buffer.
01269   return the number of byte copied or an error code <0
01270 */
01271 extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
01272         unzFile file;
01273         char *szComment;
01274         uLong uSizeBuf;
01275 {
01276 //      int err=UNZ_OK;
01277         unz_s* s;
01278         uLong uReadThis ;
01279         if (file==NULL)
01280                 return UNZ_PARAMERROR;
01281         s=(unz_s*)file;
01282 
01283         uReadThis = uSizeBuf;
01284         if (uReadThis>s->gi.size_comment)
01285                 uReadThis = s->gi.size_comment;
01286 
01287         if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
01288                 return UNZ_ERRNO;
01289 
01290         if (uReadThis>0)
01291     {
01292       *szComment='\0';
01293           if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
01294                 return UNZ_ERRNO;
01295     }
01296 
01297         if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
01298                 *(szComment+s->gi.size_comment)='\0';
01299         return (int)uReadThis;
01300 }