Decodes .xz Blocks. More...

#include "block_decoder.h"
#include "filter_decoder.h"
#include "check.h"

Classes
struct	lzma_block_coder

Functions
static bool	update_size (lzma_vli *size, lzma_vli add, lzma_vli limit)

static bool	is_size_valid (lzma_vli size, lzma_vli reference)

static lzma_ret	block_decode (void coder_ptr, const lzma_allocator allocator, const uint8_t restrict in, size_t restrict in_pos, size_t in_size, uint8_t restrict out, size_t restrict out_pos, size_t out_size, lzma_action action)

static void	block_decoder_end (void coder_ptr, const lzma_allocator allocator)

lzma_ret	lzma_block_decoder_init (lzma_next_coder next, const lzma_allocator allocator, lzma_block *block)

	LZMA_API (lzma_ret)

Detailed Description

Decodes .xz Blocks.

Definition in file block_decoder.c.

Function Documentation

◆ block_decode()

static lzma_ret block_decode	(	void *	coder_ptr,
		const lzma_allocator *	allocator,
		const uint8_t *restrict	in,
		size_t *restrict	in_pos,
		size_t	in_size,
		uint8_t *restrict	out,
		size_t *restrict	out_pos,
		size_t	out_size,
		lzma_action	action
	)

static

Definition at line 77 of file block_decoder.c.

 {
     lzma_block_coder *coder = coder_ptr;
  
     switch (coder->sequence) {
     case SEQ_CODE: {
         const size_t in_start = *in_pos;
         const size_t out_start = *out_pos;
  
         const lzma_ret ret = coder->next.code(coder->next.coder,
                 allocator, in, in_pos, in_size,
                 out, out_pos, out_size, action);
  
         const size_t in_used = *in_pos - in_start;
         const size_t out_used = *out_pos - out_start;
  
         // NOTE: We compare to compressed_limit here, which prevents
         // the total size of the Block growing past LZMA_VLI_MAX.
         if (update_size(&coder->compressed_size, in_used,
                     coder->compressed_limit)
                 || update_size(&coder->uncompressed_size,
                     out_used,
                     coder->block->uncompressed_size))
             return LZMA_DATA_ERROR;
  
         if (!coder->ignore_check)
             lzma_check_update(&coder->check, coder->block->check,
                     out + out_start, out_used);
  
         if (ret != LZMA_STREAM_END)
             return ret;
  
         // Compressed and Uncompressed Sizes are now at their final
         // values. Verify that they match the values given to us.
         if (!is_size_valid(coder->compressed_size,
                     coder->block->compressed_size)
                 || !is_size_valid(coder->uncompressed_size,
                     coder->block->uncompressed_size))
             return LZMA_DATA_ERROR;
  
         // Copy the values into coder->block. The caller
         // may use this information to construct Index.
         coder->block->compressed_size = coder->compressed_size;
         coder->block->uncompressed_size = coder->uncompressed_size;
  
         coder->sequence = SEQ_PADDING;
     }
  
     // Fall through
  
     case SEQ_PADDING:
         // Compressed Data is padded to a multiple of four bytes.
         while (coder->compressed_size & 3) {
             if (*in_pos >= in_size)
                 return LZMA_OK;
  
             // We use compressed_size here just get the Padding
             // right. The actual Compressed Size was stored to
             // coder->block already, and won't be modified by
             // us anymore.
             ++coder->compressed_size;
  
             if (in[(*in_pos)++] != 0x00)
                 return LZMA_DATA_ERROR;
         }
  
         if (coder->block->check == LZMA_CHECK_NONE)
             return LZMA_STREAM_END;
  
         if (!coder->ignore_check)
             lzma_check_finish(&coder->check, coder->block->check);
  
         coder->sequence = SEQ_CHECK;
  
     // Fall through
  
     case SEQ_CHECK: {
         const size_t check_size = lzma_check_size(coder->block->check);
         lzma_bufcpy(in, in_pos, in_size, coder->block->raw_check,
                 &coder->check_pos, check_size);
         if (coder->check_pos < check_size)
             return LZMA_OK;
  
         // Validate the Check only if we support it.
         // coder->check.buffer may be uninitialized
         // when the Check ID is not supported.
         if (!coder->ignore_check
                 && lzma_check_is_supported(coder->block->check)
                 && memcmp(coder->block->raw_check,
                     coder->check.buffer.u8,
                     check_size) != 0)
             return LZMA_DATA_ERROR;
  
         return LZMA_STREAM_END;
     }
     }
  
     return LZMA_PROG_ERROR;
 }

References test-lz4-speed::action, allocator, lzma_block_coder::block, lzma_check_state::buffer, lzma_block::check, lzma_block_coder::check, lzma_block_coder::check_pos, lzma_next_coder_s::code, lzma_next_coder_s::coder, lzma_block_coder::compressed_limit, lzma_block::compressed_size, lzma_block_coder::compressed_size, lzma_block_coder::ignore_check, in, in_pos, in_size, is_size_valid(), lzma_bufcpy(), lzma_check_finish(), LZMA_CHECK_NONE, lzma_check_update(), LZMA_DATA_ERROR, LZMA_OK, LZMA_PROG_ERROR, LZMA_STREAM_END, lzma_block_coder::next, out, out_pos, lzma_block::raw_check, lzma_block_coder::sequence, lzma_check_state::u8, lzma_block::uncompressed_size, lzma_block_coder::uncompressed_size, and update_size().

