Decodes .xz Streams. More...

#include "stream_decoder.h"
#include "block_decoder.h"

Classes
struct	lzma_stream_coder

Functions
static lzma_ret	stream_decoder_reset (lzma_stream_coder coder, const lzma_allocator allocator)

static lzma_ret	stream_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	stream_decoder_end (void coder_ptr, const lzma_allocator allocator)

static lzma_check	stream_decoder_get_check (const void *coder_ptr)

static lzma_ret	stream_decoder_memconfig (void coder_ptr, uint64_t memusage, uint64_t *old_memlimit, uint64_t new_memlimit)

lzma_ret	lzma_stream_decoder_init (lzma_next_coder next, const lzma_allocator allocator, uint64_t memlimit, uint32_t flags)

	LZMA_API (lzma_ret)

Detailed Description

Decodes .xz Streams.

Definition in file stream_decoder.c.

Function Documentation

◆ LZMA_API()

LZMA_API ( lzma_ret )

Definition at line 458 of file stream_decoder.c.

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

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

◆ lzma_stream_decoder_init()

lzma_ret lzma_stream_decoder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		uint64_t	memlimit,
		uint32_t	flags
	)

Definition at line 419 of file stream_decoder.c.

 {
     lzma_next_coder_init(&lzma_stream_decoder_init, next, allocator);
  
     if (flags & ~LZMA_SUPPORTED_FLAGS)
         return LZMA_OPTIONS_ERROR;
  
     lzma_stream_coder *coder = next->coder;
     if (coder == NULL) {
         coder = lzma_alloc(sizeof(lzma_stream_coder), allocator);
         if (coder == NULL)
             return LZMA_MEM_ERROR;
  
         next->coder = coder;
         next->code = &stream_decode;
         next->end = &stream_decoder_end;
         next->get_check = &stream_decoder_get_check;
         next->memconfig = &stream_decoder_memconfig;
  
         coder->block_decoder = LZMA_NEXT_CODER_INIT;
         coder->index_hash = NULL;
     }
  
     coder->memlimit = my_max(1, memlimit);
     coder->memusage = LZMA_MEMUSAGE_BASE;
     coder->tell_no_check = (flags & LZMA_TELL_NO_CHECK) != 0;
     coder->tell_unsupported_check
             = (flags & LZMA_TELL_UNSUPPORTED_CHECK) != 0;
     coder->tell_any_check = (flags & LZMA_TELL_ANY_CHECK) != 0;
     coder->ignore_check = (flags & LZMA_IGNORE_CHECK) != 0;
     coder->concatenated = (flags & LZMA_CONCATENATED) != 0;
     coder->first_stream = true;
  
     return stream_decoder_reset(coder, allocator);
 }

Referenced by auto_decode(), and LZMA_API().

◆ stream_decode()

