OpenWrt – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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 May 2007 Lin Mars Fix issue for multiple lzma_inflate involved
24 *******************************************************************************/
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28  
29 #include "LzmaDecode.h"
30 #include "LzmaWrapper.h"
31  
32 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
33 static const char *kCantReadMessage = "Can not read from source buffer";
34 static const char *kCantAllocateMessage = "Not enough buffer for decompression";
35 #endif
36  
37 static size_t rpos=0, dpos=0;
38  
39 static int MyReadFileAndCheck(unsigned char *src, void *dest, size_t size)
40 {
41 if (size == 0)
42 return 0;
43 memcpy(dest, src + rpos, size);
44 rpos += size;
45 return 1;
46 }
47  
48 int lzma_inflate(unsigned char *source, int s_len, unsigned char *dest, int *d_len)
49 {
50 /* We use two 32-bit integers to construct 64-bit integer for file size.
51 You can remove outSizeHigh, if you don't need >= 4GB supporting,
52 or you can use UInt64 outSize, if your compiler supports 64-bit integers*/
53 UInt32 outSize = 0;
54 UInt32 outSizeHigh = 0;
55 SizeT outSizeFull;
56 unsigned char *outStream;
57  
58 int waitEOS = 1;
59 /* waitEOS = 1, if there is no uncompressed size in headers,
60 so decoder will wait EOS (End of Stream Marker) in compressed stream */
61  
62 SizeT compressedSize;
63 unsigned char *inStream;
64  
65 CLzmaDecoderState state; /* it's about 24-80 bytes structure, if int is 32-bit */
66 unsigned char properties[LZMA_PROPERTIES_SIZE];
67  
68 int res;
69  
70 rpos=0; dpos=0;
71  
72 if (sizeof(UInt32) < 4)
73 {
74 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
75 printf("LZMA decoder needs correct UInt32\n");
76 #endif
77 return LZMA_RESULT_DATA_ERROR;
78 }
79  
80 {
81 long length=s_len;
82 if ((long)(SizeT)length != length)
83 {
84 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
85 printf("Too big compressed stream\n");
86 #endif
87 return LZMA_RESULT_DATA_ERROR;
88 }
89 compressedSize = (SizeT)(length - (LZMA_PROPERTIES_SIZE + 8));
90 }
91  
92 /* Read LZMA properties for compressed stream */
93  
94 if (!MyReadFileAndCheck(source, properties, sizeof(properties)))
95 {
96 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
97 printf("%s\n", kCantReadMessage);
98 #endif
99 return LZMA_RESULT_DATA_ERROR;
100 }
101  
102 /* Read uncompressed size */
103 {
104 int i;
105 for (i = 0; i < 8; i++)
106 {
107 unsigned char b;
108 if (!MyReadFileAndCheck(source, &b, 1))
109 {
110 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
111 printf("%s\n", kCantReadMessage);
112 #endif
113 return LZMA_RESULT_DATA_ERROR;
114 }
115 if (b != 0xFF)
116 waitEOS = 0;
117 if (i < 4)
118 outSize += (UInt32)(b) << (i * 8);
119 else
120 outSizeHigh += (UInt32)(b) << ((i - 4) * 8);
121 }
122  
123 if (waitEOS)
124 {
125 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
126 printf("Stream with EOS marker is not supported");
127 #endif
128 return LZMA_RESULT_DATA_ERROR;
129 }
130 outSizeFull = (SizeT)outSize;
131 if (sizeof(SizeT) >= 8)
132 outSizeFull |= (((SizeT)outSizeHigh << 16) << 16);
133 else if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize)
134 {
135 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
136 printf("Too big uncompressed stream");
137 #endif
138 return LZMA_RESULT_DATA_ERROR;
139 }
140 }
141  
142 /* Decode LZMA properties and allocate memory */
143 if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
144 {
145 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
146 printf("Incorrect stream properties");
147 #endif
148 return LZMA_RESULT_DATA_ERROR;
149 }
150 state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
151  
152 if (outSizeFull == 0)
153 outStream = 0;
154 else
155 {
156 if (outSizeFull > d_len)
157 outStream = 0;
158 else
159 outStream = dest;
160 }
161  
162 if (compressedSize == 0)
163 inStream = 0;
164 else
165 {
166 if ((compressedSize+rpos) > s_len )
167 inStream = 0;
168 else
169 inStream = source + rpos;
170 }
171  
172 if (state.Probs == 0
173 || (outStream == 0 && outSizeFull != 0)
174 || (inStream == 0 && compressedSize != 0)
175 )
176 {
177 free(state.Probs);
178 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
179 printf("%s\n", kCantAllocateMessage);
180 #endif
181 return LZMA_RESULT_DATA_ERROR;
182 }
183  
184 /* Decompress */
185 {
186 SizeT inProcessed;
187 SizeT outProcessed;
188 res = LzmaDecode(&state,
189 inStream, compressedSize, &inProcessed,
190 outStream, outSizeFull, &outProcessed);
191 if (res != 0)
192 {
193 #if defined(DEBUG_ENABLE_BOOTSTRAP_PRINTF) || !defined(CFG_BOOTSTRAP_CODE)
194 printf("\nDecoding error = %d\n", res);
195 #endif
196 res = 1;
197 }
198 else
199 {
200 *d_len = outProcessed;
201 }
202 }
203  
204 free(state.Probs);
205 return res;
206 }