/*
* Add a lz4 compression filter to this write handle.
*/
int
archive_write_add_filter_lz4(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_lz4");
data = calloc(1, sizeof(*data));
if (data == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
/*
* Setup default settings.
*/
data->compression_level = 1;
data->version_number = 0x01;
data->block_independence = 1;
data->block_checksum = 0;
data->stream_size = 0;
data->stream_checksum = 1;
data->preset_dictionary = 0;
data->block_maximum_size = 7;
/*
* Setup a filter setting.
*/
f->data = data;
f->options = &archive_filter_lz4_options;
f->close = &archive_filter_lz4_close;
f->free = &archive_filter_lz4_free;
f->open = &archive_filter_lz4_open;
f->code = ARCHIVE_FILTER_LZ4;
f->name = "lz4";
#if defined(HAVE_LIBLZ4) && LZ4_VERSION_MAJOR >= 1 && LZ4_VERSION_MINOR >= 2
return (ARCHIVE_OK);
#else
/*
* We don't have lz4 library, and execute external lz4 program
* instead.
*/
data->pdata = __archive_write_program_allocate("lz4");
if (data->pdata == NULL) {
free(data);
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
data->compression_level = 0;
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Using external lz4 program");
return (ARCHIVE_WARN);
#endif
}
/*
* Add a filter to this write handle that passes all data through an
* external program.
*/
int
archive_write_add_filter_program(struct archive *_a, const char *cmd)
{
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
static const char *prefix = "Program: ";
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_program");
f->data = calloc(1, sizeof(*data));
if (f->data == NULL)
goto memerr;
data = (struct private_data *)f->data;
data->cmd = strdup(cmd);
if (data->cmd == NULL)
goto memerr;
data->pdata = __archive_write_program_allocate();
if (data->pdata == NULL)
goto memerr;
/* Make up a description string. */
if (archive_string_ensure(&data->description,
strlen(prefix) + strlen(cmd) + 1) == NULL)
goto memerr;
archive_strcpy(&data->description, prefix);
archive_strcat(&data->description, cmd);
f->name = data->description.s;
f->code = ARCHIVE_FILTER_PROGRAM;
f->open = archive_compressor_program_open;
f->write = archive_compressor_program_write;
f->close = archive_compressor_program_close;
f->free = archive_compressor_program_free;
return (ARCHIVE_OK);
memerr:
archive_compressor_program_free(f);
archive_set_error(_a, ENOMEM,
"Can't allocate memory for filter program");
return (ARCHIVE_FATAL);
}
/*
* Add a bzip2 compression filter to this write handle.
*/
int
archive_write_add_filter_bzip2(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_bzip2");
data = calloc(1, sizeof(*data));
if (data == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
data->compression_level = 9; /* default */
f->data = data;
f->options = &archive_compressor_bzip2_options;
f->close = &archive_compressor_bzip2_close;
f->free = &archive_compressor_bzip2_free;
f->open = &archive_compressor_bzip2_open;
f->code = ARCHIVE_FILTER_BZIP2;
f->name = "bzip2";
#if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
return (ARCHIVE_OK);
#else
data->pdata = __archive_write_program_allocate("bzip2");
if (data->pdata == NULL) {
free(data);
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
data->compression_level = 0;
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Using external bzip2 program");
return (ARCHIVE_WARN);
#endif
}
/*
* Add a gzip compression filter to this write handle.
*/
int
archive_write_add_filter_gzip(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_gzip");
data = calloc(1, sizeof(*data));
if (data == NULL) {
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
f->data = data;
f->open = &archive_compressor_gzip_open;
f->options = &archive_compressor_gzip_options;
f->close = &archive_compressor_gzip_close;
f->free = &archive_compressor_gzip_free;
f->code = ARCHIVE_FILTER_GZIP;
f->name = "gzip";
#ifdef HAVE_ZLIB_H
data->compression_level = Z_DEFAULT_COMPRESSION;
return (ARCHIVE_OK);
#else
data->pdata = __archive_write_program_allocate();
if (data->pdata == NULL) {
free(data);
archive_set_error(&a->archive, ENOMEM, "Out of memory");
return (ARCHIVE_FATAL);
}
data->compression_level = 0;
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Using external gzip program");
return (ARCHIVE_WARN);
#endif
}
int
archive_write_add_filter_lrzip(struct archive *_a)
{
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct write_lrzip *data;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_lrzip");
data = calloc(1, sizeof(*data));
if (data == NULL) {
archive_set_error(_a, ENOMEM, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
data->pdata = __archive_write_program_allocate("lrzip");
if (data->pdata == NULL) {
free(data);
archive_set_error(_a, ENOMEM, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
f->name = "lrzip";
f->code = ARCHIVE_FILTER_LRZIP;
f->data = data;
f->open = archive_write_lrzip_open;
f->options = archive_write_lrzip_options;
f->write = archive_write_lrzip_write;
f->close = archive_write_lrzip_close;
f->free = archive_write_lrzip_free;
/* Note: This filter always uses an external program, so we
* return "warn" to inform of the fact. */
archive_set_error(_a, ARCHIVE_ERRNO_MISC,
"Using external lrzip program for lrzip compression");
return (ARCHIVE_WARN);
}