static lzma_ret stream_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 103 of file stream_decoder.c.

 {
     lzma_stream_coder *coder = coder_ptr;
  
     // When decoding the actual Block, it may be able to produce more
     // output even if we don't give it any new input.
     while (true)
     switch (coder->sequence) {
     case SEQ_STREAM_HEADER: {
         // Copy the Stream Header to the internal buffer.
         lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
                 LZMA_STREAM_HEADER_SIZE);
  
         // Return if we didn't get the whole Stream Header yet.
         if (coder->pos < LZMA_STREAM_HEADER_SIZE)
             return LZMA_OK;
  
         coder->pos = 0;
  
         // Decode the Stream Header.
         const lzma_ret ret = lzma_stream_header_decode(
                 &coder->stream_flags, coder->buffer);
         if (ret != LZMA_OK)
             return ret == LZMA_FORMAT_ERROR && !coder->first_stream
                     ? LZMA_DATA_ERROR : ret;
  
         // If we are decoding concatenated Streams, and the later
         // Streams have invalid Header Magic Bytes, we give
         // LZMA_DATA_ERROR instead of LZMA_FORMAT_ERROR.
         coder->first_stream = false;
  
         // Copy the type of the Check so that Block Header and Block
         // decoders see it.
         coder->block_options.check = coder->stream_flags.check;
  
         // Even if we return LZMA_*_CHECK below, we want
         // to continue from Block Header decoding.
         coder->sequence = SEQ_BLOCK_HEADER;
  
         // Detect if there's no integrity check or if it is
         // unsupported if those were requested by the application.
         if (coder->tell_no_check && coder->stream_flags.check
                 == LZMA_CHECK_NONE)
             return LZMA_NO_CHECK;
  
         if (coder->tell_unsupported_check
                 && !lzma_check_is_supported(
                     coder->stream_flags.check))
             return LZMA_UNSUPPORTED_CHECK;
  
         if (coder->tell_any_check)
             return LZMA_GET_CHECK;
     }
  
     // Fall through
  
     case SEQ_BLOCK_HEADER: {
         if (*in_pos >= in_size)
             return LZMA_OK;
  
         if (coder->pos == 0) {
             // Detect if it's Index.
             if (in[*in_pos] == 0x00) {
                 coder->sequence = SEQ_INDEX;
                 break;
             }
  
             // Calculate the size of the Block Header. Note that
             // Block Header decoder wants to see this byte too
             // so don't advance *in_pos.
             coder->block_options.header_size
                     = lzma_block_header_size_decode(
                         in[*in_pos]);
         }
  
         // Copy the Block Header to the internal buffer.
         lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
                 coder->block_options.header_size);
  
         // Return if we didn't get the whole Block Header yet.
         if (coder->pos < coder->block_options.header_size)
             return LZMA_OK;
  
         coder->pos = 0;
  
         // Version 1 is needed to support the .ignore_check option.
         coder->block_options.version = 1;
  
         // Set up a buffer to hold the filter chain. Block Header
         // decoder will initialize all members of this array so
         // we don't need to do it here.
         lzma_filter filters[LZMA_FILTERS_MAX + 1];
         coder->block_options.filters = filters;
  
         // Decode the Block Header.
         return_if_error(lzma_block_header_decode(&coder->block_options,
                 allocator, coder->buffer));
  
         // If LZMA_IGNORE_CHECK was used, this flag needs to be set.
         // It has to be set after lzma_block_header_decode() because
         // it always resets this to false.
         coder->block_options.ignore_check = coder->ignore_check;
  
         // Check the memory usage limit.
         const uint64_t memusage = lzma_raw_decoder_memusage(filters);
         lzma_ret ret;
  
         if (memusage == UINT64_MAX) {
             // One or more unknown Filter IDs.
             ret = LZMA_OPTIONS_ERROR;
         } else {
             // Now we can set coder->memusage since we know that
             // the filter chain is valid. We don't want
             // lzma_memusage() to return UINT64_MAX in case of
             // invalid filter chain.
             coder->memusage = memusage;
  
             if (memusage > coder->memlimit) {
                 // The chain would need too much memory.
                 ret = LZMA_MEMLIMIT_ERROR;
             } else {
                 // Memory usage is OK.
                 // Initialize the Block decoder.
                 ret = lzma_block_decoder_init(
                         &coder->block_decoder,
                         allocator,
                         &coder->block_options);
             }
         }
  
         // Free the allocated filter options since they are needed
         // only to initialize the Block decoder.
         for (size_t i = 0; i < LZMA_FILTERS_MAX; ++i)
             lzma_free(filters[i].options, allocator);
  
         coder->block_options.filters = NULL;
  
         // Check if memory usage calculation and Block enocoder
         // initialization succeeded.
         if (ret != LZMA_OK)
             return ret;
  
         coder->sequence = SEQ_BLOCK;
     }
  
     // Fall through
  
     case SEQ_BLOCK: {
         const lzma_ret ret = coder->block_decoder.code(
                 coder->block_decoder.coder, allocator,
                 in, in_pos, in_size, out, out_pos, out_size,
                 action);
  
         if (ret != LZMA_STREAM_END)
             return ret;
  
         // Block decoded successfully. Add the new size pair to
         // the Index hash.
         return_if_error(lzma_index_hash_append(coder->index_hash,
                 lzma_block_unpadded_size(
                     &coder->block_options),
                 coder->block_options.uncompressed_size));
  
         coder->sequence = SEQ_BLOCK_HEADER;
         break;
     }
  
     case SEQ_INDEX: {
         // If we don't have any input, don't call
         // lzma_index_hash_decode() since it would return
         // LZMA_BUF_ERROR, which we must not do here.
         if (*in_pos >= in_size)
             return LZMA_OK;
  
         // Decode the Index and compare it to the hash calculated
         // from the sizes of the Blocks (if any).
         const lzma_ret ret = lzma_index_hash_decode(coder->index_hash,
                 in, in_pos, in_size);
         if (ret != LZMA_STREAM_END)
             return ret;
  
         coder->sequence = SEQ_STREAM_FOOTER;
     }
  
     // Fall through
  
     case SEQ_STREAM_FOOTER: {
         // Copy the Stream Footer to the internal buffer.
         lzma_bufcpy(in, in_pos, in_size, coder->buffer, &coder->pos,
                 LZMA_STREAM_HEADER_SIZE);
  
         // Return if we didn't get the whole Stream Footer yet.
         if (coder->pos < LZMA_STREAM_HEADER_SIZE)
             return LZMA_OK;
  
         coder->pos = 0;
  
         // Decode the Stream Footer. The decoder gives
         // LZMA_FORMAT_ERROR if the magic bytes don't match,
         // so convert that return code to LZMA_DATA_ERROR.
         lzma_stream_flags footer_flags;
         const lzma_ret ret = lzma_stream_footer_decode(
                 &footer_flags, coder->buffer);
         if (ret != LZMA_OK)
             return ret == LZMA_FORMAT_ERROR
                     ? LZMA_DATA_ERROR : ret;
  
         // Check that Index Size stored in the Stream Footer matches
         // the real size of the Index field.
         if (lzma_index_hash_size(coder->index_hash)
                 != footer_flags.backward_size)
             return LZMA_DATA_ERROR;
  
         // Compare that the Stream Flags fields are identical in
         // both Stream Header and Stream Footer.
         return_if_error(lzma_stream_flags_compare(
                 &coder->stream_flags, &footer_flags));
  
         if (!coder->concatenated)
             return LZMA_STREAM_END;
  
         coder->sequence = SEQ_STREAM_PADDING;
     }
  
     // Fall through
  
     case SEQ_STREAM_PADDING:
         assert(coder->concatenated);
  
         // Skip over possible Stream Padding.
         while (true) {
             if (*in_pos >= in_size) {
                 // Unless LZMA_FINISH was used, we cannot
                 // know if there's more input coming later.
                 if (action != LZMA_FINISH)
                     return LZMA_OK;
  
                 // Stream Padding must be a multiple of
                 // four bytes.
                 return coder->pos == 0
                         ? LZMA_STREAM_END
                         : LZMA_DATA_ERROR;
             }
  
             // If the byte is not zero, it probably indicates
             // beginning of a new Stream (or the file is corrupt).
             if (in[*in_pos] != 0x00)
                 break;
  
             ++*in_pos;
             coder->pos = (coder->pos + 1) & 3;
         }
  
         // Stream Padding must be a multiple of four bytes (empty
         // Stream Padding is OK).
         if (coder->pos != 0) {
             ++*in_pos;
             return LZMA_DATA_ERROR;
         }
  
         // Prepare to decode the next Stream.
         return_if_error(stream_decoder_reset(coder, allocator));
         break;
  
     default:
         assert(0);
         return LZMA_PROG_ERROR;
     }
  
     // Never reached
 }

