laag-xz 5.2.4.0

data/vendor/git.tukaani.org/xz/src/xz/options.h

@@ -0,0 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       options.h
+/// \brief      Parser for filter-specific options
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+/// \brief      Parser for Delta options
+///
+/// \return     Pointer to allocated options structure.
+///             Doesn't return on error.
+extern lzma_options_delta *options_delta(const char *str);
+
+
+/// \brief      Parser for BCJ options
+///
+/// \return     Pointer to allocated options structure.
+///             Doesn't return on error.
+extern lzma_options_bcj *options_bcj(const char *str);
+
+
+/// \brief      Parser for LZMA options
+///
+/// \return     Pointer to allocated options structure.
+///             Doesn't return on error.
+extern lzma_options_lzma *options_lzma(const char *str);

data/vendor/git.tukaani.org/xz/src/xz/private.h

@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       private.h
+/// \brief      Common includes, definions, and prototypes
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "sysdefs.h"
+#include "mythread.h"
+
+#include "lzma.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <signal.h>
+#include <locale.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "tuklib_gettext.h"
+#include "tuklib_progname.h"
+#include "tuklib_exit.h"
+#include "tuklib_mbstr.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#	define WIN32_LEAN_AND_MEAN
+#	include <windows.h>
+#endif
+
+#ifndef STDIN_FILENO
+#	define STDIN_FILENO (fileno(stdin))
+#endif
+
+#ifndef STDOUT_FILENO
+#	define STDOUT_FILENO (fileno(stdout))
+#endif
+
+#ifndef STDERR_FILENO
+#	define STDERR_FILENO (fileno(stderr))
+#endif
+
+#ifdef HAVE_CAPSICUM
+#	define ENABLE_SANDBOX 1
+#endif
+
+#include "main.h"
+#include "mytime.h"
+#include "coder.h"
+#include "message.h"
+#include "args.h"
+#include "hardware.h"
+#include "file_io.h"
+#include "options.h"
+#include "signals.h"
+#include "suffix.h"
+#include "util.h"
+
+#ifdef HAVE_DECODERS
+#	include "list.h"
+#endif

data/vendor/git.tukaani.org/xz/src/xz/signals.c

