/**
* Inflate a string.
* options:
*/
static int larc_bzip2_decompress(lua_State *L)
{
size_t len;
const char *str = luaL_checklstring(L, 1, &len);
bz_userdata ud;
ud.z.bzalloc = NULL;
ud.z.bzfree = NULL;
ud.z.opaque = NULL;
ud.z.next_in = (char*)str;
ud.z.avail_in = len;
ud.status = BZ2_bzDecompressInit(&ud.z, 0, USE_SMALL_DECOMPRESS);
if (ud.status != BZ_OK)
{
lua_pushnil(L);
lua_pushstring(L, bz2_error(ud.status));
lua_pushinteger(L, ud.status);
return 3;
}
ud.result = -1;
if (0 != lua_cpcall(L, protected_decompress_to_buffer, &ud))
{
BZ2_bzDecompressEnd(&ud.z);
return lua_error(L);
}
BZ2_bzDecompressEnd(&ud.z);
if (ud.result != -1)
{
lua_rawgeti(L, LUA_REGISTRYINDEX, ud.result);
luaL_unref(L, LUA_REGISTRYINDEX, ud.result);
lua_pushinteger(L, len - ud.z.avail_in);
}
else
{
lua_pushnil(L);
lua_pushstring(L, bz2_error(ud.status));
}
lua_pushinteger(L, ud.status);
return 3;
}
/* Destroy
* destroy file
*/
static rc_t CC KBZipFileDestroy (KBZipFile *self)
{
rc_t rc = 0, orc = 0;
if (self)
{
if (self->file != NULL)
{
int zret = BZ_OK;
if (self->dad.write_enabled)
{
/* flush out end of compressed data */
/* if (self->completed == false) */
/* { */
size_t ignored;
bz_stream* strm = &self->strm;
strm->avail_in = 0;
strm->next_in = NULL;
rc = KBZipFileWriteInt(self, BZ_FINISH, &ignored);
/* assert (zret == BZ_STREAM_END); */ /* stream will be complete */
/* } */
zret = BZ2_bzCompressEnd(&self->strm); /* clean up */
self->completed = true;
}
else if (self->dad.read_enabled)
{
zret = BZ2_bzDecompressEnd (&self->strm);
}
else
{
rc = RC (rcFS, rcFile, rcDestroying, rcSelf, rcInvalid);
LOGERR (klogInt, orc, "corrupt object "
"closing bzip file object");
}
if (zret != BZ_OK)
{
orc = RC (rcFS, rcFile, rcDestroying, rcParam, rcInvalid);
LOGERR (klogInt, orc, "bad parameters - coding error on "
"closing bzip file object");
if (rc == 0)
rc = orc;
}
orc = KFileRelease (self->file);
if (rc == 0)
rc = orc;
}
free (self);
}
return rc;
}
String BZ2Decompress(String s, Gate2<int, int> progress)
{
if(s.IsEmpty())
return s;
bz_stream z;
Zero(z);
z.bzalloc = bzalloc_new;
z.bzfree = bzfree_new;
z.opaque = 0;
if(BZ2_bzDecompressInit(&z, 0, 0) != BZ_OK)
return String::GetVoid();
int buf_size = minmax(s.GetLength() / 2, 1024, 65536);
Buffer<char> output(buf_size);
z.next_in = (char *)s.Begin();
z.avail_in = s.GetLength();
z.next_out = output;
z.avail_out = buf_size;
String out;
while(BZ2_bzDecompress(&z) == BZ_OK)
{
if(z.avail_out == (dword)buf_size)
{ // no output generated - assume error
BZ2_bzDecompressEnd(&z);
return String::GetVoid();
}
out.Cat(output, buf_size - z.avail_out);
z.next_out = output;
z.avail_out = buf_size;
if(progress((int)(uintptr_t)((const char *)z.next_in - ~s), s.GetLength()))
{
BZ2_bzDecompressEnd(&z);
return String::GetVoid();
}
}
if(z.avail_out < (unsigned)buf_size)
out.Cat(output, buf_size - z.avail_out);
BZ2_bzDecompressEnd(&z);
return out;
}
value camlzip_bzDecompressEnd(value stream) {
#ifdef USE_BZIP2
int err;
if ((err = BZ2_bzDecompressEnd(BZStream_val(stream))) != BZ_OK)
camlzip_bzerror("Bzlib.decompressEnd", err);
free(BZStream_val(stream));
#else
failwith("Bzip2 compression not supported");
#endif
return Val_unit;
}
static void
gst_bz2dec_decompress_end (GstBz2dec * b)
{
g_return_if_fail (GST_IS_BZ2DEC (b));
if (b->ready) {
BZ2_bzDecompressEnd (&b->stream);
memset (&b->stream, 0, sizeof (b->stream));
b->ready = FALSE;
}
}
void MemoryDecompressor::Clear(void)
{
if (output)
{
free(output);
output=0;
}
if (streamInited)
BZ2_bzDecompressEnd( &stream );
}
int
ArchiveReader::ExtractItemToStream(const MarItem *item, FILE *fp)
{
/* decompress the data chunk by chunk */
bz_stream strm;
int offset, inlen, outlen, ret = OK;
memset(&strm, 0, sizeof(strm));
if (BZ2_bzDecompressInit(&strm, 0, 0) != BZ_OK)
return UNEXPECTED_BZIP_ERROR;
offset = 0;
for (;;) {
if (!item->length) {
ret = UNEXPECTED_MAR_ERROR;
break;
}
if (offset < (int) item->length && strm.avail_in == 0) {
inlen = mar_read(mArchive, item, offset, inbuf, inbuf_size);
if (inlen <= 0)
return READ_ERROR;
offset += inlen;
strm.next_in = inbuf;
strm.avail_in = inlen;
}
strm.next_out = outbuf;
strm.avail_out = outbuf_size;
ret = BZ2_bzDecompress(&strm);
if (ret != BZ_OK && ret != BZ_STREAM_END) {
ret = UNEXPECTED_BZIP_ERROR;
break;
}
outlen = outbuf_size - strm.avail_out;
if (outlen) {
if (fwrite(outbuf, outlen, 1, fp) != 1) {
ret = WRITE_ERROR_EXTRACT;
break;
}
}
if (ret == BZ_STREAM_END) {
ret = OK;
break;
}
}
BZ2_bzDecompressEnd(&strm);
return ret;
}
static void php_bz2_decompress_dtor(php_stream_filter *thisfilter)
{
if (thisfilter && Z_PTR(thisfilter->abstract)) {
php_bz2_filter_data *data = Z_PTR(thisfilter->abstract);
if (data->status == PHP_BZ2_RUNNING) {
BZ2_bzDecompressEnd(&(data->strm));
}
pefree(data->inbuf, data->persistent);
pefree(data->outbuf, data->persistent);
pefree(data, data->persistent);
}
}
static void i_stream_bzlib_close(struct iostream_private *stream,
bool close_parent)
{
struct bzlib_istream *zstream = (struct bzlib_istream *)stream;
if (!zstream->zs_closed) {
(void)BZ2_bzDecompressEnd(&zstream->zs);
zstream->zs_closed = TRUE;
}
if (close_parent)
i_stream_close(zstream->istream.parent);
}
void CryptoManager::decodeBZ2(const u_int8_t* is, size_t sz, string& os) throw (CryptoException) {
bz_stream bs = { 0 };
if(BZ2_bzDecompressInit(&bs, 0, 0) != BZ_OK)
throw(CryptoException(STRING(DECOMPRESSION_ERROR)));
// We assume that the files aren't compressed more than 2:1...if they are it'll work anyway,
// but we'll have to do multiple passes...
size_t bufsize = 2*sz;
AutoArray<char> buf(bufsize);
bs.avail_in = sz;
bs.avail_out = bufsize;
bs.next_in = (char*)(const_cast<u_int8_t*>(is));
bs.next_out = buf;
int err;
os.clear();
while((err = BZ2_bzDecompress(&bs)) == BZ_OK) {
if (bs.avail_in == 0 && bs.avail_out > 0) { // error: BZ_UNEXPECTED_EOF
BZ2_bzDecompressEnd(&bs);
throw CryptoException(STRING(DECOMPRESSION_ERROR));
}
os.append(buf, bufsize-bs.avail_out);
bs.avail_out = bufsize;
bs.next_out = buf;
}
if(err == BZ_STREAM_END)
os.append(buf, bufsize-bs.avail_out);
BZ2_bzDecompressEnd(&bs);
if(err < 0) {
// This was a real error
throw CryptoException(STRING(DECOMPRESSION_ERROR));
}
}
Variant HHVM_FUNCTION(bzdecompress, const String& source, int small /* = 0 */) {
int source_len = source.length();
int error;
uint64_t size = 0;
bz_stream bzs;
bzs.bzalloc = nullptr;
bzs.bzfree = nullptr;
if (BZ2_bzDecompressInit(&bzs, 0, small) != BZ_OK) {
return false;
}
bzs.next_in = (char *) source.c_str();
bzs.avail_in = source_len;
// in most cases bz2 offers at least 2:1 compression, so we use that as our
// base
bzs.avail_out = source_len * 2;
String ret(bzs.avail_out, ReserveString);
bzs.next_out = ret.bufferSlice().ptr;
while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {
/* compression is better then 2:1, need to allocate more memory */
bzs.avail_out = source_len;
size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
ret.setSize(size); // needs to be null-terminated before the reserve call
bzs.next_out = ret.reserve(size + bzs.avail_out).ptr + size;
}
if (error == BZ_STREAM_END || error == BZ_OK) {
size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
BZ2_bzDecompressEnd(&bzs);
ret.shrink(size);
return ret;
} else {
BZ2_bzDecompressEnd(&bzs);
return error;
}
}
static int
bzf_close(struct open_file *f)
{
struct bz_file *bzf = (struct bz_file *)f->f_fsdata;
f->f_fsdata = NULL;
if (bzf) {
BZ2_bzDecompressEnd(&(bzf->bzf_bzstream));
close(bzf->bzf_rawfd);
free(bzf);
}
return(0);
}
static void
squash_bz2_stream_destroy (void* stream) {
switch (((SquashStream*) stream)->stream_type) {
case SQUASH_STREAM_COMPRESS:
BZ2_bzCompressEnd (&(((SquashBZ2Stream*) stream)->stream));
break;
case SQUASH_STREAM_DECOMPRESS:
BZ2_bzDecompressEnd (&(((SquashBZ2Stream*) stream)->stream));
break;
}
squash_stream_destroy (stream);
}
/*---------------------------------------------------*/
void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
{
bzFile* bzf = (bzFile*)b;
BZ_SETERR(BZ_OK);
if (bzf == NULL)
{ BZ_SETERR(BZ_OK); return; };
if (bzf->writing)
{ BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
if (bzf->initialisedOk)
(void)BZ2_bzDecompressEnd ( &(bzf->strm) );
free ( bzf );
}
// Close file stream
bool FXBZFileStream::close(){
if(dir){
if(dir==FXStreamLoad){
FXFileStream::close();
BZ2_bzDecompressEnd(&bz->stream);
}
else{
ac=BZ_FINISH;
FXFileStream::close();
BZ2_bzCompressEnd(&bz->stream);
}
FXFREE(&bz);
return true;
}
return false;
}
static tsf_bool_t tear_down_mode(tsf_adpt_rdr_t *reader,
uint8_t **spillover,
uint32_t *spillover_len) {
tsf_bool_t stillok=tsf_true;
if (reader->mode==TSF_ZIP_ZLIB) {
#ifdef HAVE_ZLIB
inflateEnd(Cz(reader));
#endif
} else if (reader->mode==TSF_ZIP_BZIP2) {
#ifdef HAVE_BZIP2
BZ2_bzDecompressEnd(Cbz(reader));
#endif
}
if (reader->mode==TSF_ZIP_ZLIB ||
reader->mode==TSF_ZIP_BZIP2) {
free(reader->stream);
if (spillover!=NULL && spillover_len!=NULL) {
*spillover=malloc(reader->abstract.avail_in);
if (*spillover==NULL) {
tsf_set_errno("Could not allocate spillover buffer");
stillok=tsf_false;
} else {
*spillover_len=reader->abstract.avail_in;
memcpy(*spillover,reader->abstract.next_in,*spillover_len);
}
}
} else if (reader->mode==TSF_ZIP_NONE) {
if (spillover!=NULL && spillover_len!=NULL) {
*spillover=malloc(reader->puti-reader->geti);
if (*spillover==NULL) {
tsf_set_errno("Could not allocate spillover buffer");
stillok=tsf_false;
} else {
*spillover_len=reader->puti-reader->geti;
memcpy(*spillover,reader->buf+reader->geti,*spillover_len);
}
}
}
if (reader->mode!=TSF_ZIP_UNKNOWN) {
free(reader->buf);
}
reader->stream=NULL;
reader->buf=NULL;
reader->buf_size=0;
reader->mode=TSF_ZIP_UNKNOWN;
return stillok;
}
static void i_stream_bzlib_reset(struct bzlib_istream *zstream)
{
struct istream_private *stream = &zstream->istream;
i_stream_seek(stream->parent, stream->parent_start_offset);
zstream->eof_offset = (uoff_t)-1;
zstream->zs.next_in = NULL;
zstream->zs.avail_in = 0;
stream->parent_expected_offset = stream->parent_start_offset;
stream->skip = stream->pos = 0;
stream->istream.v_offset = 0;
zstream->high_pos = 0;
(void)BZ2_bzDecompressEnd(&zstream->zs);
i_stream_bzlib_init(zstream);
}
void
do_bunzip2 (void)
{
int result;
bz_stream strm;
strm.bzalloc = NULL;
strm.bzfree = NULL;
strm.opaque = NULL;
strm.avail_in = 0;
strm.next_out = outbuf;
strm.avail_out = OUTBUFSIZ;
result = BZ2_bzDecompressInit (&strm, 0, SMALL_MODE);
while (result == BZ_OK)
{
if (strm.avail_in == 0)
{
strm.next_in = inbuf;
strm.avail_in = (*unzip_read)(strm.next_in, INBUFSIZ);
if (strm.avail_in == 0)
break;
}
result = BZ2_bzDecompress (&strm);
if ((result != BZ_OK) && (result != BZ_STREAM_END))
break;
if ((strm.avail_out == 0) || (result == BZ_STREAM_END))
{
(*unzip_write) (outbuf, OUTBUFSIZ - strm.avail_out);
strm.next_out = outbuf;
strm.avail_out = OUTBUFSIZ;
}
}
BZ2_bzDecompressEnd (&strm);
if (result != BZ_STREAM_END)
(*unzip_error) (NULL);
}
static HB_SIZE hb_bz2UncompressedSize( const char * szSrc, HB_SIZE nLen,
int * piResult )
{
char buffer[ 1024 ];
bz_stream stream;
HB_SIZE nDest = 0;
memset( &stream, 0, sizeof( stream ) );
stream.next_in = ( char * ) szSrc;
stream.avail_in = ( unsigned int ) nLen;
stream.bzalloc = hb_bz2Alloc;
stream.bzfree = hb_bz2Free;
/* stream.opaque = NULL; */
*piResult = BZ2_bzDecompressInit( &stream, 0, 0 );
if( *piResult == BZ_OK )
{
do
{
stream.next_out = buffer;
stream.avail_out = sizeof( buffer );
*piResult = BZ2_bzDecompress( &stream );
}
while( *piResult == BZ_OK );
if( *piResult == BZ_STREAM_END )
{
*piResult = BZ_OK;
#if HB_SIZE_MAX <= UINT_MAX
if( stream.total_out_hi32 != 0 )
*piResult = BZ_MEM_ERROR;
else
nDest = ( HB_SIZE ) stream.total_out_lo32;
#else
nDest = ( ( HB_SIZE ) stream.total_out_hi32 << 32 ) |
stream.total_out_lo32;
#endif
}
BZ2_bzDecompressEnd( &stream );
}
return nDest;
}
static bool
end(void *ud) {
struct ctx *ctx = (struct ctx *)ud;
int err;
if (ctx->compress) {
err = BZ2_bzCompressEnd(&ctx->zstr);
}
else {
err = BZ2_bzDecompressEnd(&ctx->zstr);
}
if (err != BZ_OK) {
zip_error_set(ctx->error, map_error(err), 0);
return false;
}
return true;
}
void import_compress_free(ImportCompress *c) {
assert(c);
if (c->type == IMPORT_COMPRESS_XZ)
lzma_end(&c->xz);
else if (c->type == IMPORT_COMPRESS_GZIP) {
if (c->encoding)
deflateEnd(&c->gzip);
else
inflateEnd(&c->gzip);
} else if (c->type == IMPORT_COMPRESS_BZIP2) {
if (c->encoding)
BZ2_bzCompressEnd(&c->bzip2);
else
BZ2_bzDecompressEnd(&c->bzip2);
}
c->type = IMPORT_COMPRESS_UNKNOWN;
}
static int hb_bz2Uncompress( const char * szSrc, HB_SIZE nSrc,
char * szDst, HB_SIZE * pnDst )
{
bz_stream stream;
int iResult;
memset( &stream, 0, sizeof( stream ) );
stream.next_in = ( char * ) szSrc;
stream.avail_in = ( unsigned int ) nSrc;
stream.next_out = szDst;
stream.avail_out = ( unsigned int ) *pnDst;
stream.bzalloc = hb_bz2Alloc;
stream.bzfree = hb_bz2Free;
/* stream.opaque = NULL; */
iResult = BZ2_bzDecompressInit( &stream, 0, 0 );
if( iResult == BZ_OK )
{
do
{
iResult = BZ2_bzDecompress( &stream );
}
while( iResult == BZ_OK );
if( iResult == BZ_STREAM_END )
{
#if HB_SIZE_MAX <= UINT_MAX
*pnDst = ( HB_SIZE ) stream.total_out_lo32;
#else
*pnDst = ( ( HB_SIZE ) stream.total_out_hi32 << 32 ) |
stream.total_out_lo32;
#endif
iResult = BZ_OK;
}
BZ2_bzDecompressEnd( &stream );
}
return iResult;
}
static void
ft_bzip2_file_done( FT_BZip2File zip )
{
bz_stream* bzstream = &zip->bzstream;
BZ2_bzDecompressEnd( bzstream );
/* clear the rest */
bzstream->bzalloc = NULL;
bzstream->bzfree = NULL;
bzstream->opaque = NULL;
bzstream->next_in = NULL;
bzstream->next_out = NULL;
bzstream->avail_in = 0;
bzstream->avail_out = 0;
zip->memory = NULL;
zip->source = NULL;
zip->stream = NULL;
}
static int Decompress_BZIP2(char * pbOutBuffer, int * pcbOutBuffer, char * pbInBuffer, int cbInBuffer)
{
bz_stream strm;
int nResult = BZ_OK;
// Initialize the BZIP2 decompression
strm.bzalloc = NULL;
strm.bzfree = NULL;
if(BZ2_bzDecompressInit(&strm, 0, 0) == BZ_OK)
{
strm.next_in = pbInBuffer;
strm.avail_in = cbInBuffer;
strm.next_out = pbOutBuffer;
strm.avail_out = *pcbOutBuffer;
// Perform the decompression
while(nResult != BZ_STREAM_END)
{
nResult = BZ2_bzDecompress(&strm);
// If any error there, break the loop
if(nResult < BZ_OK)
break;
}
// Put the stream into idle state
BZ2_bzDecompressEnd(&strm);
// If all succeeded, set the number of output bytes
if(nResult >= BZ_OK)
{
*pcbOutBuffer = strm.total_out_lo32;
return 1;
}
}
// Something failed, so set number of output bytes to zero
*pcbOutBuffer = 0;
return 1;
}
static tsf_bool_t tear_to_none(tsf_adpt_rdr_t *reader) {
tsf_assert(reader->mode==TSF_ZIP_ZLIB ||
reader->mode==TSF_ZIP_BZIP2);
if (reader->mode==TSF_ZIP_ZLIB) {
#ifdef HAVE_ZLIB
inflateEnd(Cz(reader));
#endif
} else {
#ifdef HAVE_BZIP2
BZ2_bzDecompressEnd(Cbz(reader));
#endif
}
free(reader->stream);
reader->mode=TSF_ZIP_UNKNOWN;
if (reader->nozip_buf_size==reader->buf_size) {
reader->geti=reader->abstract.next_in-reader->buf;
reader->puti=reader->geti+reader->abstract.avail_in;
} else {
uint8_t *buf;
reader->buf_size=tsf_max(reader->nozip_buf_size,
reader->abstract.avail_in);
buf=malloc(reader->buf_size);
if (buf==NULL) {
tsf_set_errno("Could not allocate buffer in tear_to_none() in "
"tsf_adaptive_reader.c");
free(reader->buf);
/* oh man, this leaves the reader in a flaky state */
return tsf_false;
}
memcpy(buf,
reader->abstract.next_in,
reader->abstract.avail_in);
free(reader->buf);
reader->geti=0;
reader->puti=reader->abstract.avail_in;
reader->buf=buf;
}
reader->mode=TSF_ZIP_NONE;
return tsf_true;
}
/*
* Clean up the decompressor.
*/
static int
finish(struct archive_read *a)
{
struct private_data *state;
int ret;
state = (struct private_data *)a->decompressor->data;
ret = ARCHIVE_OK;
switch (BZ2_bzDecompressEnd(&(state->stream))) {
case BZ_OK:
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Failed to clean up %s compressor",
a->archive.compression_name);
ret = ARCHIVE_FATAL;
}
free(state->uncompressed_buffer);
free(state);
a->decompressor->data = NULL;
return (ret);
}
/* this function decompress a stream using bzip2 library. */
int32_t libmpq__decompress_bzip2(uint8_t *in_buf, uint32_t in_size, uint8_t *out_buf, uint32_t out_size) {
/* some common variables. */
int32_t result = 0;
int32_t tb = 0;
bz_stream strm;
/* initialize the bzlib decompression. */
strm.bzalloc = NULL;
strm.bzfree = NULL;
/* initialize the structure. */
if ((result = BZ2_bzDecompressInit(&strm, 0, 0)) != BZ_OK) {
/* something on bzlib initialization failed. */
return result;
}
/* fill the stream structure for bzlib. */
strm.next_in = (char *)in_buf;
strm.avail_in = in_size;
strm.next_out = (char *)out_buf;
strm.avail_out = out_size;
/* do the decompression. */
while (BZ2_bzDecompress(&strm) != BZ_STREAM_END);
/* save transferred bytes. */
tb = strm.total_out_lo32;
/* cleanup of bzip stream. */
BZ2_bzDecompressEnd(&strm);
/* return transferred bytes. */
return tb;
}
/*
* Clean up the decompressor.
*/
static int
bzip2_filter_close(struct archive_read_filter *self)
{
struct private_data *state;
int ret = ARCHIVE_OK;
state = (struct private_data *)self->data;
if (state->valid) {
switch (BZ2_bzDecompressEnd(&state->stream)) {
case BZ_OK:
break;
default:
archive_set_error(&self->archive->archive,
ARCHIVE_ERRNO_MISC,
"Failed to clean up decompressor");
ret = ARCHIVE_FATAL;
}
}
free(state->out_block);
free(state);
return (ret);
}
enum eav_error
extract_and_verify(unsigned char *ibuf, size_t ilen,
unsigned char **obufp, size_t *olenp, size_t blocksize,
enum eav_compression ctype,
enum eav_digest dtype, const unsigned char *digest)
{
int ret;
unsigned char *obuf = NULL;
size_t olen = 0, total_in, total_out;
bz_stream bzs;
#ifdef MD5_SUPPORT
size_t prev_total_in;
MD5_CTX md5ctx;
char i_md5sum[33];
#endif
switch (ctype) {
case EAV_COMP_NONE:
case EAV_COMP_BZIP2:
break;
case EAV_COMP_GZIP:
case EAV_COMP_XZ:
return (EAV_ERR_COMP_UNSUPPORTED);
default:
return (EAV_ERR_COMP_UNKNOWN);
}
switch (dtype) {
case EAV_DIGEST_NONE:
break;
case EAV_DIGEST_MD5:
#ifdef MD5_SUPPORT
break;
#else
return (EAV_ERR_DIGEST_UNSUPPORTED);
#endif
default:
return (EAV_ERR_DIGEST_UNKNOWN);
}
if (dtype || ctype) {
#ifdef MD5_SUPPORT
if (dtype == EAV_DIGEST_MD5)
MD5Init(&md5ctx);
#endif
if (ctype) {
/* XXX: assume bzip2 for now */
olen = 1024 * 1024;
if ((obuf = malloc(olen)) == NULL)
return (EAV_ERR_MEM);
total_in = 0;
#ifdef MD5_SUPPORT
prev_total_in = 0;
#endif
bzs.bzalloc = NULL;
bzs.bzfree = NULL;
bzs.opaque = NULL;
bzs.next_in = (char *)ibuf;
bzs.avail_in = MIN(ilen, 1024 * 1024);
bzs.next_out = (char *)obuf;
bzs.avail_out = olen;
if (BZ2_bzDecompressInit(&bzs, 0, 0) != BZ_OK)
return (EAV_ERR_COMP);
while ((ret = BZ2_bzDecompress(&bzs)) !=
BZ_STREAM_END) {
if (ret != BZ_OK) {
free(obuf);
BZ2_bzDecompressEnd(&bzs);
return (EAV_ERR_COMP);
}
total_in = ((size_t)bzs.total_in_hi32 << 32) +
bzs.total_in_lo32;
total_out = ((size_t)bzs.total_out_hi32 << 32) +
bzs.total_out_lo32;
#ifdef MD5_SUPPORT
if (dtype == EAV_DIGEST_MD5)
MD5Update(&md5ctx, ibuf + prev_total_in,
total_in - prev_total_in);
prev_total_in = total_in;
#endif
if (bzs.avail_in == 0)
bzs.avail_in =
MIN(ilen - total_in, 1024 * 1024);
if (bzs.avail_out == 0) {
olen *= 2;
if ((obuf = reallocf(obuf, olen))
== NULL) {
BZ2_bzDecompressEnd(&bzs);
return (EAV_ERR_COMP);
}
bzs.next_out = (char *)obuf + total_out;
bzs.avail_out = olen - total_out;
}
}
BZ2_bzDecompressEnd(&bzs);
total_in = ((size_t)bzs.total_in_hi32 << 32) +
bzs.total_in_lo32;
total_out = ((size_t)bzs.total_out_hi32 << 32) +
bzs.total_out_lo32;
#ifdef MD5_SUPPORT
/* Push the last read block in the MD5 machine */
if (dtype == EAV_DIGEST_MD5)
MD5Update(&md5ctx, ibuf + prev_total_in,
total_in - prev_total_in);
#endif
/* Round up to blocksize and zero pad */
olen = roundup2(total_out, blocksize);
if (olen != total_out)
memset(obuf + total_out, '\0',
olen - total_out);
/* XXX: realloc to shorten allocation? */
} else if (dtype) {
#ifdef MD5_SUPPORT
if (dtype == EAV_DIGEST_MD5)
MD5Update(&md5ctx, ibuf, ilen);
#endif
}
if (dtype) {
#ifdef MD5_SUPPORT
if (dtype == EAV_DIGEST_MD5) {
MD5End(&md5ctx, i_md5sum);
if (strcmp(digest, i_md5sum) != 0)
return (EAV_ERR_DIGEST);
}
#endif
}
}
if (ctype == EAV_COMP_NONE) {
*obufp = ibuf;
*olenp = ilen;
} else {
*obufp = obuf;
*olenp = olen;
}
return (EAV_SUCCESS);
}
void close() final {
BZ2_bzDecompressEnd(&m_bzstream);
}
