Root/
1 | /* |
2 | * LZO decompressor for the Linux kernel. Code borrowed from the lzo |
3 | * implementation by Markus Franz Xaver Johannes Oberhumer. |
4 | * |
5 | * Linux kernel adaptation: |
6 | * Copyright (C) 2009 |
7 | * Albin Tonnerre, Free Electrons <albin.tonnerre@free-electrons.com> |
8 | * |
9 | * Original code: |
10 | * Copyright (C) 1996-2005 Markus Franz Xaver Johannes Oberhumer |
11 | * All Rights Reserved. |
12 | * |
13 | * lzop and the LZO library are free software; you can redistribute them |
14 | * and/or modify them under the terms of the GNU General Public License as |
15 | * published by the Free Software Foundation; either version 2 of |
16 | * the License, or (at your option) any later version. |
17 | * |
18 | * This program is distributed in the hope that it will be useful, |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
21 | * GNU General Public License for more details. |
22 | * |
23 | * You should have received a copy of the GNU General Public License |
24 | * along with this program; see the file COPYING. |
25 | * If not, write to the Free Software Foundation, Inc., |
26 | * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
27 | * |
28 | * Markus F.X.J. Oberhumer |
29 | * <markus@oberhumer.com> |
30 | * http://www.oberhumer.com/opensource/lzop/ |
31 | */ |
32 | |
33 | #ifdef STATIC |
34 | #include "lzo/lzo1x_decompress_safe.c" |
35 | #else |
36 | #include <linux/decompress/unlzo.h> |
37 | #endif |
38 | |
39 | #include <linux/types.h> |
40 | #include <linux/lzo.h> |
41 | #include <linux/decompress/mm.h> |
42 | |
43 | #include <linux/compiler.h> |
44 | #include <asm/unaligned.h> |
45 | |
46 | static const unsigned char lzop_magic[] = { |
47 | 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a }; |
48 | |
49 | #define LZO_BLOCK_SIZE (256*1024l) |
50 | #define HEADER_HAS_FILTER 0x00000800L |
51 | #define HEADER_SIZE_MIN (9 + 7 + 4 + 8 + 1 + 4) |
52 | #define HEADER_SIZE_MAX (9 + 7 + 1 + 8 + 8 + 4 + 1 + 255 + 4) |
53 | |
54 | STATIC inline int INIT parse_header(u8 *input, int *skip, int in_len) |
55 | { |
56 | int l; |
57 | u8 *parse = input; |
58 | u8 *end = input + in_len; |
59 | u8 level = 0; |
60 | u16 version; |
61 | |
62 | /* |
63 | * Check that there's enough input to possibly have a valid header. |
64 | * Then it is possible to parse several fields until the minimum |
65 | * size may have been used. |
66 | */ |
67 | if (in_len < HEADER_SIZE_MIN) |
68 | return 0; |
69 | |
70 | /* read magic: 9 first bits */ |
71 | for (l = 0; l < 9; l++) { |
72 | if (*parse++ != lzop_magic[l]) |
73 | return 0; |
74 | } |
75 | /* get version (2bytes), skip library version (2), |
76 | * 'need to be extracted' version (2) and |
77 | * method (1) */ |
78 | version = get_unaligned_be16(parse); |
79 | parse += 7; |
80 | if (version >= 0x0940) |
81 | level = *parse++; |
82 | if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) |
83 | parse += 8; /* flags + filter info */ |
84 | else |
85 | parse += 4; /* flags */ |
86 | |
87 | /* |
88 | * At least mode, mtime_low, filename length, and checksum must |
89 | * be left to be parsed. If also mtime_high is present, it's OK |
90 | * because the next input buffer check is after reading the |
91 | * filename length. |
92 | */ |
93 | if (end - parse < 8 + 1 + 4) |
94 | return 0; |
95 | |
96 | /* skip mode and mtime_low */ |
97 | parse += 8; |
98 | if (version >= 0x0940) |
99 | parse += 4; /* skip mtime_high */ |
100 | |
101 | l = *parse++; |
102 | /* don't care about the file name, and skip checksum */ |
103 | if (end - parse < l + 4) |
104 | return 0; |
105 | parse += l + 4; |
106 | |
107 | *skip = parse - input; |
108 | return 1; |
109 | } |
110 | |
111 | STATIC inline int INIT unlzo(u8 *input, int in_len, |
112 | int (*fill) (void *, unsigned int), |
113 | int (*flush) (void *, unsigned int), |
114 | u8 *output, int *posp, |
115 | void (*error) (char *x)) |
116 | { |
117 | u8 r = 0; |
118 | int skip = 0; |
119 | u32 src_len, dst_len; |
120 | size_t tmp; |
121 | u8 *in_buf, *in_buf_save, *out_buf; |
122 | int ret = -1; |
123 | |
124 | if (output) { |
125 | out_buf = output; |
126 | } else if (!flush) { |
127 | error("NULL output pointer and no flush function provided"); |
128 | goto exit; |
129 | } else { |
130 | out_buf = malloc(LZO_BLOCK_SIZE); |
131 | if (!out_buf) { |
132 | error("Could not allocate output buffer"); |
133 | goto exit; |
134 | } |
135 | } |
136 | |
137 | if (input && fill) { |
138 | error("Both input pointer and fill function provided, don't know what to do"); |
139 | goto exit_1; |
140 | } else if (input) { |
141 | in_buf = input; |
142 | } else if (!fill) { |
143 | error("NULL input pointer and missing fill function"); |
144 | goto exit_1; |
145 | } else { |
146 | in_buf = malloc(lzo1x_worst_compress(LZO_BLOCK_SIZE)); |
147 | if (!in_buf) { |
148 | error("Could not allocate input buffer"); |
149 | goto exit_1; |
150 | } |
151 | } |
152 | in_buf_save = in_buf; |
153 | |
154 | if (posp) |
155 | *posp = 0; |
156 | |
157 | if (fill) { |
158 | /* |
159 | * Start from in_buf + HEADER_SIZE_MAX to make it possible |
160 | * to use memcpy() to copy the unused data to the beginning |
161 | * of the buffer. This way memmove() isn't needed which |
162 | * is missing from pre-boot environments of most archs. |
163 | */ |
164 | in_buf += HEADER_SIZE_MAX; |
165 | in_len = fill(in_buf, HEADER_SIZE_MAX); |
166 | } |
167 | |
168 | if (!parse_header(in_buf, &skip, in_len)) { |
169 | error("invalid header"); |
170 | goto exit_2; |
171 | } |
172 | in_buf += skip; |
173 | in_len -= skip; |
174 | |
175 | if (fill) { |
176 | /* Move the unused data to the beginning of the buffer. */ |
177 | memcpy(in_buf_save, in_buf, in_len); |
178 | in_buf = in_buf_save; |
179 | } |
180 | |
181 | if (posp) |
182 | *posp = skip; |
183 | |
184 | for (;;) { |
185 | /* read uncompressed block size */ |
186 | if (fill && in_len < 4) { |
187 | skip = fill(in_buf + in_len, 4 - in_len); |
188 | if (skip > 0) |
189 | in_len += skip; |
190 | } |
191 | if (in_len < 4) { |
192 | error("file corrupted"); |
193 | goto exit_2; |
194 | } |
195 | dst_len = get_unaligned_be32(in_buf); |
196 | in_buf += 4; |
197 | in_len -= 4; |
198 | |
199 | /* exit if last block */ |
200 | if (dst_len == 0) { |
201 | if (posp) |
202 | *posp += 4; |
203 | break; |
204 | } |
205 | |
206 | if (dst_len > LZO_BLOCK_SIZE) { |
207 | error("dest len longer than block size"); |
208 | goto exit_2; |
209 | } |
210 | |
211 | /* read compressed block size, and skip block checksum info */ |
212 | if (fill && in_len < 8) { |
213 | skip = fill(in_buf + in_len, 8 - in_len); |
214 | if (skip > 0) |
215 | in_len += skip; |
216 | } |
217 | if (in_len < 8) { |
218 | error("file corrupted"); |
219 | goto exit_2; |
220 | } |
221 | src_len = get_unaligned_be32(in_buf); |
222 | in_buf += 8; |
223 | in_len -= 8; |
224 | |
225 | if (src_len <= 0 || src_len > dst_len) { |
226 | error("file corrupted"); |
227 | goto exit_2; |
228 | } |
229 | |
230 | /* decompress */ |
231 | if (fill && in_len < src_len) { |
232 | skip = fill(in_buf + in_len, src_len - in_len); |
233 | if (skip > 0) |
234 | in_len += skip; |
235 | } |
236 | if (in_len < src_len) { |
237 | error("file corrupted"); |
238 | goto exit_2; |
239 | } |
240 | tmp = dst_len; |
241 | |
242 | /* When the input data is not compressed at all, |
243 | * lzo1x_decompress_safe will fail, so call memcpy() |
244 | * instead */ |
245 | if (unlikely(dst_len == src_len)) |
246 | memcpy(out_buf, in_buf, src_len); |
247 | else { |
248 | r = lzo1x_decompress_safe((u8 *) in_buf, src_len, |
249 | out_buf, &tmp); |
250 | |
251 | if (r != LZO_E_OK || dst_len != tmp) { |
252 | error("Compressed data violation"); |
253 | goto exit_2; |
254 | } |
255 | } |
256 | |
257 | if (flush && flush(out_buf, dst_len) != dst_len) |
258 | goto exit_2; |
259 | if (output) |
260 | out_buf += dst_len; |
261 | if (posp) |
262 | *posp += src_len + 12; |
263 | |
264 | in_buf += src_len; |
265 | in_len -= src_len; |
266 | if (fill) { |
267 | /* |
268 | * If there happens to still be unused data left in |
269 | * in_buf, move it to the beginning of the buffer. |
270 | * Use a loop to avoid memmove() dependency. |
271 | */ |
272 | if (in_len > 0) |
273 | for (skip = 0; skip < in_len; ++skip) |
274 | in_buf_save[skip] = in_buf[skip]; |
275 | in_buf = in_buf_save; |
276 | } |
277 | } |
278 | |
279 | ret = 0; |
280 | exit_2: |
281 | if (!input) |
282 | free(in_buf_save); |
283 | exit_1: |
284 | if (!output) |
285 | free(out_buf); |
286 | exit: |
287 | return ret; |
288 | } |
289 | |
290 | #define decompress unlzo |
291 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9