@@ -0,0 +1,209 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       signals.c
+/// \brief      Handling signals to abort operation
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "private.h"
+
+
+volatile sig_atomic_t user_abort = false;
+
+
+#if !(defined(_WIN32) && !defined(__CYGWIN__))
+
+/// If we were interrupted by a signal, we store the signal number so that
+/// we can raise that signal to kill the program when all cleanups have
+/// been done.
+static volatile sig_atomic_t exit_signal = 0;
+
+/// Mask of signals for which have have established a signal handler to set
+/// user_abort to true.
+static sigset_t hooked_signals;
+
+/// True once signals_init() has finished. This is used to skip blocking
+/// signals (with uninitialized hooked_signals) if signals_block() and
+/// signals_unblock() are called before signals_init() has been called.
+static bool signals_are_initialized = false;
+
+/// signals_block() and signals_unblock() can be called recursively.
+static size_t signals_block_count = 0;
+
+
+static void
+signal_handler(int sig)
+{
+	exit_signal = sig;
+	user_abort = true;
+
+#ifndef TUKLIB_DOSLIKE
+	io_write_to_user_abort_pipe();
+#endif
+
+	return;
+}
+
+
+extern void
+signals_init(void)
+{
+	// List of signals for which we establish the signal handler.
+	static const int sigs[] = {
+		SIGINT,
+		SIGTERM,
+#ifdef SIGHUP
+		SIGHUP,
+#endif
+#ifdef SIGPIPE
+		SIGPIPE,
+#endif
+#ifdef SIGXCPU
+		SIGXCPU,
+#endif
+#ifdef SIGXFSZ
+		SIGXFSZ,
+#endif
+	};
+
+	// Mask of the signals for which we have established a signal handler.
+	sigemptyset(&hooked_signals);
+	for (size_t i = 0; i < ARRAY_SIZE(sigs); ++i)
+		sigaddset(&hooked_signals, sigs[i]);
+
+#ifdef SIGALRM
+	// Add also the signals from message.c to hooked_signals.
+	for (size_t i = 0; message_progress_sigs[i] != 0; ++i)
+		sigaddset(&hooked_signals, message_progress_sigs[i]);
+#endif
+
+	// Using "my_sa" because "sa" may conflict with a sockaddr variable
+	// from system headers on Solaris.
+	struct sigaction my_sa;
+
+	// All the signals that we handle we also blocked while the signal
+	// handler runs.
+	my_sa.sa_mask = hooked_signals;
+
+	// Don't set SA_RESTART, because we want EINTR so that we can check
+	// for user_abort and cleanup before exiting. We block the signals
+	// for which we have established a handler when we don't want EINTR.
+	my_sa.sa_flags = 0;
+	my_sa.sa_handler = &signal_handler;
+
+	for (size_t i = 0; i < ARRAY_SIZE(sigs); ++i) {
+		// If the parent process has left some signals ignored,
+		// we don't unignore them.
+		struct sigaction old;
+		if (sigaction(sigs[i], NULL, &old) == 0
+				&& old.sa_handler == SIG_IGN)
+			continue;
+
+		// Establish the signal handler.
+		if (sigaction(sigs[i], &my_sa, NULL))
+			message_signal_handler();
+	}
+
+	signals_are_initialized = true;
+
+	return;
+}
+
+
+#ifndef __VMS
+extern void
+signals_block(void)
+{
+	if (signals_are_initialized) {
+		if (signals_block_count++ == 0) {
+			const int saved_errno = errno;
+			mythread_sigmask(SIG_BLOCK, &hooked_signals, NULL);
+			errno = saved_errno;
+		}
+	}
+
+	return;
+}
+
+
+extern void
+signals_unblock(void)
+{
+	if (signals_are_initialized) {
+		assert(signals_block_count > 0);
+
+		if (--signals_block_count == 0) {
+			const int saved_errno = errno;
+			mythread_sigmask(SIG_UNBLOCK, &hooked_signals, NULL);
+			errno = saved_errno;
+		}
+	}
+
+	return;
+}
+#endif
+
+
+extern void
+signals_exit(void)
+{
+	const int sig = exit_signal;
+
+	if (sig != 0) {
+#if defined(TUKLIB_DOSLIKE) || defined(__VMS)
+		// Don't raise(), set only exit status. This avoids
+		// printing unwanted message about SIGINT when the user
+		// presses C-c.
+		set_exit_status(E_ERROR);
+#else
+		struct sigaction sa;
+		sa.sa_handler = SIG_DFL;
+		sigfillset(&sa.sa_mask);
+		sa.sa_flags = 0;
+		sigaction(sig, &sa, NULL);
+		raise(exit_signal);
+#endif
+	}
+
+	return;
+}
+
+#else
+
+// While Windows has some very basic signal handling functions as required
+// by C89, they are not really used, and e.g. SIGINT doesn't work exactly
+// the way it does on POSIX (Windows creates a new thread for the signal
+// handler). Instead, we use SetConsoleCtrlHandler() to catch user
+// pressing C-c, because that seems to be the recommended way to do it.
+//
+// NOTE: This doesn't work under MSYS. Trying with SIGINT doesn't work
+// either even if it appeared to work at first. So test using Windows
+// console window.
+
+static BOOL WINAPI
+signal_handler(DWORD type lzma_attribute((__unused__)))
+{
+	// Since we don't get a signal number which we could raise() at
+	// signals_exit() like on POSIX, just set the exit status to
+	// indicate an error, so that we cannot return with zero exit status.
+	set_exit_status(E_ERROR);
+	user_abort = true;
+	return TRUE;
+}
+
+
+extern void
+signals_init(void)
+{
+	if (!SetConsoleCtrlHandler(&signal_handler, TRUE))
+		message_signal_handler();
+
+	return;
+}
+
+#endif

data/vendor/git.tukaani.org/xz/src/xz/signals.h

@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       signals.h
+/// \brief      Handling signals to abort operation
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+/// If this is true, we will clean up the possibly incomplete output file,
+/// return to main() as soon as practical. That is, the code needs to poll
+/// this variable in various places.
+extern volatile sig_atomic_t user_abort;
+
+
+/// Initialize the signal handler, which will set user_abort to true when
+/// user e.g. presses C-c.
+extern void signals_init(void);
+
+
+#if (defined(_WIN32) && !defined(__CYGWIN__)) || defined(__VMS)
+#	define signals_block() do { } while (0)
+#	define signals_unblock() do { } while (0)
+#else
+/// Block the signals which don't have SA_RESTART and which would just set
+/// user_abort to true. This is handy when we don't want to handle EINTR
+/// and don't want SA_RESTART either.
+extern void signals_block(void);
+
+/// Unblock the signals blocked by signals_block().
+extern void signals_unblock(void);
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#	define signals_exit() do { } while (0)
+#else
+/// If user has sent us a signal earlier to terminate the process,
+/// re-raise that signal to actually terminate the process.
+extern void signals_exit(void);
+#endif

