unzip/unzip.c

   1 #include "unzip.h"\r
   2 \r
   3 #include <stdlib.h>\r
   4 #include <string.h>\r
   5 #include <ctype.h>\r
   6 #include <assert.h>\r
   7 \r
   8 #include <zlib.h>\r
   9 \r
  10 /* public globals */\r
  11 //int   gUnzipQuiet = 0;                /* flag controls error messages */\r
  12 \r
  13 #define ERROR_CORRUPT "The zipfile seems to be corrupt, please check it"\r
  14 #define ERROR_FILESYSTEM "Your filesystem seems to be corrupt, please check it"\r
  15 #define ERROR_UNSUPPORTED "The format of this zipfile is not supported, please recompress it"\r
  16 \r
  17 #define INFLATE_INPUT_BUFFER_MAX 16384\r
  18 #ifndef MIN\r
  19 #define MIN(x,y) ((x)<(y)?(x):(y))\r
  20 #endif\r
  21 \r
  22 \r
  23 // notaz\r
  24 #if 1 //def __DEBUG_PRINT\r
  25 #define logerror printf\r
  26 #define errormsg(str1,def,fname) printf("%s: " #def ": " str1 "\n", fname);\r
  27 #else\r
  28 #define logerror(x...)\r
  29 #define errormsg(x...)\r
  30 #endif\r
  31 \r
  32 /* Print a error message */\r
  33 //void errormsg(const char* extmsg, const char* usermsg, const char* zipname) {\r
  34         /* Output to the user with no internal detail */\r
  35 //      if (!gUnzipQuiet)\r
  36 //              printf("Error in zipfile %s\n%s\n", zipname, usermsg);\r
  37         /* Output to log file with all informations */\r
  38 //      logerror("Error in zipfile %s: %s\n", zipname, extmsg);\r
  39 //      printf("Error in zipfile %s: %s\n", zipname, extmsg);\r
  40 //}\r
  41 \r
  42 /* -------------------------------------------------------------------------\r
  43    Unzip support\r
  44  ------------------------------------------------------------------------- */\r
  45 \r
  46 /* Use these to avoid structure padding and byte-ordering problems */\r
  47 static UINT16 read_word (char *buf) {\r
  48    unsigned char *ubuf = (unsigned char *) buf;\r
  49 \r
  50    return ((UINT16)ubuf[1] << 8) | (UINT16)ubuf[0];\r
  51 }\r
  52 \r
  53 /* Use these to avoid structure padding and byte-ordering problems */\r
  54 static UINT32 read_dword (char *buf) {\r
  55    unsigned char *ubuf = (unsigned char *) buf;\r
  56 \r
  57    return ((UINT32)ubuf[3] << 24) | ((UINT32)ubuf[2] << 16) | ((UINT32)ubuf[1] << 8) | (UINT32)ubuf[0];\r
  58 }\r
  59 \r
  60 /* Locate end-of-central-dir sig in buffer and return offset\r
  61    out:\r
  62         *offset offset of cent dir start in buffer\r
  63    return:\r
  64         ==0 not found\r
  65         !=0 found, *offset valid\r
  66 */\r
  67 static int ecd_find_sig (char *buffer, int buflen, int *offset)\r
  68 {\r
  69         static char ecdsig[] = { 'P', 'K', 0x05, 0x06 };\r
  70         int i;\r
  71         for (i=buflen-22; i>=0; i--) {\r
  72                 if (memcmp(buffer+i, ecdsig, 4) == 0) {\r
  73                         *offset = i;\r
  74                         return 1;\r
  75                 }\r
  76         }\r
  77         return 0;\r
  78 }\r
  79 \r
  80 /* Read ecd data in zip structure\r
  81    in:\r
  82      zip->fp, zip->length zip file\r
  83    out:\r
  84      zip->ecd, zip->ecd_length ecd data\r
  85 */\r
  86 static int ecd_read(ZIP* zip) {\r
  87         char* buf;\r
  88         int buf_length = 1024; /* initial buffer length */\r
  89 \r
  90         while (1) {\r
  91                 int offset;\r
  92 \r
  93                 if (buf_length > zip->length)\r
  94                         buf_length = zip->length;\r
  95 \r
  96                 if (fseek(zip->fp, zip->length - buf_length, SEEK_SET) != 0) {\r
  97                         return -1;\r
  98                 }\r
  99 \r
 100                 /* allocate buffer */\r
 101                 buf = (char*)malloc( buf_length );\r
 102                 if (!buf) {\r
 103                         return -1;\r
 104                 }\r
 105 \r
 106                 if (fread( buf, buf_length, 1, zip->fp ) != 1) {\r
 107                         free(buf);\r
 108                         return -1;\r
 109                 }\r
 110 \r
 111                 if (ecd_find_sig(buf, buf_length, &offset)) {\r
 112                         zip->ecd_length = buf_length - offset;\r
 113 \r
 114                         zip->ecd = (char*)malloc( zip->ecd_length );\r
 115                         if (!zip->ecd) {\r
 116                                 free(buf);\r
 117                                 return -1;\r
 118                         }\r
 119 \r
 120                         memcpy(zip->ecd, buf + offset, zip->ecd_length);\r
 121 \r
 122                         free(buf);\r
 123                         return 0;\r
 124                 }\r
 125 \r
 126                 free(buf);\r
 127 \r
 128                 if (buf_length < zip->length) {\r
 129                         /* double buffer */\r
 130                         buf_length = 2*buf_length;\r
 131 \r
 132                         logerror("Retry reading of zip ecd for %d bytes\n",buf_length);\r
 133 \r
 134                 } else {\r
 135                         return -1;\r
 136                 }\r
 137         }\r
 138 }\r
 139 \r
 140 /* offsets in end of central directory structure */\r
 141 #define ZIPESIG         0x00\r
 142 #define ZIPEDSK         0x04\r
 143 #define ZIPECEN         0x06\r
 144 #define ZIPENUM         0x08\r
 145 #define ZIPECENN        0x0a\r
 146 #define ZIPECSZ         0x0c\r
 147 #define ZIPEOFST        0x10\r
 148 #define ZIPECOML        0x14\r
 149 #define ZIPECOM         0x16\r
 150 \r
 151 /* offsets in central directory entry structure */\r
 152 #define ZIPCENSIG       0x0\r
 153 #define ZIPCVER         0x4\r
 154 #define ZIPCOS          0x5\r
 155 #define ZIPCVXT         0x6\r
 156 #define ZIPCEXOS        0x7\r
 157 #define ZIPCFLG         0x8\r
 158 #define ZIPCMTHD        0xa\r
 159 #define ZIPCTIM         0xc\r
 160 #define ZIPCDAT         0xe\r
 161 #define ZIPCCRC         0x10\r
 162 #define ZIPCSIZ         0x14\r
 163 #define ZIPCUNC         0x18\r
 164 #define ZIPCFNL         0x1c\r
 165 #define ZIPCXTL         0x1e\r
 166 #define ZIPCCML         0x20\r
 167 #define ZIPDSK          0x22\r
 168 #define ZIPINT          0x24\r
 169 #define ZIPEXT          0x26\r
 170 #define ZIPOFST         0x2a\r
 171 #define ZIPCFN          0x2e\r
 172 \r
 173 /* offsets in local file header structure */\r
 174 #define ZIPLOCSIG       0x00\r
 175 #define ZIPVER          0x04\r
 176 #define ZIPGENFLG       0x06\r
 177 #define ZIPMTHD         0x08\r
 178 #define ZIPTIME         0x0a\r
 179 #define ZIPDATE         0x0c\r
 180 #define ZIPCRC          0x0e\r
 181 #define ZIPSIZE         0x12\r
 182 #define ZIPUNCMP        0x16\r
 183 #define ZIPFNLN         0x1a\r
 184 #define ZIPXTRALN       0x1c\r
 185 #define ZIPNAME         0x1e\r
 186 \r
 187 /* Opens a zip stream for reading\r
 188    return:\r
 189      !=0 success, zip stream\r
 190      ==0 error\r
 191 */\r
 192 ZIP* openzip(const char* zipfile) {\r
 193         /* allocate */\r
 194         ZIP* zip = (ZIP*)malloc( sizeof(ZIP) );\r
 195         if (!zip) {\r
 196                 return 0;\r
 197         }\r
 198 \r
 199         /* open */\r
 200         zip->fp = fopen(zipfile, "rb");\r
 201         if (!zip->fp) {\r
 202                 errormsg ("Opening for reading", ERROR_FILESYSTEM, zipfile);\r
 203                 free(zip);\r
 204                 return 0;\r
 205         }\r
 206 \r
 207         /* go to end */\r
 208         if (fseek(zip->fp, 0L, SEEK_END) != 0) {\r
 209                 errormsg ("Seeking to end", ERROR_FILESYSTEM, zipfile);\r
 210                 fclose(zip->fp);\r
 211                 free(zip);\r
 212                 return 0;\r
 213         }\r
 214 \r
 215         /* get length */\r
 216         zip->length = ftell(zip->fp);\r
 217         if (zip->length < 0) {\r
 218                 errormsg ("Get file size", ERROR_FILESYSTEM, zipfile);\r
 219                 fclose(zip->fp);\r
 220                 free(zip);\r
 221                 return 0;\r
 222         }\r
 223         if (zip->length == 0) {\r
 224                 errormsg ("Empty file", ERROR_CORRUPT, zipfile);\r
 225                 fclose(zip->fp);\r
 226                 free(zip);\r
 227                 return 0;\r
 228         }\r
 229 \r
 230         /* read ecd data */\r
 231         if (ecd_read(zip)!=0) {\r
 232                 errormsg ("Reading ECD (end of central directory)", ERROR_CORRUPT, zipfile);\r
 233                 fclose(zip->fp);\r
 234                 free(zip);\r
 235                 return 0;\r
 236         }\r
 237 \r
 238         /* compile ecd info */\r
 239         zip->end_of_cent_dir_sig = read_dword (zip->ecd+ZIPESIG);\r
 240         zip->number_of_this_disk = read_word (zip->ecd+ZIPEDSK);\r
 241         zip->number_of_disk_start_cent_dir = read_word (zip->ecd+ZIPECEN);\r
 242         zip->total_entries_cent_dir_this_disk = read_word (zip->ecd+ZIPENUM);\r
 243         zip->total_entries_cent_dir = read_word (zip->ecd+ZIPECENN);\r
 244         zip->size_of_cent_dir = read_dword (zip->ecd+ZIPECSZ);\r
 245         zip->offset_to_start_of_cent_dir = read_dword (zip->ecd+ZIPEOFST);\r
 246         zip->zipfile_comment_length = read_word (zip->ecd+ZIPECOML);\r
 247         zip->zipfile_comment = zip->ecd+ZIPECOM;\r
 248 \r
 249         /* verify that we can work with this zipfile (no disk spanning allowed) */\r
 250         if ((zip->number_of_this_disk != zip->number_of_disk_start_cent_dir) ||\r
 251                 (zip->total_entries_cent_dir_this_disk != zip->total_entries_cent_dir) ||\r
 252                 (zip->total_entries_cent_dir < 1)) {\r
 253                 errormsg("Cannot span disks", ERROR_UNSUPPORTED, zipfile);\r
 254                 free(zip->ecd);\r
 255                 fclose(zip->fp);\r
 256                 free(zip);\r
 257                 return 0;\r
 258         }\r
 259 \r
 260         if (fseek(zip->fp, zip->offset_to_start_of_cent_dir, SEEK_SET)!=0) {\r
 261                 errormsg ("Seeking to central directory", ERROR_CORRUPT, zipfile);\r
 262                 free(zip->ecd);\r
 263                 fclose(zip->fp);\r
 264                 free(zip);\r
 265                 return 0;\r
 266         }\r
 267 \r
 268         /* read from start of central directory */\r
 269         zip->cd = (char*)malloc( zip->size_of_cent_dir );\r
 270         if (!zip->cd) {\r
 271                 free(zip->ecd);\r
 272                 fclose(zip->fp);\r
 273                 free(zip);\r
 274                 return 0;\r
 275         }\r
 276 \r
 277         if (fread(zip->cd, zip->size_of_cent_dir, 1, zip->fp)!=1) {\r
 278                 errormsg ("Reading central directory", ERROR_CORRUPT, zipfile);\r
 279                 free(zip->cd);\r
 280                 free(zip->ecd);\r
 281                 fclose(zip->fp);\r
 282                 free(zip);\r
 283                 return 0;\r
 284         }\r
 285 \r
 286         /* reset ent */\r
 287         zip->ent.name = 0;\r
 288 \r
 289         /* rewind */\r
 290         zip->cd_pos = 0;\r
 291 \r
 292         /* file name */\r
 293         zip->zip = (char*)malloc(strlen(zipfile)+1);\r
 294         if (!zip->zip) {\r
 295                 free(zip->cd);\r
 296                 free(zip->ecd);\r
 297                 fclose(zip->fp);\r
 298                 free(zip);\r
 299                 return 0;\r
 300         }\r
 301         strcpy(zip->zip, zipfile);\r
 302 \r
 303         return zip;\r
 304 }\r
 305 \r
 306 /* Reads the current entry from a zip stream\r
 307    in:\r
 308      zip opened zip\r
 309    return:\r
 310      !=0 success\r
 311      ==0 error\r
 312 */\r
 313 struct zipent* readzip(ZIP* zip) {\r
 314 \r
 315         /* end of directory */\r
 316         if (zip->cd_pos >= zip->size_of_cent_dir)\r
 317                 return 0;\r
 318 \r
 319         /* compile zipent info */\r
 320         zip->ent.cent_file_header_sig = read_dword (zip->cd+zip->cd_pos+ZIPCENSIG);\r
 321         zip->ent.version_made_by = *(zip->cd+zip->cd_pos+ZIPCVER);\r
 322         zip->ent.host_os = *(zip->cd+zip->cd_pos+ZIPCOS);\r
 323         zip->ent.version_needed_to_extract = *(zip->cd+zip->cd_pos+ZIPCVXT);\r
 324         zip->ent.os_needed_to_extract = *(zip->cd+zip->cd_pos+ZIPCEXOS);\r
 325         zip->ent.general_purpose_bit_flag = read_word (zip->cd+zip->cd_pos+ZIPCFLG);\r
 326         zip->ent.compression_method = read_word (zip->cd+zip->cd_pos+ZIPCMTHD);\r
 327         zip->ent.last_mod_file_time = read_word (zip->cd+zip->cd_pos+ZIPCTIM);\r
 328         zip->ent.last_mod_file_date = read_word (zip->cd+zip->cd_pos+ZIPCDAT);\r
 329         zip->ent.crc32 = read_dword (zip->cd+zip->cd_pos+ZIPCCRC);\r
 330         zip->ent.compressed_size = read_dword (zip->cd+zip->cd_pos+ZIPCSIZ);\r
 331         zip->ent.uncompressed_size = read_dword (zip->cd+zip->cd_pos+ZIPCUNC);\r
 332         zip->ent.filename_length = read_word (zip->cd+zip->cd_pos+ZIPCFNL);\r
 333         zip->ent.extra_field_length = read_word (zip->cd+zip->cd_pos+ZIPCXTL);\r
 334         zip->ent.file_comment_length = read_word (zip->cd+zip->cd_pos+ZIPCCML);\r
 335         zip->ent.disk_number_start = read_word (zip->cd+zip->cd_pos+ZIPDSK);\r
 336         zip->ent.internal_file_attrib = read_word (zip->cd+zip->cd_pos+ZIPINT);\r
 337         zip->ent.external_file_attrib = read_dword (zip->cd+zip->cd_pos+ZIPEXT);\r
 338         zip->ent.offset_lcl_hdr_frm_frst_disk = read_dword (zip->cd+zip->cd_pos+ZIPOFST);\r
 339 \r
 340     /* check to see if filename length is illegally long (past the size of this directory\r
 341        entry) */\r
 342     if (zip->cd_pos + ZIPCFN + zip->ent.filename_length > zip->size_of_cent_dir)\r
 343     {\r
 344         errormsg("Invalid filename length in directory", ERROR_CORRUPT,zip->zip);\r
 345         return 0;\r
 346     }\r
 347 \r
 348         /* copy filename */\r
 349         free(zip->ent.name);\r
 350         zip->ent.name = (char*)malloc(zip->ent.filename_length + 1);\r
 351         memcpy(zip->ent.name, zip->cd+zip->cd_pos+ZIPCFN, zip->ent.filename_length);\r
 352         zip->ent.name[zip->ent.filename_length] = 0;\r
 353 \r
 354         /* skip to next entry in central dir */\r
 355         zip->cd_pos += ZIPCFN + zip->ent.filename_length + zip->ent.extra_field_length + zip->ent.file_comment_length;\r
 356 \r
 357         return &zip->ent;\r
 358 }\r
 359 \r
 360 /* Closes a zip stream */\r
 361 void closezip(ZIP* zip) {\r
 362         /* release all */\r
 363         free(zip->ent.name);\r
 364         free(zip->cd);\r
 365         free(zip->ecd);\r
 366         /* only if not suspended */\r
 367         if (zip->fp)\r
 368                 fclose(zip->fp);\r
 369         free(zip->zip);\r
 370         free(zip);\r
 371 }\r
 372 \r
 373 /* Suspend access to a zip file (release file handler)\r
 374    in:\r
 375       zip opened zip\r
 376    note:\r
 377      A suspended zip is automatically reopened at first call of\r
 378      readuncompressd() or readcompressed() functions\r
 379 */\r
 380 void suspendzip(ZIP* zip) {\r
 381         if (zip->fp) {\r
 382                 fclose(zip->fp);\r
 383                 zip->fp = 0;\r
 384         }\r
 385 }\r
 386 \r
 387 /* Revive a suspended zip file (reopen file handler)\r
 388    in:\r
 389      zip suspended zip\r
 390    return:\r
 391         zip success\r
 392         ==0 error (zip must be closed with closezip)\r
 393 */\r
 394 static ZIP* revivezip(ZIP* zip) {\r
 395         if (!zip->fp) {\r
 396                 zip->fp = fopen(zip->zip, "rb");\r
 397                 if (!zip->fp) {\r
 398                         return 0;\r
 399                 }\r
 400         }\r
 401         return zip;\r
 402 \r
 403 }\r
 404 \r
 405 /* Reset a zip stream to the first entry\r
 406    in:\r
 407      zip opened zip\r
 408    note:\r
 409      ZIP file must be opened and not suspended\r
 410 */\r
 411 void rewindzip(ZIP* zip) {\r
 412         zip->cd_pos = 0;\r
 413 }\r
 414 \r
 415 /* Seek zip->fp to compressed data\r
 416    return:\r
 417         ==0 success\r
 418         <0 error\r
 419 */\r
 420 int seekcompresszip(ZIP* zip, struct zipent* ent) {\r
 421         char buf[ZIPNAME];\r
 422         long offset;\r
 423 \r
 424         if (!zip->fp) {\r
 425                 if (!revivezip(zip))\r
 426                         return -1;\r
 427         }\r
 428 \r
 429         if (fseek(zip->fp, ent->offset_lcl_hdr_frm_frst_disk, SEEK_SET)!=0) {\r
 430                 errormsg ("Seeking to header", ERROR_CORRUPT, zip->zip);\r
 431                 return -1;\r
 432         }\r
 433 \r
 434         if (fread(buf, ZIPNAME, 1, zip->fp)!=1) {\r
 435                 errormsg ("Reading header", ERROR_CORRUPT, zip->zip);\r
 436                 return -1;\r
 437         }\r
 438 \r
 439         {\r
 440                 UINT16 filename_length = read_word (buf+ZIPFNLN);\r
 441                 UINT16 extra_field_length = read_word (buf+ZIPXTRALN);\r
 442 \r
 443                 /* calculate offset to data and fseek() there */\r
 444                 offset = ent->offset_lcl_hdr_frm_frst_disk + ZIPNAME + filename_length + extra_field_length;\r
 445 \r
 446                 if (fseek(zip->fp, offset, SEEK_SET) != 0) {\r
 447                         errormsg ("Seeking to compressed data", ERROR_CORRUPT, zip->zip);\r
 448                         return -1;\r
 449                 }\r
 450 \r
 451         }\r
 452 \r
 453         return 0;\r
 454 }\r
 455 \r
 456 /* Inflate a file\r
 457    in:\r
 458    in_file stream to inflate\r
 459    in_size size of the compressed data to read\r
 460    out_size size of decompressed data\r
 461    out:\r
 462    out_data buffer for decompressed data\r
 463    return:\r
 464    ==0 ok\r
 465 \r
 466    990525 rewritten for use with zlib MLR\r
 467 */\r
 468 static int inflate_file(FILE* in_file, unsigned in_size, unsigned char* out_data, unsigned out_size)\r
 469 {\r
 470     int err;\r
 471         unsigned char* in_buffer;\r
 472     z_stream d_stream; /* decompression stream */\r
 473 \r
 474     d_stream.zalloc = 0;\r
 475     d_stream.zfree = 0;\r
 476     d_stream.opaque = 0;\r
 477 \r
 478         d_stream.next_in  = 0;\r
 479         d_stream.avail_in = 0;\r
 480     d_stream.next_out = out_data;\r
 481     d_stream.avail_out = out_size;\r
 482 \r
 483     err = inflateInit2(&d_stream, -MAX_WBITS);\r
 484         /* windowBits is passed < 0 to tell that there is no zlib header.\r
 485          * Note that in this case inflate *requires* an extra "dummy" byte\r
 486          * after the compressed stream in order to complete decompression and\r
 487          * return Z_STREAM_END.\r
 488          */\r
 489     if (err != Z_OK)\r
 490         {\r
 491                 logerror("inflateInit error: %d\n", err);\r
 492         return -1;\r
 493         }\r
 494 \r
 495         in_buffer = (unsigned char*)malloc(INFLATE_INPUT_BUFFER_MAX+1);\r
 496         if (!in_buffer)\r
 497                 return -1;\r
 498 \r
 499     for (;;)\r
 500         {\r
 501                 if (in_size <= 0)\r
 502                 {\r
 503                         logerror("inflate error: compressed size too small\n");\r
 504                         free (in_buffer);\r
 505                         return -1;\r
 506                 }\r
 507                 d_stream.next_in  = in_buffer;\r
 508                 d_stream.avail_in = fread (in_buffer, 1, MIN(in_size, INFLATE_INPUT_BUFFER_MAX), in_file);\r
 509                 in_size -= d_stream.avail_in;\r
 510                 if (in_size == 0)\r
 511                         d_stream.avail_in++; /* add dummy byte at end of compressed data */\r
 512 \r
 513         err = inflate(&d_stream, Z_NO_FLUSH);\r
 514         if (err == Z_STREAM_END)\r
 515                         break;\r
 516                 if (err != Z_OK)\r
 517                 {\r
 518                         logerror("inflate error: %d\n", err);\r
 519                         free (in_buffer);\r
 520                         return -1;\r
 521                 }\r
 522     }\r
 523 \r
 524     err = inflateEnd(&d_stream);\r
 525         if (err != Z_OK)\r
 526         {\r
 527                 logerror("inflateEnd error: %d\n", err);\r
 528                 free (in_buffer);\r
 529                 return -1;\r
 530         }\r
 531 \r
 532         free (in_buffer);\r
 533 \r
 534         if ((d_stream.avail_out > 0) || (in_size > 0))\r
 535         {\r
 536                 logerror("zip size mismatch. %i\n", in_size);\r
 537                 return -1;\r
 538         }\r
 539 \r
 540         return 0;\r
 541 }\r
 542 \r
 543 /* Read compressed data\r
 544    out:\r
 545         data compressed data read\r
 546    return:\r
 547         ==0 success\r
 548         <0 error\r
 549 */\r
 550 int readcompresszip(ZIP* zip, struct zipent* ent, char* data) {\r
 551         int err = seekcompresszip(zip,ent);\r
 552         if (err!=0)\r
 553                 return err;\r
 554 \r
 555         if (fread(data, ent->compressed_size, 1, zip->fp)!=1) {\r
 556                 errormsg ("Reading compressed data", ERROR_CORRUPT, zip->zip);\r
 557                 return -1;\r
 558         }\r
 559 \r
 560         return 0;\r
 561 }\r
 562 \r
 563 /* Read UNcompressed data\r
 564    out:\r
 565         data UNcompressed data\r
 566    return:\r
 567         ==0 success\r
 568         <0 error\r
 569 */\r
 570 int readuncompresszip(ZIP* zip, struct zipent* ent, char* data) {\r
 571         if (ent->compression_method == 0x0000) {\r
 572                 /* file is not compressed, simply stored */\r
 573 \r
 574                 /* check if size are equal */\r
 575                 if (ent->compressed_size != ent->uncompressed_size) {\r
 576                         errormsg("Wrong uncompressed size in store compression", ERROR_CORRUPT,zip->zip);\r
 577                         return -3;\r
 578                 }\r
 579 \r
 580                 return readcompresszip(zip,ent,data);\r
 581         } else if (ent->compression_method == 0x0008) {\r
 582                 /* file is compressed using "Deflate" method */\r
 583                 if (ent->version_needed_to_extract > 0x14) {\r
 584                         errormsg("Version too new", ERROR_UNSUPPORTED,zip->zip);\r
 585                         return -2;\r
 586                 }\r
 587 \r
 588                 if (ent->os_needed_to_extract != 0x00) {\r
 589                         errormsg("OS not supported", ERROR_UNSUPPORTED,zip->zip);\r
 590                         return -2;\r
 591                 }\r
 592 \r
 593                 if (ent->disk_number_start != zip->number_of_this_disk) {\r
 594                         errormsg("Cannot span disks", ERROR_UNSUPPORTED,zip->zip);\r
 595                         return -2;\r
 596                 }\r
 597 \r
 598                 /* read compressed data */\r
 599                 if (seekcompresszip(zip,ent)!=0) {\r
 600                         return -1;\r
 601                 }\r
 602 \r
 603                 /* configure inflate */\r
 604                 if (inflate_file( zip->fp, ent->compressed_size, (unsigned char*)data, ent->uncompressed_size))\r
 605                 {\r
 606                         errormsg("Inflating compressed data", ERROR_CORRUPT, zip->zip);\r
 607                         return -3;\r
 608                 }\r
 609 \r
 610                 return 0;\r
 611         } else {\r
 612                 errormsg("Compression method unsupported", ERROR_UNSUPPORTED, zip->zip);\r
 613                 return -2;\r
 614         }\r
 615 }\r