Esempio n. 1
0
static char *_qdbm_bzencode_impl(const char *ptr, int size, int *sp) {
    bz_stream zs;
    char *buf, *swap, obuf[BZIPBUFSIZ];
    int rv, asiz, bsiz, osiz;
    if(size < 0) size = strlen(ptr);
    zs.bzalloc = NULL;
    zs.bzfree = NULL;
    zs.opaque = NULL;
    if(BZ2_bzCompressInit(&zs, 9, 0, 30) != BZ_OK) return NULL;
    asiz = size + 16;
    if(asiz < BZIPBUFSIZ) asiz = BZIPBUFSIZ;
    if(!(buf = malloc(asiz))) {
        BZ2_bzCompressEnd(&zs);
        return NULL;
    }
    bsiz = 0;
    zs.next_in = (char *)ptr;
    zs.avail_in = size;
    zs.next_out = obuf;
    zs.avail_out = BZIPBUFSIZ;
    while((rv = BZ2_bzCompress(&zs, BZ_FINISH)) == BZ_FINISH_OK) {
        osiz = BZIPBUFSIZ - zs.avail_out;
        if(bsiz + osiz > asiz) {
            asiz = asiz * 2 + osiz;
            if(!(swap = realloc(buf, asiz))) {
                free(buf);
                BZ2_bzCompressEnd(&zs);
                return NULL;
            }
            buf = swap;
        }
        memcpy(buf + bsiz, obuf, osiz);
        bsiz += osiz;
        zs.next_out = obuf;
        zs.avail_out = BZIPBUFSIZ;
    }
    if(rv != BZ_STREAM_END) {
        free(buf);
        BZ2_bzCompressEnd(&zs);
        return NULL;
    }
    osiz = BZIPBUFSIZ - zs.avail_out;
    if(bsiz + osiz + 1 > asiz) {
        asiz = asiz * 2 + osiz;
        if(!(swap = realloc(buf, asiz))) {
            free(buf);
            BZ2_bzCompressEnd(&zs);
            return NULL;
        }
        buf = swap;
    }
    memcpy(buf + bsiz, obuf, osiz);
    bsiz += osiz;
    buf[bsiz] = '\0';
    *sp = bsiz;
    BZ2_bzCompressEnd(&zs);
    return buf;
}
Esempio n. 2
0
int ipfix_compress(ipfix_exporter *exporter) {
	bz_stream strm;
	int ret;
	int i;

	strm.bzalloc = NULL;
	strm.bzfree = NULL;
	strm.opaque = NULL;


	// The compression level is the 100k block size - as we deal with packets
	// which can be at 65536 bytes length at most the compression level should
	// not make a difference.
	ret = BZ2_bzCompressInit(&strm, bzip2_compression_level, 0, 0);
	if (ret != BZ_OK) {
		return -1;
	}

	strm.avail_out = sizeof(exporter->compression_buffer);
	strm.next_out = (char *) exporter->compression_buffer;

	for (i = 0; i < exporter->data_sendbuffer->committed; i++) {
		if (strm.avail_out <= 0) {
			msg(MSG_ERROR, "Out of buffer space while compressing.");
			BZ2_bzCompressEnd(&strm);

			return -1;
		}

		struct iovec *vec = &exporter->data_sendbuffer->entries[i];
		strm.avail_in = vec->iov_len;
		strm.next_in = vec->iov_base;

		ret = BZ2_bzCompress(&strm, BZ_RUN);
		assert(ret == BZ_RUN_OK);
	}

	strm.avail_in = 0;
	strm.next_in = NULL;
	ret = BZ2_bzCompress(&strm, BZ_FINISH);
	assert(ret == BZ_STREAM_END);

	DPRINTF("(Un-)Compressed length: %d / %d", exporter->data_sendbuffer->committed_data_length,
			sizeof(exporter->compression_buffer) - strm.avail_out);

	exporter->data_sendbuffer->entries[0].iov_base =
			exporter->compression_buffer;
	exporter->data_sendbuffer->entries[0].iov_len =
			sizeof(exporter->compression_buffer) - strm.avail_out;
	exporter->data_sendbuffer->committed = 1;
	exporter->data_sendbuffer->current = 1;
	exporter->data_sendbuffer->committed_data_length =
			exporter->data_sendbuffer->entries[0].iov_len;

	BZ2_bzCompressEnd(&strm);

	return 0;
}
Esempio n. 3
0
void BZ2Compress(Stream& out, Stream& in, Gate2<int, int> progress)
{
	enum { BUF_SIZE = 65536 };
	Buffer<char> input(BUF_SIZE), output(BUF_SIZE);
	bz_stream z;
	z.bzalloc = bzalloc_new;
	z.bzfree = bzfree_new;
	z.opaque = 0;
	if(BZ2_bzCompressInit(&z, 9, 0, 30) != BZ_OK)
	{
		out.SetError();
		return;
	}
	z.avail_in = 0;
	z.avail_out = BUF_SIZE;
	z.next_out = output;
	int code;
	int flush = BZ_RUN;
	int64 total = in.GetLeft();
	int done = 0;
	do
	{
		if(z.avail_in == 0 && flush == BZ_RUN)
		{
			z.next_in = input;
			if((z.avail_in = in.Get(z.next_in = input, BUF_SIZE)) == 0)
				flush = BZ_FINISH;
			done += z.avail_in;
			if(progress(done, (int)total) || in.IsError())
			{
				BZ2_bzCompressEnd(&z);
				out.SetError();
				return;
			}
		}
		code = BZ2_bzCompress(&z, flush);
		if(z.avail_out == 0)
		{
			out.Put(z.next_out = output, z.avail_out = BUF_SIZE);
			if(out.IsError())
			{
				BZ2_bzCompressEnd(&z);
				return;
			}
		}
	}
	while(code == BZ_RUN_OK || code == BZ_FINISH_OK);
	if(z.avail_out < BUF_SIZE)
		out.Put(output, BUF_SIZE - z.avail_out);
	BZ2_bzCompressEnd(&z);
	if(code != BZ_STREAM_END)
		out.SetError();
}
Esempio n. 4
0
/**
 * Compress a string.
 * options:
 *   blocksize=[1,9]
 *   workfactor=[0,250]
 */