data/vendor/git.tukaani.org/xz/src/xz/suffix.c

@@ -0,0 +1,399 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file       suffix.c
+/// \brief      Checks filename suffix and creates the destination filename
+//
+//  Author:     Lasse Collin
+//
+//  This file has been put into the public domain.
+//  You can do whatever you want with this file.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "private.h"
+
+#ifdef __DJGPP__
+#	include <fcntl.h>
+#endif
+
+// For case-insensitive filename suffix on case-insensitive systems
+#if defined(TUKLIB_DOSLIKE) || defined(__VMS)
+#	define strcmp strcasecmp
+#endif
+
+
+static char *custom_suffix = NULL;
+
+
+/// \brief      Test if the char is a directory separator
+static bool
+is_dir_sep(char c)
+{
+#ifdef TUKLIB_DOSLIKE
+	return c == '/' || c == '\\' || c == ':';
+#else
+	return c == '/';
+#endif
+}
+
+
+/// \brief      Test if the string contains a directory separator
+static bool
+has_dir_sep(const char *str)
+{
+#ifdef TUKLIB_DOSLIKE
+	return strpbrk(str, "/\\:") != NULL;
+#else
+	return strchr(str, '/') != NULL;
+#endif
+}
+
+
+#ifdef __DJGPP__
+/// \brief      Test for special suffix used for 8.3 short filenames (SFN)
+///
+/// \return     If str matches *.?- or *.??-, true is returned. Otherwise
+///             false is returned.
+static bool
+has_sfn_suffix(const char *str, size_t len)
+{
+	if (len >= 4 && str[len - 1] == '-' && str[len - 2] != '.'
+			&& !is_dir_sep(str[len - 2])) {
+		// *.?-
+		if (str[len - 3] == '.')
+			return !is_dir_sep(str[len - 4]);
+
+		// *.??-
+		if (len >= 5 && !is_dir_sep(str[len - 3])
+				&& str[len - 4] == '.')
+			return !is_dir_sep(str[len - 5]);
+	}
+
+	return false;
+}
+#endif
+
+
+/// \brief      Checks if src_name has given compressed_suffix
+///
+/// \param      suffix      Filename suffix to look for
+/// \param      src_name    Input filename
+/// \param      src_len     strlen(src_name)
+///
+/// \return     If src_name has the suffix, src_len - strlen(suffix) is
+///             returned. It's always a positive integer. Otherwise zero
+///             is returned.
+static size_t
+test_suffix(const char *suffix, const char *src_name, size_t src_len)
+{
+	const size_t suffix_len = strlen(suffix);
+
+	// The filename must have at least one character in addition to
+	// the suffix. src_name may contain path to the filename, so we
+	// need to check for directory separator too.
+	if (src_len <= suffix_len
+			|| is_dir_sep(src_name[src_len - suffix_len - 1]))
+		return 0;
+
+	if (strcmp(suffix, src_name + src_len - suffix_len) == 0)
+		return src_len - suffix_len;
+
+	return 0;
+}
+
+
+/// \brief      Removes the filename suffix of the compressed file
+///
+/// \return     Name of the uncompressed file, or NULL if file has unknown
+///             suffix.
+static char *
+uncompressed_name(const char *src_name, const size_t src_len)
+{
+	static const struct {
+		const char *compressed;
+		const char *uncompressed;
+	} suffixes[] = {
+		{ ".xz",    "" },
+		{ ".txz",   ".tar" }, // .txz abbreviation for .txt.gz is rare.
+		{ ".lzma",  "" },
+#ifdef __DJGPP__
+		{ ".lzm",   "" },
+#endif
+		{ ".tlz",   ".tar" },
+		// { ".gz",    "" },
+		// { ".tgz",   ".tar" },
+	};
+
+	const char *new_suffix = "";
+	size_t new_len = 0;
+
+	if (opt_format == FORMAT_RAW) {
+		// Don't check for known suffixes when --format=raw was used.
+		if (custom_suffix == NULL) {
+			message_error(_("%s: With --format=raw, "
+					"--suffix=.SUF is required unless "
+					"writing to stdout"), src_name);
+			return NULL;
+		}
+	} else {
+		for (size_t i = 0; i < ARRAY_SIZE(suffixes); ++i) {
+			new_len = test_suffix(suffixes[i].compressed,
+					src_name, src_len);
+			if (new_len != 0) {
+				new_suffix = suffixes[i].uncompressed;
+				break;
+			}
+		}
+
+#ifdef __DJGPP__
+		// Support also *.?- -> *.? and *.??- -> *.?? on DOS.
+		// This is done also when long filenames are available
+		// to keep it easy to decompress files created when
+		// long filename support wasn't available.
+		if (new_len == 0 && has_sfn_suffix(src_name, src_len)) {
+			new_suffix = "";
+			new_len = src_len - 1;
+		}
+#endif
+	}
+
+	if (new_len == 0 && custom_suffix != NULL)
+		new_len = test_suffix(custom_suffix, src_name, src_len);
+
+	if (new_len == 0) {
+		message_warning(_("%s: Filename has an unknown suffix, "
+				"skipping"), src_name);
+		return NULL;
+	}
+
+	const size_t new_suffix_len = strlen(new_suffix);
+	char *dest_name = xmalloc(new_len + new_suffix_len + 1);
+
+	memcpy(dest_name, src_name, new_len);
+	memcpy(dest_name + new_len, new_suffix, new_suffix_len);
+	dest_name[new_len + new_suffix_len] = '\0';
+
+	return dest_name;
+}
+
+
+/// This message is needed in multiple places in compressed_name(),
+/// so the message has been put into its own function.
+static void
+msg_suffix(const char *src_name, const char *suffix)
+{
+	message_warning(_("%s: File already has `%s' suffix, skipping"),
+			src_name, suffix);
+	return;
+}
+
+
+/// \brief      Appends suffix to src_name
+///
+/// In contrast to uncompressed_name(), we check only suffixes that are valid
+/// for the specified file format.
+static char *
+compressed_name(const char *src_name, size_t src_len)
+{
+	// The order of these must match the order in args.h.
+	static const char *const all_suffixes[][4] = {
+		{
+			".xz",
+			".txz",
+			NULL
+		}, {
+			".lzma",
+#ifdef __DJGPP__
+			".lzm",
+#endif
+			".tlz",
+			NULL
+/*
+		}, {
+			".gz",
+			".tgz",
+			NULL
+*/
+		}, {
+			// --format=raw requires specifying the suffix
+			// manually or using stdout.
+			NULL
+		}
+	};
+
+	// args.c ensures this.
+	assert(opt_format != FORMAT_AUTO);
+
+	const size_t format = opt_format - 1;
+	const char *const *suffixes = all_suffixes[format];
+
+	// Look for known filename suffixes and refuse to compress them.
+	for (size_t i = 0; suffixes[i] != NULL; ++i) {
+		if (test_suffix(suffixes[i], src_name, src_len) != 0) {
+			msg_suffix(src_name, suffixes[i]);
+			return NULL;
+		}
+	}
+
+#ifdef __DJGPP__
+	// Recognize also the special suffix that is used when long
+	// filename (LFN) support isn't available. This suffix is
+	// recognized on LFN systems too.
+	if (opt_format == FORMAT_XZ && has_sfn_suffix(src_name, src_len)) {
+		msg_suffix(src_name, "-");
+		return NULL;
+	}
+#endif
+
+	if (custom_suffix != NULL) {
+		if (test_suffix(custom_suffix, src_name, src_len) != 0) {
+			msg_suffix(src_name, custom_suffix);
+			return NULL;
+		}
+	}
+
+	// TODO: Hmm, maybe it would be better to validate this in args.c,
+	// since the suffix handling when decoding is weird now.
+	if (opt_format == FORMAT_RAW && custom_suffix == NULL) {
+		message_error(_("%s: With --format=raw, "
+				"--suffix=.SUF is required unless "
+				"writing to stdout"), src_name);
+		return NULL;
+	}
+
+	const char *suffix = custom_suffix != NULL
+			? custom_suffix : suffixes[0];
+	size_t suffix_len = strlen(suffix);
+
+#ifdef __DJGPP__
+	if (!_use_lfn(src_name)) {
+		// Long filename (LFN) support isn't available and we are
+		// limited to 8.3 short filenames (SFN).
+		//
+		// Look for suffix separator from the filename, and make sure
+		// that it is in the filename, not in a directory name.
+		const char *sufsep = strrchr(src_name, '.');
+		if (sufsep == NULL || sufsep[1] == '\0'
+				|| has_dir_sep(sufsep)) {
+			// src_name has no filename extension.
+			//
+			// Examples:
+			// xz foo         -> foo.xz
+			// xz -F lzma foo -> foo.lzm
+			// xz -S x foo    -> foox
+			// xz -S x foo.   -> foo.x
+			// xz -S x.y foo  -> foox.y
+			// xz -S .x foo   -> foo.x
+			// xz -S .x foo.  -> foo.x
+			//
+			// Avoid double dots:
+			if (sufsep != NULL && sufsep[1] == '\0'
+					&& suffix[0] == '.')
+				--src_len;
+
+		} else if (custom_suffix == NULL
+				&& strcasecmp(sufsep, ".tar") == 0) {
+			// ".tar" is handled specially.
+			//
+			// Examples:
+			// xz foo.tar          -> foo.txz
+			// xz -F lzma foo.tar  -> foo.tlz
+			static const char *const tar_suffixes[] = {
+				".txz",
+				".tlz",
+				// ".tgz",
+			};
+			suffix = tar_suffixes[format];
+			suffix_len = 4;
+			src_len -= 4;
+
+		} else {
+			if (custom_suffix == NULL && opt_format == FORMAT_XZ) {
+				// Instead of the .xz suffix, use a single
+				// character at the end of the filename
+				// extension. This is to minimize name
+				// conflicts when compressing multiple files
+				// with the same basename. E.g. foo.txt and
+				// foo.exe become foo.tx- and foo.ex-. Dash
+				// is rare as the last character of the
+				// filename extension, so it seems to be
+				// quite safe choice and it stands out better
+				// in directory listings than e.g. x. For
+				// comparison, gzip uses z.
+				suffix = "-";
+				suffix_len = 1;
+			}
+
+			if (suffix[0] == '.') {
+				// The first character of the suffix is a dot.
+				// Throw away the original filename extension
+				// and replace it with the new suffix.
+				//
+				// Examples:
+				// xz -F lzma foo.txt  -> foo.lzm
+				// xz -S .x  foo.txt   -> foo.x
+				src_len = sufsep - src_name;
+
+			} else {
+				// The first character of the suffix is not
+				// a dot. Preserve the first 0-2 characters
+				// of the original filename extension.
+				//
+				// Examples:
+				// xz foo.txt         -> foo.tx-
+				// xz -S x  foo.c     -> foo.cx
+				// xz -S ab foo.c     -> foo.cab
+				// xz -S ab foo.txt   -> foo.tab
+				// xz -S abc foo.txt  -> foo.abc
+				//
+				// Truncate the suffix to three chars:
+				if (suffix_len > 3)
+					suffix_len = 3;
+
+				// If needed, overwrite 1-3 characters.
+				if (strlen(sufsep) > 4 - suffix_len)
+					src_len = sufsep - src_name
+							+ 4 - suffix_len;
+			}
+		}
+	}
+#endif
+
+	char *dest_name = xmalloc(src_len + suffix_len + 1);
+
+	memcpy(dest_name, src_name, src_len);
+	memcpy(dest_name + src_len, suffix, suffix_len);
+	dest_name[src_len + suffix_len] = '\0';
+
+	return dest_name;
+}
+
+
+extern char *
+suffix_get_dest_name(const char *src_name)
+{
+	assert(src_name != NULL);
+
+	// Length of the name is needed in all cases to locate the end of
+	// the string to compare the suffix, so calculate the length here.
+	const size_t src_len = strlen(src_name);
+
+	return opt_mode == MODE_COMPRESS
+			? compressed_name(src_name, src_len)
+			: uncompressed_name(src_name, src_len);
+}
+
+
+extern void
+suffix_set(const char *suffix)
+{
+	// Empty suffix and suffixes having a directory separator are
+	// rejected. Such suffixes would break things later.
+	if (suffix[0] == '\0' || has_dir_sep(suffix))
+		message_fatal(_("%s: Invalid filename suffix"), suffix);
+
+	// Replace the old custom_suffix (if any) with the new suffix.
+	free(custom_suffix);
+	custom_suffix = xstrdup(suffix);
+	return;
+}