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); }