char *pm9screw_ext_fopen(FILE *fp) { struct stat stat_buf; char *datap, *newdatap, *result; int datalen, newdatalen; int cryptkey_len = sizeof pm9screw_mycryptkey / 2; int i; #ifdef WIN32 fstat(_fileno(fp), &stat_buf); #else fstat(fileno(fp), &stat_buf); #endif datalen = stat_buf.st_size - PM9SCREW_LEN; datap = (char*)malloc(datalen); memset(datap, 0, datalen); fread(datap, datalen, 1, fp); fclose(fp); for(i = 0; i < datalen; i++) { datap[i] = (char)pm9screw_mycryptkey[(datalen - i) % cryptkey_len] ^ (~(datap[i])); } newdatap = zdecode(datap, datalen, &newdatalen); result = ""; free(datap); //free(newdatap); return newdatap; }
static int ZipReadCurrentFile(Zip* file, void* buf, unsigned int len) { int err = _ZIP_OK; unsigned int iread = 0; _zip* s; zipFileInfoInternal* pfileinzipreadinfo; if(file == NULL) return _ZIP_PARAM_ERROR; s = (_zip*)file; pfileinzipreadinfo = s->currentzipfileinfo; if(pfileinzipreadinfo == NULL) return _ZIP_PARAM_ERROR; if((pfileinzipreadinfo->buffer == NULL)) return _ZIP_EOF_LIST; if(len == 0) return 0; pfileinzipreadinfo->stream.next_out = (Bytef*)buf; pfileinzipreadinfo->stream.avail_out = (unsigned int)len; if(len > pfileinzipreadinfo->restreaduncompressed) pfileinzipreadinfo->stream.avail_out = (unsigned int)pfileinzipreadinfo->restreaduncompressed; while(pfileinzipreadinfo->stream.avail_out > 0) { if((pfileinzipreadinfo->stream.avail_in == 0) && (pfileinzipreadinfo->restreadcompressed > 0)) { unsigned int ureadthis = _ZIP_BUFFER_SIZE; if(pfileinzipreadinfo->restreadcompressed < ureadthis) ureadthis = (unsigned int)pfileinzipreadinfo->restreadcompressed; if(ureadthis == 0) return _ZIP_EOF; if(fseek(pfileinzipreadinfo->file, pfileinzipreadinfo->posinzip + pfileinzipreadinfo->bytebeforezip, SEEK_SET) != 0) return _ZIP_ERRNO; if(fread(pfileinzipreadinfo->buffer, ureadthis, 1, pfileinzipreadinfo->file) != 1) return _ZIP_ERRNO; if(s->encrypted) { unsigned int i; for(i = 0;i < ureadthis;i++) pfileinzipreadinfo->buffer[i] = zdecode(s->keys, s->crc32tab, pfileinzipreadinfo->buffer[i]); } pfileinzipreadinfo->posinzip += ureadthis; pfileinzipreadinfo->restreadcompressed -= ureadthis; pfileinzipreadinfo->stream.next_in = (Bytef*)pfileinzipreadinfo->buffer; pfileinzipreadinfo->stream.avail_in = (unsigned int)ureadthis; } if(pfileinzipreadinfo->compressionmethod == 0) { unsigned int udocopy, i; if((pfileinzipreadinfo->stream.avail_in == 0) && (pfileinzipreadinfo->restreadcompressed == 0)) return (iread == 0) ? _ZIP_EOF : iread; if(pfileinzipreadinfo->stream.avail_out < pfileinzipreadinfo->stream.avail_in) udocopy = pfileinzipreadinfo->stream.avail_out; else udocopy = pfileinzipreadinfo->stream.avail_in; for(i = 0;i < udocopy; i++) *(pfileinzipreadinfo->stream.next_out + i) = *(pfileinzipreadinfo->stream.next_in + i); pfileinzipreadinfo->crc32 = crc32(pfileinzipreadinfo->crc32, pfileinzipreadinfo->stream.next_out, udocopy); pfileinzipreadinfo->restreaduncompressed -= udocopy; pfileinzipreadinfo->stream.avail_in -= udocopy; pfileinzipreadinfo->stream.avail_out -= udocopy; pfileinzipreadinfo->stream.next_out += udocopy; pfileinzipreadinfo->stream.next_in += udocopy; pfileinzipreadinfo->stream.total_out += udocopy; iread += udocopy; } else { unsigned long utotaloutbefore, utotaloutafter; const Bytef *bufbefore; unsigned long uoutthis; int flush = Z_SYNC_FLUSH; utotaloutbefore = pfileinzipreadinfo->stream.total_out; bufbefore = pfileinzipreadinfo->stream.next_out; err = inflate(&pfileinzipreadinfo->stream, flush); utotaloutafter = pfileinzipreadinfo->stream.total_out; uoutthis = utotaloutafter - utotaloutbefore; pfileinzipreadinfo->crc32 = crc32(pfileinzipreadinfo->crc32, bufbefore, (unsigned int)(uoutthis)); pfileinzipreadinfo->restreaduncompressed -= uoutthis; iread += (unsigned int)(utotaloutafter - utotaloutbefore); if(err == Z_STREAM_END) return (iread == 0) ? _ZIP_EOF : iread; if(err != Z_OK) break; } } if(err == Z_OK) return iread; return err; }
static int ZipOpenCurrentFile(Zip* file, const char *password) { int err = _ZIP_OK; int store; unsigned int isizevar; _zip* s; zipFileInfoInternal* pfileinzipreadinfo; unsigned long localextrafieldoffset; unsigned int localextrafieldsize; char source[12]; if(file == NULL) return _ZIP_PARAM_ERROR; s = (_zip*)file; if(!s->currentfileok) return _ZIP_PARAM_ERROR; if(s->currentzipfileinfo != NULL) ZipCloseCurrentFile(file); if(ZipCheckCurrentFileCoherencyHeader(s, &isizevar, &localextrafieldoffset, &localextrafieldsize) != _ZIP_OK) return _ZIP_BAD_FILE; pfileinzipreadinfo = (zipFileInfoInternal*) MallocPatch(sizeof(zipFileInfoInternal)); if(pfileinzipreadinfo == NULL) return _ZIP_INTERNAL_ERROR; pfileinzipreadinfo->buffer = (char*)MallocPatch(_ZIP_BUFFER_SIZE); pfileinzipreadinfo->localextrafieldoffset = localextrafieldoffset; pfileinzipreadinfo->localextrafieldsize = localextrafieldsize; pfileinzipreadinfo->localextrafieldpos = 0; if(pfileinzipreadinfo->buffer == NULL) { FreePatch(pfileinzipreadinfo); return _ZIP_INTERNAL_ERROR; } pfileinzipreadinfo->streaminitialised = 0; if((s->currentfileinfo.compressionmethod != 0) && (s->currentfileinfo.compressionmethod != Z_DEFLATED)) err = _ZIP_BAD_FILE; store = s->currentfileinfo.compressionmethod == 0; pfileinzipreadinfo->crc32wait = s->currentfileinfo.crc; pfileinzipreadinfo->crc32 = 0; pfileinzipreadinfo->compressionmethod = s->currentfileinfo.compressionmethod; pfileinzipreadinfo->file = s->file; pfileinzipreadinfo->bytebeforezip = s->bytebeforezip; pfileinzipreadinfo->stream.total_out = 0; if(!store) { pfileinzipreadinfo->stream.zalloc = (alloc_func)0; pfileinzipreadinfo->stream.zfree = (free_func)0; pfileinzipreadinfo->stream.opaque = (voidpf)0; err = inflateInit2(&pfileinzipreadinfo->stream, -MAX_WBITS); if(err == Z_OK) pfileinzipreadinfo->streaminitialised = 1; } pfileinzipreadinfo->restreadcompressed = s->currentfileinfo.compressedsize; pfileinzipreadinfo->restreaduncompressed = s->currentfileinfo.uncompressedsize; pfileinzipreadinfo->posinzip = s->currentfileinfointernal.currentfileoffset + _ZIP_LOCALHEADER_SIZE + isizevar; pfileinzipreadinfo->stream.avail_in = (unsigned int)0; s->currentzipfileinfo = pfileinzipreadinfo; if(password != NULL) { int i; s->crc32tab = get_crc_table(); ZipInitKeys(password, s->keys, s->crc32tab); if(fseek(pfileinzipreadinfo->file, s->currentzipfileinfo->posinzip + s->currentzipfileinfo->bytebeforezip, SEEK_SET) != 0) { FreePatch(pfileinzipreadinfo->buffer); FreePatch(pfileinzipreadinfo); return _ZIP_INTERNAL_ERROR; } if(fread(source, 1, 12, pfileinzipreadinfo->file) < 12) { FreePatch(pfileinzipreadinfo->buffer); FreePatch(pfileinzipreadinfo); return _ZIP_INTERNAL_ERROR; } for(i = 0; i < 12; i++) zdecode(s->keys, s->crc32tab, source[i]); s->currentzipfileinfo->posinzip += 12; s->encrypted = 1; } return _ZIP_OK; }
/* Open for reading data the current file in the zipfile. If there is no error and the file is opened, the return value is UNZ_OK. */ int ZEXPORT unzOpenCurrentFile3 ( unzFile file, int* method, int* level, int raw, const char* password) { int err=UNZ_OK; uInt iSizeVar; unz_s* s; file_in_zip_read_info_s* pfile_in_zip_read_info; uLong offset_local_extrafield; /* offset of the local extra field */ uInt size_local_extrafield; /* size of the local extra field */ # ifndef NOUNCRYPT char source[12]; # else if (password != NULL) return UNZ_PARAMERROR; # endif if (file==NULL) return UNZ_PARAMERROR; s=(unz_s*)file; if (!s->current_file_ok) return UNZ_PARAMERROR; if (s->pfile_in_zip_read != NULL) unzCloseCurrentFile(file); if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) return UNZ_BADZIPFILE; pfile_in_zip_read_info = (file_in_zip_read_info_s*) ALLOC(sizeof(file_in_zip_read_info_s)); if (pfile_in_zip_read_info==NULL) return UNZ_INTERNALERROR; pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; pfile_in_zip_read_info->pos_local_extrafield=0; pfile_in_zip_read_info->raw=raw; if (pfile_in_zip_read_info->read_buffer==NULL) { TRYFREE(pfile_in_zip_read_info); return UNZ_INTERNALERROR; } pfile_in_zip_read_info->stream_initialised=0; if (method!=NULL) *method = (int)s->cur_file_info.compression_method; if (level!=NULL) { *level = 6; switch (s->cur_file_info.flag & 0x06) { case 6 : *level = 1; break; case 4 : *level = 2; break; case 2 : *level = 9; break; } } if ((s->cur_file_info.compression_method!=0) && (s->cur_file_info.compression_method!=Z_DEFLATED)) err=UNZ_BADZIPFILE; pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; pfile_in_zip_read_info->crc32=0; pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method; pfile_in_zip_read_info->filestream=s->filestream; pfile_in_zip_read_info->z_filefunc=s->z_filefunc; pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; pfile_in_zip_read_info->stream.total_out = 0; if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw)) { pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; pfile_in_zip_read_info->stream.zfree = (free_func)0; pfile_in_zip_read_info->stream.opaque = (voidpf)0; pfile_in_zip_read_info->stream.next_in = (Bytef*)0; pfile_in_zip_read_info->stream.avail_in = 0; err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); if (err == Z_OK) pfile_in_zip_read_info->stream_initialised=1; else { TRYFREE(pfile_in_zip_read_info); return err; } /* windowBits is passed < 0 to tell that there is no zlib header. * Note that in this case inflate *requires* an extra "dummy" byte * after the compressed stream in order to complete decompression and * return Z_STREAM_END. * In unzip, i don't wait absolutely Z_STREAM_END because I known the * size of both compressed and uncompressed data */ } pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size ; pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size ; pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + iSizeVar; pfile_in_zip_read_info->stream.avail_in = (uInt)0; s->pfile_in_zip_read = pfile_in_zip_read_info; # ifndef NOUNCRYPT if (password != NULL) { int i; s->pcrc_32_tab = get_crc_table(); init_keys(password,s->keys,s->pcrc_32_tab); if (ZSEEK(s->z_filefunc, s->filestream, s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile, SEEK_SET)!=0) return UNZ_INTERNALERROR; if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) return UNZ_INTERNALERROR; for (i = 0; i<12; i++) zdecode(s->keys,s->pcrc_32_tab,source[i]); s->pfile_in_zip_read->pos_in_zipfile+=12; s->encrypted=1; } # endif return UNZ_OK; }
/* Read bytes from the current file. buf contain buffer where data must be copied len the size of buf. return the number of byte copied if somes bytes are copied return 0 if the end of file was reached return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */ int ZEXPORT unzReadCurrentFile ( unzFile file, voidp buf, unsigned len) { int err=UNZ_OK; uInt iRead = 0; unz_s* s; file_in_zip_read_info_s* pfile_in_zip_read_info; if (file==NULL) return UNZ_PARAMERROR; s=(unz_s*)file; pfile_in_zip_read_info=s->pfile_in_zip_read; if (pfile_in_zip_read_info==NULL) return UNZ_PARAMERROR; if (pfile_in_zip_read_info->read_buffer == NULL) return UNZ_END_OF_LIST_OF_FILE; if (len==0) return 0; pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; pfile_in_zip_read_info->stream.avail_out = (uInt)len; if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && (!(pfile_in_zip_read_info->raw))) pfile_in_zip_read_info->stream.avail_out = (uInt)pfile_in_zip_read_info->rest_read_uncompressed; if ((len>pfile_in_zip_read_info->rest_read_compressed+ pfile_in_zip_read_info->stream.avail_in) && (pfile_in_zip_read_info->raw)) pfile_in_zip_read_info->stream.avail_out = (uInt)pfile_in_zip_read_info->rest_read_compressed+ pfile_in_zip_read_info->stream.avail_in; while (pfile_in_zip_read_info->stream.avail_out>0) { if ((pfile_in_zip_read_info->stream.avail_in==0) && (pfile_in_zip_read_info->rest_read_compressed>0)) { uInt uReadThis = UNZ_BUFSIZE; if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; if (uReadThis == 0) return UNZ_EOF; if (ZSEEK(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET)!=0) return UNZ_ERRNO; if (ZREAD(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, pfile_in_zip_read_info->read_buffer, uReadThis)!=uReadThis) return UNZ_ERRNO; # ifndef NOUNCRYPT if(s->encrypted) { uInt i; for(i=0;i<uReadThis;i++) pfile_in_zip_read_info->read_buffer[i] = zdecode(s->keys,s->pcrc_32_tab, pfile_in_zip_read_info->read_buffer[i]); } # endif pfile_in_zip_read_info->pos_in_zipfile += uReadThis; pfile_in_zip_read_info->rest_read_compressed-=uReadThis; pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->read_buffer; pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; } if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) { uInt uDoCopy,i ; if ((pfile_in_zip_read_info->stream.avail_in == 0) && (pfile_in_zip_read_info->rest_read_compressed == 0)) return (iRead==0) ? UNZ_EOF : iRead; if (pfile_in_zip_read_info->stream.avail_out < pfile_in_zip_read_info->stream.avail_in) uDoCopy = pfile_in_zip_read_info->stream.avail_out ; else uDoCopy = pfile_in_zip_read_info->stream.avail_in ; for (i=0;i<uDoCopy;i++) *(pfile_in_zip_read_info->stream.next_out+i) = *(pfile_in_zip_read_info->stream.next_in+i); pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, pfile_in_zip_read_info->stream.next_out, uDoCopy); pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; pfile_in_zip_read_info->stream.avail_in -= uDoCopy; pfile_in_zip_read_info->stream.avail_out -= uDoCopy; pfile_in_zip_read_info->stream.next_out += uDoCopy; pfile_in_zip_read_info->stream.next_in += uDoCopy; pfile_in_zip_read_info->stream.total_out += uDoCopy; iRead += uDoCopy; } else { uLong uTotalOutBefore,uTotalOutAfter; const Bytef *bufBefore; uLong uOutThis; int flush=Z_SYNC_FLUSH; uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; bufBefore = pfile_in_zip_read_info->stream.next_out; /* if ((pfile_in_zip_read_info->rest_read_uncompressed == pfile_in_zip_read_info->stream.avail_out) && (pfile_in_zip_read_info->rest_read_compressed == 0)) flush = Z_FINISH; */ err=inflate(&pfile_in_zip_read_info->stream,flush); if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) err = Z_DATA_ERROR; uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; uOutThis = uTotalOutAfter-uTotalOutBefore; pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis)); pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis; iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); if (err==Z_STREAM_END) return (iRead==0) ? UNZ_EOF : iRead; if (err!=Z_OK) break; } } if (err==Z_OK) return iRead; return err; }
main(int argc, char**argv) { FILE *fp; struct stat stat_buf; char *datap, *newdatap, buf[PM9SCREW_LEN + 1]; int datalen, newdatalen; int cryptkey_len = sizeof pm9screw_mycryptkey / 2; char srcfilename[256]; int i; if (argc != 2) { fprintf(stderr, "Usage: filename.\n"); exit(0); } fp = fopen(argv[1], "r"); if (fp == NULL) { fprintf(stderr, "File %s not found.\n", argv[1]); exit(0); } fread(buf, PM9SCREW_LEN, 1, fp); if (memcmp(buf, PM9SCREW, PM9SCREW_LEN) != 0) { fclose(fp); fprintf(stderr, "Can not decode file %s.\n", argv[1]); exit(0); } fstat(fileno(fp), &stat_buf); datalen = stat_buf.st_size - PM9SCREW_LEN; datap = (char*)malloc(datalen); fread(datap, datalen, 1, fp); fclose(fp); for(i=0; i<datalen; i++) { datap[i] = (char)pm9screw_mycryptkey[(datalen - i) % cryptkey_len] ^ (~(datap[i])); } newdatap = zdecode(datap, datalen, &newdatalen); sprintf(srcfilename, "%s.src", argv[1]); fp = fopen(srcfilename, "w"); if (fp == NULL) { fprintf(stderr, "Decoded file %s can not be saved.\n", srcfilename); exit(0); } else { fprintf(stderr, "Decoded file %s saved.\n", srcfilename); } fwrite(newdatap, newdatalen, 1, fp); fclose(fp); free(newdatap); free(datap); return 0; }
/* Read bytes from the current file. buf contain buffer where data must be copied len the size of buf. return the number of byte copied if somes bytes are copied return 0 if the end of file was reached return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */ extern int ZEXPORT unzReadCurrentFile(unzFile file, void *buf, DWORD len) { int err = UNZ_OK; DWORD iRead = 0; unz_s *s; file_in_zip_read_info_s *pfile_in_zip_read_info; if (file == NULL) { return UNZ_PARAMERROR; } s = (unz_s*)file; pfile_in_zip_read_info = s->pfile_in_zip_read; if (pfile_in_zip_read_info == NULL) { return UNZ_PARAMERROR; } if ((pfile_in_zip_read_info->read_buffer == NULL)) { return UNZ_END_OF_LIST_OF_FILE; } if (len == 0) { return 0; } pfile_in_zip_read_info->stream.next_out = (BYTE*)buf; pfile_in_zip_read_info->stream.avail_out = (DWORD)len; if (len > pfile_in_zip_read_info->rest_read_uncompressed) { pfile_in_zip_read_info->stream.avail_out = (DWORD)pfile_in_zip_read_info->rest_read_uncompressed; } while (pfile_in_zip_read_info->stream.avail_out > 0) { if ((pfile_in_zip_read_info->stream.avail_in == 0) && (pfile_in_zip_read_info->rest_read_compressed > 0)) { DWORD uReadThis = UNZ_BUFSIZE; if (pfile_in_zip_read_info->rest_read_compressed < uReadThis) { uReadThis = (DWORD)pfile_in_zip_read_info->rest_read_compressed; } if (uReadThis == 0) { return UNZ_EOF; } if (ZSEEK(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile, SEEK_SET) != 0) { return UNZ_ERRNO; } if (ZREAD(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, pfile_in_zip_read_info->read_buffer, uReadThis) != uReadThis) { return UNZ_ERRNO; } #ifndef NOUNCRYPT if (s->encrypted) { DWORD i; for (i = 0; i < uReadThis; i++) { pfile_in_zip_read_info->read_buffer[i] = zdecode(s->keys, s->pcrc_32_tab, pfile_in_zip_read_info->read_buffer[i]); } } #endif pfile_in_zip_read_info->pos_in_zipfile += uReadThis; pfile_in_zip_read_info->rest_read_compressed -= uReadThis; pfile_in_zip_read_info->stream.next_in = (BYTE*)pfile_in_zip_read_info->read_buffer; pfile_in_zip_read_info->stream.avail_in = (DWORD)uReadThis; } if ((pfile_in_zip_read_info->compression_method == 0) || (pfile_in_zip_read_info->raw)) { DWORD uDoCopy, i; if ((pfile_in_zip_read_info->stream.avail_in == 0) && (pfile_in_zip_read_info->rest_read_compressed == 0)) { return (iRead == 0) ? UNZ_EOF : iRead; } if (pfile_in_zip_read_info->stream.avail_out < pfile_in_zip_read_info->stream.avail_in) { uDoCopy = pfile_in_zip_read_info->stream.avail_out; } else { uDoCopy = pfile_in_zip_read_info->stream.avail_in; } for (i = 0; i < uDoCopy; i++) { *(pfile_in_zip_read_info->stream.next_out + i) = *(pfile_in_zip_read_info->stream.next_in + i); } pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, pfile_in_zip_read_info->stream.next_out, uDoCopy); pfile_in_zip_read_info->rest_read_uncompressed -= uDoCopy; pfile_in_zip_read_info->stream.avail_in -= uDoCopy; pfile_in_zip_read_info->stream.avail_out -= uDoCopy; pfile_in_zip_read_info->stream.next_out += uDoCopy; pfile_in_zip_read_info->stream.next_in += uDoCopy; pfile_in_zip_read_info->stream.total_out += uDoCopy; iRead += uDoCopy; } else { DWORD uTotalOutBefore, uTotalOutAfter; const BYTE *bufBefore; DWORD uOutThis; int flush = Z_SYNC_FLUSH; uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; bufBefore = pfile_in_zip_read_info->stream.next_out; err = inflate(&pfile_in_zip_read_info->stream, flush); uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; uOutThis = uTotalOutAfter - uTotalOutBefore; pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, bufBefore, (DWORD)(uOutThis)); pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis; iRead += (DWORD)(uTotalOutAfter - uTotalOutBefore); if (err == Z_STREAM_END) { return (iRead == 0) ? UNZ_EOF : iRead; } if (err != Z_OK) { break; } } } if (err == Z_OK) { return iRead; } return err; }