static int larc_bzip2_compress(lua_State *L)
{
	int blocksize = 6,
		workfactor = 0;
	size_t len;
	const char *str = luaL_checklstring(L, 1, &len);
	bz_userdata ud;

	if (lua_gettop(L) > 1)
	{
		luaL_checktype(L, 2, LUA_TTABLE);
		GETINT2OPTION(2,blocksize,level);
		GETINTOPTION(2,workfactor);
	}
	
	ud.z.bzalloc = NULL;
	ud.z.bzfree = NULL;
	ud.z.opaque = NULL;
	
	ud.status = BZ2_bzCompressInit(&ud.z, blocksize, 0, workfactor);
	if (ud.status != BZ_OK)
	{
		lua_pushnil(L);
		lua_pushstring(L, bz2_error(ud.status));
		lua_pushinteger(L, ud.status);
		return 3;
	}
	
	ud.z.next_in = (char*)str;
	ud.z.avail_in = len;
	ud.result = -1;
	ud.flush = BZ_FINISH;
	if (0 != lua_cpcall(L, protected_compress_to_buffer, &ud))
	{
		BZ2_bzCompressEnd(&ud.z);
		return lua_error(L);
	}
	BZ2_bzCompressEnd(&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;
}
Esempio n. 5
0
wxBZipOutputStream::~wxBZipOutputStream()
{
    bz_stream* hZip = (bz_stream*)m_hZip;

    BZ2_bzCompressEnd(hZip);
	delete hZip;
}
int compress(string method, char* input_data, int input_size, char* output_data, int& output_size){
	if(method == "bzip2"){
		bz_stream stream;
		stream.bzalloc = NULL;
		stream.bzfree = NULL;
		stream.opaque = NULL;

		int rv = BZ2_bzCompressInit(&stream, 5, 0, 0);
		if(rv != BZ_OK) return -1;
		stream.next_in = input_data;
		stream.avail_in = input_size;
		stream.next_out = output_data;
		stream.avail_out = output_size;
		rv = BZ2_bzCompress(&stream, BZ_FINISH);
		while(rv != BZ_STREAM_END){
			rv = BZ2_bzCompress(&stream, BZ_FINISH);
			if(rv != BZ_STREAM_END || rv != BZ_FINISH_OK) return -1;
		}

		output_size = stream.total_out_lo32;

		BZ2_bzCompressEnd(&stream);
		return 0;
	}
	return -1;
}
Esempio n. 7
0
void stream_read_func(gpointer data, gpointer user_data) {
  file_part_t *part = (file_part_t*) data;
  
  bz_stream bzs;
  memset(&bzs, 0, sizeof(bz_stream));
  int bzerror = BZ_OK;

  bzerror = BZ2_bzCompressInit(&bzs, 9, 0, 30);
  
  if (bzerror == BZ_OK) {
    bzs.next_in = part->inBuf;
    bzs.avail_in = part->inBufz;
    bzs.next_out = part->outBuf;
    bzs.avail_out = part->outBufz;
    bzerror = BZ2_bzCompress(&bzs, BZ_FINISH);
    part->outBufz = bzs.total_out_lo32;
  }

  if (bzerror != BZ_STREAM_END) {
    part->error = TRUE;
    fprintf(stderr, "BZError %d\n", bzerror);
  }

  BZ2_bzCompressEnd(&bzs);
  
  g_mutex_lock(PART_LIST_LOCK);
  PART_LIST = g_slist_insert_sorted(PART_LIST, part, file_part_compare);
  PART_LIST_SIZE++;
  g_mutex_unlock(PART_LIST_LOCK);
}
/*
 * Finish the compression.
 */
static int
archive_compressor_bzip2_close(struct archive_write_filter *f)
{
	struct private_data *data = (struct private_data *)f->data;
	int ret, r1;

	/* Finish compression cycle. */
	ret = drive_compressor(f, data, 1);
	if (ret == ARCHIVE_OK) {
		/* Write the last block */
		ret = __archive_write_filter(f->next_filter,
		    data->compressed,
		    data->compressed_buffer_size - data->stream.avail_out);
	}

	switch (BZ2_bzCompressEnd(&(data->stream))) {
	case BZ_OK:
		break;
	default:
		archive_set_error(f->archive, ARCHIVE_ERRNO_PROGRAMMER,
		    "Failed to clean up compressor");
		ret = ARCHIVE_FATAL;
	}

	r1 = __archive_write_close_filter(f->next_filter);
	return (r1 < ret ? r1 : ret);
}
Esempio n. 9
0
torch::Data Bz2::Compress(const torch::Data &data)
{
    const int size100k = 100000;
    int bufsize = size100k * Bz2::block100k;
    int status = 0;

    bz_stream stream = {0};
    
    Data buf(bufsize);
    Data dst;
    dst.HiddenAlloc(data.GetSize());

    /* next_in should point at the data to be compressed
     * avail_in should indicate how many bytes the library may read 
     * BZ2_bzCompress updates next_in, avail_in and total_in to reflect the number of bytes it has read */
    stream.next_in = (char*) data.GetBytes();
    stream.avail_in = (int)data.GetSize();
    
    /* next_out should point to a buffer in which the compressed data is to be placed
     * avail_out indicating how much output space is available.
     * BZ2_bzCompress updates next_out, avail_out and total_out to reflect the number of bytes output. */
    stream.next_out = (char*)buf.GetBytes();
    stream.avail_out = (int)buf.GetSize();
    
    
    status = BZ2_bzCompressInit(&stream, Bz2::block100k, 0, 0);
    if (status != BZ_OK) {
        BZ2_bzCompressEnd(&stream);
        return dst;
    }
    
    do {
        status = BZ2_bzCompress(&stream, (stream.avail_in) ? BZ_RUN : BZ_FINISH);
        if (status != BZ_RUN_OK && status != BZ_STREAM_END)
            break;
        
        dst.Append(buf.GetBytes(), bufsize - stream.avail_out);
        
        stream.next_out = (char*)buf.GetBytes();
        stream.avail_out = (int)buf.GetSize();

    }while (status != BZ_STREAM_END);
    
    BZ2_bzCompressEnd(&stream);

    return dst;
}
Esempio n. 10
0
static int stream_bzip2_end(server *srv, handler_ctx *hctx) {
	bz_stream * const bz = &(hctx->u.bz);
	int rc = BZ2_bzCompressEnd(bz);
	if (BZ_OK == rc || BZ_DATA_ERROR == rc) return 0;

	log_error_write(srv, __FILE__, __LINE__, "sd",
			"BZ2_bzCompressEnd error ret=", rc);
	return -1;
}
Esempio n. 11
0
Samurai::IO::BZip2Compressor::~BZip2Compressor()
{
#ifdef DATADUMP
	printf("~BZ2_Compressor, %u/%u = %.04f\n", d->stream->total_out_lo32, d->stream->total_in_lo32,  (float) d->stream->total_out_lo32 / (float)(d->stream->total_in_lo32 + 1));
#endif
	if (d && d->stream)
		BZ2_bzCompressEnd(d->stream);
	delete d;
}
Esempio n. 12
0
void bzip2_base::end(bool compress)
{
    ready_ = false;
    bz_stream* s = static_cast<bz_stream*>(stream_);
    bzip2_error::check(
        compress ?
            BZ2_bzCompressEnd(s) : 
            BZ2_bzDecompressEnd(s)
    ); 
}
Esempio n. 13
0
Buffer BZip2Filter::process(const BufferRef& input)
{
	if (input.empty())
		return Buffer();

	int rv = BZ2_bzCompressInit(&bz_,
		level(),						// compression level
		0,								// no output
		0								// work factor
	);

	if (rv != BZ_OK)
		return Buffer();

	bz_.next_in = input.begin();
	bz_.avail_in = input.size();
	bz_.total_in_lo32 = 0;
	bz_.total_in_hi32 = 0;

	Buffer output(input.size() * 1.1 + 12);
	bz_.next_out = output.end();
	bz_.avail_out = output.capacity();
	bz_.total_out_lo32 = 0;
	bz_.total_out_hi32 = 0;

	rv = BZ2_bzCompress(&bz_, BZ_FINISH);
	if (rv != BZ_STREAM_END)
	{
		BZ2_bzCompressEnd(&bz_);
		return Buffer();
	}

	if (bz_.total_out_hi32)
		return Buffer(); // file too large

	output.resize(bz_.total_out_lo32);

	rv = BZ2_bzCompressEnd(&bz_);
	if (rv != BZ_OK)
		return Buffer();

	return output;
}
Esempio n. 14
0
static void php_bz2_compress_dtor(php_stream_filter *thisfilter)
{
	if (Z_PTR(thisfilter->abstract)) {
		php_bz2_filter_data *data = Z_PTR(thisfilter->abstract);
		BZ2_bzCompressEnd(&(data->strm));
		pefree(data->inbuf, data->persistent);
		pefree(data->outbuf, data->persistent);
		pefree(data, data->persistent);
	}
}
Esempio n. 15
0
static void o_stream_bzlib_close(struct iostream_private *stream,
				 bool close_parent)
{
	struct bzlib_ostream *zstream = (struct bzlib_ostream *)stream;

	(void)o_stream_flush(&zstream->ostream.ostream);
	(void)BZ2_bzCompressEnd(&zstream->zs);
	if (close_parent)
		o_stream_close(zstream->ostream.parent);
}
Esempio n. 16
0
/* 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;
}
Esempio n. 17
0
value camlzip_bzCompressEnd(value stream) {
#ifdef USE_BZIP2
  int err;
  if ((err = BZ2_bzCompressEnd(BZStream_val(stream))) != BZ_OK)
    camlzip_bzerror("Bzlib.compress_end", err);
  free(BZStream_val(stream));
#else
  failwith("Bzip2 compression not supported");
#endif
  return Val_unit;
}
Esempio n. 18
0
static void
gst_bz2enc_compress_end (GstBz2enc * b)
{
  g_return_if_fail (GST_IS_BZ2ENC (b));

  if (b->ready) {
    BZ2_bzCompressEnd (&b->stream);
    memset (&b->stream, 0, sizeof (b->stream));
    b->ready = FALSE;
  }
}
Esempio n. 19
0
static
int BZ2_bzBuffToBuffCompress(char* dest,
		unsigned int* destLen,
		char*         source,
		unsigned int  sourceLen,
		int           blockSize100k)
{
	bz_stream strm;
	int ret;

	if (dest == NULL || destLen == NULL
	 || source == NULL
	 || blockSize100k < 1 || blockSize100k > 9
	) {
		return BZ_PARAM_ERROR;
	}

	BZ2_bzCompressInit(&strm, blockSize100k);

	strm.next_in = source;
	strm.next_out = dest;
	strm.avail_in = sourceLen;
	strm.avail_out = *destLen;

	ret = BZ2_bzCompress(&strm, BZ_FINISH);
	if (ret == BZ_FINISH_OK) goto output_overflow;
	if (ret != BZ_STREAM_END) goto errhandler;

	/* normal termination */
	*destLen -= strm.avail_out;
	BZ2_bzCompressEnd(&strm);
	return BZ_OK;

 output_overflow:
	BZ2_bzCompressEnd(&strm);
	return BZ_OUTBUFF_FULL;

 errhandler:
	BZ2_bzCompressEnd(&strm);
	return ret;
}
Esempio n. 20
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);
}
Esempio n. 21
0
void MemoryCompressor::Clear(void)
{
	if (output)
	{
		free(output);
		output=0;
	}

	if (streamInited)
		BZ2_bzCompressEnd( &stream );

	totalRead=totalWritten=compressedInputLength=0;
}
Esempio n. 22
0
int bz2Compress(int level, const unsigned char *data, size_t avail_in, unsigned char *odata, size_t *avail_out)
{
   int ret;
   int verbosity = 0;
   int workFactor = 30;
   bz_stream strm;

   strm.bzalloc = NULL;
   strm.bzfree = NULL;   
   strm.opaque = NULL;

   ret = BZ2_bzCompressInit(&strm, level, verbosity, workFactor);
   if (ret != BZ_OK) return ret;

   strm.next_in = data;
   strm.next_out = odata;
   strm.avail_in = avail_in;
   strm.avail_out = *avail_out;

   ret = BZ2_bzCompress ( &strm, BZ_FINISH );
   if (ret == BZ_FINISH_OK) goto output_overflow;
   if (ret != BZ_STREAM_END) goto errhandler;
   
   /* normal termination */   
   *avail_out -= strm.avail_out;
   BZ2_bzCompressEnd ( &strm );                                                                                                                                                    
   return BZ_OK;
   
   output_overflow:
      BZ2_bzCompressEnd ( &strm );      
      return BZ_OUTBUFF_FULL;

   errhandler:   
      BZ2_bzCompressEnd ( &strm );

   return ret;
}
Esempio n. 23
0
String BZ2Compress(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_bzCompressInit(&z, 9, 0, 30) != BZ_OK)
		return String::GetVoid();
	int buf_size = minmax(s.GetLength(), 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;
	int res;
	while((res = BZ2_bzCompress(&z, z.avail_in ? BZ_RUN : BZ_FINISH)) == BZ_RUN_OK || res == BZ_FINISH_OK)
	{
		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_bzCompressEnd(&z);
			return String::GetVoid();
		}
	}
	out.Cat(output, buf_size - z.avail_out);
	BZ2_bzCompressEnd(&z);
	if(res != BZ_STREAM_END)
		out = String::GetVoid();
	return out;
}
Esempio n. 24
0
static gboolean
gsf_output_bzip_close (GsfOutput *output)
{
#ifdef HAVE_BZ2
	GsfOutputBzip *bzip = GSF_OUTPUT_BZIP (output);
	gboolean rt;

	rt = bzip_flush (bzip);
	BZ2_bzCompressEnd (&bzip->stream);

	return rt;
#else
	(void)output;
	return FALSE;
#endif
}
Esempio n. 25
0
// 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;
  }
