1 /*-
2 * Copyright (c) 2003-2007 Tim Kientzle
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "archive_platform.h"
27
28 __FBSDID("$FreeBSD$");
29
30
31 #ifdef HAVE_ERRNO_H
32 #include <errno.h>
33 #endif
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40 #ifdef HAVE_LIMITS_H
41 #include <limits.h>
42 #endif
43 #ifdef HAVE_UNISTD_H
44 #include <unistd.h>
45 #endif
46 #ifdef HAVE_ZLIB_H
47 #include <zlib.h>
48 #endif
49
50 #include "archive.h"
51 #include "archive_entry.h"
52 #include "archive_endian.h"
53 #include "archive_private.h"
54 #include "archive_read_private.h"
55
56 #ifdef HAVE_ZLIB_H
57 struct private_data {
58 z_stream stream;
59 char in_stream;
60 unsigned char *out_block;
61 size_t out_block_size;
62 int64_t total_out;
63 unsigned long crc;
64 uint32_t mtime;
65 char *name;
66 char eof; /* True = found end of compressed data. */
67 };
68
69 /* Gzip Filter. */
70 static ssize_t gzip_filter_read(struct archive_read_filter *, const void **);
71 static int gzip_filter_close(struct archive_read_filter *);
72 #endif
73
74 /*
75 * Note that we can detect gzip archives even if we can't decompress
76 * them. (In fact, we like detecting them because we can give better
77 * error messages.) So the bid framework here gets compiled even
78 * if zlib is unavailable.
79 *
80 * TODO: If zlib is unavailable, gzip_bidder_init() should
81 * use the compress_program framework to try to fire up an external
82 * gzip program.
83 */
84 static int gzip_bidder_bid(struct archive_read_filter_bidder *,
85 struct archive_read_filter *);
86 static int gzip_bidder_init(struct archive_read_filter *);
87
88 #if ARCHIVE_VERSION_NUMBER < 4000000
89 /* Deprecated; remove in libarchive 4.0 */
90 int
archive_read_support_compression_gzip(struct archive * a)91 archive_read_support_compression_gzip(struct archive *a)
92 {
93 return archive_read_support_filter_gzip(a);
94 }
95 #endif
96
97 static const struct archive_read_filter_bidder_vtable
98 gzip_bidder_vtable = {
99 .bid = gzip_bidder_bid,
100 .init = gzip_bidder_init,
101 };
102
103 int
archive_read_support_filter_gzip(struct archive * _a)104 archive_read_support_filter_gzip(struct archive *_a)
105 {
106 struct archive_read *a = (struct archive_read *)_a;
107
108 if (__archive_read_register_bidder(a, NULL, "gzip",
109 &gzip_bidder_vtable) != ARCHIVE_OK)
110 return (ARCHIVE_FATAL);
111
112 /* Signal the extent of gzip support with the return value here. */
113 #if HAVE_ZLIB_H
114 return (ARCHIVE_OK);
115 #else
116 archive_set_error(_a, ARCHIVE_ERRNO_MISC,
117 "Using external gzip program");
118 return (ARCHIVE_WARN);
119 #endif
120 }
121
122 /*
123 * Read and verify the header.
124 *
125 * Returns zero if the header couldn't be validated, else returns
126 * number of bytes in header. If pbits is non-NULL, it receives a
127 * count of bits verified, suitable for use by bidder.
128 */
129 static ssize_t
peek_at_header(struct archive_read_filter * filter,int * pbits,struct private_data * state)130 peek_at_header(struct archive_read_filter *filter, int *pbits,
131 #ifdef HAVE_ZLIB_H
132 struct private_data *state
133 #else
134 void *state
135 #endif
136 )
137 {
138 const unsigned char *p;
139 ssize_t avail, len;
140 int bits = 0;
141 int header_flags;
142 #ifndef HAVE_ZLIB_H
143 (void)state; /* UNUSED */
144 #endif
145
146 /* Start by looking at the first ten bytes of the header, which
147 * is all fixed layout. */
148 len = 10;
149 p = __archive_read_filter_ahead(filter, len, &avail);
150 if (p == NULL || avail == 0)
151 return (0);
152 /* We only support deflation- third byte must be 0x08. */
153 if (memcmp(p, "\x1F\x8B\x08", 3) != 0)
154 return (0);
155 bits += 24;
156 if ((p[3] & 0xE0)!= 0) /* No reserved flags set. */
157 return (0);
158 bits += 3;
159 header_flags = p[3];
160 /* Bytes 4-7 are mod time in little endian. */
161 #ifdef HAVE_ZLIB_H
162 if (state)
163 state->mtime = archive_le32dec(p + 4);
164 #endif
165 /* Byte 8 is deflate flags. */
166 /* XXXX TODO: return deflate flags back to consume_header for use
167 in initializing the decompressor. */
168 /* Byte 9 is OS. */
169
170 /* Optional extra data: 2 byte length plus variable body. */
171 if (header_flags & 4) {
172 p = __archive_read_filter_ahead(filter, len + 2, &avail);
173 if (p == NULL)
174 return (0);
175 len += ((int)p[len + 1] << 8) | (int)p[len];
176 len += 2;
177 }
178
179 /* Null-terminated optional filename. */
180 if (header_flags & 8) {
181 #ifdef HAVE_ZLIB_H
182 ssize_t file_start = len;
183 #endif
184 do {
185 ++len;
186 if (avail < len)
187 p = __archive_read_filter_ahead(filter,
188 len, &avail);
189 if (p == NULL)
190 return (0);
191 } while (p[len - 1] != 0);
192
193 #ifdef HAVE_ZLIB_H
194 if (state) {
195 /* Reset the name in case of repeat header reads. */
196 free(state->name);
197 state->name = strdup((const char *)&p[file_start]);
198 }
199 #endif
200 }
201
202 /* Null-terminated optional comment. */
203 if (header_flags & 16) {
204 do {
205 ++len;
206 if (avail < len)
207 p = __archive_read_filter_ahead(filter,
208 len, &avail);
209 if (p == NULL)
210 return (0);
211 } while (p[len - 1] != 0);
212 }
213
214 /* Optional header CRC */
215 if ((header_flags & 2)) {
216 p = __archive_read_filter_ahead(filter, len + 2, &avail);
217 if (p == NULL)
218 return (0);
219 #if 0
220 int hcrc = ((int)p[len + 1] << 8) | (int)p[len];
221 int crc = /* XXX TODO: Compute header CRC. */;
222 if (crc != hcrc)
223 return (0);
224 bits += 16;
225 #endif
226 len += 2;
227 }
228
229 if (pbits != NULL)
230 *pbits = bits;
231 return (len);
232 }
233
234 /*
235 * Bidder just verifies the header and returns the number of verified bits.
236 */
237 static int
gzip_bidder_bid(struct archive_read_filter_bidder * self,struct archive_read_filter * filter)238 gzip_bidder_bid(struct archive_read_filter_bidder *self,
239 struct archive_read_filter *filter)
240 {
241 int bits_checked;
242
243 (void)self; /* UNUSED */
244
245 if (peek_at_header(filter, &bits_checked, NULL))
246 return (bits_checked);
247 return (0);
248 }
249
250 #ifndef HAVE_ZLIB_H
251
252 /*
253 * If we don't have the library on this system, we can't do the
254 * decompression directly. We can, however, try to run "gzip -d"
255 * in case that's available.
256 */
257 static int
gzip_bidder_init(struct archive_read_filter * self)258 gzip_bidder_init(struct archive_read_filter *self)
259 {
260 int r;
261
262 r = __archive_read_program(self, "gzip -d");
263 /* Note: We set the format here even if __archive_read_program()
264 * above fails. We do, after all, know what the format is
265 * even if we weren't able to read it. */
266 self->code = ARCHIVE_FILTER_GZIP;
267 self->name = "gzip";
268 return (r);
269 }
270
271 #else
272
273 static int
gzip_read_header(struct archive_read_filter * self,struct archive_entry * entry)274 gzip_read_header(struct archive_read_filter *self, struct archive_entry *entry)
275 {
276 struct private_data *state;
277
278 state = (struct private_data *)self->data;
279
280 /* A mtime of 0 is considered invalid/missing. */
281 if (state->mtime != 0)
282 archive_entry_set_mtime(entry, state->mtime, 0);
283
284 /* If the name is available, extract it. */
285 if (state->name)
286 archive_entry_set_pathname(entry, state->name);
287
288 return (ARCHIVE_OK);
289 }
290
291 static const struct archive_read_filter_vtable
292 gzip_reader_vtable = {
293 .read = gzip_filter_read,
294 .close = gzip_filter_close,
295 #ifdef HAVE_ZLIB_H
296 .read_header = gzip_read_header,
297 #endif
298 };
299
300 /*
301 * Initialize the filter object.
302 */
303 static int
gzip_bidder_init(struct archive_read_filter * self)304 gzip_bidder_init(struct archive_read_filter *self)
305 {
306 struct private_data *state;
307 static const size_t out_block_size = 64 * 1024;
308 void *out_block;
309
310 self->code = ARCHIVE_FILTER_GZIP;
311 self->name = "gzip";
312
313 state = (struct private_data *)calloc(sizeof(*state), 1);
314 out_block = (unsigned char *)malloc(out_block_size);
315 if (state == NULL || out_block == NULL) {
316 free(out_block);
317 free(state);
318 archive_set_error(&self->archive->archive, ENOMEM,
319 "Can't allocate data for gzip decompression");
320 return (ARCHIVE_FATAL);
321 }
322
323 self->data = state;
324 state->out_block_size = out_block_size;
325 state->out_block = out_block;
326 self->vtable = &gzip_reader_vtable;
327
328 state->in_stream = 0; /* We're not actually within a stream yet. */
329
330 return (ARCHIVE_OK);
331 }
332
333 static int
consume_header(struct archive_read_filter * self)334 consume_header(struct archive_read_filter *self)
335 {
336 struct private_data *state;
337 ssize_t avail;
338 size_t len;
339 int ret;
340
341 state = (struct private_data *)self->data;
342
343 /* If this is a real header, consume it. */
344 len = peek_at_header(self->upstream, NULL, state);
345 if (len == 0)
346 return (ARCHIVE_EOF);
347 __archive_read_filter_consume(self->upstream, len);
348
349 /* Initialize CRC accumulator. */
350 state->crc = crc32(0L, NULL, 0);
351
352 /* Initialize compression library. */
353 state->stream.next_in = (unsigned char *)(uintptr_t)
354 __archive_read_filter_ahead(self->upstream, 1, &avail);
355 state->stream.avail_in = (uInt)avail;
356 ret = inflateInit2(&(state->stream),
357 -15 /* Don't check for zlib header */);
358
359 /* Decipher the error code. */
360 switch (ret) {
361 case Z_OK:
362 state->in_stream = 1;
363 return (ARCHIVE_OK);
364 case Z_STREAM_ERROR:
365 archive_set_error(&self->archive->archive,
366 ARCHIVE_ERRNO_MISC,
367 "Internal error initializing compression library: "
368 "invalid setup parameter");
369 break;
370 case Z_MEM_ERROR:
371 archive_set_error(&self->archive->archive, ENOMEM,
372 "Internal error initializing compression library: "
373 "out of memory");
374 break;
375 case Z_VERSION_ERROR:
376 archive_set_error(&self->archive->archive,
377 ARCHIVE_ERRNO_MISC,
378 "Internal error initializing compression library: "
379 "invalid library version");
380 break;
381 default:
382 archive_set_error(&self->archive->archive,
383 ARCHIVE_ERRNO_MISC,
384 "Internal error initializing compression library: "
385 " Zlib error %d", ret);
386 break;
387 }
388 return (ARCHIVE_FATAL);
389 }
390
391 static int
consume_trailer(struct archive_read_filter * self)392 consume_trailer(struct archive_read_filter *self)
393 {
394 struct private_data *state;
395 const unsigned char *p;
396 ssize_t avail;
397
398 state = (struct private_data *)self->data;
399
400 state->in_stream = 0;
401 switch (inflateEnd(&(state->stream))) {
402 case Z_OK:
403 break;
404 default:
405 archive_set_error(&self->archive->archive,
406 ARCHIVE_ERRNO_MISC,
407 "Failed to clean up gzip decompressor");
408 return (ARCHIVE_FATAL);
409 }
410
411 /* GZip trailer is a fixed 8 byte structure. */
412 p = __archive_read_filter_ahead(self->upstream, 8, &avail);
413 if (p == NULL || avail == 0)
414 return (ARCHIVE_FATAL);
415
416 /* XXX TODO: Verify the length and CRC. */
417
418 /* We've verified the trailer, so consume it now. */
419 __archive_read_filter_consume(self->upstream, 8);
420
421 return (ARCHIVE_OK);
422 }
423
424 static ssize_t
gzip_filter_read(struct archive_read_filter * self,const void ** p)425 gzip_filter_read(struct archive_read_filter *self, const void **p)
426 {
427 struct private_data *state;
428 size_t decompressed;
429 ssize_t avail_in, max_in;
430 int ret;
431
432 state = (struct private_data *)self->data;
433
434 /* Empty our output buffer. */
435 state->stream.next_out = state->out_block;
436 state->stream.avail_out = (uInt)state->out_block_size;
437
438 /* Try to fill the output buffer. */
439 while (state->stream.avail_out > 0 && !state->eof) {
440 /* If we're not in a stream, read a header
441 * and initialize the decompression library. */
442 if (!state->in_stream) {
443 ret = consume_header(self);
444 if (ret == ARCHIVE_EOF) {
445 state->eof = 1;
446 break;
447 }
448 if (ret < ARCHIVE_OK)
449 return (ret);
450 }
451
452 /* Peek at the next available data. */
453 /* ZLib treats stream.next_in as const but doesn't declare
454 * it so, hence this ugly cast. */
455 state->stream.next_in = (unsigned char *)(uintptr_t)
456 __archive_read_filter_ahead(self->upstream, 1, &avail_in);
457 if (state->stream.next_in == NULL) {
458 archive_set_error(&self->archive->archive,
459 ARCHIVE_ERRNO_MISC,
460 "truncated gzip input");
461 return (ARCHIVE_FATAL);
462 }
463 if (UINT_MAX >= SSIZE_MAX)
464 max_in = SSIZE_MAX;
465 else
466 max_in = UINT_MAX;
467 if (avail_in > max_in)
468 avail_in = max_in;
469 state->stream.avail_in = (uInt)avail_in;
470
471 /* Decompress and consume some of that data. */
472 ret = inflate(&(state->stream), 0);
473 switch (ret) {
474 case Z_OK: /* Decompressor made some progress. */
475 __archive_read_filter_consume(self->upstream,
476 avail_in - state->stream.avail_in);
477 break;
478 case Z_STREAM_END: /* Found end of stream. */
479 __archive_read_filter_consume(self->upstream,
480 avail_in - state->stream.avail_in);
481 /* Consume the stream trailer; release the
482 * decompression library. */
483 ret = consume_trailer(self);
484 if (ret < ARCHIVE_OK)
485 return (ret);
486 break;
487 default:
488 /* Return an error. */
489 archive_set_error(&self->archive->archive,
490 ARCHIVE_ERRNO_MISC,
491 "gzip decompression failed");
492 return (ARCHIVE_FATAL);
493 }
494 }
495
496 /* We've read as much as we can. */
497 decompressed = state->stream.next_out - state->out_block;
498 state->total_out += decompressed;
499 if (decompressed == 0)
500 *p = NULL;
501 else
502 *p = state->out_block;
503 return (decompressed);
504 }
505
506 /*
507 * Clean up the decompressor.
508 */
509 static int
gzip_filter_close(struct archive_read_filter * self)510 gzip_filter_close(struct archive_read_filter *self)
511 {
512 struct private_data *state;
513 int ret;
514
515 state = (struct private_data *)self->data;
516 ret = ARCHIVE_OK;
517
518 if (state->in_stream) {
519 switch (inflateEnd(&(state->stream))) {
520 case Z_OK:
521 break;
522 default:
523 archive_set_error(&(self->archive->archive),
524 ARCHIVE_ERRNO_MISC,
525 "Failed to clean up gzip compressor");
526 ret = ARCHIVE_FATAL;
527 }
528 }
529
530 free(state->name);
531 free(state->out_block);
532 free(state);
533 return (ret);
534 }
535
536 #endif /* HAVE_ZLIB_H */
537