index_decoder.c File Reference

Decodes the Index field. More...

#include "index.h"
#include "check.h"

Go to the source code of this file.

Classes
struct	lzma_index_coder

Functions
static lzma_ret	index_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 lzma_attribute((__unused__)), size_t *restrict out_pos lzma_attribute((__unused__)), size_t out_size lzma_attribute((__unused__)), lzma_action action lzma_attribute((__unused__)))
static void	index_decoder_end (void *coder_ptr, const lzma_allocator *allocator)
static lzma_ret	index_decoder_memconfig (void *coder_ptr, uint64_t *memusage, uint64_t *old_memlimit, uint64_t new_memlimit)
static lzma_ret	index_decoder_reset (lzma_index_coder *coder, const lzma_allocator *allocator, lzma_index **i, uint64_t memlimit)
static lzma_ret	index_decoder_init (lzma_next_coder *next, const lzma_allocator *allocator, lzma_index **i, uint64_t memlimit)
	LZMA_API (lzma_ret)

Detailed Description

Decodes the Index field.

Definition in file index_decoder.c.

Function Documentation

index_decode()

static lzma_ret index_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   lzma_attribute(__unused__), size_t *restrict out_pos   lzma_attribute(__unused__), size_t out_size   lzma_attribute(__unused__), lzma_action action   lzma_attribute(__unused__)  )

static

Definition at line 57 of file index_decoder.c.

{
    lzma_index_coder *coder = coder_ptr;
 
    // Similar optimization as in index_encoder.c
    const size_t in_start = *in_pos;
    lzma_ret ret = LZMA_OK;
 
    while (*in_pos < in_size)
    switch (coder->sequence) {
    case SEQ_INDICATOR:
        // Return LZMA_DATA_ERROR instead of e.g. LZMA_PROG_ERROR or
        // LZMA_FORMAT_ERROR, because a typical usage case for Index
        // decoder is when parsing the Stream backwards. If seeking
        // backward from the Stream Footer gives us something that
        // doesn't begin with Index Indicator, the file is considered
        // corrupt, not "programming error" or "unrecognized file
        // format". One could argue that the application should
        // verify the Index Indicator before trying to decode the
        // Index, but well, I suppose it is simpler this way.
        if (in[(*in_pos)++] != 0x00)
            return LZMA_DATA_ERROR;
 
        coder->sequence = SEQ_COUNT;
        break;
 
    case SEQ_COUNT:
        ret = lzma_vli_decode(&coder->count, &coder->pos,
                in, in_pos, in_size);
        if (ret != LZMA_STREAM_END)
            goto out;
 
        coder->pos = 0;
        coder->sequence = SEQ_MEMUSAGE;
 
    // Fall through
 
    case SEQ_MEMUSAGE:
        if (lzma_index_memusage(1, coder->count) > coder->memlimit) {
            ret = LZMA_MEMLIMIT_ERROR;
            goto out;
        }
 
        // Tell the Index handling code how many Records this
        // Index has to allow it to allocate memory more efficiently.
        lzma_index_prealloc(coder->index, coder->count);
 
        ret = LZMA_OK;
        coder->sequence = coder->count == 0
                ? SEQ_PADDING_INIT : SEQ_UNPADDED;
        break;
 
    case SEQ_UNPADDED:
    case SEQ_UNCOMPRESSED: {
        lzma_vli *size = coder->sequence == SEQ_UNPADDED
                ? &coder->unpadded_size
                : &coder->uncompressed_size;
 
        ret = lzma_vli_decode(size, &coder->pos,
                in, in_pos, in_size);
        if (ret != LZMA_STREAM_END)
            goto out;
 
        ret = LZMA_OK;
        coder->pos = 0;
 
        if (coder->sequence == SEQ_UNPADDED) {
            // Validate that encoded Unpadded Size isn't too small
            // or too big.
            if (coder->unpadded_size < UNPADDED_SIZE_MIN
                    || coder->unpadded_size
                        > UNPADDED_SIZE_MAX)
                return LZMA_DATA_ERROR;
 
            coder->sequence = SEQ_UNCOMPRESSED;
        } else {
            // Add the decoded Record to the Index.
            return_if_error(lzma_index_append(
                    coder->index, allocator,
                    coder->unpadded_size,
                    coder->uncompressed_size));
 
            // Check if this was the last Record.
            coder->sequence = --coder->count == 0
                    ? SEQ_PADDING_INIT
                    : SEQ_UNPADDED;
        }
 
        break;
    }
 
    case SEQ_PADDING_INIT:
        coder->pos = lzma_index_padding_size(coder->index);
        coder->sequence = SEQ_PADDING;
 
    // Fall through
 
    case SEQ_PADDING:
        if (coder->pos > 0) {
            --coder->pos;
            if (in[(*in_pos)++] != 0x00)
                return LZMA_DATA_ERROR;
 
            break;
        }
 
        // Finish the CRC32 calculation.
        coder->crc32 = lzma_crc32(in + in_start,
                *in_pos - in_start, coder->crc32);
 
        coder->sequence = SEQ_CRC32;
 
    // Fall through
 
    case SEQ_CRC32:
        do {
            if (*in_pos == in_size)
                return LZMA_OK;
 
            if (((coder->crc32 >> (coder->pos * 8)) & 0xFF)
                    != in[(*in_pos)++])
                return LZMA_DATA_ERROR;
 
        } while (++coder->pos < 4);
 
        // Decoding was successful, now we can let the application
        // see the decoded Index.
        *coder->index_ptr = coder->index;
 
        // Make index NULL so we don't free it unintentionally.
        coder->index = NULL;
 
        return LZMA_STREAM_END;
 
    default:
        assert(0);
        return LZMA_PROG_ERROR;
    }
 
out:
    // Update the CRC32,
    coder->crc32 = lzma_crc32(in + in_start,
            *in_pos - in_start, coder->crc32);
 
    return ret;
}