Esempio n. 26
0
/*++

BzipCompressObj

    Compresses data using the Bzip2 compression algorithm.

Arguments:
    sourceObj - Pointer to a Tcl object containing the data to be compressed.

    destObj   - Pointer to a Tcl object to receive the compressed data.

    level     - Compression level.

Return Value:
    A Bzip2 status code; BZ_OK is returned if successful.

--*/
static int
BzipCompressObj(
    Tcl_Obj *sourceObj,
    Tcl_Obj *destObj,
    int level
)
{
    bz_stream stream;
    int status;
    unsigned int destLength;

    //
    // The bzalloc, bzfree, and opaque data structure members
    // must be initialised prior to calling BZ2_bzCompressInit().
    //
    stream.bzalloc = BzipAlloc;
    stream.bzfree  = BzipFree;
    stream.opaque  = NULL;

    status = BZ2_bzCompressInit(&stream, level, 0, 0);
    if (status != BZ_OK) {
        return status;
    }

    stream.next_in = (char *)Tcl_GetByteArrayFromObj(sourceObj, (int *)&stream.avail_in);

    //
    // According to the Bzip2 documentation, the recommended buffer size
    // is 1% larger than the uncompressed data, plus 600 additional bytes.
    //
    stream.avail_out = destLength = (unsigned int)((double)stream.avail_in * 1.01) + 600;
    stream.next_out  = (char *)Tcl_SetByteArrayLength(destObj, stream.avail_out);

    status = BZ2_bzCompress(&stream, BZ_FINISH);
    BZ2_bzCompressEnd(&stream);

    if (status == BZ_STREAM_END) {
        // Update the object's length.
        destLength -= stream.avail_out;
        Tcl_SetByteArrayLength(destObj, (int)destLength);
        return BZ_OK;
    }

    return (status == BZ_FINISH_OK) ? BZ_OUTBUFF_FULL : status;
}
Esempio n. 27
0
static void bz_wclose(iow_t *iow)
{
	while (BZ2_bzCompress(&DATA(iow)->strm, BZ_FINISH) == BZ_OK) {
		/* Need to flush the output buffer */
		wandio_wwrite(DATA(iow)->child, 
				DATA(iow)->outbuff,
				sizeof(DATA(iow)->outbuff)-DATA(iow)->strm.avail_out);
		DATA(iow)->strm.next_out = DATA(iow)->outbuff;
		DATA(iow)->strm.avail_out = sizeof(DATA(iow)->outbuff);
	}
	BZ2_bzCompressEnd(&DATA(iow)->strm);
	wandio_wwrite(DATA(iow)->child, 
			DATA(iow)->outbuff,
			sizeof(DATA(iow)->outbuff)-DATA(iow)->strm.avail_out);
	wandio_wdestroy(DATA(iow)->child);
	free(iow->data);
	free(iow);
}
Esempio n. 28
0
File: core.c Progetto: Andygon/core
static int hb_bz2Compress( const char * szSrc, HB_SIZE nSrc,
                           char * szDst, HB_SIZE * pnDst, int iBlockSize )
{
   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_bzCompressInit( &stream, iBlockSize, 0, 0 );
   if( iResult == BZ_OK )
   {
      do
      {
         iResult = BZ2_bzCompress( &stream, BZ_FINISH );
      }
      while( iResult == BZ_FINISH_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_bzCompressEnd( &stream );
   }

   return iResult;
}
Esempio n. 29
0
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;
}
Esempio n. 30
0
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;
}