doc/examples/02_decompress.c - jrn/xz - Git at Google

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \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;
 }
	///////////////////////////////////////////////////////////////////////////////
	//
	/// \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;
	}