/* 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; }