Referenced by lzma_block_decoder_init().

◆ block_decoder_end()

static void block_decoder_end	(	void *	coder_ptr,
		const lzma_allocator *	allocator
	)

static

Definition at line 182 of file block_decoder.c.

 {
     lzma_block_coder *coder = coder_ptr;
     lzma_next_end(&coder->next, allocator);
     lzma_free(coder, allocator);
     return;
 }

References allocator, lzma_free(), lzma_next_end(), and lzma_block_coder::next.

Referenced by lzma_block_decoder_init().

◆ is_size_valid()

static bool is_size_valid	(	lzma_vli	size,
		lzma_vli	reference
	)

inlinestatic

Definition at line 70 of file block_decoder.c.

 {
     return reference == LZMA_VLI_UNKNOWN || reference == size;
 }

References LZMA_VLI_UNKNOWN.

Referenced by block_decode().

◆ LZMA_API()

LZMA_API ( lzma_ret )

Definition at line 248 of file block_decoder.c.

 {
     lzma_next_strm_init(lzma_block_decoder_init, strm, block);
  
     strm->internal->supported_actions[LZMA_RUN] = true;
     strm->internal->supported_actions[LZMA_FINISH] = true;
  
     return LZMA_OK;
 }

References lzma_stream::internal, lzma_block_decoder_init(), LZMA_FINISH, lzma_next_strm_init, LZMA_OK, LZMA_RUN, strm, and lzma_internal_s::supported_actions.

◆ lzma_block_decoder_init()

lzma_ret lzma_block_decoder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		lzma_block *	block
	)

Definition at line 192 of file block_decoder.c.

 {
     lzma_next_coder_init(&lzma_block_decoder_init, next, allocator);
  
     // Validate the options. lzma_block_unpadded_size() does that for us
     // except for Uncompressed Size and filters. Filters are validated
     // by the raw decoder.
     if (lzma_block_unpadded_size(block) == 0
             || !lzma_vli_is_valid(block->uncompressed_size))
         return LZMA_PROG_ERROR;
  
     // Allocate *next->coder if needed.
     lzma_block_coder *coder = next->coder;
     if (coder == NULL) {
         coder = lzma_alloc(sizeof(lzma_block_coder), allocator);
         if (coder == NULL)
             return LZMA_MEM_ERROR;
  
         next->coder = coder;
         next->code = &block_decode;
         next->end = &block_decoder_end;
         coder->next = LZMA_NEXT_CODER_INIT;
     }
  
     // Basic initializations
     coder->sequence = SEQ_CODE;
     coder->block = block;
     coder->compressed_size = 0;
     coder->uncompressed_size = 0;
  
     // If Compressed Size is not known, we calculate the maximum allowed
     // value so that encoded size of the Block (including Block Padding)
     // is still a valid VLI and a multiple of four.
     coder->compressed_limit
             = block->compressed_size == LZMA_VLI_UNKNOWN
                 ? (LZMA_VLI_MAX & ~LZMA_VLI_C(3))
                     - block->header_size
                     - lzma_check_size(block->check)
                 : block->compressed_size;
  
     // Initialize the check. It's caller's problem if the Check ID is not
     // supported, and the Block decoder cannot verify the Check field.
     // Caller can test lzma_check_is_supported(block->check).
     coder->check_pos = 0;
     lzma_check_init(&coder->check, block->check);
  
     coder->ignore_check = block->version >= 1
             ? block->ignore_check : false;
  
     // Initialize the filter chain.
     return lzma_raw_decoder_init(&coder->next, allocator,
             block->filters);
 }

References allocator, lzma_block_coder::block, block_decode(), block_decoder_end(), lzma_block::check, lzma_block_coder::check, lzma_block_coder::check_pos, lzma_next_coder_s::code, lzma_next_coder_s::coder, lzma_block_coder::compressed_limit, lzma_block::compressed_size, lzma_block_coder::compressed_size, lzma_next_coder_s::end, lzma_block::filters, lzma_block::header_size, lzma_block::ignore_check, lzma_block_coder::ignore_check, lzma_alloc(), lzma_check_init(), LZMA_MEM_ERROR, LZMA_NEXT_CODER_INIT, lzma_next_coder_init, LZMA_PROG_ERROR, lzma_raw_decoder_init(), LZMA_VLI_C, lzma_vli_is_valid, LZMA_VLI_MAX, LZMA_VLI_UNKNOWN, lzma_block_coder::next, NULL, lzma_block_coder::sequence, lzma_block::uncompressed_size, lzma_block_coder::uncompressed_size, and lzma_block::version.

Referenced by LZMA_API(), and stream_decode().

◆ update_size()

static bool update_size	(	lzma_vli *	size,
		lzma_vli	add,
		lzma_vli	limit
	)