Compare commits
No commits in common. "0c057f26066f0924a2aeabbe16185d4c48c5ba35" and "4279a1e7bc2bd9cb175a38258710e5b2a0b48427" have entirely different histories.
0c057f2606
...
4279a1e7bc
28 changed files with 496 additions and 740 deletions
3
COPYING
3
COPYING
|
|
@ -1,7 +1,8 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc. <http://fsf.org/>
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
|
|
|
|||
28
ChangeLog
28
ChangeLog
|
|
@ -1,22 +1,3 @@
|
|||
2025-01-06 Antonio Diaz Diaz <antonio@gnu.org>
|
||||
|
||||
* Version 0.9 released.
|
||||
* main.c (decompress): Return 2 if empty member in multimember file.
|
||||
(Pp_free): New function.
|
||||
* lzip_decompress.c (Rd_load): Check first byte of the LZMA stream.
|
||||
* check.sh: Use 'cp' instead of 'cat'.
|
||||
|
||||
2024-01-18 Antonio Diaz Diaz <antonio@gnu.org>
|
||||
|
||||
* Version 0.8 released.
|
||||
* main.c: Reformat file diagnostics as 'PROGRAM: FILE: MESSAGE'.
|
||||
(getnum): Show option name and valid range if error.
|
||||
(show_option_error): New function showing argument and option name.
|
||||
(main): Make -o preserve date/mode/owner if 1 input file.
|
||||
* lzip.h: Rename verify_* to check_*.
|
||||
* configure, Makefile.in: New variable 'MAKEINFO'.
|
||||
* INSTALL: Document use of CFLAGS+='--std=c99 -D_XOPEN_SOURCE=500'.
|
||||
|
||||
2021-01-01 Antonio Diaz Diaz <antonio@gnu.org>
|
||||
|
||||
* Version 0.7 released.
|
||||
|
|
@ -41,7 +22,7 @@
|
|||
* main.c: Set a valid invocation_name even if argc == 0.
|
||||
* Document extraction from tar.lz in '--help' output and man page.
|
||||
* main.c: Compile on DOS with DJGPP.
|
||||
* configure: Accept appending to CFLAGS; 'CFLAGS+=OPTIONS'.
|
||||
* configure: Accept appending to CFLAGS, 'CFLAGS+=OPTIONS'.
|
||||
* testsuite: Add 9 new test files.
|
||||
|
||||
2018-09-18 Antonio Diaz Diaz <antonio@gnu.org>
|
||||
|
|
@ -75,7 +56,8 @@
|
|||
* Tests the code shipped in linux patches before june 2018.
|
||||
|
||||
|
||||
Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
|
||||
This file is a collection of facts, and thus it is not copyrightable, but just
|
||||
in case, you have unlimited permission to copy, distribute, and modify it.
|
||||
This file is a collection of facts, and thus it is not copyrightable,
|
||||
but just in case, you have unlimited permission to copy, distribute, and
|
||||
modify it.
|
||||
|
|
|
|||
22
INSTALL
22
INSTALL
|
|
@ -1,10 +1,9 @@
|
|||
Requirements
|
||||
------------
|
||||
You will need a C99 compiler. (gcc 3.3.6 or newer is recommended).
|
||||
I use gcc 6.1.0 and 3.3.6, but the code should compile with any standards
|
||||
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
|
||||
Lzip is available at http://www.nongnu.org/lzip/lzip.html
|
||||
Gcc is available at http://gcc.gnu.org.
|
||||
|
||||
The operating system must allow signal handlers read access to objects with
|
||||
static storage duration so that the cleanup handler for Control-C can delete
|
||||
|
|
@ -19,8 +18,8 @@ Procedure
|
|||
or
|
||||
lzip -cd xlunzip[version].tar.lz | tar -xf -
|
||||
|
||||
This creates the directory ./xlunzip[version] containing the source code
|
||||
extracted from the archive.
|
||||
This creates the directory ./xlunzip[version] containing the source from
|
||||
the main archive.
|
||||
|
||||
2. Change to xlunzip directory and run configure.
|
||||
(Try 'configure --help' for usage instructions).
|
||||
|
|
@ -28,10 +27,6 @@ extracted from the archive.
|
|||
cd xlunzip[version]
|
||||
./configure
|
||||
|
||||
If you choose a C standard, enable the POSIX features explicitly:
|
||||
|
||||
./configure CFLAGS+='--std=c99 -D_XOPEN_SOURCE=500'
|
||||
|
||||
If you are compiling on MinGW, use:
|
||||
|
||||
./configure CFLAGS+='-D __USE_MINGW_ANSI_STDIO'
|
||||
|
|
@ -43,8 +38,7 @@ extracted from the archive.
|
|||
4. Optionally, type 'make check' to run the tests that come with xlunzip.
|
||||
|
||||
5. Type 'make install' to install the program and any data files and
|
||||
documentation. You need root privileges to install into a prefix owned
|
||||
by root.
|
||||
documentation.
|
||||
|
||||
Or type 'make install-compress', which additionally compresses the
|
||||
man page after installation.
|
||||
|
|
@ -67,15 +61,15 @@ object files and executables to go and run the 'configure' script.
|
|||
'configure' automatically checks for the source code in '.', in '..', and
|
||||
in the directory that 'configure' is in.
|
||||
|
||||
'configure' recognizes the option '--srcdir=DIR' to control where to look
|
||||
for the source code. Usually 'configure' can determine that directory
|
||||
'configure' recognizes the option '--srcdir=DIR' to control where to
|
||||
look for the sources. Usually 'configure' can determine that directory
|
||||
automatically.
|
||||
|
||||
After running 'configure', you can run 'make' and 'make install' as
|
||||
explained above.
|
||||
|
||||
|
||||
Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
|
||||
This file is free documentation: you have unlimited permission to copy,
|
||||
distribute, and modify it.
|
||||
|
|
|
|||
17
Makefile.in
17
Makefile.in
|
|
@ -2,8 +2,8 @@
|
|||
DISTNAME = $(pkgname)-$(pkgversion)
|
||||
INSTALL = install
|
||||
INSTALL_PROGRAM = $(INSTALL) -m 755
|
||||
INSTALL_DIR = $(INSTALL) -d -m 755
|
||||
INSTALL_DATA = $(INSTALL) -m 644
|
||||
INSTALL_DIR = $(INSTALL) -d -m 755
|
||||
SHELL = /bin/sh
|
||||
CAN_RUN_INSTALLINFO = $(SHELL) -c "install-info --version" > /dev/null 2>&1
|
||||
|
||||
|
|
@ -20,7 +20,7 @@ objs = carg_parser.o decompress_lunzip.o in_place.o lzip_decompress.o main.o
|
|||
all : $(progname)
|
||||
|
||||
$(progname) : $(objs)
|
||||
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(objs)
|
||||
$(CC) $(LDFLAGS) $(CFLAGS) -o $@ $(objs)
|
||||
|
||||
main.o : main.c
|
||||
$(CC) $(CPPFLAGS) $(CFLAGS) -DPROGVERSION=\"$(pkgversion)\" -c -o $@ $<
|
||||
|
|
@ -28,11 +28,6 @@ main.o : main.c
|
|||
%.o : %.c
|
||||
$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
# prevent 'make' from trying to remake source files
|
||||
$(VPATH)/configure $(VPATH)/Makefile.in $(VPATH)/doc/$(pkgname).texi : ;
|
||||
MAKEFLAGS += -r
|
||||
.SUFFIXES :
|
||||
|
||||
$(objs) : Makefile
|
||||
carg_parser.o : carg_parser.h
|
||||
decompress_lunzip.o : linux_lzip.h linux_lunzip.h linux_mm.h lzip_decompress.c
|
||||
|
|
@ -40,12 +35,13 @@ in_place.o : linux_lunzip.h lzip.h
|
|||
lzip_decompress.o : linux_module.h linux_lzip.h linux_mm.h
|
||||
main.o : carg_parser.h linux_lzip.h linux_lunzip.h lzip.h
|
||||
|
||||
|
||||
doc : man
|
||||
|
||||
info : $(VPATH)/doc/$(pkgname).info
|
||||
|
||||
$(VPATH)/doc/$(pkgname).info : $(VPATH)/doc/$(pkgname).texi
|
||||
cd $(VPATH)/doc && $(MAKEINFO) $(pkgname).texi
|
||||
cd $(VPATH)/doc && makeinfo $(pkgname).texi
|
||||
|
||||
man : $(VPATH)/doc/$(progname).1
|
||||
|
||||
|
|
@ -123,10 +119,11 @@ dist : doc
|
|||
$(DISTNAME)/*.c \
|
||||
$(DISTNAME)/testsuite/check.sh \
|
||||
$(DISTNAME)/testsuite/test.txt \
|
||||
$(DISTNAME)/testsuite/em.lz \
|
||||
$(DISTNAME)/testsuite/fox.lz \
|
||||
$(DISTNAME)/testsuite/fox_*.lz \
|
||||
$(DISTNAME)/testsuite/test.txt.lz
|
||||
$(DISTNAME)/testsuite/zero.lz \
|
||||
$(DISTNAME)/testsuite/test.txt.lz \
|
||||
$(DISTNAME)/testsuite/test_em.txt.lz
|
||||
rm -f $(DISTNAME)
|
||||
lzip -v -9 $(DISTNAME).tar
|
||||
|
||||
|
|
|
|||
8
NEWS
8
NEWS
|
|
@ -1,7 +1,3 @@
|
|||
Changes in version 0.9:
|
||||
Changes in version 0.7:
|
||||
|
||||
xlunzip now exits with error status 2 if any empty member is found in a
|
||||
multimember file.
|
||||
|
||||
xlunzip now exits with error status 2 if the first byte of the LZMA stream
|
||||
is not 0.
|
||||
Xlunzip now does not even open the output file if the input file is a terminal.
|
||||
|
|
|
|||
27
README
27
README
|
|
@ -1,12 +1,10 @@
|
|||
See the file INSTALL for compilation and installation instructions.
|
||||
|
||||
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 check that 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
|
||||
|
|
@ -28,7 +26,7 @@ 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
|
||||
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.
|
||||
|
||||
|
|
@ -78,7 +76,7 @@ address | * ,'
|
|||
|
||||
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 check integrity.
|
||||
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
|
||||
|
|
@ -89,25 +87,22 @@ required to decompress lzip data in place is:
|
|||
|
||||
Using the compressed size to calculate the extra_bytes (as in the formula
|
||||
above) may slightly overestimate the amount of space required in the worst
|
||||
case (maximum expansion). But calculating the extra_bytes from the
|
||||
uncompressed size (as does linux currently) is wrong (and inefficient for
|
||||
high compression ratios). The formula used in arch/x86/boot/header.S:
|
||||
case. But calculating the extra_bytes from the uncompressed size (as does
|
||||
linux currently) is wrong (and inefficient for high compression ratios). The
|
||||
formula used in arch/x86/boot/header.S
|
||||
|
||||
extra_bytes = ( uncompressed_size >> 8 ) + 131072
|
||||
extra_bytes = ( uncompressed_size >> 8 ) + 65536
|
||||
|
||||
fails to decompress 1 MB of zeros followed by 8 MB of random data, wastes
|
||||
memory for compression ratios larger than 4:1, and does not even consider
|
||||
multimember data.
|
||||
|
||||
|
||||
Xlunzip uses Arg_parser for command-line argument parsing:
|
||||
http://www.nongnu.org/arg-parser/arg_parser.html
|
||||
|
||||
|
||||
Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
|
||||
This file is free documentation: you have unlimited permission to copy,
|
||||
distribute, and modify it.
|
||||
|
||||
The file Makefile.in is a data file used by configure to produce the Makefile.
|
||||
It has the same copyright owner and permissions that configure itself.
|
||||
The file Makefile.in is a data file used by configure to produce the
|
||||
Makefile. It has the same copyright owner and permissions that configure
|
||||
itself.
|
||||
|
|
|
|||
164
carg_parser.c
164
carg_parser.c
|
|
@ -1,5 +1,5 @@
|
|||
/* Arg_parser - POSIX/GNU command-line argument parser. (C version)
|
||||
Copyright (C) 2006-2025 Antonio Diaz Diaz.
|
||||
/* Arg_parser - POSIX/GNU command line argument parser. (C version)
|
||||
Copyright (C) 2006-2021 Antonio Diaz Diaz.
|
||||
|
||||
This library is free software. Redistribution and use in source and
|
||||
binary forms, with or without modification, are permitted provided
|
||||
|
|
@ -32,46 +32,28 @@ static void * ap_resize_buffer( void * buf, const int min_size )
|
|||
}
|
||||
|
||||
|
||||
static char push_back_record( Arg_parser * const ap, const int code,
|
||||
const char * const long_name,
|
||||
const char * const argument )
|
||||
{
|
||||
ap_Record * p;
|
||||
void * tmp = ap_resize_buffer( ap->data,
|
||||
( ap->data_size + 1 ) * sizeof (ap_Record) );
|
||||
if( !tmp ) return 0;
|
||||
ap->data = (ap_Record *)tmp;
|
||||
p = &(ap->data[ap->data_size]);
|
||||
p->code = code;
|
||||
if( long_name )
|
||||
{
|
||||
const int len = strlen( long_name );
|
||||
p->parsed_name = (char *)malloc( len + 2 + 1 );
|
||||
if( !p->parsed_name ) return 0;
|
||||
p->parsed_name[0] = p->parsed_name[1] = '-';
|
||||
strncpy( p->parsed_name + 2, long_name, len + 1 );
|
||||
}
|
||||
else if( code > 0 && code < 256 )
|
||||
{
|
||||
p->parsed_name = (char *)malloc( 2 + 1 );
|
||||
if( !p->parsed_name ) return 0;
|
||||
p->parsed_name[0] = '-'; p->parsed_name[1] = code; p->parsed_name[2] = 0;
|
||||
}
|
||||
else p->parsed_name = 0;
|
||||
if( argument )
|
||||
static char push_back_record( struct Arg_parser * const ap,
|
||||
const int code, const char * const argument )
|
||||
{
|
||||
const int len = strlen( argument );
|
||||
p->argument = (char *)malloc( len + 1 );
|
||||
if( !p->argument ) { free( p->parsed_name ); return 0; }
|
||||
struct ap_Record * p;
|
||||
void * tmp = ap_resize_buffer( ap->data,
|
||||
( ap->data_size + 1 ) * sizeof (struct ap_Record) );
|
||||
if( !tmp ) return 0;
|
||||
ap->data = (struct ap_Record *)tmp;
|
||||
p = &(ap->data[ap->data_size]);
|
||||
p->code = code;
|
||||
p->argument = 0;
|
||||
tmp = ap_resize_buffer( p->argument, len + 1 );
|
||||
if( !tmp ) return 0;
|
||||
p->argument = (char *)tmp;
|
||||
strncpy( p->argument, argument, len + 1 );
|
||||
}
|
||||
else p->argument = 0;
|
||||
++ap->data_size;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static char add_error( Arg_parser * const ap, const char * const msg )
|
||||
static char add_error( struct Arg_parser * const ap, const char * const msg )
|
||||
{
|
||||
const int len = strlen( msg );
|
||||
void * tmp = ap_resize_buffer( ap->error, ap->error_size + len + 1 );
|
||||
|
|
@ -83,20 +65,19 @@ static char add_error( Arg_parser * const ap, const char * const msg )
|
|||
}
|
||||
|
||||
|
||||
static void free_data( Arg_parser * const ap )
|
||||
static void free_data( struct Arg_parser * const ap )
|
||||
{
|
||||
int i;
|
||||
for( i = 0; i < ap->data_size; ++i )
|
||||
{ free( ap->data[i].argument ); free( ap->data[i].parsed_name ); }
|
||||
for( i = 0; i < ap->data_size; ++i ) free( ap->data[i].argument );
|
||||
if( ap->data ) { free( ap->data ); ap->data = 0; }
|
||||
ap->data_size = 0;
|
||||
}
|
||||
|
||||
|
||||
/* Return 0 only if out of memory. */
|
||||
static char parse_long_option( Arg_parser * const ap,
|
||||
static char parse_long_option( struct Arg_parser * const ap,
|
||||
const char * const opt, const char * const arg,
|
||||
const ap_Option options[], int * const argindp )
|
||||
const struct ap_Option options[],
|
||||
int * const argindp )
|
||||
{
|
||||
unsigned len;
|
||||
int index = -1, i;
|
||||
|
|
@ -106,10 +87,9 @@ static char parse_long_option( Arg_parser * const ap,
|
|||
|
||||
/* Test all long options for either exact match or abbreviated matches. */
|
||||
for( i = 0; options[i].code != 0; ++i )
|
||||
if( options[i].long_name &&
|
||||
strncmp( options[i].long_name, &opt[2], len ) == 0 )
|
||||
if( options[i].name && strncmp( options[i].name, &opt[2], len ) == 0 )
|
||||
{
|
||||
if( strlen( options[i].long_name ) == len ) /* Exact match found */
|
||||
if( strlen( options[i].name ) == len ) /* Exact match found */
|
||||
{ index = i; exact = 1; break; }
|
||||
else if( index < 0 ) index = i; /* First nonexact match found */
|
||||
else if( options[index].code != options[i].code ||
|
||||
|
|
@ -137,55 +117,52 @@ static char parse_long_option( Arg_parser * const ap,
|
|||
{
|
||||
if( options[index].has_arg == ap_no )
|
||||
{
|
||||
add_error( ap, "option '--" ); add_error( ap, options[index].long_name );
|
||||
add_error( ap, "option '--" ); add_error( ap, options[index].name );
|
||||
add_error( ap, "' doesn't allow an argument" );
|
||||
return 1;
|
||||
}
|
||||
if( options[index].has_arg == ap_yes && !opt[len+3] )
|
||||
{
|
||||
add_error( ap, "option '--" ); add_error( ap, options[index].long_name );
|
||||
add_error( ap, "option '--" ); add_error( ap, options[index].name );
|
||||
add_error( ap, "' requires an argument" );
|
||||
return 1;
|
||||
}
|
||||
return push_back_record( ap, options[index].code, options[index].long_name,
|
||||
&opt[len+3] ); /* argument may be empty */
|
||||
return push_back_record( ap, options[index].code, &opt[len+3] );
|
||||
}
|
||||
|
||||
if( options[index].has_arg == ap_yes || options[index].has_arg == ap_yme )
|
||||
if( options[index].has_arg == ap_yes )
|
||||
{
|
||||
if( !arg || ( options[index].has_arg == ap_yes && !arg[0] ) )
|
||||
if( !arg || !arg[0] )
|
||||
{
|
||||
add_error( ap, "option '--" ); add_error( ap, options[index].long_name );
|
||||
add_error( ap, "option '--" ); add_error( ap, options[index].name );
|
||||
add_error( ap, "' requires an argument" );
|
||||
return 1;
|
||||
}
|
||||
++*argindp;
|
||||
return push_back_record( ap, options[index].code, options[index].long_name,
|
||||
arg ); /* argument may be empty */
|
||||
return push_back_record( ap, options[index].code, arg );
|
||||
}
|
||||
|
||||
return push_back_record( ap, options[index].code,
|
||||
options[index].long_name, 0 );
|
||||
return push_back_record( ap, options[index].code, "" );
|
||||
}
|
||||
|
||||
|
||||
/* Return 0 only if out of memory. */
|
||||
static char parse_short_option( Arg_parser * const ap,
|
||||
static char parse_short_option( struct Arg_parser * const ap,
|
||||
const char * const opt, const char * const arg,
|
||||
const ap_Option options[], int * const argindp )
|
||||
const struct ap_Option options[],
|
||||
int * const argindp )
|
||||
{
|
||||
int cind = 1; /* character index in opt */
|
||||
|
||||
while( cind > 0 )
|
||||
{
|
||||
int index = -1, i;
|
||||
const unsigned char c = opt[cind];
|
||||
const unsigned char code = opt[cind];
|
||||
char code_str[2];
|
||||
code_str[0] = c; code_str[1] = 0;
|
||||
code_str[0] = code; code_str[1] = 0;
|
||||
|
||||
if( c != 0 )
|
||||
if( code != 0 )
|
||||
for( i = 0; options[i].code; ++i )
|
||||
if( c == options[i].code )
|
||||
if( code == options[i].code )
|
||||
{ index = i; break; }
|
||||
|
||||
if( index < 0 )
|
||||
|
|
@ -199,34 +176,34 @@ static char parse_short_option( Arg_parser * const ap,
|
|||
|
||||
if( options[index].has_arg != ap_no && cind > 0 && opt[cind] )
|
||||
{
|
||||
if( !push_back_record( ap, c, 0, &opt[cind] ) ) return 0;
|
||||
if( !push_back_record( ap, code, &opt[cind] ) ) return 0;
|
||||
++*argindp; cind = 0;
|
||||
}
|
||||
else if( options[index].has_arg == ap_yes || options[index].has_arg == ap_yme )
|
||||
else if( options[index].has_arg == ap_yes )
|
||||
{
|
||||
if( !arg || ( options[index].has_arg == ap_yes && !arg[0] ) )
|
||||
if( !arg || !arg[0] )
|
||||
{
|
||||
add_error( ap, "option requires an argument -- '" );
|
||||
add_error( ap, code_str ); add_error( ap, "'" );
|
||||
return 1;
|
||||
}
|
||||
++*argindp; cind = 0; /* argument may be empty */
|
||||
if( !push_back_record( ap, c, 0, arg ) ) return 0;
|
||||
++*argindp; cind = 0;
|
||||
if( !push_back_record( ap, code, arg ) ) return 0;
|
||||
}
|
||||
else if( !push_back_record( ap, c, 0, 0 ) ) return 0;
|
||||
else if( !push_back_record( ap, code, "" ) ) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
char ap_init( Arg_parser * const ap,
|
||||
char ap_init( struct Arg_parser * const ap,
|
||||
const int argc, const char * const argv[],
|
||||
const ap_Option options[], const char in_order )
|
||||
const struct ap_Option options[], const char in_order )
|
||||
{
|
||||
const char ** non_options = 0; /* skipped non-options */
|
||||
int non_options_size = 0; /* number of skipped non-options */
|
||||
int argind = 1; /* index in argv */
|
||||
char done = 0; /* false until success */
|
||||
int i;
|
||||
|
||||
ap->data = 0;
|
||||
ap->error = 0;
|
||||
|
|
@ -246,20 +223,20 @@ char ap_init( Arg_parser * const ap,
|
|||
if( ch2 == '-' )
|
||||
{
|
||||
if( !argv[argind][2] ) { ++argind; break; } /* we found "--" */
|
||||
else if( !parse_long_option( ap, opt, arg, options, &argind ) ) goto out;
|
||||
else if( !parse_long_option( ap, opt, arg, options, &argind ) ) return 0;
|
||||
}
|
||||
else if( !parse_short_option( ap, opt, arg, options, &argind ) ) goto out;
|
||||
else if( !parse_short_option( ap, opt, arg, options, &argind ) ) return 0;
|
||||
if( ap->error ) break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( in_order )
|
||||
{ if( !push_back_record( ap, 0, 0, argv[argind++] ) ) goto out; }
|
||||
{ if( !push_back_record( ap, 0, argv[argind++] ) ) return 0; }
|
||||
else
|
||||
{
|
||||
void * tmp = ap_resize_buffer( non_options,
|
||||
( non_options_size + 1 ) * sizeof *non_options );
|
||||
if( !tmp ) goto out;
|
||||
if( !tmp ) return 0;
|
||||
non_options = (const char **)tmp;
|
||||
non_options[non_options_size++] = argv[argind++];
|
||||
}
|
||||
|
|
@ -268,19 +245,17 @@ char ap_init( Arg_parser * const ap,
|
|||
if( ap->error ) free_data( ap );
|
||||
else
|
||||
{
|
||||
int i;
|
||||
for( i = 0; i < non_options_size; ++i )
|
||||
if( !push_back_record( ap, 0, 0, non_options[i] ) ) goto out;
|
||||
if( !push_back_record( ap, 0, non_options[i] ) ) return 0;
|
||||
while( argind < argc )
|
||||
if( !push_back_record( ap, 0, 0, argv[argind++] ) ) goto out;
|
||||
if( !push_back_record( ap, 0, argv[argind++] ) ) return 0;
|
||||
}
|
||||
done = 1;
|
||||
out: if( non_options ) free( non_options );
|
||||
return done;
|
||||
if( non_options ) free( non_options );
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void ap_free( Arg_parser * const ap )
|
||||
void ap_free( struct Arg_parser * const ap )
|
||||
{
|
||||
free_data( ap );
|
||||
if( ap->error ) { free( ap->error ); ap->error = 0; }
|
||||
|
|
@ -288,26 +263,23 @@ void ap_free( Arg_parser * const ap )
|
|||
}
|
||||
|
||||
|
||||
const char * ap_error( const Arg_parser * const ap ) { return ap->error; }
|
||||
const char * ap_error( const struct Arg_parser * const ap )
|
||||
{ return ap->error; }
|
||||
|
||||
int ap_arguments( const Arg_parser * const ap ) { return ap->data_size; }
|
||||
|
||||
int ap_code( const Arg_parser * const ap, const int i )
|
||||
int ap_arguments( const struct Arg_parser * const ap )
|
||||
{ return ap->data_size; }
|
||||
|
||||
|
||||
int ap_code( const struct Arg_parser * const ap, const int i )
|
||||
{
|
||||
if( i < 0 || i >= ap_arguments( ap ) ) return 0;
|
||||
return ap->data[i].code;
|
||||
if( i >= 0 && i < ap_arguments( ap ) ) return ap->data[i].code;
|
||||
else return 0;
|
||||
}
|
||||
|
||||
|
||||
const char * ap_parsed_name( const Arg_parser * const ap, const int i )
|
||||
const char * ap_argument( const struct Arg_parser * const ap, const int i )
|
||||
{
|
||||
if( i < 0 || i >= ap_arguments( ap ) || !ap->data[i].parsed_name ) return "";
|
||||
return ap->data[i].parsed_name;
|
||||
}
|
||||
|
||||
|
||||
const char * ap_argument( const Arg_parser * const ap, const int i )
|
||||
{
|
||||
if( i < 0 || i >= ap_arguments( ap ) || !ap->data[i].argument ) return "";
|
||||
return ap->data[i].argument;
|
||||
if( i >= 0 && i < ap_arguments( ap ) ) return ap->data[i].argument;
|
||||
else return "";
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/* Arg_parser - POSIX/GNU command-line argument parser. (C version)
|
||||
Copyright (C) 2006-2025 Antonio Diaz Diaz.
|
||||
/* Arg_parser - POSIX/GNU command line argument parser. (C version)
|
||||
Copyright (C) 2006-2021 Antonio Diaz Diaz.
|
||||
|
||||
This library is free software. Redistribution and use in source and
|
||||
binary forms, with or without modification, are permitted provided
|
||||
|
|
@ -24,9 +24,9 @@
|
|||
message.
|
||||
|
||||
'options' is an array of 'struct ap_Option' terminated by an element
|
||||
containing a code which is zero. A null long_name means a short-only
|
||||
option. A code value outside the unsigned char range means a long-only
|
||||
option.
|
||||
containing a code which is zero. A null name means a short-only
|
||||
option. A code value outside the unsigned char range means a
|
||||
long-only option.
|
||||
|
||||
Arg_parser normally makes it appear as if all the option arguments
|
||||
were specified before all the non-option arguments for the purposes
|
||||
|
|
@ -37,65 +37,56 @@
|
|||
The argument '--' terminates all options; any following arguments are
|
||||
treated as non-option arguments, even if they begin with a hyphen.
|
||||
|
||||
The syntax of options with an optional argument is
|
||||
'-<short_option><argument>' (without whitespace), or
|
||||
'--<long_option>=<argument>'.
|
||||
|
||||
The syntax of options with an empty argument is '-<short_option> ""',
|
||||
'--<long_option> ""', or '--<long_option>=""'.
|
||||
The syntax for optional option arguments is '-<short_option><argument>'
|
||||
(without whitespace), or '--<long_option>=<argument>'.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ap_yme = yes but maybe empty */
|
||||
typedef enum ap_Has_arg { ap_no, ap_yes, ap_maybe, ap_yme } ap_Has_arg;
|
||||
enum ap_Has_arg { ap_no, ap_yes, ap_maybe };
|
||||
|
||||
typedef struct ap_Option
|
||||
struct ap_Option
|
||||
{
|
||||
int code; /* Short option letter or code ( code != 0 ) */
|
||||
const char * long_name; /* Long option name (maybe null) */
|
||||
ap_Has_arg has_arg;
|
||||
} ap_Option;
|
||||
const char * name; /* Long option name (maybe null) */
|
||||
enum ap_Has_arg has_arg;
|
||||
};
|
||||
|
||||
|
||||
typedef struct ap_Record
|
||||
struct ap_Record
|
||||
{
|
||||
int code;
|
||||
char * parsed_name;
|
||||
char * argument;
|
||||
} ap_Record;
|
||||
};
|
||||
|
||||
|
||||
typedef struct Arg_parser
|
||||
struct Arg_parser
|
||||
{
|
||||
ap_Record * data;
|
||||
struct ap_Record * data;
|
||||
char * error;
|
||||
int data_size;
|
||||
int error_size;
|
||||
} Arg_parser;
|
||||
};
|
||||
|
||||
|
||||
char ap_init( Arg_parser * const ap,
|
||||
char ap_init( struct Arg_parser * const ap,
|
||||
const int argc, const char * const argv[],
|
||||
const ap_Option options[], const char in_order );
|
||||
const struct ap_Option options[], const char in_order );
|
||||
|
||||
void ap_free( Arg_parser * const ap );
|
||||
void ap_free( struct Arg_parser * const ap );
|
||||
|
||||
const char * ap_error( const Arg_parser * const ap );
|
||||
const char * ap_error( const struct Arg_parser * const ap );
|
||||
|
||||
/* The number of arguments parsed. May be different from argc. */
|
||||
int ap_arguments( const Arg_parser * const ap );
|
||||
int ap_arguments( const struct Arg_parser * const ap );
|
||||
|
||||
/* If ap_code( i ) is 0, ap_argument( i ) is a non-option.
|
||||
Else ap_argument( i ) is the option's argument (or empty). */
|
||||
int ap_code( const Arg_parser * const ap, const int i );
|
||||
int ap_code( const struct Arg_parser * const ap, const int i );
|
||||
|
||||
/* Full name of the option parsed (short or long). */
|
||||
const char * ap_parsed_name( const Arg_parser * const ap, const int i );
|
||||
|
||||
const char * ap_argument( const Arg_parser * const ap, const int i );
|
||||
const char * ap_argument( const struct Arg_parser * const ap, const int i );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
27
configure
vendored
27
configure
vendored
|
|
@ -1,12 +1,12 @@
|
|||
#! /bin/sh
|
||||
# configure script for Xlunzip - Test tool for the lzip_decompress linux module
|
||||
# Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
# Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
#
|
||||
# This configure script is free software: you have unlimited permission
|
||||
# to copy, distribute, and modify it.
|
||||
|
||||
pkgname=xlunzip
|
||||
pkgversion=0.9
|
||||
pkgversion=0.7
|
||||
progname=xlunzip
|
||||
srctrigger=doc/${progname}.1
|
||||
|
||||
|
|
@ -24,7 +24,6 @@ CC=gcc
|
|||
CPPFLAGS=
|
||||
CFLAGS='-Wall -W -O2'
|
||||
LDFLAGS=
|
||||
MAKEINFO=makeinfo
|
||||
|
||||
# checking whether we are using GNU C.
|
||||
/bin/sh -c "${CC} --version" > /dev/null 2>&1 || { CC=cc ; CFLAGS=-O2 ; }
|
||||
|
|
@ -58,7 +57,7 @@ while [ $# != 0 ] ; do
|
|||
echo "Options and variables: [defaults in brackets]"
|
||||
echo " -h, --help display this help and exit"
|
||||
echo " -V, --version output version information and exit"
|
||||
echo " --srcdir=DIR find the source code in DIR [. or ..]"
|
||||
echo " --srcdir=DIR find the sources in DIR [. or ..]"
|
||||
echo " --prefix=DIR install into DIR [${prefix}]"
|
||||
echo " --exec-prefix=DIR base directory for arch-dependent files [${exec_prefix}]"
|
||||
echo " --bindir=DIR user executables directory [${bindir}]"
|
||||
|
|
@ -66,11 +65,10 @@ while [ $# != 0 ] ; do
|
|||
echo " --infodir=DIR info files directory [${infodir}]"
|
||||
echo " --mandir=DIR man pages directory [${mandir}]"
|
||||
echo " CC=COMPILER C compiler to use [${CC}]"
|
||||
echo " CPPFLAGS=OPTIONS command-line options for the preprocessor [${CPPFLAGS}]"
|
||||
echo " CFLAGS=OPTIONS command-line options for the C compiler [${CFLAGS}]"
|
||||
echo " CPPFLAGS=OPTIONS command line options for the preprocessor [${CPPFLAGS}]"
|
||||
echo " CFLAGS=OPTIONS command line options for the C compiler [${CFLAGS}]"
|
||||
echo " CFLAGS+=OPTIONS append options to the current value of CFLAGS"
|
||||
echo " LDFLAGS=OPTIONS command-line options for the linker [${LDFLAGS}]"
|
||||
echo " MAKEINFO=NAME makeinfo program to use [${MAKEINFO}]"
|
||||
echo " LDFLAGS=OPTIONS command line options for the linker [${LDFLAGS}]"
|
||||
echo
|
||||
exit 0 ;;
|
||||
--version | -V)
|
||||
|
|
@ -98,7 +96,6 @@ while [ $# != 0 ] ; do
|
|||
CFLAGS=*) CFLAGS=${optarg} ;;
|
||||
CFLAGS+=*) CFLAGS="${CFLAGS} ${optarg}" ;;
|
||||
LDFLAGS=*) LDFLAGS=${optarg} ;;
|
||||
MAKEINFO=*) MAKEINFO=${optarg} ;;
|
||||
|
||||
--*)
|
||||
echo "configure: WARNING: unrecognized option: '${option}'" 1>&2 ;;
|
||||
|
|
@ -109,7 +106,7 @@ while [ $# != 0 ] ; do
|
|||
exit 1 ;;
|
||||
esac
|
||||
|
||||
# Check whether the option took a separate argument
|
||||
# Check if the option took a separate argument
|
||||
if [ "${arg2}" = yes ] ; then
|
||||
if [ $# != 0 ] ; then args="${args} \"$1\"" ; shift
|
||||
else echo "configure: Missing argument to '${option}'" 1>&2
|
||||
|
|
@ -118,7 +115,7 @@ while [ $# != 0 ] ; do
|
|||
fi
|
||||
done
|
||||
|
||||
# Find the source code, if location was not specified.
|
||||
# Find the source files, if location was not specified.
|
||||
srcdirtext=
|
||||
if [ -z "${srcdir}" ] ; then
|
||||
srcdirtext="or . or .." ; srcdir=.
|
||||
|
|
@ -130,7 +127,7 @@ if [ -z "${srcdir}" ] ; then
|
|||
fi
|
||||
|
||||
if [ ! -r "${srcdir}/${srctrigger}" ] ; then
|
||||
echo "configure: Can't find source code in ${srcdir} ${srcdirtext}" 1>&2
|
||||
echo "configure: Can't find sources in ${srcdir} ${srcdirtext}" 1>&2
|
||||
echo "configure: (At least ${srctrigger} is missing)." 1>&2
|
||||
exit 1
|
||||
fi
|
||||
|
|
@ -150,7 +147,7 @@ if [ -z "${no_create}" ] ; then
|
|||
# This script is free software: you have unlimited permission
|
||||
# to copy, distribute, and modify it.
|
||||
|
||||
exec /bin/sh "$0" ${args} --no-create
|
||||
exec /bin/sh $0 ${args} --no-create
|
||||
EOF
|
||||
chmod +x config.status
|
||||
fi
|
||||
|
|
@ -167,11 +164,10 @@ echo "CC = ${CC}"
|
|||
echo "CPPFLAGS = ${CPPFLAGS}"
|
||||
echo "CFLAGS = ${CFLAGS}"
|
||||
echo "LDFLAGS = ${LDFLAGS}"
|
||||
echo "MAKEINFO = ${MAKEINFO}"
|
||||
rm -f Makefile
|
||||
cat > Makefile << EOF
|
||||
# Makefile for Xlunzip - Test tool for the lzip_decompress linux module
|
||||
# Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
# Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
# This file was generated automatically by configure. Don't edit.
|
||||
#
|
||||
# This Makefile is free software: you have unlimited permission
|
||||
|
|
@ -191,7 +187,6 @@ CC = ${CC}
|
|||
CPPFLAGS = ${CPPFLAGS}
|
||||
CFLAGS = ${CFLAGS}
|
||||
LDFLAGS = ${LDFLAGS}
|
||||
MAKEINFO = ${MAKEINFO}
|
||||
EOF
|
||||
cat "${srcdir}/Makefile.in" >> Makefile
|
||||
|
||||
|
|
|
|||
26
debian/changelog
vendored
26
debian/changelog
vendored
|
|
@ -1,29 +1,3 @@
|
|||
xlunzip (0.9-1) sid; urgency=medium
|
||||
|
||||
* Uploading to sid.
|
||||
* Merging upstream version 0.9.
|
||||
|
||||
-- Daniel Baumann <daniel.baumann@progress-linux.org> Tue, 14 Jan 2025 11:02:22 +0100
|
||||
|
||||
xlunzip (0.8-2) sid; urgency=medium
|
||||
|
||||
* Uploading to sid.
|
||||
* Updating years in copyright for 2024.
|
||||
* Updating to standards-version 4.7.0.
|
||||
|
||||
-- Daniel Baumann <daniel.baumann@progress-linux.org> Thu, 25 Jul 2024 06:55:11 +0200
|
||||
|
||||
xlunzip (0.8-1) sid; urgency=medium
|
||||
|
||||
* Uploading to sid.
|
||||
* Merging upstream version 0.8.
|
||||
* Minimizing debhelper build-depends for trixie.
|
||||
* Adding patch to avoid overriding build-environment.
|
||||
* Disabling testsuite for now as the current upstream release misses
|
||||
some files for it to run at all.
|
||||
|
||||
-- Daniel Baumann <daniel.baumann@progress-linux.org> Tue, 23 Jan 2024 06:51:16 +0100
|
||||
|
||||
xlunzip (0.7-7) sid; urgency=medium
|
||||
|
||||
* Uploading to sid.
|
||||
|
|
|
|||
3
debian/control
vendored
3
debian/control
vendored
|
|
@ -3,9 +3,10 @@ Section: utils
|
|||
Priority: optional
|
||||
Maintainer: Daniel Baumann <daniel.baumann@progress-linux.org>
|
||||
Build-Depends:
|
||||
debhelper (>= 13.1~),
|
||||
debhelper-compat (= 13),
|
||||
Rules-Requires-Root: no
|
||||
Standards-Version: 4.7.0
|
||||
Standards-Version: 4.6.2
|
||||
Homepage: http://www.nongnu.org/lzip/xlunzip.html
|
||||
Vcs-Browser: https://git.progress-linux.org/users/daniel.baumann/debian/packages/xlunzip
|
||||
Vcs-Git: https://git.progress-linux.org/users/daniel.baumann/debian/packages/xlunzip
|
||||
|
|
|
|||
6
debian/copyright
vendored
6
debian/copyright
vendored
|
|
@ -4,15 +4,15 @@ Upstream-Contact: lzip-bug@nongnu.org
|
|||
Source: https://download.savannah.gnu.org/releases/lzip/xlunzip
|
||||
|
||||
Files: *
|
||||
Copyright: 2016-2024 Antonio Diaz Diaz <ant_diaz@teleline.es>
|
||||
Copyright: 2016-2021 Antonio Diaz Diaz <ant_diaz@teleline.es>
|
||||
License: GPL-2+
|
||||
|
||||
Files: carg_parser.*
|
||||
Copyright: 2006-2024 Antonio Diaz Diaz <ant_diaz@teleline.es>
|
||||
Copyright: 2006-2021 Antonio Diaz Diaz <ant_diaz@teleline.es>
|
||||
License: BSD-2-clause
|
||||
|
||||
Files: debian/*
|
||||
Copyright: 2018-2024 Daniel Baumann <daniel.baumann@progress-linux.org>
|
||||
Copyright: 2018-2022 Daniel Baumann <daniel.baumann@progress-linux.org>
|
||||
License: GPL-2+
|
||||
|
||||
License: BSD-2-clause
|
||||
|
|
|
|||
21
debian/patches/debian/0001-build.patch
vendored
21
debian/patches/debian/0001-build.patch
vendored
|
|
@ -1,21 +0,0 @@
|
|||
Author: Daniel Baumann <daniel.baumann@progress-linux.org>
|
||||
Description: Avoid overwriting build-environment.
|
||||
|
||||
diff -Naurp xlunzip.orig/configure xlunzip/configure
|
||||
--- xlunzip.orig/configure
|
||||
+++ xlunzip/configure
|
||||
@@ -20,10 +20,10 @@ bindir='$(exec_prefix)/bin'
|
||||
datarootdir='$(prefix)/share'
|
||||
infodir='$(datarootdir)/info'
|
||||
mandir='$(datarootdir)/man'
|
||||
-CC=gcc
|
||||
-CPPFLAGS=
|
||||
-CFLAGS='-Wall -W -O2'
|
||||
-LDFLAGS=
|
||||
+#CC=gcc
|
||||
+#CPPFLAGS=
|
||||
+#CFLAGS='-Wall -W -O2'
|
||||
+#LDFLAGS=
|
||||
MAKEINFO=makeinfo
|
||||
|
||||
# checking whether we are using GNU C.
|
||||
1
debian/patches/series
vendored
1
debian/patches/series
vendored
|
|
@ -1 +0,0 @@
|
|||
debian/0001-build.patch
|
||||
3
debian/rules
vendored
3
debian/rules
vendored
|
|
@ -18,6 +18,3 @@ execute_after_dh_auto_install:
|
|||
|
||||
mv debian/xlunzip/usr/share/man/man1/xlunzip.1 debian/xlunzip/usr/share/man/man1/lzip.xlunzip.1
|
||||
ln -s /usr/share/man/man1/lzip.xlunzip.1.gz debian/xlunzip/usr/share/man/man1/xlunzip.1.gz
|
||||
|
||||
override_dh_auto_test:
|
||||
# disabled: incomplete upstream testsuite
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* Wrapper for decompressing LZIP-compressed kernel, initramfs, and initrd
|
||||
*
|
||||
* Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
* Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
*
|
||||
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
||||
*/
|
||||
|
|
@ -62,10 +62,8 @@ STATIC int INIT __lunzip(unsigned char *inbuf, long in_len,
|
|||
case LZIP_BAD_CRC:
|
||||
error("CRC mismatch in LZIP-compressed data.");
|
||||
break;
|
||||
case LZIP_EMPTY_MEMBER:
|
||||
error("Empty member in LZIP multimember data.");
|
||||
break;
|
||||
default: error("Bug in the LZIP decompressor.");
|
||||
default:
|
||||
error("Bug in the LZIP decompressor.");
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.2.
|
||||
.TH XLUNZIP "1" "January 2025" "xlunzip 0.9" "User Commands"
|
||||
.\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.47.16.
|
||||
.TH XLUNZIP "1" "January 2021" "xlunzip 0.7" "User Commands"
|
||||
.SH NAME
|
||||
xlunzip \- test tool for the lzip_decompress linux module
|
||||
.SH SYNOPSIS
|
||||
|
|
@ -10,7 +10,7 @@ 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 check that 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
|
||||
|
|
@ -77,16 +77,16 @@ Ki = KiB = 2^10 = 1024, M = 10^6, Mi = 2^20, G = 10^9, Gi = 2^30, etc...
|
|||
To extract all the files from archive 'foo.tar.lz', use the commands
|
||||
\&'tar \fB\-xf\fR foo.tar.lz' or 'xlunzip \fB\-cd\fR foo.tar.lz | tar \fB\-xf\fR \-'.
|
||||
.PP
|
||||
Exit status: 0 for a normal exit, 1 for environmental problems
|
||||
(file not found, invalid command\-line options, I/O errors, etc), 2 to
|
||||
indicate a corrupt or invalid input file, 3 for an internal consistency
|
||||
error (e.g., bug) which caused xlunzip to panic.
|
||||
Exit status: 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 xlunzip to panic.
|
||||
.SH "REPORTING BUGS"
|
||||
Report bugs to lzip\-bug@nongnu.org
|
||||
.br
|
||||
Xlunzip home page: http://www.nongnu.org/lzip/xlunzip.html
|
||||
.SH COPYRIGHT
|
||||
Copyright \(co 2025 Antonio Diaz Diaz.
|
||||
Copyright \(co 2021 Antonio Diaz Diaz.
|
||||
License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>
|
||||
.br
|
||||
This is free software: you are free to change and redistribute it.
|
||||
|
|
|
|||
30
in_place.c
30
in_place.c
|
|
@ -1,5 +1,5 @@
|
|||
/* Xlunzip - Test tool for the lzip_decompress linux module
|
||||
Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
|
||||
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
|
||||
|
|
@ -30,8 +30,8 @@
|
|||
#include "lzip.h"
|
||||
|
||||
|
||||
/* Return the number of bytes really read.
|
||||
If (value returned < size) and (errno == 0), means EOF was reached.
|
||||
/* Returns the number of bytes really read.
|
||||
If (returned value < size) and (errno == 0), means EOF was reached.
|
||||
*/
|
||||
static long readblock( const int fd, uint8_t * const buf, const long size )
|
||||
{
|
||||
|
|
@ -49,9 +49,9 @@ static long readblock( const int fd, uint8_t * const buf, const long size )
|
|||
}
|
||||
|
||||
|
||||
/* Return the address of a malloc'd buffer containing the file data and
|
||||
/* Returns the address of a malloc'd buffer containing the file data and
|
||||
the buffer and file sizes in '*buffer_sizep' and '*file_sizep'.
|
||||
In case of error, return 0 and do not modify '*sizep'.
|
||||
In case of error, returns 0 and does not modify '*size'.
|
||||
*/
|
||||
static uint8_t * read_file( const int infd, long * const buffer_sizep,
|
||||
long * const file_sizep, const char * const filename )
|
||||
|
|
@ -64,8 +64,8 @@ static uint8_t * read_file( const int infd, long * const buffer_sizep,
|
|||
while( file_size >= buffer_size && !errno )
|
||||
{
|
||||
if( buffer_size >= LONG_MAX )
|
||||
{ show_file_error( filename, "Input file is too large.", 0 );
|
||||
free( buffer ); return 0; }
|
||||
{ show_file_error( filename, "File is too large.", 0 ); free( buffer );
|
||||
return 0; }
|
||||
buffer_size = ( buffer_size <= LONG_MAX / 2 ) ? 2 * buffer_size : LONG_MAX;
|
||||
uint8_t * const tmp = (uint8_t *)realloc( buffer, buffer_size );
|
||||
if( !tmp )
|
||||
|
|
@ -95,11 +95,11 @@ static const char * set_file_sizes( struct File_sizes * const file_sizes,
|
|||
const unsigned long file_size )
|
||||
{
|
||||
if( file_size <= Lh_size ) return "File ends unexpectedly at member header.";
|
||||
if( file_size < min_member_size ) return "Input file is truncated.";
|
||||
if( file_size < min_member_size ) return "Input file is too short.";
|
||||
const Lzip_header * header = (const Lzip_header *)buffer;
|
||||
if( !Lh_check_magic( *header ) )
|
||||
if( !Lh_verify_magic( *header ) )
|
||||
return "Bad magic number (file not in lzip format).";
|
||||
if( !Lh_check_version( *header ) )
|
||||
if( !Lh_verify_version( *header ) )
|
||||
return "Version of lzip member format not supported.";
|
||||
|
||||
file_sizes->csize = file_sizes->dsize = file_sizes->tsize = 0;
|
||||
|
|
@ -122,7 +122,7 @@ static const char * set_file_sizes( struct File_sizes * const file_sizes,
|
|||
return "Member size in trailer is corrupt.";
|
||||
}
|
||||
header = (const Lzip_header *)( buffer + pos - member_size );
|
||||
if( !Lh_check_magic( *header ) || !Lh_check_version( *header ) )
|
||||
if( !Lh_verify_magic( *header ) || !Lh_verify_version( *header ) )
|
||||
{
|
||||
if( file_sizes->csize == 0 ) { --pos; continue; } /* maybe trailing data */
|
||||
return "Bad member header inside file.";
|
||||
|
|
@ -132,7 +132,7 @@ static const char * set_file_sizes( struct File_sizes * const file_sizes,
|
|||
file_sizes->tsize = file_size - pos;
|
||||
header = (const Lzip_header *)( buffer + pos );
|
||||
if( file_size - pos > Lh_size &&
|
||||
Lh_check_magic( *header ) && Lh_check_version( *header ) )
|
||||
Lh_verify_magic( *header ) && Lh_verify_version( *header ) )
|
||||
return "Last member in input file is truncated or corrupt.";
|
||||
}
|
||||
pos -= member_size;
|
||||
|
|
@ -155,7 +155,7 @@ 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. Check that the in-place decompression does not
|
||||
* decompressed data. Verify that the in-place decompression does not
|
||||
* 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.
|
||||
|
|
@ -167,7 +167,7 @@ static void error(char *x) { show_file_error( global_name, x, 0 ); }
|
|||
* |-------- decompressed data ---------|
|
||||
*/
|
||||
|
||||
int decompress_in_place( const int infd, Pretty_print * const pp,
|
||||
int decompress_in_place( const int infd, struct Pretty_print * const pp,
|
||||
const bool testing )
|
||||
{
|
||||
long buffer_size = 0, file_size = 0;
|
||||
|
|
@ -180,7 +180,7 @@ int decompress_in_place( const int infd, Pretty_print * const pp,
|
|||
const long csize = file_sizes.csize;
|
||||
const long dsize = file_sizes.dsize;
|
||||
/* const long extra_bytes = ( dsize >> 8 ) + 65536; wrong linux formula */
|
||||
const long extra_bytes = ( csize >> 6 ) + file_sizes.members * min_member_size;
|
||||
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 );
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
/*
|
||||
* LZIP decompressor
|
||||
*
|
||||
* Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
* Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
*/
|
||||
|
||||
/* Return values (< 0 = Error) */
|
||||
|
|
@ -20,8 +20,7 @@ enum {
|
|||
LZIP_WRITE_ERROR = -9,
|
||||
LZIP_BAD_DATA = -10,
|
||||
LZIP_DATA_EOF = -11,
|
||||
LZIP_BAD_CRC = -12,
|
||||
LZIP_EMPTY_MEMBER = -13
|
||||
LZIP_BAD_CRC = -12
|
||||
};
|
||||
|
||||
int lzip_decompress(unsigned char *inbuf, long in_len,
|
||||
|
|
|
|||
26
lzip.h
26
lzip.h
|
|
@ -1,5 +1,5 @@
|
|||
/* Xlunzip - Test tool for the lzip_decompress linux module
|
||||
Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
|
||||
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
|
||||
|
|
@ -30,35 +30,35 @@ enum {
|
|||
min_member_size = 36 };
|
||||
|
||||
|
||||
typedef struct Pretty_print
|
||||
struct Pretty_print
|
||||
{
|
||||
const char * name;
|
||||
char * padded_name;
|
||||
const char * stdin_name;
|
||||
unsigned longest_name;
|
||||
bool first_post;
|
||||
} Pretty_print;
|
||||
};
|
||||
|
||||
|
||||
static const uint8_t lzip_magic[4] = { 0x4C, 0x5A, 0x49, 0x50 }; /* "LZIP" */
|
||||
|
||||
enum { Lh_size = 6 };
|
||||
typedef uint8_t Lzip_header[Lh_size]; /* 0-3 magic bytes */
|
||||
typedef uint8_t Lzip_header[6]; /* 0-3 magic bytes */
|
||||
/* 4 version */
|
||||
/* 5 coded dictionary size */
|
||||
enum { Lh_size = 6 };
|
||||
|
||||
static inline bool Lh_check_magic( const Lzip_header data )
|
||||
{ return memcmp( data, lzip_magic, 4 ) == 0; }
|
||||
static inline bool Lh_verify_magic( const Lzip_header data )
|
||||
{ return ( memcmp( data, lzip_magic, 4 ) == 0 ); }
|
||||
|
||||
static inline bool Lh_check_version( const Lzip_header data )
|
||||
{ return data[4] == 1; }
|
||||
static inline bool Lh_verify_version( const Lzip_header data )
|
||||
{ return ( data[4] == 1 ); }
|
||||
|
||||
|
||||
enum { Lt_size = 20 };
|
||||
typedef uint8_t Lzip_trailer[Lt_size];
|
||||
typedef uint8_t Lzip_trailer[20];
|
||||
/* 0-3 CRC32 of the uncompressed data */
|
||||
/* 4-11 size of the uncompressed data */
|
||||
/* 12-19 member size including header and trailer */
|
||||
enum { Lt_size = 20 };
|
||||
|
||||
static inline unsigned long long Lt_get_data_size( const Lzip_trailer data )
|
||||
{
|
||||
|
|
@ -81,13 +81,13 @@ static inline void set_retval( int * retval, const int new_val )
|
|||
static const char * const mem_msg = "Not enough memory.";
|
||||
|
||||
/* defined in in_place.c */
|
||||
int decompress_in_place( const int infd, Pretty_print * const pp,
|
||||
int decompress_in_place( const int infd, struct Pretty_print * const pp,
|
||||
const bool testing );
|
||||
|
||||
/* defined in main.c */
|
||||
int convert_retval( const int retval );
|
||||
long flush( void * buf, unsigned long size );
|
||||
void show_results( Pretty_print * const pp, const long in_pos,
|
||||
void show_results( struct Pretty_print * const pp, const long in_pos,
|
||||
const long out_pos, const bool testing );
|
||||
void show_file_error( const char * const filename, const char * const msg,
|
||||
const int errcode );
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* LZIP decompressor
|
||||
*
|
||||
* Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
* Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
*
|
||||
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
||||
*/
|
||||
|
|
@ -32,17 +32,17 @@ static inline State St_set_char(const State st)
|
|||
|
||||
static inline State St_set_match(const State st)
|
||||
{
|
||||
return (st < 7) ? 7 : 10;
|
||||
return ((st < 7) ? 7 : 10);
|
||||
}
|
||||
|
||||
static inline State St_set_rep(const State st)
|
||||
{
|
||||
return (st < 7) ? 8 : 11;
|
||||
return ((st < 7) ? 8 : 11);
|
||||
}
|
||||
|
||||
static inline State St_set_shortrep(const State st)
|
||||
static inline State St_set_short_rep(const State st)
|
||||
{
|
||||
return (st < 7) ? 9 : 11;
|
||||
return ((st < 7) ? 9 : 11);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -189,12 +189,12 @@ static inline void CRC32_update_buf(uint32_t * const crc,
|
|||
|
||||
STATIC_RW_DATA const uint8_t lzip_magic[4] = { 0x4C, 0x5A, 0x49, 0x50 }; /* "LZIP" */
|
||||
|
||||
enum { Lh_size = 6 };
|
||||
typedef uint8_t Lzip_header[Lh_size]; /* 0-3 magic bytes */
|
||||
typedef uint8_t Lzip_header[6]; /* 0-3 magic bytes */
|
||||
/* 4 version */
|
||||
/* 5 coded dictionary size */
|
||||
enum { Lh_size = 6 };
|
||||
|
||||
static inline bool Lh_check_magic(const Lzip_header data)
|
||||
static inline bool Lh_verify_magic(const Lzip_header data)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
@ -205,34 +205,34 @@ static inline bool Lh_check_magic(const Lzip_header data)
|
|||
}
|
||||
|
||||
/* detect (truncated) header */
|
||||
static inline bool Lh_check_prefix(const Lzip_header data, const int sz)
|
||||
static inline bool Lh_verify_prefix(const Lzip_header data, const int sz)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < sz && i < 4; ++i)
|
||||
if (data[i] != lzip_magic[i])
|
||||
return false;
|
||||
return sz > 0;
|
||||
return (sz > 0);
|
||||
}
|
||||
|
||||
/* detect corrupt header */
|
||||
static inline bool Lh_check_corrupt(const Lzip_header data)
|
||||
static inline bool Lh_verify_corrupt(const Lzip_header data)
|
||||
{
|
||||
int matches = 0;
|
||||
int i;
|
||||
for (i = 0; i < 4; ++i)
|
||||
if (data[i] == lzip_magic[i])
|
||||
++matches;
|
||||
return matches > 1 && matches < 4;
|
||||
return (matches > 1 && matches < 4);
|
||||
}
|
||||
|
||||
static inline bool Lh_check_version(const Lzip_header data)
|
||||
static inline bool Lh_verify_version(const Lzip_header data)
|
||||
{
|
||||
return data[4] == 1;
|
||||
return (data[4] == 1);
|
||||
}
|
||||
|
||||
static inline unsigned Lh_get_dictionary_size(const Lzip_header data)
|
||||
{
|
||||
unsigned sz = 1 << (data[5] & 0x1F);
|
||||
unsigned sz = (1 << (data[5] & 0x1F));
|
||||
|
||||
if (sz > min_dictionary_size)
|
||||
sz -= (sz / 16) * ((data[5] >> 5) & 7);
|
||||
|
|
@ -240,11 +240,11 @@ static inline unsigned Lh_get_dictionary_size(const Lzip_header data)
|
|||
}
|
||||
|
||||
|
||||
enum { Lt_size = 20 };
|
||||
typedef uint8_t Lzip_trailer[Lt_size];
|
||||
typedef uint8_t Lzip_trailer[20];
|
||||
/* 0-3 CRC32 of the uncompressed data */
|
||||
/* 4-11 size of the uncompressed data */
|
||||
/* 12-19 member size including header and trailer */
|
||||
enum { Lt_size = 20 };
|
||||
|
||||
static inline unsigned Lt_get_data_crc(const Lzip_trailer data)
|
||||
{
|
||||
|
|
@ -359,17 +359,14 @@ static inline uint8_t Rd_get_byte(struct Range_decoder * const rdec)
|
|||
return rdec->buffer[rdec->pos++];
|
||||
}
|
||||
|
||||
static inline bool Rd_load(struct Range_decoder * const rdec)
|
||||
static inline void Rd_load(struct Range_decoder * const rdec)
|
||||
{
|
||||
int i;
|
||||
|
||||
rdec->code = 0;
|
||||
for (i = 0; i < 5; ++i)
|
||||
rdec->code = (rdec->code << 8) | Rd_get_byte(rdec);
|
||||
rdec->range = 0xFFFFFFFFU;
|
||||
/* check first byte of the LZMA stream */
|
||||
if (Rd_get_byte(rdec) != 0)
|
||||
return false;
|
||||
for (i = 0; i < 4; ++i) rdec->code = (rdec->code << 8) | Rd_get_byte(rdec);
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline void Rd_normalize(struct Range_decoder * const rdec)
|
||||
|
|
@ -503,12 +500,11 @@ static inline unsigned Rd_decode_len(struct Range_decoder * const rdec,
|
|||
const int pos_state)
|
||||
{
|
||||
if (Rd_decode_bit(rdec, &lm->choice1) == 0)
|
||||
return min_match_len +
|
||||
Rd_decode_tree3(rdec, lm->bm_low[pos_state]);
|
||||
return Rd_decode_tree3(rdec, lm->bm_low[pos_state]);
|
||||
if (Rd_decode_bit(rdec, &lm->choice2) == 0)
|
||||
return min_match_len + len_low_symbols +
|
||||
return len_low_symbols +
|
||||
Rd_decode_tree3(rdec, lm->bm_mid[pos_state]);
|
||||
return min_match_len + len_low_symbols + len_mid_symbols +
|
||||
return len_low_symbols + len_mid_symbols +
|
||||
Rd_decode_tree8(rdec, lm->bm_high);
|
||||
}
|
||||
|
||||
|
|
@ -672,7 +668,7 @@ LZd_data_position(const struct LZ_decoder * const d)
|
|||
}
|
||||
|
||||
|
||||
static bool LZd_check_trailer(struct LZ_decoder * const d)
|
||||
static bool LZd_verify_trailer(struct LZ_decoder * const d)
|
||||
{
|
||||
Lzip_trailer trailer;
|
||||
int i = 0;
|
||||
|
|
@ -680,9 +676,9 @@ static bool LZd_check_trailer(struct LZ_decoder * const d)
|
|||
while (i < Lt_size)
|
||||
trailer[i++] = Rd_get_byte(d->rdec);
|
||||
|
||||
return Lt_get_data_crc(trailer) == LZd_crc(d) &&
|
||||
return (Lt_get_data_crc(trailer) == LZd_crc(d) &&
|
||||
Lt_get_data_size(trailer) == LZd_data_position(d) &&
|
||||
Lt_get_member_size(trailer) == Rd_member_position(d->rdec);
|
||||
Lt_get_member_size(trailer) == Rd_member_position(d->rdec));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -696,8 +692,7 @@ static int LZd_decode_member(struct LZ_decoder * const d)
|
|||
unsigned rep3 = 0;
|
||||
State state = 0;
|
||||
|
||||
if (!Rd_load(rdec))
|
||||
return LZIP_BAD_DATA;
|
||||
Rd_load(rdec);
|
||||
while (!Rd_finished(rdec)) {
|
||||
int len;
|
||||
const int pos_state = LZd_data_position(d) & pos_state_mask;
|
||||
|
|
@ -719,7 +714,7 @@ static int LZd_decode_member(struct LZ_decoder * const d)
|
|||
if (Rd_decode_bit(rdec, &d->bm_rep[state]) != 0) {
|
||||
if (Rd_decode_bit(rdec, &d->bm_rep0[state]) == 0) {
|
||||
if (Rd_decode_bit(rdec, &d->bm_len[state][pos_state]) == 0) {
|
||||
state = St_set_shortrep(state);
|
||||
state = St_set_short_rep(state);
|
||||
LZd_put_byte(d, LZd_peek(d, rep0));
|
||||
continue;
|
||||
}
|
||||
|
|
@ -741,37 +736,44 @@ static int LZd_decode_member(struct LZ_decoder * const d)
|
|||
rep0 = distance;
|
||||
}
|
||||
state = St_set_rep(state);
|
||||
len = Rd_decode_len(rdec, &d->rep_len_model, pos_state);
|
||||
len = min_match_len + Rd_decode_len(rdec, &d->rep_len_model, pos_state);
|
||||
} else { /* match */
|
||||
rep3 = rep2; rep2 = rep1; rep1 = rep0;
|
||||
len = Rd_decode_len(rdec, &d->match_len_model, pos_state);
|
||||
rep0 = Rd_decode_tree6(rdec, d->bm_dis_slot[get_len_state(len)]);
|
||||
if (rep0 >= start_dis_model) {
|
||||
const unsigned dis_slot = rep0;
|
||||
unsigned distance;
|
||||
|
||||
len = min_match_len + Rd_decode_len(rdec, &d->match_len_model, pos_state);
|
||||
distance = Rd_decode_tree6(rdec, d->bm_dis_slot[get_len_state(len)]);
|
||||
if (distance >= start_dis_model) {
|
||||
const unsigned dis_slot = distance;
|
||||
const int direct_bits = (dis_slot >> 1) - 1;
|
||||
|
||||
rep0 = (2 | (dis_slot & 1)) << direct_bits;
|
||||
distance = (2 | (dis_slot & 1)) << direct_bits;
|
||||
if (dis_slot < end_dis_model)
|
||||
rep0 += Rd_decode_tree_reversed(rdec,
|
||||
d->bm_dis + (rep0 - dis_slot), direct_bits);
|
||||
distance += Rd_decode_tree_reversed(rdec,
|
||||
d->bm_dis + (distance - dis_slot), direct_bits);
|
||||
else {
|
||||
rep0 += Rd_decode(rdec, direct_bits - dis_align_bits) << dis_align_bits;
|
||||
rep0 += Rd_decode_tree_reversed4(rdec, d->bm_align);
|
||||
if (rep0 == 0xFFFFFFFFU) { /* marker found */
|
||||
distance +=
|
||||
Rd_decode(rdec, direct_bits - dis_align_bits) << dis_align_bits;
|
||||
distance += Rd_decode_tree_reversed4(rdec, d->bm_align);
|
||||
if (distance == 0xFFFFFFFFU) { /* marker found */
|
||||
Rd_normalize(rdec);
|
||||
LZd_flush_data(d);
|
||||
if (d->write_error)
|
||||
return LZIP_WRITE_ERROR;
|
||||
if (len == min_match_len) { /* End Of Stream marker */
|
||||
if (LZd_check_trailer(d))
|
||||
if (LZd_verify_trailer(d))
|
||||
return 0;
|
||||
else
|
||||
return LZIP_BAD_CRC;
|
||||
}
|
||||
if (len == min_match_len + 1) { /* Sync Flush marker */
|
||||
Rd_load(rdec);
|
||||
continue;
|
||||
}
|
||||
return LZIP_BAD_DATA; /* unknown marker */
|
||||
}
|
||||
}
|
||||
}
|
||||
rep3 = rep2; rep2 = rep1; rep1 = rep0; rep0 = distance;
|
||||
state = St_set_match(state);
|
||||
if (rep0 >= d->dictionary_size ||
|
||||
(rep0 >= d->pos && !d->pos_wrapped)) {
|
||||
|
|
@ -797,7 +799,6 @@ int lzip_decompress(unsigned char *inbuf, long in_len,
|
|||
struct LZ_decoder *decoder = 0;
|
||||
int retval = 0;
|
||||
bool first_member;
|
||||
bool empty = false, multi = false;
|
||||
|
||||
if (in_posp)
|
||||
*in_posp = 0;
|
||||
|
|
@ -819,18 +820,18 @@ int lzip_decompress(unsigned char *inbuf, long in_len,
|
|||
if (Rd_finished(&rdec)) { /* End Of File */
|
||||
if (first_member)
|
||||
retval = LZIP_HEADER1_EOF;
|
||||
else if (Lh_check_prefix(header, size))
|
||||
else if (Lh_verify_prefix(header, size))
|
||||
retval = LZIP_HEADER2_EOF;
|
||||
break;
|
||||
}
|
||||
if (!Lh_check_magic(header)) {
|
||||
if (!Lh_verify_magic(header)) {
|
||||
if (first_member)
|
||||
retval = LZIP_BAD_MAGIC1;
|
||||
else if (Lh_check_corrupt(header))
|
||||
else if (Lh_verify_corrupt(header))
|
||||
retval = LZIP_BAD_MAGIC2;
|
||||
break;
|
||||
}
|
||||
if (!Lh_check_version(header)) {
|
||||
if (!Lh_verify_version(header)) {
|
||||
retval = LZIP_BAD_VERSION;
|
||||
break;
|
||||
}
|
||||
|
|
@ -851,9 +852,7 @@ int lzip_decompress(unsigned char *inbuf, long in_len,
|
|||
retval = LZd_decode_member(decoder);
|
||||
if (in_posp)
|
||||
*in_posp += Rd_member_position(&rdec);
|
||||
multi = !first_member;
|
||||
data_pos = LZd_data_position(decoder);
|
||||
if (data_pos == 0) empty = true;
|
||||
if (outptr)
|
||||
outptr += data_pos;
|
||||
if (out_posp)
|
||||
|
|
@ -867,8 +866,6 @@ int lzip_decompress(unsigned char *inbuf, long in_len,
|
|||
if (decoder)
|
||||
free(decoder);
|
||||
Rd_free(&rdec);
|
||||
if (empty && multi && retval == 0)
|
||||
retval = LZIP_EMPTY_MEMBER;
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
|
|
|||
247
main.c
247
main.c
|
|
@ -1,5 +1,5 @@
|
|||
/* Xlunzip - Test tool for the lzip_decompress linux module
|
||||
Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
|
||||
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
|
||||
|
|
@ -16,9 +16,9 @@
|
|||
*/
|
||||
/*
|
||||
Exit status: 0 for a normal exit, 1 for environmental problems
|
||||
(file not found, invalid command-line options, I/O errors, etc), 2 to
|
||||
indicate a corrupt or invalid input file, 3 for an internal consistency
|
||||
error (e.g., bug) which caused xlunzip to panic.
|
||||
(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 xlunzip to panic.
|
||||
*/
|
||||
|
||||
#define _FILE_OFFSET_BITS 64
|
||||
|
|
@ -26,19 +26,19 @@
|
|||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <limits.h> /* CHAR_BIT, SSIZE_MAX */
|
||||
#include <limits.h>
|
||||
#include <signal.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h> /* SIZE_MAX */
|
||||
#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__ || defined __OS2__ || defined __DJGPP__
|
||||
#if defined(__MSVCRT__) || defined(__OS2__) || defined(__DJGPP__)
|
||||
#include <io.h>
|
||||
#if defined __MSVCRT__
|
||||
#if defined(__MSVCRT__)
|
||||
#define fchmod(x,y) 0
|
||||
#define fchown(x,y,z) 0
|
||||
#define SIGHUP SIGTERM
|
||||
|
|
@ -50,7 +50,7 @@
|
|||
#define S_IWOTH 0
|
||||
#endif
|
||||
#endif
|
||||
#if defined __DJGPP__
|
||||
#if defined(__DJGPP__)
|
||||
#define S_ISSOCK(x) 0
|
||||
#define S_ISVTX 0
|
||||
#endif
|
||||
|
|
@ -69,18 +69,13 @@
|
|||
#error "Environments where CHAR_BIT != 8 are not supported."
|
||||
#endif
|
||||
|
||||
#if ( defined SIZE_MAX && SIZE_MAX < ULONG_MAX ) || \
|
||||
( defined SSIZE_MAX && SSIZE_MAX < LONG_MAX )
|
||||
#error "Environments where 'size_t' is narrower than 'long' are not supported."
|
||||
#endif
|
||||
|
||||
static int verbosity = 0;
|
||||
static void cleanup_and_fail( const int retval );
|
||||
static void show_error( const char * const msg, const int errcode,
|
||||
const bool help );
|
||||
|
||||
static const char * const program_name = "xlunzip";
|
||||
static const char * const program_year = "2025";
|
||||
static const char * const program_year = "2021";
|
||||
static const char * invocation_name = "xlunzip"; /* default value */
|
||||
|
||||
static const struct { const char * from; const char * to; } known_extensions[] = {
|
||||
|
|
@ -88,6 +83,8 @@ static const struct { const char * from; const char * to; } known_extensions[] =
|
|||
{ ".tlz", ".tar" },
|
||||
{ 0, 0 } };
|
||||
|
||||
static int infd = -1; /* needed by the fill function */
|
||||
|
||||
/* Variables used in signal handler context.
|
||||
They are not declared volatile because the handler never returns. */
|
||||
static char * output_filename = 0;
|
||||
|
|
@ -101,7 +98,7 @@ static void show_help( void )
|
|||
"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 check that 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"
|
||||
|
|
@ -135,10 +132,10 @@ static void show_help( void )
|
|||
"Ki = KiB = 2^10 = 1024, M = 10^6, Mi = 2^20, G = 10^9, Gi = 2^30, etc...\n"
|
||||
"\nTo extract all the files from archive 'foo.tar.lz', use the commands\n"
|
||||
"'tar -xf foo.tar.lz' or 'xlunzip -cd foo.tar.lz | tar -xf -'.\n"
|
||||
"\nExit status: 0 for a normal exit, 1 for environmental problems\n"
|
||||
"(file not found, invalid command-line options, I/O errors, etc), 2 to\n"
|
||||
"indicate a corrupt or invalid input file, 3 for an internal consistency\n"
|
||||
"error (e.g., bug) which caused xlunzip to panic.\n"
|
||||
"\nExit status: 0 for a normal exit, 1 for environmental problems (file\n"
|
||||
"not found, invalid flags, I/O errors, etc), 2 to indicate a corrupt or\n"
|
||||
"invalid input file, 3 for an internal consistency error (eg, bug) which\n"
|
||||
"caused xlunzip to panic.\n"
|
||||
"\nReport bugs to lzip-bug@nongnu.org\n"
|
||||
"Xlunzip home page: http://www.nongnu.org/lzip/xlunzip.html\n" );
|
||||
}
|
||||
|
|
@ -164,9 +161,11 @@ static void * resize_buffer( void * buf, const unsigned min_size )
|
|||
}
|
||||
|
||||
|
||||
static void Pp_init( Pretty_print * const pp,
|
||||
static void Pp_init( struct Pretty_print * const pp,
|
||||
const char * const filenames[], const int num_filenames )
|
||||
{
|
||||
unsigned stdin_name_len;
|
||||
int i;
|
||||
pp->name = 0;
|
||||
pp->padded_name = 0;
|
||||
pp->stdin_name = "(stdin)";
|
||||
|
|
@ -174,8 +173,7 @@ static void Pp_init( Pretty_print * const pp,
|
|||
pp->first_post = false;
|
||||
|
||||
if( verbosity <= 0 ) return;
|
||||
const unsigned stdin_name_len = strlen( pp->stdin_name );
|
||||
int i;
|
||||
stdin_name_len = strlen( pp->stdin_name );
|
||||
for( i = 0; i < num_filenames; ++i )
|
||||
{
|
||||
const char * const s = filenames[i];
|
||||
|
|
@ -185,10 +183,8 @@ static void Pp_init( Pretty_print * const pp,
|
|||
if( pp->longest_name == 0 ) pp->longest_name = stdin_name_len;
|
||||
}
|
||||
|
||||
void Pp_free( Pretty_print * const pp )
|
||||
{ if( pp->padded_name ) { free( pp->padded_name ); pp->padded_name = 0; } }
|
||||
|
||||
static void Pp_set_name( Pretty_print * const pp, const char * const filename )
|
||||
static void Pp_set_name( struct Pretty_print * const pp,
|
||||
const char * const filename )
|
||||
{
|
||||
unsigned name_len, padded_name_len, i = 0;
|
||||
|
||||
|
|
@ -206,9 +202,10 @@ static void Pp_set_name( Pretty_print * const pp, const char * const filename )
|
|||
pp->first_post = true;
|
||||
}
|
||||
|
||||
static void Pp_show_msg( Pretty_print * const pp, const char * const msg )
|
||||
static void Pp_show_msg( struct Pretty_print * const pp, const char * const msg )
|
||||
{
|
||||
if( verbosity >= 0 )
|
||||
{
|
||||
if( verbosity < 0 ) return;
|
||||
if( pp->first_post )
|
||||
{
|
||||
pp->first_post = false;
|
||||
|
|
@ -217,63 +214,22 @@ static void Pp_show_msg( Pretty_print * const pp, const char * const msg )
|
|||
}
|
||||
if( msg ) fprintf( stderr, "%s\n", msg );
|
||||
}
|
||||
|
||||
|
||||
/* separate numbers of 5 or more digits in groups of 3 digits using '_' */
|
||||
static const char * format_num3( unsigned long long num )
|
||||
{
|
||||
enum { buffers = 8, bufsize = 4 * sizeof num, n = 10 };
|
||||
const char * const si_prefix = "kMGTPEZYRQ";
|
||||
const char * const binary_prefix = "KMGTPEZYRQ";
|
||||
static char buffer[buffers][bufsize]; /* circle of static buffers for printf */
|
||||
static int current = 0;
|
||||
int i;
|
||||
char * const buf = buffer[current++]; current %= buffers;
|
||||
char * p = buf + bufsize - 1; /* fill the buffer backwards */
|
||||
*p = 0; /* terminator */
|
||||
if( num > 9999 )
|
||||
{
|
||||
char prefix = 0; /* try binary first, then si */
|
||||
for( i = 0; i < n && num != 0 && num % 1024 == 0; ++i )
|
||||
{ num /= 1024; prefix = binary_prefix[i]; }
|
||||
if( prefix ) *(--p) = 'i';
|
||||
else
|
||||
for( i = 0; i < n && num != 0 && num % 1000 == 0; ++i )
|
||||
{ num /= 1000; prefix = si_prefix[i]; }
|
||||
if( prefix ) *(--p) = prefix;
|
||||
}
|
||||
const bool split = num >= 10000;
|
||||
|
||||
for( i = 0; ; )
|
||||
{
|
||||
*(--p) = num % 10 + '0'; num /= 10; if( num == 0 ) break;
|
||||
if( split && ++i >= 3 ) { i = 0; *(--p) = '_'; }
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
void show_option_error( const char * const arg, const char * const msg,
|
||||
const char * const option_name )
|
||||
{
|
||||
if( verbosity >= 0 )
|
||||
fprintf( stderr, "%s: '%s': %s option '%s'.\n",
|
||||
program_name, arg, msg, option_name );
|
||||
}
|
||||
|
||||
|
||||
/* Recognized formats: <num>k, <num>Ki, <num>[MGTPEZYRQ][i] */
|
||||
static unsigned long getnum( const char * const arg,
|
||||
const char * const option_name,
|
||||
static unsigned long getnum( const char * const ptr,
|
||||
const unsigned long llimit,
|
||||
const unsigned long ulimit )
|
||||
{
|
||||
unsigned long result;
|
||||
char * tail;
|
||||
errno = 0;
|
||||
unsigned long result = strtoul( arg, &tail, 0 );
|
||||
if( tail == arg )
|
||||
{ show_option_error( arg, "Bad or missing numerical argument in",
|
||||
option_name ); exit( 1 ); }
|
||||
result = strtoul( ptr, &tail, 0 );
|
||||
if( tail == ptr )
|
||||
{
|
||||
show_error( "Bad or missing numerical argument.", 0, true );
|
||||
exit( 1 );
|
||||
}
|
||||
|
||||
if( !errno && tail[0] )
|
||||
{
|
||||
|
|
@ -282,8 +238,6 @@ static unsigned long getnum( const char * const arg,
|
|||
int i;
|
||||
switch( tail[0] )
|
||||
{
|
||||
case 'Q': exponent = 10; break;
|
||||
case 'R': exponent = 9; break;
|
||||
case 'Y': exponent = 8; break;
|
||||
case 'Z': exponent = 7; break;
|
||||
case 'E': exponent = 6; break;
|
||||
|
|
@ -295,8 +249,10 @@ static unsigned long getnum( const char * const arg,
|
|||
case 'k': if( factor == 1000 ) exponent = 1; break;
|
||||
}
|
||||
if( exponent <= 0 )
|
||||
{ show_option_error( arg, "Bad multiplier in numerical argument of",
|
||||
option_name ); exit( 1 ); }
|
||||
{
|
||||
show_error( "Bad multiplier in numerical argument.", 0, true );
|
||||
exit( 1 );
|
||||
}
|
||||
for( i = 0; i < exponent; ++i )
|
||||
{
|
||||
if( ulimit / factor >= result ) result *= factor;
|
||||
|
|
@ -306,10 +262,7 @@ static unsigned long getnum( const char * const arg,
|
|||
if( !errno && ( result < llimit || result > ulimit ) ) errno = ERANGE;
|
||||
if( errno )
|
||||
{
|
||||
if( verbosity >= 0 )
|
||||
fprintf( stderr, "%s: '%s': Value out of limits [%s,%s] in "
|
||||
"option '%s'.\n", program_name, arg, format_num3( llimit ),
|
||||
format_num3( ulimit ), option_name );
|
||||
show_error( "Numerical argument out of limits.", 0, false );
|
||||
exit( 1 );
|
||||
}
|
||||
return result;
|
||||
|
|
@ -352,7 +305,7 @@ static void set_d_outname( const char * const name, const int eindex )
|
|||
strcpy( output_filename, name );
|
||||
strcat( output_filename, ".out" );
|
||||
if( verbosity >= 1 )
|
||||
fprintf( stderr, "%s: %s: Can't guess original name -- using '%s'\n",
|
||||
fprintf( stderr, "%s: Can't guess original name for '%s' -- using '%s'\n",
|
||||
program_name, name, output_filename );
|
||||
}
|
||||
|
||||
|
|
@ -367,13 +320,13 @@ static int open_instream( const char * const name, struct stat * const in_statsp
|
|||
{
|
||||
const int i = fstat( infd, in_statsp );
|
||||
const mode_t mode = in_statsp->st_mode;
|
||||
const bool can_read = i == 0 &&
|
||||
const bool can_read = ( i == 0 &&
|
||||
( S_ISBLK( mode ) || S_ISCHR( mode ) ||
|
||||
S_ISFIFO( mode ) || S_ISSOCK( mode ) );
|
||||
S_ISFIFO( mode ) || S_ISSOCK( mode ) ) );
|
||||
if( i != 0 || ( !S_ISREG( mode ) && ( !can_read || one_to_one ) ) )
|
||||
{
|
||||
if( verbosity >= 0 )
|
||||
fprintf( stderr, "%s: %s: Input file is not a regular file%s.\n",
|
||||
fprintf( stderr, "%s: Input file '%s' is not a regular file%s.\n",
|
||||
program_name, name, ( can_read && one_to_one ) ?
|
||||
",\n and neither '-c' nor '-o' were specified" : "" );
|
||||
close( infd );
|
||||
|
|
@ -394,12 +347,16 @@ static bool open_outstream( const bool force, const bool protect )
|
|||
|
||||
outfd = open( output_filename, flags, outfd_mode );
|
||||
if( outfd >= 0 ) delete_output_on_interrupt = true;
|
||||
else if( errno == EEXIST )
|
||||
show_file_error( output_filename,
|
||||
"Output file already exists, skipping.", 0 );
|
||||
else if( verbosity >= 0 )
|
||||
{
|
||||
if( errno == EEXIST )
|
||||
fprintf( stderr, "%s: Output file '%s' already exists, skipping.\n",
|
||||
program_name, output_filename );
|
||||
else
|
||||
show_file_error( output_filename, "Can't create output file", errno );
|
||||
return outfd >= 0;
|
||||
fprintf( stderr, "%s: Can't create output file '%s': %s\n",
|
||||
program_name, output_filename, strerror( errno ) );
|
||||
}
|
||||
return ( outfd >= 0 );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -417,10 +374,12 @@ static void cleanup_and_fail( const int retval )
|
|||
if( delete_output_on_interrupt )
|
||||
{
|
||||
delete_output_on_interrupt = false;
|
||||
show_file_error( output_filename, "Deleting output file, if it exists.", 0 );
|
||||
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 failed", errno, false );
|
||||
show_error( "WARNING: deletion of output file (apparently) failed.", 0, false );
|
||||
}
|
||||
exit( retval );
|
||||
}
|
||||
|
|
@ -440,7 +399,7 @@ static bool check_tty_in( const char * const input_filename, const int infd,
|
|||
if( isatty( infd ) ) /* for example /dev/tty */
|
||||
{ show_file_error( input_filename,
|
||||
"I won't read compressed data from a terminal.", 0 );
|
||||
close( infd ); set_retval( retval, 2 );
|
||||
close( infd ); set_retval( retval, 1 );
|
||||
if( !testing ) cleanup_and_fail( *retval );
|
||||
return false; }
|
||||
return true;
|
||||
|
|
@ -454,7 +413,7 @@ static void close_and_set_permissions( const struct stat * const in_statsp )
|
|||
if( in_statsp )
|
||||
{
|
||||
const mode_t mode = in_statsp->st_mode;
|
||||
/* fchown in many cases returns with EPERM, which can be safely ignored. */
|
||||
/* 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 )
|
||||
{ if( fchmod( outfd, mode ) != 0 ) warning = true; }
|
||||
else
|
||||
|
|
@ -463,8 +422,10 @@ static void close_and_set_permissions( const struct stat * const in_statsp )
|
|||
warning = true;
|
||||
}
|
||||
if( close( outfd ) != 0 )
|
||||
{ show_file_error( output_filename, "Error closing output file", errno );
|
||||
cleanup_and_fail( 1 ); }
|
||||
{
|
||||
show_error( "Error closing output file", errno, false );
|
||||
cleanup_and_fail( 1 );
|
||||
}
|
||||
outfd = -1;
|
||||
delete_output_on_interrupt = false;
|
||||
if( in_statsp )
|
||||
|
|
@ -475,8 +436,7 @@ static void close_and_set_permissions( const struct stat * const in_statsp )
|
|||
if( utime( output_filename, &t ) != 0 ) warning = true;
|
||||
}
|
||||
if( warning && verbosity >= 1 )
|
||||
show_file_error( output_filename,
|
||||
"warning: can't change output file attributes", errno );
|
||||
show_error( "Can't change output file attributes.", 0, false );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -496,22 +456,19 @@ int convert_retval( const int retval )
|
|||
case LZIP_BAD_DICT_SIZE:
|
||||
case LZIP_BAD_DATA:
|
||||
case LZIP_DATA_EOF:
|
||||
case LZIP_BAD_CRC:
|
||||
case LZIP_EMPTY_MEMBER: return 2;
|
||||
case LZIP_BAD_CRC: return 2;
|
||||
default: return 3;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int global_infd = -1; /* needed by the fill function */
|
||||
|
||||
static long fill( void * buf, unsigned long size )
|
||||
{
|
||||
unsigned long sz = 0;
|
||||
errno = 0;
|
||||
while( sz < size )
|
||||
{
|
||||
const int n = read( global_infd, (uint8_t *)buf + sz, min( 1UL << 20, size - sz ) );
|
||||
const int n = read( infd, (uint8_t *)buf + sz, min( 1UL << 20, size - sz ) );
|
||||
if( n > 0 ) sz += n;
|
||||
else if( n == 0 ) break; /* EOF */
|
||||
else if( errno != EINTR ) break;
|
||||
|
|
@ -538,9 +495,9 @@ static const char * global_name; /* copy of filename for 'error' */
|
|||
static void error(char *x) { show_file_error( global_name, x, 0 ); }
|
||||
|
||||
|
||||
static int decompress( const int infd, Pretty_print * const pp,
|
||||
const long cl_insize, const long cl_outsize,
|
||||
const bool nofill, const bool noflush, const bool testing )
|
||||
static int decompress( struct Pretty_print * const pp, const long cl_insize,
|
||||
const long cl_outsize, const bool nofill,
|
||||
const bool noflush, const bool testing )
|
||||
{
|
||||
long in_len = cl_insize;
|
||||
uint8_t * const inbuf = (in_len > 0) ? malloc( in_len ) : 0;
|
||||
|
|
@ -551,20 +508,17 @@ static int decompress( const int infd, Pretty_print * const pp,
|
|||
if( ( in_len > 0 && !inbuf ) || ( out_size > 0 && !outbuf ) )
|
||||
{ show_error( mem_msg, 0, false ); return 1; }
|
||||
|
||||
global_infd = infd;
|
||||
if( inbuf )
|
||||
{
|
||||
const long len = fill( inbuf, in_len );
|
||||
if( len < in_len )
|
||||
{ if( errno ) { show_file_error( pp->name, "Read error", errno );
|
||||
global_infd = -1; return 1; }
|
||||
{ if( errno ) { show_file_error( pp->name, "Read error", errno ); return 1; }
|
||||
in_len = len; }
|
||||
}
|
||||
global_name = pp->name;
|
||||
retval = convert_retval( __lunzip( inbuf, in_len, nofill ? 0 : fill,
|
||||
noflush ? 0 : flush, outbuf, out_size,
|
||||
&in_pos, &out_pos, error ) );
|
||||
global_infd = -1;
|
||||
if( retval ) return retval;
|
||||
if( outbuf && noflush )
|
||||
{
|
||||
|
|
@ -577,7 +531,7 @@ static int decompress( const int infd, Pretty_print * const pp,
|
|||
}
|
||||
|
||||
|
||||
void show_results( Pretty_print * const pp, const long in_pos,
|
||||
void show_results( struct Pretty_print * const pp, const long in_pos,
|
||||
const long out_pos, const bool testing )
|
||||
{
|
||||
if( verbosity >= 1 ) Pp_show_msg( pp, 0 );
|
||||
|
|
@ -632,19 +586,28 @@ static void internal_error( const char * const msg )
|
|||
int main( const int argc, const char * const argv[] )
|
||||
{
|
||||
const char * default_output_filename = "";
|
||||
static struct Arg_parser parser; /* static because valgrind complains */
|
||||
static struct Pretty_print pp; /* and memory management in C sucks */
|
||||
static const char ** filenames = 0;
|
||||
long cl_insize = 0;
|
||||
long cl_outsize = 0;
|
||||
int num_filenames = 0;
|
||||
int argind = 0;
|
||||
int failed_tests = 0;
|
||||
int retval = 0;
|
||||
int i;
|
||||
bool filenames_given = false;
|
||||
bool force = false;
|
||||
bool in_place = false;
|
||||
bool keep_input_files = false;
|
||||
bool nofill = false;
|
||||
bool noflush = false;
|
||||
bool stdin_used = false;
|
||||
bool testing = false;
|
||||
bool to_stdout = false;
|
||||
if( argc > 0 ) invocation_name = argv[0];
|
||||
|
||||
enum { opt_insize = 256, opt_outsize, opt_nofill, opt_noflush };
|
||||
const ap_Option options[] =
|
||||
const struct ap_Option options[] =
|
||||
{
|
||||
{ 'c', "stdout", ap_no },
|
||||
{ 'd', "decompress", ap_no },
|
||||
|
|
@ -664,20 +627,18 @@ int main( const int argc, const char * const argv[] )
|
|||
{ opt_noflush, "noflush", ap_no },
|
||||
{ 0 , 0, ap_no } };
|
||||
|
||||
/* static because valgrind complains and memory management in C sucks */
|
||||
static Arg_parser parser;
|
||||
if( argc > 0 ) invocation_name = argv[0];
|
||||
|
||||
if( !ap_init( &parser, argc, argv, options, 0 ) )
|
||||
{ show_error( mem_msg, 0, false ); return 1; }
|
||||
if( ap_error( &parser ) ) /* bad option */
|
||||
{ show_error( ap_error( &parser ), 0, true ); return 1; }
|
||||
|
||||
int argind = 0;
|
||||
for( ; argind < ap_arguments( &parser ); ++argind )
|
||||
{
|
||||
const int code = ap_code( &parser, argind );
|
||||
if( !code ) break; /* no more options */
|
||||
const char * const pn = ap_parsed_name( &parser, argind );
|
||||
const char * const arg = ap_argument( &parser, argind );
|
||||
if( !code ) break; /* no more options */
|
||||
switch( code )
|
||||
{
|
||||
case 'c': to_stdout = true; break;
|
||||
|
|
@ -686,7 +647,7 @@ int main( const int argc, const char * const argv[] )
|
|||
case 'h': show_help(); return 0;
|
||||
case 'I': in_place = true; break;
|
||||
case 'k': keep_input_files = true; break;
|
||||
case 'n': break; /* ignored */
|
||||
case 'n': break;
|
||||
case 'o': if( strcmp( arg, "-" ) == 0 ) to_stdout = true;
|
||||
else { default_output_filename = arg; } break;
|
||||
case 'q': verbosity = -1; break;
|
||||
|
|
@ -694,9 +655,9 @@ int main( const int argc, const char * const argv[] )
|
|||
case 'v': if( verbosity < 4 ) ++verbosity; break;
|
||||
case 'V': show_version(); return 0;
|
||||
case opt_insize:
|
||||
cl_insize = arg[0] ? getnum( arg, pn, 1, LONG_MAX ) : 16384; break;
|
||||
cl_insize = arg[0] ? getnum( arg, 1, LONG_MAX ) : 16384; break;
|
||||
case opt_outsize: cl_outsize = arg[0] ?
|
||||
getnum( arg, pn, min_dictionary_size, LONG_MAX ) : max_dictionary_size;
|
||||
getnum( arg, min_dictionary_size, LONG_MAX ) : max_dictionary_size;
|
||||
break;
|
||||
case opt_nofill: nofill = true; break;
|
||||
case opt_noflush: noflush = true; break;
|
||||
|
|
@ -704,18 +665,15 @@ int main( const int argc, const char * const argv[] )
|
|||
}
|
||||
} /* end process options */
|
||||
|
||||
#if defined __MSVCRT__ || defined __OS2__ || defined __DJGPP__
|
||||
#if defined(__MSVCRT__) || defined(__OS2__) || defined(__DJGPP__)
|
||||
setmode( STDIN_FILENO, O_BINARY );
|
||||
setmode( STDOUT_FILENO, O_BINARY );
|
||||
#endif
|
||||
|
||||
static const char ** filenames = 0;
|
||||
int num_filenames = max( 1, ap_arguments( &parser ) - argind );
|
||||
num_filenames = max( 1, ap_arguments( &parser ) - argind );
|
||||
filenames = resize_buffer( filenames, num_filenames * sizeof filenames[0] );
|
||||
filenames[0] = "-";
|
||||
|
||||
int i;
|
||||
bool filenames_given = false;
|
||||
for( i = 0; argind + i < ap_arguments( &parser ); ++i )
|
||||
{
|
||||
filenames[i] = ap_argument( &parser, argind + i );
|
||||
|
|
@ -734,18 +692,15 @@ int main( const int argc, const char * const argv[] )
|
|||
if( !to_stdout && !testing && ( filenames_given || to_file ) )
|
||||
set_signals( signal_handler );
|
||||
|
||||
static Pretty_print pp;
|
||||
Pp_init( &pp, filenames, num_filenames );
|
||||
|
||||
int failed_tests = 0;
|
||||
int retval = 0;
|
||||
const bool one_to_one = !to_stdout && !testing && !to_file;
|
||||
bool stdin_used = false;
|
||||
struct stat in_stats;
|
||||
for( i = 0; i < num_filenames; ++i )
|
||||
{
|
||||
const char * input_filename = "";
|
||||
int infd;
|
||||
int tmp;
|
||||
struct stat in_stats;
|
||||
const struct stat * in_statsp;
|
||||
|
||||
Pp_set_name( &pp, filenames[i] );
|
||||
if( strcmp( filenames[i], "-" ) == 0 )
|
||||
|
|
@ -761,15 +716,15 @@ int main( const int argc, const char * const argv[] )
|
|||
infd = open_instream( input_filename, &in_stats, one_to_one );
|
||||
if( infd < 0 ) { set_retval( &retval, 1 ); continue; }
|
||||
if( !check_tty_in( pp.name, infd, testing, &retval ) ) continue;
|
||||
if( one_to_one ) /* open outfd after checking infd */
|
||||
if( one_to_one ) /* open outfd after verifying infd */
|
||||
{
|
||||
set_d_outname( input_filename, extension_index( input_filename ) );
|
||||
if( !open_outstream( force, true ) )
|
||||
{ close( infd ); set_retval( &retval, 1 ); continue; }
|
||||
{ close( infd ); infd = -1; set_retval( &retval, 1 ); continue; }
|
||||
}
|
||||
}
|
||||
|
||||
if( to_file && outfd < 0 ) /* open outfd after checking infd */
|
||||
if( to_file && outfd < 0 ) /* open outfd after verifying infd */
|
||||
{
|
||||
output_filename = resize_buffer( output_filename,
|
||||
strlen( default_output_filename ) + 1 );
|
||||
|
|
@ -777,16 +732,15 @@ int main( const int argc, const char * const argv[] )
|
|||
if( !open_outstream( force, false ) ) return 1;
|
||||
}
|
||||
|
||||
const struct stat * const in_statsp =
|
||||
( input_filename[0] && one_to_one ) ? &in_stats : 0;
|
||||
int tmp;
|
||||
in_statsp = ( input_filename[0] && one_to_one ) ? &in_stats : 0;
|
||||
if( in_place )
|
||||
tmp = decompress_in_place( infd, &pp, testing );
|
||||
else
|
||||
tmp = decompress( infd, &pp, cl_insize, cl_outsize, nofill, noflush, testing );
|
||||
tmp = decompress( &pp, cl_insize, cl_outsize, nofill, noflush, testing );
|
||||
if( close( infd ) != 0 )
|
||||
{ show_file_error( pp.name, "Error closing input file", errno );
|
||||
set_retval( &tmp, 1 ); }
|
||||
infd = -1;
|
||||
set_retval( &retval, tmp );
|
||||
if( tmp )
|
||||
{ if( !testing ) cleanup_and_fail( retval );
|
||||
|
|
@ -797,9 +751,7 @@ int main( const int argc, const char * const argv[] )
|
|||
if( input_filename[0] && !keep_input_files && one_to_one )
|
||||
remove( input_filename );
|
||||
}
|
||||
if( delete_output_on_interrupt ) /* -o */
|
||||
close_and_set_permissions( ( retval == 0 && !stdin_used &&
|
||||
filenames_given && num_filenames == 1 ) ? &in_stats : 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 );
|
||||
|
|
@ -810,7 +762,6 @@ int main( const int argc, const char * const argv[] )
|
|||
program_name, failed_tests,
|
||||
( failed_tests == 1 ) ? "file" : "files" );
|
||||
free( output_filename );
|
||||
Pp_free( &pp );
|
||||
free( filenames );
|
||||
ap_free( &parser );
|
||||
return retval;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#! /bin/sh
|
||||
# check script for Xlunzip - Test tool for the lzip_decompress linux module
|
||||
# Copyright (C) 2016-2025 Antonio Diaz Diaz.
|
||||
# Copyright (C) 2016-2021 Antonio Diaz Diaz.
|
||||
#
|
||||
# This script is free software: you have unlimited permission
|
||||
# to copy, distribute, and modify it.
|
||||
|
|
@ -28,11 +28,11 @@ if [ -d tmp ] ; then rm -rf tmp ; fi
|
|||
mkdir tmp
|
||||
cd "${objdir}"/tmp || framework_failure
|
||||
|
||||
cp "${testdir}"/test.txt in || framework_failure
|
||||
cat "${testdir}"/test.txt > in || framework_failure
|
||||
in_lz="${testdir}"/test.txt.lz
|
||||
em_lz="${testdir}"/em.lz
|
||||
in_em="${testdir}"/test_em.txt.lz
|
||||
fox_lz="${testdir}"/fox.lz
|
||||
fnz_lz="${testdir}"/fox_nz.lz
|
||||
zero_lz="${testdir}"/zero.lz
|
||||
fail=0
|
||||
test_failed() { fail=1 ; printf " $1" ; [ -z "$2" ] || printf "($2)" ; }
|
||||
|
||||
|
|
@ -80,37 +80,35 @@ printf "LZIP\001+.............................." | "${LZIP}" -t 2> /dev/null
|
|||
|
||||
printf "\ntesting decompression..."
|
||||
|
||||
"${LZIP}" -t "${in_lz}" || test_failed $LINENO
|
||||
"${LZIP}" -d "${in_lz}" -o out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -cd "${in_lz}" > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -d "${in_lz}" -o - > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -d < "${in_lz}" > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
rm -f out || framework_failure
|
||||
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
|
||||
|
||||
cp "${in_lz}" out.lz || framework_failure
|
||||
"${LZIP}" -dk out.lz || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
rm -f out || framework_failure
|
||||
"${LZIP}" -cd "${fox_lz}" > fox || test_failed $LINENO
|
||||
cp fox copy || framework_failure
|
||||
cp "${in_lz}" copy.lz || framework_failure
|
||||
"${LZIP}" -d copy.lz out.lz 2> /dev/null # skip copy, decompress out
|
||||
cat "${in_lz}" > copy.lz || framework_failure
|
||||
"${LZIP}" -dk copy.lz || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
printf "to be overwritten" > copy || framework_failure
|
||||
"${LZIP}" -d copy.lz 2> /dev/null
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
[ ! -e out.lz ] || test_failed $LINENO
|
||||
cmp fox copy || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -df copy.lz || test_failed $LINENO
|
||||
[ ! -e copy.lz ] || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
rm -f copy out || framework_failure
|
||||
|
||||
printf "to be overwritten" > out || framework_failure
|
||||
"${LZIP}" -df -o out < "${in_lz}" || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
printf "to be overwritten" > copy || framework_failure
|
||||
"${LZIP}" -d -o copy < "${in_lz}" 2> /dev/null
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
"${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
|
||||
|
|
@ -118,126 +116,71 @@ rm -f ./- || framework_failure
|
|||
cmp in ./- || test_failed $LINENO
|
||||
rm -f ./- || framework_failure
|
||||
|
||||
cp "${in_lz}" anyothername || framework_failure
|
||||
"${LZIP}" -dv - anyothername - < "${in_lz}" > out 2> /dev/null ||
|
||||
cat "${in_lz}" > anyothername || framework_failure
|
||||
"${LZIP}" -dv - anyothername - < "${in_lz}" > copy 2> /dev/null ||
|
||||
test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
cmp in anyothername.out || test_failed $LINENO
|
||||
rm -f anyothername.out || framework_failure
|
||||
rm -f copy anyothername.out || framework_failure
|
||||
|
||||
"${LZIP}" -tq in "${in_lz}"
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -tq nx_file.lz "${in_lz}"
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq in "${in_lz}" > out
|
||||
"${LZIP}" -cdq in "${in_lz}" > copy
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cat out in | cmp in - || test_failed $LINENO # out must be empty
|
||||
"${LZIP}" -cdq nx_file.lz "${in_lz}" > out # skip nx_file, decompress in
|
||||
cat copy in | cmp in - || test_failed $LINENO
|
||||
"${LZIP}" -cdq nx_file.lz "${in_lz}" > copy
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
rm -f out || framework_failure
|
||||
cp "${in_lz}" out.lz || framework_failure
|
||||
"${LZIP}" -dq in out.lz
|
||||
cmp in copy || test_failed $LINENO
|
||||
rm -f copy || framework_failure
|
||||
cat "${in_lz}" > copy.lz || framework_failure
|
||||
"${LZIP}" -dq in copy.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
[ -e out.lz ] || test_failed $LINENO
|
||||
[ ! -e out ] || test_failed $LINENO
|
||||
[ -e copy.lz ] || test_failed $LINENO
|
||||
[ ! -e copy ] || test_failed $LINENO
|
||||
[ ! -e in.out ] || test_failed $LINENO
|
||||
"${LZIP}" -dq nx_file.lz out.lz
|
||||
"${LZIP}" -dq nx_file.lz copy.lz
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
[ ! -e out.lz ] || test_failed $LINENO
|
||||
[ ! -e copy.lz ] || test_failed $LINENO
|
||||
[ ! -e nx_file ] || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
rm -f out || framework_failure
|
||||
cmp in copy || test_failed $LINENO
|
||||
|
||||
cat in in > in2 || framework_failure
|
||||
"${LZIP}" -t "${in_lz}" "${in_lz}" || test_failed $LINENO
|
||||
"${LZIP}" -cd "${in_lz}" "${in_lz}" -o out > out2 || test_failed $LINENO
|
||||
"${LZIP}" -cd "${in_lz}" "${in_lz}" -o out > copy2 || test_failed $LINENO
|
||||
[ ! -e out ] || test_failed $LINENO # override -o
|
||||
cmp in2 out2 || test_failed $LINENO
|
||||
rm -f out2 || framework_failure
|
||||
"${LZIP}" -d "${in_lz}" "${in_lz}" -o out2 || test_failed $LINENO
|
||||
cmp in2 out2 || test_failed $LINENO
|
||||
rm -f out2 || framework_failure
|
||||
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 "${in_lz}" "${in_lz}" > out2.lz || framework_failure
|
||||
lines=`"${LZIP}" -tvv out2.lz 2>&1 | wc -l` || test_failed $LINENO
|
||||
[ "${lines}" -eq 1 ] || test_failed $LINENO "${lines}"
|
||||
|
||||
printf "\ngarbage" >> out2.lz || framework_failure
|
||||
"${LZIP}" -tvvvv out2.lz 2> /dev/null || test_failed $LINENO
|
||||
printf "to be overwritten" > out2 || framework_failure
|
||||
"${LZIP}" -df out2.lz || test_failed $LINENO
|
||||
cmp in2 out2 || test_failed $LINENO
|
||||
|
||||
touch empty || framework_failure
|
||||
cp "${em_lz}" em.lz || framework_failure
|
||||
"${LZIP}" -dk em.lz || test_failed $LINENO
|
||||
cmp empty em || test_failed $LINENO
|
||||
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
|
||||
"${LZIP}" -df copy2.lz || test_failed $LINENO
|
||||
cmp in2 copy2 || test_failed $LINENO
|
||||
|
||||
printf "\ntesting bad input..."
|
||||
|
||||
cat em.lz em.lz | "${LZIP}" -tq
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cat em.lz em.lz | "${LZIP}" -dq > em
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp empty em || test_failed $LINENO
|
||||
cat em.lz "${in_lz}" | "${LZIP}" -tq
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cat em.lz "${in_lz}" | "${LZIP}" -dq > out
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
cat "${in_lz}" em.lz | "${LZIP}" -tq
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cat "${in_lz}" em.lz | "${LZIP}" -dq > out
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
cat em.lz em.lz > ee.lz || framework_failure
|
||||
"${LZIP}" -tq < ee.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq < ee.lz > em
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp empty em || test_failed $LINENO
|
||||
"${LZIP}" -tq ee.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq ee.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
[ ! -e ee ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq ee.lz > em
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp empty em || test_failed $LINENO
|
||||
rm -f em || framework_failure
|
||||
cat "${in_lz}" em.lz "${in_lz}" > inein.lz || framework_failure
|
||||
"${LZIP}" -tq < inein.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq < inein.lz > out2
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp in2 out2 || test_failed $LINENO
|
||||
"${LZIP}" -tq inein.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -dq inein.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
[ ! -e inein ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq inein.lz > out2
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp in2 out2 || test_failed $LINENO
|
||||
rm -f out2 inein.lz em.lz || framework_failure
|
||||
|
||||
headers='LZIp LZiP LZip LzIP LzIp LziP lZIP lZIp lZiP lzIP'
|
||||
body='\001\014\000\000\101\376\367\377\377\340\000\200\000\215\357\002\322\001\000\000\000\000\000\000\000\045\000\000\000\000\000\000\000'
|
||||
cp "${in_lz}" int.lz || framework_failure
|
||||
printf "LZIP${body}" >> int.lz || framework_failure
|
||||
if "${LZIP}" -t int.lz ; then
|
||||
body='\001\014\000\203\377\373\377\377\300\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\000\000\000\000\000\000'
|
||||
cat "${in_lz}" > int.lz
|
||||
printf "LZIP${body}" >> int.lz
|
||||
if "${LZIP}" -tq int.lz ; then
|
||||
for header in ${headers} ; do
|
||||
printf "${header}${body}" > int.lz || framework_failure
|
||||
"${LZIP}" -tq int.lz # first member
|
||||
printf "${header}${body}" > int.lz # first member
|
||||
"${LZIP}" -tq int.lz
|
||||
[ $? = 2 ] || test_failed $LINENO ${header}
|
||||
"${LZIP}" -tq < int.lz
|
||||
[ $? = 2 ] || test_failed $LINENO ${header}
|
||||
"${LZIP}" -cdq int.lz > /dev/null
|
||||
[ $? = 2 ] || test_failed $LINENO ${header}
|
||||
cp "${in_lz}" int.lz || framework_failure
|
||||
printf "${header}${body}" >> int.lz || framework_failure
|
||||
"${LZIP}" -tq int.lz # trailing data
|
||||
cat "${in_lz}" > int.lz
|
||||
printf "${header}${body}" >> int.lz # trailing data
|
||||
"${LZIP}" -tq int.lz
|
||||
[ $? = 2 ] || test_failed $LINENO ${header}
|
||||
"${LZIP}" -tq < int.lz
|
||||
[ $? = 2 ] || test_failed $LINENO ${header}
|
||||
|
|
@ -245,188 +188,181 @@ if "${LZIP}" -t int.lz ; then
|
|||
[ $? = 2 ] || test_failed $LINENO ${header}
|
||||
done
|
||||
else
|
||||
printf "warning: skipping header test: 'printf' does not work on your system."
|
||||
printf "\nwarning: skipping header test: 'printf' does not work on your system."
|
||||
fi
|
||||
rm -f int.lz || framework_failure
|
||||
|
||||
"${LZIP}" -tq "${fnz_lz}"
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
|
||||
for i in fox_v2.lz fox_s11.lz fox_de20.lz \
|
||||
fox_bcrc.lz fox_crc0.lz fox_das46.lz fox_mes81.lz ; do
|
||||
"${LZIP}" -tq "${testdir}"/$i
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
done
|
||||
|
||||
"${LZIP}" -cd "${fox_lz}" > fox || test_failed $LINENO
|
||||
for i in fox_bcrc.lz fox_crc0.lz fox_das46.lz fox_mes81.lz ; do
|
||||
"${LZIP}" -cdq "${testdir}"/$i > out
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
cmp fox out || test_failed $LINENO $i
|
||||
done
|
||||
rm -f fox || framework_failure
|
||||
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=14682 count=1 2> /dev/null &&
|
||||
[ -e trunc.lz ] && cmp in2.lz trunc.lz ; then
|
||||
for i in 6 20 14664 14683 14684 14685 14686 14687 14688 ; do
|
||||
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
|
||||
for i in 6 20 14734 14753 14754 14755 14756 14757 14758 ; do
|
||||
dd if=in3.lz of=trunc.lz bs=$i count=1 2> /dev/null
|
||||
"${LZIP}" -tq trunc.lz
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
"${LZIP}" -tq < trunc.lz
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
"${LZIP}" -cdq trunc.lz > /dev/null
|
||||
"${LZIP}" -cdq trunc.lz > out
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
"${LZIP}" -dq < trunc.lz > /dev/null
|
||||
"${LZIP}" -dq < trunc.lz > out
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
done
|
||||
else
|
||||
printf "warning: skipping truncation test: 'dd' does not work on your system."
|
||||
printf "\nwarning: skipping truncation test: 'dd' does not work on your system."
|
||||
fi
|
||||
rm -f trunc.lz || framework_failure
|
||||
rm -f trunc.lz out || framework_failure
|
||||
|
||||
cp "${in_lz}" ingin.lz || framework_failure
|
||||
cat "${in_lz}" > ingin.lz || framework_failure
|
||||
printf "g" >> ingin.lz || framework_failure
|
||||
cat "${in_lz}" >> ingin.lz || framework_failure
|
||||
"${LZIP}" -t ingin.lz || test_failed $LINENO
|
||||
"${LZIP}" -t < ingin.lz || test_failed $LINENO
|
||||
"${LZIP}" -dk ingin.lz || test_failed $LINENO
|
||||
cmp in ingin || test_failed $LINENO
|
||||
"${LZIP}" -cd ingin.lz > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -d < ingin.lz > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -cd ingin.lz > copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
"${LZIP}" -d < ingin.lz > copy || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
|
||||
printf "\ntesting linux options..."
|
||||
|
||||
for i in "" =1 =2 =4 =16 =64 =256 =1024 =4096 =16384 =65536 ; do
|
||||
"${LZIP}" -t --insize$i "${in_lz}" || test_failed $LINENO $i
|
||||
"${LZIP}" -cd --insize$i "${in_lz}" > out || test_failed $LINENO $i
|
||||
cmp in out || test_failed $LINENO $i
|
||||
"${LZIP}" -cd --insize$i "${in_lz}" > copy || test_failed $LINENO $i
|
||||
cmp in copy || test_failed $LINENO $i
|
||||
done
|
||||
|
||||
for i in =1 =2 =4 =16 =64 =256 =1024 =4096 ; do
|
||||
"${LZIP}" -tq --insize$i --nofill "${in_lz}"
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
"${LZIP}" -cdq --insize$i --nofill "${in_lz}" > out
|
||||
"${LZIP}" -cdq --insize$i --nofill "${in_lz}" > copy
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
cmp -s in out && test_failed $LINENO $i
|
||||
cmp -s in copy && test_failed $LINENO $i
|
||||
done
|
||||
|
||||
for i in "" =16384 =65536 ; do
|
||||
"${LZIP}" -t --insize$i --nofill "${in_lz}" || test_failed $LINENO $i
|
||||
"${LZIP}" -cd --insize$i --nofill "${in_lz}" > out ||
|
||||
"${LZIP}" -cd --insize$i --nofill "${in_lz}" > copy ||
|
||||
test_failed $LINENO $i
|
||||
cmp in out || test_failed $LINENO $i
|
||||
cmp in copy || test_failed $LINENO $i
|
||||
done
|
||||
|
||||
for i in =18KiB =65536 =262144 ; do
|
||||
"${LZIP}" -t --outsize$i "${in_lz}" || test_failed $LINENO $i
|
||||
"${LZIP}" -cd --outsize$i "${in_lz}" > out ||
|
||||
"${LZIP}" -cd --outsize$i "${in_lz}" > copy ||
|
||||
test_failed $LINENO $i
|
||||
cmp in out || test_failed $LINENO $i
|
||||
cmp in copy || test_failed $LINENO $i
|
||||
done
|
||||
|
||||
for i in =36301 =65536 =262144 ; do
|
||||
for i in =36388 =65536 =262144 ; do
|
||||
"${LZIP}" -t --outsize$i --noflush "${in_lz}" ||
|
||||
test_failed $LINENO $i
|
||||
"${LZIP}" -cd --outsize$i --noflush "${in_lz}" > out ||
|
||||
"${LZIP}" -cd --outsize$i --noflush "${in_lz}" > copy ||
|
||||
test_failed $LINENO $i
|
||||
cmp in out || test_failed $LINENO $i
|
||||
cmp in copy || test_failed $LINENO $i
|
||||
done
|
||||
|
||||
for i in =36300 ; do
|
||||
for i in =36387 ; do
|
||||
"${LZIP}" -tq --outsize$i --noflush "${in_lz}"
|
||||
[ $? = 1 ] || test_failed $LINENO $i
|
||||
"${LZIP}" -cdq --outsize$i --noflush "${in_lz}" > out
|
||||
"${LZIP}" -cdq --outsize$i --noflush "${in_lz}" > copy
|
||||
[ $? = 1 ] || test_failed $LINENO $i
|
||||
cmp -s in out && test_failed $LINENO $i
|
||||
cmp -s in copy && test_failed $LINENO $i
|
||||
done
|
||||
|
||||
for i in =4096 =16384 ; do
|
||||
"${LZIP}" -tq --outsize$i --noflush "${in_lz}"
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
"${LZIP}" -cdq --outsize$i --noflush "${in_lz}" > out
|
||||
"${LZIP}" -cdq --outsize$i --noflush "${in_lz}" > copy
|
||||
[ $? = 2 ] || test_failed $LINENO $i
|
||||
cmp -s in out && test_failed $LINENO $i
|
||||
cmp -s in copy && test_failed $LINENO $i
|
||||
done
|
||||
|
||||
"${LZIP}" -t --insize --outsize=36388 --nofill --noflush "${in_lz}" ||
|
||||
test_failed $LINENO
|
||||
"${LZIP}" -cd --insize --outsize=36388 --nofill --noflush "${in_lz}" > out ||
|
||||
"${LZIP}" -cd --insize --outsize=36388 --nofill --noflush "${in_lz}" > copy ||
|
||||
test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
cmp in copy || test_failed $LINENO
|
||||
|
||||
"${LZIP}" -tq --nofill "${in_lz}"
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq --nofill "${in_lz}" > out
|
||||
"${LZIP}" -cdq --nofill "${in_lz}" > copy
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp -s in out && test_failed $LINENO
|
||||
cmp -s in copy && test_failed $LINENO
|
||||
"${LZIP}" -tq --noflush "${in_lz}"
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq --noflush "${in_lz}" > out
|
||||
"${LZIP}" -cdq --noflush "${in_lz}" > copy
|
||||
[ $? = 1 ] || test_failed $LINENO
|
||||
cmp -s in out && test_failed $LINENO
|
||||
cmp -s in copy && test_failed $LINENO
|
||||
|
||||
# decompress in place
|
||||
rm -f out out2 || framework_failure
|
||||
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 out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
rm -f out || framework_failure
|
||||
"${LZIP}" -d --in-place < "${in_lz}" -o out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place "${in_lz}" > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place < "${in_lz}" > out || test_failed $LINENO
|
||||
cmp in out || 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 out2 || test_failed $LINENO
|
||||
cmp in2 out2 || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place "${in_lz}" "${in_lz}" > out2 || test_failed $LINENO
|
||||
cmp in2 out2 || 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 out || framework_failure
|
||||
"${LZIP}" -d --in-place $i.lz -o out || test_failed $LINENO
|
||||
cmp $i out || test_failed $LINENO
|
||||
rm -f out || framework_failure
|
||||
"${LZIP}" -d --in-place < $i.lz -o out || test_failed $LINENO
|
||||
cmp $i out || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place $i.lz > out || test_failed $LINENO
|
||||
cmp $i out || test_failed $LINENO
|
||||
"${LZIP}" -cd --in-place < $i.lz > out || test_failed $LINENO
|
||||
cmp $i out || 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 out2 ingin.lz in2 in2.lz in3 in3.lz || framework_failure
|
||||
rm -f copy copy2 ingin.lz in2 in2.lz in3 in3.lz || framework_failure
|
||||
|
||||
cat "${in_lz}" "${em_lz}" > ine.lz || framework_failure
|
||||
"${LZIP}" -tq --in-place ine.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq --in-place ine.lz > out
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp empty out || test_failed $LINENO
|
||||
cat "${em_lz}" "${in_lz}" > ine.lz || framework_failure
|
||||
"${LZIP}" -tq --in-place ine.lz
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
"${LZIP}" -cdq --in-place ine.lz > out
|
||||
[ $? = 2 ] || test_failed $LINENO
|
||||
cmp empty out || test_failed $LINENO
|
||||
rm -f ine.lz empty || 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
|
||||
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 > out || test_failed $LINENO
|
||||
cmp in out || test_failed $LINENO
|
||||
rm -f out int.lz || framework_failure
|
||||
"${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
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -1,7 +1,8 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc. <http://fsf.org/>
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
|
|
@ -338,7 +339,8 @@ Public License instead of this License.
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc. <http://fsf.org/>
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
|
|
|
|||
Binary file not shown.
BIN
testsuite/test_em.txt.lz
Normal file
BIN
testsuite/test_em.txt.lz
Normal file
Binary file not shown.
Loading…
Add table
Add a link
Reference in a new issue