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