Referenced by lzma_stream_decoder_init().

◆ stream_decoder_end()

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

static

Definition at line 380 of file stream_decoder.c.

 {
     lzma_stream_coder *coder = coder_ptr;
     lzma_next_end(&coder->block_decoder, allocator);
     lzma_index_hash_end(coder->index_hash, allocator);
     lzma_free(coder, allocator);
     return;
 }

References allocator, lzma_stream_coder::block_decoder, lzma_stream_coder::index_hash, lzma_free(), and lzma_next_end().

Referenced by lzma_stream_decoder_init().

◆ stream_decoder_get_check()

static lzma_check stream_decoder_get_check ( const void * coder_ptr )

static

Definition at line 391 of file stream_decoder.c.

 {
     const lzma_stream_coder *coder = coder_ptr;
     return coder->stream_flags.check;
 }

References lzma_stream_flags::check, and lzma_stream_coder::stream_flags.

Referenced by lzma_stream_decoder_init().

◆ stream_decoder_memconfig()

static lzma_ret stream_decoder_memconfig	(	void *	coder_ptr,
		uint64_t *	memusage,
		uint64_t *	old_memlimit,
		uint64_t	new_memlimit
	)

static

Definition at line 399 of file stream_decoder.c.

 {
     lzma_stream_coder *coder = coder_ptr;
  
     *memusage = coder->memusage;
     *old_memlimit = coder->memlimit;
  
     if (new_memlimit != 0) {
         if (new_memlimit < coder->memusage)
             return LZMA_MEMLIMIT_ERROR;
  
         coder->memlimit = new_memlimit;
     }
  
     return LZMA_OK;
 }

References LZMA_MEMLIMIT_ERROR, LZMA_OK, lzma_stream_coder::memlimit, and lzma_stream_coder::memusage.

Referenced by lzma_stream_decoder_init().

◆ stream_decoder_reset()

static lzma_ret stream_decoder_reset	(	lzma_stream_coder *	coder,
		const lzma_allocator *	allocator
	)

static

Definition at line 87 of file stream_decoder.c.

 {
     // Initialize the Index hash used to verify the Index.
     coder->index_hash = lzma_index_hash_init(coder->index_hash, allocator);
     if (coder->index_hash == NULL)
         return LZMA_MEM_ERROR;
  
     // Reset the rest of the variables.
     coder->sequence = SEQ_STREAM_HEADER;
     coder->pos = 0;
  
     return LZMA_OK;
 }

References allocator, lzma_stream_coder::index_hash, LZMA_MEM_ERROR, LZMA_OK, NULL, lzma_stream_coder::pos, and lzma_stream_coder::sequence.

Referenced by lzma_stream_decoder_init(), and stream_decode().

Classes

Functions

Detailed Description

Function Documentation

◆ LZMA_API()

◆ lzma_stream_decoder_init()

◆ stream_decode()

◆ stream_decoder_end()

◆ stream_decoder_get_check()

◆ stream_decoder_memconfig()

◆ stream_decoder_reset()