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.c" |
35 | #else |
36 | #include <linux/slab.h> |
37 | #include <linux/decompress/unlzo.h> |
38 | #endif |
39 | |
40 | #include <linux/types.h> |
41 | #include <linux/lzo.h> |
42 | #include <linux/decompress/mm.h> |
43 | |
44 | #include <linux/compiler.h> |
45 | #include <asm/unaligned.h> |
46 | |
47 | static const unsigned char lzop_magic[] = { |
48 | 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a }; |
49 | |
50 | #define LZO_BLOCK_SIZE (256*1024l) |
51 | #define HEADER_HAS_FILTER 0x00000800L |
52 | |
53 | STATIC inline int INIT parse_header(u8 *input, u8 *skip) |
54 | { |
55 | int l; |
56 | u8 *parse = input; |
57 | u8 level = 0; |
58 | u16 version; |
59 | |
60 | /* read magic: 9 first bits */ |
61 | for (l = 0; l < 9; l++) { |
62 | if (*parse++ != lzop_magic[l]) |
63 | return 0; |
64 | } |
65 | /* get version (2bytes), skip library version (2), |
66 | * 'need to be extracted' version (2) and |
67 | * method (1) */ |
68 | version = get_unaligned_be16(parse); |
69 | parse += 7; |
70 | if (version >= 0x0940) |
71 | level = *parse++; |
72 | if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) |
73 | parse += 8; /* flags + filter info */ |
74 | else |
75 | parse += 4; /* flags */ |
76 | |
77 | /* skip mode and mtime_low */ |
78 | parse += 8; |
79 | if (version >= 0x0940) |
80 | parse += 4; /* skip mtime_high */ |
81 | |
82 | l = *parse++; |
83 | /* don't care about the file name, and skip checksum */ |
84 | parse += l + 4; |
85 | |
86 | *skip = parse - input; |
87 | return 1; |
88 | } |
89 | |
90 | STATIC inline int INIT unlzo(u8 *input, int in_len, |
91 | int (*fill) (void *, unsigned int), |
92 | int (*flush) (void *, unsigned int), |
93 | u8 *output, int *posp, |
94 | void (*error_fn) (char *x)) |
95 | { |
96 | u8 skip = 0, r = 0; |
97 | u32 src_len, dst_len; |
98 | size_t tmp; |
99 | u8 *in_buf, *in_buf_save, *out_buf; |
100 | int ret = -1; |
101 | |
102 | set_error_fn(error_fn); |
103 | |
104 | if (output) { |
105 | out_buf = output; |
106 | } else if (!flush) { |
107 | error("NULL output pointer and no flush function provided"); |
108 | goto exit; |
109 | } else { |
110 | out_buf = malloc(LZO_BLOCK_SIZE); |
111 | if (!out_buf) { |
112 | error("Could not allocate output buffer"); |
113 | goto exit; |
114 | } |
115 | } |
116 | |
117 | if (input && fill) { |
118 | error("Both input pointer and fill function provided, don't know what to do"); |
119 | goto exit_1; |
120 | } else if (input) { |
121 | in_buf = input; |
122 | } else if (!fill || !posp) { |
123 | error("NULL input pointer and missing position pointer or fill function"); |
124 | goto exit_1; |
125 | } else { |
126 | in_buf = malloc(lzo1x_worst_compress(LZO_BLOCK_SIZE)); |
127 | if (!in_buf) { |
128 | error("Could not allocate input buffer"); |
129 | goto exit_1; |
130 | } |
131 | } |
132 | in_buf_save = in_buf; |
133 | |
134 | if (posp) |
135 | *posp = 0; |
136 | |
137 | if (fill) |
138 | fill(in_buf, lzo1x_worst_compress(LZO_BLOCK_SIZE)); |
139 | |
140 | if (!parse_header(input, &skip)) { |
141 | error("invalid header"); |
142 | goto exit_2; |
143 | } |
144 | in_buf += skip; |
145 | |
146 | if (posp) |
147 | *posp = skip; |
148 | |
149 | for (;;) { |
150 | /* read uncompressed block size */ |
151 | dst_len = get_unaligned_be32(in_buf); |
152 | in_buf += 4; |
153 | |
154 | /* exit if last block */ |
155 | if (dst_len == 0) { |
156 | if (posp) |
157 | *posp += 4; |
158 | break; |
159 | } |
160 | |
161 | if (dst_len > LZO_BLOCK_SIZE) { |
162 | error("dest len longer than block size"); |
163 | goto exit_2; |
164 | } |
165 | |
166 | /* read compressed block size, and skip block checksum info */ |
167 | src_len = get_unaligned_be32(in_buf); |
168 | in_buf += 8; |
169 | |
170 | if (src_len <= 0 || src_len > dst_len) { |
171 | error("file corrupted"); |
172 | goto exit_2; |
173 | } |
174 | |
175 | /* decompress */ |
176 | tmp = dst_len; |
177 | |
178 | /* When the input data is not compressed at all, |
179 | * lzo1x_decompress_safe will fail, so call memcpy() |
180 | * instead */ |
181 | if (unlikely(dst_len == src_len)) |
182 | memcpy(out_buf, in_buf, src_len); |
183 | else { |
184 | r = lzo1x_decompress_safe((u8 *) in_buf, src_len, |
185 | out_buf, &tmp); |
186 | |
187 | if (r != LZO_E_OK || dst_len != tmp) { |
188 | error("Compressed data violation"); |
189 | goto exit_2; |
190 | } |
191 | } |
192 | |
193 | if (flush) |
194 | flush(out_buf, dst_len); |
195 | if (output) |
196 | out_buf += dst_len; |
197 | if (posp) |
198 | *posp += src_len + 12; |
199 | if (fill) { |
200 | in_buf = in_buf_save; |
201 | fill(in_buf, lzo1x_worst_compress(LZO_BLOCK_SIZE)); |
202 | } else |
203 | in_buf += src_len; |
204 | } |
205 | |
206 | ret = 0; |
207 | exit_2: |
208 | if (!input) |
209 | free(in_buf); |
210 | exit_1: |
211 | if (!output) |
212 | free(out_buf); |
213 | exit: |
214 | return ret; |
215 | } |
216 | |
217 | #define decompress unlzo |
218 |
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