/////////////////////////////////////////////////////////////////////////////// // /// \file 02_decompress.c /// \brief Decompress .xz files to stdout /// /// Usage: ./02_decompress INPUT_FILES... > OUTFILE /// /// Example: ./02_decompress foo.xz bar.xz > foobar // // Author: Lasse Collin // // This file has been put into the public domain. // You can do whatever you want with this file. // /////////////////////////////////////////////////////////////////////////////// #include <stdbool.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <lzma.h> static bool init_decoder(lzma_stream *strm) { // Initialize a .xz decoder. The decoder supports a memory usage limit // and a set of flags. // // The memory usage of the decompressor depends on the settings used // to compress a .xz file. It can vary from less than a megabyte to // a few gigabytes, but in practice (at least for now) it rarely // exceeds 65 MiB because that's how much memory is required to // decompress files created with "xz -9". Settings requiring more // memory take extra effort to use and don't (at least for now) // provide significantly better compression in most cases. // // Memory usage limit is useful if it is important that the // decompressor won't consume gigabytes of memory. The need // for limiting depends on the application. In this example, // no memory usage limiting is used. This is done by setting // the limit to UINT64_MAX. // // The .xz format allows concatenating compressed files as is: // // echo foo | xz > foobar.xz // echo bar | xz >> foobar.xz // // When decompressing normal standalone .xz files, LZMA_CONCATENATED // should always be used to support decompression of concatenated // .xz files. If LZMA_CONCATENATED isn't used, the decoder will stop // after the first .xz stream. This can be useful when .xz data has // been embedded inside another file format. // // Flags other than LZMA_CONCATENATED are supported too, and can // be combined with bitwise-or. See lzma/container.h // (src/liblzma/api/lzma/container.h in the source package or e.g. // /usr/include/lzma/container.h depending on the install prefix) // for details. lzma_ret ret = lzma_stream_decoder( strm, UINT64_MAX, LZMA_CONCATENATED); // Return successfully if the initialization went fine. if (ret == LZMA_OK) return true; // Something went wrong. The possible errors are documented in // lzma/container.h (src/liblzma/api/lzma/container.h in the source // package or e.g. /usr/include/lzma/container.h depending on the // install prefix). // // Note that LZMA_MEMLIMIT_ERROR is never possible here. If you // specify a very tiny limit, the error will be delayed until // the first headers have been parsed by a call to lzma_code(). const char *msg; switch (ret) { case LZMA_MEM_ERROR: msg = "Memory allocation failed"; break; case LZMA_OPTIONS_ERROR: msg = "Unsupported decompressor flags"; break; default: // This is most likely LZMA_PROG_ERROR indicating a bug in // this program or in liblzma. It is inconvenient to have a // separate error message for errors that should be impossible // to occur, but knowing the error code is important for // debugging. That's why it is good to print the error code // at least when there is no good error message to show. msg = "Unknown error, possibly a bug"; break; } fprintf(stderr, "Error initializing the decoder: %s (error code %u)\n", msg, ret); return false; } static bool decompress(lzma_stream *strm, const char *inname, FILE *infile, FILE *outfile) { // When LZMA_CONCATENATED flag was used when initializing the decoder, // we need to tell lzma_code() when there will be no more input. // This is done by setting action to LZMA_FINISH instead of LZMA_RUN // in the same way as it is done when encoding. // // When LZMA_CONCATENATED isn't used, there is no need to use // LZMA_FINISH to tell when all the input has been read, but it // is still OK to use it if you want. When LZMA_CONCATENATED isn't // used, the decoder will stop after the first .xz stream. In that // case some unused data may be left in strm->next_in. lzma_action action = LZMA_RUN; uint8_t inbuf[BUFSIZ]; uint8_t outbuf[BUFSIZ]; strm->next_in = NULL; strm->avail_in = 0; strm->next_out = outbuf; strm->avail_out = sizeof(outbuf); while (true) { if (strm->avail_in == 0 && !feof(infile)) { strm->next_in = inbuf; strm->avail_in = fread(inbuf, 1, sizeof(inbuf), infile); if (ferror(infile)) { fprintf(stderr, "%s: Read error: %s\n", inname, strerror(errno)); return false; } // Once the end of the input file has been reached, // we need to tell lzma_code() that no more input // will be coming. As said before, this isn't required // if the LZMA_CONCATENATED flag isn't used when // initializing the decoder. if (feof(infile)) action = LZMA_FINISH; } lzma_ret ret = lzma_code(strm, action); if (strm->avail_out == 0 || ret == LZMA_STREAM_END) { size_t write_size = sizeof(outbuf) - strm->avail_out; if (fwrite(outbuf, 1, write_size, outfile) != write_size) { fprintf(stderr, "Write error: %s\n", strerror(errno)); return false; } strm->next_out = outbuf; strm->avail_out = sizeof(outbuf); } if (ret != LZMA_OK) { // Once everything has been decoded successfully, the // return value of lzma_code() will be LZMA_STREAM_END. // // It is important to check for LZMA_STREAM_END. Do not // assume that getting ret != LZMA_OK would mean that // everything has gone well or that when you aren't // getting more output it must have successfully // decoded everything. if (ret == LZMA_STREAM_END) return true; // It's not LZMA_OK nor LZMA_STREAM_END, // so it must be an error code. See lzma/base.h // (src/liblzma/api/lzma/base.h in the source package // or e.g. /usr/include/lzma/base.h depending on the // install prefix) for the list and documentation of // possible values. Many values listen in lzma_ret // enumeration aren't possible in this example, but // can be made possible by enabling memory usage limit // or adding flags to the decoder initialization. const char *msg; switch (ret) { case LZMA_MEM_ERROR: msg = "Memory allocation failed"; break; case LZMA_FORMAT_ERROR: // .xz magic bytes weren't found. msg = "The input is not in the .xz format"; break; case LZMA_OPTIONS_ERROR: // For example, the headers specify a filter // that isn't supported by this liblzma // version (or it hasn't been enabled when // building liblzma, but no-one sane does // that unless building liblzma for an // embedded system). Upgrading to a newer // liblzma might help. // // Note that it is unlikely that the file has // accidentally became corrupt if you get this // error. The integrity of the .xz headers is // always verified with a CRC32, so // unintentionally corrupt files can be // distinguished from unsupported files. msg = "Unsupported compression options"; break; case LZMA_DATA_ERROR: msg = "Compressed file is corrupt"; break; case LZMA_BUF_ERROR: // Typically this error means that a valid // file has got truncated, but it might also // be a damaged part in the file that makes // the decoder think the file is truncated. // If you prefer, you can use the same error // message for this as for LZMA_DATA_ERROR. msg = "Compressed file is truncated or " "otherwise corrupt"; break; default: // This is most likely LZMA_PROG_ERROR. msg = "Unknown error, possibly a bug"; break; } fprintf(stderr, "%s: Decoder error: " "%s (error code %u)\n", inname, msg, ret); return false; } } } extern int main(int argc, char **argv) { if (argc <= 1) { fprintf(stderr, "Usage: %s FILES...\n", argv[0]); return EXIT_FAILURE; } lzma_stream strm = LZMA_STREAM_INIT; bool success = true; // Try to decompress all files. for (int i = 1; i < argc; ++i) { if (!init_decoder(&strm)) { // Decoder initialization failed. There's no point // to retry it so we need to exit. success = false; break; } FILE *infile = fopen(argv[i], "rb"); if (infile == NULL) { fprintf(stderr, "%s: Error opening the " "input file: %s\n", argv[i], strerror(errno)); success = false; } else { success &= decompress(&strm, argv[i], infile, stdout); fclose(infile); } } // Free the memory allocated for the decoder. This only needs to be // done after the last file. lzma_end(&strm); if (fclose(stdout)) { fprintf(stderr, "Write error: %s\n", strerror(errno)); success = false; } return success ? EXIT_SUCCESS : EXIT_FAILURE; }