xzdec.c File Reference

Simple single-threaded tool to uncompress .xz or .lzma files. More...

#include "sysdefs.h"
#include "lzma.h"
#include <stdarg.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include "getopt.h"
#include "tuklib_progname.h"
#include "tuklib_exit.h"

Go to the source code of this file.

Macros
#define	TOOL_FORMAT   "xz"

Functions
static void	lzma_attribute ((__format__(__printf__, 1, 2)))
static void	lzma_attribute ((__noreturn__))
static void	parse_options (int argc, char **argv)
	Parses command line options. More...
static void	uncompress (lzma_stream *strm, FILE *file, const char *filename)
int	main (int argc, char **argv)

Variables
static int	display_errors = 2

Detailed Description

Simple single-threaded tool to uncompress .xz or .lzma files.

Definition in file xzdec.c.

Macro Definition Documentation

TOOL_FORMAT

#define TOOL_FORMAT   "xz"

Definition at line 34 of file xzdec.c.

Function Documentation

lzma_attribute() [1/2]

static void lzma_attribute ( (__format__(__printf__, 1, 2))  )

static

Definition at line 43 of file xzdec.c.

{
    va_list ap;
    va_start(ap, fmt);
 
    if (display_errors) {
        fprintf(stderr, "%s: ", progname);
        vfprintf(stderr, fmt, ap);
        fprintf(stderr, "\n");
    }
 
    va_end(ap);
    return;
}

References display_errors, and progname.

lzma_attribute() [2/2]

static void lzma_attribute ( (__noreturn__)  )

static

Definition at line 60 of file xzdec.c.

{
    printf(
"Usage: %s [OPTION]... [FILE]...\n"
"Decompress files in the ." TOOL_FORMAT " format to standard output.\n"
"\n"
"  -d, --decompress   (ignored, only decompression is supported)\n"
"  -k, --keep         (ignored, files are never deleted)\n"
"  -c, --stdout       (ignored, output is always written to standard output)\n"
"  -q, --quiet        specify *twice* to suppress errors\n"
"  -Q, --no-warn      (ignored, the exit status 2 is never used)\n"
"  -h, --help         display this help and exit\n"
"  -V, --version      display the version number and exit\n"
"\n"
"With no FILE, or when FILE is -, read standard input.\n"
"\n"
"Report bugs to <" PACKAGE_BUGREPORT "> (in English or Finnish).\n"
PACKAGE_NAME " home page: <" PACKAGE_URL ">\n", progname);
 
    tuklib_exit(EXIT_SUCCESS, EXIT_FAILURE, display_errors);
}

References display_errors, PACKAGE_BUGREPORT, PACKAGE_NAME, PACKAGE_URL, printf(), progname, TOOL_FORMAT, and tuklib_exit.

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 274 of file xzdec.c.

{
    // Initialize progname which we will be used in error messages.
    tuklib_progname_init(argv);
 
    // Parse the command line options.
    parse_options(argc, argv);
 
    // The same lzma_stream is used for all files that we decode. This way
    // we don't need to reallocate memory for every file if they use same
    // compression settings.
    lzma_stream strm = LZMA_STREAM_INIT;
 
    // Some systems require setting stdin and stdout to binary mode.
#ifdef TUKLIB_DOSLIKE
    setmode(fileno(stdin), O_BINARY);
    setmode(fileno(stdout), O_BINARY);
#endif
 
    if (optind == argc) {
        // No filenames given, decode from stdin.
        uncompress(&strm, stdin, "(stdin)");
    } else {
        // Loop through the filenames given on the command line.
        do {
            // "-" indicates stdin.
            if (strcmp(argv[optind], "-") == 0) {
                uncompress(&strm, stdin, "(stdin)");
            } else {
                FILE *file = fopen(argv[optind], "rb");
                if (file == NULL) {
                    my_errorf("%s: %s", argv[optind],
                            strerror(errno));
                    exit(EXIT_FAILURE);
                }
 
                uncompress(&strm, file, argv[optind]);
                fclose(file);
            }
        } while (++optind < argc);
    }
 
#ifndef NDEBUG
    // Free the memory only when debugging. Freeing wastes some time,
    // but allows detecting possible memory leaks with Valgrind.
    lzma_end(&strm);
#endif
 
    tuklib_exit(EXIT_SUCCESS, EXIT_FAILURE, display_errors);
}

References argv, display_errors, test-lz4-list::exit, benchmark::FILE, LZMA_STREAM_INIT, NULL, O_BINARY, optind, parse_options(), strm, tuklib_exit, tuklib_progname_init, and uncompress().

parse_options()

static void parse_options ( int  argc, char **  argv  )

static

Parses command line options.

Definition at line 96 of file xzdec.c.

{
    static const char short_opts[] = "cdkM:hqQV";
    static const struct option long_opts[] = {
        { "stdout",       no_argument,         NULL, 'c' },
        { "to-stdout",    no_argument,         NULL, 'c' },
        { "decompress",   no_argument,         NULL, 'd' },
        { "uncompress",   no_argument,         NULL, 'd' },
        { "keep",         no_argument,         NULL, 'k' },
        { "quiet",        no_argument,         NULL, 'q' },
        { "no-warn",      no_argument,         NULL, 'Q' },
        { "help",         no_argument,         NULL, 'h' },
        { "version",      no_argument,         NULL, 'V' },
        { NULL,           0,                   NULL, 0   }
    };
 
    int c;
 
    while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL))
            != -1) {
        switch (c) {
        case 'c':
        case 'd':
        case 'k':
        case 'Q':
            break;
 
        case 'q':
            if (display_errors > 0)
                --display_errors;
 
            break;
 
        case 'h':
            help();
 
        case 'V':
            version();
 
        default:
            exit(EXIT_FAILURE);
        }
    }
 
    return;
}

