node-liblzma 1.0.4 → 1.1.4

package/deps/xz/src/xz/private.h

@@ -1,59 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \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
-
-#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"
-#include "list.h"

package/deps/xz/src/xz/signals.c

@@ -1,209 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \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

package/deps/xz/src/xz/signals.h

@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \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

package/deps/xz/src/xz/suffix.c

@@ -1,399 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \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;
-}