/* * 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_COMPRESSION_BZIP2; f->name = "bzip2"; return (ARCHIVE_OK); }
/* * Open the archive using the current settings. */ int archive_write_open(struct archive *_a, void *client_data, archive_open_callback *opener, archive_write_callback *writer, archive_close_callback *closer) { struct archive_write *a = (struct archive_write *)_a; struct archive_write_filter *client_filter; int ret, r1; archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_open"); archive_clear_error(&a->archive); a->client_writer = writer; a->client_opener = opener; a->client_closer = closer; a->client_data = client_data; client_filter = __archive_write_allocate_filter(_a); client_filter->open = archive_write_client_open; client_filter->write = archive_write_client_write; client_filter->close = archive_write_client_close; ret = __archive_write_open_filter(a->filter_first); if (ret < ARCHIVE_WARN) { r1 = __archive_write_close_filter(a->filter_first); return (r1 < ret ? r1 : ret); } a->archive.state = ARCHIVE_STATE_HEADER; if (a->format_init) ret = (a->format_init)(a); return (ret); }
/* * 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 archive_write *a = (struct archive_write *)_a; struct private_data *data; static const char *prefix = "Program: "; archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_add_filter_program"); data = calloc(1, sizeof(*data)); if (data == NULL) { archive_set_error(&a->archive, ENOMEM, "Out of memory"); return (ARCHIVE_FATAL); } data->cmd = strdup(cmd); data->description = (char *)malloc(strlen(prefix) + strlen(cmd) + 1); strcpy(data->description, prefix); strcat(data->description, cmd); f->name = data->description; f->data = data; f->open = &archive_compressor_program_open; f->code = ARCHIVE_COMPRESSION_PROGRAM; return (ARCHIVE_OK); }
/* * 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 compress filter to this write handle. */ int archive_write_add_filter_compress(struct archive *_a) { struct archive_write *a = (struct archive_write *)_a; struct archive_write_filter *f = __archive_write_allocate_filter(_a); archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_add_filter_compress"); f->open = &archive_compressor_compress_open; f->code = ARCHIVE_COMPRESSION_COMPRESS; f->name = "compress"; return (ARCHIVE_OK); }
int archive_write_add_filter_lzip(struct archive *_a) { struct archive_write_filter *f; int r; archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, "archive_write_add_filter_lzip"); f = __archive_write_allocate_filter(_a); r = common_setup(f); if (r == ARCHIVE_OK) { f->code = ARCHIVE_FILTER_LZIP; f->name = "lzip"; } return (r); }
/* * 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); }