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