Import libarchive-2.8.4.
[dragonfly.git] / contrib / libarchive / libarchive / archive_read_support_compression_xz.c
1 /*-
2  * Copyright (c) 2009 Michihiro NAKAJIMA
3  * Copyright (c) 2003-2008 Tim Kientzle and Miklos Vajna
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "archive_platform.h"
28
29 __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_compression_xz.c 201167 2009-12-29 06:06:20Z kientzle $");
30
31 #ifdef HAVE_ERRNO_H
32 #include <errno.h>
33 #endif
34 #include <stdio.h>
35 #ifdef HAVE_STDLIB_H
36 #include <stdlib.h>
37 #endif
38 #ifdef HAVE_STRING_H
39 #include <string.h>
40 #endif
41 #ifdef HAVE_UNISTD_H
42 #include <unistd.h>
43 #endif
44 #if HAVE_LZMA_H
45 #include <lzma.h>
46 #elif HAVE_LZMADEC_H
47 #include <lzmadec.h>
48 #endif
49
50 #include "archive.h"
51 #include "archive_endian.h"
52 #include "archive_private.h"
53 #include "archive_read_private.h"
54
55 #if HAVE_LZMA_H && HAVE_LIBLZMA
56
57 struct private_data {
58         lzma_stream      stream;
59         unsigned char   *out_block;
60         size_t           out_block_size;
61         int64_t          total_out;
62         char             eof; /* True = found end of compressed data. */
63 };
64
65 /* Combined lzma/xz filter */
66 static ssize_t  xz_filter_read(struct archive_read_filter *, const void **);
67 static int      xz_filter_close(struct archive_read_filter *);
68 static int      xz_lzma_bidder_init(struct archive_read_filter *);
69
70 #elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC
71
72 struct private_data {
73         lzmadec_stream   stream;
74         unsigned char   *out_block;
75         size_t           out_block_size;
76         int64_t          total_out;
77         char             eof; /* True = found end of compressed data. */
78 };
79
80 /* Lzma-only filter */
81 static ssize_t  lzma_filter_read(struct archive_read_filter *, const void **);
82 static int      lzma_filter_close(struct archive_read_filter *);
83 #endif
84
85 /*
86  * Note that we can detect xz and lzma compressed files even if we
87  * can't decompress them.  (In fact, we like detecting them because we
88  * can give better error messages.)  So the bid framework here gets
89  * compiled even if no lzma library is available.
90  */
91 static int      xz_bidder_bid(struct archive_read_filter_bidder *,
92                     struct archive_read_filter *);
93 static int      xz_bidder_init(struct archive_read_filter *);
94 static int      lzma_bidder_bid(struct archive_read_filter_bidder *,
95                     struct archive_read_filter *);
96 static int      lzma_bidder_init(struct archive_read_filter *);
97
98 int
99 archive_read_support_compression_xz(struct archive *_a)
100 {
101         struct archive_read *a = (struct archive_read *)_a;
102         struct archive_read_filter_bidder *bidder = __archive_read_get_bidder(a);
103
104         archive_clear_error(_a);
105         if (bidder == NULL)
106                 return (ARCHIVE_FATAL);
107
108         bidder->data = NULL;
109         bidder->bid = xz_bidder_bid;
110         bidder->init = xz_bidder_init;
111         bidder->options = NULL;
112         bidder->free = NULL;
113 #if HAVE_LZMA_H && HAVE_LIBLZMA
114         return (ARCHIVE_OK);
115 #else
116         archive_set_error(_a, ARCHIVE_ERRNO_MISC,
117             "Using external unxz program for xz decompression");
118         return (ARCHIVE_WARN);
119 #endif
120 }
121
122 int
123 archive_read_support_compression_lzma(struct archive *_a)
124 {
125         struct archive_read *a = (struct archive_read *)_a;
126         struct archive_read_filter_bidder *bidder = __archive_read_get_bidder(a);
127
128         archive_clear_error(_a);
129         if (bidder == NULL)
130                 return (ARCHIVE_FATAL);
131
132         bidder->data = NULL;
133         bidder->bid = lzma_bidder_bid;
134         bidder->init = lzma_bidder_init;
135         bidder->options = NULL;
136         bidder->free = NULL;
137 #if HAVE_LZMA_H && HAVE_LIBLZMA
138         return (ARCHIVE_OK);
139 #elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC
140         return (ARCHIVE_OK);
141 #else
142         archive_set_error(_a, ARCHIVE_ERRNO_MISC,
143             "Using external unlzma program for lzma decompression");
144         return (ARCHIVE_WARN);
145 #endif
146 }
147
148 /*
149  * Test whether we can handle this data.
150  */
151 static int
152 xz_bidder_bid(struct archive_read_filter_bidder *self,
153     struct archive_read_filter *filter)
154 {
155         const unsigned char *buffer;
156         ssize_t avail;
157         int bits_checked;
158
159         (void)self; /* UNUSED */
160
161         buffer = __archive_read_filter_ahead(filter, 6, &avail);
162         if (buffer == NULL)
163                 return (0);
164
165         /*
166          * Verify Header Magic Bytes : FD 37 7A 58 5A 00
167          */
168         bits_checked = 0;
169         if (buffer[0] != 0xFD)
170                 return (0);
171         bits_checked += 8;
172         if (buffer[1] != 0x37)
173                 return (0);
174         bits_checked += 8;
175         if (buffer[2] != 0x7A)
176                 return (0);
177         bits_checked += 8;
178         if (buffer[3] != 0x58)
179                 return (0);
180         bits_checked += 8;
181         if (buffer[4] != 0x5A)
182                 return (0);
183         bits_checked += 8;
184         if (buffer[5] != 0x00)
185                 return (0);
186         bits_checked += 8;
187
188         return (bits_checked);
189 }
190
191 /*
192  * Test whether we can handle this data.
193  *
194  * <sigh> LZMA has a rather poor file signature.  Zeros do not
195  * make good signature bytes as a rule, and the only non-zero byte
196  * here is an ASCII character.  For example, an uncompressed tar
197  * archive whose first file is ']' would satisfy this check.  It may
198  * be necessary to exclude LZMA from compression_all() because of
199  * this.  Clients of libarchive would then have to explicitly enable
200  * LZMA checking instead of (or in addition to) compression_all() when
201  * they have other evidence (file name, command-line option) to go on.
202  */
203 static int
204 lzma_bidder_bid(struct archive_read_filter_bidder *self,
205     struct archive_read_filter *filter)
206 {
207         const unsigned char *buffer;
208         ssize_t avail;
209         uint32_t dicsize;
210         uint64_t uncompressed_size;
211         int bits_checked;
212
213         (void)self; /* UNUSED */
214
215         buffer = __archive_read_filter_ahead(filter, 14, &avail);
216         if (buffer == NULL)
217                 return (0);
218
219         /* First byte of raw LZMA stream is commonly 0x5d.
220          * The first byte is a special number, which consists of
221          * three parameters of LZMA compression, a number of literal
222          * context bits(which is from 0 to 8, default is 3), a number
223          * of literal pos bits(which is from 0 to 4, default is 0),
224          * a number of pos bits(which is from 0 to 4, default is 2).
225          * The first byte is made by
226          * (pos bits * 5 + literal pos bit) * 9 + * literal contest bit,
227          * and so the default value in this field is
228          * (2 * 5 + 0) * 9 + 3 = 0x5d.
229          * lzma of LZMA SDK has options to change those parameters.
230          * It means a range of this field is from 0 to 224. And lzma of
231          * XZ Utils with option -e records 0x5e in this field. */
232         /* NOTE: If this checking of the first byte increases false
233          * recognition, we should allow only 0x5d and 0x5e for the first
234          * byte of LZMA stream. */
235         bits_checked = 0;
236         if (buffer[0] > (4 * 5 + 4) * 9 + 8)
237                 return (0);
238         /* Most likely value in the first byte of LZMA stream. */
239         if (buffer[0] == 0x5d || buffer[0] == 0x5e)
240                 bits_checked += 8;
241
242         /* Sixth through fourteenth bytes are uncompressed size,
243          * stored in little-endian order. `-1' means uncompressed
244          * size is unknown and lzma of XZ Utils always records `-1'
245          * in this field. */
246         uncompressed_size = archive_le64dec(buffer+5);
247         if (uncompressed_size == (uint64_t)ARCHIVE_LITERAL_LL(-1))
248                 bits_checked += 64;
249
250         /* Second through fifth bytes are dictionary size, stored in
251          * little-endian order. The minimum dictionary size is
252          * 1 << 12(4KiB) which the lzma of LZMA SDK uses with option
253          * -d12 and the maxinam dictionary size is 1 << 27(128MiB)
254          * which the one uses with option -d27.
255          * NOTE: A comment of LZMA SDK source code says this dictionary
256          * range is from 1 << 12 to 1 << 30. */
257         dicsize = archive_le32dec(buffer+1);
258         switch (dicsize) {
259         case 0x00001000:/* lzma of LZMA SDK option -d12. */
260         case 0x00002000:/* lzma of LZMA SDK option -d13. */
261         case 0x00004000:/* lzma of LZMA SDK option -d14. */
262         case 0x00008000:/* lzma of LZMA SDK option -d15. */
263         case 0x00010000:/* lzma of XZ Utils option -0 and -1.
264                          * lzma of LZMA SDK option -d16. */
265         case 0x00020000:/* lzma of LZMA SDK option -d17. */
266         case 0x00040000:/* lzma of LZMA SDK option -d18. */
267         case 0x00080000:/* lzma of XZ Utils option -2.
268                          * lzma of LZMA SDK option -d19. */
269         case 0x00100000:/* lzma of XZ Utils option -3.
270                          * lzma of LZMA SDK option -d20. */
271         case 0x00200000:/* lzma of XZ Utils option -4.
272                          * lzma of LZMA SDK option -d21. */
273         case 0x00400000:/* lzma of XZ Utils option -5.
274                          * lzma of LZMA SDK option -d22. */
275         case 0x00800000:/* lzma of XZ Utils option -6.
276                          * lzma of LZMA SDK option -d23. */
277         case 0x01000000:/* lzma of XZ Utils option -7.
278                          * lzma of LZMA SDK option -d24. */
279         case 0x02000000:/* lzma of XZ Utils option -8.
280                          * lzma of LZMA SDK option -d25. */
281         case 0x04000000:/* lzma of XZ Utils option -9.
282                          * lzma of LZMA SDK option -d26. */
283         case 0x08000000:/* lzma of LZMA SDK option -d27. */
284                 bits_checked += 32;
285                 break;
286         default:
287                 /* If a memory usage for encoding was not enough on
288                  * the platform where LZMA stream was made, lzma of
289                  * XZ Utils automatically decreased the dictionary
290                  * size to enough memory for encoding by 1Mi bytes
291                  * (1 << 20).*/
292                 if (dicsize <= 0x03F00000 && dicsize >= 0x00300000 &&
293                     (dicsize & ((1 << 20)-1)) == 0 &&
294                     bits_checked == 8 + 64) {
295                         bits_checked += 32;
296                         break;
297                 }
298                 /* Otherwise dictionary size is unlikely. But it is
299                  * possible that someone makes lzma stream with
300                  * liblzma/LZMA SDK in one's dictionary size. */
301                 return (0);
302         }
303
304         /* TODO: The above test is still very weak.  It would be
305          * good to do better. */
306
307         return (bits_checked);
308 }
309
310 #if HAVE_LZMA_H && HAVE_LIBLZMA
311
312 /*
313  * liblzma 4.999.7 and later support both lzma and xz streams.
314  */
315 static int
316 xz_bidder_init(struct archive_read_filter *self)
317 {
318         self->code = ARCHIVE_COMPRESSION_XZ;
319         self->name = "xz";
320         return (xz_lzma_bidder_init(self));
321 }
322
323 static int
324 lzma_bidder_init(struct archive_read_filter *self)
325 {
326         self->code = ARCHIVE_COMPRESSION_LZMA;
327         self->name = "lzma";
328         return (xz_lzma_bidder_init(self));
329 }
330
331 /*
332  * Setup the callbacks.
333  */
334 static int
335 xz_lzma_bidder_init(struct archive_read_filter *self)
336 {
337         static const size_t out_block_size = 64 * 1024;
338         void *out_block;
339         struct private_data *state;
340         int ret;
341
342         state = (struct private_data *)calloc(sizeof(*state), 1);
343         out_block = (unsigned char *)malloc(out_block_size);
344         if (state == NULL || out_block == NULL) {
345                 archive_set_error(&self->archive->archive, ENOMEM,
346                     "Can't allocate data for xz decompression");
347                 free(out_block);
348                 free(state);
349                 return (ARCHIVE_FATAL);
350         }
351
352         self->data = state;
353         state->out_block_size = out_block_size;
354         state->out_block = out_block;
355         self->read = xz_filter_read;
356         self->skip = NULL; /* not supported */
357         self->close = xz_filter_close;
358
359         state->stream.avail_in = 0;
360
361         state->stream.next_out = state->out_block;
362         state->stream.avail_out = state->out_block_size;
363
364         /* Initialize compression library.
365          * TODO: I don't know what value is best for memlimit.
366          *       maybe, it needs to check memory size which
367          *       running system has.
368          */
369         if (self->code == ARCHIVE_COMPRESSION_XZ)
370                 ret = lzma_stream_decoder(&(state->stream),
371                     (1U << 30),/* memlimit */
372                     LZMA_CONCATENATED);
373         else
374                 ret = lzma_alone_decoder(&(state->stream),
375                     (1U << 30));/* memlimit */
376
377         if (ret == LZMA_OK)
378                 return (ARCHIVE_OK);
379
380         /* Library setup failed: Choose an error message and clean up. */
381         switch (ret) {
382         case LZMA_MEM_ERROR:
383                 archive_set_error(&self->archive->archive, ENOMEM,
384                     "Internal error initializing compression library: "
385                     "Cannot allocate memory");
386                 break;
387         case LZMA_OPTIONS_ERROR:
388                 archive_set_error(&self->archive->archive,
389                     ARCHIVE_ERRNO_MISC,
390                     "Internal error initializing compression library: "
391                     "Invalid or unsupported options");
392                 break;
393         default:
394                 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
395                     "Internal error initializing lzma library");
396                 break;
397         }
398
399         free(state->out_block);
400         free(state);
401         self->data = NULL;
402         return (ARCHIVE_FATAL);
403 }
404
405 /*
406  * Return the next block of decompressed data.
407  */
408 static ssize_t
409 xz_filter_read(struct archive_read_filter *self, const void **p)
410 {
411         struct private_data *state;
412         size_t decompressed;
413         ssize_t avail_in;
414         int ret;
415
416         state = (struct private_data *)self->data;
417
418         /* Empty our output buffer. */
419         state->stream.next_out = state->out_block;
420         state->stream.avail_out = state->out_block_size;
421
422         /* Try to fill the output buffer. */
423         while (state->stream.avail_out > 0 && !state->eof) {
424                 state->stream.next_in =
425                     __archive_read_filter_ahead(self->upstream, 1, &avail_in);
426                 if (state->stream.next_in == NULL && avail_in < 0)
427                         return (ARCHIVE_FATAL);
428                 state->stream.avail_in = avail_in;
429
430                 /* Decompress as much as we can in one pass. */
431                 ret = lzma_code(&(state->stream),
432                     (state->stream.avail_in == 0)? LZMA_FINISH: LZMA_RUN);
433                 switch (ret) {
434                 case LZMA_STREAM_END: /* Found end of stream. */
435                         state->eof = 1;
436                         /* FALL THROUGH */
437                 case LZMA_OK: /* Decompressor made some progress. */
438                         __archive_read_filter_consume(self->upstream,
439                             avail_in - state->stream.avail_in);
440                         break;
441                 case LZMA_MEM_ERROR:
442                         archive_set_error(&self->archive->archive, ENOMEM,
443                             "Lzma library error: Cannot allocate memory");
444                         return (ARCHIVE_FATAL);
445                 case LZMA_MEMLIMIT_ERROR:
446                         archive_set_error(&self->archive->archive, ENOMEM,
447                             "Lzma library error: Out of memory");
448                         return (ARCHIVE_FATAL);
449                 case LZMA_FORMAT_ERROR:
450                         archive_set_error(&self->archive->archive,
451                             ARCHIVE_ERRNO_MISC,
452                             "Lzma library error: format not recognized");
453                         return (ARCHIVE_FATAL);
454                 case LZMA_OPTIONS_ERROR:
455                         archive_set_error(&self->archive->archive,
456                             ARCHIVE_ERRNO_MISC,
457                             "Lzma library error: Invalid options");
458                         return (ARCHIVE_FATAL);
459                 case LZMA_DATA_ERROR:
460                         archive_set_error(&self->archive->archive,
461                             ARCHIVE_ERRNO_MISC,
462                             "Lzma library error: Corrupted input data");
463                         return (ARCHIVE_FATAL);
464                 case LZMA_BUF_ERROR:
465                         archive_set_error(&self->archive->archive,
466                             ARCHIVE_ERRNO_MISC,
467                             "Lzma library error:  No progress is possible");
468                         return (ARCHIVE_FATAL);
469                 default:
470                         /* Return an error. */
471                         archive_set_error(&self->archive->archive,
472                             ARCHIVE_ERRNO_MISC,
473                             "Lzma decompression failed:  Unknown error");
474                         return (ARCHIVE_FATAL);
475                 }
476         }
477
478         decompressed = state->stream.next_out - state->out_block;
479         state->total_out += decompressed;
480         if (decompressed == 0)
481                 *p = NULL;
482         else
483                 *p = state->out_block;
484         return (decompressed);
485 }
486
487 /*
488  * Clean up the decompressor.
489  */
490 static int
491 xz_filter_close(struct archive_read_filter *self)
492 {
493         struct private_data *state;
494
495         state = (struct private_data *)self->data;
496         lzma_end(&(state->stream));
497         free(state->out_block);
498         free(state);
499         return (ARCHIVE_OK);
500 }
501
502 #else
503
504 #if HAVE_LZMADEC_H && HAVE_LIBLZMADEC
505
506 /*
507  * If we have the older liblzmadec library, then we can handle
508  * LZMA streams but not XZ streams.
509  */
510
511 /*
512  * Setup the callbacks.
513  */
514 static int
515 lzma_bidder_init(struct archive_read_filter *self)
516 {
517         static const size_t out_block_size = 64 * 1024;
518         void *out_block;
519         struct private_data *state;
520         ssize_t ret, avail_in;
521
522         self->code = ARCHIVE_COMPRESSION_LZMA;
523         self->name = "lzma";
524
525         state = (struct private_data *)calloc(sizeof(*state), 1);
526         out_block = (unsigned char *)malloc(out_block_size);
527         if (state == NULL || out_block == NULL) {
528                 archive_set_error(&self->archive->archive, ENOMEM,
529                     "Can't allocate data for lzma decompression");
530                 free(out_block);
531                 free(state);
532                 return (ARCHIVE_FATAL);
533         }
534
535         self->data = state;
536         state->out_block_size = out_block_size;
537         state->out_block = out_block;
538         self->read = lzma_filter_read;
539         self->skip = NULL; /* not supported */
540         self->close = lzma_filter_close;
541
542         /* Prime the lzma library with 18 bytes of input. */
543         state->stream.next_in = (unsigned char *)(uintptr_t)
544             __archive_read_filter_ahead(self->upstream, 18, &avail_in);
545         if (state->stream.next_in == NULL)
546                 return (ARCHIVE_FATAL);
547         state->stream.avail_in = avail_in;
548         state->stream.next_out = state->out_block;
549         state->stream.avail_out = state->out_block_size;
550
551         /* Initialize compression library. */
552         ret = lzmadec_init(&(state->stream));
553         __archive_read_filter_consume(self->upstream,
554             avail_in - state->stream.avail_in);
555         if (ret == LZMADEC_OK)
556                 return (ARCHIVE_OK);
557
558         /* Library setup failed: Clean up. */
559         archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
560             "Internal error initializing lzma library");
561
562         /* Override the error message if we know what really went wrong. */
563         switch (ret) {
564         case LZMADEC_HEADER_ERROR:
565                 archive_set_error(&self->archive->archive,
566                     ARCHIVE_ERRNO_MISC,
567                     "Internal error initializing compression library: "
568                     "invalid header");
569                 break;
570         case LZMADEC_MEM_ERROR:
571                 archive_set_error(&self->archive->archive, ENOMEM,
572                     "Internal error initializing compression library: "
573                     "out of memory");
574                 break;
575         }
576
577         free(state->out_block);
578         free(state);
579         self->data = NULL;
580         return (ARCHIVE_FATAL);
581 }
582
583 /*
584  * Return the next block of decompressed data.
585  */
586 static ssize_t
587 lzma_filter_read(struct archive_read_filter *self, const void **p)
588 {
589         struct private_data *state;
590         size_t decompressed;
591         ssize_t avail_in, ret;
592
593         state = (struct private_data *)self->data;
594
595         /* Empty our output buffer. */
596         state->stream.next_out = state->out_block;
597         state->stream.avail_out = state->out_block_size;
598
599         /* Try to fill the output buffer. */
600         while (state->stream.avail_out > 0 && !state->eof) {
601                 state->stream.next_in = (unsigned char *)(uintptr_t)
602                     __archive_read_filter_ahead(self->upstream, 1, &avail_in);
603                 if (state->stream.next_in == NULL && avail_in < 0)
604                         return (ARCHIVE_FATAL);
605                 state->stream.avail_in = avail_in;
606
607                 /* Decompress as much as we can in one pass. */
608                 ret = lzmadec_decode(&(state->stream), avail_in == 0);
609                 switch (ret) {
610                 case LZMADEC_STREAM_END: /* Found end of stream. */
611                         state->eof = 1;
612                         /* FALL THROUGH */
613                 case LZMADEC_OK: /* Decompressor made some progress. */
614                         __archive_read_filter_consume(self->upstream,
615                             avail_in - state->stream.avail_in);
616                         break;
617                 case LZMADEC_BUF_ERROR: /* Insufficient input data? */
618                         archive_set_error(&self->archive->archive,
619                             ARCHIVE_ERRNO_MISC,
620                             "Insufficient compressed data");
621                         return (ARCHIVE_FATAL);
622                 default:
623                         /* Return an error. */
624                         archive_set_error(&self->archive->archive,
625                             ARCHIVE_ERRNO_MISC,
626                             "Lzma decompression failed");
627                         return (ARCHIVE_FATAL);
628                 }
629         }
630
631         decompressed = state->stream.next_out - state->out_block;
632         state->total_out += decompressed;
633         if (decompressed == 0)
634                 *p = NULL;
635         else
636                 *p = state->out_block;
637         return (decompressed);
638 }
639
640 /*
641  * Clean up the decompressor.
642  */
643 static int
644 lzma_filter_close(struct archive_read_filter *self)
645 {
646         struct private_data *state;
647         int ret;
648
649         state = (struct private_data *)self->data;
650         ret = ARCHIVE_OK;
651         switch (lzmadec_end(&(state->stream))) {
652         case LZMADEC_OK:
653                 break;
654         default:
655                 archive_set_error(&(self->archive->archive),
656                     ARCHIVE_ERRNO_MISC,
657                     "Failed to clean up %s compressor",
658                     self->archive->archive.compression_name);
659                 ret = ARCHIVE_FATAL;
660         }
661
662         free(state->out_block);
663         free(state);
664         return (ret);
665 }
666
667 #else
668
669 /*
670  *
671  * If we have no suitable library on this system, we can't actually do
672  * the decompression.  We can, however, still detect compressed
673  * archives and emit a useful message.
674  *
675  */
676 static int
677 lzma_bidder_init(struct archive_read_filter *self)
678 {
679         int r;
680
681         r = __archive_read_program(self, "unlzma");
682         /* Note: We set the format here even if __archive_read_program()
683          * above fails.  We do, after all, know what the format is
684          * even if we weren't able to read it. */
685         self->code = ARCHIVE_COMPRESSION_LZMA;
686         self->name = "lzma";
687         return (r);
688 }
689
690 #endif /* HAVE_LZMADEC_H */
691
692
693 static int
694 xz_bidder_init(struct archive_read_filter *self)
695 {
696         int r;
697
698         r = __archive_read_program(self, "unxz");
699         /* Note: We set the format here even if __archive_read_program()
700          * above fails.  We do, after all, know what the format is
701          * even if we weren't able to read it. */
702         self->code = ARCHIVE_COMPRESSION_XZ;
703         self->name = "xz";
704         return (r);
705 }
706
707
708 #endif /* HAVE_LZMA_H */