summaryrefslogtreecommitdiffstats
path: root/main.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--main.c1787
1 files changed, 1033 insertions, 754 deletions
diff --git a/main.c b/main.c
index 353a1d9..cda4327 100644
--- a/main.c
+++ b/main.c
@@ -1,754 +1,1033 @@
-/* Pdlzip - Data compressor based on the LZMA algorithm
- 2009-08-14 : Igor Pavlov : Public domain
- Copyright (C) 2010, 2011, 2012 Antonio Diaz Diaz.
-
- This program is free software: you have unlimited permission
- to copy, distribute and modify it.
-
- 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.
-*/
-
-#define _FILE_OFFSET_BITS 64
-
-#include <errno.h>
-#include <limits.h>
-#include <signal.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#if defined(__OS2__)
-#include <io.h>
-#endif
-
-#include "pdarg_parser.h"
-#include "pdlzip.h"
-#include "Alloc.h"
-#include "7zFile.h"
-#include "LzmaDec.h"
-#include "LzmaEnc.h"
-
-#if CHAR_BIT != 8
-#error "Environments where CHAR_BIT != 8 are not supported."
-#endif
-
-#ifndef LLONG_MAX
-#define LLONG_MAX 0x7FFFFFFFFFFFFFFFLL
-#endif
-#ifndef LLONG_MIN
-#define LLONG_MIN (-LLONG_MAX - 1LL)
-#endif
-#ifndef ULLONG_MAX
-#define ULLONG_MAX 0xFFFFFFFFFFFFFFFFULL
-#endif
-
-long long int llabs( long long int number );
-
-
-static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
-static void SzFree(void *p, void *address) { p = p; MyFree(address); }
-static ISzAlloc g_Alloc = { SzAlloc, SzFree };
-
-const char * const Program_name = "Pdlzip";
-const char * const program_name = "pdlzip";
-const char * const program_year = "2012";
-const char * invocation_name = 0;
-
-
-struct { const char * from; const char * to; } const known_extensions[] = {
- { ".lz", "" },
- { ".tlz", ".tar" },
- { ".lzma", "" },
- { 0, 0 } };
-
-struct Lzma_options
- {
- int dictionary_size; /* 4KiB..512MiB */
- int match_len_limit; /* 5..273 */
- };
-
-enum Mode { m_compress, m_decompress, m_test };
-char * output_filename = 0;
-
-
-/* assure at least a minimum size for buffer 'buf' */
-inline void * resize_buffer( void * buf, const int min_size )
- {
- if( buf ) buf = realloc( buf, min_size );
- else buf = malloc( min_size );
- return buf;
- }
-
-
-static void show_help()
- {
- printf( "%s - A \"public domain\" version of the lzip data compressor\n", Program_name );
- printf( "also able to decompress legacy lzma-alone (.lzma) files.\n"
- "\nUsage: %s [options] [file]\n", invocation_name );
- printf( "\nOptions:\n"
- " -h, --help display this help and exit\n"
- " -V, --version output version information and exit\n"
- " -c, --stdout send output to standard output\n"
- " -d, --decompress decompress\n"
-/* " -f, --force overwrite existing output files\n" */
-/* " -k, --keep keep (don't delete) input files\n" */
- " -m, --match-length=<bytes> set match length limit in bytes [36]\n"
- " -q, --quiet suppress all messages\n"
- " -s, --dictionary-size=<bytes> set dictionary size limit in bytes [8MiB]\n"
- " -t, --test test compressed file integrity\n"
- " -v, --verbose be verbose (a 2nd -v gives more)\n"
- " -1 .. -9 set compression level [default 6]\n"
- " --fast alias for -1\n"
- " --best alias for -9\n"
- "If no file name is given, pdlzip compresses or decompresses\n"
- "from standard input to standard output.\n"
- "Numbers may be followed by a multiplier: k = kB = 10^3 = 1000,\n"
- "Ki = KiB = 2^10 = 1024, M = 10^6, Mi = 2^20, G = 10^9, Gi = 2^30, etc...\n"
- "The bidimensional parameter space of LZMA can't be mapped to a linear\n"
- "scale optimal for all files. If your files are large, very repetitive,\n"
- "etc, you may need to use the --match-length and --dictionary-size\n"
- "options directly to achieve optimal performance.\n"
- "\nReport bugs to lzip-bug@nongnu.org\n"
- "Pdlzip home page: http://www.nongnu.org/lzip/pdlzip.html\n" );
- }
-
-
-static void show_version()
- {
- printf( "%s %s\n", Program_name, PROGVERSION );
- printf( "Copyright (C) %s Antonio Diaz Diaz.\n", program_year );
- printf( "Public Domain 2009 Igor Pavlov.\n"
- "This is free software: you are free to change and redistribute it.\n"
- "There is NO WARRANTY, to the extent permitted by law.\n" );
- }
-
-
-static const char * format_num( long long num )
- {
- const char * const prefix[8] =
- { "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi" };
- enum { buf_size = 16, factor = 1024 };
- static char buf[buf_size];
- const char *p = "";
- bool exact = ( num % factor == 0 );
- int i;
-
- for( i = 0; i < 8 && ( llabs( num ) > 9999 ||
- ( exact && llabs( num ) >= factor ) ); ++i )
- { num /= factor; if( num % factor != 0 ) exact = false; p = prefix[i]; }
- snprintf( buf, buf_size, "%lld %s", num, p );
- return buf;
- }
-
-
-static long long getnum( const char * const ptr,
- const long long llimit, const long long ulimit )
- {
- long long result;
- char *tail;
-
- errno = 0;
- result = strtoll( ptr, &tail, 0 );
- if( tail == ptr )
- {
- show_error( "Bad or missing numerical argument.", 0, true );
- exit( 1 );
- }
-
- if( !errno && tail[0] )
- {
- int factor = ( tail[1] == 'i' ) ? 1024 : 1000;
- int exponent = 0, i;
- bool bad_multiplier = false;
- switch( tail[0] )
- {
- case ' ': break;
- case 'Y': exponent = 8; break;
- case 'Z': exponent = 7; break;
- case 'E': exponent = 6; break;
- case 'P': exponent = 5; break;
- case 'T': exponent = 4; break;
- case 'G': exponent = 3; break;
- case 'M': exponent = 2; break;
- case 'K': if( factor == 1024 ) exponent = 1; else bad_multiplier = true;
- break;
- case 'k': if( factor == 1000 ) exponent = 1; else bad_multiplier = true;
- break;
- default : bad_multiplier = true;
- }
- if( bad_multiplier )
- {
- show_error( "Bad multiplier in numerical argument.", 0, true );
- exit( 1 );
- }
- for( i = 0; i < exponent; ++i )
- {
- if( LLONG_MAX / factor >= llabs( result ) ) result *= factor;
- else { errno = ERANGE; break; }
- }
- }
- if( !errno && ( result < llimit || result > ulimit ) ) errno = ERANGE;
- if( errno )
- {
- show_error( "Numerical argument out of limits.", 0, false );
- exit( 1 );
- }
- return result;
- }
-
-
-static int get_dict_size( const char * const arg )
- {
- char *tail;
- int bits = strtol( arg, &tail, 0 );
- if( bits >= min_dictionary_bits &&
- bits <= max_dictionary_bits && *tail == 0 )
- return ( 1 << bits );
- return getnum( arg, min_dictionary_size, max_dictionary_size );
- }
-
-
-static void show_name( const char * const name )
- {
- if( verbosity >= 1 )
- fprintf( stderr, " %s: ", ( name && name[0] ) ? name : "(stdin)" );
- }
-
-
-#define IN_BUF_SIZE (1 << 16)
-#define OUT_BUF_SIZE (1 << 16)
-
-static bool read_inbuf( ISeqInStream * const inStream, Byte inBuf[],
- size_t * const inPos, size_t * const inSize )
- {
- size_t rest;
- if( *inPos >= *inSize ) *inSize = 0;
- else if( *inPos > 0 )
- {
- memmove( inBuf, inBuf + *inPos, *inSize - *inPos );
- *inSize -= *inPos;
- }
- *inPos = 0;
- rest = IN_BUF_SIZE - *inSize;
- if( rest > 0 )
- {
- if( inStream->Read( inStream, inBuf + *inSize, &rest ) != 0 )
- { show_error( "Read error", errno, false ); return false; }
- *inSize += rest;
- }
- return true;
- }
-
-
-static int lzma_Decode2( UInt64 unpackSize, CLzmaDec *state,
- ISeqOutStream *outStream, ISeqInStream *inStream,
- Byte inBuf[], size_t * const inPos,
- size_t * const inSize, const bool testing )
- {
- long long total_in = 13, total_out = 0;
- Byte outBuf[OUT_BUF_SIZE];
- size_t outPos = 0;
- const bool thereIsSize = (unpackSize != (UInt64)(Int64)-1);
- LzmaDec_Init(state);
-
- for (;;)
- {
- SizeT inProcessed;
- SizeT outProcessed = OUT_BUF_SIZE - outPos;
- ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
- ELzmaStatus status;
-
- if( *inPos == *inSize && !read_inbuf( inStream, inBuf, inPos, inSize ) )
- return 1;
- inProcessed = *inSize - *inPos;
- if (thereIsSize && outProcessed > unpackSize)
- {
- outProcessed = (SizeT)unpackSize;
- finishMode = LZMA_FINISH_END;
- }
-
- if( LzmaDec_DecodeToBuf( state, outBuf + outPos, &outProcessed,
- inBuf + *inPos, &inProcessed, finishMode, &status ) != 0 )
- { show_error( "Data error.", 0, false ); return 1; }
- *inPos += inProcessed;
- total_in += inProcessed;
- outPos += outProcessed;
- unpackSize -= outProcessed;
-
- if (outStream)
- if (outStream->Write(outStream, outBuf, outPos) != outPos)
- { show_error( "Can not write output file", errno, false ); return 1; }
-
- total_out += outPos;
- outPos = 0;
-
- if( ( inProcessed == 0 && outProcessed == 0 ) ||
- ( thereIsSize && unpackSize == 0 ) )
- {
- if( ( thereIsSize && unpackSize != 0 ) ||
- ( !thereIsSize && status != LZMA_STATUS_FINISHED_WITH_MARK ) )
- { show_error( "Data error.", 0, false ); return 1; }
- if( verbosity >= 2 )
- fprintf( stderr, "lzma-alone, dictionary size %7sB. ",
- format_num( state->prop.dicSize ) );
- if( verbosity >= 3 )
- fprintf( stderr, "uncompressed size %9lld, compressed size %8lld. ",
- total_out, total_in );
- if( verbosity >= 1 )
- { if( testing ) fprintf( stderr, "(apparently) ok\n" );
- else fprintf( stderr, "(apparently) done\n" ); }
- return 0;
- }
- }
- }
-
-
-static int Decode2( CLzmaDec *state, ISeqOutStream *outStream,
- ISeqInStream *inStream, Byte inBuf[], size_t * const inPos,
- size_t * const inSize, const int member_version,
- const bool testing )
- {
- long long total_in = Fh_size, total_out = 0;
- Byte outBuf[OUT_BUF_SIZE];
- size_t outPos = 0;
- uint32_t crc = 0xFFFFFFFFU;
- LzmaDec_Init(state);
-
- for (;;)
- {
- SizeT inProcessed;
- SizeT outProcessed = OUT_BUF_SIZE - outPos;
- ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
- ELzmaStatus status;
-
- if( *inPos == *inSize && !read_inbuf( inStream, inBuf, inPos, inSize ) )
- return 1;
- if( *inPos == *inSize )
- { show_error( "Unexpected EOF.", 0, false ); return 1; }
- inProcessed = *inSize - *inPos;
-
- if( LzmaDec_DecodeToBuf( state, outBuf + outPos, &outProcessed,
- inBuf + *inPos, &inProcessed, finishMode, &status ) != 0 )
- { show_error( "Data error.", 0, false ); return 1; }
- *inPos += inProcessed;
- total_in += inProcessed;
- outPos += outProcessed;
-
- if (outStream)
- if (outStream->Write(outStream, outBuf, outPos) != outPos)
- { show_error( "Can not write output file", errno, false ); return 1; }
-
- CRC32_update_buf( &crc, outBuf, outPos );
- total_out += outPos;
- outPos = 0;
-
- if (inProcessed == 0 && outProcessed == 0)
- {
- File_trailer trailer;
- size_t i;
- const size_t trailer_size = Ft_versioned_size( member_version );
- bool error = false;
-
- if( status != LZMA_STATUS_FINISHED_WITH_MARK )
- { show_error( "Data error.", 0, false ); return 1; }
- if( *inSize - *inPos < trailer_size &&
- !read_inbuf( inStream, inBuf, inPos, inSize ) ) return 1;
- if( *inSize - *inPos < trailer_size )
- {
- error = true;
- if( verbosity >= 0 )
- fprintf( stderr, "trailer truncated at trailer position %u;"
- " some checks may fail.\n",
- (unsigned int)(*inSize - *inPos) );
- for( i = *inSize - *inPos; i < trailer_size; ++i )
- inBuf[*inPos+i] = 0;
- }
- for( i = 0; i < trailer_size; ++i )
- trailer[i] = inBuf[(*inPos)++];
- total_in += trailer_size;
- if( member_version == 0 ) Ft_set_member_size( trailer, total_in );
- if( Ft_get_data_crc( trailer ) != ( crc ^ 0xFFFFFFFFU ) )
- {
- error = true;
- if( verbosity >= 0 )
- fprintf( stderr, "crc mismatch; trailer says %08X, data crc is %08X.\n",
- (unsigned int)Ft_get_data_crc( trailer ),
- (unsigned int)( crc ^ 0xFFFFFFFFU ) );
- }
- if( Ft_get_data_size( trailer ) != total_out )
- {
- error = true;
- if( verbosity >= 0 )
- fprintf( stderr, "data size mismatch; trailer says %lld, data size is %lld.\n",
- Ft_get_data_size( trailer ), total_out );
- }
- if( Ft_get_member_size( trailer ) != total_in )
- {
- error = true;
- if( verbosity >= 0 )
- fprintf( stderr, "member size mismatch; trailer says %lld, member size is %lld.\n",
- Ft_get_member_size( trailer ), total_in );
- }
- if( !error && verbosity >= 3 )
- fprintf( stderr, "data crc %08X, data size %9lld, member size %8lld. ",
- (unsigned int)Ft_get_data_crc( trailer ),
- Ft_get_data_size( trailer ), Ft_get_member_size( trailer ) );
- if( !error && verbosity >= 1 )
- { if( testing ) fprintf( stderr, "ok\n" );
- else fprintf( stderr, "done\n" ); }
- if( error ) return 2;
- return 0;
- }
- }
- }
-
-
-static int Decode( ISeqOutStream *outStream, ISeqInStream *inStream,
- const char * const name, const bool testing )
- {
- UInt64 unpackSize = 0;
- CLzmaDec state;
- File_header header;
- Byte inBuf[IN_BUF_SIZE];
- size_t inPos = 0, inSize = 0;
- int retval = 0;
- bool lzma_mode = false;
- bool first_member;
- /* 5 bytes of LZMA properties and 8 bytes of uncompressed size */
- unsigned char props[LZMA_PROPS_SIZE+8];
-
- for( first_member = true; ; first_member = false )
- {
- int i;
- if( inSize < Fh_size &&
- !read_inbuf( inStream, inBuf, &inPos, &inSize ) ) return 1;
- if( inSize < Fh_size ) /* End Of File */
- {
- if( !first_member ) break;
- show_error( "Error reading member header.", 0, false ); return 1;
- }
- for( i = 0; i < Fh_size; ++i )
- props[i] = header[i] = inBuf[inPos++];
- if( !Fh_verify_magic( header ) )
- {
- if( !first_member ) break; /* trailing garbage */
- if( inSize >= 13 - Fh_size ) /* try lzma-alone */
- {
- for( i = Fh_size; i < 13; ++i ) props[i] = inBuf[inPos++];
- for( i = 0; i < 8; ++i )
- unpackSize += (UInt64)props[LZMA_PROPS_SIZE+i] << (i * 8);
- if( ( props[12] == 0 || props[12] == 0xFF ) && props[12] == props[11] )
- lzma_mode = true;
- }
- if( !lzma_mode )
- {
- show_error( "Bad magic number (file not in lzip format).", 0, false );
- return 2;
- }
- }
- if( !first_member ) show_name( name );
- if( !lzma_mode )
- {
- int ds, i;
- if( !Fh_verify_version( header ) )
- {
- if( verbosity >= 0 )
- fprintf( stderr, "version %d member format not supported, newer %s needed.\n",
- Fh_version( header ), program_name );
- return 2;
- }
- if( Fh_get_dictionary_size( header ) < min_dictionary_size ||
- Fh_get_dictionary_size( header ) > max_dictionary_size )
- {
- if( verbosity >= 0 )
- fprintf( stderr, "invalid dictionary size in member header.\n" );
- return 2;
- }
-
- if( verbosity >= 2 )
- fprintf( stderr, "version %d, dictionary size %7sB. ",
- Fh_version( header ),
- format_num( Fh_get_dictionary_size( header ) ) );
-
- props[0] = 93; /* (45 * 2) + (9 * 0) + 3 */
- ds = Fh_get_dictionary_size( header );
- for( i = 1; i <= 4; ++i ) { props[i] = ds & 0xFF; ds >>= 8; }
- }
-
- LzmaDec_Construct(&state);
- if( LzmaDec_Allocate( &state, props, LZMA_PROPS_SIZE, &g_Alloc ) != 0 )
- { show_error( "Can not allocate memory.", 0, false ); return 1; }
- if( !lzma_mode )
- retval = Decode2( &state, outStream, inStream, inBuf, &inPos,
- &inSize, Fh_version( header ), testing );
- else
- retval = lzma_Decode2( unpackSize, &state, outStream, inStream,
- inBuf, &inPos, &inSize, testing );
- LzmaDec_Free(&state, &g_Alloc);
- if( retval != 0 || lzma_mode ) break;
- }
- return retval;
- }
-
-
-static int Encode( ISeqOutStream *outStream, ISeqInStream *inStream,
- const struct Lzma_options * const encoder_options )
- {
- CLzmaEncProps props;
- int retval = 0;
- File_header header;
-
- CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
- if(enc == 0)
- { show_error( "Can not allocate memory.", 0, false ); return 1; }
-
- LzmaEncProps_Init(&props);
- props.dictSize = encoder_options->dictionary_size;
- props.lc = literal_context_bits;
- props.lp = 0;
- props.pb = pos_state_bits;
- props.fb = encoder_options->match_len_limit;
- props.btMode = 1;
- props.numHashBytes = 4;
- props.mc = 16 + ( encoder_options->match_len_limit / 2 );
- LzmaEnc_SetProps(enc, &props);
-
- Fh_set_magic( header );
- if( !Fh_set_dictionary_size( header, encoder_options->dictionary_size ) ||
- encoder_options->match_len_limit < min_match_len_limit ||
- encoder_options->match_len_limit > max_match_len )
- internal_error( "invalid argument to encoder" );
-
- if( outStream->Write( outStream, header, Fh_size ) != Fh_size )
- { show_error( "Can not write output file", errno, false ); retval = 1; }
- else
- if( LzmaEnc_Encode(enc, outStream, inStream, NULL, &g_Alloc, &g_Alloc) != 0 )
- { show_error( "Data error.", 0, false ); retval = 1; }
- LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
- return retval;
- }
-
-
-int verbosity = 0;
-
-
-void show_error( const char * const msg, const int errcode, const bool help )
- {
- if( verbosity >= 0 )
- {
- if( msg && msg[0] )
- {
- fprintf( stderr, "%s: %s", program_name, msg );
- if( errcode > 0 ) fprintf( stderr, ": %s", strerror( errcode ) );
- fprintf( stderr, "\n" );
- }
- if( help && invocation_name && invocation_name[0] )
- fprintf( stderr, "Try '%s --help' for more information.\n",
- invocation_name );
- }
- }
-
-
-void internal_error( const char * const msg )
- {
- if( verbosity >= 0 )
- fprintf( stderr, "%s: internal error: %s.\n", program_name, msg );
- exit( 3 );
- }
-
-
-static int extension_index( const char * const name )
- {
- int i;
- for( i = 0; known_extensions[i].from; ++i )
- {
- const char * const ext = known_extensions[i].from;
- if( strlen( name ) > strlen( ext ) &&
- strncmp( name + strlen( name ) - strlen( ext ), ext, strlen( ext ) ) == 0 )
- return i;
- }
- return -1;
- }
-
-
-static void set_c_outname( const char * const name )
- {
- output_filename = resize_buffer( output_filename, strlen( name ) +
- strlen( known_extensions[0].from ) + 1 );
- strcpy( output_filename, name );
- strcat( output_filename, known_extensions[0].from );
- }
-
-
-static void set_d_outname( const char * const name )
- {
- const int i = extension_index( name );
- if( i >= 0 )
- {
- const char * const from = known_extensions[i].from;
- if( strlen( name ) > strlen( from ) )
- {
- output_filename = resize_buffer( output_filename, strlen( name ) +
- strlen( known_extensions[0].to ) + 1 );
- strcpy( output_filename, name );
- strcpy( output_filename + strlen( name ) - strlen( from ),
- known_extensions[i].to );
- return;
- }
- }
- output_filename = resize_buffer( output_filename, strlen( name ) + 4 + 1 );
- strcpy( output_filename, name );
- strcat( output_filename, ".out" );
- if( verbosity >= 1 )
- fprintf( stderr, "%s: Can't guess original name for '%s' -- using '%s'.\n",
- program_name, name, output_filename );
- }
-
-
-CRC32 crc32;
-
-
-int main( const int argc, const char * const argv[] )
- {
- /* Mapping from gzip/bzip2 style 1..9 compression modes
- to the corresponding LZMA compression modes. */
- const struct Lzma_options option_mapping[] =
- {
- { 1 << 20, 5 }, /* -0 */
- { 1 << 20, 5 }, /* -1 */
- { 3 << 19, 6 }, /* -2 */
- { 1 << 21, 8 }, /* -3 */
- { 3 << 20, 12 }, /* -4 */
- { 1 << 22, 20 }, /* -5 */
- { 1 << 23, 36 }, /* -6 */
- { 1 << 24, 68 }, /* -7 */
- { 3 << 23, 132 }, /* -8 */
- { 1 << 25, 273 } }; /* -9 */
- struct Lzma_options encoder_options = option_mapping[6]; /* default = "-6" */
- enum Mode program_mode = m_compress;
- const char * input_filename = "";
- CFileSeqInStream inStream;
- CFileOutStream outStream;
- int argind;
- int retval;
- bool force = false;
- bool keep_input_files = false;
- bool to_stdout = false;
-
- const struct ap_Option options[] =
- {
- { '0', 0, ap_no },
- { '1', "fast", ap_no },
- { '2', 0, ap_no },
- { '3', 0, ap_no },
- { '4', 0, ap_no },
- { '5', 0, ap_no },
- { '6', 0, ap_no },
- { '7', 0, ap_no },
- { '8', 0, ap_no },
- { '9', "best", ap_no },
- { 'b', "member-size", ap_yes },
- { 'c', "stdout", ap_no },
- { 'd', "decompress", ap_no },
- { 'f', "force", ap_no },
- { 'h', "help", ap_no },
- { 'k', "keep", ap_no },
- { 'm', "match-length", ap_yes },
- { 'q', "quiet", ap_no },
- { 's', "dictionary-size", ap_yes },
- { 'S', "volume-size", ap_yes },
- { 't', "test", ap_no },
- { 'v', "verbose", ap_no },
- { 'V', "version", ap_no },
- { 0 , 0, ap_no } };
-
- struct Arg_parser parser;
-
- invocation_name = argv[0];
- CRC32_init();
- if (sizeof(UInt32) != 4 || sizeof(UInt64) != 8)
- internal_error( "incorrect UInt32 or UInt64" );
-
- if( !ap_init( &parser, argc, argv, options, 0 ) )
- { show_error( "Memory exhausted.", 0, false ); return 1; }
- if( ap_error( &parser ) ) /* bad option */
- { show_error( ap_error( &parser ), 0, true ); return 1; }
-
- for( argind = 0; argind < ap_arguments( &parser ); ++argind )
- {
- const int code = ap_code( &parser, argind );
- const char * const arg = ap_argument( &parser, argind );
- if( !code ) break; /* no more options */
- switch( code )
- {
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- encoder_options = option_mapping[code-'0']; break;
- case 'b': break;
- case 'c': to_stdout = true; break;
- case 'd': program_mode = m_decompress; break;
- case 'e': break;
- case 'f': force = true; break;
- case 'h': show_help(); return 0;
- case 'k': keep_input_files = true; break;
- case 'm': encoder_options.match_len_limit =
- getnum( arg, min_match_len_limit, max_match_len ); break;
- case 'q': verbosity = -1; break;
- case 's': encoder_options.dictionary_size = get_dict_size( arg );
- break;
- case 'S': break;
- case 't': program_mode = m_test; break;
- case 'v': if( verbosity < 4 ) ++verbosity; break;
- case 'V': show_version(); return 0;
- default : internal_error( "uncaught option" );
- }
- } /* end process options */
-
-#if defined(__OS2__)
- _fsetmode( stdin, "b" );
- _fsetmode( stdout, "b" );
-#endif
-
- if( ap_arguments( &parser ) > argind &&
- strcmp( ap_argument( &parser, argind ), "-" ) )
- input_filename = ap_argument( &parser, argind );
- if( ap_arguments( &parser ) > argind + 1 )
- { show_error( "Too many file names.", 0, true ); return 1; }
-
- if( program_mode == m_test ) output_filename = "/dev/null";
- else
- {
- if( to_stdout || !input_filename[0] ) output_filename = "";
- else
- {
- if( program_mode == m_compress ) set_c_outname( input_filename );
- else set_d_outname( input_filename );
- }
- }
-
- FileSeqInStream_CreateVTable(&inStream);
- File_Construct(&inStream.file);
-
- FileOutStream_CreateVTable(&outStream);
- File_Construct(&outStream.file);
-
- if (InFile_Open(&inStream.file, input_filename) != 0)
- { show_error( "Can not open input file", errno, false ); return 1; }
-
- if (OutFile_Open(&outStream.file, output_filename) != 0)
- { show_error( "Can not open output file", errno, false ); return 1; }
-
- show_name( input_filename );
- if( program_mode == m_compress )
- retval = Encode( &outStream.s, &inStream.s, &encoder_options );
- else
- retval = Decode( &outStream.s, &inStream.s, input_filename, program_mode == m_test );
-
- File_Close(&outStream.file);
- File_Close(&inStream.file);
-
- ap_free( &parser );
- return retval;
- }
+/* Pdlzip - Data compressor based on the LZMA algorithm
+ 2009-08-14 : Igor Pavlov : Public domain
+ Copyright (C) 2010, 2011, 2012, 2013 Antonio Diaz Diaz.
+
+ This program is free software: you have unlimited permission
+ to copy, distribute and modify it.
+
+ 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.
+*/
+/*
+ Return values: 0 for a normal exit, 1 for environmental problems
+ (file not found, invalid flags, I/O errors, etc), 2 to indicate a
+ corrupt or invalid input file, 3 for an internal consistency error
+ (eg, bug) which caused pdlzip to panic.
+*/
+
+#define _FILE_OFFSET_BITS 64
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <utime.h>
+#include <sys/stat.h>
+#if defined(__MSVCRT__)
+#include <io.h>
+#define fchmod(x,y) 0
+#define fchown(x,y,z) 0
+#define SIGHUP SIGTERM
+#define S_ISSOCK(x) 0
+#define S_IRGRP 0
+#define S_IWGRP 0
+#define S_IROTH 0
+#define S_IWOTH 0
+#endif
+#if defined(__OS2__)
+#include <io.h>
+#endif
+
+#include "carg_parser.h"
+#include "clzip.h"
+#include "LzmaDec.h"
+#include "LzmaEnc.h"
+
+#if CHAR_BIT != 8
+#error "Environments where CHAR_BIT != 8 are not supported."
+#endif
+
+
+const char * const Program_name = "Pdlzip";
+const char * const program_name = "pdlzip";
+const char * const program_year = "2013";
+const char * invocation_name = 0;
+
+#ifdef O_BINARY
+const int o_binary = O_BINARY;
+#else
+const int o_binary = 0;
+#endif
+
+struct { const char * from; const char * to; } const known_extensions[] = {
+ { ".lz", "" },
+ { ".tlz", ".tar" },
+ { ".lzma", "" },
+ { 0, 0 } };
+
+struct Lzma_options
+ {
+ int dictionary_size; /* 4KiB..512MiB */
+ int match_len_limit; /* 5..273 */
+ };
+
+enum Mode { m_compress, m_decompress, m_test };
+
+char * output_filename = 0;
+int outfd = -1;
+int verbosity = 0;
+const mode_t usr_rw = S_IRUSR | S_IWUSR;
+const mode_t all_rw = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+mode_t outfd_mode = S_IRUSR | S_IWUSR;
+bool delete_output_on_interrupt = false;
+
+
+static void show_help( void )
+ {
+ printf( "%s - A \"public domain\" version of the lzip data compressor\n", Program_name );
+ printf( "also able to decompress legacy lzma-alone (.lzma) files.\n"
+ "\nUsage: %s [options] [files]\n", invocation_name );
+ printf( "\nOptions:\n"
+ " -h, --help display this help and exit\n"
+ " -V, --version output version information and exit\n"
+ " -c, --stdout send output to standard output\n"
+ " -d, --decompress decompress\n"
+ " -f, --force overwrite existing output files\n"
+ " -F, --recompress force recompression of compressed files\n"
+ " -k, --keep keep (don't delete) input files\n"
+ " -m, --match-length=<bytes> set match length limit in bytes [36]\n"
+ " -o, --output=<file> if reading stdin, place the output into <file>\n"
+ " -q, --quiet suppress all messages\n"
+ " -s, --dictionary-size=<bytes> set dictionary size limit in bytes [8MiB]\n"
+ " -t, --test test compressed file integrity\n"
+ " -v, --verbose be verbose (a 2nd -v gives more)\n"
+ " -1 .. -9 set compression level [default 6]\n"
+ " --fast alias for -1\n"
+ " --best alias for -9\n"
+ "If no file names are given, pdlzip compresses or decompresses\n"
+ "from standard input to standard output.\n"
+ "Numbers may be followed by a multiplier: k = kB = 10^3 = 1000,\n"
+ "Ki = KiB = 2^10 = 1024, M = 10^6, Mi = 2^20, G = 10^9, Gi = 2^30, etc...\n"
+ "The bidimensional parameter space of LZMA can't be mapped to a linear\n"
+ "scale optimal for all files. If your files are large, very repetitive,\n"
+ "etc, you may need to use the --match-length and --dictionary-size\n"
+ "options directly to achieve optimal performance.\n"
+ "\nReport bugs to lzip-bug@nongnu.org\n"
+ "Pdlzip home page: http://www.nongnu.org/lzip/pdlzip.html\n" );
+ }
+
+
+static void show_version( void )
+ {
+ printf( "%s %s\n", Program_name, PROGVERSION );
+ printf( "Copyright (C) %s Antonio Diaz Diaz.\n", program_year );
+ printf( "Public Domain 2009 Igor Pavlov.\n"
+ "This is free software: you are free to change and redistribute it.\n"
+ "There is NO WARRANTY, to the extent permitted by law.\n" );
+ }
+
+
+static const char * format_num( unsigned num )
+ {
+ const char * const prefix[8] =
+ { "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi" };
+ enum { buf_size = 16, factor = 1024 };
+ static char buf[buf_size];
+ const char * p = "";
+ bool exact = ( num % factor == 0 );
+ int i;
+
+ for( i = 0; i < 8 && ( num > 9999 || ( exact && num >= factor ) ); ++i )
+ { num /= factor; if( num % factor != 0 ) exact = false; p = prefix[i]; }
+ snprintf( buf, buf_size, "%u %s", num, p );
+ return buf;
+ }
+
+
+void show_header( const File_header header )
+ {
+ const char * const prefix[8] =
+ { "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi" };
+ enum { factor = 1024 };
+ const char * p = "";
+ const char * np = " ";
+ unsigned num = Fh_get_dictionary_size( header ), i;
+ bool exact = ( num % factor == 0 );
+
+ for( i = 0; i < 8 && ( num > 9999 || ( exact && num >= factor ) ); ++i )
+ { num /= factor; if( num % factor != 0 ) exact = false;
+ p = prefix[i]; np = ""; }
+ fprintf( stderr, "version %d, dictionary size %s%4u %sB. ",
+ Fh_version( header ), np, num, p );
+ }
+
+
+static unsigned long getnum( const char * const ptr,
+ const unsigned long llimit,
+ const unsigned long ulimit )
+ {
+ unsigned long result;
+ char * tail;
+ errno = 0;
+ result = strtoul( ptr, &tail, 0 );
+ if( tail == ptr )
+ {
+ show_error( "Bad or missing numerical argument.", 0, true );
+ exit( 1 );
+ }
+
+ if( !errno && tail[0] )
+ {
+ int factor = ( tail[1] == 'i' ) ? 1024 : 1000;
+ int exponent = 0, i;
+ bool bad_multiplier = false;
+ switch( tail[0] )
+ {
+ case ' ': break;
+ case 'Y': exponent = 8; break;
+ case 'Z': exponent = 7; break;
+ case 'E': exponent = 6; break;
+ case 'P': exponent = 5; break;
+ case 'T': exponent = 4; break;
+ case 'G': exponent = 3; break;
+ case 'M': exponent = 2; break;
+ case 'K': if( factor == 1024 ) exponent = 1; else bad_multiplier = true;
+ break;
+ case 'k': if( factor == 1000 ) exponent = 1; else bad_multiplier = true;
+ break;
+ default : bad_multiplier = true;
+ }
+ if( bad_multiplier )
+ {
+ show_error( "Bad multiplier in numerical argument.", 0, true );
+ exit( 1 );
+ }
+ for( i = 0; i < exponent; ++i )
+ {
+ if( ulimit / factor >= result ) result *= factor;
+ else { errno = ERANGE; break; }
+ }
+ }
+ if( !errno && ( result < llimit || result > ulimit ) ) errno = ERANGE;
+ if( errno )
+ {
+ show_error( "Numerical argument out of limits.", 0, false );
+ exit( 1 );
+ }
+ return result;
+ }
+
+
+static int get_dict_size( const char * const arg )
+ {
+ char * tail;
+ int bits = strtol( arg, &tail, 0 );
+ if( bits >= min_dictionary_bits &&
+ bits <= max_dictionary_bits && *tail == 0 )
+ return ( 1 << bits );
+ return getnum( arg, min_dictionary_size, max_dictionary_size );
+ }
+
+
+static int extension_index( const char * const name )
+ {
+ int i;
+ for( i = 0; known_extensions[i].from; ++i )
+ {
+ const char * const ext = known_extensions[i].from;
+ if( strlen( name ) > strlen( ext ) &&
+ strncmp( name + strlen( name ) - strlen( ext ), ext, strlen( ext ) ) == 0 )
+ return i;
+ }
+ return -1;
+ }
+
+
+static int open_instream( const char * const name, struct stat * const in_statsp,
+ const enum Mode program_mode, const int eindex,
+ const bool recompress, const bool to_stdout )
+ {
+ int infd = -1;
+ if( program_mode == m_compress && !recompress && eindex >= 0 )
+ {
+ if( verbosity >= 0 )
+ fprintf( stderr, "%s: Input file '%s' already has '%s' suffix.\n",
+ program_name, name, known_extensions[eindex].from );
+ }
+ else
+ {
+ infd = open( name, O_RDONLY | o_binary );
+ if( infd < 0 )
+ {
+ if( verbosity >= 0 )
+ fprintf( stderr, "%s: Can't open input file '%s': %s.\n",
+ program_name, name, strerror( errno ) );
+ }
+ else
+ {
+ const int i = fstat( infd, in_statsp );
+ const mode_t mode = in_statsp->st_mode;
+ const bool can_read = ( i == 0 &&
+ ( S_ISBLK( mode ) || S_ISCHR( mode ) ||
+ S_ISFIFO( mode ) || S_ISSOCK( mode ) ) );
+ if( i != 0 || ( !S_ISREG( mode ) && ( !to_stdout || !can_read ) ) )
+ {
+ if( verbosity >= 0 )
+ fprintf( stderr, "%s: Input file '%s' is not a regular file%s.\n",
+ program_name, name,
+ ( can_read && !to_stdout ) ?
+ " and '--stdout' was not specified" : "" );
+ close( infd );
+ infd = -1;
+ }
+ }
+ }
+ return infd;
+ }
+
+
+void cleanup_and_fail( const int retval )
+ {
+ if( delete_output_on_interrupt )
+ {
+ delete_output_on_interrupt = false;
+ if( verbosity >= 0 )
+ fprintf( stderr, "%s: Deleting output file '%s', if it exists.\n",
+ program_name, output_filename );
+ if( outfd >= 0 ) { close( outfd ); outfd = -1; }
+ if( remove( output_filename ) != 0 && errno != ENOENT )
+ show_error( "WARNING: deletion of output file (apparently) failed.", 0, false );
+ }
+ exit( retval );
+ }
+
+
+/* assure at least a minimum size for buffer 'buf' */
+static void * resize_buffer( void * buf, const int min_size )
+ {
+ if( buf ) buf = realloc( buf, min_size );
+ else buf = malloc( min_size );
+ if( !buf )
+ {
+ show_error( "Not enough memory.", 0, false );
+ cleanup_and_fail( 1 );
+ }
+ return buf;
+ }
+
+
+static void set_c_outname( const char * const name )
+ {
+ output_filename = resize_buffer( output_filename, strlen( name ) +
+ strlen( known_extensions[0].from ) + 1 );
+ strcpy( output_filename, name );
+ strcat( output_filename, known_extensions[0].from );
+ }
+
+
+static void set_d_outname( const char * const name, const int i )
+ {
+ if( i >= 0 )
+ {
+ const char * const from = known_extensions[i].from;
+ if( strlen( name ) > strlen( from ) )
+ {
+ output_filename = resize_buffer( output_filename, strlen( name ) +
+ strlen( known_extensions[0].to ) + 1 );
+ strcpy( output_filename, name );
+ strcpy( output_filename + strlen( name ) - strlen( from ),
+ known_extensions[i].to );
+ return;
+ }
+ }
+ output_filename = resize_buffer( output_filename, strlen( name ) + 4 + 1 );
+ strcpy( output_filename, name );
+ strcat( output_filename, ".out" );
+ if( verbosity >= 1 )
+ fprintf( stderr, "%s: Can't guess original name for '%s' -- using '%s'.\n",
+ program_name, name, output_filename );
+ }
+
+
+static bool open_outstream( const bool force )
+ {
+ int flags = O_CREAT | O_WRONLY | o_binary;
+ if( force ) flags |= O_TRUNC; else flags |= O_EXCL;
+
+ outfd = open( output_filename, flags, outfd_mode );
+ if( outfd < 0 && verbosity >= 0 )
+ {
+ if( errno == EEXIST )
+ fprintf( stderr, "%s: Output file '%s' already exists, skipping.\n",
+ program_name, output_filename );
+ else
+ fprintf( stderr, "%s: Can't create output file '%s': %s.\n",
+ program_name, output_filename, strerror( errno ) );
+ }
+ return ( outfd >= 0 );
+ }
+
+
+static bool check_tty( const int infd, const enum Mode program_mode )
+ {
+ if( program_mode == m_compress && outfd >= 0 && isatty( outfd ) )
+ {
+ show_error( "I won't write compressed data to a terminal.", 0, true );
+ return false;
+ }
+ if( ( program_mode == m_decompress || program_mode == m_test ) &&
+ isatty( infd ) )
+ {
+ show_error( "I won't read compressed data from a terminal.", 0, true );
+ return false;
+ }
+ return true;
+ }
+
+
+ /* Set permissions, owner and times. */
+static void close_and_set_permissions( const struct stat * const in_statsp )
+ {
+ bool warning = false;
+ if( in_statsp )
+ {
+ /* fchown will in many cases return with EPERM, which can be safely ignored. */
+ if( ( fchown( outfd, in_statsp->st_uid, in_statsp->st_gid ) != 0 &&
+ errno != EPERM ) ||
+ fchmod( outfd, in_statsp->st_mode ) != 0 ) warning = true;
+ }
+ if( close( outfd ) != 0 ) cleanup_and_fail( 1 );
+ outfd = -1;
+ delete_output_on_interrupt = false;
+ if( in_statsp )
+ {
+ struct utimbuf t;
+ t.actime = in_statsp->st_atime;
+ t.modtime = in_statsp->st_mtime;
+ if( utime( output_filename, &t ) != 0 ) warning = true;
+ }
+ if( warning && verbosity >= 1 )
+ show_error( "Can't change output file attributes.", 0, false );
+ }
+
+
+static int compress( const struct Lzma_options * const encoder_options,
+ const int infd, struct Pretty_print * const pp )
+ {
+ int retval = 0;
+ File_header header;
+ CLzmaEncHandle encoder;
+
+ if( verbosity >= 1 ) Pp_show_msg( pp, 0 );
+ Fh_set_magic( header );
+ if( !Fh_set_dictionary_size( header, encoder_options->dictionary_size ) ||
+ encoder_options->match_len_limit < min_match_len_limit ||
+ encoder_options->match_len_limit > max_match_len )
+ internal_error( "invalid argument to encoder" );
+
+ encoder = LzmaEnc_Init( Fh_get_dictionary_size( header ),
+ encoder_options->match_len_limit, infd, outfd );
+ if( !encoder )
+ {
+ Pp_show_msg( pp, "Not enough memory. Try a smaller dictionary size" );
+ return 1;
+ }
+
+ if( writeblock( outfd, header, Fh_size ) != Fh_size )
+ { show_error( "Can not write output file", errno, false ); retval = 1; }
+ else
+ if( LzmaEnc_Encode( encoder ) != 0 )
+ { Pp_show_msg( pp, "Encoder error" ); retval = 1; }
+ LzmaEnc_Free( encoder );
+ return retval;
+ }
+
+
+#define IN_BUF_SIZE (1 << 16)
+#define OUT_BUF_SIZE (1 << 16)
+
+static bool read_inbuf( const int infd, uint8_t inBuf[],
+ int * const inPos, int * const inSize )
+ {
+ int rest;
+ if( *inPos >= *inSize ) *inSize = 0;
+ else if( *inPos > 0 )
+ {
+ memmove( inBuf, inBuf + *inPos, *inSize - *inPos );
+ *inSize -= *inPos;
+ }
+ *inPos = 0;
+ rest = IN_BUF_SIZE - *inSize;
+ if( rest > 0 )
+ {
+ const int rd = readblock( infd, inBuf + *inSize, rest );
+ if( rd < rest && errno )
+ { show_error( "Read error", errno, false ); return false; }
+ *inSize += rd;
+ }
+ return true;
+ }
+
+
+static int lzma_decode( uint64_t unpackSize, CLzmaDec *decoder, const int infd,
+ uint8_t inBuf[], int * const inPos,
+ int * const inSize, const bool testing )
+ {
+ unsigned long long total_in = 13, total_out = 0;
+ uint8_t outBuf[OUT_BUF_SIZE];
+ int outPos = 0;
+ const bool thereIsSize = (unpackSize != (uint64_t)-1);
+
+ for (;;)
+ {
+ uint32_t inProcessed;
+ uint32_t outProcessed = OUT_BUF_SIZE - outPos;
+ ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+ ELzmaStatus status;
+
+ if( *inPos >= *inSize && !read_inbuf( infd, inBuf, inPos, inSize ) )
+ return 1;
+ inProcessed = *inSize - *inPos;
+ if (thereIsSize && outProcessed > unpackSize)
+ {
+ outProcessed = unpackSize;
+ finishMode = LZMA_FINISH_END;
+ }
+
+ if( !LzmaDec_DecodeToBuf( decoder, outBuf + outPos, &outProcessed,
+ inBuf + *inPos, &inProcessed, finishMode, &status ) )
+ { show_error( "Data error.", 0, false ); return 1; }
+ *inPos += inProcessed;
+ total_in += inProcessed;
+ outPos += outProcessed;
+ unpackSize -= outProcessed;
+
+ if( outfd >= 0 && writeblock( outfd, outBuf, outPos ) != outPos )
+ { show_error( "Can not write output file", errno, false ); return 1; }
+
+ total_out += outPos;
+ outPos = 0;
+
+ if( ( inProcessed == 0 && outProcessed == 0 ) ||
+ ( thereIsSize && unpackSize == 0 ) )
+ {
+ if( ( thereIsSize && unpackSize != 0 ) ||
+ ( !thereIsSize && status != LZMA_STATUS_FINISHED_WITH_MARK ) )
+ { show_error( "Data error.", 0, false ); return 1; }
+ if( verbosity >= 2 )
+ fprintf( stderr, "lzma-alone, dictionary size %7sB. ",
+ format_num( decoder->dicBufSize ) );
+ if( verbosity >= 3 )
+ fprintf( stderr, "uncompressed size %9llu, compressed size %8llu. ",
+ total_out, total_in );
+ if( verbosity >= 1 )
+ { if( testing ) fprintf( stderr, "(apparently) ok\n" );
+ else fprintf( stderr, "(apparently) done\n" ); }
+ return 0;
+ }
+ }
+ }
+
+
+static int lzip_decode( CLzmaDec *decoder, const int infd, uint8_t inBuf[],
+ int * const inPos, int * const inSize,
+ const int member_version )
+ {
+ unsigned long long total_in = Fh_size, total_out = 0;
+ uint8_t outBuf[OUT_BUF_SIZE];
+ int outPos = 0;
+ uint32_t crc = 0xFFFFFFFFU;
+
+ for (;;)
+ {
+ uint32_t inProcessed;
+ uint32_t outProcessed = OUT_BUF_SIZE - outPos;
+ ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+ ELzmaStatus status;
+
+ if( *inPos >= *inSize && !read_inbuf( infd, inBuf, inPos, inSize ) )
+ return 1;
+ if( *inPos >= *inSize )
+ { show_error( "Unexpected EOF.", 0, false ); return 1; }
+ inProcessed = *inSize - *inPos;
+
+ if( !LzmaDec_DecodeToBuf( decoder, outBuf + outPos, &outProcessed,
+ inBuf + *inPos, &inProcessed, finishMode, &status ) )
+ { show_error( "Data error.", 0, false ); return 1; }
+ *inPos += inProcessed;
+ total_in += inProcessed;
+ outPos += outProcessed;
+
+ if( outfd >= 0 && writeblock( outfd, outBuf, outPos ) != outPos )
+ { show_error( "Can not write output file", errno, false ); return 1; }
+
+ CRC32_update_buf( &crc, outBuf, outPos );
+ total_out += outPos;
+ outPos = 0;
+
+ if (inProcessed == 0 && outProcessed == 0)
+ {
+ File_trailer trailer;
+ int i;
+ const int trailer_size = Ft_versioned_size( member_version );
+ bool error = false;
+
+ if( status != LZMA_STATUS_FINISHED_WITH_MARK )
+ { show_error( "Data error.", 0, false ); return 1; }
+ if( *inSize - *inPos < trailer_size &&
+ !read_inbuf( infd, inBuf, inPos, inSize ) ) return 1;
+ if( *inSize - *inPos < trailer_size )
+ {
+ error = true;
+ if( verbosity >= 0 )
+ fprintf( stderr, "Trailer truncated at trailer position %u;"
+ " some checks may fail.\n",
+ (unsigned)(*inSize - *inPos) );
+ for( i = *inSize - *inPos; i < trailer_size; ++i )
+ inBuf[*inPos+i] = 0;
+ }
+ for( i = 0; i < trailer_size; ++i )
+ trailer[i] = inBuf[(*inPos)++];
+ total_in += trailer_size;
+ if( member_version == 0 ) Ft_set_member_size( trailer, total_in );
+ if( Ft_get_data_crc( trailer ) != ( crc ^ 0xFFFFFFFFU ) )
+ {
+ error = true;
+ if( verbosity >= 0 )
+ fprintf( stderr, "CRC mismatch; trailer says %08X, data crc is %08X.\n",
+ Ft_get_data_crc( trailer ), crc ^ 0xFFFFFFFFU );
+ }
+ if( Ft_get_data_size( trailer ) != total_out )
+ {
+ error = true;
+ if( verbosity >= 0 )
+ fprintf( stderr, "Data size mismatch; trailer says %llu, data size is %llu (0x%llX).\n",
+ Ft_get_data_size( trailer ), total_out, total_out );
+ }
+ if( Ft_get_member_size( trailer ) != total_in )
+ {
+ error = true;
+ if( verbosity >= 0 )
+ fprintf( stderr, "Member size mismatch; trailer says %llu, member size is %llu (0x%llX).\n",
+ Ft_get_member_size( trailer ), total_in, total_in );
+ }
+ if( !error && verbosity >= 3 && total_out > 0 && total_in > 0 )
+ fprintf( stderr, "%6.3f:1, %6.3f bits/byte, %5.2f%% saved. ",
+ (double)total_out / total_in,
+ ( 8.0 * total_in ) / total_out,
+ 100.0 * ( 1.0 - ( (double)total_in / total_out ) ) );
+ if( !error && verbosity >= 4 )
+ fprintf( stderr, "data CRC %08X, data size %9llu, member size %8llu. ",
+ Ft_get_data_crc( trailer ),
+ Ft_get_data_size( trailer ), Ft_get_member_size( trailer ) );
+ if( error ) return 2;
+ return 0;
+ }
+ }
+ }
+
+
+static int decompress( const int infd, struct Pretty_print * const pp,
+ const bool testing )
+ {
+ uint64_t unpackSize = 0;
+ CLzmaDec decoder;
+ uint8_t inBuf[IN_BUF_SIZE];
+ int inPos = 0, inSize = 0;
+ int retval = 0;
+ bool lzip_mode = true;
+ bool first_member;
+ /* 5 bytes of LZMA properties and 8 bytes of uncompressed size */
+ uint8_t raw_props[LZMA_PROPS_SIZE+8];
+
+ for( first_member = true; ; first_member = false )
+ {
+ int i;
+ File_header header;
+ if( inSize - inPos < Fh_size &&
+ !read_inbuf( infd, inBuf, &inPos, &inSize ) ) return 1;
+ if( inSize - inPos < Fh_size ) /* End Of File */
+ {
+ if( first_member )
+ { Pp_show_msg( pp, "Error reading member header" ); retval = 1; }
+ break;
+ }
+ for( i = 0; i < Fh_size; ++i ) raw_props[i] = header[i] = inBuf[inPos++];
+ if( !Fh_verify_magic( header ) )
+ {
+ if( !first_member ) break; /* trailing garbage */
+ if( inSize - inPos >= 13 - Fh_size ) /* try lzma-alone */
+ {
+ for( i = Fh_size; i < 13; ++i ) raw_props[i] = inBuf[inPos++];
+ for( i = 0; i < 8; ++i )
+ unpackSize += (uint64_t)raw_props[LZMA_PROPS_SIZE+i] << (i * 8);
+ if( ( raw_props[12] == 0 || raw_props[12] == 0xFF ) &&
+ raw_props[12] == raw_props[11] && raw_props[0] < (9 * 5 * 5) )
+ lzip_mode = false;
+ }
+ if( lzip_mode )
+ {
+ Pp_show_msg( pp, "Bad magic number (file not in lzip format)" );
+ retval = 2; break;
+ }
+ }
+ if( lzip_mode )
+ {
+ int ds, i;
+ if( !Fh_verify_version( header ) )
+ {
+ if( verbosity >= 0 )
+ { Pp_show_msg( pp, 0 );
+ fprintf( stderr, "Version %d member format not supported.\n",
+ Fh_version( header ) ); }
+ retval = 2; break;
+ }
+ if( Fh_get_dictionary_size( header ) < min_dictionary_size ||
+ Fh_get_dictionary_size( header ) > max_dictionary_size )
+ { Pp_show_msg( pp, "Invalid dictionary size in member header" );
+ retval = 2; break; }
+
+ raw_props[0] = 93; /* (45 * 2) + (9 * 0) + 3 */
+ ds = Fh_get_dictionary_size( header );
+ for( i = 1; i <= 4; ++i ) { raw_props[i] = ds & 0xFF; ds >>= 8; }
+ }
+
+ if( verbosity >= 2 || ( verbosity == 1 && first_member ) )
+ {
+ Pp_show_msg( pp, 0 );
+ if( lzip_mode && verbosity >= 2 ) show_header( header );
+ }
+
+ if( !LzmaDec_Init( &decoder, raw_props ) )
+ {
+ show_error( "Not enough memory. Find a machine with more memory.", 0, false );
+ cleanup_and_fail( 1 );
+ }
+ if( lzip_mode )
+ retval = lzip_decode( &decoder, infd, inBuf, &inPos, &inSize,
+ Fh_version( header ) );
+ else
+ retval = lzma_decode( unpackSize, &decoder, infd,
+ inBuf, &inPos, &inSize, testing );
+ LzmaDec_Free(&decoder);
+ if( retval != 0 || !lzip_mode ) break;
+ if( verbosity >= 2 )
+ { if( testing ) fprintf( stderr, "ok\n" );
+ else fprintf( stderr, "done\n" ); Pp_reset( pp ); }
+ }
+ if( lzip_mode && verbosity == 1 && retval == 0 )
+ { if( testing ) fprintf( stderr, "ok\n" );
+ else fprintf( stderr, "done\n" ); }
+ return retval;
+ }
+
+
+void signal_handler( int sig )
+ {
+ if( sig ) {} /* keep compiler happy */
+ show_error( "Control-C or similar caught, quitting.", 0, false );
+ cleanup_and_fail( 1 );
+ }
+
+
+static void set_signals( void )
+ {
+ signal( SIGHUP, signal_handler );
+ signal( SIGINT, signal_handler );
+ signal( SIGTERM, signal_handler );
+ }
+
+
+void Pp_init( struct Pretty_print * const pp, const char * const filenames[],
+ const int num_filenames, const int v )
+ {
+ unsigned stdin_name_len;
+ int i;
+ pp->name = 0;
+ pp->stdin_name = "(stdin)";
+ pp->longest_name = 0;
+ pp->verbosity = v;
+ pp->first_post = false;
+ stdin_name_len = strlen( pp->stdin_name );
+
+ for( i = 0; i < num_filenames; ++i )
+ {
+ const char * const s = filenames[i];
+ const int len = ( (strcmp( s, "-" ) == 0) ? stdin_name_len : strlen( s ) );
+ if( len > pp->longest_name ) pp->longest_name = len;
+ }
+ if( pp->longest_name == 0 ) pp->longest_name = stdin_name_len;
+ }
+
+
+void Pp_show_msg( struct Pretty_print * const pp, const char * const msg )
+ {
+ if( verbosity >= 0 )
+ {
+ if( pp->first_post )
+ {
+ int i, len;
+ pp->first_post = false;
+ fprintf( stderr, " %s: ", pp->name );
+ len = pp->longest_name - strlen( pp->name );
+ for( i = 0; i < len; ++i ) fprintf( stderr, " " );
+ if( !msg ) fflush( stderr );
+ }
+ if( msg ) fprintf( stderr, "%s.\n", msg );
+ }
+ }
+
+
+void show_error( const char * const msg, const int errcode, const bool help )
+ {
+ if( verbosity >= 0 )
+ {
+ if( msg && msg[0] )
+ {
+ fprintf( stderr, "%s: %s", program_name, msg );
+ if( errcode > 0 ) fprintf( stderr, ": %s", strerror( errcode ) );
+ fprintf( stderr, "\n" );
+ }
+ if( help )
+ fprintf( stderr, "Try '%s --help' for more information.\n",
+ invocation_name );
+ }
+ }
+
+
+void internal_error( const char * const msg )
+ {
+ if( verbosity >= 0 )
+ fprintf( stderr, "%s: internal error: %s.\n", program_name, msg );
+ exit( 3 );
+ }
+
+
+int main( const int argc, const char * const argv[] )
+ {
+ /* Mapping from gzip/bzip2 style 1..9 compression modes
+ to the corresponding LZMA compression modes. */
+ const struct Lzma_options option_mapping[] =
+ {
+ { 1 << 20, 5 }, /* -0 */
+ { 1 << 20, 5 }, /* -1 */
+ { 3 << 19, 6 }, /* -2 */
+ { 1 << 21, 8 }, /* -3 */
+ { 3 << 20, 12 }, /* -4 */
+ { 1 << 22, 20 }, /* -5 */
+ { 1 << 23, 36 }, /* -6 */
+ { 1 << 24, 68 }, /* -7 */
+ { 3 << 23, 132 }, /* -8 */
+ { 1 << 25, 273 } }; /* -9 */
+ struct Lzma_options encoder_options = option_mapping[6]; /* default = "-6" */
+ const char * input_filename = "";
+ const char * default_output_filename = "";
+ const char ** filenames = 0;
+ int num_filenames = 0;
+ int infd = -1;
+ enum Mode program_mode = m_compress;
+ int argind = 0;
+ int retval = 0;
+ int i;
+ bool filenames_given = false;
+ bool force = false;
+ bool keep_input_files = false;
+ bool recompress = false;
+ bool to_stdout = false;
+ struct Pretty_print pp;
+
+ const struct ap_Option options[] =
+ {
+ { '0', "fast", ap_no },
+ { '1', 0, ap_no },
+ { '2', 0, ap_no },
+ { '3', 0, ap_no },
+ { '4', 0, ap_no },
+ { '5', 0, ap_no },
+ { '6', 0, ap_no },
+ { '7', 0, ap_no },
+ { '8', 0, ap_no },
+ { '9', "best", ap_no },
+ { 'b', "member-size", ap_yes },
+ { 'c', "stdout", ap_no },
+ { 'd', "decompress", ap_no },
+ { 'f', "force", ap_no },
+ { 'F', "recompress", ap_no },
+ { 'h', "help", ap_no },
+ { 'k', "keep", ap_no },
+ { 'm', "match-length", ap_yes },
+ { 'o', "output", ap_yes },
+ { 'q', "quiet", ap_no },
+ { 's', "dictionary-size", ap_yes },
+ { 'S', "volume-size", ap_yes },
+ { 't', "test", ap_no },
+ { 'v', "verbose", ap_no },
+ { 'V', "version", ap_no },
+ { 0 , 0, ap_no } };
+
+ struct Arg_parser parser;
+
+ invocation_name = argv[0];
+ CRC32_init();
+
+ if( !ap_init( &parser, argc, argv, options, 0 ) )
+ { show_error( "Memory exhausted.", 0, false ); return 1; }
+ if( ap_error( &parser ) ) /* bad option */
+ { show_error( ap_error( &parser ), 0, true ); return 1; }
+
+ for( ; argind < ap_arguments( &parser ); ++argind )
+ {
+ const int code = ap_code( &parser, argind );
+ const char * const arg = ap_argument( &parser, argind );
+ if( !code ) break; /* no more options */
+ switch( code )
+ {
+ case '0':
+ case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ encoder_options = option_mapping[code-'0']; break;
+ case 'b': break;
+ case 'c': to_stdout = true; break;
+ case 'd': program_mode = m_decompress; break;
+ case 'f': force = true; break;
+ case 'F': recompress = true; break;
+ case 'h': show_help(); return 0;
+ case 'k': keep_input_files = true; break;
+ case 'm': encoder_options.match_len_limit =
+ getnum( arg, min_match_len_limit, max_match_len ); break;
+ case 'o': default_output_filename = arg; break;
+ case 'q': verbosity = -1; break;
+ case 's': encoder_options.dictionary_size = get_dict_size( arg );
+ break;
+ case 'S': break;
+ case 't': program_mode = m_test; break;
+ case 'v': if( verbosity < 4 ) ++verbosity; break;
+ case 'V': show_version(); return 0;
+ default : internal_error( "uncaught option" );
+ }
+ } /* end process options */
+
+#if defined(__MSVCRT__) || defined(__OS2__)
+ setmode( STDIN_FILENO, O_BINARY );
+ setmode( STDOUT_FILENO, O_BINARY );
+#endif
+
+ if( program_mode == m_test )
+ outfd = -1;
+
+ num_filenames = max( 1, ap_arguments( &parser ) - argind );
+ filenames = resize_buffer( filenames, num_filenames * sizeof filenames[0] );
+ filenames[0] = "-";
+
+ for( i = 0; argind + i < ap_arguments( &parser ); ++i )
+ {
+ filenames[i] = ap_argument( &parser, argind + i );
+ if( strcmp( filenames[i], "-" ) != 0 ) filenames_given = true;
+ }
+
+ if( !to_stdout && program_mode != m_test &&
+ ( filenames_given || default_output_filename[0] ) )
+ set_signals();
+
+ Pp_init( &pp, filenames, num_filenames, verbosity );
+
+ output_filename = resize_buffer( output_filename, 1 );
+ for( i = 0; i < num_filenames; ++i )
+ {
+ int tmp;
+ struct stat in_stats;
+ const struct stat * in_statsp;
+ output_filename[0] = 0;
+
+ if( !filenames[i][0] || strcmp( filenames[i], "-" ) == 0 )
+ {
+ input_filename = "";
+ infd = STDIN_FILENO;
+ if( program_mode != m_test )
+ {
+ if( to_stdout || !default_output_filename[0] )
+ outfd = STDOUT_FILENO;
+ else
+ {
+ if( program_mode == m_compress )
+ set_c_outname( default_output_filename );
+ else
+ {
+ output_filename = resize_buffer( output_filename,
+ strlen( default_output_filename ) + 1 );
+ strcpy( output_filename, default_output_filename );
+ }
+ outfd_mode = all_rw;
+ if( !open_outstream( force ) )
+ {
+ if( retval < 1 ) retval = 1;
+ close( infd ); infd = -1;
+ continue;
+ }
+ }
+ }
+ }
+ else
+ {
+ const int eindex = extension_index( filenames[i] );
+ input_filename = filenames[i];
+ infd = open_instream( input_filename, &in_stats, program_mode,
+ eindex, recompress, to_stdout );
+ if( infd < 0 ) { if( retval < 1 ) retval = 1; continue; }
+ if( program_mode != m_test )
+ {
+ if( to_stdout ) outfd = STDOUT_FILENO;
+ else
+ {
+ if( program_mode == m_compress )
+ set_c_outname( input_filename );
+ else set_d_outname( input_filename, eindex );
+ outfd_mode = usr_rw;
+ if( !open_outstream( force ) )
+ {
+ if( retval < 1 ) retval = 1;
+ close( infd ); infd = -1;
+ continue;
+ }
+ }
+ }
+ }
+
+ if( !check_tty( infd, program_mode ) ) return 1;
+
+ if( output_filename[0] && !to_stdout && program_mode != m_test )
+ delete_output_on_interrupt = true;
+ in_statsp = input_filename[0] ? &in_stats : 0;
+ Pp_set_name( &pp, input_filename );
+ if( program_mode == m_compress )
+ tmp = compress( &encoder_options, infd, &pp );
+ else
+ tmp = decompress( infd, &pp, program_mode == m_test );
+ if( tmp > retval ) retval = tmp;
+ if( tmp && program_mode != m_test ) cleanup_and_fail( retval );
+
+ if( delete_output_on_interrupt )
+ close_and_set_permissions( in_statsp );
+ if( input_filename[0] )
+ {
+ close( infd ); infd = -1;
+ if( !keep_input_files && !to_stdout && program_mode != m_test )
+ remove( input_filename );
+ }
+ }
+ if( outfd >= 0 && close( outfd ) != 0 )
+ {
+ show_error( "Can't close stdout", errno, false );
+ if( retval < 1 ) retval = 1;
+ }
+ free( output_filename );
+ free( filenames );
+ ap_free( &parser );
+ return retval;
+ }
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-02 10:12:27 +0000