References argv, c, display_errors, test-lz4-list::exit, getopt_long(), cmd_descs_generate::help, no_argument, NULL, and version.

Referenced by main().

uncompress()

static void uncompress ( lzma_stream *  strm, FILE *  file, const char *  filename  )

static

Definition at line 145 of file xzdec.c.

{
    lzma_ret ret;
 
    // Initialize the decoder
#ifdef LZMADEC
    ret = lzma_alone_decoder(strm, UINT64_MAX);
#else
    ret = lzma_stream_decoder(strm, UINT64_MAX, LZMA_CONCATENATED);
#endif
 
    // The only reasonable error here is LZMA_MEM_ERROR.
    if (ret != LZMA_OK) {
        my_errorf("%s", ret == LZMA_MEM_ERROR ? strerror(ENOMEM)
                : "Internal error (bug)");
        exit(EXIT_FAILURE);
    }
 
    // Input and output buffers
    uint8_t in_buf[BUFSIZ];
    uint8_t out_buf[BUFSIZ];
 
    strm->avail_in = 0;
    strm->next_out = out_buf;
    strm->avail_out = BUFSIZ;
 
    lzma_action action = LZMA_RUN;
 
    while (true) {
        if (strm->avail_in == 0) {
            strm->next_in = in_buf;
            strm->avail_in = fread(in_buf, 1, BUFSIZ, file);
 
            if (ferror(file)) {
                // POSIX says that fread() sets errno if
                // an error occurred. ferror() doesn't
                // touch errno.
                my_errorf("%s: Error reading input file: %s",
                        filename, strerror(errno));
                exit(EXIT_FAILURE);
            }
 
#ifndef LZMADEC
            // When using LZMA_CONCATENATED, we need to tell
            // liblzma when it has got all the input.
            if (feof(file))
                action = LZMA_FINISH;
#endif
        }
 
        ret = lzma_code(strm, action);
 
        // Write and check write error before checking decoder error.
        // This way as much data as possible gets written to output
        // even if decoder detected an error.
        if (strm->avail_out == 0 || ret != LZMA_OK) {
            const size_t write_size = BUFSIZ - strm->avail_out;
 
            if (fwrite(out_buf, 1, write_size, stdout)
                    != write_size) {
                // Wouldn't be a surprise if writing to stderr
                // would fail too but at least try to show an
                // error message.
                my_errorf("Cannot write to standard output: "
                        "%s", strerror(errno));
                exit(EXIT_FAILURE);
            }
 
            strm->next_out = out_buf;
            strm->avail_out = BUFSIZ;
        }
 
        if (ret != LZMA_OK) {
            if (ret == LZMA_STREAM_END) {
#ifdef LZMADEC
                // Check that there's no trailing garbage.
                if (strm->avail_in != 0
                        || fread(in_buf, 1, 1, file)
                            != 0
                        || !feof(file))
                    ret = LZMA_DATA_ERROR;
                else
                    return;
#else
                // lzma_stream_decoder() already guarantees
                // that there's no trailing garbage.
                assert(strm->avail_in == 0);
                assert(action == LZMA_FINISH);
                assert(feof(file));
                return;
#endif
            }
 
            const char *msg;
            switch (ret) {
            case LZMA_MEM_ERROR:
                msg = strerror(ENOMEM);
                break;
 
            case LZMA_FORMAT_ERROR:
                msg = "File format not recognized";
                break;
 
            case LZMA_OPTIONS_ERROR:
                // FIXME: Better message?
                msg = "Unsupported compression options";
                break;
 
            case LZMA_DATA_ERROR:
                msg = "File is corrupt";
                break;
 
            case LZMA_BUF_ERROR:
                msg = "Unexpected end of input";
                break;
 
            default:
                msg = "Internal error (bug)";
                break;
            }
 
            my_errorf("%s: %s", filename, msg);
            exit(EXIT_FAILURE);
        }
    }
}

References test-lz4-speed::action, assert(), lzma_stream::avail_in, lzma_stream::avail_out, ENOMEM, test-lz4-list::exit, in_buf, LZMA_BUF_ERROR, LZMA_CONCATENATED, LZMA_DATA_ERROR, LZMA_FINISH, LZMA_FORMAT_ERROR, LZMA_MEM_ERROR, LZMA_OK, LZMA_OPTIONS_ERROR, LZMA_RUN, LZMA_STREAM_END, msg, lzma_stream::next_in, lzma_stream::next_out, out_buf, strm, and UINT64_MAX.

Referenced by main().

Variable Documentation

display_errors

int display_errors = 2

static

Error messages are suppressed if this is zero, which is the case when –quiet has been given at least twice.

Definition at line 40 of file xzdec.c.

Referenced by lzma_attribute(), main(), and parse_options().