target/linux/ifxmips/image/u-boot/files/lib_generic/LzmaWrapper.c

   1 /******************************************************************************
   2 **
   3 ** FILE NAME    : LzmaWrapper.c
   4 ** PROJECT      : bootloader
   5 ** MODULES      : U-boot
   6 **
   7 ** DATE         : 2 Nov 2006
   8 ** AUTHOR       : Lin Mars
   9 ** DESCRIPTION  : LZMA decoder support for U-boot 1.1.5
  10 ** COPYRIGHT    :       Copyright (c) 2006
  11 **                      Infineon Technologies AG
  12 **                      Am Campeon 1-12, 85579 Neubiberg, Germany
  13 **
  14 **    This program is free software; you can redistribute it and/or modify
  15 **    it under the terms of the GNU General Public License as published by
  16 **    the Free Software Foundation; either version 2 of the License, or
  17 **    (at your option) any later version.
  18 **
  19 ** HISTORY
  20 ** $Date        $Author         $Comment
  21 ** 2 Nov 2006   Lin Mars        init version which derived from LzmaTest.c from
  22 **                              LZMA v4.43 SDK
  23 *******************************************************************************/
  24 #define LZMA_NO_STDIO
  25 #ifndef LZMA_NO_STDIO
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #endif
  30
  31 #include <config.h>
  32 #include <common.h>
  33 #include <linux/types.h>
  34 #include <linux/string.h>
  35 #include <linux/ctype.h>
  36 #include <malloc.h>
  37
  38 #ifdef CONFIG_LZMA
  39
  40 #include "LzmaDecode.h"
  41 #include "LzmaWrapper.h"
  42
  43 static const char *kCantReadMessage = "Can not read from source buffer";
  44 static const char *kCantAllocateMessage = "Not enough buffer for decompression";
  45
  46 static size_t rpos=0, dpos=0;
  47
  48 static int MyReadFileAndCheck(unsigned char *src, void *dest, size_t size)
  49 {
  50   if (size == 0)
  51     return 0;
  52   memcpy(dest, src + rpos, size);
  53   rpos += size;
  54   return 1;
  55 }
  56
  57 int lzma_inflate(unsigned char *source, int s_len, unsigned char *dest, int *d_len)
  58 {
  59   /* We use two 32-bit integers to construct 64-bit integer for file size.
  60      You can remove outSizeHigh, if you don't need >= 4GB supporting,
  61      or you can use UInt64 outSize, if your compiler supports 64-bit integers*/
  62   UInt32 outSize = 0;
  63   UInt32 outSizeHigh = 0;
  64   SizeT outSizeFull;
  65   unsigned char *outStream;
  66
  67   int waitEOS = 1;
  68   /* waitEOS = 1, if there is no uncompressed size in headers,
  69    so decoder will wait EOS (End of Stream Marker) in compressed stream */
  70
  71   SizeT compressedSize;
  72   unsigned char *inStream;
  73
  74   CLzmaDecoderState state;  /* it's about 24-80 bytes structure, if int is 32-bit */
  75   unsigned char properties[LZMA_PROPERTIES_SIZE];
  76
  77   int res;
  78
  79   if (sizeof(UInt32) < 4)
  80   {
  81     printf("LZMA decoder needs correct UInt32\n");
  82     return LZMA_RESULT_DATA_ERROR;
  83   }
  84
  85   {
  86     long length=s_len;
  87     if ((long)(SizeT)length != length)
  88     {
  89       printf("Too big compressed stream\n");
  90       return LZMA_RESULT_DATA_ERROR;
  91     }
  92     compressedSize = (SizeT)(length - (LZMA_PROPERTIES_SIZE + 8));
  93   }
  94
  95   /* Read LZMA properties for compressed stream */
  96
  97   if (!MyReadFileAndCheck(source, properties, sizeof(properties)))
  98   {
  99     printf("%s\n", kCantReadMessage);
 100     return LZMA_RESULT_DATA_ERROR;
 101   }
 102
 103   /* Read uncompressed size */
 104   {
 105     int i;
 106     for (i = 0; i < 8; i++)
 107     {
 108       unsigned char b;
 109       if (!MyReadFileAndCheck(source, &b, 1))
 110       {
 111         printf("%s\n", kCantReadMessage);
 112         return LZMA_RESULT_DATA_ERROR;
 113       }
 114       if (b != 0xFF)
 115         waitEOS = 0;
 116       if (i < 4)
 117         outSize += (UInt32)(b) << (i * 8);
 118       else
 119         outSizeHigh += (UInt32)(b) << ((i - 4) * 8);
 120     }
 121
 122     if (waitEOS)
 123     {
 124       printf("Stream with EOS marker is not supported");
 125       return LZMA_RESULT_DATA_ERROR;
 126     }
 127     outSizeFull = (SizeT)outSize;
 128     if (sizeof(SizeT) >= 8)
 129       outSizeFull |= (((SizeT)outSizeHigh << 16) << 16);
 130     else if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize)
 131     {
 132       printf("Too big uncompressed stream");
 133       return LZMA_RESULT_DATA_ERROR;
 134     }
 135   }
 136
 137   /* Decode LZMA properties and allocate memory */
 138   if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
 139   {
 140     printf("Incorrect stream properties");
 141     return LZMA_RESULT_DATA_ERROR;
 142   }
 143   state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
 144
 145   if (outSizeFull == 0)
 146     outStream = 0;
 147   else
 148   {
 149     if (outSizeFull > d_len)
 150       outStream = 0;
 151     else
 152       outStream = dest;
 153   }
 154
 155   if (compressedSize == 0)
 156     inStream = 0;
 157   else
 158   {
 159     if ((compressedSize+rpos) > s_len )
 160       inStream = 0;
 161     else
 162       inStream = source + rpos;
 163   }
 164
 165   if (state.Probs == 0
 166     || (outStream == 0 && outSizeFull != 0)
 167     || (inStream == 0 && compressedSize != 0)
 168     )
 169   {
 170     free(state.Probs);
 171     printf("%s\n", kCantAllocateMessage);
 172     return LZMA_RESULT_DATA_ERROR;
 173   }
 174
 175   /* Decompress */
 176   {
 177     SizeT inProcessed;
 178     SizeT outProcessed;
 179     res = LzmaDecode(&state,
 180       inStream, compressedSize, &inProcessed,
 181       outStream, outSizeFull, &outProcessed);
 182     if (res != 0)
 183     {
 184       printf("\nDecoding error = %d\n", res);
 185       res = 1;
 186     }
 187     else
 188     {
 189       *d_len = outProcessed;
 190     }
 191   }
 192
 193   free(state.Probs);
 194   return res;
 195 }
 196
 197 #endif /* CONFIG_LZMA */