static int
archive_write_client_open(struct archive_write_filter *f)
{
struct archive_write *a = (struct archive_write *)f->archive;
struct archive_none *state;
void *buffer;
size_t buffer_size;
f->bytes_per_block = archive_write_get_bytes_per_block(f->archive);
f->bytes_in_last_block =
archive_write_get_bytes_in_last_block(f->archive);
buffer_size = f->bytes_per_block;
state = (struct archive_none *)calloc(1, sizeof(*state));
buffer = (char *)malloc(buffer_size);
if (state == NULL || buffer == NULL) {
free(state);
free(buffer);
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for output buffering");
return (ARCHIVE_FATAL);
}
state->buffer_size = buffer_size;
state->buffer = buffer;
state->next = state->buffer;
state->avail = state->buffer_size;
f->data = state;
if (a->client_opener == NULL)
return (ARCHIVE_OK);
return (a->client_opener(f->archive, a->client_data));
}
/*
* Setup callback.
*/
static int
archive_compressor_gzip_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
ret = __archive_write_open_filter(f->next_filter);
if (ret != ARCHIVE_OK)
return (ret);
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of
* the of bytes per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0)
bs -= bs % bpb;
}
data->compressed_buffer_size = bs;
data->compressed
= (unsigned char *)malloc(data->compressed_buffer_size);
if (data->compressed == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
return (ARCHIVE_FATAL);
}
}
data->crc = crc32(0L, NULL, 0);
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
/* Prime output buffer with a gzip header. */
data->compressed[0] = 0x1f; /* GZip signature bytes */
data->compressed[1] = 0x8b;
data->compressed[2] = 0x08; /* "Deflate" compression */
data->compressed[3] = 0; /* No options */
if (data->timestamp >= 0) {
time_t t = time(NULL);
data->compressed[4] = (uint8_t)(t)&0xff; /* Timestamp */
data->compressed[5] = (uint8_t)(t>>8)&0xff;
data->compressed[6] = (uint8_t)(t>>16)&0xff;
data->compressed[7] = (uint8_t)(t>>24)&0xff;
} else
/*
* Setup callback.
*/
static int
archive_compressor_xz_open(struct archive_write_filter *f)
{
struct private_data *data = f->data;
int ret;
ret = __archive_write_open_filter(f->next_filter);
if (ret != ARCHIVE_OK)
return (ret);
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
* per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0)
bs -= bs % bpb;
}
data->compressed_buffer_size = bs;
data->compressed
= (unsigned char *)malloc(data->compressed_buffer_size);
if (data->compressed == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
return (ARCHIVE_FATAL);
}
}
f->write = archive_compressor_xz_write;
/* Initialize compression library. */
if (f->code == ARCHIVE_FILTER_LZIP) {
const struct option_value *val =
&option_values[data->compression_level];
data->lzma_opt.dict_size = val->dict_size;
data->lzma_opt.preset_dict = NULL;
data->lzma_opt.preset_dict_size = 0;
data->lzma_opt.lc = LZMA_LC_DEFAULT;
data->lzma_opt.lp = LZMA_LP_DEFAULT;
data->lzma_opt.pb = LZMA_PB_DEFAULT;
data->lzma_opt.mode =
data->compression_level<= 2? LZMA_MODE_FAST:LZMA_MODE_NORMAL;
data->lzma_opt.nice_len = val->nice_len;
data->lzma_opt.mf = val->mf;
data->lzma_opt.depth = 0;
data->lzmafilters[0].id = LZMA_FILTER_LZMA1;
data->lzmafilters[0].options = &data->lzma_opt;
data->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */
} else {
if (lzma_lzma_preset(&data->lzma_opt, data->compression_level)) {
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library");
}
data->lzmafilters[0].id = LZMA_FILTER_LZMA2;
data->lzmafilters[0].options = &data->lzma_opt;
data->lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */
}
ret = archive_compressor_xz_init_stream(f, data);
if (ret == LZMA_OK) {
f->data = data;
return (0);
}
return (ARCHIVE_FATAL);
}
/*
* Setup callback.
*/
static int
archive_filter_lz4_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
size_t required_size;
static size_t bkmap[] = { 64 * 1024, 256 * 1024, 1 * 1024 * 1024,
4 * 1024 * 1024 };
size_t pre_block_size;
ret = __archive_write_open_filter(f->next_filter);
if (ret != 0)
return (ret);
if (data->block_maximum_size < 4)
data->block_size = bkmap[0];
else
data->block_size = bkmap[data->block_maximum_size - 4];
required_size = 4 + 15 + 4 + data->block_size + 4 + 4;
if (data->out_buffer_size < required_size) {
size_t bs = required_size, bpb;
free(data->out_buffer);
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of
* the of bytes per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0) {
bs += bpb;
bs -= bs % bpb;
}
}
data->out_block_size = bs;
bs += required_size;
data->out_buffer = malloc(bs);
data->out = data->out_buffer;
data->out_buffer_size = bs;
}
pre_block_size = (data->block_independence)? 0: 64 * 1024;
if (data->in_buffer_size < data->block_size + pre_block_size) {
free(data->in_buffer_allocated);
data->in_buffer_size = data->block_size;
data->in_buffer_allocated =
malloc(data->in_buffer_size + pre_block_size);
data->in_buffer = data->in_buffer_allocated + pre_block_size;
if (!data->block_independence && data->compression_level >= 3)
data->in_buffer = data->in_buffer_allocated;
data->in = data->in_buffer;
data->in_buffer_size = data->block_size;
}
if (data->out_buffer == NULL || data->in_buffer_allocated == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
return (ARCHIVE_FATAL);
}
f->write = archive_filter_lz4_write;
return (ARCHIVE_OK);
}
/*
* Setup callback.
*/
static int
archive_compressor_bzip2_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
ret = __archive_write_open_filter(f->next_filter);
if (ret != 0)
return (ret);
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
* per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0)
bs -= bs % bpb;
}
data->compressed_buffer_size = bs;
data->compressed
= (char *)malloc(data->compressed_buffer_size);
if (data->compressed == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
return (ARCHIVE_FATAL);
}
}
memset(&data->stream, 0, sizeof(data->stream));
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
f->write = archive_compressor_bzip2_write;
/* Initialize compression library */
ret = BZ2_bzCompressInit(&(data->stream),
data->compression_level, 0, 30);
if (ret == BZ_OK) {
f->data = data;
return (ARCHIVE_OK);
}
/* Library setup failed: clean up. */
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library");
/* Override the error message if we know what really went wrong. */
switch (ret) {
case BZ_PARAM_ERROR:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"invalid setup parameter");
break;
case BZ_MEM_ERROR:
archive_set_error(f->archive, ENOMEM,
"Internal error initializing compression library: "
"out of memory");
break;
case BZ_CONFIG_ERROR:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"mis-compiled library");
break;
}
return (ARCHIVE_FATAL);
}
/*
* Setup callback.
*/
static int
archive_compressor_compress_open(struct archive_write_filter *f)
{
int ret;
struct private_data *state;
size_t bs = 65536, bpb;
f->code = ARCHIVE_COMPRESSION_COMPRESS;
f->name = "compress";
ret = __archive_write_open_filter(f->next_filter);
if (ret != ARCHIVE_OK)
return (ret);
state = (struct private_data *)calloc(1, sizeof(*state));
if (state == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression");
return (ARCHIVE_FATAL);
}
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
* per block for performance. */
bpb = archive_write_get_bytes_per_block(f->archive);
if (bpb > bs)
bs = bpb;
else if (bpb != 0)
bs -= bs % bpb;
}
state->compressed_buffer_size = bs;
state->compressed = malloc(state->compressed_buffer_size);
if (state->compressed == NULL) {
archive_set_error(f->archive, ENOMEM,
"Can't allocate data for compression buffer");
free(state);
return (ARCHIVE_FATAL);
}
f->write = archive_compressor_compress_write;
f->close = archive_compressor_compress_close;
f->free = archive_compressor_compress_free;
state->max_maxcode = 0x10000; /* Should NEVER generate this code. */
state->in_count = 0; /* Length of input. */
state->bit_buf = 0;
state->bit_offset = 0;
state->out_count = 3; /* Includes 3-byte header mojo. */
state->compress_ratio = 0;
state->checkpoint = CHECK_GAP;
state->code_len = 9;
state->cur_maxcode = MAXCODE(state->code_len);
state->first_free = FIRST;
memset(state->hashtab, 0xff, sizeof(state->hashtab));
/* Prime output buffer with a gzip header. */
state->compressed[0] = 0x1f; /* Compress */
state->compressed[1] = 0x9d;
state->compressed[2] = 0x90; /* Block mode, 16bit max */
state->compressed_offset = 3;
f->data = state;
return (0);
}
