/* initialize private fields */
static int fastlzlibInit(zfast_stream *s, int block_size) {
if (s != NULL) {
int code;
if (fastlzlibGetBlockSizeLevel(block_size) == -1) {
s->msg = "block size is invalid";
return Z_STREAM_ERROR;
}
s->state = (zfast_stream_internal*)
zalloc(s, sizeof(zfast_stream_internal), 1);
strcpy(s->state->magic, MAGIC);
s->state->compress = NULL;
s->state->decompress = NULL;
if ( ( code = fastlzlibSetCompressor(s, COMPRESSOR_DEFAULT) ) != Z_OK) {
fastlzlibFree(s);
return code;
}
s->state->block_size = (uInt) block_size;
s->state->inBuff = zalloc(s, BUFFER_BLOCK_SIZE(s), 1);
s->state->outBuff = zalloc(s, BUFFER_BLOCK_SIZE(s), 1);
if (s->state->inBuff != NULL && s->state->outBuff != NULL) {
fastlzlibReset(s);
return Z_OK;
}
s->msg = "memory exhausted";
fastlzlibFree(s);
} else {
return Z_STREAM_ERROR;
}
return Z_MEM_ERROR;
}
static bool decompress_with_fastlz(JCR *jcr,
const char *last_fname,
char **data,
uint32_t *length,
uint32_t comp_magic,
bool sparse,
bool want_data_stream)
{
int zstat;
zfast_stream stream;
zfast_stream_compressor compressor = COMPRESSOR_FASTLZ;
char ec1[50]; /* Buffer printing huge values */
switch (comp_magic) {
case COMPRESS_FZ4L:
case COMPRESS_FZ4H:
compressor = COMPRESSOR_LZ4;
break;
}
/*
* NOTE! We only use uInt and Bytef because they are
* needed by the fastlz routines, they should not otherwise
* be used in Bareos.
*/
memset(&stream, 0, sizeof(stream));
stream.next_in = (Bytef *)*data + sizeof(comp_stream_header);
stream.avail_in = (uInt)*length - sizeof(comp_stream_header);
if (sparse && want_data_stream) {
stream.next_out = (Bytef *)jcr->compress.inflate_buffer + OFFSET_FADDR_SIZE;
stream.avail_out = (uInt)jcr->compress.inflate_buffer_size - OFFSET_FADDR_SIZE;
} else {
stream.next_out = (Bytef *)jcr->compress.inflate_buffer;
stream.avail_out = (uInt)jcr->compress.inflate_buffer_size;
}
Dmsg2(400, "Comp_len=%d msglen=%d\n", stream.avail_in, *length);
if ((zstat = fastlzlibDecompressInit(&stream)) != Z_OK) {
goto cleanup;
}
if ((zstat = fastlzlibSetCompressor(&stream, compressor)) != Z_OK) {
goto cleanup;
}
while (1) {
zstat = fastlzlibDecompress(&stream);
switch (zstat) {
case Z_BUF_ERROR:
/*
* The buffer size is too small, try with a bigger one
*/
jcr->compress.inflate_buffer_size = jcr->compress.inflate_buffer_size + (jcr->compress.inflate_buffer_size >> 1);
jcr->compress.inflate_buffer = check_pool_memory_size(jcr->compress.inflate_buffer, jcr->compress.inflate_buffer_size);
if (sparse && want_data_stream) {
stream.next_out = (Bytef *)jcr->compress.inflate_buffer + OFFSET_FADDR_SIZE;
stream.avail_out = (uInt)jcr->compress.inflate_buffer_size - OFFSET_FADDR_SIZE;
} else {
stream.next_out = (Bytef *)jcr->compress.inflate_buffer;
stream.avail_out = (uInt)jcr->compress.inflate_buffer_size;
}
continue;
case Z_OK:
case Z_STREAM_END:
break;
default:
goto cleanup;
}
break;
}
/*
* We return a decompressed data stream with the fileoffset encoded when this was a sparse stream.
*/
if (sparse && want_data_stream) {
memcpy(jcr->compress.inflate_buffer, *data, OFFSET_FADDR_SIZE);
}
*data = jcr->compress.inflate_buffer;
*length = stream.total_out;
Dmsg2(400, "Write uncompressed %d bytes, total before write=%s\n", *length, edit_uint64(jcr->JobBytes, ec1));
fastlzlibDecompressEnd(&stream);
return true;
cleanup:
Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"), last_fname, zlib_strerror(zstat));
fastlzlibDecompressEnd(&stream);
return false;
}
bool setup_compression_context(b_ctx &bctx)
{
bool retval = false;
if ((bctx.ff_pkt->flags & FO_COMPRESS)) {
/*
* See if we need to be compatible with the old GZIP stream encoding.
*/
if (!me->compatible || bctx.ff_pkt->Compress_algo != COMPRESS_GZIP) {
memset(&bctx.ch, 0, sizeof(comp_stream_header));
/*
* Calculate buffer offsets.
*/
if ((bctx.ff_pkt->flags & FO_SPARSE) ||
(bctx.ff_pkt->flags & FO_OFFSETS)) {
bctx.chead = (uint8_t *)bctx.jcr->compress.deflate_buffer + OFFSET_FADDR_SIZE;
bctx.cbuf = (uint8_t *)bctx.jcr->compress.deflate_buffer + OFFSET_FADDR_SIZE + sizeof(comp_stream_header);
bctx.max_compress_len = bctx.jcr->compress.deflate_buffer_size - (sizeof(comp_stream_header) + OFFSET_FADDR_SIZE);
} else {
bctx.chead = (uint8_t *)bctx.jcr->compress.deflate_buffer;
bctx.cbuf = (uint8_t *)bctx.jcr->compress.deflate_buffer + sizeof(comp_stream_header);
bctx.max_compress_len = bctx.jcr->compress.deflate_buffer_size - sizeof(comp_stream_header);
}
bctx.wbuf = bctx.jcr->compress.deflate_buffer; /* compressed output here */
bctx.cipher_input = (uint8_t *)bctx.jcr->compress.deflate_buffer; /* encrypt compressed data */
bctx.ch.magic = bctx.ff_pkt->Compress_algo;
bctx.ch.version = COMP_HEAD_VERSION;
} else {
/*
* Calculate buffer offsets.
*/
bctx.chead = NULL;
if ((bctx.ff_pkt->flags & FO_SPARSE) ||
(bctx.ff_pkt->flags & FO_OFFSETS)) {
bctx.cbuf = (uint8_t *)bctx.jcr->compress.deflate_buffer + OFFSET_FADDR_SIZE;
bctx.max_compress_len = bctx.jcr->compress.deflate_buffer_size - OFFSET_FADDR_SIZE;
} else {
bctx.cbuf = (uint8_t *)bctx.jcr->compress.deflate_buffer;
bctx.max_compress_len = bctx.jcr->compress.deflate_buffer_size;
}
bctx.wbuf = bctx.jcr->compress.deflate_buffer; /* compressed output here */
bctx.cipher_input = (uint8_t *)bctx.jcr->compress.deflate_buffer; /* encrypt compressed data */
}
/*
* Do compression specific actions and set the magic, header version and compression level.
*/
switch (bctx.ff_pkt->Compress_algo) {
#if defined(HAVE_LIBZ)
case COMPRESS_GZIP: {
z_stream *pZlibStream;
/**
* Only change zlib parameters if there is no pending operation.
* This should never happen as deflateReset is called after each
* deflate.
*/
pZlibStream = (z_stream *)bctx.jcr->compress.workset.pZLIB;
if (pZlibStream->total_in == 0) {
int zstat;
/*
* Set gzip compression level - must be done per file
*/
if ((zstat = deflateParams(pZlibStream, bctx.ff_pkt->Compress_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
Jmsg(bctx.jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
bctx.jcr->setJobStatus(JS_ErrorTerminated);
goto bail_out;
}
}
bctx.ch.level = bctx.ff_pkt->Compress_level;
break;
}
#endif
#if defined(HAVE_LZO)
case COMPRESS_LZO1X:
break;
#endif
#if defined(HAVE_FASTLZ)
case COMPRESS_FZFZ:
case COMPRESS_FZ4L:
case COMPRESS_FZ4H: {
int zstat;
zfast_stream *pZfastStream;
zfast_stream_compressor compressor = COMPRESSOR_FASTLZ;
/**
* Only change fastlz parameters if there is no pending operation.
* This should never happen as fastlzlibCompressReset is called after each
* fastlzlibCompress.
*/
pZfastStream = (zfast_stream *)bctx.jcr->compress.workset.pZFAST;
if (pZfastStream->total_in == 0) {
switch (bctx.ff_pkt->Compress_algo) {
case COMPRESS_FZ4L:
case COMPRESS_FZ4H:
compressor = COMPRESSOR_LZ4;
break;
}
if ((zstat = fastlzlibSetCompressor(pZfastStream, compressor)) != Z_OK) {
Jmsg(bctx.jcr, M_FATAL, 0, _("Compression fastlzlibSetCompressor error: %d\n"), zstat);
bctx.jcr->setJobStatus(JS_ErrorTerminated);
goto bail_out;
}
}
bctx.ch.level = bctx.ff_pkt->Compress_level;
break;
}
#endif
default:
break;
}
}
retval = true;
bail_out:
return retval;
}
/*
* Setup deflate for auto deflate of data streams.
*/
static bool setup_auto_deflation(DCR *dcr)
{
JCR *jcr = dcr->jcr;
bool retval = false;
uint32_t compress_buf_size = 0;
if (jcr->buf_size == 0) {
jcr->buf_size = DEFAULT_NETWORK_BUFFER_SIZE;
}
if (!setup_compression_buffers(jcr, sd_enabled_compatible,
dcr->device->autodeflate_algorithm,
&compress_buf_size)) {
goto bail_out;
}
/*
* See if we need to create a new compression buffer or make sure the existing is big enough.
*/
if (!jcr->compress.deflate_buffer) {
jcr->compress.deflate_buffer = get_memory(compress_buf_size);
jcr->compress.deflate_buffer_size = compress_buf_size;
} else {
if (compress_buf_size > jcr->compress.deflate_buffer_size) {
jcr->compress.deflate_buffer = realloc_pool_memory(jcr->compress.deflate_buffer, compress_buf_size);
jcr->compress.deflate_buffer_size = compress_buf_size;
}
}
switch (dcr->device->autodeflate_algorithm) {
#if defined(HAVE_LIBZ)
case COMPRESS_GZIP: {
int zstat;
z_stream *pZlibStream;
pZlibStream = (z_stream *)jcr->compress.workset.pZLIB;
if ((zstat = deflateParams(pZlibStream, dcr->device->autodeflate_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
jcr->setJobStatus(JS_ErrorTerminated);
goto bail_out;
}
break;
}
#endif
#if defined(HAVE_LZO)
case COMPRESS_LZO1X:
break;
#endif
#if defined(HAVE_FASTLZ)
case COMPRESS_FZFZ:
case COMPRESS_FZ4L:
case COMPRESS_FZ4H: {
int zstat;
zfast_stream *pZfastStream;
zfast_stream_compressor compressor = COMPRESSOR_FASTLZ;
switch (dcr->device->autodeflate_algorithm) {
case COMPRESS_FZ4L:
case COMPRESS_FZ4H:
compressor = COMPRESSOR_LZ4;
break;
}
pZfastStream = (zfast_stream *)jcr->compress.workset.pZFAST;
if ((zstat = fastlzlibSetCompressor(pZfastStream, compressor)) != Z_OK) {
Jmsg(jcr, M_FATAL, 0, _("Compression fastlzlibSetCompressor error: %d\n"), zstat);
jcr->setJobStatus(JS_ErrorTerminated);
goto bail_out;
}
break;
}
#endif
default:
break;
}
retval = true;
bail_out:
return retval;
}