コード例 #1
0
ファイル: PtexReader.cpp プロジェクト: rgba32/brdf
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;
}
コード例 #2
0
ファイル: inflate.c プロジェクト: mferland/libzc
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;
}
コード例 #3
0
/* 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;
}
コード例 #4
0
ファイル: tif_zip.c プロジェクト: GrokImageCompression/grok
/*
 * 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);
}
コード例 #5
0
ファイル: compress.c プロジェクト: BackupGGCode/propgcc
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;
}
コード例 #6
0
ファイル: gzipbuf.cpp プロジェクト: ewwink/openlitespeed
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;
}
コード例 #7
0
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;
}
コード例 #8
0
ファイル: zlib_adapter.cpp プロジェクト: diocles/gnash
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;
}
コード例 #9
0
ファイル: BgzfReader.cpp プロジェクト: m-angelov/ugene
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;
}
コード例 #10
0
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);
    }
}
コード例 #11
0
ファイル: uncompress.c プロジェクト: cidermole/wndr3800-uboot
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
}
コード例 #12
0
    //---------------------------------------------------------------------
	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());
			}
		}		
	}
コード例 #13
0
ファイル: fn-zlib.c プロジェクト: fermitools/frontier
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;
}
コード例 #14
0
ファイル: block-cloop.c プロジェクト: doniexun/MemCheck
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;
}
コード例 #15
0
ファイル: ftgzip.c プロジェクト: bowlofstew/Aquaria
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;
}
コード例 #16
0
ファイル: OgreDeflate.cpp プロジェクト: wjwwood/ogre
 //---------------------------------------------------------------------
 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());
         }
     }       
 }
コード例 #17
0
ファイル: cdriso.c プロジェクト: KitoHo/pcsx_rearmed
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;
}
コード例 #18
0
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;
}
コード例 #19
0
ファイル: BgzfReader.cpp プロジェクト: m-angelov/ugene
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;
}
コード例 #20
0
ファイル: zbuf.c プロジェクト: d4s/nmsg
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);
}
コード例 #21
0
ファイル: Hub.cpp プロジェクト: lpinca/uWebSockets
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;
}
コード例 #22
0
ファイル: cloop.c プロジェクト: Isaac-Lozano/qemu
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;
}
コード例 #23
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));
			
		}

	}
コード例 #24
0
ファイル: compress.c プロジェクト: nfvproject/TFM
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");
}
コード例 #25
0
void InflatingStreamBuf::reset()
{
    int rc = inflateReset(&_zstr);
    if (rc == Z_OK)
        _eof = false;
    else
        throw IOException(zError(rc));
}
コード例 #26
0
ファイル: nzlib.c プロジェクト: yawkat/rjoin-zlib
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);
    }
}
コード例 #27
0
ファイル: zlib_compress.c プロジェクト: muyu/pcompress
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);
}
コード例 #28
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;
}
コード例 #29
0
/* 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;
}
コード例 #30
0
ファイル: jni_zlib_inflate.c プロジェクト: phase/Velocity
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);
}