Merging upstream version 0.6.
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
parent
e39d8907e0
commit
f4329ad86e
GPG key ID:
FBB4F0E80A80222F
13 changed files with 378 additions and 275 deletions
|
|
@ -1,3 +1,11 @@
|
|||
2020-06-24 Antonio Diaz Diaz <antonio@gnu.org>
|
||||
|
||||
* Version 0.6 released.
|
||||
* Make '-o' behave like '-c', but writing to file instead of stdout.
|
||||
* in_place.c: Multimember decompression should now work for any file
|
||||
that fits in memory and is smaller than (LONG_MAX - extra_bytes).
|
||||
* README: Add an analysis of the in-place decompression.
|
||||
|
||||
2020-04-27 Antonio Diaz Diaz <antonio@gnu.org>
|
||||
|
||||
* Version 0.5 released.
|
||||
|
|
|
|||
6
INSTALL
6
INSTALL
|
|
@ -1,6 +1,6 @@
|
|||
Requirements
|
||||
------------
|
||||
You will need a C compiler.
|
||||
You will need a C99 compiler. (gcc 2.95 or newer is recommended).
|
||||
I use gcc 6.1.0 and 4.1.2, but the code should compile with any standards
|
||||
compliant compiler.
|
||||
Gcc is available at http://gcc.gnu.org.
|
||||
|
|
@ -41,8 +41,8 @@ the main archive.
|
|||
documentation.
|
||||
|
||||
Or type 'make install-compress', which additionally compresses the
|
||||
man page after installation. (Installing compressed docs may become
|
||||
the default in the future).
|
||||
man page after installation.
|
||||
(Installing compressed docs may become the default in the future).
|
||||
|
||||
You can install only the program or the man page by typing
|
||||
'make install-bin' or 'make install-man' respectively.
|
||||
|
|
|
|||
35
NEWS
35
NEWS
|
|
@ -1,22 +1,19 @@
|
|||
Changes in version 0.5:
|
||||
Changes in version 0.6:
|
||||
|
||||
The lzip_decompress module has been updated to version 5.4.18.
|
||||
Option '-o, --output' now behaves like '-c, --stdout', but sending the
|
||||
output unconditionally to a file instead of to standard output. See the new
|
||||
description of '-o' in the manual. This change is not backwards compatible.
|
||||
Therefore commands like:
|
||||
xlunzip -d -o foo - bar.lz < foo.lz
|
||||
must now be split into:
|
||||
xlunzip -d -o foo - < foo.lz
|
||||
xlunzip -d bar.lz
|
||||
or rewritten as:
|
||||
xlunzip -d - bar.lz < foo.lz > foo
|
||||
|
||||
Xlunzip now reports an error if a file name is empty (xlunzip -t "").
|
||||
In-place decompression of concatenated files should now work for any
|
||||
combination of files as long as they fit in memory and their total
|
||||
decompressed size is smaller than LONG_MAX minus a small extra space.
|
||||
|
||||
The words 'decompressed' and 'compressed' have been replaced with the
|
||||
shorter 'out' and 'in' in the verbose output when decompressing or testing.
|
||||
|
||||
Decompression speed has been slightly increased.
|
||||
|
||||
A compilation error with GCC 10 has been fixed. (Reported by Daniel Baumann).
|
||||
|
||||
The commands needed to extract files from a tar.lz archive have been
|
||||
documented in the output of '--help' and in the man page.
|
||||
|
||||
Xlunzip now compiles on DOS with DJGPP. (Patch from Robert Riebisch).
|
||||
|
||||
The configure script now accepts appending options to CFLAGS using the
|
||||
syntax 'CFLAGS+=OPTIONS'.
|
||||
|
||||
9 new test files have been added to the testsuite.
|
||||
The README file now includes an analysis of the amount of memory required
|
||||
for in-place decompression.
|
||||
|
|
|
|||
96
README
96
README
|
|
@ -1,25 +1,23 @@
|
|||
Description
|
||||
|
||||
Xlunzip is a test tool for the lzip decompression code of my lzip patch
|
||||
for linux. Xlunzip is similar to lunzip, but it uses the lzip_decompress
|
||||
linux module as a backend. Xlunzip tests the module for stream,
|
||||
buffer-to-buffer and mixed decompression modes, including in-place
|
||||
decompression (using the same buffer for input and output). You can use
|
||||
xlunzip to verify that the module produces correct results when
|
||||
decompressing single member files, multimember files, or the
|
||||
concatenation of two or more compressed files. Xlunzip can be used with
|
||||
unzcrash to test the robustness of the module to the decompression of
|
||||
corrupted data.
|
||||
Xlunzip is a test tool for the lzip decompression code of my lzip patch for
|
||||
linux. Xlunzip is similar to lunzip, but it uses the lzip_decompress linux
|
||||
module as a backend. Xlunzip tests the module for stream, buffer-to-buffer,
|
||||
and mixed decompression modes, including in-place decompression (using the
|
||||
same buffer for input and output). You can use xlunzip to verify that the
|
||||
module produces correct results when decompressing single member files,
|
||||
multimember files, or the concatenation of two or more compressed files.
|
||||
Xlunzip can be used with unzcrash to test the robustness of the module to
|
||||
the decompression of corrupted data.
|
||||
|
||||
Note that the in-place decompression of concatenated files can't be
|
||||
guaranteed to work because an arbitrarily low compression ratio of the
|
||||
last part of the data can be achieved by appending enough empty
|
||||
compressed members to a file, masking a high compression ratio at the
|
||||
beginning of the data.
|
||||
The distributed index feature of the lzip format allows xlunzip to
|
||||
decompress concatenated files in place. This can't be guaranteed to work
|
||||
with formats like gzip or bzip2 because they can't detect whether a high
|
||||
compression ratio in the first members of the multimember data is being
|
||||
masked by a low compression ratio in the last members.
|
||||
|
||||
The xlunzip tarball contains a copy of the lzip_decompress module and
|
||||
can be compiled and tested without downloading or applying the patch to
|
||||
the kernel.
|
||||
The xlunzip tarball contains a copy of the lzip_decompress module and can be
|
||||
compiled and tested without downloading or applying the patch to the kernel.
|
||||
|
||||
My lzip patch for linux can be found at
|
||||
http://download.savannah.gnu.org/releases/lzip/kernel/
|
||||
|
|
@ -29,14 +27,72 @@ Lzip related components in the kernel
|
|||
|
||||
The lzip_decompress module in lib/lzip_decompress.c provides a versatile
|
||||
lzip decompression function able to do buffer to buffer decompression or
|
||||
stream decompression with fill and flush callback functions. The usage
|
||||
of the function is documented in include/linux/lzip.h.
|
||||
stream decompression with fill and flush callback functions. The usage of
|
||||
the function is documented in include/linux/lzip.h.
|
||||
|
||||
For decompressing the kernel image, initramfs, and initrd, there is a
|
||||
wrapper function in lib/decompress_lunzip.c providing the same common
|
||||
interface as the other decompress_*.c files, which is defined in
|
||||
include/linux/decompress/generic.h.
|
||||
|
||||
Analysis of the in-place decompression
|
||||
======================================
|
||||
|
||||
In order to decompress the kernel in place (using the same buffer for input
|
||||
and output), the compressed data is placed at the end of the buffer used to
|
||||
hold the decompressed data. The buffer must be large enough to contain after
|
||||
the decompressed data extra space for a marker, a trailer, the maximum
|
||||
possible data expansion, and (if the compressed data consists of more than
|
||||
one member) N-1 empty members.
|
||||
|
||||
|------ compressed data ------|
|
||||
V V
|
||||
|----------------|-------------------|---------|
|
||||
^ ^ extra
|
||||
|-------- decompressed data ---------|
|
||||
|
||||
The input pointer initially points to the beginning of the compressed data
|
||||
and the output pointer initially points to the beginning of the buffer.
|
||||
Decompressing compressible data reduces the distance between the pointers,
|
||||
while decompressing uncompressible data increases the distance. The extra
|
||||
space must be large enough that the output pointer does not overrun the
|
||||
input pointer even if all the overlap between compressed and decompressed
|
||||
data is uncompressible. The worst case is very compressible data followed by
|
||||
uncompressible data because in this case the output pointer increases faster
|
||||
when the input pointer is smaller.
|
||||
|
||||
| * <-- input pointer
|
||||
| * , <-- output pointer
|
||||
| * , '
|
||||
| x ' <-- overrun (x)
|
||||
memory | * ,'
|
||||
address | * ,'
|
||||
|* ,'
|
||||
| ,'
|
||||
| ,'
|
||||
|,'
|
||||
`--------------------------
|
||||
time
|
||||
|
||||
All we need to know to calculate the minimum required extra space is:
|
||||
The maximum expansion ratio.
|
||||
The size of the last part of a member required to verify integrity.
|
||||
For multimember data, the overhead per member. (36 bytes for lzip).
|
||||
|
||||
The maximum expansion ratio of LZMA data is of about 1.4%. Rounding this up
|
||||
to 1/64 (1.5625%) and adding 36 bytes per input member, the extra space
|
||||
required to decompress lzip data in place is:
|
||||
extra_bytes = ( compressed_size >> 6 ) + members * 36
|
||||
|
||||
Using the compressed size to calculate the extra_bytes (as in the equation
|
||||
above) may slightly overestimate the amount of space required in the worst
|
||||
case. But calculating the extra_bytes from the uncompressed size (as does
|
||||
linux) is wrong (and inefficient for high compression ratios). The formula
|
||||
used in arch/x86/boot/header.S
|
||||
extra_bytes = (uncompressed_size >> 8) + 65536
|
||||
fails with 1 MB of zeros followed by 8 MB of random data, and wastes memory
|
||||
for compression ratios > 4:1.
|
||||
|
||||
|
||||
Copyright (C) 2016-2020 Antonio Diaz Diaz.
|
||||
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ void ap_free( struct Arg_parser * const ap );
|
|||
|
||||
const char * ap_error( const struct Arg_parser * const ap );
|
||||
|
||||
/* The number of arguments parsed (may be different from argc) */
|
||||
/* The number of arguments parsed. May be different from argc. */
|
||||
int ap_arguments( const struct Arg_parser * const ap );
|
||||
|
||||
/* If ap_code( i ) is 0, ap_argument( i ) is a non-option.
|
||||
|
|
|
|||
11
configure
vendored
11
configure
vendored
|
|
@ -6,7 +6,7 @@
|
|||
# to copy, distribute, and modify it.
|
||||
|
||||
pkgname=xlunzip
|
||||
pkgversion=0.5
|
||||
pkgversion=0.6
|
||||
progname=xlunzip
|
||||
srctrigger=doc/${progname}.1
|
||||
|
||||
|
|
@ -26,11 +26,7 @@ CFLAGS='-Wall -W -O2'
|
|||
LDFLAGS=
|
||||
|
||||
# checking whether we are using GNU C.
|
||||
/bin/sh -c "${CC} --version" > /dev/null 2>&1 ||
|
||||
{
|
||||
CC=cc
|
||||
CFLAGS=-O2
|
||||
}
|
||||
/bin/sh -c "${CC} --version" > /dev/null 2>&1 || { CC=cc ; CFLAGS=-O2 ; }
|
||||
|
||||
# Loop over all args
|
||||
args=
|
||||
|
|
@ -42,7 +38,8 @@ while [ $# != 0 ] ; do
|
|||
shift
|
||||
|
||||
# Add the argument quoted to args
|
||||
args="${args} \"${option}\""
|
||||
if [ -z "${args}" ] ; then args="\"${option}\""
|
||||
else args="${args} \"${option}\"" ; fi
|
||||
|
||||
# Split out the argument for options that take them
|
||||
case ${option} in
|
||||
|
|
|
|||
|
|
@ -1,27 +1,26 @@
|
|||
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.46.1.
|
||||
.TH XLUNZIP "1" "April 2020" "xlunzip 0.5" "User Commands"
|
||||
.TH XLUNZIP "1" "June 2020" "xlunzip 0.6" "User Commands"
|
||||
.SH NAME
|
||||
xlunzip \- test tool for the lzip_decompress linux module
|
||||
.SH SYNOPSIS
|
||||
.B xlunzip
|
||||
[\fI\,options\/\fR] [\fI\,files\/\fR]
|
||||
.SH DESCRIPTION
|
||||
Xlunzip is a test tool for the lzip decompression code of my lzip patch
|
||||
for linux. Xlunzip is similar to lunzip, but it uses the lzip_decompress
|
||||
linux module as a backend. Xlunzip tests the module for stream,
|
||||
buffer\-to\-buffer and mixed decompression modes, including in\-place
|
||||
decompression (using the same buffer for input and output). You can use
|
||||
xlunzip to verify that the module produces correct results when
|
||||
decompressing single member files, multimember files, or the
|
||||
concatenation of two or more compressed files. Xlunzip can be used with
|
||||
unzcrash to test the robustness of the module to the decompression of
|
||||
corrupted data.
|
||||
Xlunzip is a test tool for the lzip decompression code of my lzip patch for
|
||||
linux. Xlunzip is similar to lunzip, but it uses the lzip_decompress linux
|
||||
module as a backend. Xlunzip tests the module for stream, buffer\-to\-buffer,
|
||||
and mixed decompression modes, including in\-place decompression (using the
|
||||
same buffer for input and output). You can use xlunzip to verify that the
|
||||
module produces correct results when decompressing single member files,
|
||||
multimember files, or the concatenation of two or more compressed files.
|
||||
Xlunzip can be used with unzcrash to test the robustness of the module to
|
||||
the decompression of corrupted data.
|
||||
.PP
|
||||
Note that the in\-place decompression of concatenated files can't be
|
||||
guaranteed to work because an arbitrarily low compression ratio of the
|
||||
last part of the data can be achieved by appending enough empty
|
||||
compressed members to a file, masking a high compression ratio at the
|
||||
beginning of the data.
|
||||
The distributed index feature of the lzip format allows xlunzip to
|
||||
decompress concatenated files in place. This can't be guaranteed to work
|
||||
with formats like gzip or bzip2 because they can't detect whether a high
|
||||
compression ratio in the first members of the multimember data is being
|
||||
masked by a low compression ratio in the last members.
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
\fB\-h\fR, \fB\-\-help\fR
|
||||
|
|
@ -46,7 +45,7 @@ decompress or test using only one buffer
|
|||
keep (don't delete) input files
|
||||
.TP
|
||||
\fB\-o\fR, \fB\-\-output=\fR<file>
|
||||
if reading standard input, write to <file>
|
||||
write to <file>, keep input files
|
||||
.TP
|
||||
\fB\-q\fR, \fB\-\-quiet\fR
|
||||
suppress all messages
|
||||
|
|
|
|||
46
in_place.c
46
in_place.c
|
|
@ -58,8 +58,7 @@ static uint8_t * read_file( const int infd, long * const buffer_sizep,
|
|||
{
|
||||
long buffer_size = 1 << 20;
|
||||
uint8_t * buffer = (uint8_t *)malloc( buffer_size );
|
||||
if( !buffer )
|
||||
{ show_file_error( filename, "Not enough memory.", 0 ); return 0; }
|
||||
if( !buffer ) { show_file_error( filename, mem_msg, 0 ); return 0; }
|
||||
|
||||
long file_size = readblock( infd, buffer, buffer_size );
|
||||
while( file_size >= buffer_size && !errno )
|
||||
|
|
@ -70,8 +69,7 @@ static uint8_t * read_file( const int infd, long * const buffer_sizep,
|
|||
buffer_size = ( buffer_size <= LONG_MAX / 2 ) ? 2 * buffer_size : LONG_MAX;
|
||||
uint8_t * const tmp = (uint8_t *)realloc( buffer, buffer_size );
|
||||
if( !tmp )
|
||||
{ show_file_error( filename, "Not enough memory.", 0 ); free( buffer );
|
||||
return 0; }
|
||||
{ show_file_error( filename, mem_msg, 0 ); free( buffer ); return 0; }
|
||||
buffer = tmp;
|
||||
file_size += readblock( infd, buffer + file_size, buffer_size - file_size );
|
||||
}
|
||||
|
|
@ -88,6 +86,7 @@ struct File_sizes
|
|||
{
|
||||
unsigned long long csize;
|
||||
unsigned long long dsize;
|
||||
long members;
|
||||
long trailing;
|
||||
};
|
||||
|
||||
|
|
@ -102,7 +101,8 @@ static const char * set_file_sizes( struct File_sizes * const file_sizes,
|
|||
if( !Lh_verify_version( *header ) )
|
||||
return "Version of lzip member format not supported.";
|
||||
|
||||
file_sizes->csize = file_sizes->dsize = file_sizes->trailing = 0;
|
||||
file_sizes->csize = file_sizes->dsize = 0;
|
||||
file_sizes->members = file_sizes->trailing = 0;
|
||||
unsigned long pos = file_size; /* always points to a header or to EOF */
|
||||
while( pos >= min_member_size )
|
||||
{
|
||||
|
|
@ -137,6 +137,7 @@ static const char * set_file_sizes( struct File_sizes * const file_sizes,
|
|||
pos -= member_size;
|
||||
file_sizes->csize += member_size;
|
||||
file_sizes->dsize += Lt_get_data_size( *trailer );
|
||||
++file_sizes->members;
|
||||
}
|
||||
if( pos != 0 || file_sizes->csize == 0 ) return "Can't get file sizes.";
|
||||
if( file_sizes->csize + file_sizes->trailing != (unsigned long)file_size )
|
||||
|
|
@ -154,13 +155,15 @@ static void error(char *x) { show_file_error( global_name, x, 0 ); }
|
|||
/*
|
||||
* Load the compressed file at the end of the buffer used to hold the
|
||||
* decompressed data. Verify that the in-place decompression does not
|
||||
* overwrite the compressed data.
|
||||
* overwrite the compressed data. The buffer must be large enough to contain
|
||||
* after the decompressed data extra space for a marker, a trailer, the
|
||||
* maximum possible data expansion, and (if multimember) N-1 empty members.
|
||||
*
|
||||
* |----- compressed data ------|
|
||||
* |------ compressed data ------|
|
||||
* V V
|
||||
* |---------------|-------------------|--------|
|
||||
* ^ ^
|
||||
* |------- decompressed data ---------|
|
||||
* |----------------|-------------------|---------|
|
||||
* ^ ^ extra
|
||||
* |-------- decompressed data ---------|
|
||||
*/
|
||||
|
||||
int decompress_in_place( const int infd, struct Pretty_print * const pp,
|
||||
|
|
@ -175,19 +178,22 @@ int decompress_in_place( const int infd, struct Pretty_print * const pp,
|
|||
|
||||
const long csize = file_sizes.csize;
|
||||
const long dsize = file_sizes.dsize;
|
||||
/* const long trailing = file_sizes.trailing; */
|
||||
/* ( (csize-36+63) >> 6 ) + 36 never failed with single member */
|
||||
const long rextra = ( csize >> 5 ) + 72;
|
||||
if( buffer_size < dsize + rextra ) /* avoid realloc if big enough */
|
||||
/* const long extra_bytes = ( dsize >> 8 ) + 65536; wrong linux formula */
|
||||
const long extra_bytes = ( csize >> 6 ) + file_sizes.members * 36;
|
||||
const long long target_buffer_size = max( dsize, csize ) + extra_bytes;
|
||||
if( target_buffer_size > LONG_MAX )
|
||||
{ show_file_error( pp->name, "Buffer is larger than LONG_MAX.", 0 );
|
||||
return 1; }
|
||||
if( buffer_size < target_buffer_size ) /* avoid realloc if big enough */
|
||||
{
|
||||
buffer_size = dsize + rextra;
|
||||
buffer = (uint8_t *)realloc( buffer, buffer_size );
|
||||
if( !buffer )
|
||||
{ show_file_error( pp->name, "Not enough memory.", 0 ); return 1; }
|
||||
buffer = (uint8_t *)realloc( buffer, target_buffer_size );
|
||||
if( !buffer ) { show_file_error( pp->name, mem_msg, 0 ); return 1; }
|
||||
}
|
||||
else buffer_size = max( dsize + rextra, csize );
|
||||
const long cbegin = buffer_size - csize;
|
||||
buffer_size = target_buffer_size;
|
||||
const long cbegin = buffer_size - csize; /* overwrite trailing data */
|
||||
if( cbegin > 0 ) memmove( buffer + cbegin, buffer, csize );
|
||||
/*fprintf( stderr, "buffer_size = %ld, cbegin = %ld, extra_bytes = %ld\n",
|
||||
buffer_size, cbegin, extra_bytes );*/
|
||||
|
||||
long in_pos, out_pos;
|
||||
int retval;
|
||||
|
|
|
|||
2
lzip.h
2
lzip.h
|
|
@ -75,6 +75,8 @@ static inline unsigned long long Lt_get_member_size( const Lzip_trailer data )
|
|||
}
|
||||
|
||||
|
||||
static const char * const mem_msg = "Not enough memory.";
|
||||
|
||||
/* defined in in_place.c */
|
||||
int decompress_in_place( const int infd, struct Pretty_print * const pp,
|
||||
const bool testing );
|
||||
|
|
|
|||
142
main.c
142
main.c
|
|
@ -94,21 +94,20 @@ static bool delete_output_on_interrupt = false;
|
|||
|
||||
static void show_help( void )
|
||||
{
|
||||
printf( "Xlunzip is a test tool for the lzip decompression code of my lzip patch\n"
|
||||
"for linux. Xlunzip is similar to lunzip, but it uses the lzip_decompress\n"
|
||||
"linux module as a backend. Xlunzip tests the module for stream,\n"
|
||||
"buffer-to-buffer and mixed decompression modes, including in-place\n"
|
||||
"decompression (using the same buffer for input and output). You can use\n"
|
||||
"xlunzip to verify that the module produces correct results when\n"
|
||||
"decompressing single member files, multimember files, or the\n"
|
||||
"concatenation of two or more compressed files. Xlunzip can be used with\n"
|
||||
"unzcrash to test the robustness of the module to the decompression of\n"
|
||||
"corrupted data.\n"
|
||||
"\nNote that the in-place decompression of concatenated files can't be\n"
|
||||
"guaranteed to work because an arbitrarily low compression ratio of the\n"
|
||||
"last part of the data can be achieved by appending enough empty\n"
|
||||
"compressed members to a file, masking a high compression ratio at the\n"
|
||||
"beginning of the data.\n"
|
||||
printf( "Xlunzip is a test tool for the lzip decompression code of my lzip patch for\n"
|
||||
"linux. Xlunzip is similar to lunzip, but it uses the lzip_decompress linux\n"
|
||||
"module as a backend. Xlunzip tests the module for stream, buffer-to-buffer,\n"
|
||||
"and mixed decompression modes, including in-place decompression (using the\n"
|
||||
"same buffer for input and output). You can use xlunzip to verify that the\n"
|
||||
"module produces correct results when decompressing single member files,\n"
|
||||
"multimember files, or the concatenation of two or more compressed files.\n"
|
||||
"Xlunzip can be used with unzcrash to test the robustness of the module to\n"
|
||||
"the decompression of corrupted data.\n"
|
||||
"\nThe distributed index feature of the lzip format allows xlunzip to\n"
|
||||
"decompress concatenated files in place. This can't be guaranteed to work\n"
|
||||
"with formats like gzip or bzip2 because they can't detect whether a high\n"
|
||||
"compression ratio in the first members of the multimember data is being\n"
|
||||
"masked by a low compression ratio in the last members.\n"
|
||||
"\nUsage: %s [options] [files]\n", invocation_name );
|
||||
printf( "\nOptions:\n"
|
||||
" -h, --help display this help and exit\n"
|
||||
|
|
@ -118,7 +117,7 @@ static void show_help( void )
|
|||
" -f, --force overwrite existing output files\n"
|
||||
" -I, --in-place decompress or test using only one buffer\n"
|
||||
" -k, --keep keep (don't delete) input files\n"
|
||||
" -o, --output=<file> if reading standard input, write to <file>\n"
|
||||
" -o, --output=<file> write to <file>, keep input files\n"
|
||||
" -q, --quiet suppress all messages\n"
|
||||
" -t, --test test compressed file integrity\n"
|
||||
" -v, --verbose be verbose (a 2nd -v gives more)\n"
|
||||
|
|
@ -157,11 +156,7 @@ static void * resize_buffer( void * buf, const unsigned 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 );
|
||||
}
|
||||
if( !buf ) { show_error( mem_msg, 0, false ); cleanup_and_fail( 1 ); }
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
|
@ -316,7 +311,7 @@ static void set_d_outname( const char * const name, const int eindex )
|
|||
|
||||
|
||||
static int open_instream( const char * const name, struct stat * const in_statsp,
|
||||
const bool no_ofile )
|
||||
const bool one_to_one )
|
||||
{
|
||||
int infd = open( name, O_RDONLY | O_BINARY );
|
||||
if( infd < 0 )
|
||||
|
|
@ -328,13 +323,12 @@ static int open_instream( const char * const name, struct stat * const in_statsp
|
|||
const bool can_read = ( i == 0 &&
|
||||
( S_ISBLK( mode ) || S_ISCHR( mode ) ||
|
||||
S_ISFIFO( mode ) || S_ISSOCK( mode ) ) );
|
||||
if( i != 0 || ( !S_ISREG( mode ) && ( !can_read || !no_ofile ) ) )
|
||||
if( i != 0 || ( !S_ISREG( mode ) && ( !can_read || one_to_one ) ) )
|
||||
{
|
||||
if( verbosity >= 0 )
|
||||
fprintf( stderr, "%s: Input file '%s' is not a regular file%s.\n",
|
||||
program_name, name,
|
||||
( can_read && !no_ofile ) ?
|
||||
",\n and '--stdout' was not specified" : "" );
|
||||
program_name, name, ( can_read && one_to_one ) ?
|
||||
",\n and neither '-c' nor '-o' were specified" : "" );
|
||||
close( infd );
|
||||
infd = -1;
|
||||
}
|
||||
|
|
@ -343,11 +337,11 @@ static int open_instream( const char * const name, struct stat * const in_statsp
|
|||
}
|
||||
|
||||
|
||||
static bool open_outstream( const bool force, const bool from_stdin )
|
||||
static bool open_outstream( const bool force, const bool protect )
|
||||
{
|
||||
const mode_t usr_rw = S_IRUSR | S_IWUSR;
|
||||
const mode_t all_rw = usr_rw | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
|
||||
const mode_t outfd_mode = from_stdin ? all_rw : usr_rw;
|
||||
const mode_t outfd_mode = protect ? usr_rw : all_rw;
|
||||
int flags = O_APPEND | O_CREAT | O_RDWR | O_BINARY;
|
||||
if( force ) flags |= O_TRUNC; else flags |= O_EXCL;
|
||||
|
||||
|
|
@ -499,7 +493,7 @@ static int decompress( struct Pretty_print * const pp, const long cl_insize,
|
|||
long in_pos, out_pos;
|
||||
int retval;
|
||||
if( ( in_len > 0 && !inbuf ) || ( out_size > 0 && !outbuf ) )
|
||||
{ show_error( "Not enough memory.", 0, false ); return 1; }
|
||||
{ show_error( mem_msg, 0, false ); return 1; }
|
||||
|
||||
if( inbuf )
|
||||
{
|
||||
|
|
@ -544,6 +538,9 @@ void show_results( struct Pretty_print * const pp, const long in_pos,
|
|||
}
|
||||
|
||||
|
||||
static inline void set_retval( int * retval, const int new_val )
|
||||
{ if( *retval < new_val ) *retval = new_val; }
|
||||
|
||||
static void show_error( const char * const msg, const int errcode,
|
||||
const bool help )
|
||||
{
|
||||
|
|
@ -623,7 +620,7 @@ int main( const int argc, const char * const argv[] )
|
|||
if( argc > 0 ) invocation_name = argv[0];
|
||||
|
||||
if( !ap_init( &parser, argc, argv, options, 0 ) )
|
||||
{ show_error( "Not enough memory.", 0, false ); return 1; }
|
||||
{ show_error( mem_msg, 0, false ); return 1; }
|
||||
if( ap_error( &parser ) ) /* bad option */
|
||||
{ show_error( ap_error( &parser ), 0, true ); return 1; }
|
||||
|
||||
|
|
@ -641,7 +638,8 @@ int main( const int argc, const char * const argv[] )
|
|||
case 'I': in_place = true; break;
|
||||
case 'k': keep_input_files = true; break;
|
||||
case 'n': break;
|
||||
case 'o': default_output_filename = arg; break;
|
||||
case 'o': if( strcmp( arg, "-" ) == 0 ) to_stdout = true;
|
||||
else { default_output_filename = arg; } break;
|
||||
case 'q': verbosity = -1; break;
|
||||
case 't': testing = true; break;
|
||||
case 'v': if( verbosity < 4 ) ++verbosity; break;
|
||||
|
|
@ -672,64 +670,44 @@ int main( const int argc, const char * const argv[] )
|
|||
if( strcmp( filenames[i], "-" ) != 0 ) filenames_given = true;
|
||||
}
|
||||
|
||||
if( testing )
|
||||
outfd = -1;
|
||||
if( testing ) to_stdout = false; /* apply overrides */
|
||||
if( testing || to_stdout ) default_output_filename = "";
|
||||
|
||||
if( !to_stdout && !testing &&
|
||||
( filenames_given || default_output_filename[0] ) )
|
||||
output_filename = resize_buffer( output_filename, 1 );
|
||||
output_filename[0] = 0;
|
||||
if( to_stdout && !testing ) outfd = STDOUT_FILENO;
|
||||
else outfd = -1;
|
||||
|
||||
const bool to_file = !to_stdout && !testing && default_output_filename[0];
|
||||
if( !to_stdout && !testing && ( filenames_given || to_file ) )
|
||||
set_signals( signal_handler );
|
||||
|
||||
Pp_init( &pp, filenames, num_filenames );
|
||||
|
||||
output_filename = resize_buffer( output_filename, 1 );
|
||||
const bool one_to_one = !to_stdout && !testing && !to_file;
|
||||
for( i = 0; i < num_filenames; ++i )
|
||||
{
|
||||
const char * input_filename = "";
|
||||
int tmp;
|
||||
struct stat in_stats;
|
||||
const struct stat * in_statsp;
|
||||
output_filename[0] = 0;
|
||||
|
||||
if( strcmp( filenames[i], "-" ) == 0 )
|
||||
{
|
||||
if( stdin_used ) continue; else stdin_used = true;
|
||||
infd = STDIN_FILENO;
|
||||
if( !testing )
|
||||
{
|
||||
if( to_stdout || !default_output_filename[0] )
|
||||
outfd = STDOUT_FILENO;
|
||||
else
|
||||
{
|
||||
output_filename = resize_buffer( output_filename,
|
||||
strlen( default_output_filename ) + 1 );
|
||||
strcpy( output_filename, default_output_filename );
|
||||
if( !open_outstream( force, true ) )
|
||||
{
|
||||
if( retval < 1 ) retval = 1;
|
||||
close( infd ); infd = -1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
if( one_to_one ) { outfd = STDOUT_FILENO; output_filename[0] = 0; }
|
||||
}
|
||||
else
|
||||
{
|
||||
input_filename = filenames[i];
|
||||
infd = open_instream( input_filename, &in_stats, to_stdout || testing );
|
||||
if( infd < 0 ) { if( retval < 1 ) retval = 1; continue; }
|
||||
if( !testing )
|
||||
{
|
||||
if( to_stdout ) outfd = STDOUT_FILENO;
|
||||
else
|
||||
infd = open_instream( input_filename, &in_stats, one_to_one );
|
||||
if( infd < 0 ) { set_retval( &retval, 1 ); continue; }
|
||||
if( one_to_one )
|
||||
{
|
||||
set_d_outname( input_filename, extension_index( input_filename ) );
|
||||
if( !open_outstream( force, false ) )
|
||||
{
|
||||
if( retval < 1 ) retval = 1;
|
||||
close( infd ); infd = -1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if( !open_outstream( force, true ) )
|
||||
{ set_retval( &retval, 1 ); close( infd ); infd = -1; continue; }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -738,37 +716,43 @@ int main( const int argc, const char * const argv[] )
|
|||
{
|
||||
show_file_error( pp.name,
|
||||
"I won't read compressed data from a terminal.", 0 );
|
||||
if( retval < 1 ) retval = 1;
|
||||
set_retval( &retval, 1 );
|
||||
if( testing ) { close( infd ); infd = -1; continue; }
|
||||
cleanup_and_fail( retval );
|
||||
}
|
||||
|
||||
in_statsp = input_filename[0] ? &in_stats : 0;
|
||||
if( to_file && outfd < 0 ) /* open outfd after verifying infd */
|
||||
{
|
||||
output_filename = resize_buffer( output_filename,
|
||||
strlen( default_output_filename ) + 1 );
|
||||
strcpy( output_filename, default_output_filename );
|
||||
if( !open_outstream( force, false ) ) return 1;
|
||||
}
|
||||
|
||||
in_statsp = ( input_filename[0] && one_to_one ) ? &in_stats : 0;
|
||||
if( in_place )
|
||||
tmp = decompress_in_place( infd, &pp, testing );
|
||||
else
|
||||
tmp = decompress( &pp, cl_insize, cl_outsize, nofill, noflush, testing );
|
||||
if( close( infd ) != 0 )
|
||||
{
|
||||
show_error( input_filename[0] ? "Error closing input file" :
|
||||
"Error closing stdin", errno, false );
|
||||
if( tmp < 1 ) tmp = 1;
|
||||
}
|
||||
{ show_file_error( pp.name, "Error closing input file", errno );
|
||||
set_retval( &tmp, 1 ); }
|
||||
infd = -1;
|
||||
if( tmp > retval ) retval = tmp;
|
||||
set_retval( &retval, tmp );
|
||||
if( tmp )
|
||||
{ if( !testing ) cleanup_and_fail( retval );
|
||||
else ++failed_tests; }
|
||||
|
||||
if( delete_output_on_interrupt )
|
||||
if( delete_output_on_interrupt && one_to_one )
|
||||
close_and_set_permissions( in_statsp );
|
||||
if( input_filename[0] && !keep_input_files && !to_stdout && !testing )
|
||||
if( input_filename[0] && !keep_input_files && one_to_one )
|
||||
remove( input_filename );
|
||||
}
|
||||
if( outfd >= 0 && close( outfd ) != 0 )
|
||||
if( delete_output_on_interrupt ) close_and_set_permissions( 0 ); /* -o */
|
||||
else if( outfd >= 0 && close( outfd ) != 0 ) /* -c */
|
||||
{
|
||||
show_error( "Error closing stdout", errno, false );
|
||||
if( retval < 1 ) retval = 1;
|
||||
set_retval( &retval, 1 );
|
||||
}
|
||||
if( failed_tests > 0 && verbosity >= 1 && num_filenames > 1 )
|
||||
fprintf( stderr, "%s: warning: %d %s failed the test.\n",
|
||||
|
|
|
|||
|
|
@ -48,8 +48,13 @@ printf "testing xlunzip-%s..." "$2"
|
|||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq -o in < "${in_lz}"
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq -o in "${in_lz}"
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq -o out nx_file.lz
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
[ ! -e out ] || test_failed $LINENO
|
||||
# these are for code coverage
|
||||
"${LZIP}" -t -- nx_file 2> /dev/null
|
||||
"${LZIP}" -t -- nx_file.lz 2> /dev/null
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
"${LZIP}" -t "" < /dev/null 2> /dev/null
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
|
|
@ -77,11 +82,17 @@ printf "\ntesting decompression..."
|
|||
|
||||
for i in "${in_lz}" "${in_em}" ; do
|
||||
"${LZIP}" -t "$i" || test_failed $LINENO "$i"
|
||||
"${LZIP}" -d "$i" -o copy || test_failed $LINENO "$i"
|
||||
cmp in copy || test_failed $LINENO "$i"
|
||||
"${LZIP}" -cd "$i" > copy || test_failed $LINENO "$i"
|
||||
cmp in copy || test_failed $LINENO "$i"
|
||||
"${LZIP}" -d "$i" -o - > copy || test_failed $LINENO "$i"
|
||||
cmp in copy || test_failed $LINENO "$i"
|
||||
"${LZIP}" -d < "$i" > copy || test_failed $LINENO "$i"
|
||||
cmp in copy || test_failed $LINENO "$i"
|
||||
rm -f copy || framework_failure
|
||||
done
|
||||
|
||||
rm -f copy || framework_failure
|
||||
cat "${in_lz}" > copy.lz || framework_failure
|
||||
"${LZIP}" -dk copy.lz || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
|
|
@ -95,10 +106,16 @@ cmp in copy || test_failed $LINENO
|
|||
printf "to be overwritten" > copy || framework_failure
|
||||
"${LZIP}" -df -o copy < "${in_lz}" || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
rm -f out copy || framework_failure
|
||||
"${LZIP}" -d -o ./- "${in_lz}" || test_failed $LINENO
|
||||
cmp in ./- || test_failed $LINENO
|
||||
rm -f ./- || framework_failure
|
||||
"${LZIP}" -d -o ./- < "${in_lz}" || test_failed $LINENO
|
||||
cmp in ./- || test_failed $LINENO
|
||||
rm -f ./- || framework_failure
|
||||
|
||||
rm -f copy || framework_failure
|
||||
cat "${in_lz}" > anyothername || framework_failure
|
||||
"${LZIP}" -dv --output copy - anyothername - < "${in_lz}" 2> /dev/null ||
|
||||
"${LZIP}" -dv - anyothername - < "${in_lz}" > copy 2> /dev/null ||
|
||||
test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
cmp in anyothername.out || test_failed $LINENO
|
||||
|
|
@ -128,12 +145,16 @@ cat "${in_lz}" > copy.lz || framework_failure
|
|||
cmp in copy || test_failed $LINENO
|
||||
|
||||
cat in in > in2 || framework_failure
|
||||
cat "${in_lz}" "${in_lz}" > in2.lz || framework_failure
|
||||
"${LZIP}" -t in2.lz || test_failed $LINENO
|
||||
"${LZIP}" -cd in2.lz > copy2 || test_failed $LINENO
|
||||
"${LZIP}" -t "${in_lz}" "${in_lz}" || test_failed $LINENO
|
||||
"${LZIP}" -cd "${in_lz}" "${in_lz}" -o out > copy2 || test_failed $LINENO
|
||||
[ ! -e out ] || test_failed $LINENO # override -o
|
||||
cmp in2 copy2 || test_failed $LINENO
|
||||
rm -f copy2 || framework_failure
|
||||
"${LZIP}" -d "${in_lz}" "${in_lz}" -o copy2 || test_failed $LINENO
|
||||
cmp in2 copy2 || test_failed $LINENO
|
||||
rm -f copy2 || framework_failure
|
||||
|
||||
cat in2.lz > copy2.lz || framework_failure
|
||||
cat "${in_lz}" "${in_lz}" > copy2.lz || framework_failure
|
||||
printf "\ngarbage" >> copy2.lz || framework_failure
|
||||
"${LZIP}" -tvvvv copy2.lz 2> /dev/null || test_failed $LINENO
|
||||
printf "to be overwritten" > copy2 || framework_failure
|
||||
|
|
@ -183,6 +204,7 @@ for i in fox_bcrc.lz fox_crc0.lz fox_das46.lz fox_mes81.lz ; do
|
|||
done
|
||||
rm -f fox out || framework_failure
|
||||
|
||||
cat "${in_lz}" "${in_lz}" > in2.lz || framework_failure
|
||||
cat "${in_lz}" "${in_lz}" "${in_lz}" > in3.lz || framework_failure
|
||||
if dd if=in3.lz of=trunc.lz bs=14752 count=1 2> /dev/null &&
|
||||
[ -e trunc.lz ] && cmp in2.lz trunc.lz > /dev/null 2>&1 ; then
|
||||
|
|
@ -283,30 +305,62 @@ cmp -s in copy && test_failed $LINENO
|
|||
[ $? = 1 ] || test_failed $LINENO
|
||||
cmp -s in copy && test_failed $LINENO
|
||||
|
||||
# decompress in place
|
||||
rm -f copy copy2 || framework_failure
|
||||
"${LZIP}" -t --in-place "${in_lz}" || test_failed $LINENO
|
||||
"${LZIP}" -t --in-place < "${in_lz}" || test_failed $LINENO
|
||||
"${LZIP}" -d --in-place "${in_lz}" -o copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
rm -f copy || framework_failure
|
||||
"${LZIP}" -d --in-place < "${in_lz}" -o copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place "${in_lz}" > copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place < "${in_lz}" > copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
"${LZIP}" -t --in-place "${in_lz}" "${in_lz}" || test_failed $LINENO
|
||||
"${LZIP}" -d --in-place "${in_lz}" "${in_lz}" -o copy2 || test_failed $LINENO
|
||||
cmp in2 copy2 || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place "${in_lz}" "${in_lz}" > copy2 || test_failed $LINENO
|
||||
cmp in2 copy2 || test_failed $LINENO
|
||||
|
||||
# decompress multimember in place
|
||||
cat in in in > in3 || framework_failure
|
||||
for i in in2 in3 ; do
|
||||
"${LZIP}" -t --in-place $i.lz || test_failed $LINENO
|
||||
"${LZIP}" -t --in-place < $i.lz || test_failed $LINENO
|
||||
rm -f copy || framework_failure
|
||||
"${LZIP}" -d --in-place $i.lz -o copy || test_failed $LINENO
|
||||
cmp $i copy || test_failed $LINENO
|
||||
rm -f copy || framework_failure
|
||||
"${LZIP}" -d --in-place < $i.lz -o copy || test_failed $LINENO
|
||||
cmp $i copy || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place $i.lz > copy || test_failed $LINENO
|
||||
cmp $i copy || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place < $i.lz > copy || test_failed $LINENO
|
||||
cmp $i copy || test_failed $LINENO
|
||||
done
|
||||
"${LZIP}" -tq --in-place ingin.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
rm -f copy copy2 ingin.lz in2 in2.lz in3 in3.lz || framework_failure
|
||||
|
||||
cat "${in_lz}" "${zero_lz}" "${zero_lz}" "${zero_lz}" "${zero_lz}" \
|
||||
"${zero_lz}" "${zero_lz}" "${zero_lz}" > inz.lz || framework_failure
|
||||
cat "${in_lz}" > inz.lz || framework_failure
|
||||
counter=0
|
||||
while [ ${counter} -lt 20 ] ; do
|
||||
cat "${zero_lz}" >> inz.lz || framework_failure
|
||||
"${LZIP}" -t --in-place inz.lz || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place inz.lz > copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
cat "${zero_lz}" >> inz.lz || framework_failure
|
||||
"${LZIP}" -tq --in-place inz.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq --in-place inz.lz > copy
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp -s in copy && test_failed $LINENO
|
||||
rm -f copy ingin.lz in2 in2.lz in3 in3.lz || framework_failure
|
||||
counter=$((counter+1))
|
||||
done
|
||||
rm -f copy inz.lz || framework_failure
|
||||
|
||||
# decompress with trailing data in place
|
||||
cat "${in_lz}" in in in in > int.lz || framework_failure
|
||||
"${LZIP}" -t --in-place int.lz || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place int.lz > copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
rm -f copy int.lz || framework_failure
|
||||
|
||||
echo
|
||||
if [ ${fail} = 0 ] ; then
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue