Argument parsing. More...

#include "private.h"
#include "getopt.h"
#include <ctype.h>

Functions
static void	parse_memlimit (const char name, const char name_percentage, char *str, bool set_compress, bool set_decompress)
	Parse and set the memory usage limit for compression and/or decompression. More...

static void	parse_block_list (char *str)

static void	parse_real (args_info args, int argc, char *argv)

static void	parse_environment (args_info args, char argv0, const char *varname)

void	args_parse (args_info args, int argc, char *argv)

void	args_free (void)

Variables
bool	opt_stdout = false

bool	opt_force = false

bool	opt_keep_original = false

bool	opt_robot = false

bool	opt_ignore_check = false

const char	stdin_filename [] = "(stdin)"

Detailed Description

Argument parsing.

Note: Filter-specific options parsing is in options.c.

Definition in file args.c.

Function Documentation

◆ args_free()

void args_free ( void )

Definition at line 695 of file args.c.

 {
     free(opt_block_list);
     return;
 }

References free(), and opt_block_list.

Referenced by main().

◆ args_parse()

void args_parse	(	args_info *	args,
		int	argc,
		char **	argv
	)

Definition at line 592 of file args.c.

 {
     // Initialize those parts of *args that we need later.
     args->files_name = NULL;
     args->files_file = NULL;
     args->files_delim = '\0';
  
     // Check how we were called.
     {
         // Remove the leading path name, if any.
         const char *name = strrchr(argv[0], '/');
         if (name == NULL)
             name = argv[0];
         else
             ++name;
  
         // NOTE: It's possible that name[0] is now '\0' if argv[0]
         // is weird, but it doesn't matter here.
  
         // Look for full command names instead of substrings like
         // "un", "cat", and "lz" to reduce possibility of false
         // positives when the programs have been renamed.
         if (strstr(name, "xzcat") != NULL) {
             opt_mode = MODE_DECOMPRESS;
             opt_stdout = true;
         } else if (strstr(name, "unxz") != NULL) {
             opt_mode = MODE_DECOMPRESS;
         } else if (strstr(name, "lzcat") != NULL) {
             opt_format = FORMAT_LZMA;
             opt_mode = MODE_DECOMPRESS;
             opt_stdout = true;
         } else if (strstr(name, "unlzma") != NULL) {
             opt_format = FORMAT_LZMA;
             opt_mode = MODE_DECOMPRESS;
         } else if (strstr(name, "lzma") != NULL) {
             opt_format = FORMAT_LZMA;
         }
     }
  
     // First the flags from the environment
     parse_environment(args, argv[0], "XZ_DEFAULTS");
     parse_environment(args, argv[0], "XZ_OPT");
  
     // Then from the command line
     parse_real(args, argc, argv);
  
     // If encoder or decoder support was omitted at build time,
     // show an error now so that the rest of the code can rely on
     // that whatever is in opt_mode is also supported.
 #ifndef HAVE_ENCODERS
     if (opt_mode == MODE_COMPRESS)
         message_fatal(_("Compression support was disabled "
                 "at build time"));
 #endif
 #ifndef HAVE_DECODERS
     // Even MODE_LIST cannot work without decoder support so MODE_COMPRESS
     // is the only valid choice.
     if (opt_mode != MODE_COMPRESS)
         message_fatal(_("Decompression support was disabled "
                 "at build time"));
 #endif
  
     // Never remove the source file when the destination is not on disk.
     // In test mode the data is written nowhere, but setting opt_stdout
     // will make the rest of the code behave well.
     if (opt_stdout || opt_mode == MODE_TEST) {
         opt_keep_original = true;
         opt_stdout = true;
     }
  
     // When compressing, if no --format flag was used, or it
     // was --format=auto, we compress to the .xz format.
     if (opt_mode == MODE_COMPRESS && opt_format == FORMAT_AUTO)
         opt_format = FORMAT_XZ;
  
     // Compression settings need to be validated (options themselves and
     // their memory usage) when compressing to any file format. It has to
     // be done also when uncompressing raw data, since for raw decoding
     // the options given on the command line are used to know what kind
     // of raw data we are supposed to decode.
     if (opt_mode == MODE_COMPRESS || opt_format == FORMAT_RAW)
         coder_set_compression_settings();
  
     // If no filenames are given, use stdin.
     if (argv[optind] == NULL && args->files_name == NULL) {
         // We don't modify or free() the "-" constant. The caller
         // modifies this so don't make the struct itself const.
         static char *names_stdin[2] = { (char *)"-", NULL };
         args->arg_names = names_stdin;
         args->arg_count = 1;
     } else {
         // We got at least one filename from the command line, or
         // --files or --files0 was specified.
         args->arg_names = argv + optind;
         args->arg_count = (unsigned int)(argc - optind);
     }
  
     return;
 }

References _, args, argv, coder_set_compression_settings(), FORMAT_AUTO, FORMAT_LZMA, FORMAT_RAW, FORMAT_XZ, int, message_fatal(), MODE_COMPRESS, MODE_DECOMPRESS, MODE_TEST, name, NULL, opt_format, opt_keep_original, opt_mode, opt_stdout, optind, parse_environment(), and parse_real().

Referenced by main().

◆ parse_block_list()

static void parse_block_list ( char * str )

static

Definition at line 59 of file args.c.

 {
     // It must be non-empty and not begin with a comma.
     if (str[0] == '\0' || str[0] == ',')
         message_fatal(_("%s: Invalid argument to --block-list"), str);
  
     // Count the number of comma-separated strings.
     size_t count = 1;
     for (size_t i = 0; str[i] != '\0'; ++i)
         if (str[i] == ',')
             ++count;
  
     // Prevent an unlikely integer overflow.
     if (count > SIZE_MAX / sizeof(uint64_t) - 1)
         message_fatal(_("%s: Too many arguments to --block-list"),
                 str);
  
     // Allocate memory to hold all the sizes specified.
     // If --block-list was specified already, its value is forgotten.
     free(opt_block_list);
     opt_block_list = xmalloc((count + 1) * sizeof(uint64_t));
  
     for (size_t i = 0; i < count; ++i) {
         // Locate the next comma and replace it with \0.
         char *p = strchr(str, ',');
         if (p != NULL)
             *p = '\0';
  
         if (str[0] == '\0') {
             // There is no string, that is, a comma follows
             // another comma. Use the previous value.
             //
             // NOTE: We checked earlier that the first char
             // of the whole list cannot be a comma.
             assert(i > 0);
             opt_block_list[i] = opt_block_list[i - 1];
         } else {
             opt_block_list[i] = str_to_uint64("block-list", str,
                     0, UINT64_MAX);
  
             // Zero indicates no more new Blocks.
             if (opt_block_list[i] == 0) {
                 if (i + 1 != count)
                     message_fatal(_("0 can only be used "
                             "as the last element "
                             "in --block-list"));
  
                 opt_block_list[i] = UINT64_MAX;
             }
         }
  
         str = p + 1;
     }
  
     // Terminate the array.
     opt_block_list[count] = 0;
     return;
 }

References _, assert(), count, free(), i, message_fatal(), NULL, opt_block_list, p, SIZE_MAX, cmd_descs_generate::str, str_to_uint64(), UINT64_MAX, and xmalloc.

Referenced by parse_real().

◆ parse_environment()

static void parse_environment	(	args_info *	args,
		char *	argv0,
		const char *	varname
	)

static

Definition at line 511 of file args.c.

 {
     char *env = getenv(varname);
     if (env == NULL)
         return;
  
     // We modify the string, so make a copy of it.
     env = xstrdup(env);
  
     // Calculate the number of arguments in env. argc stats at one
     // to include space for the program name.
     int argc = 1;
     bool prev_was_space = true;
     for (size_t i = 0; env[i] != '\0'; ++i) {
         // NOTE: Cast to unsigned char is needed so that correct
         // value gets passed to isspace(), which expects
         // unsigned char cast to int. Casting to int is done
         // automatically due to integer promotion, but we need to
         // force char to unsigned char manually. Otherwise 8-bit
         // characters would get promoted to wrong value if
         // char is signed.
         if (isspace((unsigned char)env[i])) {
             prev_was_space = true;
         } else if (prev_was_space) {
             prev_was_space = false;
  
             // Keep argc small enough to fit into a signed int
             // and to keep it usable for memory allocation.
             if (++argc == my_min(
                     INT_MAX, SIZE_MAX / sizeof(char *)))
                 message_fatal(_("The environment variable "
                         "%s contains too many "
                         "arguments"), varname);
         }
     }
  
     // Allocate memory to hold pointers to the arguments. Add one to get
     // space for the terminating NULL (if some systems happen to need it).
     char **argv = xmalloc(((size_t)(argc) + 1) * sizeof(char *));
     argv[0] = argv0;
     argv[argc] = NULL;
  
     // Go through the string again. Split the arguments using '\0'
     // characters and add pointers to the resulting strings to argv.
     argc = 1;
     prev_was_space = true;
     for (size_t i = 0; env[i] != '\0'; ++i) {
         if (isspace((unsigned char)env[i])) {
             prev_was_space = true;
             env[i] = '\0';
         } else if (prev_was_space) {
             prev_was_space = false;
             argv[argc++] = env + i;
         }
     }
  
     // Parse the argument list we got from the environment. All non-option
     // arguments i.e. filenames are ignored.
     parse_real(args, argc, argv);
  
     // Reset the state of the getopt_long() so that we can parse the
     // command line options too. There are two incompatible ways to
     // do it.
 #ifdef HAVE_OPTRESET
     // BSD
     optind = 1;
     optreset = 1;
 #else
     // GNU, Solaris
     optind = 0;
 #endif
  
     // We don't need the argument list from environment anymore.
     free(argv);
     free(env);
  
     return;
 }

References _, args, argv, env, free(), getenv(), i, INT_MAX, isspace, message_fatal(), my_min, NULL, optind, optreset, parse_real(), SIZE_MAX, xmalloc, and xstrdup().

Referenced by args_parse().

◆ parse_memlimit()

static void parse_memlimit	(	const char *	name,
		const char *	name_percentage,
		char *	str,
		bool	set_compress,
		bool	set_decompress
	)

static

Parse and set the memory usage limit for compression and/or decompression.

Definition at line 34 of file args.c.

 {
     bool is_percentage = false;
     uint64_t value;
  
     const size_t len = strlen(str);
     if (len > 0 && str[len - 1] == '%') {
         str[len - 1] = '\0';
         is_percentage = true;
         value = str_to_uint64(name_percentage, str, 1, 100);
     } else {
         // On 32-bit systems, SIZE_MAX would make more sense than
         // UINT64_MAX. But use UINT64_MAX still so that scripts
         // that assume > 4 GiB values don't break.
         value = str_to_uint64(name, str, 0, UINT64_MAX);
     }
  
     hardware_memlimit_set(
             value, set_compress, set_decompress, is_percentage);
     return;
 }

References hardware_memlimit_set(), len, cmd_descs_generate::str, str_to_uint64(), UINT64_MAX, and value.

Referenced by parse_real().

◆ parse_real()

static void parse_real	(	args_info *	args,
		int	argc,
		char **	argv
	)

static

