1 #include "links.h"
2 
3 #ifdef write
4 #undef write
5 #endif
6 
7 my_uintptr_t decompressed_cache_size = 0;
8 
display_error(struct terminal * term,unsigned char * msg,int * errp)9 static int display_error(struct terminal *term, unsigned char *msg, int *errp)
10 {
11 	if (errp) *errp = 1;
12 	if (!term) return 0;
13 	if (!errp) if (find_msg_box(term, msg, NULL, NULL)) return 0;
14 	return 1;
15 }
16 
17 #ifdef HAVE_ANY_COMPRESSION
18 
decoder_memory_init(unsigned char ** p,size_t * size,off_t init_length)19 static void decoder_memory_init(unsigned char **p, size_t *size, off_t init_length)
20 {
21 	if (init_length > 0 && init_length < MAXINT) *size = (int)init_length;
22 	else *size = 4096;
23 again:
24 	if (*size <= 4096) {
25 		*p = mem_alloc(*size);
26 	} else {
27 		*p = mem_alloc_mayfail(*size);
28 		if (!*p) {
29 			*size >>= 1;
30 			goto again;
31 		}
32 	}
33 }
34 
decoder_memory_expand(unsigned char ** p,size_t size,size_t * addsize)35 static int decoder_memory_expand(unsigned char **p, size_t size, size_t *addsize)
36 {
37 	unsigned char *pp;
38 	size_t add = size / 4 + 1;
39 	if (add > MAXINT) add = MAXINT;
40 	while (size + add < size || !(pp = mem_realloc_mayfail(*p, size + add))) {
41 		if (add > 1) add >>= 1;
42 		else goto ovf;
43 	}
44 	*addsize = add;
45 	*p = pp;
46 	return 0;
47 
48 ovf:
49 	*addsize = 0;
50 	return -1;
51 }
52 
decompress_error(struct terminal * term,struct cache_entry * ce,unsigned char * lib,unsigned char * msg,int * errp)53 static void decompress_error(struct terminal *term, struct cache_entry *ce, unsigned char *lib, unsigned char *msg, int *errp)
54 {
55 	unsigned char *u, *server;
56 	if ((u = parse_http_header(ce->head, cast_uchar "Content-Encoding", NULL))) {
57 		mem_free(u);
58 		if ((server = get_host_name(ce->url))) {
59 			add_blacklist_entry(server, BL_NO_COMPRESSION);
60 			mem_free(server);
61 		}
62 	}
63 	if (!display_error(term, TEXT_(T_DECOMPRESSION_ERROR), errp)) return;
64 	u = display_url(term, ce->url, 1);
65 	msg_box(term, getml(u, NULL), TEXT_(T_DECOMPRESSION_ERROR), AL_CENTER, TEXT_(T_ERROR_DECOMPRESSING_), u, TEXT_(T__wITH_), lib, cast_uchar ": ", msg, MSG_BOX_END, NULL, 1, TEXT_(T_CANCEL), msg_box_null, B_ENTER | B_ESC);
66 }
67 
68 #endif
69 
70 #ifdef HAVE_ZLIB
71 #include <zlib.h>
decode_gzip(struct terminal * term,struct cache_entry * ce,int defl,int * errp)72 static int decode_gzip(struct terminal *term, struct cache_entry *ce, int defl, int *errp)
73 {
74 	unsigned char err;
75 	unsigned char memory_error;
76 	unsigned char skip_gzip_header;
77 	unsigned char old_zlib;
78 	z_stream z;
79 	off_t offset;
80 	int r;
81 	unsigned char *p;
82 	struct fragment *f;
83 	struct list_head *lf;
84 	size_t size;
85 
86 	retry_after_memory_error:
87 	memory_error = 0;
88 	decoder_memory_init(&p, &size, ce->length);
89 	init_again:
90 	err = 0;
91 	skip_gzip_header = 0;
92 	old_zlib = 0;
93 	memset(&z, 0, sizeof z);
94 	z.next_in = NULL;
95 	z.avail_in = 0;
96 	z.next_out = p;
97 	z.avail_out = (unsigned)size;
98 	z.zalloc = NULL;
99 	z.zfree = NULL;
100 	z.opaque = NULL;
101 	r = inflateInit2(&z, defl == 1 ? 15 : defl == 2 ? -15 : 15 + 16);
102 	init_failed:
103 	switch (r) {
104 		case Z_OK:		break;
105 		case Z_MEM_ERROR:	memory_error = 1;
106 					err = 1;
107 					goto after_inflateend;
108 		case Z_STREAM_ERROR:
109 					if (!defl && !old_zlib) {
110 						if (defrag_entry(ce)) {
111 							memory_error = 1;
112 							err = 1;
113 							goto after_inflateend;
114 						}
115 						r = inflateInit2(&z, -15);
116 						skip_gzip_header = 1;
117 						old_zlib = 1;
118 						goto init_failed;
119 					}
120 					decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Invalid parameter", errp);
121 					err = 1;
122 					goto after_inflateend;
123 		case Z_VERSION_ERROR:	decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Bad zlib version", errp);
124 					err = 1;
125 					goto after_inflateend;
126 		default:		decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Unknown return value on inflateInit2", errp);
127 					err = 1;
128 					goto after_inflateend;
129 	}
130 	offset = 0;
131 	foreach(struct fragment, f, lf, ce->frag) {
132 		if (f->offset != offset) break;
133 		z.next_in = f->data;
134 		z.avail_in = (unsigned)f->length;
135 		if ((off_t)z.avail_in != f->length) overalloc();
136 		repeat_frag:
137 		if (skip_gzip_header == 2) {
138 			if (z.avail_in < 8) goto finish;
139 			z.next_in = (unsigned char *)z.next_in + 8;
140 			z.avail_in -= 8;
141 			skip_gzip_header = 1;
142 		}
143 		if (skip_gzip_header) {
144 			/* if zlib is old, we have to skip gzip header manually
145 			   otherwise zlib 1.2.x can do it automatically */
146 			unsigned char *head = z.next_in;
147 			unsigned headlen = 10;
148 			if (z.avail_in <= 11) goto finish;
149 			if (head[0] != 0x1f || head[1] != 0x8b) {
150 				decompress_error(term, ce, cast_uchar "zlib", TEXT_(T_COMPRESSED_ERROR), errp);
151 				err = 1;
152 				goto finish;
153 			}
154 			if (head[2] != 8 || head[3] & 0xe0) {
155 				decompress_error(term, ce, cast_uchar "zlib", TEXT_(T_UNKNOWN_COMPRESSION_METHOD), errp);
156 				err = 1;
157 				goto finish;
158 			}
159 			if (head[3] & 0x04) {
160 				headlen += 2 + head[10] + (head[11] << 8);
161 				if (headlen >= z.avail_in) goto finish;
162 			}
163 			if (head[3] & 0x08) {
164 				do {
165 					headlen++;
166 					if (headlen >= z.avail_in) goto finish;
167 				} while (head[headlen - 1]);
168 			}
169 			if (head[3] & 0x10) {
170 				do {
171 					headlen++;
172 					if (headlen >= z.avail_in) goto finish;
173 				} while (head[headlen - 1]);
174 			}
175 			if (head[3] & 0x01) {
176 				headlen += 2;
177 				if (headlen >= z.avail_in) goto finish;
178 			}
179 			z.next_in = (unsigned char *)z.next_in + headlen;
180 			z.avail_in -= headlen;
181 			skip_gzip_header = 0;
182 		}
183 		r = inflate(&z, f->list_entry.next == &ce->frag ? Z_SYNC_FLUSH : Z_NO_FLUSH);
184 		switch (r) {
185 			case Z_OK:		break;
186 			case Z_BUF_ERROR:	break;
187 			case Z_STREAM_END:	r = inflateEnd(&z);
188 						if (r != Z_OK) goto end_failed;
189 						r = inflateInit2(&z, old_zlib ? -15 : defl ? 15 : 15 + 16);
190 						if (r != Z_OK) {
191 							old_zlib = 0;
192 							goto init_failed;
193 						}
194 						if (old_zlib) {
195 							skip_gzip_header = 2;
196 						}
197 						break;
198 			case Z_NEED_DICT:
199 			case Z_DATA_ERROR:	if (defl == 1) {
200 							defl = 2;
201 							r = inflateEnd(&z);
202 							if (r != Z_OK) goto end_failed;
203 							goto init_again;
204 						}
205 						decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : TEXT_(T_COMPRESSED_ERROR), errp);
206 						err = 1;
207 						goto finish;
208 			case Z_STREAM_ERROR:	decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Internal error on inflate", errp);
209 						err = 1;
210 						goto finish;
211 			case Z_MEM_ERROR:
212 			mem_error:		memory_error = 1;
213 						err = 1;
214 						goto finish;
215 			default:		decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Unknown return value on inflate", errp);
216 						err = 1;
217 						break;
218 		}
219 		if (!z.avail_out) {
220 			size_t addsize;
221 			if (decoder_memory_expand(&p, size, &addsize) < 0)
222 				goto mem_error;
223 			z.next_out = p + size;
224 			z.avail_out = (unsigned)addsize;
225 			size += addsize;
226 		}
227 		if (z.avail_in) goto repeat_frag;
228 		/* In zlib 1.1.3, inflate(Z_SYNC_FLUSH) doesn't work.
229 		   The following line fixes it --- for last fragment, loop until
230 		   we get an eof. */
231 		if (r == Z_OK && f->list_entry.next == &ce->frag) goto repeat_frag;
232 		offset += f->length;
233 	}
234 	finish:
235 	r = inflateEnd(&z);
236 	end_failed:
237 	switch (r) {
238 		case Z_OK:		break;
239 		case Z_STREAM_ERROR:	decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Internal error on inflateEnd", errp);
240 					err = 1;
241 					break;
242 		case Z_MEM_ERROR:	memory_error = 1;
243 					err = 1;
244 					break;
245 		default:		decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : (unsigned char *)"Unknown return value on inflateEnd", errp);
246 					err = 1;
247 					break;
248 	}
249 	after_inflateend:
250 	if (memory_error) {
251 		mem_free(p);
252 		if (out_of_memory(0, NULL, 0))
253 			goto retry_after_memory_error;
254 		decompress_error(term, ce, cast_uchar "zlib", z.msg ? (unsigned char *)z.msg : TEXT_(T_OUT_OF_MEMORY), errp);
255 		return 1;
256 	}
257 	if (err && (unsigned char *)z.next_out == p) {
258 		mem_free(p);
259 		return 1;
260 	}
261 	ce->decompressed = p;
262 	ce->decompressed_len = (unsigned char *)z.next_out - (unsigned char *)p;
263 	decompressed_cache_size += ce->decompressed_len;
264 	ce->decompressed = mem_realloc(ce->decompressed, ce->decompressed_len);
265 	return 0;
266 }
267 #endif
268 
269 #ifdef HAVE_BROTLI
270 #if defined(__TINYC__) && defined(__STDC_VERSION__)
271 #undef __STDC_VERSION__
272 #endif
273 #include <brotli/decode.h>
brotli_alloc(void * opaque,size_t size)274 static void *brotli_alloc(void *opaque, size_t size)
275 {
276 	return mem_alloc_mayfail(size);
277 }
brotli_free(void * opaque,void * ptr)278 static void brotli_free(void *opaque, void *ptr)
279 {
280 	if (ptr) mem_free(ptr);
281 }
decode_brotli(struct terminal * term,struct cache_entry * ce,int * errp)282 static int decode_brotli(struct terminal *term, struct cache_entry *ce, int *errp)
283 {
284 	unsigned char err;
285 	BrotliDecoderState *br;
286 	const unsigned char *next_in;
287 	size_t avail_in;
288 	unsigned char *next_out;
289 	size_t avail_out;
290 	off_t offset;
291 	BrotliDecoderResult res;
292 	unsigned char *p;
293 	struct fragment *f;
294 	struct list_head *lf;
295 	size_t size;
296 
297 	err = 0;
298 	decoder_memory_init(&p, &size, ce->length);
299 	next_out = p;
300 	avail_out = size;
301 	br = BrotliDecoderCreateInstance(brotli_alloc, brotli_free, NULL);
302 	if (!br) {
303 		decompress_error(term, ce, cast_uchar "brotli", TEXT_(T_OUT_OF_MEMORY), errp);
304 		err = 1;
305 		goto after_inflateend;
306 	}
307 
308 	offset = 0;
309 	foreach(struct fragment, f, lf, ce->frag) {
310 		if (f->offset != offset) break;
311 		next_in = f->data;
312 		avail_in = (size_t)f->length;
313 		if ((off_t)avail_in != f->length) overalloc();
314 		repeat_frag:
315 		res = BrotliDecoderDecompressStream(br, &avail_in, &next_in, &avail_out, &next_out, NULL);
316 		if (res == BROTLI_DECODER_RESULT_ERROR) {
317 			decompress_error(term, ce, cast_uchar "brotli", cast_uchar BrotliDecoderErrorString(BrotliDecoderGetErrorCode(br)), errp);
318 			err = 1;
319 			goto finish;
320 		}
321 		if (!avail_out) {
322 			size_t addsize;
323 			if (decoder_memory_expand(&p, size, &addsize) < 0) {
324 				decompress_error(term, ce, cast_uchar "brotli", TEXT_(T_OUT_OF_MEMORY), errp);
325 				err = 1;
326 				goto finish;
327 			}
328 			next_out = p + size;
329 			avail_out = addsize;
330 			size += addsize;
331 			goto repeat_frag;
332 		}
333 		if (avail_in) goto repeat_frag;
334 		/*
335 		BrotliDecoderHasMoreOutput(br) returns BROTLI_BOOL which is defined differently for different compilers, so we must not use it
336 		if (BrotliDecoderHasMoreOutput(br)) goto repeat_frag;
337 		*/
338 		offset += f->length;
339 	}
340 
341 	finish:
342 	BrotliDecoderDestroyInstance(br);
343 	after_inflateend:
344 	if (err && next_out == p) {
345 		mem_free(p);
346 		return 1;
347 	}
348 	ce->decompressed = p;
349 	ce->decompressed_len = next_out - p;
350 	decompressed_cache_size += ce->decompressed_len;
351 	ce->decompressed = mem_realloc(ce->decompressed, ce->decompressed_len);
352 	return 0;
353 }
354 #endif
355 
356 #ifdef HAVE_ZSTD
357 #include <zstd.h>
decode_zstd(struct terminal * term,struct cache_entry * ce,int * errp)358 static int decode_zstd(struct terminal *term, struct cache_entry *ce, int *errp)
359 {
360 	ZSTD_DStream *zstd_stream = NULL;
361 	struct fragment *f;
362 	struct list_head *lf;
363 	off_t offset;
364 #ifdef HAVE_LONG_LONG
365 	unsigned long long dec_size;
366 #else
367 	size_t dec_size;
368 #endif
369 	size_t ret;
370 	unsigned char *p = NULL;
371 	size_t size;
372 	ZSTD_inBuffer in;
373 	ZSTD_outBuffer out;
374 
375 	zstd_stream = ZSTD_createDStream();
376 	if (!zstd_stream) {
377 mem_error:
378 		decompress_error(term, ce, cast_uchar "zstd", TEXT_(T_OUT_OF_MEMORY), errp);
379 		goto err_ret;
380 	}
381 	ret = ZSTD_initDStream(zstd_stream);
382 	if (ZSTD_isError(ret)) {
383 		decompress_error(term, ce, cast_uchar "zstd", cast_uchar ZSTD_getErrorName(ret), errp);
384 		goto err_ret;
385 	}
386 
387 	dec_size = 0;
388 	if (!list_empty(ce->frag)) {
389 		f = list_struct(ce->frag.next, struct fragment);
390 		dec_size = ZSTD_getDecompressedSize(f->data, f->length);
391 		/*debug("dec size %llx\n", dec_size);*/
392 		if (ZSTD_isError(dec_size))
393 			dec_size = 0;
394 	}
395 
396 	decoder_memory_init(&p, &size, dec_size && dec_size < MAXINT ? (off_t)dec_size : ce->length);
397 
398 	out.dst = p;
399 	out.size = size;
400 	out.pos = 0;
401 
402 	offset = 0;
403 	foreach(struct fragment, f, lf, ce->frag) {
404 		if (f->offset != offset) break;
405 		in.src = f->data;
406 		in.size = f->length;
407 		in.pos = 0;
408 
409 repeat_frag:
410 		ret = ZSTD_decompressStream(zstd_stream, &out, &in);
411 		if (ZSTD_isError(ret)) {
412 			decompress_error(term, ce, cast_uchar "zstd", cast_uchar ZSTD_getErrorName(ret), errp);
413 			goto err_ret;
414 		}
415 		if (out.pos == out.size) {
416 			size_t addsize;
417 			if (decoder_memory_expand(&p, size, &addsize) < 0)
418 				goto mem_error;
419 			out.dst = p + size;
420 			out.size = addsize;
421 			out.pos = 0;
422 			size += addsize;
423 			goto repeat_frag;
424 		}
425 		if (in.pos < in.size)
426 			goto repeat_frag;
427 
428 		offset += f->length;
429 	}
430 
431 	ZSTD_freeDStream(zstd_stream);
432 	zstd_stream = NULL;
433 
434 	ce->decompressed = p;
435 	ce->decompressed_len = (unsigned char *)out.dst + out.pos - p;
436 	decompressed_cache_size += ce->decompressed_len;
437 
438 	ce->decompressed = mem_realloc(ce->decompressed, ce->decompressed_len);
439 
440 	return 0;
441 
442 err_ret:
443 	if (p)
444 		mem_free(p);
445 	if (zstd_stream)
446 		ZSTD_freeDStream(zstd_stream);
447 	return 1;
448 }
449 #endif
450 
451 #ifdef HAVE_BZIP2
452 #include <bzlib.h>
decode_bzip2(struct terminal * term,struct cache_entry * ce,int * errp)453 static int decode_bzip2(struct terminal *term, struct cache_entry *ce, int *errp)
454 {
455 	unsigned char err;
456 	unsigned char memory_error;
457 	bz_stream z;
458 	off_t offset;
459 	int r;
460 	unsigned char *p;
461 	struct fragment *f;
462 	struct list_head *lf;
463 	size_t size;
464 
465 	retry_after_memory_error:
466 	err = 0;
467 	memory_error = 0;
468 	decoder_memory_init(&p, &size, ce->length);
469 	memset(&z, 0, sizeof z);
470 	z.next_in = NULL;
471 	z.avail_in = 0;
472 	z.next_out = cast_char p;
473 	z.avail_out = (unsigned)size;
474 	z.bzalloc = NULL;
475 	z.bzfree = NULL;
476 	z.opaque = NULL;
477 	r = BZ2_bzDecompressInit(&z, 0, 0);
478 	init_failed:
479 	switch (r) {
480 		case BZ_OK:		break;
481 		case BZ_MEM_ERROR:	memory_error = 1;
482 					err = 1;
483 					goto after_inflateend;
484 		case BZ_PARAM_ERROR:
485 					decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Invalid parameter", errp);
486 					err = 1;
487 					goto after_inflateend;
488 		case BZ_CONFIG_ERROR:	decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Bzlib is miscompiled", errp);
489 					err = 1;
490 					goto after_inflateend;
491 		default:		decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Unknown return value on BZ2_bzDecompressInit", errp);
492 					err = 1;
493 					goto after_inflateend;
494 	}
495 	offset = 0;
496 	foreach(struct fragment, f, lf, ce->frag) {
497 		if (f->offset != offset) break;
498 		z.next_in = cast_char f->data;
499 		z.avail_in = (unsigned)f->length;
500 		if ((off_t)z.avail_in != f->length) overalloc();
501 		repeat_frag:
502 		r = BZ2_bzDecompress(&z);
503 		switch (r) {
504 			case BZ_OK:		break;
505 			case BZ_STREAM_END:
506 						r = BZ2_bzDecompressEnd(&z);
507 						if (r != BZ_OK) goto end_failed;
508 						r = BZ2_bzDecompressInit(&z, 0, 0);
509 						if (r != BZ_OK) goto init_failed;
510 						break;
511 			case BZ_DATA_ERROR_MAGIC:
512 			case BZ_DATA_ERROR:	decompress_error(term, ce, cast_uchar "bzip2", TEXT_(T_COMPRESSED_ERROR), errp);
513 						err = 1;
514 						goto finish;
515 			case BZ_PARAM_ERROR:	decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Internal error on BZ2_bzDecompress", errp);
516 						err = 1;
517 						goto finish;
518 			case BZ_MEM_ERROR:
519 			mem_error:		memory_error = 1;
520 						err = 1;
521 						goto finish;
522 			default:		decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Unknown return value on BZ2_bzDecompress", errp);
523 						err = 1;
524 						break;
525 		}
526 		if (!z.avail_out) {
527 			size_t addsize;
528 			if (decoder_memory_expand(&p, size, &addsize) < 0)
529 				goto mem_error;
530 			z.next_out = cast_char(p + size);
531 			z.avail_out = (unsigned)addsize;
532 			size += addsize;
533 			goto repeat_frag;
534 		}
535 		if (z.avail_in) goto repeat_frag;
536 		offset += f->length;
537 	}
538 	finish:
539 	r = BZ2_bzDecompressEnd(&z);
540 	end_failed:
541 	switch (r) {
542 		case BZ_OK:		break;
543 		case BZ_PARAM_ERROR:	decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Internal error on BZ2_bzDecompressEnd", errp);
544 					err = 1;
545 					break;
546 		case BZ_MEM_ERROR:	memory_error = 1;
547 					err = 1;
548 					break;
549 		default:		decompress_error(term, ce, cast_uchar "bzip2", cast_uchar "Unknown return value on BZ2_bzDecompressEnd", errp);
550 					err = 1;
551 					break;
552 	}
553 	after_inflateend:
554 	if (memory_error) {
555 		mem_free(p);
556 		if (out_of_memory(0, NULL, 0))
557 			goto retry_after_memory_error;
558 		decompress_error(term, ce, cast_uchar "bzip2", TEXT_(T_OUT_OF_MEMORY), errp);
559 		return 1;
560 	}
561 	if (err && (unsigned char *)z.next_out == p) {
562 		mem_free(p);
563 		return 1;
564 	}
565 	ce->decompressed = p;
566 	ce->decompressed_len = (unsigned char *)z.next_out - (unsigned char *)p;
567 	decompressed_cache_size += ce->decompressed_len;
568 	ce->decompressed = mem_realloc(ce->decompressed, ce->decompressed_len);
569 	return 0;
570 }
571 #endif
572 
573 #ifdef HAVE_LZMA
574 #include <lzma.h>
575 #define internal internal_
decode_lzma(struct terminal * term,struct cache_entry * ce,int * errp)576 static int decode_lzma(struct terminal *term, struct cache_entry *ce, int *errp)
577 {
578 	unsigned char err;
579 	unsigned char memory_error;
580 	lzma_stream z = LZMA_STREAM_INIT;
581 	off_t offset;
582 	int r;
583 	unsigned char *p;
584 	struct fragment *f;
585 	struct list_head *lf;
586 	size_t size;
587 
588 	retry_after_memory_error:
589 	err = 0;
590 	memory_error = 0;
591 	decoder_memory_init(&p, &size, ce->length);
592 	z.next_in = NULL;
593 	z.avail_in = 0;
594 	z.next_out = p;
595 	z.avail_out = size;
596 	r = lzma_auto_decoder(&z, UINT64_MAX, 0);
597 	init_failed:
598 	switch (r) {
599 		case LZMA_OK:		break;
600 		case LZMA_MEM_ERROR:	memory_error = 1;
601 					err = 1;
602 					goto after_inflateend;
603 		case LZMA_OPTIONS_ERROR:
604 					decompress_error(term, ce, cast_uchar "lzma", cast_uchar "Invalid parameter", errp);
605 					err = 1;
606 					goto after_inflateend;
607 		case LZMA_PROG_ERROR:	decompress_error(term, ce, cast_uchar "lzma", cast_uchar "Lzma is miscompiled", errp);
608 					err = 1;
609 					goto after_inflateend;
610 		default:		decompress_error(term, ce, cast_uchar "lzma", cast_uchar "Unknown return value on lzma_auto_decoder", errp);
611 					err = 1;
612 					goto after_inflateend;
613 	}
614 	offset = 0;
615 	foreach(struct fragment, f, lf, ce->frag) {
616 		if (f->offset != offset) break;
617 		z.next_in = f->data;
618 		z.avail_in = (size_t)f->length;
619 		if ((off_t)z.avail_in != f->length) overalloc();
620 		repeat_frag:
621 		r = lzma_code(&z, LZMA_RUN);
622 		switch (r) {
623 			case LZMA_OK:
624 			case LZMA_NO_CHECK:
625 			case LZMA_UNSUPPORTED_CHECK:
626 			case LZMA_GET_CHECK:
627 						break;
628 			case LZMA_STREAM_END:
629 						lzma_end(&z);
630 						r = lzma_auto_decoder(&z, UINT64_MAX, 0);
631 						if (r != LZMA_OK) goto init_failed;
632 						break;
633 			case LZMA_MEM_ERROR:
634 			mem_error:		memory_error = 1;
635 						err = 1;
636 						goto finish;
637 			case LZMA_MEMLIMIT_ERROR:
638 						decompress_error(term, ce, cast_uchar "lzma", cast_uchar "Memory limit was exceeded", errp);
639 						err = 1;
640 						goto finish;
641 			case LZMA_FORMAT_ERROR:
642 			case LZMA_DATA_ERROR:
643 			case LZMA_BUF_ERROR:
644 						decompress_error(term, ce, cast_uchar "lzma", TEXT_(T_COMPRESSED_ERROR), errp);
645 						err = 1;
646 						goto finish;
647 			case LZMA_OPTIONS_ERROR:decompress_error(term, ce, cast_uchar "lzma", cast_uchar "File contains unsupported options", errp);
648 						err = 1;
649 						goto finish;
650 			case LZMA_PROG_ERROR:	decompress_error(term, ce, cast_uchar "lzma", cast_uchar "Lzma is miscompiled", errp);
651 						err = 1;
652 						goto finish;
653 			default:		decompress_error(term, ce, cast_uchar "lzma", cast_uchar "Unknown return value on lzma_code", errp);
654 						err = 1;
655 						break;
656 		}
657 		if (!z.avail_out) {
658 			size_t addsize;
659 			if (decoder_memory_expand(&p, size, &addsize) < 0)
660 				goto mem_error;
661 			z.next_out = p + size;
662 			z.avail_out = addsize;
663 			size += addsize;
664 			goto repeat_frag;
665 		}
666 		if (z.avail_in) goto repeat_frag;
667 		offset += f->length;
668 	}
669 	finish:
670 	lzma_end(&z);
671 	after_inflateend:
672 	if (memory_error) {
673 		mem_free(p);
674 		if (out_of_memory(0, NULL, 0))
675 			goto retry_after_memory_error;
676 		decompress_error(term, ce, cast_uchar "lzma", TEXT_(T_OUT_OF_MEMORY), errp);
677 		return 1;
678 	}
679 	if (err && (unsigned char *)z.next_out == p) {
680 		mem_free(p);
681 		return 1;
682 	}
683 	ce->decompressed = p;
684 	ce->decompressed_len = (unsigned char *)z.next_out - (unsigned char *)p;
685 	decompressed_cache_size += ce->decompressed_len;
686 	ce->decompressed = mem_realloc(ce->decompressed, ce->decompressed_len);
687 	return 0;
688 }
689 #endif
690 
691 #ifdef HAVE_LZIP
692 #include <lzlib.h>
decode_lzip(struct terminal * term,struct cache_entry * ce,int * errp)693 static int decode_lzip(struct terminal *term, struct cache_entry *ce, int *errp)
694 {
695 	unsigned char err;
696 	unsigned char memory_error;
697 	void *lz;
698 	off_t offset;
699 	int r;
700 	enum LZ_Errno le;
701 	unsigned char *p;
702 	struct fragment *f;
703 	struct list_head *lf;
704 	size_t size;
705 	size_t used_size;
706 
707 	retry_after_memory_error:
708 	err = 0;
709 	memory_error = 0;
710 	decoder_memory_init(&p, &size, ce->length);
711 	used_size = 0;
712 
713 	lz = LZ_decompress_open();
714 	if (!lz) {
715 		err = 1;
716 		memory_error = 1;
717 		goto after_inflateend;
718 	}
719 	if (LZ_decompress_errno(lz) != LZ_ok) {
720 lz_error:
721 		le = LZ_decompress_errno(lz);
722 		if (0)
723 mem_error:		le = LZ_mem_error;
724 		err = 1;
725 		if (le == LZ_mem_error) {
726 			memory_error = 1;
727 		} else if (!ce->incomplete) {
728 			decompress_error(term, ce, cast_uchar "lzip", cast_uchar LZ_strerror(le), errp);
729 		}
730 		goto finish;
731 	}
732 
733 	offset = 0;
734 	foreach(struct fragment, f, lf, ce->frag) {
735 		unsigned char *current_ptr;
736 		int current_len;
737 		if (f->offset != offset) break;
738 		current_ptr = f->data;
739 		current_len = (int)f->length;
740 		while (current_len) {
741 			r = LZ_decompress_write(lz, current_ptr, current_len);
742 			if (r == -1)
743 				goto lz_error;
744 			current_ptr += r;
745 			current_len -= r;
746 			do {
747 				if (used_size == size) {
748 					size_t addsize;
749 					if (decoder_memory_expand(&p, size, &addsize) < 0)
750 						goto mem_error;
751 					size += addsize;
752 				}
753 				r = LZ_decompress_read(lz, p + used_size, (int)(size - used_size));
754 				if (r == -1)
755 					goto lz_error;
756 				used_size += r;
757 			} while (r);
758 		}
759 		offset += f->length;
760 	}
761 	r = LZ_decompress_finish(lz);
762 	if (r == -1)
763 		goto lz_error;
764 	while ((r = LZ_decompress_finished(lz)) == 0) {
765 		if (used_size == size) {
766 			size_t addsize;
767 			if (decoder_memory_expand(&p, size, &addsize) < 0)
768 				goto mem_error;
769 			size += addsize;
770 		}
771 		r = LZ_decompress_read(lz, p + used_size, (int)(size - used_size));
772 		if (r == -1)
773 			goto lz_error;
774 		used_size += r;
775 	}
776 	if (r == -1)
777 		goto lz_error;
778 
779 finish:
780 	LZ_decompress_close(lz);
781 after_inflateend:
782 	if (memory_error) {
783 		mem_free(p);
784 		if (out_of_memory(0, NULL, 0))
785 			goto retry_after_memory_error;
786 		decompress_error(term, ce, cast_uchar "lzip", TEXT_(T_OUT_OF_MEMORY), errp);
787 		return 1;
788 	}
789 	if (err && !used_size) {
790 		mem_free(p);
791 		return 1;
792 	}
793 	ce->decompressed = p;
794 	ce->decompressed_len = used_size;
795 	decompressed_cache_size += ce->decompressed_len;
796 	ce->decompressed = mem_realloc(ce->decompressed, ce->decompressed_len);
797 	return 0;
798 }
799 #endif
800 
get_file_by_term(struct terminal * term,struct cache_entry * ce,unsigned char ** start,size_t * len,int * errp)801 int get_file_by_term(struct terminal *term, struct cache_entry *ce, unsigned char **start, size_t *len, int *errp)
802 {
803 	unsigned char *enc;
804 	struct fragment *fr;
805 	int e;
806 	if (errp) *errp = 0;
807 	*start = NULL;
808 	*len = 0;
809 	if (!ce) return 1;
810 	if (ce->decompressed) {
811 #if defined(HAVE_ANY_COMPRESSION)
812 		return_decompressed:
813 #endif
814 		*start = ce->decompressed;
815 		*len = ce->decompressed_len;
816 		return 0;
817 	}
818 	enc = get_content_encoding(ce->head, ce->url, 0);
819 	if (enc) {
820 #ifdef HAVE_ZLIB
821 		if (!casestrcmp(enc, cast_uchar "gzip") || !casestrcmp(enc, cast_uchar "x-gzip") || !casestrcmp(enc, cast_uchar "deflate")) {
822 			int defl = !casestrcmp(enc, cast_uchar "deflate");
823 			mem_free(enc);
824 			if (decode_gzip(term, ce, defl, errp)) goto uncompressed;
825 			goto return_decompressed;
826 		}
827 #endif
828 #ifdef HAVE_BROTLI
829 		if (!casestrcmp(enc, cast_uchar "br")) {
830 			mem_free(enc);
831 			if (decode_brotli(term, ce, errp)) goto uncompressed;
832 			goto return_decompressed;
833 		}
834 #endif
835 #ifdef HAVE_ZSTD
836 		if (!casestrcmp(enc, cast_uchar "zstd")) {
837 			mem_free(enc);
838 			if (decode_zstd(term, ce, errp)) goto uncompressed;
839 			goto return_decompressed;
840 		}
841 #endif
842 #ifdef HAVE_BZIP2
843 		if (!casestrcmp(enc, cast_uchar "bzip2")) {
844 			mem_free(enc);
845 			if (decode_bzip2(term, ce, errp)) goto uncompressed;
846 			goto return_decompressed;
847 		}
848 #endif
849 #ifdef HAVE_LZMA
850 		if (!casestrcmp(enc, cast_uchar "lzma") || !casestrcmp(enc, cast_uchar "lzma2")) {
851 			mem_free(enc);
852 			if (decode_lzma(term, ce, errp)) goto uncompressed;
853 			goto return_decompressed;
854 		}
855 #endif
856 #ifdef HAVE_LZIP
857 		if (!casestrcmp(enc, cast_uchar "lzip")) {
858 			mem_free(enc);
859 			if (decode_lzip(term, ce, errp)) goto uncompressed;
860 			goto return_decompressed;
861 		}
862 #endif
863 		mem_free(enc);
864 		goto uncompressed;
865 	}
866 	uncompressed:
867 	if ((e = defrag_entry(ce)) < 0) {
868 		unsigned char *msg = get_err_msg(e, term);
869 		if (display_error(term, TEXT_(T_ERROR), errp)) {
870 			unsigned char *u = display_url(term, ce->url, 1);
871 			msg_box(term, getml(u, NULL), TEXT_(T_ERROR), AL_CENTER, TEXT_(T_ERROR_LOADING), cast_uchar " ", u, cast_uchar ":\n\n", msg, MSG_BOX_END, NULL, 1, TEXT_(T_CANCEL), msg_box_null, B_ENTER | B_ESC);
872 		}
873 	}
874 	if (list_empty(ce->frag)) return 1;
875 	fr = list_struct(ce->frag.next, struct fragment);
876 	if (fr->offset || !fr->length) return 1;
877 	*start = fr->data;
878 	*len = fr->length;
879 	return 0;
880 }
881 
get_file(struct object_request * o,unsigned char ** start,size_t * len)882 int get_file(struct object_request *o, unsigned char **start, size_t *len)
883 {
884 	struct terminal *term;
885 	*start = NULL;
886 	*len = 0;
887 	if (!o) return 1;
888 	term = find_terminal(o->term);
889 	return get_file_by_term(term, o->ce, start, len, NULL);
890 }
891 
free_decompressed_data(struct cache_entry * e)892 void free_decompressed_data(struct cache_entry *e)
893 {
894 	if (e->decompressed) {
895 		if (decompressed_cache_size < e->decompressed_len)
896 			internal_error("free_decompressed_data: decompressed_cache_size underflow %lu, %lu", (unsigned long)decompressed_cache_size, (unsigned long)e->decompressed_len);
897 		decompressed_cache_size -= e->decompressed_len;
898 		e->decompressed_len = 0;
899 		mem_free(e->decompressed);
900 		e->decompressed = NULL;
901 	}
902 }
903 
904 #ifdef HAVE_ANY_COMPRESSION
905 
add_compress_methods(unsigned char ** s,int * l)906 void add_compress_methods(unsigned char **s, int *l)
907 {
908 	int cl = 0;
909 #ifdef HAVE_ZLIB
910 	{
911 		if (!cl) cl = 1; else add_to_str(s, l, cast_uchar ", ");
912 		add_to_str(s, l, cast_uchar "ZLIB");
913 #ifdef zlib_version
914 		add_to_str(s, l, cast_uchar " (");
915 		add_to_str(s, l, (unsigned char *)zlib_version);
916 		add_chr_to_str(s, l, ')');
917 #endif
918 	}
919 #endif
920 #ifdef HAVE_BROTLI
921 	{
922 		unsigned bv = BrotliDecoderVersion();
923 		if (!cl) cl = 1; else add_to_str(s, l, cast_uchar ", ");
924 		add_to_str(s, l, cast_uchar "BROTLI");
925 		add_to_str(s, l, cast_uchar " (");
926 		add_num_to_str(s, l, bv >> 24);
927 		add_chr_to_str(s, l, '.');
928 		add_num_to_str(s, l, (bv >> 12) & 0xfff);
929 		add_chr_to_str(s, l, '.');
930 		add_num_to_str(s, l, bv & 0xfff);
931 		add_chr_to_str(s, l, ')');
932 	}
933 #endif
934 #ifdef HAVE_ZSTD
935 	{
936 		unsigned zv = ZSTD_versionNumber();
937 		if (!cl) cl = 1; else add_to_str(s, l, cast_uchar ", ");
938 		add_to_str(s, l, cast_uchar "ZSTD");
939 		add_to_str(s, l, cast_uchar " (");
940 		add_num_to_str(s, l, zv / 10000);
941 		add_chr_to_str(s, l, '.');
942 		add_num_to_str(s, l, zv / 100 % 100);
943 		add_chr_to_str(s, l, '.');
944 		add_num_to_str(s, l, zv % 100);
945 		add_chr_to_str(s, l, ')');
946 	}
947 #endif
948 #ifdef HAVE_BZIP2
949 	{
950 		unsigned char *b = (unsigned char *)BZ2_bzlibVersion();
951 		int bl = (int)strcspn(cast_const_char b, ",");
952 		if (!cl) cl = 1; else add_to_str(s, l, cast_uchar ", ");
953 		add_to_str(s, l, cast_uchar "BZIP2");
954 		add_to_str(s, l, cast_uchar " (");
955 		add_bytes_to_str(s, l, b, bl);
956 		add_chr_to_str(s, l, ')');
957 	}
958 #endif
959 #ifdef HAVE_LZMA
960 	{
961 		if (!cl) cl = 1; else add_to_str(s, l, cast_uchar ", ");
962 		add_to_str(s, l, cast_uchar "LZMA");
963 		add_to_str(s, l, cast_uchar " (");
964 		add_to_str(s, l, cast_uchar lzma_version_string());
965 		add_chr_to_str(s, l, ')');
966 	}
967 #endif
968 #ifdef HAVE_LZIP
969 	{
970 		if (!cl) cl = 1; else add_to_str(s, l, cast_uchar ", ");
971 		add_to_str(s, l, cast_uchar "LZIP");
972 		add_to_str(s, l, cast_uchar " (");
973 		add_to_str(s, l, cast_uchar LZ_version());
974 		add_chr_to_str(s, l, ')');
975 	}
976 #endif
977 }
978 
979 #endif
980