/branches/gl-inet/tools/lzma/patches/002-lzmp.patch |
@@ -0,0 +1,1059 @@ |
Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzmp.cpp |
=================================================================== |
--- /dev/null 1970-01-01 00:00:00.000000000 +0000 |
+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzmp.cpp 2009-06-01 22:01:10.000000000 +0200 |
@@ -0,0 +1,895 @@ |
+/* |
+ * LZMA command line tool similar to gzip to encode and decode LZMA files. |
+ * |
+ * Copyright (C) 2005 Ville Koskinen |
+ * |
+ * This program is free software; you can redistribute it and/or |
+ * modify it under the terms of the GNU General Public License |
+ * as published by the Free Software Foundation; either version 2 |
+ * of the License, or (at your option) any later version. |
+ * |
+ * This program is distributed in the hope that it will be useful, |
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of |
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
+ * GNU General Public License for more details. |
+ * |
+ * You should have received a copy of the GNU General Public License |
+ * along with this program; if not, write to the Free Software |
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, |
+ * USA. |
+ */ |
+ |
+#include "../../../Common/MyInitGuid.h" |
+ |
+#include <iostream> |
+using std::cout; |
+using std::cerr; |
+using std::endl; |
+ |
+#include <cstdio> |
+#include <cstdlib> |
+#include <cstring> |
+ |
+#include <string> |
+using std::string; |
+#include <vector> |
+using std::vector; |
+typedef vector<string> stringVector; |
+ |
+#include <unistd.h> |
+#include <getopt.h> |
+#include <signal.h> |
+ |
+#include <sys/types.h> |
+#include <sys/stat.h> |
+#include <utime.h> |
+#include <sys/time.h> // futimes() |
+ |
+// For Solaris |
+#ifndef HAVE_FUTIMES |
+//#define futimes(fd, tv) futimesat(fd, NULL, tv) |
+#endif |
+ |
+#if defined(_WIN32) || defined(OS2) || defined(MSDOS) |
+#include <fcntl.h> |
+#include <io.h> |
+#define MY_SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY) |
+#else |
+#define MY_SET_BINARY_MODE(file) |
+#endif |
+ |
+#include "../../../7zip/Common/FileStreams.h" |
+ |
+#include "../../../Common/Types.h" |
+ |
+#include "../../../7zip/Compress/LzmaDecoder.h" |
+#include "../../../7zip/Compress/LzmaEncoder.h" |
+ |
+#include "Exception.h" |
+ |
+#include "lzma_version.h" |
+ |
+namespace lzma { |
+ |
+const char *PROGRAM_VERSION = PACKAGE_VERSION; |
+const char *PROGRAM_COPYRIGHT = "Copyright (C) 2006 Ville Koskinen"; |
+ |
+/* LZMA_Alone switches: |
+ -a{N}: set compression mode - [0, 2], default: 2 (max) |
+ -d{N}: set dictionary - [0,28], default: 23 (8MB) |
+ -fb{N}: set number of fast bytes - [5, 255], default: 128 |
+ -lc{N}: set number of literal context bits - [0, 8], default: 3 |
+ -lp{N}: set number of literal pos bits - [0, 4], default: 0 |
+ -pb{N}: set number of pos bits - [0, 4], default: 2 |
+ -mf{MF_ID}: set Match Finder: [bt2, bt3, bt4, bt4b, pat2r, pat2, |
+ pat2h, pat3h, pat4h, hc3, hc4], default: bt4 |
+*/ |
+ |
+struct lzma_option { |
+ short compression_mode; // -a |
+ short dictionary; // -d |
+ short fast_bytes; // -fb |
+ wchar_t *match_finder; // -mf |
+ short literal_context_bits; // -lc |
+ short literal_pos_bits; // -lp |
+ short pos_bits; // -pb |
+}; |
+ |
+/* The following is a mapping from gzip/bzip2 style -1 .. -9 compression modes |
+ * to the corresponding LZMA compression modes. Thanks, Larhzu, for coining |
+ * these. */ |
+const lzma_option option_mapping[] = { |
+ { 0, 0, 0, NULL, 0, 0, 0}, // -0 (needed for indexing) |
+ { 0, 16, 64, L"hc4", 3, 0, 2}, // -1 |
+ { 0, 20, 64, L"hc4", 3, 0, 2}, // -2 |
+ { 1, 19, 64, L"bt4", 3, 0, 2}, // -3 |
+ { 2, 20, 64, L"bt4", 3, 0, 2}, // -4 |
+ { 2, 21, 128, L"bt4", 3, 0, 2}, // -5 |
+ { 2, 22, 128, L"bt4", 3, 0, 2}, // -6 |
+ { 2, 23, 128, L"bt4", 3, 0, 2}, // -7 |
+ { 2, 24, 255, L"bt4", 3, 0, 2}, // -8 |
+ { 2, 25, 255, L"bt4", 3, 0, 2}, // -9 |
+}; |
+ |
+struct extension_pair { |
+ char *from; |
+ char *to; |
+}; |
+ |
+const extension_pair known_extensions[] = { |
+ { ".lzma", "" }, |
+ { ".tlz", ".tar" }, |
+ { NULL, NULL } |
+}; |
+ |
+/* Sorry, I just happen to like enumerations. */ |
+enum PROGRAM_MODE { |
+ PM_COMPRESS = 0, |
+ PM_DECOMPRESS, |
+ PM_TEST, |
+ PM_HELP, |
+ PM_LICENSE, |
+ PM_VERSION |
+}; |
+ |
+enum { |
+ STATUS_OK = 0, |
+ STATUS_ERROR = 1, |
+ STATUS_WARNING = 2 |
+}; |
+ |
+/* getopt options. */ |
+/* struct option { name, has_arg, flag, val } */ |
+const struct option long_options[] = { |
+ { "stdout", 0, 0, 'c' }, |
+ { "decompress", 0, 0, 'd' }, |
+ { "compress", 0, 0, 'z' }, |
+ { "keep", 0, 0, 'k' }, |
+ { "force", 0, 0, 'f' }, |
+ { "test", 0, 0, 't' }, |
+ { "suffix", 1, 0, 'S' }, |
+ { "quiet", 0, 0, 'q' }, |
+ { "verbose", 0, 0, 'v' }, |
+ { "help", 0, 0, 'h' }, |
+ { "license", 0, 0, 'L' }, |
+ { "version", 0, 0, 'V' }, |
+ { "fast", 0, 0, '1' }, |
+ { "best", 0, 0, '9' }, |
+ { 0, 0, 0, 0 } |
+}; |
+ |
+/* getopt option string (for the above options). */ |
+const char option_string[] = "cdzkftS:qvhLV123456789A:D:F:"; |
+ |
+/* Defaults. */ |
+PROGRAM_MODE program_mode = PM_COMPRESS; |
+int verbosity = 0; |
+bool stdinput = false; |
+bool stdoutput = false; |
+bool keep = false; |
+bool force = false; |
+int compression_mode = 7; |
+//char *suffix = strdup(".lzma"); |
+char *suffix = strdup(known_extensions[0].from); |
+lzma_option advanced_options = { -1, -1, -1, NULL, -1, -1, -1 }; |
+ |
+void print_help(const char *const argv0) |
+{ |
+ // Help goes to stdout while other messages go to stderr. |
+ cout << "\nlzma " << PROGRAM_VERSION |
+ << " " << PROGRAM_COPYRIGHT << "\n" |
+ "Based on LZMA SDK " << LZMA_SDK_VERSION_STRING << " " |
+ << LZMA_SDK_COPYRIGHT_STRING |
+ << "\n\nUsage: " << argv0 |
+ << " [flags and input files in any order]\n" |
+" -c --stdout output to standard output\n" |
+" -d --decompress force decompression\n" |
+" -z --compress force compression\n" |
+" -k --keep keep (don't delete) input files\n" |
+" -f --force force overwrite of output file and compress links\n" |
+" -t --test test compressed file integrity\n" |
+" -S .suf --suffix .suf use suffix .suf on compressed files\n" |
+" -q --quiet suppress error messages\n" |
+" -v --verbose be verbose\n" |
+" -h --help print this message\n" |
+" -L --license display the license information\n" |
+" -V --version display version numbers of LZMA SDK and lzma\n" |
+" -1 .. -2 fast compression\n" |
+" -3 .. -9 good to excellent compression. -7 is the default.\n" |
+" --fast alias for -1\n" |
+" --best alias for -9 (usually *not* what you want)\n\n" |
+" Memory usage depends a lot on the chosen compression mode -1 .. -9.\n" |
+" See the man page lzma(1) for details.\n\n"; |
+} |
+ |
+void print_license(void) |
+{ |
+ cout << "\n LZMA command line tool " << PROGRAM_VERSION << " - " |
+ << PROGRAM_COPYRIGHT |
+ << "\n LZMA SDK " << LZMA_SDK_VERSION_STRING << " - " |
+ << LZMA_SDK_COPYRIGHT_STRING |
+ << "\n This program is a part of the LZMA utils package.\n" |
+ " http://tukaani.org/lzma/\n\n" |
+" This program is free software; you can redistribute it and/or\n" |
+" modify it under the terms of the GNU General Public License\n" |
+" as published by the Free Software Foundation; either version 2\n" |
+" of the License, or (at your option) any later version.\n" |
+"\n" |
+" This program is distributed in the hope that it will be useful,\n" |
+" but WITHOUT ANY WARRANTY; without even the implied warranty of\n" |
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" |
+" GNU General Public License for more details.\n" |
+"\n"; |
+} |
+ |
+void print_version(void) |
+{ |
+ cout << "LZMA command line tool " << PROGRAM_VERSION << "\n" |
+ << "LZMA SDK " << LZMA_SDK_VERSION_STRING << "\n"; |
+} |
+ |
+short str2int (const char *str, const int &min, const int &max) |
+{ |
+ int value = -1; |
+ char *endptr = NULL; |
+ if (str == NULL || str[0] == '\0') |
+ throw ArgumentException("Invalid integer option"); |
+ value = strtol (str, &endptr, 10); |
+ if (*endptr != '\0' || value < min || value > max) |
+ throw ArgumentException("Invalid integer option"); |
+ return value; |
+} |
+ |
+void parse_options(int argc, char **argv, stringVector &filenames) |
+{ |
+ /* Snatched from getopt(3). */ |
+ int c; |
+ |
+ /* Check how we were called */ |
+ { |
+ char *p = strrchr (argv[0], '/'); // Remove path prefix, if any |
+ if (p++ == NULL) |
+ p = argv[0]; |
+ if (strstr (p, "un") != NULL) { |
+ program_mode = PM_DECOMPRESS; |
+ } else if (strstr (p, "cat") != NULL) { |
+ program_mode = PM_DECOMPRESS; |
+ stdoutput = true; |
+ } |
+ } |
+ |
+ while (-1 != (c = getopt_long(argc, argv, option_string, |
+ long_options, NULL))) { |
+ switch (c) { |
+ // stdout |
+ case 'c': |
+ stdoutput = true; |
+ break; |
+ |
+ // decompress |
+ case 'd': |
+ program_mode = PM_DECOMPRESS; |
+ break; |
+ |
+ // compress |
+ case 'z': |
+ program_mode = PM_COMPRESS; |
+ break; |
+ |
+ // keep |
+ case 'k': |
+ keep = true; |
+ break; |
+ |
+ // force |
+ case 'f': |
+ force = true; |
+ break; |
+ |
+ // test |
+ case 't': |
+ program_mode = PM_TEST; |
+ break; |
+ |
+ // suffix |
+ case 'S': |
+ if (optarg) { |
+ free(suffix); |
+ suffix = strdup(optarg); |
+ } |
+ break; |
+ |
+ // quiet |
+ case 'q': |
+ verbosity = 0; |
+ break; |
+ |
+ // verbose |
+ case 'v': |
+ verbosity++; |
+ break; |
+ |
+ // help |
+ case 'h': |
+ program_mode = PM_HELP; |
+ break; |
+ |
+ // license |
+ case 'L': |
+ program_mode = PM_LICENSE; |
+ break; |
+ |
+ // version |
+ case 'V': |
+ program_mode = PM_VERSION; |
+ break; |
+ |
+ case '1': case '2': case '3': case '4': case '5': |
+ case '6': case '7': case '8': case '9': |
+ compression_mode = c - '0'; |
+ break; |
+ |
+ // Advanced options // |
+ // Compression mode |
+ case 'A': |
+ advanced_options.compression_mode = |
+ str2int (optarg, 0, 2); |
+ break; |
+ |
+ // Dictionary size |
+ case 'D': |
+ advanced_options.dictionary = |
+ str2int (optarg, 0, 28); |
+ break; |
+ |
+ // Fast bytes |
+ case 'F': |
+ advanced_options.fast_bytes = |
+ str2int (optarg, 0, 273); |
+ break; |
+ |
+ default: |
+ throw ArgumentException(""); |
+ break; |
+ } // switch(c) |
+ } // while(1) |
+ |
+ for (int i = optind; i < argc; i++) { |
+ if (strcmp("-", argv[i]) == 0) |
+ continue; |
+ filenames.push_back(argv[i]); |
+ } |
+} // parse_options |
+ |
+void set_encoder_properties(NCompress::NLzma::CEncoder *encoder, |
+ lzma_option &opt) |
+{ |
+ /* Almost verbatim from LzmaAlone.cpp. */ |
+ PROPID propIDs[] = |
+ { |
+ NCoderPropID::kDictionarySize, |
+ NCoderPropID::kPosStateBits, |
+ NCoderPropID::kLitContextBits, |
+ NCoderPropID::kLitPosBits, |
+ NCoderPropID::kAlgorithm, |
+ NCoderPropID::kNumFastBytes, |
+ NCoderPropID::kMatchFinder, |
+ NCoderPropID::kEndMarker |
+ }; |
+ const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]); |
+#define VALUE(x) (advanced_options.x >= 0 ? advanced_options.x : opt.x) |
+ PROPVARIANT properties[kNumProps]; |
+ for (int p = 0; p < 6; p++) |
+ properties[p].vt = VT_UI4; |
+ properties[0].ulVal = UInt32(1 << VALUE (dictionary)); |
+ properties[1].ulVal = UInt32(VALUE (pos_bits)); |
+ properties[2].ulVal = UInt32(VALUE (literal_context_bits)); |
+ properties[3].ulVal = UInt32(VALUE (literal_pos_bits)); |
+ properties[4].ulVal = UInt32(VALUE (compression_mode)); |
+ properties[5].ulVal = UInt32(VALUE (fast_bytes)); |
+#undef VALUE |
+ |
+ properties[6].vt = VT_BSTR; |
+ properties[6].bstrVal = (BSTR)opt.match_finder; |
+ |
+ properties[7].vt = VT_BOOL; |
+ properties[7].boolVal = stdinput ? VARIANT_TRUE : VARIANT_FALSE; |
+ |
+ if (encoder->SetCoderProperties(propIDs, properties, kNumProps) != S_OK) |
+ throw Exception("SetCoderProperties() error"); |
+} |
+ |
+void encode(NCompress::NLzma::CEncoder *encoderSpec, |
+ CMyComPtr<ISequentialInStream> inStream, |
+ CMyComPtr<ISequentialOutStream> outStream, |
+ lzma_option encoder_options, |
+ UInt64 fileSize) |
+{ |
+ set_encoder_properties(encoderSpec, encoder_options); |
+ |
+ encoderSpec->WriteCoderProperties(outStream); |
+ |
+ for (int i = 0; i < 8; i++) |
+ { |
+ Byte b = Byte(fileSize >> (8 * i)); |
+ if (outStream->Write(&b, sizeof(b), 0) != S_OK) |
+ throw Exception("Write error while encoding"); |
+ } |
+ |
+ HRESULT result = encoderSpec->Code(inStream, outStream, 0, 0, 0); |
+ |
+ if (result == E_OUTOFMEMORY) |
+ throw Exception("Cannot allocate memory"); |
+ else if (result != S_OK) { |
+ char buffer[33]; |
+ snprintf(buffer, 33, "%d", (unsigned int)result); |
+ throw Exception(string("Encoder error: ") + buffer); |
+ } |
+} |
+ |
+void decode(NCompress::NLzma::CDecoder *decoderSpec, |
+ CMyComPtr<ISequentialInStream> inStream, |
+ CMyComPtr<ISequentialOutStream> outStream) |
+{ |
+ const UInt32 kPropertiesSize = 5; |
+ Byte properties[kPropertiesSize]; |
+ UInt32 processedSize; |
+ UInt64 fileSize = 0; |
+ |
+ if (inStream->Read(properties, kPropertiesSize, &processedSize) != S_OK) |
+ throw Exception("Read error"); |
+ if (processedSize != kPropertiesSize) |
+ throw Exception("Read error"); |
+ if (decoderSpec->SetDecoderProperties2(properties, kPropertiesSize) != S_OK) |
+ throw Exception("SetDecoderProperties() error"); |
+ |
+ for (int i = 0; i < 8; i++) |
+ { |
+ Byte b; |
+ |
+ if (inStream->Read(&b, sizeof(b), &processedSize) != S_OK) |
+ throw Exception("Read error"); |
+ if (processedSize != 1) |
+ throw Exception("Read error"); |
+ |
+ fileSize |= ((UInt64)b) << (8 * i); |
+ } |
+ |
+ if (decoderSpec->Code(inStream, outStream, 0, &fileSize, 0) != S_OK) |
+ throw Exception("Decoder error"); |
+} |
+ |
+int open_instream(const string infile, |
+ CMyComPtr<ISequentialInStream> &inStream, |
+ UInt64 &fileSize) |
+{ |
+ CInFileStream *inStreamSpec = new CInFileStream; |
+ inStream = inStreamSpec; |
+ if (!inStreamSpec->Open(infile.c_str())) |
+ throw Exception("Cannot open input file " + infile); |
+ |
+ inStreamSpec->File.GetLength(fileSize); |
+ |
+ return inStreamSpec->File.GetHandle(); |
+} |
+ |
+int open_outstream(const string outfile, |
+ CMyComPtr<ISequentialOutStream> &outStream) |
+{ |
+ COutFileStream *outStreamSpec = new COutFileStream; |
+ outStream = outStreamSpec; |
+ |
+ bool open_by_force = (program_mode == PM_TEST) | force; |
+ |
+ if (!outStreamSpec->Create(outfile.c_str(), open_by_force)) |
+ throw Exception("Cannot open output file " + outfile); |
+ |
+ return outStreamSpec->File.GetHandle(); |
+} |
+ |
+double get_ratio(int inhandle, int outhandle) |
+{ |
+ struct stat in_stats, out_stats; |
+ fstat(inhandle, &in_stats); |
+ fstat(outhandle, &out_stats); |
+ |
+ return (double)out_stats.st_size / (double)in_stats.st_size; |
+} |
+ |
+mode_t get_file_mode(string filename) |
+{ |
+ struct stat in_stat; |
+ lstat(filename.c_str(), &in_stat); |
+ |
+ return in_stat.st_mode; |
+} |
+ |
+bool string_ends_with(string str, string ending) |
+{ |
+ return equal(ending.rbegin(), ending.rend(), str.rbegin()); |
+} |
+ |
+bool extension_is_known(string filename) |
+{ |
+ bool known_format = false; |
+ extension_pair extension; int i = 1; |
+ |
+ extension = known_extensions[0]; |
+ while (extension.from != NULL) { |
+ if (string_ends_with(filename, extension.from)) { |
+ known_format = true; |
+ break; |
+ } |
+ extension = known_extensions[i]; |
+ i++; |
+ } |
+ |
+ if (!known_format) { |
+ if (!string_ends_with(filename, suffix)) { |
+ return false; |
+ } |
+ } |
+ |
+ return true; |
+} |
+ |
+string replace_extension(string filename) |
+{ |
+ int suffix_starts_at = filename.length() - strlen (suffix); |
+ string from_suffix = filename.substr(suffix_starts_at, strlen (suffix)); |
+ string ret = filename.substr(0, suffix_starts_at); |
+ extension_pair extension; int i = 1; |
+ |
+ bool found_replacement = false; |
+ extension = known_extensions[0]; |
+ while (extension.from != NULL) { |
+ if (from_suffix.compare(extension.from) == 0) { |
+ ret += extension.to; |
+ found_replacement = true; |
+ break; |
+ } |
+ |
+ extension = known_extensions[i]; |
+ i++; |
+ } |
+ |
+ return ret; |
+} |
+ |
+string pretty_print_status(string filename, string output_filename, |
+ string ratio) |
+{ |
+ string ret = ""; |
+ |
+ ret += filename; |
+ ret += ":\t "; |
+ |
+ if (program_mode == PM_TEST) { |
+ ret += "decoded succesfully"; |
+ |
+ return ret; |
+ } |
+ |
+ if (!stdinput && !stdoutput) { |
+ ret += ratio; |
+ ret += " -- "; |
+ } |
+ |
+ if (program_mode == PM_COMPRESS) { |
+ if (keep) { |
+ ret += "encoded succesfully"; |
+ |
+ return ret; |
+ } |
+ |
+ ret += "replaced with "; |
+ ret += output_filename; |
+ |
+ return ret; |
+ } |
+ |
+ if (program_mode == PM_DECOMPRESS) { |
+ if (keep) { |
+ ret += "decoded succesfully"; |
+ |
+ return ret; |
+ } |
+ |
+ ret += "replaced with "; |
+ ret += output_filename; |
+ |
+ return ret; |
+ } |
+ |
+ return ret; |
+} |
+ |
+static string archive_name; // I know, it is crude, but I haven't found any other |
+ // way then making a global variable to transfer filename to handler |
+ |
+void signal_handler (int signum) |
+{ |
+ unlink (archive_name.c_str()); // deleting |
+ signal (signum, SIG_DFL); // we return the default function to used signal |
+ kill (getpid(), signum); // and then send this signal to the process again |
+} |
+ |
+} // namespace lzma |
+ |
+ |
+int main(int argc, char **argv) |
+{ |
+ using namespace lzma; |
+ using std::cerr; |
+ |
+ stringVector filenames; |
+ |
+ signal (SIGTERM,signal_handler); |
+ signal (SIGHUP,signal_handler); |
+ signal (SIGINT,signal_handler); |
+ |
+ try { |
+ parse_options(argc, argv, filenames); |
+ } |
+ catch (...) { |
+ return STATUS_ERROR; |
+ } |
+ |
+ if (program_mode == PM_HELP) { |
+ print_help(argv[0]); |
+ return STATUS_OK; |
+ } |
+ else if (program_mode == PM_LICENSE) { |
+ print_license(); |
+ return STATUS_OK; |
+ } |
+ else if (program_mode == PM_VERSION) { |
+ print_version(); |
+ return STATUS_OK; |
+ } |
+ |
+ if (filenames.empty()) { |
+ stdinput = true; |
+ stdoutput = true; |
+ |
+ /* FIXME: get rid of this */ |
+ filenames.push_back("-"); |
+ } |
+ |
+ /* Protection: always create new files with 0600 in order to prevent |
+ * outsiders from reading incomplete data. */ |
+ umask(0077); |
+ |
+ bool warning = false; |
+ |
+ for (int i = 0; i < filenames.size(); i++) { |
+ CMyComPtr<ISequentialInStream> inStream; |
+ CMyComPtr<ISequentialOutStream> outStream; |
+ UInt64 fileSize = 0; |
+ int inhandle = 0, outhandle = 0; |
+ string output_filename; |
+ |
+ if (stdinput) { |
+ inStream = new CStdInFileStream; |
+ MY_SET_BINARY_MODE(stdin); |
+ fileSize = (UInt64)(Int64)-1; |
+ |
+ inhandle = STDIN_FILENO; |
+ |
+ outStream = new CStdOutFileStream; |
+ MY_SET_BINARY_MODE(stdout); |
+ |
+ outhandle = STDOUT_FILENO; |
+ } |
+ else { |
+ mode_t infile_mode = get_file_mode(filenames[i]); |
+ if (!S_ISREG(infile_mode)) { |
+ if (S_ISDIR(infile_mode)) { |
+ warning = true; |
+ cerr << argv[0] << ": " << filenames[i] << ": " |
+ << "cowardly refusing to work on directory" |
+ << endl; |
+ |
+ continue; |
+ } |
+ else if (S_ISLNK(infile_mode)) { |
+ if (!stdoutput && !force) { |
+ warning = true; |
+ |
+ cerr << argv[0] << ": " << filenames[i] << ": " |
+ << "cowardly refusing to work on symbolic link " |
+ << "(use --force to force encoding or decoding)" |
+ << endl; |
+ |
+ continue; |
+ } |
+ } |
+ else { |
+ warning = true; |
+ |
+ cerr << argv[0] << ": " << filenames[i] << ": " |
+ << "doesn't exist or is not a regular file" |
+ << endl; |
+ |
+ continue; |
+ } |
+ } |
+ |
+ // Test if the file already ends with *suffix. |
+ if (program_mode == PM_COMPRESS && !force |
+ && string_ends_with(filenames[i], |
+ suffix)) { |
+ warning = true; |
+ |
+ cerr << filenames[i] << " already has " |
+ << suffix << " suffix -- unchanged\n"; |
+ |
+ continue; |
+ } |
+ |
+ // Test if the file extension is known. |
+ if (program_mode == PM_DECOMPRESS |
+ && !extension_is_known(filenames[i])) { |
+ warning = true; |
+ |
+ cerr << filenames[i] << ": " |
+ << " unknown suffix -- unchanged" |
+ << endl; |
+ |
+ continue; |
+ } |
+ |
+ try { |
+ inhandle = open_instream(filenames[i], inStream, fileSize); |
+ } |
+ catch (Exception e) { |
+ cerr << argv[0] << ": " << e.what() << endl; |
+ return STATUS_ERROR; |
+ } |
+ |
+ if (stdoutput) { |
+ outStream = new CStdOutFileStream; |
+ MY_SET_BINARY_MODE(stdout); |
+ |
+ outhandle = STDOUT_FILENO; |
+ } |
+ else { |
+ /* Testing mode is nothing else but decoding |
+ * and throwing away the result. */ |
+ if (program_mode == PM_TEST) |
+ output_filename = "/dev/null"; |
+ else if (program_mode == PM_DECOMPRESS) |
+ output_filename = replace_extension(filenames[i]); |
+ else |
+ output_filename = filenames[i] |
+ + suffix; |
+ archive_name = output_filename; |
+ |
+ try { |
+ outhandle = open_outstream(output_filename, outStream); |
+ } |
+ catch (Exception e) { |
+ cerr << argv[0] << ": " << e.what() << endl; |
+ return STATUS_ERROR; |
+ } |
+ } |
+ |
+ } |
+ |
+ // Unless --force is specified, do not read/write compressed |
+ // data from/to a terminal. |
+ if (!force) { |
+ if (program_mode == PM_COMPRESS && isatty(outhandle)) { |
+ cerr << argv[0] << ": compressed data not " |
+ "written to a terminal. Use " |
+ "-f to force compression.\n" |
+ << argv[0] << ": For help, type: " |
+ << argv[0] << " -h\n"; |
+ return STATUS_ERROR; |
+ } else if (program_mode == PM_DECOMPRESS |
+ && isatty(inhandle)) { |
+ cerr << argv[0] << ": compressed data not " |
+ "read from a terminal. Use " |
+ "-f to force decompression.\n" |
+ << argv[0] << ": For help, type: " |
+ << argv[0] << " -h\n"; |
+ return STATUS_ERROR; |
+ } |
+ } |
+ |
+ if (program_mode == PM_COMPRESS) { |
+ NCompress::NLzma::CEncoder *encoderSpec = |
+ new NCompress::NLzma::CEncoder; |
+ |
+ lzma_option options = option_mapping[compression_mode]; |
+ |
+ try { |
+ encode(encoderSpec, inStream, outStream, options, fileSize); |
+ } |
+ catch (Exception e) { |
+ cerr << argv[0] << ": " << e.what() << endl; |
+ unlink(output_filename.c_str()); |
+ delete(encoderSpec); |
+ |
+ return STATUS_ERROR; |
+ } |
+ |
+ delete(encoderSpec); |
+ } |
+ else { // PM_DECOMPRESS | PM_TEST |
+ NCompress::NLzma::CDecoder *decoderSpec = |
+ new NCompress::NLzma::CDecoder; |
+ |
+ try { |
+ decode(decoderSpec, inStream, outStream); |
+ } |
+ catch (Exception e) { |
+ cerr << argv[0] << ": " << e.what() << endl; |
+ unlink(output_filename.c_str()); |
+ delete(decoderSpec); |
+ |
+ return STATUS_ERROR; |
+ } |
+ |
+ delete(decoderSpec); |
+ } |
+ |
+ /* Set permissions and owners. */ |
+ if ( (program_mode == PM_COMPRESS || program_mode == PM_DECOMPRESS ) |
+ && (!stdinput && !stdoutput) ) { |
+ |
+ int ret = 0; |
+ struct stat file_stats; |
+ ret = fstat(inhandle, &file_stats); |
+ |
+ ret = fchmod(outhandle, file_stats.st_mode); |
+ ret = fchown(outhandle, file_stats.st_uid, file_stats.st_gid); |
+ // We need to call fchmod() again, since otherwise the SUID bits |
+ // are lost. |
+ ret = fchmod(outhandle, file_stats.st_mode); |
+ |
+ struct timeval file_times[2]; |
+ // Access time |
+ file_times[0].tv_sec = file_stats.st_atime; |
+ file_times[0].tv_usec = 0; |
+ // Modification time |
+ file_times[1].tv_sec = file_stats.st_mtime; |
+ file_times[1].tv_usec = 0; |
+ |
+ ret = futimes(outhandle, file_times); |
+ |
+ if (!keep) |
+ unlink(filenames[i].c_str()); |
+ } |
+ |
+ if (verbosity > 0) { |
+ if (stdoutput) { |
+ cerr << filenames[i] << ":\t "; |
+ cerr << "decoded succesfully" |
+ << endl; |
+ } |
+ |
+ else { |
+ char buf[10] = { 0 }; |
+ |
+ if (program_mode == PM_DECOMPRESS) |
+ snprintf(buf, 10, "%.2f%%", |
+ (1 - get_ratio(outhandle, inhandle)) * 100); |
+ if (program_mode == PM_COMPRESS) |
+ snprintf(buf, 10, "%.2f%%", |
+ (1 - get_ratio(inhandle, outhandle)) * 100); |
+ |
+ string ratio = buf; |
+ cerr << pretty_print_status(filenames[i], output_filename, |
+ ratio) |
+ << endl; |
+ } |
+ } |
+ } |
+ |
+ if (warning) |
+ return STATUS_WARNING; |
+ |
+ return STATUS_OK; |
+} |
+ |
Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/Exception.h |
=================================================================== |
--- /dev/null 1970-01-01 00:00:00.000000000 +0000 |
+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/Exception.h 2009-06-01 22:01:10.000000000 +0200 |
@@ -0,0 +1,45 @@ |
+/* A couple of exceptions for lzmp. |
+ * |
+ * Copyright (C) 2005 Ville Koskinen |
+ * |
+ * This program is free software; you can redistribute it and/or |
+ * modify it under the terms of the GNU General Public License |
+ * as published by the Free Software Foundation; either version 2 |
+ * of the License, or (at your option) any later version. |
+ * |
+ * This program is distributed in the hope that it will be useful, |
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of |
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
+ * GNU General Public License for more details. |
+ */ |
+ |
+#ifndef _EXCEPTION_H_ |
+#define _EXCEPTION_H_ |
+ |
+#include <string> |
+using std::string; |
+ |
+class Exception |
+{ |
+private: |
+ string message; |
+public: |
+ Exception(char *what): message(what) { } |
+ Exception(string what): message(what) { } |
+ |
+ ~Exception() { } |
+ |
+ string what(void) { return message; } |
+}; |
+ |
+class ArgumentException: public Exception |
+{ |
+public: |
+ ArgumentException(char *what): Exception(what) { } |
+ ArgumentException(string what): Exception(what) { } |
+ |
+ ~ArgumentException() { } |
+}; |
+ |
+#endif |
+ |
Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/makefile.gcc |
=================================================================== |
--- lzma-4.65.orig/CPP/7zip/Compress/LZMA_Alone/makefile.gcc 2009-06-01 22:00:54.000000000 +0200 |
+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/makefile.gcc 2009-06-01 22:06:13.000000000 +0200 |
@@ -1,9 +1,10 @@ |
-PROG = lzma |
+PROG = lzma_alone |
+PROG2 = lzma |
CXX = g++ -O2 -Wall |
CXX_C = gcc -O2 -Wall |
LIB = -lm |
RM = rm -f |
-CFLAGS = -c -D_FILE_OFFSET_BITS=64 |
+CFLAGS = -c -I ../../../ -D_FILE_OFFSET_BITS=64 -DPACKAGE_VERSION="\"4.32.0beta3\"" |
|
ifdef SystemDrive |
IS_MINGW = 1 |
@@ -45,12 +46,35 @@ |
Lzma86Dec.o \ |
Lzma86Enc.o \ |
|
+OBJS2 = \ |
+ C_FileIO.o \ |
+ CRC.o \ |
+ Alloc.o \ |
+ FileStreams.o \ |
+ StreamUtils.o \ |
+ InBuffer.o \ |
+ OutBuffer.o \ |
+ LzmaDecoder.o \ |
+ StringConvert.o \ |
+ StringToInt.o \ |
+ LzmaEncoder.o \ |
+ LzmaDec.o \ |
+ LzmaEnc.o \ |
+ LzFind.o \ |
+ 7zCrc.o \ |
+ lzmp.o |
|
-all: $(PROG) |
+all: $(PROG) $(PROG2) |
|
$(PROG): $(OBJS) |
$(CXX) -o $(PROG) $(LDFLAGS) $(OBJS) $(LIB) $(LIB2) |
|
+$(PROG2): $(OBJS2) |
+ $(CXX) -o $(PROG2) $(LDFLAGS) $(OBJS2) $(LIB) |
+ |
+lzmp.o: lzmp.cpp |
+ $(CXX) $(CFLAGS) lzmp.cpp |
+ |
LzmaAlone.o: LzmaAlone.cpp |
$(CXX) $(CFLAGS) LzmaAlone.cpp |
|
@@ -131,5 +153,5 @@ |
$(CXX_C) $(CFLAGS) ../../../../C/LzmaUtil/Lzma86Enc.c |
|
clean: |
- -$(RM) $(PROG) $(OBJS) |
+ -$(RM) $(PROG) $(PROG2) $(OBJS) |
|
Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzma_version.h |
=================================================================== |
--- /dev/null 1970-01-01 00:00:00.000000000 +0000 |
+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzma_version.h 2009-06-01 22:01:10.000000000 +0200 |
@@ -0,0 +1,31 @@ |
+#ifndef LZMA_VERSION_H |
+#define LZMA_VERSION_H |
+ |
+/* |
+ Version and copyright information used by LZMA utils. |
+*/ |
+ |
+static const char *LZMA_SDK_VERSION_STRING = "4.43"; |
+ |
+static const char *LZMA_SDK_COPYRIGHT_STRING = |
+ "Copyright (C) 1999-2006 Igor Pavlov"; |
+ |
+static const char *LZMA_SDK_COPYRIGHT_INFO = |
+ " See http://7-zip.org/sdk.html or the documentation of LZMA SDK for\n" |
+ " the license. For reference, the version 4.43 is free software\n" |
+ " licensed under the GNU LGPL."; |
+ |
+ |
+static const char *LZMA_UTILS_VERSION_STRING = PACKAGE_VERSION; |
+ |
+static const char *LZMA_UTILS_COPYRIGHT_STRING = |
+ "Copyright (C) 2006 Lasse Collin"; |
+ |
+static const char *LZMA_UTILS_COPYRIGHT_INFO = |
+ "This program comes with ABSOLUTELY NO WARRANTY.\n" |
+ "You may redistribute copies of this program\n" |
+ "under the terms of the GNU General Public License.\n" |
+ "For more information about these matters, see the file " |
+ "named COPYING.\n"; |
+ |
+#endif /* ifndef LZMA_VERSION_H */ |
Index: lzma-4.65/CPP/Common/C_FileIO.h |
=================================================================== |
--- lzma-4.65.orig/CPP/Common/C_FileIO.h 2009-05-15 23:33:51.000000000 +0200 |
+++ lzma-4.65/CPP/Common/C_FileIO.h 2009-06-01 22:06:56.000000000 +0200 |
@@ -24,6 +24,7 @@ |
bool Close(); |
bool GetLength(UInt64 &length) const; |
off_t Seek(off_t distanceToMove, int moveMethod) const; |
+ int GetHandle() const { return _handle; } |
}; |
|
class CInFile: public CFileBase |