static int
Compressor_init_alone(lzma_stream *lzs, uint32_t preset, PyObject *filterspecs)
{
lzma_ret lzret;
if (filterspecs == Py_None) {
lzma_options_lzma options;
if (lzma_lzma_preset(&options, preset)) {
PyErr_Format(Error, "Invalid compression preset: %d", preset);
return -1;
}
lzret = lzma_alone_encoder(lzs, &options);
} else {
lzma_filter filters[LZMA_FILTERS_MAX + 1];
if (parse_filter_chain_spec(filters, filterspecs) == -1)
return -1;
if (filters[0].id == LZMA_FILTER_LZMA1 &&
filters[1].id == LZMA_VLI_UNKNOWN) {
lzret = lzma_alone_encoder(lzs, filters[0].options);
} else {
PyErr_SetString(PyExc_ValueError,
"Invalid filter chain for FORMAT_ALONE - "
"must be a single LZMA1 filter");
lzret = LZMA_PROG_ERROR;
}
free_filter_chain(filters);
}
if (PyErr_Occurred() || catch_lzma_error(lzret))
return -1;
else
return 0;
}
static int
archive_compressor_xz_init_stream(struct archive_write *a,
struct private_data *state)
{
int ret;
state->stream = (lzma_stream)LZMA_STREAM_INIT;
state->stream.next_out = state->compressed;
state->stream.avail_out = state->compressed_buffer_size;
if (a->archive.compression_code == ARCHIVE_COMPRESSION_XZ)
ret = lzma_stream_encoder(&(state->stream),
state->lzmafilters, LZMA_CHECK_CRC64);
else
ret = lzma_alone_encoder(&(state->stream), &state->lzma_opt);
if (ret == LZMA_OK)
return (ARCHIVE_OK);
switch (ret) {
case LZMA_MEM_ERROR:
archive_set_error(&a->archive, ENOMEM,
"Internal error initializing compression library: "
"Cannot allocate memory");
break;
default:
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"It's a bug in liblzma");
break;
}
return (ARCHIVE_FATAL);
}
/*@null@*/
static XZFILE *xzopen_internal(const char *path, const char *mode, int fdno, int xz)
/*@globals fileSystem @*/
/*@modifies fileSystem @*/
{
int level = LZMA_PRESET_DEFAULT;
int encoding = 0;
FILE *fp;
XZFILE *xzfile;
lzma_stream tmp;
lzma_ret ret;
for (; *mode != '\0'; mode++) {
if (*mode == 'w')
encoding = 1;
else if (*mode == 'r')
encoding = 0;
else if (*mode >= '0' && *mode <= '9')
level = (int)(*mode - '0');
}
if (fdno != -1)
fp = fdopen(fdno, encoding ? "w" : "r");
else
fp = fopen(path, encoding ? "w" : "r");
if (!fp)
return NULL;
xzfile = calloc(1, sizeof(*xzfile));
if (!xzfile) {
(void) fclose(fp);
return NULL;
}
xzfile->fp = fp;
xzfile->encoding = encoding;
xzfile->eof = 0;
tmp = (lzma_stream)LZMA_STREAM_INIT;
xzfile->strm = tmp;
if (encoding) {
if (xz) {
ret = lzma_easy_encoder(&xzfile->strm, level, LZMA_CHECK_CRC32);
} else {
lzma_options_lzma options;
(void) lzma_lzma_preset(&options, level);
ret = lzma_alone_encoder(&xzfile->strm, &options);
}
} else {
/* We set the memlimit for decompression to 100MiB which should be
* more than enough to be sufficient for level 9 which requires 65 MiB.
*/
ret = lzma_auto_decoder(&xzfile->strm, 100<<20, 0);
}
if (ret != LZMA_OK) {
(void) fclose(fp);
memset(xzfile, 0, sizeof(*xzfile));
free(xzfile);
return NULL;
}
return xzfile;
}
static LZFILE *lzopen_internal(const char *path, const char *mode, int fd, int xz)
{
int level = 7; /* Use XZ's default compression level if unspecified */
int encoding = 0;
FILE *fp;
LZFILE *lzfile;
lzma_ret ret;
lzma_stream init_strm = LZMA_STREAM_INIT;
for (; *mode; mode++) {
if (*mode == 'w')
encoding = 1;
else if (*mode == 'r')
encoding = 0;
else if (*mode >= '1' && *mode <= '9')
level = *mode - '0';
}
if (fd != -1)
fp = fdopen(fd, encoding ? "w" : "r");
else
fp = fopen(path, encoding ? "w" : "r");
if (!fp)
return 0;
lzfile = calloc(1, sizeof(*lzfile));
if (!lzfile) {
fclose(fp);
return 0;
}
lzfile->file = fp;
lzfile->encoding = encoding;
lzfile->eof = 0;
lzfile->strm = init_strm;
if (encoding) {
if (xz) {
ret = lzma_easy_encoder(&lzfile->strm, level, LZMA_CHECK_SHA256);
} else {
lzma_options_lzma options;
lzma_lzma_preset(&options, level);
ret = lzma_alone_encoder(&lzfile->strm, &options);
}
} else { /* lzma_easy_decoder_memusage(level) is not ready yet, use hardcoded limit for now */
ret = lzma_auto_decoder(&lzfile->strm, 100<<20, 0);
}
if (ret != LZMA_OK) {
fclose(fp);
free(lzfile);
return 0;
}
return lzfile;
}
static void
filter_lzma_init(struct io_lzma *io, lzma_stream *s)
{
uint32_t preset;
lzma_options_lzma options;
lzma_ret ret;
io->status |= DPKG_STREAM_COMPRESS;
preset = io->params->level;
if (io->params->strategy == COMPRESSOR_STRATEGY_EXTREME)
preset |= LZMA_PRESET_EXTREME;
if (lzma_lzma_preset(&options, preset))
filter_lzma_error(io, LZMA_OPTIONS_ERROR);
ret = lzma_alone_encoder(s, &options);
if (ret != LZMA_OK)
filter_lzma_error(io, ret);
}
static inline lzma_ret setup_alone_encoder(lzma_stream *strm, int level)
{
lzma_options_lzma options;
lzma_lzma_preset(&options, level);
return lzma_alone_encoder(strm, &options);
}
static int
archive_compressor_xz_init_stream(struct archive_write_filter *f,
struct private_data *data)
{
static const lzma_stream lzma_stream_init_data = LZMA_STREAM_INIT;
int ret;
data->stream = lzma_stream_init_data;
data->stream.next_out = data->compressed;
data->stream.avail_out = data->compressed_buffer_size;
if (f->code == ARCHIVE_FILTER_XZ)
ret = lzma_stream_encoder(&(data->stream),
data->lzmafilters, LZMA_CHECK_CRC64);
else if (f->code == ARCHIVE_FILTER_LZMA)
ret = lzma_alone_encoder(&(data->stream), &data->lzma_opt);
else { /* ARCHIVE_FILTER_LZIP */
int dict_size = data->lzma_opt.dict_size;
int ds, log2dic, wedges;
/* Calculate a coded dictionary size */
if (dict_size < (1 << 12) || dict_size > (1 << 27)) {
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Unacceptable dictionary dize for lzip: %d",
dict_size);
return (ARCHIVE_FATAL);
}
for (log2dic = 27; log2dic >= 12; log2dic--) {
if (dict_size & (1 << log2dic))
break;
}
if (dict_size > (1 << log2dic)) {
log2dic++;
wedges =
((1 << log2dic) - dict_size) / (1 << (log2dic - 4));
} else
wedges = 0;
ds = ((wedges << 5) & 0xe0) | (log2dic & 0x1f);
data->crc32 = 0;
/* Make a header */
data->compressed[0] = 0x4C;
data->compressed[1] = 0x5A;
data->compressed[2] = 0x49;
data->compressed[3] = 0x50;
data->compressed[4] = 1;/* Version */
data->compressed[5] = (unsigned char)ds;
data->stream.next_out += 6;
data->stream.avail_out -= 6;
ret = lzma_raw_encoder(&(data->stream), data->lzmafilters);
}
if (ret == LZMA_OK)
return (ARCHIVE_OK);
switch (ret) {
case LZMA_MEM_ERROR:
archive_set_error(f->archive, ENOMEM,
"Internal error initializing compression library: "
"Cannot allocate memory");
break;
default:
archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
"Internal error initializing compression library: "
"It's a bug in liblzma");
break;
}
return (ARCHIVE_FATAL);
}