References allocator, assert(), lzma_index_coder::count, lzma_index_coder::crc32, in, in_pos, in_size, lzma_index_coder::index, lzma_index_coder::index_ptr, LZMA_DATA_ERROR, lzma_index_padding_size(), lzma_index_prealloc(), LZMA_MEMLIMIT_ERROR, LZMA_OK, LZMA_PROG_ERROR, LZMA_STREAM_END, lzma_index_coder::memlimit, NULL, out, lzma_index_coder::pos, return_if_error, lzma_index_coder::sequence, lzma_index_coder::uncompressed_size, lzma_index_coder::unpadded_size, UNPADDED_SIZE_MAX, and UNPADDED_SIZE_MIN.

Referenced by index_decoder_init().

index_decoder_end()

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

static

Definition at line 212 of file index_decoder.c.

{
    lzma_index_coder *coder = coder_ptr;
    lzma_index_end(coder->index, allocator);
    lzma_free(coder, allocator);
    return;
}

References allocator, lzma_index_coder::index, and lzma_free().

Referenced by index_decoder_init().

index_decoder_init()

static lzma_ret index_decoder_init ( lzma_next_coder *  next, const lzma_allocator *  allocator, lzma_index **  i, uint64_t  memlimit  )

static

Definition at line 269 of file index_decoder.c.

{
    lzma_next_coder_init(&index_decoder_init, next, allocator);
 
    if (i == NULL)
        return LZMA_PROG_ERROR;
 
    lzma_index_coder *coder = next->coder;
    if (coder == NULL) {
        coder = lzma_alloc(sizeof(lzma_index_coder), allocator);
        if (coder == NULL)
            return LZMA_MEM_ERROR;
 
        next->coder = coder;
        next->code = &index_decode;
        next->end = &index_decoder_end;
        next->memconfig = &index_decoder_memconfig;
        coder->index = NULL;
    } else {
        lzma_index_end(coder->index, allocator);
    }
 
    return index_decoder_reset(coder, allocator, i, memlimit);
}

References allocator, lzma_next_coder_s::code, lzma_next_coder_s::coder, lzma_next_coder_s::end, i, lzma_index_coder::index, index_decode(), index_decoder_end(), index_decoder_memconfig(), index_decoder_reset(), lzma_alloc(), LZMA_MEM_ERROR, lzma_next_coder_init, LZMA_PROG_ERROR, lzma_next_coder_s::memconfig, memlimit, and NULL.

Referenced by LZMA_API().

index_decoder_memconfig()

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

static

Definition at line 222 of file index_decoder.c.

{
    lzma_index_coder *coder = coder_ptr;
 
    *memusage = lzma_index_memusage(1, coder->count);
    *old_memlimit = coder->memlimit;
 
    if (new_memlimit != 0) {
        if (new_memlimit < *memusage)
            return LZMA_MEMLIMIT_ERROR;
 
        coder->memlimit = new_memlimit;
    }
 
    return LZMA_OK;
}

References lzma_index_coder::count, LZMA_MEMLIMIT_ERROR, LZMA_OK, and lzma_index_coder::memlimit.

Referenced by index_decoder_init().

index_decoder_reset()

static lzma_ret index_decoder_reset ( lzma_index_coder *  coder, const lzma_allocator *  allocator, lzma_index **  i, uint64_t  memlimit  )

static

Definition at line 242 of file index_decoder.c.

{
    // Remember the pointer given by the application. We will set it
    // to point to the decoded Index only if decoding is successful.
    // Before that, keep it NULL so that applications can always safely
    // pass it to lzma_index_end() no matter did decoding succeed or not.
    coder->index_ptr = i;
    *i = NULL;
 
    // We always allocate a new lzma_index.
    coder->index = lzma_index_init(allocator);
    if (coder->index == NULL)
        return LZMA_MEM_ERROR;
 
    // Initialize the rest.
    coder->sequence = SEQ_INDICATOR;
    coder->memlimit = my_max(1, memlimit);
    coder->count = 0; // Needs to be initialized due to _memconfig().
    coder->pos = 0;
    coder->crc32 = 0;
 
    return LZMA_OK;
}

References allocator, lzma_index_coder::count, lzma_index_coder::crc32, i, lzma_index_coder::index, lzma_index_coder::index_ptr, LZMA_MEM_ERROR, LZMA_OK, memlimit, lzma_index_coder::memlimit, my_max, NULL, lzma_index_coder::pos, and lzma_index_coder::sequence.

Referenced by index_decoder_init().

LZMA_API()

LZMA_API

(

lzma_ret

)

Definition at line 296 of file index_decoder.c.

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

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