bool PtexReader::readZipBlock(void* data, int zipsize, int unzipsize) { void* buff = alloca(BlockSize); _zstream.next_out = (Bytef*) data; _zstream.avail_out = unzipsize; while (1) { int size = (zipsize < BlockSize) ? zipsize : BlockSize; zipsize -= size; if (!readBlock(buff, size)) break; _zstream.next_in = (Bytef*) buff; _zstream.avail_in = size; int zresult = inflate(&_zstream, zipsize ? Z_NO_FLUSH : Z_FINISH); if (zresult == Z_STREAM_END) break; if (zresult != Z_OK) { setError("PtexReader error: unzip failed, file corrupt"); inflateReset(&_zstream); return 0; } } int total = _zstream.total_out; inflateReset(&_zstream); return total == unzipsize; }
int inflate_buffer(struct zlib_state *zlib, unsigned char *in, size_t inlen, unsigned char *out, size_t outlen, uint32_t original_crc) { int ret; uint32_t crc; zlib->s.avail_in = inlen; zlib->s.next_in = in; crc = crc32(0L, Z_NULL, 0); do { zlib->s.avail_out = outlen; zlib->s.next_out = out; ret = inflate(&zlib->s, Z_NO_FLUSH); if (ret < 0) { inflateReset(&zlib->s); return -1; } crc = crc32(crc, out, outlen - zlib->s.avail_out); } while (ret != Z_STREAM_END); inflateReset(&zlib->s); return crc == original_crc ? 0 : -1; }
/* not used even though it's defined ... */ int Sg_InflateReset(SgZStream *strm, int windowBits) { int r; #ifdef HAVE_ZLIB_INFLATE_RESET2 if (windowBits < 0) { r = inflateReset(strm->strm); } else { r = inflateReset2(strm->strm, windowBits); } #else /* to avoid not to use platform zlib */ r = inflateReset(strm->strm); #endif return r; }
/* * Setup state for decoding a strip. */ static int ZIPPreDecode(TIFF* tif, uint16 s) { static const char module[] = "ZIPPreDecode"; ZIPState* sp = DecoderState(tif); (void) s; assert(sp != NULL); if( (sp->state & ZSTATE_INIT_DECODE) == 0 ) tif->tif_setupdecode( tif ); sp->stream.next_in = tif->tif_rawdata; assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised, we need to simplify this code to reflect a ZLib that is likely updated to deal with 8byte memory sizes, though this code will respond appropriately even before we simplify it */ sp->stream.avail_in = (uInt) tif->tif_rawcc; if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc) { TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); return (0); } return (inflateReset(&sp->stream) == Z_OK); }
static bfd_boolean decompress_contents (bfd_byte *compressed_buffer, bfd_size_type compressed_size, bfd_byte *uncompressed_buffer, bfd_size_type uncompressed_size) { z_stream strm; int rc; /* It is possible the section consists of several compressed buffers concatenated together, so we uncompress in a loop. */ strm.zalloc = NULL; strm.zfree = NULL; strm.opaque = NULL; strm.avail_in = compressed_size - 12; strm.next_in = (Bytef*) compressed_buffer + 12; strm.avail_out = uncompressed_size; rc = inflateInit (&strm); while (strm.avail_in > 0) { if (rc != Z_OK) return FALSE; strm.next_out = ((Bytef*) uncompressed_buffer + (uncompressed_size - strm.avail_out)); rc = inflate (&strm, Z_FINISH); if (rc != Z_STREAM_END) return FALSE; rc = inflateReset (&strm); } rc = inflateEnd (&strm); return rc == Z_OK && strm.avail_out == 0; }
int GzipBuf::init( int type, int level ) { int ret; if ( type == GZIP_INFLATE ) m_type = GZIP_INFLATE; else m_type = GZIP_DEFLATE; if ( m_type == GZIP_DEFLATE ) { if ( !m_zstr.state ) ret = deflateInit2 (&m_zstr, level, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY); else { ret = deflateReset( &m_zstr ); } } else { if ( !m_zstr.state ) ret = inflateInit2( &m_zstr, 15+16 ); else { ret = inflateReset( &m_zstr ); } } return ret; }
bool WebSocketInflater::addBytes(const char* data, size_t length) { if (!length) return false; size_t consumedSoFar = 0; while (consumedSoFar < length) { size_t writePosition = m_buffer.size(); m_buffer.grow(writePosition + bufferIncrementUnit); size_t availableCapacity = m_buffer.size() - writePosition; size_t remainingLength = length - consumedSoFar; setStreamParameter(m_stream.get(), data + consumedSoFar, remainingLength, m_buffer.data() + writePosition, availableCapacity); int result = inflate(m_stream.get(), Z_NO_FLUSH); consumedSoFar += remainingLength - m_stream->avail_in; m_buffer.shrink(writePosition + availableCapacity - m_stream->avail_out); if (result == Z_BUF_ERROR) continue; if (result == Z_STREAM_END) { // Received a block with BFINAL set to 1. Reset decompression state. if (inflateReset(m_stream.get()) != Z_OK) return false; continue; } if (result != Z_OK) return false; ASSERT(remainingLength > m_stream->avail_in); } ASSERT(consumedSoFar == length); return true; }
void InflaterIOChannel::reset() { m_error = 0; m_at_eof = 0; const int err = inflateReset(&m_zstream); if (err != Z_OK) { log_error("inflater_impl::reset() inflateReset() returned %d", err); m_error = 1; return; } m_zstream.next_in = 0; m_zstream.avail_in = 0; m_zstream.next_out = 0; m_zstream.avail_out = 0; // Rewind the underlying stream. if (!m_in->seek(m_initial_stream_pos)) { std::stringstream ss; ss << "inflater_impl::reset: unable to seek underlying " "stream to position " << m_initial_stream_pos; throw ParserException(ss.str()); } m_logical_stream_pos = m_initial_stream_pos; }
void BgzfReader::nextBlock() { uInt oldAvailOut = stream.avail_out; stream.avail_out = 0; while(true) { if(0 == stream.avail_in) { qint64 returnedValue = ioAdapter.readBlock(buffer, sizeof(buffer)); if(-1 == returnedValue) { coreLog.error(QString("in BgzfReader::nextBlock, failed to read %1 bytes from ioAdapter, after %2 bytes already read. %3") .arg(sizeof(buffer)) .arg(ioAdapter.bytesRead()) .arg(ioAdapter.errorString())); throw IOException(BAMDbiPlugin::tr("Can't read input")); } else if(0 == returnedValue) { endOfFile = true; break; } else { stream.avail_in = returnedValue; stream.next_in = (Bytef *)buffer; } } int returnedValue = inflate(&stream, Z_SYNC_FLUSH); if(Z_STREAM_END == returnedValue) { headerOffset = ioAdapter.bytesRead() - stream.avail_in; inflateReset(&stream); } else if(Z_BUF_ERROR == returnedValue) { break; } else if(Z_OK != returnedValue) { coreLog.error(QString("in BgzfReader::nextBlock, failed to decompress %1 bytes, after %2 raw bytes already read") .arg(sizeof(buffer)) .arg(ioAdapter.bytesRead())); throw InvalidFormatException(BAMDbiPlugin::tr("Can't decompress data")); } } stream.avail_out = oldAvailOut; }
extern "C" void Java_java_util_zip_Inflater_resetImpl(JNIEnv* env, jobject, jlong handle) { NativeZipStream* stream = toNativeZipStream(handle); int err = inflateReset(&stream->stream); if (err != Z_OK) { throwExceptionForZlibError(env, "java/lang/IllegalArgumentException", err, stream); } }
int squashfs_uncompress_block (void *dst, int dstlen, void *src, int srclen) { int err; #ifdef CONFIG_SQUASHFS_LZMA SizeT InProcessed; int bytes; if((err = LzmaDecode(&state, src, srclen, &InProcessed, dst, dstlen, &bytes)) != LZMA_RESULT_OK) { printf("lzma_fs returned unexpected result 0x%x\n", err); return 0; } return bytes; #else inflateReset (&stream); stream.next_in = src; stream.avail_in = srclen; stream.next_out = dst; stream.avail_out = dstlen; err = inflate (&stream, Z_FINISH); if ((err==Z_OK)||(err==Z_STREAM_END)) return dstlen-stream.avail_out; else return 0; #endif }
//--------------------------------------------------------------------- void DeflateStream::seek( size_t pos ) { if (!mIsCompressedValid) { mCompressedStream->seek(pos); return; } if (getAccessMode() & WRITE) { mTmpWriteStream->seek(pos); } else { if (pos == 0) { mCurrentPos = 0; mZStream->next_in = mTmp; mCompressedStream->seek(0); mZStream->avail_in = mCompressedStream->read(mTmp, OGRE_DEFLATE_TMP_SIZE); inflateReset(mZStream); } else { skip(pos - tell()); } } }
int fn_gunzip_init() { int ret=Z_OK; if(inzstream==0) { // open a stream and leave it open just like with deflate above inzstream=frontier_mem_alloc(sizeof(*inzstream)); if(inzstream==0) return Z_MEM_ERROR; inzstream->zalloc=fn_zalloc; inzstream->zfree=fn_zfree; inzstream->opaque=0; inzstream->next_in=Z_NULL; inzstream->avail_in=0; ret=inflateInit(inzstream); if(ret!=Z_OK) { fn_incleanup(); return ret; } } else { // reuse existing stream ret=inflateReset(inzstream); if(ret!=Z_OK) { fn_incleanup(); return ret; } } return ret; }
static inline int cloop_read_block(BDRVCloopState *s,int block_num) { if(s->current_block != block_num) { int ret; uint32_t bytes = s->offsets[block_num+1]-s->offsets[block_num]; lseek(s->fd, s->offsets[block_num], SEEK_SET); ret = read(s->fd, s->compressed_block, bytes); if (ret != bytes) return -1; s->zstream.next_in = s->compressed_block; s->zstream.avail_in = bytes; s->zstream.next_out = s->uncompressed_block; s->zstream.avail_out = s->block_size; ret = inflateReset(&s->zstream); if(ret != Z_OK) return -1; ret = inflate(&s->zstream, Z_FINISH); if(ret != Z_STREAM_END || s->zstream.total_out != s->block_size) return -1; s->current_block = block_num; } return 0; }
static FT_Error ft_gzip_file_reset( FT_GZipFile zip ) { FT_Stream stream = zip->source; FT_Error error; if ( !FT_STREAM_SEEK( zip->start ) ) { z_stream* zstream = &zip->zstream; inflateReset( zstream ); zstream->avail_in = 0; zstream->next_in = zip->input; zstream->avail_out = 0; zstream->next_out = zip->buffer; zip->limit = zip->buffer + FT_GZIP_BUFFER_SIZE; zip->cursor = zip->limit; zip->pos = 0; } return error; }
//--------------------------------------------------------------------- void DeflateStream::seek( size_t pos ) { if (!mIsCompressedValid) { mCompressedStream->seek(pos); return; } if (getAccessMode() & WRITE) { mTmpWriteStream->seek(pos); } else { if (pos == 0) { mCurrentPos = 0; mZStream->next_in = mTmp; mCompressedStream->seek(0); mZStream->avail_in = static_cast<uint>(mCompressedStream->read(mTmp, getAvailInForSinglePass())); inflateReset(mZStream); } else { skip(pos - tell()); } } }
static int uncompress2(void *out, unsigned long *out_size, void *in, unsigned long in_size) { static z_stream z; int ret = 0; if (z.zalloc == NULL) { // XXX: one-time leak here.. z.next_in = Z_NULL; z.avail_in = 0; z.zalloc = Z_NULL; z.zfree = Z_NULL; z.opaque = Z_NULL; ret = inflateInit2(&z, -15); } else ret = inflateReset(&z); if (ret != Z_OK) return ret; z.next_in = in; z.avail_in = in_size; z.next_out = out; z.avail_out = *out_size; ret = inflate(&z, Z_NO_FLUSH); //inflateEnd(&z); *out_size -= z.avail_out; return ret == 1 ? 0 : ret; }
int SpdyZlibFilter::init( int isInflator, int verSpdy ) { int ret; m_isInflator = isInflator; assert( (uint)verSpdy < sizeof( s_dicts ) / sizeof( char * ) ); m_version = verSpdy; if ( isInflator ) { if ( m_stream.state ) ret = inflateReset( &m_stream ); else ret = inflateInit2( &m_stream, 15 ); } else { if ( m_stream.state ) ret = deflateReset( &m_stream ); else ret = deflateInit( &m_stream, -1 ); ret = deflateSetDictionary( &m_stream, s_dicts[ m_version ], s_dictsLen[ m_version ] ); } return ret; }
void BgzfReader::seek(VirtualOffset offset) { if((offset.getCoffset() == headerOffset) && (offset.getUoffset() >= (int)stream.total_out)) { qint64 toSkip = offset.getUoffset() - stream.total_out; if(skip(toSkip) < toSkip) { coreLog.error(QString("in BgzfReader::seek, cannot seek to offset {coffset=%1,uoffset=%2}, failed to skip %3") .arg(offset.getCoffset()) .arg(offset.getUoffset()) .arg(toSkip)); throw InvalidFormatException(BAMDbiPlugin::tr("Unexpected end of file")); } } else { qint64 toSkipIo = offset.getCoffset() - ioAdapter.bytesRead(); if(!ioAdapter.skip(toSkipIo)) { coreLog.error(QString("in BgzfReader::seek, cannot seek to offset {coffset=%1,uoffset=%2}, ioAdapter failed to skip %3") .arg(offset.getCoffset()) .arg(offset.getUoffset()) .arg(toSkipIo)); throw IOException(BAMDbiPlugin::tr("Can't read input")); } stream.next_in = Z_NULL; stream.avail_in = 0; headerOffset = ioAdapter.bytesRead(); inflateReset(&stream); qint64 toSkip = offset.getUoffset(); if(skip(toSkip) < toSkip) { coreLog.error(QString("in BgzfReader::seek, cannot seek to offset {coffset=%1,uoffset=%2}, failed to skip %3 after ioAdapter skipped %4") .arg(offset.getCoffset()) .arg(offset.getUoffset()) .arg(toSkip) .arg(toSkipIo)); throw InvalidFormatException(BAMDbiPlugin::tr("Unexpected end of file")); } } endOfFile = false; }
nmsg_res nmsg_zbuf_inflate(nmsg_zbuf_t zb, size_t z_len, u_char *z_buf, size_t *u_len, u_char **u_buf) { int zret; uint32_t my_ulen; load_net32(z_buf, &my_ulen); z_buf += 4; *u_len = my_ulen; *u_buf = malloc(*u_len); if (*u_buf == NULL) return (nmsg_res_memfail); zb->zs.avail_in = z_len; zb->zs.next_in = z_buf; zb->zs.avail_out = *u_len; zb->zs.next_out = *u_buf; zret = inflate(&zb->zs, Z_NO_FLUSH); if (zret != Z_STREAM_END || zb->zs.avail_out != 0) { free(*u_buf); return (nmsg_res_failure); } assert(inflateReset(&zb->zs) == Z_OK); return (nmsg_res_success); }
char *Hub::inflate(char *data, size_t &length) { dynamicInflationBuffer.clear(); inflationStream.next_in = (Bytef *) data; inflationStream.avail_in = length; int err; do { inflationStream.next_out = (Bytef *) inflationBuffer; inflationStream.avail_out = LARGE_BUFFER_SIZE; err = ::inflate(&inflationStream, Z_FINISH); if (!inflationStream.avail_in) { break; } dynamicInflationBuffer.append(inflationBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out); } while (err == Z_BUF_ERROR); inflateReset(&inflationStream); if (err != Z_BUF_ERROR && err != Z_OK) { length = 0; return nullptr; } if (dynamicInflationBuffer.length()) { dynamicInflationBuffer.append(inflationBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out); length = dynamicInflationBuffer.length(); return (char *) dynamicInflationBuffer.data(); } length = LARGE_BUFFER_SIZE - inflationStream.avail_out; return inflationBuffer; }
static inline int cloop_read_block(BlockDriverState *bs, int block_num) { BDRVCloopState *s = bs->opaque; if (s->current_block != block_num) { int ret; uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num]; ret = bdrv_pread(bs->file->bs, s->offsets[block_num], s->compressed_block, bytes); if (ret != bytes) { return -1; } s->zstream.next_in = s->compressed_block; s->zstream.avail_in = bytes; s->zstream.next_out = s->uncompressed_block; s->zstream.avail_out = s->block_size; ret = inflateReset(&s->zstream); if (ret != Z_OK) { return -1; } ret = inflate(&s->zstream, Z_FINISH); if (ret != Z_STREAM_END || s->zstream.total_out != s->block_size) { return -1; } s->current_block = block_num; } return 0; }
//--------------------------------------------------------------------- void DeflateStream::init() { mpZStream = OGRE_ALLOC_T(z_stream, 1, MEMCATEGORY_GENERAL); mpZStream->zalloc = OgreZalloc; mpZStream->zfree = OgreZfree; if (getAccessMode() == READ) { mpTmp = (unsigned char*)OGRE_MALLOC(OGRE_DEFLATE_TMP_SIZE, MEMCATEGORY_GENERAL); size_t restorePoint = mCompressedStream->tell(); // read early chunk mpZStream->next_in = mpTmp; mpZStream->avail_in = mCompressedStream->read(mpTmp, OGRE_DEFLATE_TMP_SIZE); if (inflateInit(mpZStream) != Z_OK) { mIsCompressedValid = false; } else mIsCompressedValid = true; if (mIsCompressedValid) { // in fact, inflateInit on some implementations doesn't try to read // anything. We need to at least read something to test Bytef testOut[4]; size_t savedIn = mpZStream->avail_in; mpZStream->avail_out = 4; mpZStream->next_out = testOut; if (inflate(mpZStream, Z_SYNC_FLUSH) != Z_OK) mIsCompressedValid = false; // restore for reading mpZStream->avail_in = savedIn; mpZStream->next_in = mpTmp; inflateReset(mpZStream); } if (!mIsCompressedValid) { // Not compressed data! // Fail gracefully, fall back on reading the underlying stream direct destroy(); mCompressedStream->seek(restorePoint); } } else { // Write to temp file char tmpname[L_tmpnam]; tmpnam(tmpname); mTempFileName = tmpname; std::fstream *f = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)(); f->open(tmpname, std::ios::binary | std::ios::out); mTmpWriteStream = DataStreamPtr(OGRE_NEW FileStreamDataStream(f)); } }
static void resetDecoder(Gzb64* gzb64) { int zret = inflateReset(& gzb64->gz_decode_strm); if(zret < 0) zerr(zret); zret = BIO_reset(gzb64->b64_decoder); gzb64->decoded_last_chunk = false; if(DEBUG) printf("Decoder reset\n"); }
void InflatingStreamBuf::reset() { int rc = inflateReset(&_zstr); if (rc == Z_OK) _eof = false; else throw IOException(zError(rc)); }
void Java_at_yawk_rjoin_zlib_NZlib_reset(JNIEnv *env, jclass jc, jboolean inf, jlong stream) { int result; if (inf) { result = inflateReset((z_stream*) stream); } else { result = deflateReset((z_stream*) stream); } }
int zlib_decompress(void *src, uint64_t srclen, void *dst, uint64_t *dstlen, int level, uchar_t chdr, int btype, void *data) { int err; unsigned int slen, dlen; uint64_t _srclen = srclen; uint64_t _dstlen = *dstlen; uchar_t *dst1 = (uchar_t *)dst; uchar_t *src1 = (uchar_t *)src; z_stream *zs = (z_stream *)data; while (_srclen > 0) { if (_srclen > SINGLE_CALL_MAX) { slen = SINGLE_CALL_MAX; } else { slen = _srclen; } if (_dstlen > SINGLE_CALL_MAX) { dlen = SINGLE_CALL_MAX; } else { dlen = _dstlen; } zs->next_in = src1; zs->avail_in = slen; zs->next_out = dst1; zs->avail_out = dlen; err = inflate(zs, Z_NO_FLUSH); if (err != Z_OK && err != Z_STREAM_END) { zerr(err, 0); return (-1); } dst1 += (dlen - zs->avail_out); _dstlen -= (dlen - zs->avail_out); src1 += (slen - zs->avail_in); _srclen -= (slen - zs->avail_in); if (err == Z_STREAM_END) { if (_srclen > 0) { zerr(Z_DATA_ERROR, 0); return (-1); } else { break; } } } *dstlen = *dstlen - _dstlen; err = inflateReset(zs); if (err != Z_OK) { zerr(err, 1); return (-1); } return (0); }
/** * This function will rewind a real/zipped file. * * It seeks to the beginning of this file's data in the zip, * or the beginning of the file for a stat'fd. */ int zzip_rewind(ZZIP_FILE *fp) { ZZIP_DIR *dir; int err; if (! fp) return -1; if (! fp->dir) { /* stat fd */ fp->io->fd.seeks(fp->fd,0,SEEK_SET); return 0; } dir = fp->dir; /* * If this is other handle than previous, save current seek pointer */ if (dir->currentfp != fp) { if (zzip_file_saveoffset(dir->currentfp) < 0) { dir->errcode = ZZIP_DIR_SEEK; return -1; } else { dir->currentfp = fp; } } /* seek to beginning of this file */ if (fp->io->fd.seeks(dir->fd, fp->dataoffset, SEEK_SET) < 0) return -1; /* reset the inflate init stuff */ fp->restlen = fp->usize; fp->offset = fp->dataoffset; if (fp->method) { /* method == 8, deflate */ err = inflateReset(&fp->d_stream); if (err != Z_OK) { goto error; } /* start over at next inflate with a fresh read() */ fp->d_stream.avail_in = 0; fp->crestlen = fp->csize; } return 0; error: if (fp) zzip_file_close(fp); return err; }
/* Reinitialize the filter. */ static int s_zlibD_reset(stream_state * st) { stream_zlib_state *const ss = (stream_zlib_state *)st; if (inflateReset(&ss->dynamic->zstate) != Z_OK) return ERRC; /****** WRONG ******/ return 0; }
JNIEXPORT void JNICALL Java_com_velocitypowered_natives_compression_NativeZlibInflate_reset(JNIEnv *env, jobject obj, jlong ctx) { z_stream* stream = (z_stream*) ctx; int ret = inflateReset(stream); assert(ret == Z_OK); }