1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2000-2006
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 */
6
7 #include <common.h>
8 #include <watchdog.h>
9 #include <command.h>
10 #include <console.h>
11 #include <image.h>
12 #include <malloc.h>
13 #include <memalign.h>
14 #include <u-boot/zlib.h>
15 #include <div64.h>
16
17 #define HEADER0 '\x1f'
18 #define HEADER1 '\x8b'
19 #define ZALLOC_ALIGNMENT 16
20 #define HEAD_CRC 2
21 #define EXTRA_FIELD 4
22 #define ORIG_NAME 8
23 #define COMMENT 0x10
24 #define RESERVED 0xe0
25 #define DEFLATED 8
26
gzalloc(void * x,unsigned items,unsigned size)27 void *gzalloc(void *x, unsigned items, unsigned size)
28 {
29 void *p;
30
31 size *= items;
32 size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
33
34 p = malloc (size);
35
36 return (p);
37 }
38
gzfree(void * x,void * addr,unsigned nb)39 void gzfree(void *x, void *addr, unsigned nb)
40 {
41 free (addr);
42 }
43
gzip_parse_header(const unsigned char * src,unsigned long len)44 int gzip_parse_header(const unsigned char *src, unsigned long len)
45 {
46 int i, flags;
47
48 /* skip header */
49 i = 10;
50 flags = src[3];
51 if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
52 puts ("Error: Bad gzipped data\n");
53 return (-1);
54 }
55 if ((flags & EXTRA_FIELD) != 0)
56 i = 12 + src[10] + (src[11] << 8);
57 if ((flags & ORIG_NAME) != 0)
58 while (src[i++] != 0)
59 ;
60 if ((flags & COMMENT) != 0)
61 while (src[i++] != 0)
62 ;
63 if ((flags & HEAD_CRC) != 0)
64 i += 2;
65 if (i >= len) {
66 puts ("Error: gunzip out of data in header\n");
67 return (-1);
68 }
69 return i;
70 }
71
gunzip(void * dst,int dstlen,unsigned char * src,unsigned long * lenp)72 int gunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp)
73 {
74 int offset = gzip_parse_header(src, *lenp);
75
76 if (offset < 0)
77 return offset;
78
79 return zunzip(dst, dstlen, src, lenp, 1, offset);
80 }
81
82 #ifdef CONFIG_CMD_UNZIP
83 __weak
gzwrite_progress_init(u64 expectedsize)84 void gzwrite_progress_init(u64 expectedsize)
85 {
86 putc('\n');
87 }
88
89 __weak
gzwrite_progress(int iteration,u64 bytes_written,u64 total_bytes)90 void gzwrite_progress(int iteration,
91 u64 bytes_written,
92 u64 total_bytes)
93 {
94 if (0 == (iteration & 3))
95 printf("%llu/%llu\r", bytes_written, total_bytes);
96 }
97
98 __weak
gzwrite_progress_finish(int returnval,u64 bytes_written,u64 total_bytes,u32 expected_crc,u32 calculated_crc)99 void gzwrite_progress_finish(int returnval,
100 u64 bytes_written,
101 u64 total_bytes,
102 u32 expected_crc,
103 u32 calculated_crc)
104 {
105 if (0 == returnval) {
106 printf("\n\t%llu bytes, crc 0x%08x\n",
107 total_bytes, calculated_crc);
108 } else {
109 printf("\n\tuncompressed %llu of %llu\n"
110 "\tcrcs == 0x%08x/0x%08x\n",
111 bytes_written, total_bytes,
112 expected_crc, calculated_crc);
113 }
114 }
115
gzwrite(unsigned char * src,int len,struct blk_desc * dev,unsigned long szwritebuf,u64 startoffs,u64 szexpected)116 int gzwrite(unsigned char *src, int len,
117 struct blk_desc *dev,
118 unsigned long szwritebuf,
119 u64 startoffs,
120 u64 szexpected)
121 {
122 int i, flags;
123 z_stream s;
124 int r = 0;
125 unsigned char *writebuf;
126 unsigned crc = 0;
127 u64 totalfilled = 0;
128 lbaint_t blksperbuf, outblock;
129 u32 expected_crc;
130 u32 payload_size;
131 int iteration = 0;
132
133 if (!szwritebuf ||
134 (szwritebuf % dev->blksz) ||
135 (szwritebuf < dev->blksz)) {
136 printf("%s: size %lu not a multiple of %lu\n",
137 __func__, szwritebuf, dev->blksz);
138 return -1;
139 }
140
141 if (startoffs & (dev->blksz-1)) {
142 printf("%s: start offset %llu not a multiple of %lu\n",
143 __func__, startoffs, dev->blksz);
144 return -1;
145 }
146
147 blksperbuf = szwritebuf / dev->blksz;
148 outblock = lldiv(startoffs, dev->blksz);
149
150 /* skip header */
151 i = 10;
152 flags = src[3];
153 if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
154 puts("Error: Bad gzipped data\n");
155 return -1;
156 }
157 if ((flags & EXTRA_FIELD) != 0)
158 i = 12 + src[10] + (src[11] << 8);
159 if ((flags & ORIG_NAME) != 0)
160 while (src[i++] != 0)
161 ;
162 if ((flags & COMMENT) != 0)
163 while (src[i++] != 0)
164 ;
165 if ((flags & HEAD_CRC) != 0)
166 i += 2;
167
168 if (i >= len-8) {
169 puts("Error: gunzip out of data in header");
170 return -1;
171 }
172
173 payload_size = len - i - 8;
174
175 memcpy(&expected_crc, src + len - 8, sizeof(expected_crc));
176 expected_crc = le32_to_cpu(expected_crc);
177 u32 szuncompressed;
178 memcpy(&szuncompressed, src + len - 4, sizeof(szuncompressed));
179 if (szexpected == 0) {
180 szexpected = le32_to_cpu(szuncompressed);
181 } else if (szuncompressed != (u32)szexpected) {
182 printf("size of %llx doesn't match trailer low bits %x\n",
183 szexpected, szuncompressed);
184 return -1;
185 }
186 if (lldiv(szexpected, dev->blksz) > (dev->lba - outblock)) {
187 printf("%s: uncompressed size %llu exceeds device size\n",
188 __func__, szexpected);
189 return -1;
190 }
191
192 gzwrite_progress_init(szexpected);
193
194 s.zalloc = gzalloc;
195 s.zfree = gzfree;
196
197 r = inflateInit2(&s, -MAX_WBITS);
198 if (r != Z_OK) {
199 printf("Error: inflateInit2() returned %d\n", r);
200 return -1;
201 }
202
203 s.next_in = src + i;
204 s.avail_in = payload_size+8;
205 writebuf = (unsigned char *)malloc_cache_aligned(szwritebuf);
206
207 /* decompress until deflate stream ends or end of file */
208 do {
209 if (s.avail_in == 0) {
210 printf("%s: weird termination with result %d\n",
211 __func__, r);
212 break;
213 }
214
215 /* run inflate() on input until output buffer not full */
216 do {
217 unsigned long blocks_written;
218 int numfilled;
219 lbaint_t writeblocks;
220
221 s.avail_out = szwritebuf;
222 s.next_out = writebuf;
223 r = inflate(&s, Z_SYNC_FLUSH);
224 if ((r != Z_OK) &&
225 (r != Z_STREAM_END)) {
226 printf("Error: inflate() returned %d\n", r);
227 goto out;
228 }
229 numfilled = szwritebuf - s.avail_out;
230 crc = crc32(crc, writebuf, numfilled);
231 totalfilled += numfilled;
232 if (numfilled < szwritebuf) {
233 writeblocks = (numfilled+dev->blksz-1)
234 / dev->blksz;
235 memset(writebuf+numfilled, 0,
236 dev->blksz-(numfilled%dev->blksz));
237 } else {
238 writeblocks = blksperbuf;
239 }
240
241 gzwrite_progress(iteration++,
242 totalfilled,
243 szexpected);
244 blocks_written = blk_dwrite(dev, outblock,
245 writeblocks, writebuf);
246 outblock += blocks_written;
247 if (ctrlc()) {
248 puts("abort\n");
249 goto out;
250 }
251 WATCHDOG_RESET();
252 } while (s.avail_out == 0);
253 /* done when inflate() says it's done */
254 } while (r != Z_STREAM_END);
255
256 if ((szexpected != totalfilled) ||
257 (crc != expected_crc))
258 r = -1;
259 else
260 r = 0;
261
262 out:
263 gzwrite_progress_finish(r, totalfilled, szexpected,
264 expected_crc, crc);
265 free(writebuf);
266 inflateEnd(&s);
267
268 return r;
269 }
270 #endif
271
272 /*
273 * Uncompress blocks compressed with zlib without headers
274 */
zunzip(void * dst,int dstlen,unsigned char * src,unsigned long * lenp,int stoponerr,int offset)275 int zunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp,
276 int stoponerr, int offset)
277 {
278 z_stream s;
279 int err = 0;
280 int r;
281
282 s.zalloc = gzalloc;
283 s.zfree = gzfree;
284
285 r = inflateInit2(&s, -MAX_WBITS);
286 if (r != Z_OK) {
287 printf("Error: inflateInit2() returned %d\n", r);
288 return -1;
289 }
290 s.next_in = src + offset;
291 s.avail_in = *lenp - offset;
292 s.next_out = dst;
293 s.avail_out = dstlen;
294 do {
295 r = inflate(&s, Z_FINISH);
296 if (stoponerr == 1 && r != Z_STREAM_END &&
297 (s.avail_in == 0 || s.avail_out == 0 || r != Z_BUF_ERROR)) {
298 printf("Error: inflate() returned %d\n", r);
299 err = -1;
300 break;
301 }
302 } while (r == Z_BUF_ERROR);
303 *lenp = s.next_out - (unsigned char *) dst;
304 inflateEnd(&s);
305
306 return err;
307 }
308