src/liblzma/common/block_header_decoder.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       block_header_decoder.c
   4 /// \brief      Decodes Block Header from .lzma files
   5 //
   6 //  Copyright (C) 2007 Lasse Collin
   7 //
   8 //  This library is free software; you can redistribute it and/or
   9 //  modify it under the terms of the GNU Lesser General Public
  10 //  License as published by the Free Software Foundation; either
  11 //  version 2.1 of the License, or (at your option) any later version.
  12 //
  13 //  This library is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 //  Lesser General Public License for more details.
  17 //
  18 ///////////////////////////////////////////////////////////////////////////////
  19
  20 #include "common.h"
  21 #include "check.h"
  22
  23
  24 static void
  25 free_properties(lzma_block *options, lzma_allocator *allocator)
  26 {
  27         // Free allocated filter options. The last array member is not
  28         // touched after the initialization in the beginning of
  29         // lzma_block_header_decode(), so we don't need to touch that here.
  30         for (size_t i = 0; i < LZMA_FILTERS_MAX; ++i) {
  31                 lzma_free(options->filters[i].options, allocator);
  32                 options->filters[i].id = LZMA_VLI_UNKNOWN;
  33                 options->filters[i].options = NULL;
  34         }
  35
  36         return;
  37 }
  38
  39
  40 extern LZMA_API lzma_ret
  41 lzma_block_header_decode(lzma_block *options,
  42                 lzma_allocator *allocator, const uint8_t *in)
  43 {
  44         // NOTE: We consider the header to be corrupt not only when the
  45         // CRC32 doesn't match, but also when variable-length integers
  46         // are invalid or over 63 bits, or if the header is too small
  47         // to contain the claimed information.
  48
  49         // Initialize the filter options array. This way the caller can
  50         // safely free() the options even if an error occurs in this function.
  51         for (size_t i = 0; i <= LZMA_FILTERS_MAX; ++i) {
  52                 options->filters[i].id = LZMA_VLI_UNKNOWN;
  53                 options->filters[i].options = NULL;
  54         }
  55
  56         // Validate Block Header Size and Check type. The caller must have
  57         // already set these, so it is a programming error if this test fails.
  58         if (lzma_block_header_size_decode(in[0]) != options->header_size
  59                         || (unsigned int)(options->check) > LZMA_CHECK_ID_MAX)
  60                 return LZMA_PROG_ERROR;
  61
  62         // Exclude the CRC32 field.
  63         const size_t in_size = options->header_size - 4;
  64
  65         // Verify CRC32
  66         if (lzma_crc32(in, in_size, 0) != integer_read_32(in + in_size))
  67                 return LZMA_DATA_ERROR;
  68
  69         // Check for unsupported flags.
  70         if (in[1] & 0x3C)
  71                 return LZMA_OPTIONS_ERROR;
  72
  73         // Start after the Block Header Size and Block Flags fields.
  74         size_t in_pos = 2;
  75
  76         // Compressed Size
  77         if (in[1] & 0x40) {
  78                 return_if_error(lzma_vli_decode(&options->compressed_size,
  79                                 NULL, in, &in_pos, in_size));
  80
  81                 // Validate Compressed Size. This checks that it isn't zero
  82                 // and that the total size of the Block is a valid VLI.
  83                 if (lzma_block_unpadded_size(options) == 0)
  84                         return LZMA_DATA_ERROR;
  85         } else {
  86                 options->compressed_size = LZMA_VLI_UNKNOWN;
  87         }
  88
  89         // Uncompressed Size
  90         if (in[1] & 0x80)
  91                 return_if_error(lzma_vli_decode(&options->uncompressed_size,
  92                                 NULL, in, &in_pos, in_size));
  93         else
  94                 options->uncompressed_size = LZMA_VLI_UNKNOWN;
  95
  96         // Filter Flags
  97         const size_t filter_count = (in[1] & 3) + 1;
  98         for (size_t i = 0; i < filter_count; ++i) {
  99                 const lzma_ret ret = lzma_filter_flags_decode(
 100                                 &options->filters[i], allocator,
 101                                 in, &in_pos, in_size);
 102                 if (ret != LZMA_OK) {
 103                         free_properties(options, allocator);
 104                         return ret;
 105                 }
 106         }
 107
 108         // Padding
 109         while (in_pos < in_size) {
 110                 if (in[in_pos++] != 0x00) {
 111                         free_properties(options, allocator);
 112
 113                         // Possibly some new field present so use
 114                         // LZMA_OPTIONS_ERROR instead of LZMA_DATA_ERROR.
 115                         return LZMA_OPTIONS_ERROR;
 116                 }
 117         }
 118
 119         return LZMA_OK;
 120 }