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