zlib/unzip.c

   1 /* unzip.c -- IO on .zip files using zlib
   2    Version 0.15 beta, Mar 19th, 1998,
   3
   4    Read unzip.h for more info
   5 */
   6
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include "zlib.h"
  12 #include "unzip.h"
  13
  14 #ifdef STDC
  15 #  include <stddef.h>
  16 #  include <string.h>
  17 #  include <stdlib.h>
  18 #endif
  19 #ifdef NO_ERRNO_H
  20     extern int errno;
  21 #else
  22 #   include <errno.h>
  23 #endif
  24
  25
  26 #ifndef local
  27 #  define local static
  28 #endif
  29 /* compile with -Dlocal if your debugger can't find static symbols */
  30
  31
  32
  33 #if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
  34                       !defined(CASESENSITIVITYDEFAULT_NO)
  35 #define CASESENSITIVITYDEFAULT_NO
  36 #endif
  37
  38
  39 #ifndef UNZ_BUFSIZE
  40 #define UNZ_BUFSIZE (16384)
  41 #endif
  42
  43 #ifndef UNZ_MAXFILENAMEINZIP
  44 #define UNZ_MAXFILENAMEINZIP (256)
  45 #endif
  46
  47 #ifndef ALLOC
  48 # define ALLOC(size) (malloc(size))
  49 #endif
  50 #ifndef TRYFREE
  51 # define TRYFREE(p) {if (p) free(p);}
  52 #endif
  53
  54 #define SIZECENTRALDIRITEM (0x2e)
  55 #define SIZEZIPLOCALHEADER (0x1e)
  56
  57
  58 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
  59
  60 #ifndef SEEK_CUR
  61 #define SEEK_CUR    1
  62 #endif
  63
  64 #ifndef SEEK_END
  65 #define SEEK_END    2
  66 #endif
  67
  68 #ifndef SEEK_SET
  69 #define SEEK_SET    0
  70 #endif
  71
  72 const char unz_copyright[] =
  73    " unzip 0.15 Copyright 1998 Gilles Vollant ";
  74
  75 /* unz_file_info_interntal contain internal info about a file in zipfile*/
  76 typedef struct unz_file_info_internal_s
  77 {
  78     uLong offset_curfile;/* relative offset of local header 4 bytes */
  79 } unz_file_info_internal;
  80
  81
  82 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
  83     when reading and decompress it */
  84 typedef struct
  85 {
  86         char  *read_buffer;         /* internal buffer for compressed data */
  87         z_stream stream;            /* zLib stream structure for inflate */
  88
  89         uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
  90         uLong stream_initialised;   /* flag set if stream structure is initialised*/
  91
  92         uLong offset_local_extrafield;/* offset of the local extra field */
  93         uInt  size_local_extrafield;/* size of the local extra field */
  94         uLong pos_local_extrafield;   /* position in the local extra field in read*/
  95
  96         uLong crc32;                /* crc32 of all data uncompressed */
  97         uLong crc32_wait;           /* crc32 we must obtain after decompress all */
  98         uLong rest_read_compressed; /* number of byte to be decompressed */
  99         uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
 100         FILE* file;                 /* io structore of the zipfile */
 101         uLong compression_method;   /* compression method (0==store) */
 102         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
 103 } file_in_zip_read_info_s;
 104
 105
 106 /* unz_s contain internal information about the zipfile
 107 */
 108 typedef struct
 109 {
 110         FILE* file;                 /* io structore of the zipfile */
 111         unz_global_info gi;       /* public global information */
 112         uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
 113         uLong num_file;             /* number of the current file in the zipfile*/
 114         uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
 115         uLong current_file_ok;      /* flag about the usability of the current file*/
 116         uLong central_pos;          /* position of the beginning of the central dir*/
 117
 118         uLong size_central_dir;     /* size of the central directory  */
 119         uLong offset_central_dir;   /* offset of start of central directory with
 120                                                                    respect to the starting disk number */
 121
 122         unz_file_info cur_file_info; /* public info about the current file in zip*/
 123         unz_file_info_internal cur_file_info_internal; /* private info about it*/
 124     file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
 125                                             file if we are decompressing it */
 126 } unz_s;
 127
 128
 129 /* ===========================================================================
 130      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
 131    for end of file.
 132    IN assertion: the stream s has been sucessfully opened for reading.
 133 */
 134
 135
 136 local int unzlocal_getByte(fin,pi)
 137         FILE *fin;
 138         int *pi;
 139 {
 140     unsigned char c;
 141         int err = fread(&c, 1, 1, fin);
 142     if (err==1)
 143     {
 144         *pi = (int)c;
 145         return UNZ_OK;
 146     }
 147     else
 148     {
 149         if (ferror(fin))
 150             return UNZ_ERRNO;
 151         else
 152             return UNZ_EOF;
 153     }
 154 }
 155
 156
 157 /* ===========================================================================
 158    Reads a long in LSB order from the given gz_stream. Sets
 159 */
 160 local int unzlocal_getShort (fin,pX)
 161         FILE* fin;
 162     uLong *pX;
 163 {
 164     uLong x ;
 165     int i=0;
 166     int err;
 167
 168     err = unzlocal_getByte(fin,&i);
 169     x = (uLong)i;
 170
 171     if (err==UNZ_OK)
 172         err = unzlocal_getByte(fin,&i);
 173     x += ((uLong)i)<<8;
 174
 175     if (err==UNZ_OK)
 176         *pX = x;
 177     else
 178         *pX = 0;
 179     return err;
 180 }
 181
 182 local int unzlocal_getLong (fin,pX)
 183         FILE* fin;
 184     uLong *pX;
 185 {
 186     uLong x ;
 187     int i=0;
 188     int err;
 189
 190     err = unzlocal_getByte(fin,&i);
 191     x = (uLong)i;
 192
 193     if (err==UNZ_OK)
 194         err = unzlocal_getByte(fin,&i);
 195     x += ((uLong)i)<<8;
 196
 197     if (err==UNZ_OK)
 198         err = unzlocal_getByte(fin,&i);
 199     x += ((uLong)i)<<16;
 200
 201     if (err==UNZ_OK)
 202         err = unzlocal_getByte(fin,&i);
 203     x += ((uLong)i)<<24;
 204
 205     if (err==UNZ_OK)
 206         *pX = x;
 207     else
 208         *pX = 0;
 209     return err;
 210 }
 211
 212
 213 /* My own strcmpi / strcasecmp */
 214 local int strcmpcasenosensitive_internal (fileName1,fileName2)
 215         const char* fileName1;
 216         const char* fileName2;
 217 {
 218         for (;;)
 219         {
 220                 char c1=*(fileName1++);
 221                 char c2=*(fileName2++);
 222                 if ((c1>='a') && (c1<='z'))
 223                         c1 -= 0x20;
 224                 if ((c2>='a') && (c2<='z'))
 225                         c2 -= 0x20;
 226                 if (c1=='\0')
 227                         return ((c2=='\0') ? 0 : -1);
 228                 if (c2=='\0')
 229                         return 1;
 230                 if (c1<c2)
 231                         return -1;
 232                 if (c1>c2)
 233                         return 1;
 234         }
 235 }
 236
 237
 238 #ifdef  CASESENSITIVITYDEFAULT_NO
 239 #define CASESENSITIVITYDEFAULTVALUE 2
 240 #else
 241 #define CASESENSITIVITYDEFAULTVALUE 1
 242 #endif
 243
 244 #ifndef STRCMPCASENOSENTIVEFUNCTION
 245 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
 246 #endif
 247
 248 /*
 249    Compare two filename (fileName1,fileName2).
 250    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
 251    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
 252                                                                 or strcasecmp)
 253    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
 254         (like 1 on Unix, 2 on Windows)
 255
 256 */
 257 extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
 258         const char* fileName1;
 259         const char* fileName2;
 260         int iCaseSensitivity;
 261 {
 262         if (iCaseSensitivity==0)
 263                 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
 264
 265         if (iCaseSensitivity==1)
 266                 return strcmp(fileName1,fileName2);
 267
 268         return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
 269 }
 270
 271 #define BUFREADCOMMENT (0x400)
 272
 273 /*
 274   Locate the Central directory of a zipfile (at the end, just before
 275     the global comment)
 276 */
 277 local uLong unzlocal_SearchCentralDir(fin)
 278         FILE *fin;
 279 {
 280         unsigned char* buf;
 281         uLong uSizeFile;
 282         uLong uBackRead;
 283         uLong uMaxBack=0xffff; /* maximum size of global comment */
 284         uLong uPosFound=0;
 285
 286         if (fseek(fin,0,SEEK_END) != 0)
 287                 return 0;
 288
 289
 290         uSizeFile = ftell( fin );
 291
 292         if (uMaxBack>uSizeFile)
 293                 uMaxBack = uSizeFile;
 294
 295         buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
 296         if (buf==NULL)
 297                 return 0;
 298
 299         uBackRead = 4;
 300         while (uBackRead<uMaxBack)
 301         {
 302                 uLong uReadSize,uReadPos ;
 303                 int i;
 304                 if (uBackRead+BUFREADCOMMENT>uMaxBack)
 305                         uBackRead = uMaxBack;
 306                 else
 307                         uBackRead+=BUFREADCOMMENT;
 308                 uReadPos = uSizeFile-uBackRead ;
 309
 310                 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
 311                      (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
 312                 if (fseek(fin,uReadPos,SEEK_SET)!=0)
 313                         break;
 314
 315                 if (fread(buf,(uInt)uReadSize,1,fin)!=1)
 316                         break;
 317
 318                 for (i=(int)uReadSize-3; (i--)>0;)
 319                         if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
 320                                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
 321                         {
 322                                 uPosFound = uReadPos+i;
 323                                 break;
 324                         }
 325
 326                 if (uPosFound!=0)
 327                         break;
 328         }
 329         TRYFREE(buf);
 330         return uPosFound;
 331 }
 332
 333 /*
 334   Open a Zip file. path contain the full pathname (by example,
 335      on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
 336          "zlib/zlib109.zip".
 337          If the zipfile cannot be opened (file don't exist or in not valid), the
 338            return value is NULL.
 339      Else, the return value is a unzFile Handle, usable with other function
 340            of this unzip package.
 341 */
 342 extern unzFile ZEXPORT unzOpen (path)
 343         const char *path;
 344 {
 345         unz_s us;
 346         unz_s *s;
 347         uLong central_pos,uL;
 348         FILE * fin ;
 349
 350         uLong number_disk;          /* number of the current dist, used for
 351                                                                    spaning ZIP, unsupported, always 0*/
 352         uLong number_disk_with_CD;  /* number the the disk with central dir, used
 353                                                                    for spaning ZIP, unsupported, always 0*/
 354         uLong number_entry_CD;      /* total number of entries in
 355                                        the central dir
 356                                        (same than number_entry on nospan) */
 357
 358         int err=UNZ_OK;
 359
 360     if (unz_copyright[0]!=' ')
 361         return NULL;
 362
 363     fin=fopen(path,"rb");
 364         if (fin==NULL)
 365                 return NULL;
 366
 367         central_pos = unzlocal_SearchCentralDir(fin);
 368         if (central_pos==0)
 369                 err=UNZ_ERRNO;
 370
 371         if (fseek(fin,central_pos,SEEK_SET)!=0)
 372                 err=UNZ_ERRNO;
 373
 374         /* the signature, already checked */
 375         if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
 376                 err=UNZ_ERRNO;
 377
 378         /* number of this disk */
 379         if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
 380                 err=UNZ_ERRNO;
 381
 382         /* number of the disk with the start of the central directory */
 383         if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
 384                 err=UNZ_ERRNO;
 385
 386         /* total number of entries in the central dir on this disk */
 387         if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
 388                 err=UNZ_ERRNO;
 389
 390         /* total number of entries in the central dir */
 391         if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
 392                 err=UNZ_ERRNO;
 393
 394         if ((number_entry_CD!=us.gi.number_entry) ||
 395                 (number_disk_with_CD!=0) ||
 396                 (number_disk!=0))
 397                 err=UNZ_BADZIPFILE;
 398
 399         /* size of the central directory */
 400         if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
 401                 err=UNZ_ERRNO;
 402
 403         /* offset of start of central directory with respect to the
 404               starting disk number */
 405         if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
 406                 err=UNZ_ERRNO;
 407
 408         /* zipfile comment length */
 409         if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
 410                 err=UNZ_ERRNO;
 411
 412         if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
 413                 (err==UNZ_OK))
 414                 err=UNZ_BADZIPFILE;
 415
 416         if (err!=UNZ_OK)
 417         {
 418                 fclose(fin);
 419                 return NULL;
 420         }
 421
 422         us.file=fin;
 423         us.byte_before_the_zipfile = central_pos -
 424                                     (us.offset_central_dir+us.size_central_dir);
 425         us.central_pos = central_pos;
 426     us.pfile_in_zip_read = NULL;
 427
 428
 429         s=(unz_s*)ALLOC(sizeof(unz_s));
 430         *s=us;
 431         unzGoToFirstFile((unzFile)s);
 432         return (unzFile)s;
 433 }
 434
 435
 436 /*
 437   Close a ZipFile opened with unzipOpen.
 438   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
 439     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
 440   return UNZ_OK if there is no problem. */
 441 extern int ZEXPORT unzClose (file)
 442         unzFile file;
 443 {
 444         unz_s* s;
 445         if (file==NULL)
 446                 return UNZ_PARAMERROR;
 447         s=(unz_s*)file;
 448
 449     if (s->pfile_in_zip_read!=NULL)
 450         unzCloseCurrentFile(file);
 451
 452         fclose(s->file);
 453         TRYFREE(s);
 454         return UNZ_OK;
 455 }
 456
 457
 458 /*
 459   Write info about the ZipFile in the *pglobal_info structure.
 460   No preparation of the structure is needed
 461   return UNZ_OK if there is no problem. */
 462 extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
 463         unzFile file;
 464         unz_global_info *pglobal_info;
 465 {
 466         unz_s* s;
 467         if (file==NULL)
 468                 return UNZ_PARAMERROR;
 469         s=(unz_s*)file;
 470         *pglobal_info=s->gi;
 471         return UNZ_OK;
 472 }
 473
 474
 475 /*
 476    Translate date/time from Dos format to tm_unz (readable more easilty)
 477 */
 478 local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
 479     uLong ulDosDate;
 480     tm_unz* ptm;
 481 {
 482     uLong uDate;
 483     uDate = (uLong)(ulDosDate>>16);
 484     ptm->tm_mday = (uInt)(uDate&0x1f) ;
 485     ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
 486     ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
 487
 488     ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
 489     ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
 490     ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
 491 }
 492
 493 /*
 494   Get Info about the current file in the zipfile, with internal only info
 495 */
 496 local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
 497                                                   unz_file_info *pfile_info,
 498                                                   unz_file_info_internal
 499                                                   *pfile_info_internal,
 500                                                   char *szFileName,
 501                                                                                                   uLong fileNameBufferSize,
 502                                                   void *extraField,
 503                                                                                                   uLong extraFieldBufferSize,
 504                                                   char *szComment,
 505                                                                                                   uLong commentBufferSize));
 506
 507 local int unzlocal_GetCurrentFileInfoInternal (file,
 508                                               pfile_info,
 509                                               pfile_info_internal,
 510                                               szFileName, fileNameBufferSize,
 511                                               extraField, extraFieldBufferSize,
 512                                               szComment,  commentBufferSize)
 513         unzFile file;
 514         unz_file_info *pfile_info;
 515         unz_file_info_internal *pfile_info_internal;
 516         char *szFileName;
 517         uLong fileNameBufferSize;
 518         void *extraField;
 519         uLong extraFieldBufferSize;
 520         char *szComment;
 521         uLong commentBufferSize;
 522 {
 523         unz_s* s;
 524         unz_file_info file_info;
 525         unz_file_info_internal file_info_internal;
 526         int err=UNZ_OK;
 527         uLong uMagic;
 528         long lSeek=0;
 529
 530         if (file==NULL)
 531                 return UNZ_PARAMERROR;
 532         s=(unz_s*)file;
 533         if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
 534                 err=UNZ_ERRNO;
 535
 536
 537         /* we check the magic */
 538         if (err==UNZ_OK)
 539         {
 540                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
 541                         err=UNZ_ERRNO;
 542                 else if (uMagic!=0x02014b50)
 543                         err=UNZ_BADZIPFILE;
 544         }
 545
 546         if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
 547                 err=UNZ_ERRNO;
 548
 549         if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
 550                 err=UNZ_ERRNO;
 551
 552         if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
 553                 err=UNZ_ERRNO;
 554
 555         if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
 556                 err=UNZ_ERRNO;
 557
 558         if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
 559                 err=UNZ_ERRNO;
 560
 561     unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
 562
 563         if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
 564                 err=UNZ_ERRNO;
 565
 566         if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
 567                 err=UNZ_ERRNO;
 568
 569         if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
 570                 err=UNZ_ERRNO;
 571
 572         if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
 573                 err=UNZ_ERRNO;
 574
 575         if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
 576                 err=UNZ_ERRNO;
 577
 578         if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
 579                 err=UNZ_ERRNO;
 580
 581         if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
 582                 err=UNZ_ERRNO;
 583
 584         if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
 585                 err=UNZ_ERRNO;
 586
 587         if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
 588                 err=UNZ_ERRNO;
 589
 590         if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
 591                 err=UNZ_ERRNO;
 592
 593         lSeek+=file_info.size_filename;
 594         if ((err==UNZ_OK) && (szFileName!=NULL))
 595         {
 596                 uLong uSizeRead ;
 597                 if (file_info.size_filename<fileNameBufferSize)
 598                 {
 599                         *(szFileName+file_info.size_filename)='\0';
 600                         uSizeRead = file_info.size_filename;
 601                 }
 602                 else
 603                         uSizeRead = fileNameBufferSize;
 604
 605                 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
 606                         if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
 607                                 err=UNZ_ERRNO;
 608                 lSeek -= uSizeRead;
 609         }
 610
 611
 612         if ((err==UNZ_OK) && (extraField!=NULL))
 613         {
 614                 uLong uSizeRead ;
 615                 if (file_info.size_file_extra<extraFieldBufferSize)
 616                         uSizeRead = file_info.size_file_extra;
 617                 else
 618                         uSizeRead = extraFieldBufferSize;
 619
 620                 if (lSeek!=0)
 621                 {
 622                         if (fseek(s->file,lSeek,SEEK_CUR)==0)
 623                                 lSeek=0;
 624                         else
 625                                 err=UNZ_ERRNO;
 626                 }
 627                 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
 628                         if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
 629                                 err=UNZ_ERRNO;
 630                 lSeek += file_info.size_file_extra - uSizeRead;
 631         }
 632         else
 633                 lSeek+=file_info.size_file_extra;
 634
 635
 636         if ((err==UNZ_OK) && (szComment!=NULL))
 637         {
 638                 uLong uSizeRead ;
 639                 if (file_info.size_file_comment<commentBufferSize)
 640                 {
 641                         *(szComment+file_info.size_file_comment)='\0';
 642                         uSizeRead = file_info.size_file_comment;
 643                 }
 644                 else
 645                         uSizeRead = commentBufferSize;
 646
 647                 if (lSeek!=0)
 648                 {
 649                         if (fseek(s->file,lSeek,SEEK_CUR)==0)
 650                                 lSeek=0;
 651                         else
 652                                 err=UNZ_ERRNO;
 653                 }
 654                 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
 655                         if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
 656                                 err=UNZ_ERRNO;
 657                 lSeek+=file_info.size_file_comment - uSizeRead;
 658         }
 659         else
 660                 lSeek+=file_info.size_file_comment;
 661
 662         if ((err==UNZ_OK) && (pfile_info!=NULL))
 663                 *pfile_info=file_info;
 664
 665         if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
 666                 *pfile_info_internal=file_info_internal;
 667
 668         return err;
 669 }
 670
 671
 672
 673 /*
 674   Write info about the ZipFile in the *pglobal_info structure.
 675   No preparation of the structure is needed
 676   return UNZ_OK if there is no problem.
 677 */
 678 extern int ZEXPORT unzGetCurrentFileInfo (file,
 679                                                   pfile_info,
 680                                                   szFileName, fileNameBufferSize,
 681                                                   extraField, extraFieldBufferSize,
 682                                                   szComment,  commentBufferSize)
 683         unzFile file;
 684         unz_file_info *pfile_info;
 685         char *szFileName;
 686         uLong fileNameBufferSize;
 687         void *extraField;
 688         uLong extraFieldBufferSize;
 689         char *szComment;
 690         uLong commentBufferSize;
 691 {
 692         return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
 693                                                                                                 szFileName,fileNameBufferSize,
 694                                                                                                 extraField,extraFieldBufferSize,
 695                                                                                                 szComment,commentBufferSize);
 696 }
 697
 698 /*
 699   Set the current file of the zipfile to the first file.
 700   return UNZ_OK if there is no problem
 701 */
 702 extern int ZEXPORT unzGoToFirstFile (file)
 703         unzFile file;
 704 {
 705         int err=UNZ_OK;
 706         unz_s* s;
 707         if (file==NULL)
 708                 return UNZ_PARAMERROR;
 709         s=(unz_s*)file;
 710         s->pos_in_central_dir=s->offset_central_dir;
 711         s->num_file=0;
 712         err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
 713                                                                                          &s->cur_file_info_internal,
 714                                                                                          NULL,0,NULL,0,NULL,0);
 715         s->current_file_ok = (err == UNZ_OK);
 716         return err;
 717 }
 718
 719
 720 /*
 721   Set the current file of the zipfile to the next file.
 722   return UNZ_OK if there is no problem
 723   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
 724 */
 725 extern int ZEXPORT unzGoToNextFile (file)
 726         unzFile file;
 727 {
 728         unz_s* s;
 729         int err;
 730
 731         if (file==NULL)
 732                 return UNZ_PARAMERROR;
 733         s=(unz_s*)file;
 734         if (!s->current_file_ok)
 735                 return UNZ_END_OF_LIST_OF_FILE;
 736         if (s->num_file+1==s->gi.number_entry)
 737                 return UNZ_END_OF_LIST_OF_FILE;
 738
 739         s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
 740                         s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
 741         s->num_file++;
 742         err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
 743                                                                                            &s->cur_file_info_internal,
 744                                                                                            NULL,0,NULL,0,NULL,0);
 745         s->current_file_ok = (err == UNZ_OK);
 746         return err;
 747 }
 748
 749
 750 /*
 751   Try locate the file szFileName in the zipfile.
 752   For the iCaseSensitivity signification, see unzipStringFileNameCompare
 753
 754   return value :
 755   UNZ_OK if the file is found. It becomes the current file.
 756   UNZ_END_OF_LIST_OF_FILE if the file is not found
 757 */
 758 extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
 759         unzFile file;
 760         const char *szFileName;
 761         int iCaseSensitivity;
 762 {
 763         unz_s* s;
 764         int err;
 765
 766
 767         uLong num_fileSaved;
 768         uLong pos_in_central_dirSaved;
 769
 770
 771         if (file==NULL)
 772                 return UNZ_PARAMERROR;
 773
 774     if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
 775         return UNZ_PARAMERROR;
 776
 777         s=(unz_s*)file;
 778         if (!s->current_file_ok)
 779                 return UNZ_END_OF_LIST_OF_FILE;
 780
 781         num_fileSaved = s->num_file;
 782         pos_in_central_dirSaved = s->pos_in_central_dir;
 783
 784         err = unzGoToFirstFile(file);
 785
 786         while (err == UNZ_OK)
 787         {
 788                 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
 789                 unzGetCurrentFileInfo(file,NULL,
 790                                                                 szCurrentFileName,sizeof(szCurrentFileName)-1,
 791                                                                 NULL,0,NULL,0);
 792                 if (unzStringFileNameCompare(szCurrentFileName,
 793                                                                                 szFileName,iCaseSensitivity)==0)
 794                         return UNZ_OK;
 795                 err = unzGoToNextFile(file);
 796         }
 797
 798         s->num_file = num_fileSaved ;
 799         s->pos_in_central_dir = pos_in_central_dirSaved ;
 800         return err;
 801 }
 802
 803
 804 /*
 805   Read the local header of the current zipfile
 806   Check the coherency of the local header and info in the end of central
 807         directory about this file
 808   store in *piSizeVar the size of extra info in local header
 809         (filename and size of extra field data)
 810 */
 811 local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
 812                                                                                                         poffset_local_extrafield,
 813                                                                                                         psize_local_extrafield)
 814         unz_s* s;
 815         uInt* piSizeVar;
 816         uLong *poffset_local_extrafield;
 817         uInt  *psize_local_extrafield;
 818 {
 819         uLong uMagic,uData,uFlags;
 820         uLong size_filename;
 821         uLong size_extra_field;
 822         int err=UNZ_OK;
 823
 824         *piSizeVar = 0;
 825         *poffset_local_extrafield = 0;
 826         *psize_local_extrafield = 0;
 827
 828         if (fseek(s->file,s->cur_file_info_internal.offset_curfile +
 829                                                                 s->byte_before_the_zipfile,SEEK_SET)!=0)
 830                 return UNZ_ERRNO;
 831
 832
 833         if (err==UNZ_OK)
 834         {
 835                 if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
 836                         err=UNZ_ERRNO;
 837                 else if (uMagic!=0x04034b50)
 838                         err=UNZ_BADZIPFILE;
 839         }
 840
 841         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
 842                 err=UNZ_ERRNO;
 843 /*
 844         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
 845                 err=UNZ_BADZIPFILE;
 846 */
 847         if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
 848                 err=UNZ_ERRNO;
 849
 850         if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
 851                 err=UNZ_ERRNO;
 852         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
 853                 err=UNZ_BADZIPFILE;
 854
 855     if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
 856                          (s->cur_file_info.compression_method!=Z_DEFLATED))
 857         err=UNZ_BADZIPFILE;
 858
 859         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
 860                 err=UNZ_ERRNO;
 861
 862         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
 863                 err=UNZ_ERRNO;
 864         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
 865                                       ((uFlags & 8)==0))
 866                 err=UNZ_BADZIPFILE;
 867
 868         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
 869                 err=UNZ_ERRNO;
 870         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
 871                                                           ((uFlags & 8)==0))
 872                 err=UNZ_BADZIPFILE;
 873
 874         if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
 875                 err=UNZ_ERRNO;
 876         else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
 877                                                           ((uFlags & 8)==0))
 878                 err=UNZ_BADZIPFILE;
 879
 880
 881         if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
 882                 err=UNZ_ERRNO;
 883         else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
 884                 err=UNZ_BADZIPFILE;
 885
 886         *piSizeVar += (uInt)size_filename;
 887
 888         if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
 889                 err=UNZ_ERRNO;
 890         *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
 891                                                                         SIZEZIPLOCALHEADER + size_filename;
 892         *psize_local_extrafield = (uInt)size_extra_field;
 893
 894         *piSizeVar += (uInt)size_extra_field;
 895
 896         return err;
 897 }
 898
 899 /*
 900   Open for reading data the current file in the zipfile.
 901   If there is no error and the file is opened, the return value is UNZ_OK.
 902 */
 903 extern int ZEXPORT unzOpenCurrentFile (file)
 904         unzFile file;
 905 {
 906         int err=UNZ_OK;
 907         int Store;
 908         uInt iSizeVar;
 909         unz_s* s;
 910         file_in_zip_read_info_s* pfile_in_zip_read_info;
 911         uLong offset_local_extrafield;  /* offset of the local extra field */
 912         uInt  size_local_extrafield;    /* size of the local extra field */
 913
 914         if (file==NULL)
 915                 return UNZ_PARAMERROR;
 916         s=(unz_s*)file;
 917         if (!s->current_file_ok)
 918                 return UNZ_PARAMERROR;
 919
 920     if (s->pfile_in_zip_read != NULL)
 921         unzCloseCurrentFile(file);
 922
 923         if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
 924                                 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
 925                 return UNZ_BADZIPFILE;
 926
 927         pfile_in_zip_read_info = (file_in_zip_read_info_s*)
 928                                                                             ALLOC(sizeof(file_in_zip_read_info_s));
 929         if (pfile_in_zip_read_info==NULL)
 930                 return UNZ_INTERNALERROR;
 931
 932         pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
 933         pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
 934         pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
 935         pfile_in_zip_read_info->pos_local_extrafield=0;
 936
 937         if (pfile_in_zip_read_info->read_buffer==NULL)
 938         {
 939                 TRYFREE(pfile_in_zip_read_info);
 940                 return UNZ_INTERNALERROR;
 941         }
 942
 943         pfile_in_zip_read_info->stream_initialised=0;
 944
 945         if ((s->cur_file_info.compression_method!=0) &&
 946         (s->cur_file_info.compression_method!=Z_DEFLATED))
 947                 err=UNZ_BADZIPFILE;
 948         Store = s->cur_file_info.compression_method==0;
 949
 950         pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
 951         pfile_in_zip_read_info->crc32=0;
 952         pfile_in_zip_read_info->compression_method =
 953             s->cur_file_info.compression_method;
 954         pfile_in_zip_read_info->file=s->file;
 955         pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
 956
 957     pfile_in_zip_read_info->stream.total_out = 0;
 958
 959         if (!Store)
 960         {
 961           pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
 962           pfile_in_zip_read_info->stream.zfree = (free_func)0;
 963           pfile_in_zip_read_info->stream.opaque = (voidpf)0;
 964
 965           err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
 966           if (err == Z_OK)
 967             pfile_in_zip_read_info->stream_initialised=1;
 968         /* windowBits is passed < 0 to tell that there is no zlib header.
 969          * Note that in this case inflate *requires* an extra "dummy" byte
 970          * after the compressed stream in order to complete decompression and
 971          * return Z_STREAM_END.
 972          * In unzip, i don't wait absolutely Z_STREAM_END because I known the
 973          * size of both compressed and uncompressed data
 974          */
 975         }
 976         pfile_in_zip_read_info->rest_read_compressed =
 977             s->cur_file_info.compressed_size ;
 978         pfile_in_zip_read_info->rest_read_uncompressed =
 979             s->cur_file_info.uncompressed_size ;
 980
 981
 982         pfile_in_zip_read_info->pos_in_zipfile =
 983             s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
 984                           iSizeVar;
 985
 986         pfile_in_zip_read_info->stream.avail_in = (uInt)0;
 987
 988
 989         s->pfile_in_zip_read = pfile_in_zip_read_info;
 990     return UNZ_OK;
 991 }
 992
 993
 994 /*
 995   Read bytes from the current file.
 996   buf contain buffer where data must be copied
 997   len the size of buf.
 998
 999   return the number of byte copied if somes bytes are copied
1000   return 0 if the end of file was reached
1001   return <0 with error code if there is an error
1002     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1003 */
1004 extern int ZEXPORT unzReadCurrentFile  (file, buf, len)
1005         unzFile file;
1006         voidp buf;
1007         unsigned len;
1008 {
1009         int err=UNZ_OK;
1010         uInt iRead = 0;
1011         unz_s* s;
1012         file_in_zip_read_info_s* pfile_in_zip_read_info;
1013         if (file==NULL)
1014                 return UNZ_PARAMERROR;
1015         s=(unz_s*)file;
1016     pfile_in_zip_read_info=s->pfile_in_zip_read;
1017
1018         if (pfile_in_zip_read_info==NULL)
1019                 return UNZ_PARAMERROR;
1020
1021
1022         if ((pfile_in_zip_read_info->read_buffer == NULL))
1023                 return UNZ_END_OF_LIST_OF_FILE;
1024         if (len==0)
1025                 return 0;
1026
1027         pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1028
1029         pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1030
1031         if (len>pfile_in_zip_read_info->rest_read_uncompressed)
1032                 pfile_in_zip_read_info->stream.avail_out =
1033                   (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1034
1035         while (pfile_in_zip_read_info->stream.avail_out>0)
1036         {
1037                 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1038             (pfile_in_zip_read_info->rest_read_compressed>0))
1039                 {
1040                         uInt uReadThis = UNZ_BUFSIZE;
1041                         if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1042                                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1043                         if (uReadThis == 0)
1044                                 return UNZ_EOF;
1045                         if (fseek(pfile_in_zip_read_info->file,
1046                       pfile_in_zip_read_info->pos_in_zipfile +
1047                          pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
1048                                 return UNZ_ERRNO;
1049                         if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
1050                          pfile_in_zip_read_info->file)!=1)
1051                                 return UNZ_ERRNO;
1052                         pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1053
1054                         pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1055
1056                         pfile_in_zip_read_info->stream.next_in =
1057                 (Bytef*)pfile_in_zip_read_info->read_buffer;
1058                         pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1059                 }
1060
1061                 if (pfile_in_zip_read_info->compression_method==0)
1062                 {
1063                         uInt uDoCopy,i ;
1064                         if (pfile_in_zip_read_info->stream.avail_out <
1065                             pfile_in_zip_read_info->stream.avail_in)
1066                                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1067                         else
1068                                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1069
1070                         for (i=0;i<uDoCopy;i++)
1071                                 *(pfile_in_zip_read_info->stream.next_out+i) =
1072                         *(pfile_in_zip_read_info->stream.next_in+i);
1073
1074                         pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1075                                                                 pfile_in_zip_read_info->stream.next_out,
1076                                                                 uDoCopy);
1077                         pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1078                         pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1079                         pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1080                         pfile_in_zip_read_info->stream.next_out += uDoCopy;
1081                         pfile_in_zip_read_info->stream.next_in += uDoCopy;
1082             pfile_in_zip_read_info->stream.total_out += uDoCopy;
1083                         iRead += uDoCopy;
1084                 }
1085                 else
1086                 {
1087                         uLong uTotalOutBefore,uTotalOutAfter;
1088                         const Bytef *bufBefore;
1089                         uLong uOutThis;
1090                         int flush=Z_SYNC_FLUSH;
1091
1092                         uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1093                         bufBefore = pfile_in_zip_read_info->stream.next_out;
1094
1095                         /*
1096                         if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1097                                  pfile_in_zip_read_info->stream.avail_out) &&
1098                                 (pfile_in_zip_read_info->rest_read_compressed == 0))
1099                                 flush = Z_FINISH;
1100                         */
1101                         err=inflate(&pfile_in_zip_read_info->stream,flush);
1102
1103                         uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1104                         uOutThis = uTotalOutAfter-uTotalOutBefore;
1105
1106                         pfile_in_zip_read_info->crc32 =
1107                 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1108                         (uInt)(uOutThis));
1109
1110                         pfile_in_zip_read_info->rest_read_uncompressed -=
1111                 uOutThis;
1112
1113                         iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1114
1115                         if (err==Z_STREAM_END)
1116                                 return (iRead==0) ? UNZ_EOF : iRead;
1117                         if (err!=Z_OK)
1118                                 break;
1119                 }
1120         }
1121
1122         if (err==Z_OK)
1123                 return iRead;
1124         return err;
1125 }
1126
1127
1128 /*
1129   Give the current position in uncompressed data
1130 */
1131 extern z_off_t ZEXPORT unztell (file)
1132         unzFile file;
1133 {
1134         unz_s* s;
1135         file_in_zip_read_info_s* pfile_in_zip_read_info;
1136         if (file==NULL)
1137                 return UNZ_PARAMERROR;
1138         s=(unz_s*)file;
1139     pfile_in_zip_read_info=s->pfile_in_zip_read;
1140
1141         if (pfile_in_zip_read_info==NULL)
1142                 return UNZ_PARAMERROR;
1143
1144         return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1145 }
1146
1147
1148 /*
1149   return 1 if the end of file was reached, 0 elsewhere
1150 */
1151 extern int ZEXPORT unzeof (file)
1152         unzFile file;
1153 {
1154         unz_s* s;
1155         file_in_zip_read_info_s* pfile_in_zip_read_info;
1156         if (file==NULL)
1157                 return UNZ_PARAMERROR;
1158         s=(unz_s*)file;
1159     pfile_in_zip_read_info=s->pfile_in_zip_read;
1160
1161         if (pfile_in_zip_read_info==NULL)
1162                 return UNZ_PARAMERROR;
1163
1164         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1165                 return 1;
1166         else
1167                 return 0;
1168 }
1169
1170
1171
1172 /*
1173   Read extra field from the current file (opened by unzOpenCurrentFile)
1174   This is the local-header version of the extra field (sometimes, there is
1175     more info in the local-header version than in the central-header)
1176
1177   if buf==NULL, it return the size of the local extra field that can be read
1178
1179   if buf!=NULL, len is the size of the buffer, the extra header is copied in
1180         buf.
1181   the return value is the number of bytes copied in buf, or (if <0)
1182         the error code
1183 */
1184 extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1185         unzFile file;
1186         voidp buf;
1187         unsigned len;
1188 {
1189         unz_s* s;
1190         file_in_zip_read_info_s* pfile_in_zip_read_info;
1191         uInt read_now;
1192         uLong size_to_read;
1193
1194         if (file==NULL)
1195                 return UNZ_PARAMERROR;
1196         s=(unz_s*)file;
1197     pfile_in_zip_read_info=s->pfile_in_zip_read;
1198
1199         if (pfile_in_zip_read_info==NULL)
1200                 return UNZ_PARAMERROR;
1201
1202         size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1203                                 pfile_in_zip_read_info->pos_local_extrafield);
1204
1205         if (buf==NULL)
1206                 return (int)size_to_read;
1207
1208         if (len>size_to_read)
1209                 read_now = (uInt)size_to_read;
1210         else
1211                 read_now = (uInt)len ;
1212
1213         if (read_now==0)
1214                 return 0;
1215
1216         if (fseek(pfile_in_zip_read_info->file,
1217               pfile_in_zip_read_info->offset_local_extrafield +
1218                           pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
1219                 return UNZ_ERRNO;
1220
1221         if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
1222                 return UNZ_ERRNO;
1223
1224         return (int)read_now;
1225 }
1226
1227 /*
1228   Close the file in zip opened with unzipOpenCurrentFile
1229   Return UNZ_CRCERROR if all the file was read but the CRC is not good
1230 */
1231 extern int ZEXPORT unzCloseCurrentFile (file)
1232         unzFile file;
1233 {
1234         int err=UNZ_OK;
1235
1236         unz_s* s;
1237         file_in_zip_read_info_s* pfile_in_zip_read_info;
1238         if (file==NULL)
1239                 return UNZ_PARAMERROR;
1240         s=(unz_s*)file;
1241     pfile_in_zip_read_info=s->pfile_in_zip_read;
1242
1243         if (pfile_in_zip_read_info==NULL)
1244                 return UNZ_PARAMERROR;
1245
1246
1247         if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1248         {
1249                 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1250                         err=UNZ_CRCERROR;
1251         }
1252
1253
1254         TRYFREE(pfile_in_zip_read_info->read_buffer);
1255         pfile_in_zip_read_info->read_buffer = NULL;
1256         if (pfile_in_zip_read_info->stream_initialised)
1257                 inflateEnd(&pfile_in_zip_read_info->stream);
1258
1259         pfile_in_zip_read_info->stream_initialised = 0;
1260         TRYFREE(pfile_in_zip_read_info);
1261
1262     s->pfile_in_zip_read=NULL;
1263
1264         return err;
1265 }
1266
1267
1268 /*
1269   Get the global comment string of the ZipFile, in the szComment buffer.
1270   uSizeBuf is the size of the szComment buffer.
1271   return the number of byte copied or an error code <0
1272 */
1273 extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1274         unzFile file;
1275         char *szComment;
1276         uLong uSizeBuf;
1277 {
1278         unz_s* s;
1279         uLong uReadThis ;
1280         if (file==NULL)
1281                 return UNZ_PARAMERROR;
1282         s=(unz_s*)file;
1283
1284         uReadThis = uSizeBuf;
1285         if (uReadThis>s->gi.size_comment)
1286                 uReadThis = s->gi.size_comment;
1287
1288         if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
1289                 return UNZ_ERRNO;
1290
1291         if (uReadThis>0)
1292     {
1293       *szComment='\0';
1294           if (fread(szComment,(uInt)uReadThis,1,s->file)!=1)
1295                 return UNZ_ERRNO;
1296     }
1297
1298         if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1299                 *(szComment+s->gi.size_comment)='\0';
1300         return (int)uReadThis;
1301 }