Definition at line 120 of file args.c.

 {
     enum {
         OPT_X86 = INT_MIN,
         OPT_POWERPC,
         OPT_IA64,
         OPT_ARM,
         OPT_ARMTHUMB,
         OPT_SPARC,
         OPT_DELTA,
         OPT_LZMA1,
         OPT_LZMA2,
  
         OPT_SINGLE_STREAM,
         OPT_NO_SPARSE,
         OPT_FILES,
         OPT_FILES0,
         OPT_BLOCK_SIZE,
         OPT_BLOCK_LIST,
         OPT_MEM_COMPRESS,
         OPT_MEM_DECOMPRESS,
         OPT_NO_ADJUST,
         OPT_INFO_MEMORY,
         OPT_ROBOT,
         OPT_FLUSH_TIMEOUT,
         OPT_IGNORE_CHECK,
     };
  
     static const char short_opts[]
             = "cC:defF:hHlkM:qQrS:tT:vVz0123456789";
  
     static const struct option long_opts[] = {
         // Operation mode
         { "compress",     no_argument,       NULL,  'z' },
         { "decompress",   no_argument,       NULL,  'd' },
         { "uncompress",   no_argument,       NULL,  'd' },
         { "test",         no_argument,       NULL,  't' },
         { "list",         no_argument,       NULL,  'l' },
  
         // Operation modifiers
         { "keep",         no_argument,       NULL,  'k' },
         { "force",        no_argument,       NULL,  'f' },
         { "stdout",       no_argument,       NULL,  'c' },
         { "to-stdout",    no_argument,       NULL,  'c' },
         { "single-stream", no_argument,      NULL,  OPT_SINGLE_STREAM },
         { "no-sparse",    no_argument,       NULL,  OPT_NO_SPARSE },
         { "suffix",       required_argument, NULL,  'S' },
         // { "recursive",      no_argument,       NULL,  'r' }, // TODO
         { "files",        optional_argument, NULL,  OPT_FILES },
         { "files0",       optional_argument, NULL,  OPT_FILES0 },
  
         // Basic compression settings
         { "format",       required_argument, NULL,  'F' },
         { "check",        required_argument, NULL,  'C' },
         { "ignore-check", no_argument,       NULL,  OPT_IGNORE_CHECK },
         { "block-size",   required_argument, NULL,  OPT_BLOCK_SIZE },
         { "block-list",  required_argument, NULL,  OPT_BLOCK_LIST },
         { "memlimit-compress",   required_argument, NULL, OPT_MEM_COMPRESS },
         { "memlimit-decompress", required_argument, NULL, OPT_MEM_DECOMPRESS },
         { "memlimit",     required_argument, NULL,  'M' },
         { "memory",       required_argument, NULL,  'M' }, // Old alias
         { "no-adjust",    no_argument,       NULL,  OPT_NO_ADJUST },
         { "threads",      required_argument, NULL,  'T' },
         { "flush-timeout", required_argument, NULL, OPT_FLUSH_TIMEOUT },
  
         { "extreme",      no_argument,       NULL,  'e' },
         { "fast",         no_argument,       NULL,  '0' },
         { "best",         no_argument,       NULL,  '9' },
  
         // Filters
         { "lzma1",        optional_argument, NULL,  OPT_LZMA1 },
         { "lzma2",        optional_argument, NULL,  OPT_LZMA2 },
         { "x86",          optional_argument, NULL,  OPT_X86 },
         { "powerpc",      optional_argument, NULL,  OPT_POWERPC },
         { "ia64",         optional_argument, NULL,  OPT_IA64 },
         { "arm",          optional_argument, NULL,  OPT_ARM },
         { "armthumb",     optional_argument, NULL,  OPT_ARMTHUMB },
         { "sparc",        optional_argument, NULL,  OPT_SPARC },
         { "delta",        optional_argument, NULL,  OPT_DELTA },
  
         // Other options
         { "quiet",        no_argument,       NULL,  'q' },
         { "verbose",      no_argument,       NULL,  'v' },
         { "no-warn",      no_argument,       NULL,  'Q' },
         { "robot",        no_argument,       NULL,  OPT_ROBOT },
         { "info-memory",  no_argument,       NULL,  OPT_INFO_MEMORY },
         { "help",         no_argument,       NULL,  'h' },
         { "long-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) {
         // Compression preset (also for decompression if --format=raw)
         case '0': case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8': case '9':
             coder_set_preset((uint32_t)(c - '0'));
             break;
  
         // --memlimit-compress
         case OPT_MEM_COMPRESS:
             parse_memlimit("memlimit-compress",
                     "memlimit-compress%", optarg,
                     true, false);
             break;
  
         // --memlimit-decompress
         case OPT_MEM_DECOMPRESS:
             parse_memlimit("memlimit-decompress",
                     "memlimit-decompress%", optarg,
                     false, true);
             break;
  
         // --memlimit
         case 'M':
             parse_memlimit("memlimit", "memlimit%", optarg,
                     true, true);
             break;
  
         // --suffix
         case 'S':
             suffix_set(optarg);
             break;
  
         case 'T':
             // The max is from src/liblzma/common/common.h.
             hardware_threads_set(str_to_uint64("threads",
                     optarg, 0, 16384));
             break;
  
         // --version
         case 'V':
             // This doesn't return.
             message_version();
  
         // --stdout
         case 'c':
             opt_stdout = true;
             break;
  
         // --decompress
         case 'd':
             opt_mode = MODE_DECOMPRESS;
             break;
  
         // --extreme
         case 'e':
             coder_set_extreme();
             break;
  
         // --force
         case 'f':
             opt_force = true;
             break;
  
         // --info-memory
         case OPT_INFO_MEMORY:
             // This doesn't return.
             hardware_memlimit_show();
  
         // --help
         case 'h':
             // This doesn't return.
             message_help(false);
  
         // --long-help
         case 'H':
             // This doesn't return.
             message_help(true);
  
         // --list
         case 'l':
             opt_mode = MODE_LIST;
             break;
  
         // --keep
         case 'k':
             opt_keep_original = true;
             break;
  
         // --quiet
         case 'q':
             message_verbosity_decrease();
             break;
  
         case 'Q':
             set_exit_no_warn();
             break;
  
         case 't':
             opt_mode = MODE_TEST;
             break;
  
         // --verbose
         case 'v':
             message_verbosity_increase();
             break;
  
         // --robot
         case OPT_ROBOT:
             opt_robot = true;
  
             // This is to make sure that floating point numbers
             // always have a dot as decimal separator.
             setlocale(LC_NUMERIC, "C");
             break;
  
         case 'z':
             opt_mode = MODE_COMPRESS;
             break;
  
         // Filter setup
  
         case OPT_X86:
             coder_add_filter(LZMA_FILTER_X86,
                     options_bcj(optarg));
             break;
  
         case OPT_POWERPC:
             coder_add_filter(LZMA_FILTER_POWERPC,
                     options_bcj(optarg));
             break;
  
         case OPT_IA64:
             coder_add_filter(LZMA_FILTER_IA64,
                     options_bcj(optarg));
             break;
  
         case OPT_ARM:
             coder_add_filter(LZMA_FILTER_ARM,
                     options_bcj(optarg));
             break;
  
         case OPT_ARMTHUMB:
             coder_add_filter(LZMA_FILTER_ARMTHUMB,
                     options_bcj(optarg));
             break;
  
         case OPT_SPARC:
             coder_add_filter(LZMA_FILTER_SPARC,
                     options_bcj(optarg));
             break;
  
         case OPT_DELTA:
             coder_add_filter(LZMA_FILTER_DELTA,
                     options_delta(optarg));
             break;
  
         case OPT_LZMA1:
             coder_add_filter(LZMA_FILTER_LZMA1,
                     options_lzma(optarg));
             break;
  
         case OPT_LZMA2:
             coder_add_filter(LZMA_FILTER_LZMA2,
                     options_lzma(optarg));
             break;
  
         // Other
  
         // --format
         case 'F': {
             // Just in case, support both "lzma" and "alone" since
             // the latter was used for forward compatibility in
             // LZMA Utils 4.32.x.
             static const struct {
                 char str[8];
                 enum format_type format;
             } types[] = {
                 { "auto",   FORMAT_AUTO },
                 { "xz",     FORMAT_XZ },
                 { "lzma",   FORMAT_LZMA },
                 { "alone",  FORMAT_LZMA },
                 // { "gzip",   FORMAT_GZIP },
                 // { "gz",     FORMAT_GZIP },
                 { "raw",    FORMAT_RAW },
             };
  
             size_t i = 0;
             while (strcmp(types[i].str, optarg) != 0)
                 if (++i == ARRAY_SIZE(types))
                     message_fatal(_("%s: Unknown file "
                             "format type"),
                             optarg);
  
             opt_format = types[i].format;
             break;
         }
  
         // --check
         case 'C': {
             static const struct {
                 char str[8];
                 lzma_check check;
             } types[] = {
                 { "none",   LZMA_CHECK_NONE },
                 { "crc32",  LZMA_CHECK_CRC32 },
                 { "crc64",  LZMA_CHECK_CRC64 },
                 { "sha256", LZMA_CHECK_SHA256 },
             };
  
             size_t i = 0;
             while (strcmp(types[i].str, optarg) != 0) {
                 if (++i == ARRAY_SIZE(types))
                     message_fatal(_("%s: Unsupported "
                             "integrity "
                             "check type"), optarg);
             }
  
             // Use a separate check in case we are using different
             // liblzma than what was used to compile us.
             if (!lzma_check_is_supported(types[i].check))
                 message_fatal(_("%s: Unsupported integrity "
                         "check type"), optarg);
  
             coder_set_check(types[i].check);
             break;
         }
  
         case OPT_IGNORE_CHECK:
             opt_ignore_check = true;
             break;
  
         case OPT_BLOCK_SIZE:
             opt_block_size = str_to_uint64("block-size", optarg,
                     0, LZMA_VLI_MAX);
             break;
  
         case OPT_BLOCK_LIST: {
             parse_block_list(optarg);
             break;
         }
  
         case OPT_SINGLE_STREAM:
             opt_single_stream = true;
             break;
  
         case OPT_NO_SPARSE:
             io_no_sparse();
             break;
  
         case OPT_FILES:
             args->files_delim = '\n';
  
         // Fall through
  
         case OPT_FILES0:
             if (args->files_name != NULL)
                 message_fatal(_("Only one file can be "
                         "specified with `--files' "
                         "or `--files0'."));
  
             if (optarg == NULL) {
                 args->files_name = (char *)stdin_filename;
                 args->files_file = stdin;
             } else {
                 args->files_name = optarg;
                 args->files_file = fopen(optarg,
                         c == OPT_FILES ? "r" : "rb");
                 if (args->files_file == NULL)
                     message_fatal("%s: %s", optarg,
                             strerror(errno));
             }
  
             break;
  
         case OPT_NO_ADJUST:
             opt_auto_adjust = false;
             break;
  
         case OPT_FLUSH_TIMEOUT:
             opt_flush_timeout = str_to_uint64("flush-timeout",
                     optarg, 0, UINT64_MAX);
             break;
  
         default:
             message_try_help();
             tuklib_exit(E_ERROR, E_ERROR, false);
         }
     }
  
     return;
 }