mirror of https://github.com/madler/zlib
zlib 1.2.0.2
This commit is contained in:
parent
13a294f044
commit
8e34b3a802
36
ChangeLog
36
ChangeLog
|
@ -1,5 +1,39 @@
|
|||
|
||||
ChangeLog file for zlib
|
||||
Changes in 1.2.0.2 (13 July 2003)
|
||||
- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons
|
||||
- Attempt to avoid warnings in crc32.c for pointer-int conversion
|
||||
- Add AIX to configure, remove aix directory [Bakker]
|
||||
- Add some casts to minigzip.c
|
||||
- Improve checking after insecure sprintf() or vsprintf() calls
|
||||
- Remove #elif's from crc32.c
|
||||
- Change leave label to inf_leave in inflate.c and infback.c to avoid
|
||||
library conflicts
|
||||
- Remove inflate gzip decoding by default--only enable gzip decoding by
|
||||
special request for stricter backward compatibility
|
||||
- Add zlibCompileFlags() function to return compilation information
|
||||
- More typecasting in deflate.c to avoid warnings
|
||||
- Remove leading underscore from _Capital #defines [Truta]
|
||||
- Fix configure to link shared library when testing
|
||||
- Add some Windows CE target adjustments [Mai]
|
||||
- Remove #define ZLIB_DLL in zconf.h [Vollant]
|
||||
- Add zlib.3 [Rodgers]
|
||||
- Update RFC URL in deflate.c and algorithm.txt [Mai]
|
||||
- Add zlib_dll_FAQ.txt to contrib [Truta]
|
||||
- Add UL to some constants [Truta]
|
||||
- Update minizip and vstudio [Vollant]
|
||||
- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h
|
||||
- Expand use of NO_DUMMY_DECL to avoid all dummy structures
|
||||
- Added iostream3 to contrib [Schwardt]
|
||||
- Replace rewind() with fseek() for WinCE [Truta]
|
||||
- Improve setting of zlib format compression level flags
|
||||
- Report 0 for huffman and rle strategies and for level == 0 or 1
|
||||
- Report 2 only for level == 6
|
||||
- Only deal with 64K limit when necessary at compile time [Truta]
|
||||
- Allow TOO_FAR check to be turned off at compile time [Truta]
|
||||
- Added gzclearerr() function [Souza]
|
||||
- Added gzungetc() function
|
||||
|
||||
Changes in 1.2.0.1 (17 March 2003)
|
||||
- Add Z_RLE strategy for run-length encoding [Truta]
|
||||
- When Z_RLE requested, restrict matches to distance one
|
||||
|
@ -12,7 +46,7 @@ Changes in 1.2.0.1 (17 March 2003)
|
|||
- Include additional header file on VMS for off_t typedef
|
||||
- Try to use _vsnprintf where it supplants vsprintf [Vollant]
|
||||
- Add some casts in inffast.c
|
||||
- Enchance comments in zlib.h on what happens if the gzprintf() tries to
|
||||
- Enchance comments in zlib.h on what happens if gzprintf() tries to
|
||||
write more than 4095 bytes before compression
|
||||
- Remove unused state from inflateBackEnd()
|
||||
- Remove exit(0) from minigzip.c, example.c
|
||||
|
|
3
FAQ
3
FAQ
|
@ -228,7 +228,8 @@ The lastest zlib FAQ is at http://www.gzip.org/zlib/zlib_faq.html
|
|||
hand, if zlib is compiled to use snprintf() or vsnprintf(), which should
|
||||
normally be the case, then there is no vulnerability. The ./configure
|
||||
script will display warnings if an insecure variation of sprintf() will
|
||||
be used by gzprintf().
|
||||
be used by gzprintf(). Also the zlibCompileFlags() functions will return
|
||||
information on what variant of sprintf() is used by gzprintf().
|
||||
|
||||
If you don't have snprintf() or vsnprintf() and would like one, you can
|
||||
find a portable implementation here:
|
||||
|
|
2
Makefile
2
Makefile
|
@ -24,7 +24,7 @@ LDFLAGS=libz.a
|
|||
LDSHARED=$(CC)
|
||||
CPP=$(CC) -E
|
||||
|
||||
VER=1.2.0.1
|
||||
VER=1.2.0.2
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
|
||||
|
|
|
@ -24,7 +24,7 @@ LDFLAGS=libz.a
|
|||
LDSHARED=$(CC)
|
||||
CPP=$(CC) -E
|
||||
|
||||
VER=1.2.0.1
|
||||
VER=1.2.0.2
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
|
||||
|
|
4
README
4
README
|
@ -1,6 +1,6 @@
|
|||
ZLIB DATA COMPRESSION LIBRARY
|
||||
|
||||
zlib 1.2.0.1 is a general purpose data compression library. All the code is
|
||||
zlib 1.2.0.2 is a general purpose data compression library. All the code is
|
||||
thread safe. The data format used by the zlib library is described by RFCs
|
||||
(Request for Comments) 1950 to 1952 in the files
|
||||
http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format)
|
||||
|
@ -34,7 +34,7 @@ Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
|
|||
issue of Dr. Dobb's Journal; a copy of the article is available in
|
||||
http://dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
|
||||
The changes made in version 1.2.0.1 are documented in the file ChangeLog.
|
||||
The changes made in version 1.2.0.2 are documented in the file ChangeLog.
|
||||
|
||||
Unsupported third party contributions are provided in directory "contrib".
|
||||
|
||||
|
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#define ZLIB_INTERNAL
|
||||
#include "zlib.h"
|
||||
|
||||
#define BASE 65521L /* largest prime smaller than 65536 */
|
||||
|
|
|
@ -1,9 +0,0 @@
|
|||
To make a shared library:
|
||||
|
||||
1. Compile a static library
|
||||
2. Use mkexps on that to create libz.exp
|
||||
3. Apply the configure.diff patch to configure
|
||||
4. Run the new configure to make a new Makefile
|
||||
5. Use the new Makefile to make the shared library
|
||||
|
||||
Courtesy of dbakker@arrayasolutions.com
|
|
@ -1,57 +0,0 @@
|
|||
*** ../orig/zlib-1.1.4/configure Wed Jul 8 14:19:35 1998
|
||||
--- configure Sun Feb 9 11:11:19 2003
|
||||
***************
|
||||
*** 18,23 ****
|
||||
--- 18,24 ----
|
||||
# If you have problems, try without defining CC and CFLAGS before reporting
|
||||
# an error.
|
||||
|
||||
+ LDFLAGS="-L. -lz"
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`
|
||||
***************
|
||||
*** 116,121 ****
|
||||
--- 117,128 ----
|
||||
SFLAGS=${CFLAGS-"-Kconform_pic -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
+ AIX*)
|
||||
+ SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
+ CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
+ LDTESTSHARED=${LDSHARED-"cc -G"}
|
||||
+ LDSHAREDFLAGS="-L. libz.so"
|
||||
+ LDSHARED=${LDSHARED-"cc -G"};;
|
||||
# send working options for other systems to support@gzip.org
|
||||
*) SFLAGS=${CFLAGS-"-O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
***************
|
||||
*** 127,135 ****
|
||||
echo Checking for shared library support...
|
||||
# we must test in two steps (cc then ld), required at least on SunOS 4.x
|
||||
if test "`($CC -c $SFLAGS $test.c) 2>&1`" = "" &&
|
||||
! test "`($LDSHARED -o $test$shared_ext $test.o) 2>&1`" = ""; then
|
||||
CFLAGS="$SFLAGS"
|
||||
LIBS="$SHAREDLIB.$VER"
|
||||
echo Building shared library $SHAREDLIB.$VER with $CC.
|
||||
elif test -z "$old_cc" -a -z "$old_cflags"; then
|
||||
echo No shared library suppport.
|
||||
--- 134,143 ----
|
||||
echo Checking for shared library support...
|
||||
# we must test in two steps (cc then ld), required at least on SunOS 4.x
|
||||
if test "`($CC -c $SFLAGS $test.c) 2>&1`" = "" &&
|
||||
! test "`($LDTESTSHARED -o $test$shared_ext $test.o) 2>&1`" = ""; then
|
||||
CFLAGS="$SFLAGS"
|
||||
LIBS="$SHAREDLIB.$VER"
|
||||
+ LDFLAGS="$LDSHAREDFLAGS"
|
||||
echo Building shared library $SHAREDLIB.$VER with $CC.
|
||||
elif test -z "$old_cc" -a -z "$old_cflags"; then
|
||||
echo No shared library suppport.
|
||||
***************
|
||||
*** 209,212 ****
|
||||
--- 217,221 ----
|
||||
/^exec_prefix *=/s%=.*%=$exec_prefix%
|
||||
/^libdir *=/s%=.*%=$libdir%
|
||||
/^includedir *=/s%=.*%=$includedir%
|
||||
+ /^LDFLAGS *=/s%=.*%=$LDFLAGS%
|
||||
" > Makefile
|
37
aix/mkexps
37
aix/mkexps
|
@ -1,37 +0,0 @@
|
|||
#!/bin/ksh
|
||||
#
|
||||
# mkexps - make export list
|
||||
# This program creates an export list by combining all the "." and normal names
|
||||
# into one list.
|
||||
#
|
||||
if [[ "$#" -ne 1 ]]
|
||||
then
|
||||
print "Usage: mkexps ArchiveFile"
|
||||
exit -2
|
||||
fi
|
||||
if [[ ! -f $1 ]]
|
||||
then
|
||||
print "mkexps: Cannot open file \"$1\""
|
||||
exit -1
|
||||
fi
|
||||
|
||||
dump -g $1 | awk '
|
||||
BEGIN {
|
||||
top = 1
|
||||
}
|
||||
/^[ ]*[0-9][0-9]*/ {
|
||||
if ( (n = index( $2, "." )) > 0 ) {
|
||||
export_array[ top++ ] = substr( $2, n+1, length( $2 ))
|
||||
}
|
||||
else {
|
||||
export_array[ top++ ] = $2
|
||||
}
|
||||
}
|
||||
|
||||
END {
|
||||
for ( i = 1; i < top; i++ )
|
||||
{
|
||||
print export_array[ i ]
|
||||
}
|
||||
|
||||
}' | sort | uniq
|
|
@ -206,4 +206,4 @@ Compression,'' IEEE Transactions on Information Theory, Vol. 23, No. 3,
|
|||
pp. 337-343.
|
||||
|
||||
``DEFLATE Compressed Data Format Specification'' available in
|
||||
ftp://ds.internic.net/rfc/rfc1951.txt
|
||||
http://www.ietf.org/rfc/rfc1951.txt
|
||||
|
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#define ZLIB_INTERNAL
|
||||
#include "zlib.h"
|
||||
|
||||
/* ===========================================================================
|
||||
|
|
|
@ -19,6 +19,7 @@
|
|||
# an error.
|
||||
|
||||
LIBS=libz.a
|
||||
LDFLAGS="-L. ${LIBS}"
|
||||
SHAREDLIB=libz.so
|
||||
VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`
|
||||
AR=${AR-"ar rc"}
|
||||
|
@ -53,6 +54,10 @@ case "$1" in
|
|||
esac
|
||||
done
|
||||
|
||||
if [ $shared -eq 1 ]; then
|
||||
LDFLAGS="-L. ${SHAREDLIB}"
|
||||
fi
|
||||
|
||||
test=ztest$$
|
||||
cat > $test.c <<EOF
|
||||
extern int getchar();
|
||||
|
@ -123,6 +128,10 @@ else
|
|||
SFLAGS=${CFLAGS-"-KPIC -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
AIX*) # Courtesy of dbakker@arrayasolutions.com
|
||||
SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
LDSHARED=${LDSHARED-"xlc -G"};;
|
||||
# send working options for other systems to support@gzip.org
|
||||
*) SFLAGS=${CFLAGS-"-O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
|
@ -422,4 +431,5 @@ sed < Makefile.in "
|
|||
/^exec_prefix *=/s%=.*%=$exec_prefix%
|
||||
/^libdir *=/s%=.*%=$libdir%
|
||||
/^includedir *=/s%=.*%=$includedir%
|
||||
/^LDFLAGS *=/s%=.*%=$LDFLAGS%
|
||||
" > Makefile
|
||||
|
|
|
@ -0,0 +1,35 @@
|
|||
These classes provide a C++ stream interface to the zlib library. It allows you
|
||||
to do things like:
|
||||
|
||||
gzofstream outf("blah.gz");
|
||||
outf << "These go into the gzip file " << 123 << endl;
|
||||
|
||||
It does this by deriving a specialized stream buffer for gzipped files, which is
|
||||
the way Stroustrup would have done it. :->
|
||||
|
||||
The gzifstream and gzofstream classes were originally written by Kevin Ruland
|
||||
and made available in the zlib contrib/iostream directory. The older version still
|
||||
compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of
|
||||
this version.
|
||||
|
||||
The new classes are as standard-compliant as possible, closely following the
|
||||
approach of the standard library's fstream classes. It compiles under gcc versions
|
||||
3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard
|
||||
library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs
|
||||
from the previous one in the following respects:
|
||||
- added showmanyc
|
||||
- added setbuf, with support for unbuffered output via setbuf(0,0)
|
||||
- a few bug fixes of stream behavior
|
||||
- gzipped output file opened with default compression level instead of maximum level
|
||||
- setcompressionlevel()/strategy() members replaced by single setcompression()
|
||||
|
||||
The code is provided "as is", with the permission to use, copy, modify, distribute
|
||||
and sell it for any purpose without fee.
|
||||
|
||||
Ludwig Schwardt
|
||||
<schwardt@sun.ac.za>
|
||||
|
||||
DSP Lab
|
||||
Electrical & Electronic Engineering Department
|
||||
University of Stellenbosch
|
||||
South Africa
|
|
@ -0,0 +1,17 @@
|
|||
Possible upgrades to gzfilebuf:
|
||||
|
||||
- The ability to do putback (e.g. putbackfail)
|
||||
|
||||
- The ability to seek (zlib supports this, but could be slow/tricky)
|
||||
|
||||
- Simultaneous read/write access (does it make sense?)
|
||||
|
||||
- Support for ios_base::ate open mode
|
||||
|
||||
- Locale support?
|
||||
|
||||
- Check public interface to see which calls give problems
|
||||
(due to dependence on library internals)
|
||||
|
||||
- Override operator<<(ostream&, gzfilebuf*) to allow direct copying
|
||||
of stream buffer to stream ( i.e. os << is.rdbuf(); )
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
* Test program for gzifstream and gzofstream
|
||||
*
|
||||
* by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
*/
|
||||
|
||||
#include "zfstream.h"
|
||||
#include <iostream> // for cout
|
||||
|
||||
int main() {
|
||||
|
||||
gzofstream outf;
|
||||
gzifstream inf;
|
||||
char buf[80];
|
||||
|
||||
outf.open("test1.txt.gz");
|
||||
outf << "The quick brown fox sidestepped the lazy canine\n"
|
||||
<< 1.3 << "\nPlan " << 9 << std::endl;
|
||||
outf.close();
|
||||
std::cout << "Wrote the following message to 'test1.txt.gz' (check with zcat or zless):\n"
|
||||
<< "The quick brown fox sidestepped the lazy canine\n"
|
||||
<< 1.3 << "\nPlan " << 9 << std::endl;
|
||||
|
||||
std::cout << "\nReading 'test1.txt.gz' (buffered) produces:\n";
|
||||
inf.open("test1.txt.gz");
|
||||
while (inf.getline(buf,80,'\n')) {
|
||||
std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n";
|
||||
}
|
||||
inf.close();
|
||||
|
||||
outf.rdbuf()->pubsetbuf(0,0);
|
||||
outf.open("test2.txt.gz");
|
||||
outf << setcompression(Z_NO_COMPRESSION)
|
||||
<< "The quick brown fox sidestepped the lazy canine\n"
|
||||
<< 1.3 << "\nPlan " << 9 << std::endl;
|
||||
outf.close();
|
||||
std::cout << "\nWrote the same message to 'test2.txt.gz' in uncompressed form";
|
||||
|
||||
std::cout << "\nReading 'test2.txt.gz' (unbuffered) produces:\n";
|
||||
inf.rdbuf()->pubsetbuf(0,0);
|
||||
inf.open("test2.txt.gz");
|
||||
while (inf.getline(buf,80,'\n')) {
|
||||
std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n";
|
||||
}
|
||||
inf.close();
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
|
@ -0,0 +1,479 @@
|
|||
/*
|
||||
* A C++ I/O streams interface to the zlib gz* functions
|
||||
*
|
||||
* by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
*
|
||||
* This version is standard-compliant and compatible with gcc 3.x.
|
||||
*/
|
||||
|
||||
#include "zfstream.h"
|
||||
#include <cstring> // for strcpy, strcat, strlen (mode strings)
|
||||
#include <cstdio> // for BUFSIZ
|
||||
|
||||
// Internal buffer sizes (default and "unbuffered" versions)
|
||||
#define BIGBUFSIZE BUFSIZ
|
||||
#define SMALLBUFSIZE 1
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Default constructor
|
||||
gzfilebuf::gzfilebuf()
|
||||
: file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),
|
||||
buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)
|
||||
{
|
||||
// No buffers to start with
|
||||
this->disable_buffer();
|
||||
}
|
||||
|
||||
// Destructor
|
||||
gzfilebuf::~gzfilebuf()
|
||||
{
|
||||
// Sync output buffer and close only if responsible for file
|
||||
// (i.e. attached streams should be left open at this stage)
|
||||
this->sync();
|
||||
if (own_fd)
|
||||
this->close();
|
||||
// Make sure internal buffer is deallocated
|
||||
this->disable_buffer();
|
||||
}
|
||||
|
||||
// Set compression level and strategy
|
||||
int
|
||||
gzfilebuf::setcompression(int comp_level,
|
||||
int comp_strategy)
|
||||
{
|
||||
return gzsetparams(file, comp_level, comp_strategy);
|
||||
}
|
||||
|
||||
// Open gzipped file
|
||||
gzfilebuf*
|
||||
gzfilebuf::open(const char *name,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
// Fail if file already open
|
||||
if (this->is_open())
|
||||
return NULL;
|
||||
// Don't support simultaneous read/write access (yet)
|
||||
if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
|
||||
return NULL;
|
||||
|
||||
// Build mode string for gzopen and check it [27.8.1.3.2]
|
||||
char char_mode[6] = "\0\0\0\0\0";
|
||||
if (!this->open_mode(mode, char_mode))
|
||||
return NULL;
|
||||
|
||||
// Attempt to open file
|
||||
if ((file = gzopen(name, char_mode)) == NULL)
|
||||
return NULL;
|
||||
|
||||
// On success, allocate internal buffer and set flags
|
||||
this->enable_buffer();
|
||||
io_mode = mode;
|
||||
own_fd = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
// Attach to gzipped file
|
||||
gzfilebuf*
|
||||
gzfilebuf::attach(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
// Fail if file already open
|
||||
if (this->is_open())
|
||||
return NULL;
|
||||
// Don't support simultaneous read/write access (yet)
|
||||
if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
|
||||
return NULL;
|
||||
|
||||
// Build mode string for gzdopen and check it [27.8.1.3.2]
|
||||
char char_mode[6] = "\0\0\0\0\0";
|
||||
if (!this->open_mode(mode, char_mode))
|
||||
return NULL;
|
||||
|
||||
// Attempt to attach to file
|
||||
if ((file = gzdopen(fd, char_mode)) == NULL)
|
||||
return NULL;
|
||||
|
||||
// On success, allocate internal buffer and set flags
|
||||
this->enable_buffer();
|
||||
io_mode = mode;
|
||||
own_fd = false;
|
||||
return this;
|
||||
}
|
||||
|
||||
// Close gzipped file
|
||||
gzfilebuf*
|
||||
gzfilebuf::close()
|
||||
{
|
||||
// Fail immediately if no file is open
|
||||
if (!this->is_open())
|
||||
return NULL;
|
||||
// Assume success
|
||||
gzfilebuf* retval = this;
|
||||
// Attempt to sync and close gzipped file
|
||||
if (this->sync() == -1)
|
||||
retval = NULL;
|
||||
if (gzclose(file) < 0)
|
||||
retval = NULL;
|
||||
// File is now gone anyway (postcondition [27.8.1.3.8])
|
||||
file = NULL;
|
||||
own_fd = false;
|
||||
// Destroy internal buffer if it exists
|
||||
this->disable_buffer();
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||||
|
||||
// Convert int open mode to mode string
|
||||
bool
|
||||
gzfilebuf::open_mode(std::ios_base::openmode mode,
|
||||
char* c_mode) const
|
||||
{
|
||||
bool testb = mode & std::ios_base::binary;
|
||||
bool testi = mode & std::ios_base::in;
|
||||
bool testo = mode & std::ios_base::out;
|
||||
bool testt = mode & std::ios_base::trunc;
|
||||
bool testa = mode & std::ios_base::app;
|
||||
|
||||
// Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
|
||||
// Original zfstream hardcoded the compression level to maximum here...
|
||||
// Double the time for less than 1% size improvement seems
|
||||
// excessive though - keeping it at the default level
|
||||
// To change back, just append "9" to the next three mode strings
|
||||
if (!testi && testo && !testt && !testa)
|
||||
strcpy(c_mode, "w");
|
||||
if (!testi && testo && !testt && testa)
|
||||
strcpy(c_mode, "a");
|
||||
if (!testi && testo && testt && !testa)
|
||||
strcpy(c_mode, "w");
|
||||
if (testi && !testo && !testt && !testa)
|
||||
strcpy(c_mode, "r");
|
||||
// No read/write mode yet
|
||||
// if (testi && testo && !testt && !testa)
|
||||
// strcpy(c_mode, "r+");
|
||||
// if (testi && testo && testt && !testa)
|
||||
// strcpy(c_mode, "w+");
|
||||
|
||||
// Mode string should be empty for invalid combination of flags
|
||||
if (strlen(c_mode) == 0)
|
||||
return false;
|
||||
if (testb)
|
||||
strcat(c_mode, "b");
|
||||
return true;
|
||||
}
|
||||
|
||||
// Determine number of characters in internal get buffer
|
||||
std::streamsize
|
||||
gzfilebuf::showmanyc()
|
||||
{
|
||||
// Calls to underflow will fail if file not opened for reading
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::in))
|
||||
return -1;
|
||||
// Make sure get area is in use
|
||||
if (this->gptr() && (this->gptr() < this->egptr()))
|
||||
return std::streamsize(this->egptr() - this->gptr());
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Fill get area from gzipped file
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::underflow()
|
||||
{
|
||||
// If something is left in the get area by chance, return it
|
||||
// (this shouldn't normally happen, as underflow is only supposed
|
||||
// to be called when gptr >= egptr, but it serves as error check)
|
||||
if (this->gptr() && (this->gptr() < this->egptr()))
|
||||
return traits_type::to_int_type(*(this->gptr()));
|
||||
|
||||
// If the file hasn't been opened for reading, produce error
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::in))
|
||||
return traits_type::eof();
|
||||
|
||||
// Attempt to fill internal buffer from gzipped file
|
||||
// (buffer must be guaranteed to exist...)
|
||||
int bytes_read = gzread(file, buffer, buffer_size);
|
||||
// Indicates error or EOF
|
||||
if (bytes_read <= 0)
|
||||
{
|
||||
// Reset get area
|
||||
this->setg(buffer, buffer, buffer);
|
||||
return traits_type::eof();
|
||||
}
|
||||
// Make all bytes read from file available as get area
|
||||
this->setg(buffer, buffer, buffer + bytes_read);
|
||||
|
||||
// Return next character in get area
|
||||
return traits_type::to_int_type(*(this->gptr()));
|
||||
}
|
||||
|
||||
// Write put area to gzipped file
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::overflow(int_type c)
|
||||
{
|
||||
// Determine whether put area is in use
|
||||
if (this->pbase())
|
||||
{
|
||||
// Double-check pointer range
|
||||
if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
|
||||
return traits_type::eof();
|
||||
// Add extra character to buffer if not EOF
|
||||
if (!traits_type::eq_int_type(c, traits_type::eof()))
|
||||
{
|
||||
*(this->pptr()) = traits_type::to_char_type(c);
|
||||
this->pbump(1);
|
||||
}
|
||||
// Number of characters to write to file
|
||||
int bytes_to_write = this->pptr() - this->pbase();
|
||||
// Overflow doesn't fail if nothing is to be written
|
||||
if (bytes_to_write > 0)
|
||||
{
|
||||
// If the file hasn't been opened for writing, produce error
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::out))
|
||||
return traits_type::eof();
|
||||
// If gzipped file won't accept all bytes written to it, fail
|
||||
if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)
|
||||
return traits_type::eof();
|
||||
// Reset next pointer to point to pbase on success
|
||||
this->pbump(-bytes_to_write);
|
||||
}
|
||||
}
|
||||
// Write extra character to file if not EOF
|
||||
else if (!traits_type::eq_int_type(c, traits_type::eof()))
|
||||
{
|
||||
// If the file hasn't been opened for writing, produce error
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::out))
|
||||
return traits_type::eof();
|
||||
// Impromptu char buffer (allows "unbuffered" output)
|
||||
char_type last_char = traits_type::to_char_type(c);
|
||||
// If gzipped file won't accept this character, fail
|
||||
if (gzwrite(file, &last_char, 1) != 1)
|
||||
return traits_type::eof();
|
||||
}
|
||||
|
||||
// If you got here, you have succeeded (even if c was EOF)
|
||||
// The return value should therefore be non-EOF
|
||||
if (traits_type::eq_int_type(c, traits_type::eof()))
|
||||
return traits_type::not_eof(c);
|
||||
else
|
||||
return c;
|
||||
}
|
||||
|
||||
// Assign new buffer
|
||||
std::streambuf*
|
||||
gzfilebuf::setbuf(char_type* p,
|
||||
std::streamsize n)
|
||||
{
|
||||
// First make sure stuff is sync'ed, for safety
|
||||
if (this->sync() == -1)
|
||||
return NULL;
|
||||
// If buffering is turned off on purpose via setbuf(0,0), still allocate one...
|
||||
// "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
|
||||
// least a buffer of size 1 (very inefficient though, therefore make it bigger?)
|
||||
// This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
|
||||
if (!p || !n)
|
||||
{
|
||||
// Replace existing buffer (if any) with small internal buffer
|
||||
this->disable_buffer();
|
||||
buffer = NULL;
|
||||
buffer_size = 0;
|
||||
own_buffer = true;
|
||||
this->enable_buffer();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Replace existing buffer (if any) with external buffer
|
||||
this->disable_buffer();
|
||||
buffer = p;
|
||||
buffer_size = n;
|
||||
own_buffer = false;
|
||||
this->enable_buffer();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
// Write put area to gzipped file (i.e. ensures that put area is empty)
|
||||
int
|
||||
gzfilebuf::sync()
|
||||
{
|
||||
return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;
|
||||
}
|
||||
|
||||
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||||
|
||||
// Allocate internal buffer
|
||||
void
|
||||
gzfilebuf::enable_buffer()
|
||||
{
|
||||
// If internal buffer required, allocate one
|
||||
if (own_buffer && !buffer)
|
||||
{
|
||||
// Check for buffered vs. "unbuffered"
|
||||
if (buffer_size > 0)
|
||||
{
|
||||
// Allocate internal buffer
|
||||
buffer = new char_type[buffer_size];
|
||||
// Get area starts empty and will be expanded by underflow as need arises
|
||||
this->setg(buffer, buffer, buffer);
|
||||
// Setup entire internal buffer as put area.
|
||||
// The one-past-end pointer actually points to the last element of the buffer,
|
||||
// so that overflow(c) can safely add the extra character c to the sequence.
|
||||
// These pointers remain in place for the duration of the buffer
|
||||
this->setp(buffer, buffer + buffer_size - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Even in "unbuffered" case, (small?) get buffer is still required
|
||||
buffer_size = SMALLBUFSIZE;
|
||||
buffer = new char_type[buffer_size];
|
||||
this->setg(buffer, buffer, buffer);
|
||||
// "Unbuffered" means no put buffer
|
||||
this->setp(0, 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// If buffer already allocated, reset buffer pointers just to make sure no
|
||||
// stale chars are lying around
|
||||
this->setg(buffer, buffer, buffer);
|
||||
this->setp(buffer, buffer + buffer_size - 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Destroy internal buffer
|
||||
void
|
||||
gzfilebuf::disable_buffer()
|
||||
{
|
||||
// If internal buffer exists, deallocate it
|
||||
if (own_buffer && buffer)
|
||||
{
|
||||
// Preserve unbuffered status by zeroing size
|
||||
if (!this->pbase())
|
||||
buffer_size = 0;
|
||||
delete[] buffer;
|
||||
buffer = NULL;
|
||||
this->setg(0, 0, 0);
|
||||
this->setp(0, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Reset buffer pointers to initial state if external buffer exists
|
||||
this->setg(buffer, buffer, buffer);
|
||||
if (buffer)
|
||||
this->setp(buffer, buffer + buffer_size - 1);
|
||||
else
|
||||
this->setp(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Default constructor initializes stream buffer
|
||||
gzifstream::gzifstream()
|
||||
: std::istream(NULL), sb()
|
||||
{ this->init(&sb); }
|
||||
|
||||
// Initialize stream buffer and open file
|
||||
gzifstream::gzifstream(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
: std::istream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->open(name, mode);
|
||||
}
|
||||
|
||||
// Initialize stream buffer and attach to file
|
||||
gzifstream::gzifstream(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
: std::istream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->attach(fd, mode);
|
||||
}
|
||||
|
||||
// Open file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzifstream::open(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.open(name, mode | std::ios_base::in))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Attach to file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzifstream::attach(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.attach(fd, mode | std::ios_base::in))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Close file
|
||||
void
|
||||
gzifstream::close()
|
||||
{
|
||||
if (!sb.close())
|
||||
this->setstate(std::ios_base::failbit);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Default constructor initializes stream buffer
|
||||
gzofstream::gzofstream()
|
||||
: std::ostream(NULL), sb()
|
||||
{ this->init(&sb); }
|
||||
|
||||
// Initialize stream buffer and open file
|
||||
gzofstream::gzofstream(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
: std::ostream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->open(name, mode);
|
||||
}
|
||||
|
||||
// Initialize stream buffer and attach to file
|
||||
gzofstream::gzofstream(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
: std::ostream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->attach(fd, mode);
|
||||
}
|
||||
|
||||
// Open file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzofstream::open(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.open(name, mode | std::ios_base::out))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Attach to file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzofstream::attach(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.attach(fd, mode | std::ios_base::out))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Close file
|
||||
void
|
||||
gzofstream::close()
|
||||
{
|
||||
if (!sb.close())
|
||||
this->setstate(std::ios_base::failbit);
|
||||
}
|
|
@ -0,0 +1,466 @@
|
|||
/*
|
||||
* A C++ I/O streams interface to the zlib gz* functions
|
||||
*
|
||||
* by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
*
|
||||
* This version is standard-compliant and compatible with gcc 3.x.
|
||||
*/
|
||||
|
||||
#ifndef ZFSTREAM_H
|
||||
#define ZFSTREAM_H
|
||||
|
||||
#include <istream> // not iostream, since we don't need cin/cout
|
||||
#include <ostream>
|
||||
#include "zlib.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file stream buffer class.
|
||||
*
|
||||
* This class implements basic_filebuf for gzipped files. It doesn't yet support
|
||||
* seeking (allowed by zlib but slow/limited), putback and read/write access
|
||||
* (tricky). Otherwise, it attempts to be a drop-in replacement for the standard
|
||||
* file streambuf.
|
||||
*/
|
||||
class gzfilebuf : public std::streambuf
|
||||
{
|
||||
public:
|
||||
// Default constructor.
|
||||
gzfilebuf();
|
||||
|
||||
// Destructor.
|
||||
virtual
|
||||
~gzfilebuf();
|
||||
|
||||
/**
|
||||
* @brief Set compression level and strategy on the fly.
|
||||
* @param comp_level Compression level (see zlib.h for allowed values)
|
||||
* @param comp_strategy Compression strategy (see zlib.h for allowed values)
|
||||
* @return Z_OK on success, Z_STREAM_ERROR otherwise.
|
||||
*
|
||||
* Unfortunately, these parameters cannot be modified separately, as the
|
||||
* previous zfstream version assumed. Since the strategy is seldom changed,
|
||||
* it can default and setcompression(level) then becomes like the old
|
||||
* setcompressionlevel(level).
|
||||
*/
|
||||
int
|
||||
setcompression(int comp_level,
|
||||
int comp_strategy = Z_DEFAULT_STRATEGY);
|
||||
|
||||
/**
|
||||
* @brief Check if file is open.
|
||||
* @return True if file is open.
|
||||
*/
|
||||
bool
|
||||
is_open() const { return (file != NULL); }
|
||||
|
||||
/**
|
||||
* @brief Open gzipped file.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*/
|
||||
gzfilebuf*
|
||||
open(const char* name,
|
||||
std::ios_base::openmode mode);
|
||||
|
||||
/**
|
||||
* @brief Attach to already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*/
|
||||
gzfilebuf*
|
||||
attach(int fd,
|
||||
std::ios_base::openmode mode);
|
||||
|
||||
/**
|
||||
* @brief Close gzipped file.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*/
|
||||
gzfilebuf*
|
||||
close();
|
||||
|
||||
protected:
|
||||
/**
|
||||
* @brief Convert ios open mode int to mode string used by zlib.
|
||||
* @return True if valid mode flag combination.
|
||||
*/
|
||||
bool
|
||||
open_mode(std::ios_base::openmode mode,
|
||||
char* c_mode) const;
|
||||
|
||||
/**
|
||||
* @brief Number of characters available in stream buffer.
|
||||
* @return Number of characters.
|
||||
*
|
||||
* This indicates number of characters in get area of stream buffer.
|
||||
* These characters can be read without accessing the gzipped file.
|
||||
*/
|
||||
virtual std::streamsize
|
||||
showmanyc();
|
||||
|
||||
/**
|
||||
* @brief Fill get area from gzipped file.
|
||||
* @return First character in get area on success, EOF on error.
|
||||
*
|
||||
* This actually reads characters from gzipped file to stream
|
||||
* buffer. Always buffered.
|
||||
*/
|
||||
virtual int_type
|
||||
underflow();
|
||||
|
||||
/**
|
||||
* @brief Write put area to gzipped file.
|
||||
* @param c Extra character to add to buffer contents.
|
||||
* @return Non-EOF on success, EOF on error.
|
||||
*
|
||||
* This actually writes characters in stream buffer to
|
||||
* gzipped file. With unbuffered output this is done one
|
||||
* character at a time.
|
||||
*/
|
||||
virtual int_type
|
||||
overflow(int_type c = traits_type::eof());
|
||||
|
||||
/**
|
||||
* @brief Installs external stream buffer.
|
||||
* @param p Pointer to char buffer.
|
||||
* @param n Size of external buffer.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*
|
||||
* Call setbuf(0,0) to enable unbuffered output.
|
||||
*/
|
||||
virtual std::streambuf*
|
||||
setbuf(char_type* p,
|
||||
std::streamsize n);
|
||||
|
||||
/**
|
||||
* @brief Flush stream buffer to file.
|
||||
* @return 0 on success, -1 on error.
|
||||
*
|
||||
* This calls underflow(EOF) to do the job.
|
||||
*/
|
||||
virtual int
|
||||
sync();
|
||||
|
||||
//
|
||||
// Some future enhancements
|
||||
//
|
||||
// virtual int_type uflow();
|
||||
// virtual int_type pbackfail(int_type c = traits_type::eof());
|
||||
// virtual pos_type
|
||||
// seekoff(off_type off,
|
||||
// std::ios_base::seekdir way,
|
||||
// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);
|
||||
// virtual pos_type
|
||||
// seekpos(pos_type sp,
|
||||
// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);
|
||||
|
||||
private:
|
||||
/**
|
||||
* @brief Allocate internal buffer.
|
||||
*
|
||||
* This function is safe to call multiple times. It will ensure
|
||||
* that a proper internal buffer exists if it is required. If the
|
||||
* buffer already exists or is external, the buffer pointers will be
|
||||
* reset to their original state.
|
||||
*/
|
||||
void
|
||||
enable_buffer();
|
||||
|
||||
/**
|
||||
* @brief Destroy internal buffer.
|
||||
*
|
||||
* This function is safe to call multiple times. It will ensure
|
||||
* that the internal buffer is deallocated if it exists. In any
|
||||
* case, it will also reset the buffer pointers.
|
||||
*/
|
||||
void
|
||||
disable_buffer();
|
||||
|
||||
/**
|
||||
* Underlying file pointer.
|
||||
*/
|
||||
gzFile file;
|
||||
|
||||
/**
|
||||
* Mode in which file was opened.
|
||||
*/
|
||||
std::ios_base::openmode io_mode;
|
||||
|
||||
/**
|
||||
* @brief True if this object owns file descriptor.
|
||||
*
|
||||
* This makes the class responsible for closing the file
|
||||
* upon destruction.
|
||||
*/
|
||||
bool own_fd;
|
||||
|
||||
/**
|
||||
* @brief Stream buffer.
|
||||
*
|
||||
* For simplicity this remains allocated on the free store for the
|
||||
* entire life span of the gzfilebuf object, unless replaced by setbuf.
|
||||
*/
|
||||
char_type* buffer;
|
||||
|
||||
/**
|
||||
* @brief Stream buffer size.
|
||||
*
|
||||
* Defaults to system default buffer size (typically 8192 bytes).
|
||||
* Modified by setbuf.
|
||||
*/
|
||||
std::streamsize buffer_size;
|
||||
|
||||
/**
|
||||
* @brief True if this object owns stream buffer.
|
||||
*
|
||||
* This makes the class responsible for deleting the buffer
|
||||
* upon destruction.
|
||||
*/
|
||||
bool own_buffer;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file input stream class.
|
||||
*
|
||||
* This class implements ifstream for gzipped files. Seeking and putback
|
||||
* is not supported yet.
|
||||
*/
|
||||
class gzifstream : public std::istream
|
||||
{
|
||||
public:
|
||||
// Default constructor
|
||||
gzifstream();
|
||||
|
||||
/**
|
||||
* @brief Construct stream on gzipped file to be opened.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*/
|
||||
explicit
|
||||
gzifstream(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* @brief Construct stream on already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*/
|
||||
explicit
|
||||
gzifstream(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* Obtain underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf*
|
||||
rdbuf() const
|
||||
{ return const_cast<gzfilebuf*>(&sb); }
|
||||
|
||||
/**
|
||||
* @brief Check if file is open.
|
||||
* @return True if file is open.
|
||||
*/
|
||||
bool
|
||||
is_open() { return sb.is_open(); }
|
||||
|
||||
/**
|
||||
* @brief Open gzipped file.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*
|
||||
* Stream will be in state good() if file opens successfully;
|
||||
* otherwise in state fail(). This differs from the behavior of
|
||||
* ifstream, which never sets the state to good() and therefore
|
||||
* won't allow you to reuse the stream for a second file unless
|
||||
* you manually clear() the state. The choice is a matter of
|
||||
* convenience.
|
||||
*/
|
||||
void
|
||||
open(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* @brief Attach to already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*
|
||||
* Stream will be in state good() if attach succeeded; otherwise
|
||||
* in state fail().
|
||||
*/
|
||||
void
|
||||
attach(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* @brief Close gzipped file.
|
||||
*
|
||||
* Stream will be in state fail() if close failed.
|
||||
*/
|
||||
void
|
||||
close();
|
||||
|
||||
private:
|
||||
/**
|
||||
* Underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf sb;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file output stream class.
|
||||
*
|
||||
* This class implements ofstream for gzipped files. Seeking and putback
|
||||
* is not supported yet.
|
||||
*/
|
||||
class gzofstream : public std::ostream
|
||||
{
|
||||
public:
|
||||
// Default constructor
|
||||
gzofstream();
|
||||
|
||||
/**
|
||||
* @brief Construct stream on gzipped file to be opened.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*/
|
||||
explicit
|
||||
gzofstream(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* @brief Construct stream on already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*/
|
||||
explicit
|
||||
gzofstream(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* Obtain underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf*
|
||||
rdbuf() const
|
||||
{ return const_cast<gzfilebuf*>(&sb); }
|
||||
|
||||
/**
|
||||
* @brief Check if file is open.
|
||||
* @return True if file is open.
|
||||
*/
|
||||
bool
|
||||
is_open() { return sb.is_open(); }
|
||||
|
||||
/**
|
||||
* @brief Open gzipped file.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*
|
||||
* Stream will be in state good() if file opens successfully;
|
||||
* otherwise in state fail(). This differs from the behavior of
|
||||
* ofstream, which never sets the state to good() and therefore
|
||||
* won't allow you to reuse the stream for a second file unless
|
||||
* you manually clear() the state. The choice is a matter of
|
||||
* convenience.
|
||||
*/
|
||||
void
|
||||
open(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* @brief Attach to already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*
|
||||
* Stream will be in state good() if attach succeeded; otherwise
|
||||
* in state fail().
|
||||
*/
|
||||
void
|
||||
attach(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* @brief Close gzipped file.
|
||||
*
|
||||
* Stream will be in state fail() if close failed.
|
||||
*/
|
||||
void
|
||||
close();
|
||||
|
||||
private:
|
||||
/**
|
||||
* Underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf sb;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file output stream manipulator class.
|
||||
*
|
||||
* This class defines a two-argument manipulator for gzofstream. It is used
|
||||
* as base for the setcompression(int,int) manipulator.
|
||||
*/
|
||||
template<typename T1, typename T2>
|
||||
class gzomanip2
|
||||
{
|
||||
public:
|
||||
// Allows insertor to peek at internals
|
||||
template <typename Ta, typename Tb>
|
||||
friend gzofstream&
|
||||
operator<<(gzofstream&,
|
||||
const gzomanip2<Ta,Tb>&);
|
||||
|
||||
// Constructor
|
||||
gzomanip2(gzofstream& (*f)(gzofstream&, T1, T2),
|
||||
T1 v1,
|
||||
T2 v2);
|
||||
private:
|
||||
// Underlying manipulator function
|
||||
gzofstream&
|
||||
(*func)(gzofstream&, T1, T2);
|
||||
|
||||
// Arguments for manipulator function
|
||||
T1 val1;
|
||||
T2 val2;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Manipulator function thunks through to stream buffer
|
||||
inline gzofstream&
|
||||
setcompression(gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY)
|
||||
{
|
||||
(gzs.rdbuf())->setcompression(l, s);
|
||||
return gzs;
|
||||
}
|
||||
|
||||
// Manipulator constructor stores arguments
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
gzomanip2<T1,T2>::gzomanip2(gzofstream &(*f)(gzofstream &, T1, T2),
|
||||
T1 v1,
|
||||
T2 v2)
|
||||
: func(f), val1(v1), val2(v2)
|
||||
{ }
|
||||
|
||||
// Insertor applies underlying manipulator function to stream
|
||||
template<typename T1, typename T2>
|
||||
inline gzofstream&
|
||||
operator<<(gzofstream& s, const gzomanip2<T1,T2>& m)
|
||||
{ return (*m.func)(s, m.val1, m.val2); }
|
||||
|
||||
// Insert this onto stream to simplify setting of compression level
|
||||
inline gzomanip2<int,int>
|
||||
setcompression(int l, int s = Z_DEFAULT_STRATEGY)
|
||||
{ return gzomanip2<int,int>(&setcompression, l, s); }
|
||||
|
||||
#endif // ZFSTREAM_H
|
|
@ -1,47 +1,51 @@
|
|||
Change in 0.21: (10 Mar 03)
|
||||
- bug fixes
|
||||
|
||||
Change in 0.17: (27 Jan 02)
|
||||
- bug fixes
|
||||
|
||||
Change in 0.16: (19 Jan 02)
|
||||
- Support of ioapi for virtualize zip file access
|
||||
|
||||
Change in 0.15: (19 Mar 98)
|
||||
- fix memory leak in minizip.c
|
||||
|
||||
Change in 0.14: (10 Mar 98)
|
||||
- fix bugs in minizip.c sample for zipping big file
|
||||
- fix problem in month in date handling
|
||||
- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
|
||||
comment handling
|
||||
|
||||
Change in 0.13: (6 Mar 98)
|
||||
- fix bugs in zip.c
|
||||
- add real minizip sample
|
||||
|
||||
Change in 0.12: (4 Mar 98)
|
||||
- add zip.c and zip.h for creates .zip file
|
||||
- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
|
||||
- fix miniunz.c for file without specific record for directory
|
||||
|
||||
Change in 0.11: (3 Mar 98)
|
||||
- fix bug in unzGetCurrentFileInfo for get extra field and comment
|
||||
- enhance miniunz sample, remove the bad unztst.c sample
|
||||
|
||||
Change in 0.10: (2 Mar 98)
|
||||
- fix bug in unzReadCurrentFile
|
||||
- rename unzip* to unz* function and structure
|
||||
- remove Windows-like hungary notation variable name
|
||||
- modify some structure in unzip.h
|
||||
- add somes comment in source
|
||||
- remove unzipGetcCurrentFile function
|
||||
- replace ZUNZEXPORT by ZEXPORT
|
||||
- add unzGetLocalExtrafield for get the local extrafield info
|
||||
- add a new sample, miniunz.c
|
||||
|
||||
Change in 0.4: (25 Feb 98)
|
||||
- suppress the type unzipFileInZip.
|
||||
Only on file in the zipfile can be open at the same time
|
||||
- fix somes typo in code
|
||||
- added tm_unz structure in unzip_file_info (date/time in readable format)
|
||||
Change in 0.22: (19 May 03)
|
||||
- crypting support (unless you define NOCRYPT)
|
||||
- append file in existing zipfile
|
||||
|
||||
Change in 0.21: (10 Mar 03)
|
||||
- bug fixes
|
||||
|
||||
Change in 0.17: (27 Jan 02)
|
||||
- bug fixes
|
||||
|
||||
Change in 0.16: (19 Jan 02)
|
||||
- Support of ioapi for virtualize zip file access
|
||||
|
||||
Change in 0.15: (19 Mar 98)
|
||||
- fix memory leak in minizip.c
|
||||
|
||||
Change in 0.14: (10 Mar 98)
|
||||
- fix bugs in minizip.c sample for zipping big file
|
||||
- fix problem in month in date handling
|
||||
- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
|
||||
comment handling
|
||||
|
||||
Change in 0.13: (6 Mar 98)
|
||||
- fix bugs in zip.c
|
||||
- add real minizip sample
|
||||
|
||||
Change in 0.12: (4 Mar 98)
|
||||
- add zip.c and zip.h for creates .zip file
|
||||
- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
|
||||
- fix miniunz.c for file without specific record for directory
|
||||
|
||||
Change in 0.11: (3 Mar 98)
|
||||
- fix bug in unzGetCurrentFileInfo for get extra field and comment
|
||||
- enhance miniunz sample, remove the bad unztst.c sample
|
||||
|
||||
Change in 0.10: (2 Mar 98)
|
||||
- fix bug in unzReadCurrentFile
|
||||
- rename unzip* to unz* function and structure
|
||||
- remove Windows-like hungary notation variable name
|
||||
- modify some structure in unzip.h
|
||||
- add somes comment in source
|
||||
- remove unzipGetcCurrentFile function
|
||||
- replace ZUNZEXPORT by ZEXPORT
|
||||
- add unzGetLocalExtrafield for get the local extrafield info
|
||||
- add a new sample, miniunz.c
|
||||
|
||||
Change in 0.4: (25 Feb 98)
|
||||
- suppress the type unzipFileInZip.
|
||||
Only on file in the zipfile can be open at the same time
|
||||
- fix somes typo in code
|
||||
- added tm_unz structure in unzip_file_info (date/time in readable format)
|
||||
|
|
|
@ -1,25 +1,25 @@
|
|||
CC=cc
|
||||
CFLAGS=-O -I../..
|
||||
|
||||
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
|
||||
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
|
||||
|
||||
.c.o:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
all: miniunz minizip
|
||||
|
||||
miniunz: $(UNZ_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
|
||||
|
||||
minizip: $(ZIP_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
|
||||
|
||||
test: miniunz minizip
|
||||
./minizip test readme.txt
|
||||
./miniunz -l test.zip
|
||||
mv readme.txt readme.old
|
||||
./miniunz test.zip
|
||||
|
||||
clean:
|
||||
/bin/rm -f *.o *~ minizip miniunz
|
||||
CC=cc
|
||||
CFLAGS=-O -I../..
|
||||
|
||||
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
|
||||
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
|
||||
|
||||
.c.o:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
all: miniunz minizip
|
||||
|
||||
miniunz: $(UNZ_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
|
||||
|
||||
minizip: $(ZIP_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
|
||||
|
||||
test: miniunz minizip
|
||||
./minizip test readme.txt
|
||||
./miniunz -l test.zip
|
||||
mv readme.txt readme.old
|
||||
./miniunz test.zip
|
||||
|
||||
clean:
|
||||
/bin/rm -f *.o *~ minizip miniunz
|
||||
|
|
|
@ -1,104 +1,104 @@
|
|||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
|
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence
|
||||
*/
|
||||
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
|
||||
* unpredictable manner on 16-bit systems; not a problem
|
||||
* with any known compiler so far, though */
|
||||
|
||||
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
|
||||
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Update the encryption keys with the next byte of plain text
|
||||
*/
|
||||
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
|
||||
{
|
||||
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
|
||||
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
|
||||
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
|
||||
{
|
||||
register int keyshift = (int)((*(pkeys+1)) >> 24);
|
||||
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Initialize the encryption keys and the random header according to
|
||||
* the given password.
|
||||
*/
|
||||
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
*(pkeys+0) = 305419896L;
|
||||
*(pkeys+1) = 591751049L;
|
||||
*(pkeys+2) = 878082192L;
|
||||
while (*passwd != '\0') {
|
||||
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
|
||||
passwd++;
|
||||
}
|
||||
}
|
||||
|
||||
#define zdecode(pkeys,pcrc_32_tab,c) \
|
||||
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
|
||||
|
||||
#define zencode(pkeys,pcrc_32_tab,c,t) \
|
||||
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
|
||||
|
||||
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
|
||||
|
||||
#define RAND_HEAD_LEN 12
|
||||
/* "last resort" source for second part of crypt seed pattern */
|
||||
# ifndef ZCR_SEED2
|
||||
# define ZCR_SEED2 (unsigned long)3141592654L /* use PI as default pattern */
|
||||
# endif
|
||||
|
||||
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
|
||||
const char *passwd; /* password string */
|
||||
unsigned char *buf; /* where to write header */
|
||||
int bufSize;
|
||||
unsigned long* pkeys;
|
||||
const unsigned long* pcrc_32_tab;
|
||||
unsigned long crcForCrypting;
|
||||
{
|
||||
int n; /* index in random header */
|
||||
int t; /* temporary */
|
||||
int c; /* random byte */
|
||||
unsigned char header[RAND_HEAD_LEN-2]; /* random header */
|
||||
static unsigned calls = 0; /* ensure different random header each time */
|
||||
|
||||
if (bufSize<RAND_HEAD_LEN)
|
||||
return 0;
|
||||
|
||||
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
|
||||
* output of rand() to get less predictability, since rand() is
|
||||
* often poorly implemented.
|
||||
*/
|
||||
if (++calls == 1)
|
||||
{
|
||||
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
|
||||
}
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
c = (rand() >> 7) & 0xff;
|
||||
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
|
||||
}
|
||||
/* Encrypt random header (last two bytes is high word of crc) */
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
|
||||
}
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
|
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence
|
||||
*/
|
||||
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
|
||||
* unpredictable manner on 16-bit systems; not a problem
|
||||
* with any known compiler so far, though */
|
||||
|
||||
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
|
||||
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Update the encryption keys with the next byte of plain text
|
||||
*/
|
||||
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
|
||||
{
|
||||
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
|
||||
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
|
||||
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
|
||||
{
|
||||
register int keyshift = (int)((*(pkeys+1)) >> 24);
|
||||
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Initialize the encryption keys and the random header according to
|
||||
* the given password.
|
||||
*/
|
||||
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
*(pkeys+0) = 305419896L;
|
||||
*(pkeys+1) = 591751049L;
|
||||
*(pkeys+2) = 878082192L;
|
||||
while (*passwd != '\0') {
|
||||
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
|
||||
passwd++;
|
||||
}
|
||||
}
|
||||
|
||||
#define zdecode(pkeys,pcrc_32_tab,c) \
|
||||
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
|
||||
|
||||
#define zencode(pkeys,pcrc_32_tab,c,t) \
|
||||
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
|
||||
|
||||
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
|
||||
|
||||
#define RAND_HEAD_LEN 12
|
||||
/* "last resort" source for second part of crypt seed pattern */
|
||||
# ifndef ZCR_SEED2
|
||||
# define ZCR_SEED2 (unsigned long)3141592654L /* use PI as default pattern */
|
||||
# endif
|
||||
|
||||
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
|
||||
const char *passwd; /* password string */
|
||||
unsigned char *buf; /* where to write header */
|
||||
int bufSize;
|
||||
unsigned long* pkeys;
|
||||
const unsigned long* pcrc_32_tab;
|
||||
unsigned long crcForCrypting;
|
||||
{
|
||||
int n; /* index in random header */
|
||||
int t; /* temporary */
|
||||
int c; /* random byte */
|
||||
unsigned char header[RAND_HEAD_LEN-2]; /* random header */
|
||||
static unsigned calls = 0; /* ensure different random header each time */
|
||||
|
||||
if (bufSize<RAND_HEAD_LEN)
|
||||
return 0;
|
||||
|
||||
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
|
||||
* output of rand() to get less predictability, since rand() is
|
||||
* often poorly implemented.
|
||||
*/
|
||||
if (++calls == 1)
|
||||
{
|
||||
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
|
||||
}
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
c = (rand() >> 7) & 0xff;
|
||||
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
|
||||
}
|
||||
/* Encrypt random header (last two bytes is high word of crc) */
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
|
||||
}
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -1,177 +1,177 @@
|
|||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 0.21, March 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
|
||||
|
||||
|
||||
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
|
||||
|
||||
#ifndef SEEK_CUR
|
||||
#define SEEK_CUR 1
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_END
|
||||
#define SEEK_END 2
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_SET
|
||||
#define SEEK_SET 0
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func OF((
|
||||
voidpf opaque,
|
||||
const char* filename,
|
||||
int mode));
|
||||
|
||||
uLong ZCALLBACK fread_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size));
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size));
|
||||
|
||||
long ZCALLBACK ftell_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
long ZCALLBACK fseek_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin));
|
||||
|
||||
int ZCALLBACK fclose_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
int ZCALLBACK ferror_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
|
||||
voidpf opaque;
|
||||
const char* filename;
|
||||
int mode;
|
||||
{
|
||||
FILE* file = NULL;
|
||||
const char* mode_fopen = NULL;
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
mode_fopen = "rb";
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
mode_fopen = "r+b";
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
mode_fopen = "wb";
|
||||
|
||||
if ((filename!=NULL) && (mode_fopen != NULL))
|
||||
file = fopen(filename, mode_fopen);
|
||||
return file;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret;
|
||||
ret = fread(buf, 1, (size_t)size, (FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
const void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret;
|
||||
ret = fwrite(buf, 1, (size_t)size, (FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK ftell_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret;
|
||||
ret = ftell((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
uLong offset;
|
||||
int origin;
|
||||
{
|
||||
int fseek_origin=0;
|
||||
long ret;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
fseek_origin = SEEK_CUR;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
fseek_origin = SEEK_END;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
fseek_origin = SEEK_SET;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
ret = 0;
|
||||
fseek((FILE *)stream, offset, fseek_origin);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK fclose_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret;
|
||||
ret = fclose((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK ferror_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret;
|
||||
ret = ferror((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void fill_fopen_filefunc (pzlib_filefunc_def)
|
||||
zlib_filefunc_def* pzlib_filefunc_def;
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = fopen_file_func;
|
||||
pzlib_filefunc_def->zread_file = fread_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = fwrite_file_func;
|
||||
pzlib_filefunc_def->ztell_file = ftell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = fseek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = fclose_file_func;
|
||||
pzlib_filefunc_def->zerror_file = ferror_file_func;
|
||||
pzlib_filefunc_def->opaque = NULL;
|
||||
}
|
||||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
|
||||
|
||||
|
||||
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
|
||||
|
||||
#ifndef SEEK_CUR
|
||||
#define SEEK_CUR 1
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_END
|
||||
#define SEEK_END 2
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_SET
|
||||
#define SEEK_SET 0
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func OF((
|
||||
voidpf opaque,
|
||||
const char* filename,
|
||||
int mode));
|
||||
|
||||
uLong ZCALLBACK fread_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size));
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size));
|
||||
|
||||
long ZCALLBACK ftell_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
long ZCALLBACK fseek_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin));
|
||||
|
||||
int ZCALLBACK fclose_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
int ZCALLBACK ferror_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
|
||||
voidpf opaque;
|
||||
const char* filename;
|
||||
int mode;
|
||||
{
|
||||
FILE* file = NULL;
|
||||
const char* mode_fopen = NULL;
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
mode_fopen = "rb";
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
mode_fopen = "r+b";
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
mode_fopen = "wb";
|
||||
|
||||
if ((filename!=NULL) && (mode_fopen != NULL))
|
||||
file = fopen(filename, mode_fopen);
|
||||
return file;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret;
|
||||
ret = fread(buf, 1, (size_t)size, (FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
const void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret;
|
||||
ret = fwrite(buf, 1, (size_t)size, (FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK ftell_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret;
|
||||
ret = ftell((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
uLong offset;
|
||||
int origin;
|
||||
{
|
||||
int fseek_origin=0;
|
||||
long ret;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
fseek_origin = SEEK_CUR;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
fseek_origin = SEEK_END;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
fseek_origin = SEEK_SET;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
ret = 0;
|
||||
fseek((FILE *)stream, offset, fseek_origin);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK fclose_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret;
|
||||
ret = fclose((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK ferror_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret;
|
||||
ret = ferror((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void fill_fopen_filefunc (pzlib_filefunc_def)
|
||||
zlib_filefunc_def* pzlib_filefunc_def;
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = fopen_file_func;
|
||||
pzlib_filefunc_def->zread_file = fread_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = fwrite_file_func;
|
||||
pzlib_filefunc_def->ztell_file = ftell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = fseek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = fclose_file_func;
|
||||
pzlib_filefunc_def->zerror_file = ferror_file_func;
|
||||
pzlib_filefunc_def->opaque = NULL;
|
||||
}
|
||||
|
|
|
@ -1,75 +1,75 @@
|
|||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 0.21, March 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#define _ZLIBIOAPI_H
|
||||
|
||||
|
||||
#define ZLIB_FILEFUNC_SEEK_CUR (1)
|
||||
#define ZLIB_FILEFUNC_SEEK_END (2)
|
||||
#define ZLIB_FILEFUNC_SEEK_SET (0)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_READ (1)
|
||||
#define ZLIB_FILEFUNC_MODE_WRITE (2)
|
||||
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
|
||||
#define ZLIB_FILEFUNC_MODE_CREATE (8)
|
||||
|
||||
|
||||
#ifndef ZCALLBACK
|
||||
|
||||
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
|
||||
#define ZCALLBACK CALLBACK
|
||||
#else
|
||||
#define ZCALLBACK
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
|
||||
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
|
||||
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
|
||||
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
|
||||
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
|
||||
|
||||
typedef struct zlib_filefunc_def_s
|
||||
{
|
||||
open_file_func zopen_file;
|
||||
read_file_func zread_file;
|
||||
write_file_func zwrite_file;
|
||||
tell_file_func ztell_file;
|
||||
seek_file_func zseek_file;
|
||||
close_file_func zclose_file;
|
||||
testerror_file_func zerror_file;
|
||||
voidpf opaque;
|
||||
} zlib_filefunc_def;
|
||||
|
||||
|
||||
|
||||
void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
|
||||
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
|
||||
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
|
||||
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#define _ZLIBIOAPI_H
|
||||
|
||||
|
||||
#define ZLIB_FILEFUNC_SEEK_CUR (1)
|
||||
#define ZLIB_FILEFUNC_SEEK_END (2)
|
||||
#define ZLIB_FILEFUNC_SEEK_SET (0)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_READ (1)
|
||||
#define ZLIB_FILEFUNC_MODE_WRITE (2)
|
||||
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
|
||||
#define ZLIB_FILEFUNC_MODE_CREATE (8)
|
||||
|
||||
|
||||
#ifndef ZCALLBACK
|
||||
|
||||
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
|
||||
#define ZCALLBACK CALLBACK
|
||||
#else
|
||||
#define ZCALLBACK
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
|
||||
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
|
||||
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
|
||||
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
|
||||
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
|
||||
|
||||
typedef struct zlib_filefunc_def_s
|
||||
{
|
||||
open_file_func zopen_file;
|
||||
read_file_func zread_file;
|
||||
write_file_func zwrite_file;
|
||||
tell_file_func ztell_file;
|
||||
seek_file_func zseek_file;
|
||||
close_file_func zclose_file;
|
||||
testerror_file_func zerror_file;
|
||||
voidpf opaque;
|
||||
} zlib_filefunc_def;
|
||||
|
||||
|
||||
|
||||
void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
|
||||
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
|
||||
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
|
||||
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
@ -1,271 +1,271 @@
|
|||
/* iowin32.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
This IO API version uses the Win32 API (for Microsoft Windows)
|
||||
|
||||
Version 0.21, March 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <windows.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
#include "iowin32.h"
|
||||
|
||||
#ifndef INVALID_HANDLE_VALUE
|
||||
#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
|
||||
#endif
|
||||
|
||||
#ifndef INVALID_SET_FILE_POINTER
|
||||
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK win32_open_file_func OF((
|
||||
voidpf opaque,
|
||||
const char* filename,
|
||||
int mode));
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size));
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size));
|
||||
|
||||
long ZCALLBACK win32_tell_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
long ZCALLBACK win32_seek_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin));
|
||||
|
||||
long ZCALLBACK win32_close_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
int ZCALLBACK win32_error_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
typedef struct
|
||||
{
|
||||
HANDLE hf;
|
||||
int error;
|
||||
} WIN32FILE_IOWIN;
|
||||
|
||||
voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
|
||||
voidpf opaque;
|
||||
const char* filename;
|
||||
int mode;
|
||||
{
|
||||
const char* mode_fopen = NULL;
|
||||
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
|
||||
HANDLE hFile = 0;
|
||||
voidpf ret=NULL;
|
||||
|
||||
dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
|
||||
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_READ;
|
||||
dwCreationDisposition = OPEN_EXISTING;
|
||||
dwShareMode = FILE_SHARE_READ;
|
||||
}
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
|
||||
dwCreationDisposition = OPEN_EXISTING;
|
||||
}
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
|
||||
dwCreationDisposition = CREATE_ALWAYS;
|
||||
}
|
||||
|
||||
if ((filename!=NULL) && (dwDesiredAccess != 0))
|
||||
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
|
||||
dwCreationDisposition, dwFlagsAndAttributes, NULL);
|
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE)
|
||||
hFile = NULL;
|
||||
|
||||
if (hFile != NULL)
|
||||
{
|
||||
WIN32FILE_IOWIN w32fiow;
|
||||
w32fiow.hf = hFile;
|
||||
w32fiow.error = 0;
|
||||
ret = malloc(sizeof(WIN32FILE_IOWIN));
|
||||
if (ret==NULL)
|
||||
CloseHandle(hFile);
|
||||
else *((WIN32FILE_IOWIN*)ret) = w32fiow;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret=0;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
if (!ReadFile(hFile, buf, size, &ret, NULL))
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
if (dwErr == ERROR_HANDLE_EOF)
|
||||
dwErr = 0;
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
const void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret=0;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
|
||||
if (hFile !=NULL)
|
||||
if (!WriteFile(hFile, buf, size, &ret, NULL))
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
if (dwErr == ERROR_HANDLE_EOF)
|
||||
dwErr = 0;
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_tell_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret=-1;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
{
|
||||
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
|
||||
if (dwSet == INVALID_SET_FILE_POINTER)
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
ret = -1;
|
||||
}
|
||||
else
|
||||
ret=(long)dwSet;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
uLong offset;
|
||||
int origin;
|
||||
{
|
||||
DWORD dwMoveMethod=0xFFFFFFFF;
|
||||
HANDLE hFile = NULL;
|
||||
|
||||
long ret=-1;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
dwMoveMethod = FILE_CURRENT;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
dwMoveMethod = FILE_END;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
dwMoveMethod = FILE_BEGIN;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
|
||||
if (hFile != NULL)
|
||||
{
|
||||
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
|
||||
if (dwSet == INVALID_SET_FILE_POINTER)
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
ret = -1;
|
||||
}
|
||||
else
|
||||
ret=0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_close_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret=-1;
|
||||
|
||||
if (stream!=NULL)
|
||||
{
|
||||
HANDLE hFile;
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
{
|
||||
CloseHandle(hFile);
|
||||
ret=0;
|
||||
}
|
||||
free(stream);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK win32_error_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret=-1;
|
||||
if (stream!=NULL)
|
||||
{
|
||||
ret = ((WIN32FILE_IOWIN*)stream) -> error;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void fill_win32_filefunc (pzlib_filefunc_def)
|
||||
zlib_filefunc_def* pzlib_filefunc_def;
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = win32_open_file_func;
|
||||
pzlib_filefunc_def->zread_file = win32_read_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
|
||||
pzlib_filefunc_def->ztell_file = win32_tell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = win32_seek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = win32_close_file_func;
|
||||
pzlib_filefunc_def->zerror_file = win32_error_file_func;
|
||||
pzlib_filefunc_def->opaque=NULL;
|
||||
}
|
||||
/* iowin32.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
This IO API version uses the Win32 API (for Microsoft Windows)
|
||||
|
||||
Version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <windows.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
#include "iowin32.h"
|
||||
|
||||
#ifndef INVALID_HANDLE_VALUE
|
||||
#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
|
||||
#endif
|
||||
|
||||
#ifndef INVALID_SET_FILE_POINTER
|
||||
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK win32_open_file_func OF((
|
||||
voidpf opaque,
|
||||
const char* filename,
|
||||
int mode));
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size));
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size));
|
||||
|
||||
long ZCALLBACK win32_tell_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
long ZCALLBACK win32_seek_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin));
|
||||
|
||||
long ZCALLBACK win32_close_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
int ZCALLBACK win32_error_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
typedef struct
|
||||
{
|
||||
HANDLE hf;
|
||||
int error;
|
||||
} WIN32FILE_IOWIN;
|
||||
|
||||
voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
|
||||
voidpf opaque;
|
||||
const char* filename;
|
||||
int mode;
|
||||
{
|
||||
const char* mode_fopen = NULL;
|
||||
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
|
||||
HANDLE hFile = 0;
|
||||
voidpf ret=NULL;
|
||||
|
||||
dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
|
||||
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_READ;
|
||||
dwCreationDisposition = OPEN_EXISTING;
|
||||
dwShareMode = FILE_SHARE_READ;
|
||||
}
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
|
||||
dwCreationDisposition = OPEN_EXISTING;
|
||||
}
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
|
||||
dwCreationDisposition = CREATE_ALWAYS;
|
||||
}
|
||||
|
||||
if ((filename!=NULL) && (dwDesiredAccess != 0))
|
||||
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
|
||||
dwCreationDisposition, dwFlagsAndAttributes, NULL);
|
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE)
|
||||
hFile = NULL;
|
||||
|
||||
if (hFile != NULL)
|
||||
{
|
||||
WIN32FILE_IOWIN w32fiow;
|
||||
w32fiow.hf = hFile;
|
||||
w32fiow.error = 0;
|
||||
ret = malloc(sizeof(WIN32FILE_IOWIN));
|
||||
if (ret==NULL)
|
||||
CloseHandle(hFile);
|
||||
else *((WIN32FILE_IOWIN*)ret) = w32fiow;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret=0;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
if (!ReadFile(hFile, buf, size, &ret, NULL))
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
if (dwErr == ERROR_HANDLE_EOF)
|
||||
dwErr = 0;
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
const void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret=0;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
|
||||
if (hFile !=NULL)
|
||||
if (!WriteFile(hFile, buf, size, &ret, NULL))
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
if (dwErr == ERROR_HANDLE_EOF)
|
||||
dwErr = 0;
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_tell_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret=-1;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
{
|
||||
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
|
||||
if (dwSet == INVALID_SET_FILE_POINTER)
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
ret = -1;
|
||||
}
|
||||
else
|
||||
ret=(long)dwSet;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
uLong offset;
|
||||
int origin;
|
||||
{
|
||||
DWORD dwMoveMethod=0xFFFFFFFF;
|
||||
HANDLE hFile = NULL;
|
||||
|
||||
long ret=-1;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
dwMoveMethod = FILE_CURRENT;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
dwMoveMethod = FILE_END;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
dwMoveMethod = FILE_BEGIN;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
|
||||
if (hFile != NULL)
|
||||
{
|
||||
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
|
||||
if (dwSet == INVALID_SET_FILE_POINTER)
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
ret = -1;
|
||||
}
|
||||
else
|
||||
ret=0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_close_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret=-1;
|
||||
|
||||
if (stream!=NULL)
|
||||
{
|
||||
HANDLE hFile;
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
{
|
||||
CloseHandle(hFile);
|
||||
ret=0;
|
||||
}
|
||||
free(stream);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK win32_error_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret=-1;
|
||||
if (stream!=NULL)
|
||||
{
|
||||
ret = ((WIN32FILE_IOWIN*)stream) -> error;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void fill_win32_filefunc (pzlib_filefunc_def)
|
||||
zlib_filefunc_def* pzlib_filefunc_def;
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = win32_open_file_func;
|
||||
pzlib_filefunc_def->zread_file = win32_read_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
|
||||
pzlib_filefunc_def->ztell_file = win32_tell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = win32_seek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = win32_close_file_func;
|
||||
pzlib_filefunc_def->zerror_file = win32_error_file_func;
|
||||
pzlib_filefunc_def->opaque=NULL;
|
||||
}
|
||||
|
|
|
@ -1,19 +1,19 @@
|
|||
/* iowin32.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
This IO API version uses the Win32 API (for Microsoft Windows)
|
||||
|
||||
Version 0.21, March 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* iowin32.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
This IO API version uses the Win32 API (for Microsoft Windows)
|
||||
|
||||
Version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,392 +1,397 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef unix
|
||||
# include <unistd.h>
|
||||
# include <utime.h>
|
||||
# include <sys/types.h>
|
||||
# include <sys/stat.h>
|
||||
#else
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include "zip.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#define USEWIN32IOAPI
|
||||
#include "iowin32.h"
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define WRITEBUFFERSIZE (16384)
|
||||
#define MAXFILENAME (256)
|
||||
|
||||
#ifdef WIN32
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
int ret = 0;
|
||||
{
|
||||
FILETIME ftLocal;
|
||||
HANDLE hFind;
|
||||
WIN32_FIND_DATA ff32;
|
||||
|
||||
hFind = FindFirstFile(f,&ff32);
|
||||
if (hFind != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
|
||||
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
|
||||
FindClose(hFind);
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#ifdef unix
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
int ret=0;
|
||||
struct stat s; /* results of stat() */
|
||||
struct tm* filedate;
|
||||
time_t tm_t=0;
|
||||
|
||||
if (strcmp(f,"-")!=0)
|
||||
{
|
||||
char name[MAXFILENAME+1];
|
||||
int len = strlen(f);
|
||||
|
||||
strncpy(name, f,MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
name[ MAXFILENAME ] = '\0';
|
||||
|
||||
if (name[len - 1] == '/')
|
||||
name[len - 1] = '\0';
|
||||
/* not all systems allow stat'ing a file with / appended */
|
||||
if (stat(name,&s)==0)
|
||||
{
|
||||
tm_t = s.st_mtime;
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
filedate = localtime(&tm_t);
|
||||
|
||||
tmzip->tm_sec = filedate->tm_sec;
|
||||
tmzip->tm_min = filedate->tm_min;
|
||||
tmzip->tm_hour = filedate->tm_hour;
|
||||
tmzip->tm_mday = filedate->tm_mday;
|
||||
tmzip->tm_mon = filedate->tm_mon ;
|
||||
tmzip->tm_year = filedate->tm_year;
|
||||
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
int check_exist_file(filename)
|
||||
const char* filename;
|
||||
{
|
||||
FILE* ftestexist;
|
||||
int ret = 1;
|
||||
ftestexist = fopen(filename,"rb");
|
||||
if (ftestexist==NULL)
|
||||
ret = 0;
|
||||
else
|
||||
fclose(ftestexist);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void do_banner()
|
||||
{
|
||||
printf("MiniZip 0.15, demo of zLib + Zip package written by Gilles Vollant\n");
|
||||
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
|
||||
}
|
||||
|
||||
void do_help()
|
||||
{
|
||||
printf("Usage : minizip [-o] file.zip [files_to_add]\n\n") ;
|
||||
}
|
||||
|
||||
/* calculate the CRC32 of a file,
|
||||
because to encrypt a file, we need known the CRC32 of the file before */
|
||||
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
|
||||
{
|
||||
unsigned long calculate_crc=0;
|
||||
int err=ZIP_OK;
|
||||
FILE * fin = fopen(filenameinzip,"rb");
|
||||
unsigned long size_read = 0;
|
||||
unsigned long total_read = 0;
|
||||
if (fin==NULL)
|
||||
{
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (err == ZIP_OK)
|
||||
do
|
||||
{
|
||||
err = ZIP_OK;
|
||||
size_read = (int)fread(buf,1,size_buf,fin);
|
||||
if (size_read < size_buf)
|
||||
if (feof(fin)==0)
|
||||
{
|
||||
printf("error in reading %s\n",filenameinzip);
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (size_read>0)
|
||||
calculate_crc = crc32(calculate_crc,buf,size_read);
|
||||
total_read += size_read;
|
||||
|
||||
} while ((err == ZIP_OK) && (size_read>0));
|
||||
|
||||
if (fin)
|
||||
fclose(fin);
|
||||
|
||||
*result_crc=calculate_crc;
|
||||
printf("file %s crc %x\n",filenameinzip,calculate_crc);
|
||||
return err;
|
||||
}
|
||||
|
||||
int main(argc,argv)
|
||||
int argc;
|
||||
char *argv[];
|
||||
{
|
||||
int i;
|
||||
int opt_overwrite=0;
|
||||
int opt_compress_level=Z_DEFAULT_COMPRESSION;
|
||||
int zipfilenamearg = 0;
|
||||
char filename_try[MAXFILENAME+16];
|
||||
int zipok;
|
||||
int err=0;
|
||||
int size_buf=0;
|
||||
void* buf=NULL;
|
||||
const char* password=NULL;
|
||||
|
||||
|
||||
do_banner();
|
||||
if (argc==1)
|
||||
{
|
||||
do_help();
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=1;i<argc;i++)
|
||||
{
|
||||
if ((*argv[i])=='-')
|
||||
{
|
||||
const char *p=argv[i]+1;
|
||||
|
||||
while ((*p)!='\0')
|
||||
{
|
||||
char c=*(p++);;
|
||||
if ((c=='o') || (c=='O'))
|
||||
opt_overwrite = 1;
|
||||
if ((c=='a') || (c=='A'))
|
||||
opt_overwrite = 2;
|
||||
if ((c>='0') && (c<='9'))
|
||||
opt_compress_level = c-'0';
|
||||
|
||||
if (((c=='p') || (c=='P')) && (i+1<argc))
|
||||
{
|
||||
password=argv[i+1];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
if (zipfilenamearg == 0)
|
||||
zipfilenamearg = i ;
|
||||
}
|
||||
}
|
||||
|
||||
size_buf = WRITEBUFFERSIZE;
|
||||
buf = (void*)malloc(size_buf);
|
||||
if (buf==NULL)
|
||||
{
|
||||
printf("Error allocating memory\n");
|
||||
return ZIP_INTERNALERROR;
|
||||
}
|
||||
|
||||
if (zipfilenamearg==0)
|
||||
zipok=0;
|
||||
else
|
||||
{
|
||||
int i,len;
|
||||
int dot_found=0;
|
||||
|
||||
zipok = 1 ;
|
||||
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
filename_try[ MAXFILENAME ] = '\0';
|
||||
|
||||
len=(int)strlen(filename_try);
|
||||
for (i=0;i<len;i++)
|
||||
if (filename_try[i]=='.')
|
||||
dot_found=1;
|
||||
|
||||
if (dot_found==0)
|
||||
strcat(filename_try,".zip");
|
||||
|
||||
if (opt_overwrite==2)
|
||||
{
|
||||
/* if the file don't exist, we not append file */
|
||||
if (check_exist_file(filename_try)==0)
|
||||
opt_overwrite=1;
|
||||
}
|
||||
else
|
||||
if (opt_overwrite==0)
|
||||
if (check_exist_file(filename_try)!=0)
|
||||
{
|
||||
char rep=0;
|
||||
do
|
||||
{
|
||||
char answer[128];
|
||||
printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
|
||||
scanf("%1s",answer);
|
||||
rep = answer[0] ;
|
||||
if ((rep>='a') && (rep<='z'))
|
||||
rep -= 0x20;
|
||||
}
|
||||
while ((rep!='Y') && (rep!='N') && (rep!='A'));
|
||||
if (rep=='N')
|
||||
zipok = 0;
|
||||
if (rep=='A')
|
||||
opt_overwrite = 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (zipok==1)
|
||||
{
|
||||
zipFile zf;
|
||||
int errclose;
|
||||
#ifdef USEWIN32IOAPI
|
||||
zlib_filefunc_def ffunc;
|
||||
fill_win32_filefunc(&ffunc);
|
||||
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
|
||||
#else
|
||||
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
|
||||
#endif
|
||||
|
||||
if (zf == NULL)
|
||||
{
|
||||
printf("error opening %s\n",filename_try);
|
||||
err= ZIP_ERRNO;
|
||||
}
|
||||
else
|
||||
printf("creating %s\n",filename_try);
|
||||
|
||||
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
|
||||
{
|
||||
if (((*(argv[i]))!='-') && ((*(argv[i]))!='/'))
|
||||
{
|
||||
FILE * fin;
|
||||
int size_read;
|
||||
const char* filenameinzip = argv[i];
|
||||
zip_fileinfo zi;
|
||||
unsigned long crcFile=0;
|
||||
|
||||
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
|
||||
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
|
||||
zi.dosDate = 0;
|
||||
zi.internal_fa = 0;
|
||||
zi.external_fa = 0;
|
||||
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
|
||||
|
||||
/*
|
||||
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
|
||||
NULL,0,NULL,0,NULL / * comment * /,
|
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0,
|
||||
opt_compress_level);
|
||||
*/
|
||||
if ((password != NULL) && (err==ZIP_OK))
|
||||
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
|
||||
|
||||
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
|
||||
NULL,0,NULL,0,NULL /* comment*/,
|
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0,
|
||||
opt_compress_level,0,
|
||||
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
|
||||
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
|
||||
password,crcFile);
|
||||
|
||||
if (err != ZIP_OK)
|
||||
printf("error in opening %s in zipfile\n",filenameinzip);
|
||||
else
|
||||
{
|
||||
fin = fopen(filenameinzip,"rb");
|
||||
if (fin==NULL)
|
||||
{
|
||||
err=ZIP_ERRNO;
|
||||
printf("error in opening %s for reading\n",filenameinzip);
|
||||
}
|
||||
}
|
||||
|
||||
if (err == ZIP_OK)
|
||||
do
|
||||
{
|
||||
err = ZIP_OK;
|
||||
size_read = (int)fread(buf,1,size_buf,fin);
|
||||
if (size_read < size_buf)
|
||||
if (feof(fin)==0)
|
||||
{
|
||||
printf("error in reading %s\n",filenameinzip);
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (size_read>0)
|
||||
{
|
||||
err = zipWriteInFileInZip (zf,buf,size_read);
|
||||
if (err<0)
|
||||
{
|
||||
printf("error in writing %s in the zipfile\n",
|
||||
filenameinzip);
|
||||
}
|
||||
|
||||
}
|
||||
} while ((err == ZIP_OK) && (size_read>0));
|
||||
|
||||
if (fin)
|
||||
fclose(fin);
|
||||
|
||||
if (err<0)
|
||||
err=ZIP_ERRNO;
|
||||
else
|
||||
{
|
||||
err = zipCloseFileInZip(zf);
|
||||
if (err!=ZIP_OK)
|
||||
printf("error in closing %s in the zipfile\n",
|
||||
filenameinzip);
|
||||
}
|
||||
}
|
||||
}
|
||||
errclose = zipClose(zf,NULL);
|
||||
if (errclose != ZIP_OK)
|
||||
printf("error in closing %s\n",filename_try);
|
||||
}
|
||||
|
||||
free(buf);
|
||||
return 0;
|
||||
}
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef unix
|
||||
# include <unistd.h>
|
||||
# include <utime.h>
|
||||
# include <sys/types.h>
|
||||
# include <sys/stat.h>
|
||||
#else
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include "zip.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#define USEWIN32IOAPI
|
||||
#include "iowin32.h"
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define WRITEBUFFERSIZE (16384)
|
||||
#define MAXFILENAME (256)
|
||||
|
||||
#ifdef WIN32
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
int ret = 0;
|
||||
{
|
||||
FILETIME ftLocal;
|
||||
HANDLE hFind;
|
||||
WIN32_FIND_DATA ff32;
|
||||
|
||||
hFind = FindFirstFile(f,&ff32);
|
||||
if (hFind != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
|
||||
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
|
||||
FindClose(hFind);
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#ifdef unix
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
int ret=0;
|
||||
struct stat s; /* results of stat() */
|
||||
struct tm* filedate;
|
||||
time_t tm_t=0;
|
||||
|
||||
if (strcmp(f,"-")!=0)
|
||||
{
|
||||
char name[MAXFILENAME+1];
|
||||
int len = strlen(f);
|
||||
|
||||
strncpy(name, f,MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
name[ MAXFILENAME ] = '\0';
|
||||
|
||||
if (name[len - 1] == '/')
|
||||
name[len - 1] = '\0';
|
||||
/* not all systems allow stat'ing a file with / appended */
|
||||
if (stat(name,&s)==0)
|
||||
{
|
||||
tm_t = s.st_mtime;
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
filedate = localtime(&tm_t);
|
||||
|
||||
tmzip->tm_sec = filedate->tm_sec;
|
||||
tmzip->tm_min = filedate->tm_min;
|
||||
tmzip->tm_hour = filedate->tm_hour;
|
||||
tmzip->tm_mday = filedate->tm_mday;
|
||||
tmzip->tm_mon = filedate->tm_mon ;
|
||||
tmzip->tm_year = filedate->tm_year;
|
||||
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
int check_exist_file(filename)
|
||||
const char* filename;
|
||||
{
|
||||
FILE* ftestexist;
|
||||
int ret = 1;
|
||||
ftestexist = fopen(filename,"rb");
|
||||
if (ftestexist==NULL)
|
||||
ret = 0;
|
||||
else
|
||||
fclose(ftestexist);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void do_banner()
|
||||
{
|
||||
printf("MiniZip 0.22, demo of zLib + Zip package written by Gilles Vollant\n");
|
||||
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
|
||||
}
|
||||
|
||||
void do_help()
|
||||
{
|
||||
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
|
||||
" -o Overwrite existing file.zip\n" \
|
||||
" -a Append to existing file.zip\n" \
|
||||
" -0 Store only\n" \
|
||||
" -1 Compress faster\n" \
|
||||
" -9 Compress better\n\n");
|
||||
}
|
||||
|
||||
/* calculate the CRC32 of a file,
|
||||
because to encrypt a file, we need known the CRC32 of the file before */
|
||||
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
|
||||
{
|
||||
unsigned long calculate_crc=0;
|
||||
int err=ZIP_OK;
|
||||
FILE * fin = fopen(filenameinzip,"rb");
|
||||
unsigned long size_read = 0;
|
||||
unsigned long total_read = 0;
|
||||
if (fin==NULL)
|
||||
{
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (err == ZIP_OK)
|
||||
do
|
||||
{
|
||||
err = ZIP_OK;
|
||||
size_read = (int)fread(buf,1,size_buf,fin);
|
||||
if (size_read < size_buf)
|
||||
if (feof(fin)==0)
|
||||
{
|
||||
printf("error in reading %s\n",filenameinzip);
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (size_read>0)
|
||||
calculate_crc = crc32(calculate_crc,buf,size_read);
|
||||
total_read += size_read;
|
||||
|
||||
} while ((err == ZIP_OK) && (size_read>0));
|
||||
|
||||
if (fin)
|
||||
fclose(fin);
|
||||
|
||||
*result_crc=calculate_crc;
|
||||
printf("file %s crc %x\n",filenameinzip,calculate_crc);
|
||||
return err;
|
||||
}
|
||||
|
||||
int main(argc,argv)
|
||||
int argc;
|
||||
char *argv[];
|
||||
{
|
||||
int i;
|
||||
int opt_overwrite=0;
|
||||
int opt_compress_level=Z_DEFAULT_COMPRESSION;
|
||||
int zipfilenamearg = 0;
|
||||
char filename_try[MAXFILENAME+16];
|
||||
int zipok;
|
||||
int err=0;
|
||||
int size_buf=0;
|
||||
void* buf=NULL;
|
||||
const char* password=NULL;
|
||||
|
||||
|
||||
do_banner();
|
||||
if (argc==1)
|
||||
{
|
||||
do_help();
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=1;i<argc;i++)
|
||||
{
|
||||
if ((*argv[i])=='-')
|
||||
{
|
||||
const char *p=argv[i]+1;
|
||||
|
||||
while ((*p)!='\0')
|
||||
{
|
||||
char c=*(p++);;
|
||||
if ((c=='o') || (c=='O'))
|
||||
opt_overwrite = 1;
|
||||
if ((c=='a') || (c=='A'))
|
||||
opt_overwrite = 2;
|
||||
if ((c>='0') && (c<='9'))
|
||||
opt_compress_level = c-'0';
|
||||
|
||||
if (((c=='p') || (c=='P')) && (i+1<argc))
|
||||
{
|
||||
password=argv[i+1];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
if (zipfilenamearg == 0)
|
||||
zipfilenamearg = i ;
|
||||
}
|
||||
}
|
||||
|
||||
size_buf = WRITEBUFFERSIZE;
|
||||
buf = (void*)malloc(size_buf);
|
||||
if (buf==NULL)
|
||||
{
|
||||
printf("Error allocating memory\n");
|
||||
return ZIP_INTERNALERROR;
|
||||
}
|
||||
|
||||
if (zipfilenamearg==0)
|
||||
zipok=0;
|
||||
else
|
||||
{
|
||||
int i,len;
|
||||
int dot_found=0;
|
||||
|
||||
zipok = 1 ;
|
||||
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
filename_try[ MAXFILENAME ] = '\0';
|
||||
|
||||
len=(int)strlen(filename_try);
|
||||
for (i=0;i<len;i++)
|
||||
if (filename_try[i]=='.')
|
||||
dot_found=1;
|
||||
|
||||
if (dot_found==0)
|
||||
strcat(filename_try,".zip");
|
||||
|
||||
if (opt_overwrite==2)
|
||||
{
|
||||
/* if the file don't exist, we not append file */
|
||||
if (check_exist_file(filename_try)==0)
|
||||
opt_overwrite=1;
|
||||
}
|
||||
else
|
||||
if (opt_overwrite==0)
|
||||
if (check_exist_file(filename_try)!=0)
|
||||
{
|
||||
char rep=0;
|
||||
do
|
||||
{
|
||||
char answer[128];
|
||||
printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
|
||||
scanf("%1s",answer);
|
||||
rep = answer[0] ;
|
||||
if ((rep>='a') && (rep<='z'))
|
||||
rep -= 0x20;
|
||||
}
|
||||
while ((rep!='Y') && (rep!='N') && (rep!='A'));
|
||||
if (rep=='N')
|
||||
zipok = 0;
|
||||
if (rep=='A')
|
||||
opt_overwrite = 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (zipok==1)
|
||||
{
|
||||
zipFile zf;
|
||||
int errclose;
|
||||
#ifdef USEWIN32IOAPI
|
||||
zlib_filefunc_def ffunc;
|
||||
fill_win32_filefunc(&ffunc);
|
||||
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
|
||||
#else
|
||||
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
|
||||
#endif
|
||||
|
||||
if (zf == NULL)
|
||||
{
|
||||
printf("error opening %s\n",filename_try);
|
||||
err= ZIP_ERRNO;
|
||||
}
|
||||
else
|
||||
printf("creating %s\n",filename_try);
|
||||
|
||||
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
|
||||
{
|
||||
if (((*(argv[i]))!='-') && ((*(argv[i]))!='/'))
|
||||
{
|
||||
FILE * fin;
|
||||
int size_read;
|
||||
const char* filenameinzip = argv[i];
|
||||
zip_fileinfo zi;
|
||||
unsigned long crcFile=0;
|
||||
|
||||
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
|
||||
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
|
||||
zi.dosDate = 0;
|
||||
zi.internal_fa = 0;
|
||||
zi.external_fa = 0;
|
||||
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
|
||||
|
||||
/*
|
||||
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
|
||||
NULL,0,NULL,0,NULL / * comment * /,
|
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0,
|
||||
opt_compress_level);
|
||||
*/
|
||||
if ((password != NULL) && (err==ZIP_OK))
|
||||
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
|
||||
|
||||
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
|
||||
NULL,0,NULL,0,NULL /* comment*/,
|
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0,
|
||||
opt_compress_level,0,
|
||||
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
|
||||
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
|
||||
password,crcFile);
|
||||
|
||||
if (err != ZIP_OK)
|
||||
printf("error in opening %s in zipfile\n",filenameinzip);
|
||||
else
|
||||
{
|
||||
fin = fopen(filenameinzip,"rb");
|
||||
if (fin==NULL)
|
||||
{
|
||||
err=ZIP_ERRNO;
|
||||
printf("error in opening %s for reading\n",filenameinzip);
|
||||
}
|
||||
}
|
||||
|
||||
if (err == ZIP_OK)
|
||||
do
|
||||
{
|
||||
err = ZIP_OK;
|
||||
size_read = (int)fread(buf,1,size_buf,fin);
|
||||
if (size_read < size_buf)
|
||||
if (feof(fin)==0)
|
||||
{
|
||||
printf("error in reading %s\n",filenameinzip);
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (size_read>0)
|
||||
{
|
||||
err = zipWriteInFileInZip (zf,buf,size_read);
|
||||
if (err<0)
|
||||
{
|
||||
printf("error in writing %s in the zipfile\n",
|
||||
filenameinzip);
|
||||
}
|
||||
|
||||
}
|
||||
} while ((err == ZIP_OK) && (size_read>0));
|
||||
|
||||
if (fin)
|
||||
fclose(fin);
|
||||
|
||||
if (err<0)
|
||||
err=ZIP_ERRNO;
|
||||
else
|
||||
{
|
||||
err = zipCloseFileInZip(zf);
|
||||
if (err!=ZIP_OK)
|
||||
printf("error in closing %s in the zipfile\n",
|
||||
filenameinzip);
|
||||
}
|
||||
}
|
||||
}
|
||||
errclose = zipClose(zf,NULL);
|
||||
if (errclose != ZIP_OK)
|
||||
printf("error in closing %s\n",filename_try);
|
||||
}
|
||||
|
||||
free(buf);
|
||||
return 0;
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,342 +1,342 @@
|
|||
/* unzip.h -- IO for uncompress .zip files using zlib
|
||||
Version 0.21, March 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Encryption and multi volume ZipFile (span) are not supported.
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _unz_H
|
||||
#define _unz_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagunzFile__ { int unused; } unzFile__;
|
||||
typedef unzFile__ *unzFile;
|
||||
#else
|
||||
typedef voidp unzFile;
|
||||
#endif
|
||||
|
||||
|
||||
#define UNZ_OK (0)
|
||||
#define UNZ_END_OF_LIST_OF_FILE (-100)
|
||||
#define UNZ_ERRNO (Z_ERRNO)
|
||||
#define UNZ_EOF (0)
|
||||
#define UNZ_PARAMERROR (-102)
|
||||
#define UNZ_BADZIPFILE (-103)
|
||||
#define UNZ_INTERNALERROR (-104)
|
||||
#define UNZ_CRCERROR (-105)
|
||||
|
||||
/* tm_unz contain date/time info */
|
||||
typedef struct tm_unz_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_unz;
|
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */
|
||||
typedef struct unz_global_info_s
|
||||
{
|
||||
uLong number_entry; /* total number of entries in
|
||||
the central dir on this disk */
|
||||
uLong size_comment; /* size of the global comment of the zipfile */
|
||||
} unz_global_info;
|
||||
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_info_s
|
||||
{
|
||||
uLong version; /* version made by 2 bytes */
|
||||
uLong version_needed; /* version needed to extract 2 bytes */
|
||||
uLong flag; /* general purpose bit flag 2 bytes */
|
||||
uLong compression_method; /* compression method 2 bytes */
|
||||
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
|
||||
uLong crc; /* crc-32 4 bytes */
|
||||
uLong compressed_size; /* compressed size 4 bytes */
|
||||
uLong uncompressed_size; /* uncompressed size 4 bytes */
|
||||
uLong size_filename; /* filename length 2 bytes */
|
||||
uLong size_file_extra; /* extra field length 2 bytes */
|
||||
uLong size_file_comment; /* file comment length 2 bytes */
|
||||
|
||||
uLong disk_num_start; /* disk number start 2 bytes */
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
|
||||
tm_unz tmu_date;
|
||||
} unz_file_info;
|
||||
|
||||
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
|
||||
const char* fileName2,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Compare two filename (fileName1,fileName2).
|
||||
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
|
||||
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
|
||||
or strcasecmp)
|
||||
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
|
||||
(like 1 on Unix, 2 on Windows)
|
||||
*/
|
||||
|
||||
|
||||
extern unzFile ZEXPORT unzOpen OF((const char *path));
|
||||
/*
|
||||
Open a Zip file. path contain the full pathname (by example,
|
||||
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
|
||||
"zlib/zlib113.zip".
|
||||
If the zipfile cannot be opened (file don't exist or in not valid), the
|
||||
return value is NULL.
|
||||
Else, the return value is a unzFile Handle, usable with other function
|
||||
of this unzip package.
|
||||
*/
|
||||
|
||||
extern unzFile ZEXPORT unzOpen2 OF((const char *path,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
/*
|
||||
Open a Zip file, like unzOpen, but provide a set of file low level API
|
||||
for read/write the zip file (see ioapi.h)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzClose OF((unzFile file));
|
||||
/*
|
||||
Close a ZipFile opened with unzipOpen.
|
||||
If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
|
||||
these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
|
||||
unz_global_info *pglobal_info));
|
||||
/*
|
||||
Write info about the ZipFile in the *pglobal_info structure.
|
||||
No preparation of the structure is needed
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
|
||||
extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
|
||||
char *szComment,
|
||||
uLong uSizeBuf));
|
||||
/*
|
||||
Get the global comment string of the ZipFile, in the szComment buffer.
|
||||
uSizeBuf is the size of the szComment buffer.
|
||||
return the number of byte copied or an error code <0
|
||||
*/
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* Unzip package allow you browse the directory of the zipfile */
|
||||
|
||||
extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the first file.
|
||||
return UNZ_OK if there is no problem
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGoToNextFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the next file.
|
||||
return UNZ_OK if there is no problem
|
||||
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzLocateFile OF((unzFile file,
|
||||
const char *szFileName,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Try locate the file szFileName in the zipfile.
|
||||
For the iCaseSensitivity signification, see unzStringFileNameCompare
|
||||
|
||||
return value :
|
||||
UNZ_OK if the file is found. It becomes the current file.
|
||||
UNZ_END_OF_LIST_OF_FILE if the file is not found
|
||||
*/
|
||||
|
||||
|
||||
/* ****************************************** */
|
||||
/* Ryan supplied functions */
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_pos_s
|
||||
{
|
||||
uLong pos_in_zip_directory; /* offset in zip file directory */
|
||||
uLong num_of_file; /* # of file */
|
||||
} unz_file_pos;
|
||||
|
||||
extern int ZEXPORT unzGetFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
extern int ZEXPORT unzGoToFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
/* ****************************************** */
|
||||
|
||||
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
|
||||
unz_file_info *pfile_info,
|
||||
char *szFileName,
|
||||
uLong fileNameBufferSize,
|
||||
void *extraField,
|
||||
uLong extraFieldBufferSize,
|
||||
char *szComment,
|
||||
uLong commentBufferSize));
|
||||
/*
|
||||
Get Info about the current file
|
||||
if pfile_info!=NULL, the *pfile_info structure will contain somes info about
|
||||
the current file
|
||||
if szFileName!=NULL, the filemane string will be copied in szFileName
|
||||
(fileNameBufferSize is the size of the buffer)
|
||||
if extraField!=NULL, the extra field information will be copied in extraField
|
||||
(extraFieldBufferSize is the size of the buffer).
|
||||
This is the Central-header version of the extra field
|
||||
if szComment!=NULL, the comment string of the file will be copied in szComment
|
||||
(commentBufferSize is the size of the buffer)
|
||||
*/
|
||||
|
||||
/***************************************************************************/
|
||||
/* for reading the content of the current zipfile, you can open it, read data
|
||||
from it, and close it (you can close it before reading all the file)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
|
||||
const char* password));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
password is a crypting password
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw,
|
||||
const char* password));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Close the file in zip opened with unzOpenCurrentFile
|
||||
Return UNZ_CRCERROR if all the file was read but the CRC is not good
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read bytes from the current file (opened by unzOpenCurrentFile)
|
||||
buf contain buffer where data must be copied
|
||||
len the size of buf.
|
||||
|
||||
return the number of byte copied if somes bytes are copied
|
||||
return 0 if the end of file was reached
|
||||
return <0 with error code if there is an error
|
||||
(UNZ_ERRNO for IO error, or zLib error for uncompress error)
|
||||
*/
|
||||
|
||||
extern z_off_t ZEXPORT unztell OF((unzFile file));
|
||||
/*
|
||||
Give the current position in uncompressed data
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzeof OF((unzFile file));
|
||||
/*
|
||||
return 1 if the end of file was reached, 0 elsewhere
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read extra field from the current file (opened by unzOpenCurrentFile)
|
||||
This is the local-header version of the extra field (sometimes, there is
|
||||
more info in the local-header version than in the central-header)
|
||||
|
||||
if buf==NULL, it return the size of the local extra field
|
||||
|
||||
if buf!=NULL, len is the size of the buffer, the extra header is copied in
|
||||
buf.
|
||||
the return value is the number of bytes copied in buf, or (if <0)
|
||||
the error code
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _unz_H */
|
||||
/* unzip.h -- IO for uncompress .zip files using zlib
|
||||
Version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Encryption and multi volume ZipFile (span) are not supported.
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _unz_H
|
||||
#define _unz_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagunzFile__ { int unused; } unzFile__;
|
||||
typedef unzFile__ *unzFile;
|
||||
#else
|
||||
typedef voidp unzFile;
|
||||
#endif
|
||||
|
||||
|
||||
#define UNZ_OK (0)
|
||||
#define UNZ_END_OF_LIST_OF_FILE (-100)
|
||||
#define UNZ_ERRNO (Z_ERRNO)
|
||||
#define UNZ_EOF (0)
|
||||
#define UNZ_PARAMERROR (-102)
|
||||
#define UNZ_BADZIPFILE (-103)
|
||||
#define UNZ_INTERNALERROR (-104)
|
||||
#define UNZ_CRCERROR (-105)
|
||||
|
||||
/* tm_unz contain date/time info */
|
||||
typedef struct tm_unz_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_unz;
|
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */
|
||||
typedef struct unz_global_info_s
|
||||
{
|
||||
uLong number_entry; /* total number of entries in
|
||||
the central dir on this disk */
|
||||
uLong size_comment; /* size of the global comment of the zipfile */
|
||||
} unz_global_info;
|
||||
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_info_s
|
||||
{
|
||||
uLong version; /* version made by 2 bytes */
|
||||
uLong version_needed; /* version needed to extract 2 bytes */
|
||||
uLong flag; /* general purpose bit flag 2 bytes */
|
||||
uLong compression_method; /* compression method 2 bytes */
|
||||
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
|
||||
uLong crc; /* crc-32 4 bytes */
|
||||
uLong compressed_size; /* compressed size 4 bytes */
|
||||
uLong uncompressed_size; /* uncompressed size 4 bytes */
|
||||
uLong size_filename; /* filename length 2 bytes */
|
||||
uLong size_file_extra; /* extra field length 2 bytes */
|
||||
uLong size_file_comment; /* file comment length 2 bytes */
|
||||
|
||||
uLong disk_num_start; /* disk number start 2 bytes */
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
|
||||
tm_unz tmu_date;
|
||||
} unz_file_info;
|
||||
|
||||
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
|
||||
const char* fileName2,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Compare two filename (fileName1,fileName2).
|
||||
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
|
||||
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
|
||||
or strcasecmp)
|
||||
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
|
||||
(like 1 on Unix, 2 on Windows)
|
||||
*/
|
||||
|
||||
|
||||
extern unzFile ZEXPORT unzOpen OF((const char *path));
|
||||
/*
|
||||
Open a Zip file. path contain the full pathname (by example,
|
||||
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
|
||||
"zlib/zlib113.zip".
|
||||
If the zipfile cannot be opened (file don't exist or in not valid), the
|
||||
return value is NULL.
|
||||
Else, the return value is a unzFile Handle, usable with other function
|
||||
of this unzip package.
|
||||
*/
|
||||
|
||||
extern unzFile ZEXPORT unzOpen2 OF((const char *path,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
/*
|
||||
Open a Zip file, like unzOpen, but provide a set of file low level API
|
||||
for read/write the zip file (see ioapi.h)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzClose OF((unzFile file));
|
||||
/*
|
||||
Close a ZipFile opened with unzipOpen.
|
||||
If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
|
||||
these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
|
||||
unz_global_info *pglobal_info));
|
||||
/*
|
||||
Write info about the ZipFile in the *pglobal_info structure.
|
||||
No preparation of the structure is needed
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
|
||||
extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
|
||||
char *szComment,
|
||||
uLong uSizeBuf));
|
||||
/*
|
||||
Get the global comment string of the ZipFile, in the szComment buffer.
|
||||
uSizeBuf is the size of the szComment buffer.
|
||||
return the number of byte copied or an error code <0
|
||||
*/
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* Unzip package allow you browse the directory of the zipfile */
|
||||
|
||||
extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the first file.
|
||||
return UNZ_OK if there is no problem
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGoToNextFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the next file.
|
||||
return UNZ_OK if there is no problem
|
||||
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzLocateFile OF((unzFile file,
|
||||
const char *szFileName,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Try locate the file szFileName in the zipfile.
|
||||
For the iCaseSensitivity signification, see unzStringFileNameCompare
|
||||
|
||||
return value :
|
||||
UNZ_OK if the file is found. It becomes the current file.
|
||||
UNZ_END_OF_LIST_OF_FILE if the file is not found
|
||||
*/
|
||||
|
||||
|
||||
/* ****************************************** */
|
||||
/* Ryan supplied functions */
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_pos_s
|
||||
{
|
||||
uLong pos_in_zip_directory; /* offset in zip file directory */
|
||||
uLong num_of_file; /* # of file */
|
||||
} unz_file_pos;
|
||||
|
||||
extern int ZEXPORT unzGetFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
extern int ZEXPORT unzGoToFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
/* ****************************************** */
|
||||
|
||||
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
|
||||
unz_file_info *pfile_info,
|
||||
char *szFileName,
|
||||
uLong fileNameBufferSize,
|
||||
void *extraField,
|
||||
uLong extraFieldBufferSize,
|
||||
char *szComment,
|
||||
uLong commentBufferSize));
|
||||
/*
|
||||
Get Info about the current file
|
||||
if pfile_info!=NULL, the *pfile_info structure will contain somes info about
|
||||
the current file
|
||||
if szFileName!=NULL, the filemane string will be copied in szFileName
|
||||
(fileNameBufferSize is the size of the buffer)
|
||||
if extraField!=NULL, the extra field information will be copied in extraField
|
||||
(extraFieldBufferSize is the size of the buffer).
|
||||
This is the Central-header version of the extra field
|
||||
if szComment!=NULL, the comment string of the file will be copied in szComment
|
||||
(commentBufferSize is the size of the buffer)
|
||||
*/
|
||||
|
||||
/***************************************************************************/
|
||||
/* for reading the content of the current zipfile, you can open it, read data
|
||||
from it, and close it (you can close it before reading all the file)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
|
||||
const char* password));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
password is a crypting password
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw,
|
||||
const char* password));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Close the file in zip opened with unzOpenCurrentFile
|
||||
Return UNZ_CRCERROR if all the file was read but the CRC is not good
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read bytes from the current file (opened by unzOpenCurrentFile)
|
||||
buf contain buffer where data must be copied
|
||||
len the size of buf.
|
||||
|
||||
return the number of byte copied if somes bytes are copied
|
||||
return 0 if the end of file was reached
|
||||
return <0 with error code if there is an error
|
||||
(UNZ_ERRNO for IO error, or zLib error for uncompress error)
|
||||
*/
|
||||
|
||||
extern z_off_t ZEXPORT unztell OF((unzFile file));
|
||||
/*
|
||||
Give the current position in uncompressed data
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzeof OF((unzFile file));
|
||||
/*
|
||||
return 1 if the end of file was reached, 0 elsewhere
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read extra field from the current file (opened by unzOpenCurrentFile)
|
||||
This is the local-header version of the extra field (sometimes, there is
|
||||
more info in the local-header version than in the central-header)
|
||||
|
||||
if buf==NULL, it return the size of the local extra field
|
||||
|
||||
if buf!=NULL, len is the size of the buffer, the extra header is copied in
|
||||
buf.
|
||||
the return value is the number of bytes copied in buf, or (if <0)
|
||||
the error code
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _unz_H */
|
||||
|
|
|
@ -0,0 +1,326 @@
|
|||
/* zconf.h -- configuration of the zlib compression library
|
||||
* Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#ifndef _ZCONF_H
|
||||
#define _ZCONF_H
|
||||
|
||||
/*
|
||||
* If you *really* need a unique prefix for all types and library functions,
|
||||
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
|
||||
*/
|
||||
#ifdef Z_PREFIX
|
||||
# define deflateInit_ z_deflateInit_
|
||||
# define deflate z_deflate
|
||||
# define deflateEnd z_deflateEnd
|
||||
# define inflateInit_ z_inflateInit_
|
||||
# define inflate z_inflate
|
||||
# define inflateEnd z_inflateEnd
|
||||
# define deflateInit2_ z_deflateInit2_
|
||||
# define deflateSetDictionary z_deflateSetDictionary
|
||||
# define deflateCopy z_deflateCopy
|
||||
# define deflateReset z_deflateReset
|
||||
# define deflateParams z_deflateParams
|
||||
# define deflateBound z_deflateBound
|
||||
# define inflateInit2_ z_inflateInit2_
|
||||
# define inflateSetDictionary z_inflateSetDictionary
|
||||
# define inflateSync z_inflateSync
|
||||
# define inflateSyncPoint z_inflateSyncPoint
|
||||
# define inflateCopy z_inflateCopy
|
||||
# define inflateReset z_inflateReset
|
||||
# define compress z_compress
|
||||
# define compress2 z_compress2
|
||||
# define compressBound z_compressBound
|
||||
# define uncompress z_uncompress
|
||||
# define adler32 z_adler32
|
||||
# define crc32 z_crc32
|
||||
# define get_crc_table z_get_crc_table
|
||||
|
||||
# define Byte z_Byte
|
||||
# define uInt z_uInt
|
||||
# define uLong z_uLong
|
||||
# define Bytef z_Bytef
|
||||
# define charf z_charf
|
||||
# define intf z_intf
|
||||
# define uIntf z_uIntf
|
||||
# define uLongf z_uLongf
|
||||
# define voidpf z_voidpf
|
||||
# define voidp z_voidp
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __STDC_VERSION__
|
||||
# ifndef STDC
|
||||
# define STDC
|
||||
# endif
|
||||
# if __STDC_VERSION__ >= 199901L
|
||||
# ifndef STDC99
|
||||
# define STDC99
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
|
||||
# define WIN32
|
||||
#endif
|
||||
#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
|
||||
# ifndef __32BIT__
|
||||
# define __32BIT__
|
||||
# endif
|
||||
#endif
|
||||
#if defined(__MSDOS__) && !defined(MSDOS)
|
||||
# define MSDOS
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more
|
||||
* than 64k bytes at a time (needed on systems with 16-bit int).
|
||||
*/
|
||||
#if defined(MSDOS) && !defined(__32BIT__)
|
||||
# define MAXSEG_64K
|
||||
#endif
|
||||
#ifdef MSDOS
|
||||
# define UNALIGNED_OK
|
||||
#endif
|
||||
|
||||
#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC)
|
||||
# define STDC
|
||||
#endif
|
||||
#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
|
||||
# ifndef STDC
|
||||
# define STDC
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined __HOS_AIX__
|
||||
# ifndef STDC
|
||||
# define STDC
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef STDC
|
||||
# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
|
||||
# define const /* note: need a more gentle solution here */
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Some Mac compilers merge all .h files incorrectly: */
|
||||
#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
|
||||
# define NO_DUMMY_DECL
|
||||
#endif
|
||||
|
||||
/* Old Borland C incorrectly complains about missing returns: */
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x460)
|
||||
# define NEED_DUMMY_RETURN
|
||||
#endif
|
||||
#if defined(__TURBOC__) && !defined(__BORLANDC__)
|
||||
# define NEED_DUMMY_RETURN
|
||||
#endif
|
||||
|
||||
|
||||
/* Maximum value for memLevel in deflateInit2 */
|
||||
#ifndef MAX_MEM_LEVEL
|
||||
# ifdef MAXSEG_64K
|
||||
# define MAX_MEM_LEVEL 8
|
||||
# else
|
||||
# define MAX_MEM_LEVEL 9
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Maximum value for windowBits in deflateInit2 and inflateInit2.
|
||||
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
|
||||
* created by gzip. (Files created by minigzip can still be extracted by
|
||||
* gzip.)
|
||||
*/
|
||||
#ifndef MAX_WBITS
|
||||
# define MAX_WBITS 15 /* 32K LZ77 window */
|
||||
#endif
|
||||
|
||||
/* The memory requirements for deflate are (in bytes):
|
||||
(1 << (windowBits+2)) + (1 << (memLevel+9))
|
||||
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
|
||||
plus a few kilobytes for small objects. For example, if you want to reduce
|
||||
the default memory requirements from 256K to 128K, compile with
|
||||
make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
|
||||
Of course this will generally degrade compression (there's no free lunch).
|
||||
|
||||
The memory requirements for inflate are (in bytes) 1 << windowBits
|
||||
that is, 32K for windowBits=15 (default value) plus a few kilobytes
|
||||
for small objects.
|
||||
*/
|
||||
|
||||
/* Type declarations */
|
||||
|
||||
#ifndef OF /* function prototypes */
|
||||
# ifdef STDC
|
||||
# define OF(args) args
|
||||
# else
|
||||
# define OF(args) ()
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Microsoft Visual Studio define _vsnprintf but not vsnprintf
|
||||
*/
|
||||
#if !defined(STDC99) && !(defined(__TURBOC__) && __TURBOC__ >= 0x550) && !defined(VSNPRINTF_DEFINED)
|
||||
# ifdef MSDOS
|
||||
/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
|
||||
but for now we just assume it doesn't. */
|
||||
# define NO_vsnprintf
|
||||
# endif
|
||||
# ifdef WIN32
|
||||
/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
|
||||
# if !defined(vsnprintf) && !defined(__TURBOC__)
|
||||
# define vsnprintf _vsnprintf
|
||||
# endif
|
||||
# endif
|
||||
# ifdef __TURBOC__
|
||||
# define NO_vsnprintf
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* The following definitions for FAR are needed only for MSDOS mixed
|
||||
* model programming (small or medium model with some far allocations).
|
||||
* This was tested only with MSC; for other MSDOS compilers you may have
|
||||
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
|
||||
* just define FAR to be empty.
|
||||
*/
|
||||
#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
|
||||
/* MSC small or medium model */
|
||||
# define SMALL_MEDIUM
|
||||
# ifdef _MSC_VER
|
||||
# define FAR _far
|
||||
# else
|
||||
# define FAR far
|
||||
# endif
|
||||
#endif
|
||||
#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
|
||||
# ifndef __32BIT__
|
||||
# define SMALL_MEDIUM
|
||||
# define FAR _far
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(WIN32) && (!defined(ZLIB_WIN32_NODLL)) && (!defined(ZLIB_DLL))
|
||||
# define ZLIB_DLL
|
||||
#endif
|
||||
|
||||
/* Compile with -DZLIB_DLL for Windows DLL support */
|
||||
#if defined(ZLIB_DLL)
|
||||
# if defined(_WINDOWS) || defined(WINDOWS) || defined(WIN32)
|
||||
# ifndef WINAPIV
|
||||
# ifdef FAR
|
||||
# undef FAR
|
||||
# endif
|
||||
# include <windows.h>
|
||||
# endif
|
||||
# ifdef WIN32
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA WINAPIV
|
||||
# else
|
||||
# define ZEXPORT WINAPI _export
|
||||
# define ZEXPORTVA FAR _cdecl _export
|
||||
# endif
|
||||
# endif
|
||||
# if defined (__BORLANDC__)
|
||||
# if (__BORLANDC__ >= 0x0500) && defined (WIN32)
|
||||
# include <windows.h>
|
||||
# define ZEXPORT __declspec(dllexport) WINAPI
|
||||
# define ZEXPORTVA __declspec(dllexport) WINAPIV
|
||||
# else
|
||||
# if defined (_Windows) && defined (__DLL__)
|
||||
# define ZEXPORT _export
|
||||
# define ZEXPORTVA _export
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined (__BEOS__)
|
||||
# if defined (ZLIB_DLL)
|
||||
# define ZEXTERN extern __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXTERN extern __declspec(dllimport)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef ZEXPORT
|
||||
# define ZEXPORT
|
||||
#endif
|
||||
#ifndef ZEXPORTVA
|
||||
# define ZEXPORTVA
|
||||
#endif
|
||||
#ifndef ZEXTERN
|
||||
# define ZEXTERN extern
|
||||
#endif
|
||||
|
||||
#ifndef FAR
|
||||
# define FAR
|
||||
#endif
|
||||
|
||||
#if !defined(__MACTYPES__)
|
||||
typedef unsigned char Byte; /* 8 bits */
|
||||
#endif
|
||||
typedef unsigned int uInt; /* 16 bits or more */
|
||||
typedef unsigned long uLong; /* 32 bits or more */
|
||||
|
||||
#ifdef SMALL_MEDIUM
|
||||
/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
|
||||
# define Bytef Byte FAR
|
||||
#else
|
||||
typedef Byte FAR Bytef;
|
||||
#endif
|
||||
typedef char FAR charf;
|
||||
typedef int FAR intf;
|
||||
typedef uInt FAR uIntf;
|
||||
typedef uLong FAR uLongf;
|
||||
|
||||
#ifdef STDC
|
||||
typedef void const *voidpc;
|
||||
typedef void FAR *voidpf;
|
||||
typedef void *voidp;
|
||||
#else
|
||||
typedef Byte const *voidpc;
|
||||
typedef Byte FAR *voidpf;
|
||||
typedef Byte *voidp;
|
||||
#endif
|
||||
|
||||
#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */
|
||||
# include <sys/types.h> /* for off_t */
|
||||
# include <unistd.h> /* for SEEK_* and off_t */
|
||||
# ifdef VMS
|
||||
# include <unixio.h> /* for off_t */
|
||||
# endif
|
||||
# define z_off_t off_t
|
||||
#endif
|
||||
#ifndef SEEK_SET
|
||||
# define SEEK_SET 0 /* Seek from beginning of file. */
|
||||
# define SEEK_CUR 1 /* Seek from current position. */
|
||||
# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
|
||||
#endif
|
||||
#ifndef z_off_t
|
||||
# define z_off_t long
|
||||
#endif
|
||||
|
||||
/* MVS linker does not support external names larger than 8 bytes */
|
||||
#if defined(__MVS__)
|
||||
# pragma map(deflateInit_,"DEIN")
|
||||
# pragma map(deflateInit2_,"DEIN2")
|
||||
# pragma map(deflateEnd,"DEEND")
|
||||
# pragma map(deflateBound,"DEBND")
|
||||
# pragma map(inflateInit_,"ININ")
|
||||
# pragma map(inflateInit2_,"ININ2")
|
||||
# pragma map(inflateEnd,"INEND")
|
||||
# pragma map(inflateSync,"INSY")
|
||||
# pragma map(inflateSetDictionary,"INSEDI")
|
||||
# pragma map(compressBound,"CMBND")
|
||||
# pragma map(inflate_table,"INTABL")
|
||||
# pragma map(inflate_fast,"INFA")
|
||||
# pragma map(inflate_copyright,"INCOPY")
|
||||
#endif
|
||||
|
||||
#endif /* _ZCONF_H */
|
File diff suppressed because it is too large
Load Diff
|
@ -1,235 +1,235 @@
|
|||
/* zip.h -- IO for compress .zip files using zlib
|
||||
Version 0.21, March 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Encryption and multi volume ZipFile (span) are not supported.
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
For uncompress .zip file, look at unzip.h
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _zip_H
|
||||
#define _zip_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagzipFile__ { int unused; } zipFile__;
|
||||
typedef zipFile__ *zipFile;
|
||||
#else
|
||||
typedef voidp zipFile;
|
||||
#endif
|
||||
|
||||
#define ZIP_OK (0)
|
||||
#define ZIP_EOF (0)
|
||||
#define ZIP_ERRNO (Z_ERRNO)
|
||||
#define ZIP_PARAMERROR (-102)
|
||||
#define ZIP_BADZIPFILE (-103)
|
||||
#define ZIP_INTERNALERROR (-104)
|
||||
|
||||
#ifndef DEF_MEM_LEVEL
|
||||
# if MAX_MEM_LEVEL >= 8
|
||||
# define DEF_MEM_LEVEL 8
|
||||
# else
|
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||
# endif
|
||||
#endif
|
||||
/* default memLevel */
|
||||
|
||||
/* tm_zip contain date/time info */
|
||||
typedef struct tm_zip_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_zip;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
tm_zip tmz_date; /* date in understandable format */
|
||||
uLong dosDate; /* if dos_date == 0, tmu_date is used */
|
||||
/* uLong flag; */ /* general purpose bit flag 2 bytes */
|
||||
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
} zip_fileinfo;
|
||||
|
||||
typedef const char* zipcharpc;
|
||||
|
||||
|
||||
#define APPEND_STATUS_CREATE (0)
|
||||
#define APPEND_STATUS_CREATEAFTER (1)
|
||||
#define APPEND_STATUS_ADDINZIP (2)
|
||||
|
||||
extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
|
||||
/*
|
||||
Create a zipfile.
|
||||
pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
|
||||
an Unix computer "zlib/zlib113.zip".
|
||||
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
|
||||
will be created at the end of the file.
|
||||
(useful if the file contain a self extractor code)
|
||||
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
|
||||
add files in existing zip (be sure you don't add file that doesn't exist)
|
||||
If the zipfile cannot be opened, the return value is NULL.
|
||||
Else, the return value is a zipFile Handle, usable with other function
|
||||
of this zip package.
|
||||
*/
|
||||
|
||||
/* Note : there is no delete function into a zipfile.
|
||||
If you want delete file into a zipfile, you must open a zipfile, and create another
|
||||
Of couse, you can use RAW reading and writing to copy the file you did not want delte
|
||||
*/
|
||||
|
||||
extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
|
||||
int append,
|
||||
zipcharpc* globalcomment,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level));
|
||||
/*
|
||||
Open a file in the ZIP for writing.
|
||||
filename : the filename in zip (if NULL, '-' without quote will be used
|
||||
*zipfi contain supplemental information
|
||||
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
|
||||
contains the extrafield data the the local header
|
||||
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
|
||||
contains the extrafield data the the local header
|
||||
if comment != NULL, comment contain the comment string
|
||||
method contain the compression method (0 for store, Z_DEFLATED for deflate)
|
||||
level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip, except if raw=1, we write raw file
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw,
|
||||
int windowBits,
|
||||
int memLevel,
|
||||
int strategy,
|
||||
const char* password,
|
||||
uLong crcForCtypting));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip2, except
|
||||
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
|
||||
password : crypting password (NULL for no crypting)
|
||||
crcForCtypting : crc of file to compress (needed for crypting)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
|
||||
const void* buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Write data in the zipfile
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
|
||||
/*
|
||||
Close the current file in the zipfile
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
|
||||
uLong uncompressed_size,
|
||||
uLong crc32));
|
||||
/*
|
||||
Close the current file in the zipfile, for fiel opened with
|
||||
parameter raw=1 in zipOpenNewFileInZip2
|
||||
uncompressed_size and crc32 are value for the uncompressed size
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipClose OF((zipFile file,
|
||||
const char* global_comment));
|
||||
/*
|
||||
Close the zipfile
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _zip_H */
|
||||
/* zip.h -- IO for compress .zip files using zlib
|
||||
Version 0.22, May 19th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Encryption and multi volume ZipFile (span) are not supported.
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
For uncompress .zip file, look at unzip.h
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _zip_H
|
||||
#define _zip_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagzipFile__ { int unused; } zipFile__;
|
||||
typedef zipFile__ *zipFile;
|
||||
#else
|
||||
typedef voidp zipFile;
|
||||
#endif
|
||||
|
||||
#define ZIP_OK (0)
|
||||
#define ZIP_EOF (0)
|
||||
#define ZIP_ERRNO (Z_ERRNO)
|
||||
#define ZIP_PARAMERROR (-102)
|
||||
#define ZIP_BADZIPFILE (-103)
|
||||
#define ZIP_INTERNALERROR (-104)
|
||||
|
||||
#ifndef DEF_MEM_LEVEL
|
||||
# if MAX_MEM_LEVEL >= 8
|
||||
# define DEF_MEM_LEVEL 8
|
||||
# else
|
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||
# endif
|
||||
#endif
|
||||
/* default memLevel */
|
||||
|
||||
/* tm_zip contain date/time info */
|
||||
typedef struct tm_zip_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_zip;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
tm_zip tmz_date; /* date in understandable format */
|
||||
uLong dosDate; /* if dos_date == 0, tmu_date is used */
|
||||
/* uLong flag; */ /* general purpose bit flag 2 bytes */
|
||||
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
} zip_fileinfo;
|
||||
|
||||
typedef const char* zipcharpc;
|
||||
|
||||
|
||||
#define APPEND_STATUS_CREATE (0)
|
||||
#define APPEND_STATUS_CREATEAFTER (1)
|
||||
#define APPEND_STATUS_ADDINZIP (2)
|
||||
|
||||
extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
|
||||
/*
|
||||
Create a zipfile.
|
||||
pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
|
||||
an Unix computer "zlib/zlib113.zip".
|
||||
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
|
||||
will be created at the end of the file.
|
||||
(useful if the file contain a self extractor code)
|
||||
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
|
||||
add files in existing zip (be sure you don't add file that doesn't exist)
|
||||
If the zipfile cannot be opened, the return value is NULL.
|
||||
Else, the return value is a zipFile Handle, usable with other function
|
||||
of this zip package.
|
||||
*/
|
||||
|
||||
/* Note : there is no delete function into a zipfile.
|
||||
If you want delete file into a zipfile, you must open a zipfile, and create another
|
||||
Of couse, you can use RAW reading and writing to copy the file you did not want delte
|
||||
*/
|
||||
|
||||
extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
|
||||
int append,
|
||||
zipcharpc* globalcomment,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level));
|
||||
/*
|
||||
Open a file in the ZIP for writing.
|
||||
filename : the filename in zip (if NULL, '-' without quote will be used
|
||||
*zipfi contain supplemental information
|
||||
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
|
||||
contains the extrafield data the the local header
|
||||
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
|
||||
contains the extrafield data the the local header
|
||||
if comment != NULL, comment contain the comment string
|
||||
method contain the compression method (0 for store, Z_DEFLATED for deflate)
|
||||
level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip, except if raw=1, we write raw file
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw,
|
||||
int windowBits,
|
||||
int memLevel,
|
||||
int strategy,
|
||||
const char* password,
|
||||
uLong crcForCtypting));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip2, except
|
||||
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
|
||||
password : crypting password (NULL for no crypting)
|
||||
crcForCtypting : crc of file to compress (needed for crypting)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
|
||||
const void* buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Write data in the zipfile
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
|
||||
/*
|
||||
Close the current file in the zipfile
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
|
||||
uLong uncompressed_size,
|
||||
uLong crc32));
|
||||
/*
|
||||
Close the current file in the zipfile, for fiel opened with
|
||||
parameter raw=1 in zipOpenNewFileInZip2
|
||||
uncompressed_size and crc32 are value for the uncompressed size
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipClose OF((zipFile file,
|
||||
const char* global_comment));
|
||||
/*
|
||||
Close the zipfile
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _zip_H */
|
||||
|
|
|
@ -14,4 +14,9 @@ open zlibvc.sln with Microsoft Visual C++ 7.0 (Visual Studio .net)
|
|||
|
||||
|
||||
Note : You don't need recompile yourself. There is compiled .LIB in
|
||||
http://www.winimage.com/zLibDll
|
||||
http://www.winimage.com/zLibDll . See this page for more information
|
||||
|
||||
|
||||
|
||||
Gilles Vollant
|
||||
info@winimage.com
|
||||
|
|
|
@ -4,7 +4,7 @@ DESCRIPTION '"""zlib data compression library"""'
|
|||
|
||||
EXETYPE WINDOWS
|
||||
|
||||
VERSION 1.20
|
||||
VERSION 1.21
|
||||
|
||||
CODE PRELOAD MOVEABLE DISCARDABLE
|
||||
DATA PRELOAD MOVEABLE SINGLE
|
||||
|
|
|
@ -3,8 +3,8 @@
|
|||
|
||||
#define IDR_VERSION1 1
|
||||
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
|
||||
FILEVERSION 1,2,0,0
|
||||
PRODUCTVERSION 1,2,0,0
|
||||
FILEVERSION 1,2,1,0
|
||||
PRODUCTVERSION 1,2,1,0
|
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
|
||||
FILEFLAGS 0
|
||||
FILEOS VOS_DOS_WINDOWS16
|
||||
|
@ -18,7 +18,7 @@ BEGIN
|
|||
|
||||
BEGIN
|
||||
VALUE "FileDescription", "zlib data compression library\0"
|
||||
VALUE "FileVersion", "1.2.0\0"
|
||||
VALUE "FileVersion", "1.2.1\0"
|
||||
VALUE "InternalName", "zlib16\0"
|
||||
VALUE "OriginalFilename", "zlib16.dll\0"
|
||||
VALUE "ProductName", "ZLib16.DLL\0"
|
||||
|
|
|
@ -2,8 +2,8 @@
|
|||
|
||||
#define IDR_VERSION1 1
|
||||
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
|
||||
FILEVERSION 1,2,0,0
|
||||
PRODUCTVERSION 1,2,0,0
|
||||
FILEVERSION 1,2,1,0
|
||||
PRODUCTVERSION 1,2,1,0
|
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
|
||||
FILEFLAGS 0
|
||||
FILEOS VOS_DOS_WINDOWS32
|
||||
|
@ -17,7 +17,7 @@ BEGIN
|
|||
|
||||
BEGIN
|
||||
VALUE "FileDescription", "zlib data compression library\0"
|
||||
VALUE "FileVersion", "1.2.0.0\0"
|
||||
VALUE "FileVersion", "1.2.1.0\0"
|
||||
VALUE "InternalName", "zlib\0"
|
||||
VALUE "OriginalFilename", "zlib.dll\0"
|
||||
VALUE "ProductName", "ZLib.DLL\0"
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
LIBRARY "zlib"
|
||||
|
||||
VERSION 1.20
|
||||
VERSION 1.21
|
||||
|
||||
HEAPSIZE 1048576,8192
|
||||
|
||||
|
|
|
@ -0,0 +1,257 @@
|
|||
|
||||
Frequently Asked Questions about ZLIB.DLL
|
||||
|
||||
|
||||
This FAQ is about the design, the rationale, and the use of
|
||||
ZLIB.DLL. If you have general questions about zlib, you should
|
||||
check the file "FAQ" found in the zlib distribution, or at the
|
||||
location http://www.gzip.org/zlib/zlib_faq.html
|
||||
|
||||
|
||||
1. Why am I having problems using ZLIB.DLL? My application works
|
||||
with the static build of zlib just fine, and I didn't make any
|
||||
modification when recompiling it for ZLIB.DLL.
|
||||
|
||||
- Make sure you define ZLIB_DLL before including "zlib.h".
|
||||
Applications that link to ZLIB.DLL will work properly if
|
||||
the source files are compiled in this (or in a compatible)
|
||||
way, and the executables are linked to MSVCRT.DLL.
|
||||
|
||||
|
||||
2. Why do I have to do this? When I use other libraries, I can
|
||||
link my code to their static or dynamic versions, without
|
||||
needing any source code modification or recompilation.
|
||||
|
||||
- In order to preserve the backwards compatibility with the
|
||||
older versions of ZLIB.DLL, and give the ability to use zlib
|
||||
to the non-C programmers at the same time, we had to do this
|
||||
compromise.
|
||||
|
||||
|
||||
3. What exactly is this mess about, and why is it happening?
|
||||
|
||||
- It's about the calling convention used for the zlib functions.
|
||||
If linked in statically, zlib uses the C (CDECL) convention.
|
||||
If linked in dynamically (via ZLIB.DLL), it uses the STDCALL
|
||||
convention. The ZLIB_DLL macro switches on the use of STDCALL.
|
||||
|
||||
It happens because we need to preserve compatibility with the
|
||||
old releases of ZLIB.DLL that use STDCALL, and, at the same
|
||||
time, we must provide support for programmers who use other
|
||||
programming languages with bindings that require CDECL.
|
||||
|
||||
|
||||
4. Why not use the STDCALL convention all the time?
|
||||
It's the standard convention in Win32, and I need it in my
|
||||
Visual Basic project!
|
||||
|
||||
- Most of the Win32 API functions (without varargs) use indeed
|
||||
the STDCALL (WINAPI) convention, but the standard C functions
|
||||
use the default CDECL. If one calls Win32 functions such as
|
||||
CreateFile(), sometimes it makes sense to decorate one's own
|
||||
functions with STDCALL. But if one is aiming at ANSI C or
|
||||
POSIX portability, and calls functions such as fopen(), it is
|
||||
not a sound decision to include <windows.h> or to use non-ANSI
|
||||
constructs only to make one's functions STDCALL-able. This is
|
||||
not the biggest problem, however.
|
||||
|
||||
Technically, STDCALL is not bad; it is even a little faster
|
||||
than CDECL. The problem of using STDCALL is actually a problem
|
||||
of using any explicit calling convention. FASTCALL falls into
|
||||
the same category.
|
||||
|
||||
Explicit specification of calling conventions, whether it's
|
||||
direct or indirect via a macro, happens commonly in Windows,
|
||||
but it is regarded as a noisy, non-standard C quirk on other
|
||||
platforms. It isn't possible to write an ANSI C -conforming
|
||||
program, for example, if it is necessary to specify calling
|
||||
conventions. Libraries can hide the dirty stuff in header
|
||||
files, under macros, but callbacks will still remain exposed.
|
||||
This is why the zlib callbacks will not be decorated.
|
||||
(The old Windows callbacks, such as WndProc, are decorated,
|
||||
but the newer ones are not.)
|
||||
|
||||
There is one more problem with explicit, non-default calling
|
||||
conventions: the ability to use zlib in other programming
|
||||
languages. Some of them, like Ada (GNAT) and Fortran (GNU G77)
|
||||
have C bindings implemented initially on Unix, hence relying
|
||||
on the C calling convention.
|
||||
|
||||
So we are decorating the functions using STDCALL in ZLIB.DLL
|
||||
to maintain compatibility with the old versions, but we are
|
||||
using the default CDECL in the static library, to allow other
|
||||
programming languages to use zlib in a portable fashion, via
|
||||
C bindings.
|
||||
|
||||
|
||||
5. Why not use the default (CDECL) convention all the time?
|
||||
It's the standard convention in C, and I need it in my Ada
|
||||
project!
|
||||
|
||||
- Originally, ZLIB.DLL was intended to run under Visual Basic,
|
||||
and VB6 and earlier need STDCALL.
|
||||
|
||||
We admit that cluttering the main zlib sources, for the sake
|
||||
of interfacing with Visual Basic and at the expense of other
|
||||
programming languages, is not fair. It would have been better
|
||||
to maintain a "VB-only" project in the contrib/ directory, and
|
||||
to build a custom ZLIBVB.DLL, for example -- as we did with
|
||||
the Delphi projects. Another possible solution would have been
|
||||
to build STDCALL wrappers around the CDECL-exported functions.
|
||||
|
||||
But this was the accident that we have to live with, in order
|
||||
to maintain binary compatibility with the older versions of
|
||||
ZLIB.DLL.
|
||||
|
||||
|
||||
6. If my application uses ZLIB.DLL, do I have to link it to
|
||||
MSVCRT.DLL? Why?
|
||||
|
||||
- The executables (.EXE, .DLL, etc.) that are involved in the
|
||||
same process and are using the C run-time library (i.e. they
|
||||
are calling any standard C function), must link to the same
|
||||
library. There are several libraries in the Win32 system:
|
||||
CRTDLL.DLL, MSVCRT.DLL, the static C libraries, etc.
|
||||
Since ZLIB.DLL is linked to MSVCRT.DLL, the executables that
|
||||
depend on it must also link to MSVCRT.DLL.
|
||||
|
||||
|
||||
7. Why are you saying that ZLIB.DLL and my application must be
|
||||
linked to the same C run-time library (CRT)? I linked my
|
||||
application and my DLLs to different C libraries (e.g. my
|
||||
application to a static library, and my DLLs to MSVCRT.DLL),
|
||||
and everything works fine.
|
||||
|
||||
- If a library invokes only pure Win32 API (i.e. accessible
|
||||
via <windows.h>), its DLL build will work in any context.
|
||||
But if a library invokes standard C functions, things get
|
||||
more complicated.
|
||||
|
||||
There is a single Win32 library in a Win32 system. Every
|
||||
function in this library resides in a single DLL module, that
|
||||
is safe to call from anywhere. On the other hand, there are
|
||||
multiple versions of the C library that are all at the same
|
||||
time in the system, and all of them have internal states,
|
||||
therefore it is dangerous to intermix them with each other.
|
||||
|
||||
Intermixing multiple C libraries is possible, as long as their
|
||||
internal states are kept intact. The Microsoft Knowledge Base
|
||||
article Q140584 "HOWTO: Link with the Correct C Run-Time (CRT)
|
||||
Library" enumerates some of the potential problems raised by
|
||||
intermixing, but does not offer a complete description of how
|
||||
to avoid them, except by advising not to mix the C libraries.
|
||||
If you can send us more information about this issue, we will
|
||||
highly appreciate it. (But please do NOT send us source code
|
||||
from Microsoft, even if it comes with your legitimate copy of
|
||||
Visual C++!)
|
||||
|
||||
If this kind of intermixing works for you, it's because your
|
||||
application and DLLs are avoiding the corruption of the CRT's
|
||||
internal states, due to a fortunate accident. It's not because
|
||||
those libraries really work together.
|
||||
|
||||
Also note that linking ZLIB.DLL to non-Microsoft C libraries
|
||||
(such as Borland's) raises similar problems.
|
||||
|
||||
|
||||
8. Why are you linking ZLIB.DLL to MSVCRT.DLL?
|
||||
|
||||
- MSVCRT.DLL exists on every Windows 95 with a new service pack
|
||||
installed, or with Microsoft Internet Explorer 4 or later, and
|
||||
on all other Windows 4.x or later (Windows 98, Windows NT 4,
|
||||
or later). It is freely distributable; if not present in the
|
||||
system, it can be downloaded from Microsoft or from other
|
||||
software provider for free.
|
||||
|
||||
The fact that MSVCRT.DLL does not exist on a virgin Windows 95
|
||||
is not so problematic. The number of Windows 95 installations
|
||||
is rapidly decreasing, Microsoft stopped supporting it a long
|
||||
time ago, and many recent applications from various vendors
|
||||
including Microsoft, do not even run on it. Even without these
|
||||
arguments, no serious user should run Windows 95 without a
|
||||
proper update installed.
|
||||
|
||||
There is also the fact that the mainstream C compilers for
|
||||
Windows are Microsoft Visual C++ 6.0, and gcc/MinGW. Both
|
||||
are producing executables that link to MSVCRT.DLL by default,
|
||||
without offering other dynamic CRTs as alternatives easy to
|
||||
select by users.
|
||||
|
||||
|
||||
9. Why are you not linking ZLIB.DLL to
|
||||
<<my favorite C run-time library>> ?
|
||||
|
||||
- We considered and abandoned the following alternatives:
|
||||
|
||||
* Linking ZLIB.DLL to a static C library (LIBC.LIB, or
|
||||
LIBCMT.LIB) is not a good option. People are using ZLIB.DLL
|
||||
mainly to save disk space. If you are linking your program
|
||||
to a static C library, you may as well consider linking zlib
|
||||
in statically, too.
|
||||
|
||||
* Linking ZLIB.DLL to CRTDLL.DLL looks very appealing,
|
||||
because CRTDLL.DLL is present on every Win32 installation.
|
||||
Unfortunately, it has a series of problems: it raises
|
||||
difficulties when linking to the Microsoft C++ libraries,
|
||||
it is not thread-safe, and Microsoft has discontinued its
|
||||
support a long time ago.
|
||||
|
||||
* Linking ZLIB.DLL to MSVCRT70.DLL, supplied with the
|
||||
Microsoft .NET platform and Visual C++ 7.0, is not a good
|
||||
option. Although it can be downloaded and distributed
|
||||
freely, it is hardly present on today's Win32 installations.
|
||||
If it will become more popular than MSVCRT.DLL, and will be
|
||||
pre-installed on the future Win32 systems, we will probably
|
||||
think again about it.
|
||||
|
||||
* Linking ZLIB.DLL to NTDLL.DLL is not possible.
|
||||
NTDLL.DLL exports only a part of the C library, and only
|
||||
on Windows NT systems.
|
||||
|
||||
|
||||
10. I understand your reasons. However, my project needs ZLIB.DLL
|
||||
linked to something different than MSVCRT.DLL. What can I do?
|
||||
|
||||
Feel free to rebuild this DLL from the zlib sources, and link
|
||||
it the way you want. It is required, however, to clearly
|
||||
state that your build is unofficial. Another thing that is not
|
||||
required, but highly recommended, is to name that custom DLL
|
||||
differently, and/or to install it in a private directory that
|
||||
can be accessed by your application, but is not visible to the
|
||||
others (e.g. it's not the SYSTEM or the SYSTEM32 directory,
|
||||
and it's not in the PATH). Otherwise, your build may clash
|
||||
with applications that link to the official build.
|
||||
|
||||
For example, in Cygwin, zlib is linked to their runtime
|
||||
CYGWIN1.DLL, and it is distributed under the name CYGZ.DLL.
|
||||
|
||||
|
||||
11. My I include additional pieces of code that I find useful,
|
||||
link them in ZLIB.DLL, and export them?
|
||||
|
||||
No. A legitimate build of ZLIB.DLL must not include code that
|
||||
does not originate from the official zlib sources. But you can
|
||||
make your own private build, and give it a different name, as
|
||||
suggested in the previous answer.
|
||||
|
||||
For example, in Borland Delphi and C++ Builder, zlib is part
|
||||
of the standard VCL library. If an application links to VCL
|
||||
dynamically, the name of the distributable binary (VCLxx.DLL)
|
||||
does not posess any danger of clashing with a legitimate but
|
||||
incompatible ZLIB.DLL.
|
||||
|
||||
|
||||
12. I see that I may have all kinds of problems if I use ZLIB.DLL.
|
||||
Do you recommend to link zlib in statically? Do I get rid of
|
||||
problems?
|
||||
|
||||
- Yes, definitely. In fact, unless you are distributing a large
|
||||
number of executables, each of them linking to zlib, you will
|
||||
save space by linking zlib in statically (assuming that you
|
||||
would otherwise distribute ZLIB.DLL with your application).
|
||||
zlib is not a big library, and the space saved by ZLIB.DLL is
|
||||
little. Much of the actual size of the DLL is due to the 4KB
|
||||
alignment in the binary.
|
||||
|
||||
But you may have reasons, other than size, to use the DLL.
|
||||
That is entirely up to you.
|
28
crc32.c
28
crc32.c
|
@ -18,25 +18,29 @@
|
|||
# endif /* !DYNAMIC_CRC_TABLE */
|
||||
#endif /* MAKECRCH */
|
||||
|
||||
#include "zlib.h"
|
||||
#include "zutil.h"
|
||||
|
||||
#define local static
|
||||
|
||||
/* Find a four-byte integer type for crc32_little() and crc32_big(). */
|
||||
#ifndef NOBYFOUR
|
||||
# ifdef __STDC__ /* need ANSI C limits.h to determine sizes */
|
||||
# ifdef STDC /* need ANSI C limits.h to determine sizes */
|
||||
# include <limits.h>
|
||||
# define BYFOUR
|
||||
# if (UINT_MAX == 4294967295)
|
||||
# if (UINT_MAX == 0xffffffffUL)
|
||||
typedef unsigned int u4;
|
||||
# elif (ULONG_MAX == 4294967295)
|
||||
typedef unsigned long u4;
|
||||
# elif (USHRT_MAX == 4294967295)
|
||||
typedef unsigned short u4;
|
||||
# else
|
||||
# undef BYFOUR /* can't find a four-byte integer type! */
|
||||
# if (ULONG_MAX == 0xffffffffUL)
|
||||
typedef unsigned long u4;
|
||||
# else
|
||||
# if (USHRT_MAX == 0xffffffffUL)
|
||||
typedef unsigned short u4;
|
||||
# else
|
||||
# undef BYFOUR /* can't find a four-byte integer type! */
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
# endif /* __STDC__ */
|
||||
# endif /* STDC */
|
||||
#endif /* !NOBYFOUR */
|
||||
|
||||
/* Definitions for doing the crc four data bytes at a time. */
|
||||
|
@ -95,7 +99,7 @@ local void make_crc_table()
|
|||
/* terms of polynomial defining this crc (except x^32): */
|
||||
static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
|
||||
|
||||
/* make exclusive-or pattern from polynomial (0xedb88320L) */
|
||||
/* make exclusive-or pattern from polynomial (0xedb88320UL) */
|
||||
poly = 0UL;
|
||||
for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
|
||||
poly |= 1UL << (31 - p[n]);
|
||||
|
@ -240,7 +244,7 @@ local unsigned long crc32_little(crc, buf, len)
|
|||
|
||||
c = (u4)crc;
|
||||
c = ~c;
|
||||
while (len && ((int)buf & 3)) {
|
||||
while (len && ((size_t)buf & 3)) {
|
||||
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
|
||||
len--;
|
||||
}
|
||||
|
@ -280,7 +284,7 @@ local unsigned long crc32_big(crc, buf, len)
|
|||
|
||||
c = REV((u4)crc);
|
||||
c = ~c;
|
||||
while (len && ((int)buf & 3)) {
|
||||
while (len && ((size_t)buf & 3)) {
|
||||
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
|
||||
len--;
|
||||
}
|
||||
|
|
52
deflate.c
52
deflate.c
|
@ -37,7 +37,7 @@
|
|||
* REFERENCES
|
||||
*
|
||||
* Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
|
||||
* Available in ftp://ds.internic.net/rfc/rfc1951.txt
|
||||
* Available in http://www.ietf.org/rfc/rfc1951.txt
|
||||
*
|
||||
* A description of the Rabin and Karp algorithm is given in the book
|
||||
* "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
|
||||
|
@ -52,7 +52,7 @@
|
|||
#include "deflate.h"
|
||||
|
||||
const char deflate_copyright[] =
|
||||
" deflate 1.2.0.1 Copyright 1995-2003 Jean-loup Gailly ";
|
||||
" deflate 1.2.0.2 Copyright 1995-2003 Jean-loup Gailly ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
|
@ -157,7 +157,9 @@ local const config configuration_table[10] = {
|
|||
#define EQUAL 0
|
||||
/* result of memcmp for equal strings */
|
||||
|
||||
#ifndef NO_DUMMY_DECL
|
||||
struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
|
||||
#endif
|
||||
|
||||
/* ===========================================================================
|
||||
* Update a hash value with the given input byte
|
||||
|
@ -255,10 +257,11 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
|
|||
windowBits = -windowBits;
|
||||
}
|
||||
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
|
||||
windowBits < 9 || windowBits > 15 || level < 0 || level > 9 ||
|
||||
windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
|
||||
strategy < 0 || strategy > Z_RLE) {
|
||||
return Z_STREAM_ERROR;
|
||||
}
|
||||
if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
|
||||
s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
|
||||
if (s == Z_NULL) return Z_MEM_ERROR;
|
||||
strm->state = (struct internal_state FAR *)s;
|
||||
|
@ -520,9 +523,16 @@ int ZEXPORT deflate (strm, flush)
|
|||
if (s->status == INIT_STATE) {
|
||||
|
||||
uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
|
||||
uInt level_flags = (s->level-1) >> 1;
|
||||
uInt level_flags;
|
||||
|
||||
if (level_flags > 3) level_flags = 3;
|
||||
if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
|
||||
level_flags = 0;
|
||||
else if (s->level < 6)
|
||||
level_flags = 1;
|
||||
else if (s->level == 6)
|
||||
level_flags = 2;
|
||||
else
|
||||
level_flags = 3;
|
||||
header |= (level_flags << 6);
|
||||
if (s->strstart != 0) header |= PRESET_DICT;
|
||||
header += 31 - (header % 31);
|
||||
|
@ -975,7 +985,7 @@ local uInt longest_match_fast(s, cur_match)
|
|||
if (len < MIN_MATCH) return MIN_MATCH - 1;
|
||||
|
||||
s->match_start = cur_match;
|
||||
return len <= s->lookahead ? len : s->lookahead;
|
||||
return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
|
@ -1028,19 +1038,22 @@ local void fill_window(s)
|
|||
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
|
||||
|
||||
/* Deal with !@#$% 64K limit: */
|
||||
if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
|
||||
more = wsize;
|
||||
|
||||
} else if (more == (unsigned)(-1)) {
|
||||
/* Very unlikely, but possible on 16 bit machine if strstart == 0
|
||||
* and lookahead == 1 (input done one byte at time)
|
||||
*/
|
||||
more--;
|
||||
if (sizeof(int) <= 2) {
|
||||
if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
|
||||
more = wsize;
|
||||
|
||||
} else if (more == (unsigned)(-1)) {
|
||||
/* Very unlikely, but possible on 16 bit machine if
|
||||
* strstart == 0 && lookahead == 1 (input done one byte at time)
|
||||
*/
|
||||
more--;
|
||||
}
|
||||
}
|
||||
|
||||
/* If the window is almost full and there is insufficient lookahead,
|
||||
* move the upper half to the lower one to make room in the upper half.
|
||||
*/
|
||||
} else if (s->strstart >= wsize+MAX_DIST(s)) {
|
||||
if (s->strstart >= wsize+MAX_DIST(s)) {
|
||||
|
||||
zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
|
||||
s->match_start -= wsize;
|
||||
|
@ -1347,9 +1360,12 @@ local block_state deflate_slow(s, flush)
|
|||
}
|
||||
/* longest_match() or longest_match_fast() sets match_start */
|
||||
|
||||
if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
|
||||
(s->match_length == MIN_MATCH &&
|
||||
s->strstart - s->match_start > TOO_FAR))) {
|
||||
if (s->match_length <= 5 && (s->strategy == Z_FILTERED
|
||||
#if TOO_FAR < 32768
|
||||
|| (s->match_length == MIN_MATCH &&
|
||||
s->strstart - s->match_start > TOO_FAR)
|
||||
#endif
|
||||
)) {
|
||||
|
||||
/* If prev_match is also MIN_MATCH, match_start is garbage
|
||||
* but we will ignore the current match anyway.
|
||||
|
|
|
@ -10,8 +10,8 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#ifndef _DEFLATE_H
|
||||
#define _DEFLATE_H
|
||||
#ifndef DEFLATE_H
|
||||
#define DEFLATE_H
|
||||
|
||||
#include "zutil.h"
|
||||
|
||||
|
@ -315,4 +315,4 @@ void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
|
|||
flush = _tr_tally(s, distance, length)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* DEFLATE_H */
|
||||
|
|
12
example.c
12
example.c
|
@ -142,13 +142,18 @@ void test_gzio(out, in, uncompr, uncomprLen)
|
|||
exit(1);
|
||||
}
|
||||
|
||||
if (gzungetc(' ', file) != ' ') {
|
||||
fprintf(stderr, "gzungetc error\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
gzgets(file, (char*)uncompr, uncomprLen);
|
||||
uncomprLen = strlen((char*)uncompr);
|
||||
if (uncomprLen != 6) { /* "hello!" */
|
||||
if (uncomprLen != 7) { /* " hello!" */
|
||||
fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
|
||||
exit(1);
|
||||
}
|
||||
if (strcmp((char*)uncompr, hello+7)) {
|
||||
if (strcmp((char*)uncompr, hello+6)) {
|
||||
fprintf(stderr, "bad gzgets after gzseek\n");
|
||||
exit(1);
|
||||
} else {
|
||||
|
@ -523,6 +528,9 @@ int main(argc, argv)
|
|||
fprintf(stderr, "warning: different zlib version\n");
|
||||
}
|
||||
|
||||
printf("zlib version %s = 0x%04x, compile flags = 0x%x\n",
|
||||
ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
|
||||
|
||||
compr = (Byte*)calloc((uInt)comprLen, 1);
|
||||
uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
|
||||
/* compr and uncompr are cleared to avoid reading uninitialized
|
||||
|
|
90
gzio.c
90
gzio.c
|
@ -11,7 +11,9 @@
|
|||
|
||||
#include "zutil.h"
|
||||
|
||||
#ifndef NO_DUMMY_DECL
|
||||
struct internal_state {int dummy;}; /* for buggy compilers */
|
||||
#endif
|
||||
|
||||
#ifndef Z_BUFSIZE
|
||||
# ifdef MAXSEG_64K
|
||||
|
@ -55,6 +57,8 @@ typedef struct gz_stream {
|
|||
int transparent; /* 1 if input file is not a .gz file */
|
||||
char mode; /* 'w' or 'r' */
|
||||
long startpos; /* start of compressed data in file (header skipped) */
|
||||
int back; /* one character push-back */
|
||||
int last; /* true if push-back is last character */
|
||||
} gz_stream;
|
||||
|
||||
|
||||
|
@ -102,6 +106,7 @@ local gzFile gz_open (path, mode, fd)
|
|||
s->file = NULL;
|
||||
s->z_err = Z_OK;
|
||||
s->z_eof = 0;
|
||||
s->back = EOF;
|
||||
s->crc = crc32(0L, Z_NULL, 0);
|
||||
s->msg = NULL;
|
||||
s->transparent = 0;
|
||||
|
@ -391,6 +396,18 @@ int ZEXPORT gzread (file, buf, len)
|
|||
s->stream.next_out = (Bytef*)buf;
|
||||
s->stream.avail_out = len;
|
||||
|
||||
if (s->stream.avail_out && s->back != EOF) {
|
||||
*next_out++ = s->back;
|
||||
s->stream.next_out++;
|
||||
s->stream.avail_out--;
|
||||
s->back = EOF;
|
||||
s->stream.total_out++;
|
||||
if (s->last) {
|
||||
s->z_err = Z_STREAM_END;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
while (s->stream.avail_out != 0) {
|
||||
|
||||
if (s->transparent) {
|
||||
|
@ -476,6 +493,24 @@ int ZEXPORT gzgetc(file)
|
|||
}
|
||||
|
||||
|
||||
/* ===========================================================================
|
||||
Push one byte back onto the stream.
|
||||
*/
|
||||
int ZEXPORT gzungetc(c, file)
|
||||
int c;
|
||||
gzFile file;
|
||||
{
|
||||
gz_stream *s = (gz_stream*)file;
|
||||
|
||||
if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
|
||||
s->back = c;
|
||||
s->stream.total_out--;
|
||||
s->last = (s->z_err == Z_STREAM_END);
|
||||
if (s->z_eof) s->z_eof = 0;
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/* ===========================================================================
|
||||
Reads bytes from the compressed file until len-1 characters are
|
||||
read, or a newline character is read and transferred to buf, or an
|
||||
|
@ -535,6 +570,7 @@ int ZEXPORT gzwrite (file, buf, len)
|
|||
return (int)(len - s->stream.avail_in);
|
||||
}
|
||||
|
||||
|
||||
/* ===========================================================================
|
||||
Converts, formats, and writes the args to the compressed file under
|
||||
control of the format string, as in fprintf. gzprintf returns the number of
|
||||
|
@ -549,34 +585,30 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
|
|||
va_list va;
|
||||
int len;
|
||||
|
||||
buf[sizeof(buf) - 1] = 0;
|
||||
va_start(va, format);
|
||||
#ifdef NO_vsnprintf
|
||||
# ifdef HAS_vsprintf_void
|
||||
(void)vsprintf(buf, format, va);
|
||||
va_end(va);
|
||||
len = strlen(buf); /* some *sprintf don't return the nb of bytes written */
|
||||
if (len <= 0) return 0;
|
||||
for (len = 0; len < sizeof(buf); len++)
|
||||
if (buf[len] == 0) break;
|
||||
# else
|
||||
len = vsprintf(buf, format, va);
|
||||
va_end(va);
|
||||
if (len <= 0 || len >= sizeof(buf))
|
||||
return 0;
|
||||
# endif
|
||||
#else
|
||||
# ifdef HAS_vsnprintf_void
|
||||
(void)vsnprintf(buf, sizeof(buf), format, va);
|
||||
va_end(va);
|
||||
len = strlen(buf);
|
||||
if (len <= 0)
|
||||
return 0;
|
||||
# else
|
||||
len = vsnprintf(buf, sizeof(buf), format, va);
|
||||
va_end(va);
|
||||
if (len <= 0 || len >= sizeof(buf))
|
||||
return 0;
|
||||
# endif
|
||||
#endif
|
||||
|
||||
if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
|
||||
return 0;
|
||||
return gzwrite(file, buf, (unsigned)len);
|
||||
}
|
||||
#else /* not ANSI C */
|
||||
|
@ -591,33 +623,29 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
|
|||
char buf[Z_PRINTF_BUFSIZE];
|
||||
int len;
|
||||
|
||||
buf[sizeof(buf) - 1] = 0;
|
||||
#ifdef NO_snprintf
|
||||
# ifdef HAS_sprintf_void
|
||||
sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
|
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||
len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
|
||||
if (len <= 0) return 0;
|
||||
for (len = 0; len < sizeof(buf); len++)
|
||||
if (buf[len] == 0) break;
|
||||
# else
|
||||
len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
|
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||
if (len <= 0 || len >= sizeof(buf))
|
||||
return 0;
|
||||
# endif
|
||||
#else
|
||||
# ifdef HAS_snprintf_void
|
||||
snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
|
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||
len = strlen(buf);
|
||||
if (len <= 0)
|
||||
return 0;
|
||||
# else
|
||||
len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
|
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||
if (len <= 0 || len >= sizeof(buf))
|
||||
return 0;
|
||||
# endif
|
||||
#endif
|
||||
|
||||
if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
|
||||
return 0;
|
||||
return gzwrite(file, buf, len);
|
||||
}
|
||||
#endif
|
||||
|
@ -762,6 +790,7 @@ z_off_t ZEXPORT gzseek (file, offset, whence)
|
|||
|
||||
if (s->transparent) {
|
||||
/* map to fseek */
|
||||
s->back = EOF;
|
||||
s->stream.avail_in = 0;
|
||||
s->stream.next_in = s->inbuf;
|
||||
if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
|
||||
|
@ -782,6 +811,12 @@ z_off_t ZEXPORT gzseek (file, offset, whence)
|
|||
s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
|
||||
if (s->outbuf == Z_NULL) return -1L;
|
||||
}
|
||||
if (offset && s->back != EOF) {
|
||||
s->back == EOF;
|
||||
s->stream.total_out++;
|
||||
offset--;
|
||||
if (s->last) s->z_err = Z_STREAM_END;
|
||||
}
|
||||
while (offset > 0) {
|
||||
int size = Z_BUFSIZE;
|
||||
if (offset < Z_BUFSIZE) size = (int)offset;
|
||||
|
@ -805,12 +840,13 @@ int ZEXPORT gzrewind (file)
|
|||
|
||||
s->z_err = Z_OK;
|
||||
s->z_eof = 0;
|
||||
s->back = EOF;
|
||||
s->stream.avail_in = 0;
|
||||
s->stream.next_in = s->inbuf;
|
||||
s->crc = crc32(0L, Z_NULL, 0);
|
||||
|
||||
if (s->startpos == 0) { /* not a compressed file */
|
||||
rewind(s->file);
|
||||
fseek(s->file, 0L, SEEK_SET); /* rewind() is not always available */
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -906,7 +942,7 @@ int ZEXPORT gzclose (file)
|
|||
errnum is set to Z_ERRNO and the application may consult errno
|
||||
to get the exact error code.
|
||||
*/
|
||||
const char* ZEXPORT gzerror (file, errnum)
|
||||
const char * ZEXPORT gzerror (file, errnum)
|
||||
gzFile file;
|
||||
int *errnum;
|
||||
{
|
||||
|
@ -932,3 +968,17 @@ const char* ZEXPORT gzerror (file, errnum)
|
|||
strcat(s->msg, m);
|
||||
return (const char*)s->msg;
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
Clear the error and end-of-file flags, and do the same for the real file.
|
||||
*/
|
||||
void ZEXPORT gzclearerr (file)
|
||||
gzFile file;
|
||||
{
|
||||
gz_stream *s = (gz_stream*)file;
|
||||
|
||||
if (s == NULL) return;
|
||||
if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
|
||||
s->z_eof = 0;
|
||||
clearerr(s->file);
|
||||
}
|
||||
|
|
12
infback.c
12
infback.c
|
@ -151,7 +151,7 @@ struct inflate_state FAR *state;
|
|||
if (have == 0) { \
|
||||
next = Z_NULL; \
|
||||
ret = Z_BUF_ERROR; \
|
||||
goto leave; \
|
||||
goto inf_leave; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
@ -203,7 +203,7 @@ struct inflate_state FAR *state;
|
|||
left = state->wsize; \
|
||||
if (out(out_desc, put, left)) { \
|
||||
ret = Z_BUF_ERROR; \
|
||||
goto leave; \
|
||||
goto inf_leave; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
@ -582,19 +582,19 @@ void FAR *out_desc;
|
|||
if (out(out_desc, state->window, state->wsize - left))
|
||||
ret = Z_BUF_ERROR;
|
||||
}
|
||||
goto leave;
|
||||
goto inf_leave;
|
||||
|
||||
case BAD:
|
||||
ret = Z_DATA_ERROR;
|
||||
goto leave;
|
||||
goto inf_leave;
|
||||
|
||||
default: /* can't happen, but makes compilers happy */
|
||||
ret = Z_STREAM_ERROR;
|
||||
goto leave;
|
||||
goto inf_leave;
|
||||
}
|
||||
|
||||
/* Return unused input */
|
||||
leave:
|
||||
inf_leave:
|
||||
strm->next_in = next;
|
||||
strm->avail_in = have;
|
||||
return ret;
|
||||
|
|
61
inflate.c
61
inflate.c
|
@ -77,7 +77,7 @@
|
|||
* and buffer address return values for the input function
|
||||
* - Check next_in and next_out for Z_NULL on entry to inflate()
|
||||
*
|
||||
* The history for versions past 1.2.0 are in ChangeLog in zlib distribution.
|
||||
* The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
|
@ -147,8 +147,12 @@ int stream_size;
|
|||
state->wrap = 0;
|
||||
windowBits = -windowBits;
|
||||
}
|
||||
else
|
||||
state->wrap = 1;
|
||||
else {
|
||||
state->wrap = (windowBits >> 4) + 1;
|
||||
#ifdef GUNZIP
|
||||
windowBits &= 15;
|
||||
#endif
|
||||
}
|
||||
if (windowBits < 8 || windowBits > 15) {
|
||||
ZFREE(strm, state);
|
||||
strm->state = Z_NULL;
|
||||
|
@ -403,7 +407,7 @@ unsigned out;
|
|||
if there is no input available. */
|
||||
#define PULLBYTE() \
|
||||
do { \
|
||||
if (have == 0) goto leave; \
|
||||
if (have == 0) goto inf_leave; \
|
||||
have--; \
|
||||
hold += (unsigned long)(*next++) << bits; \
|
||||
bits += 8; \
|
||||
|
@ -502,14 +506,14 @@ unsigned out;
|
|||
complete that state. Those states are copying stored data, writing a
|
||||
literal byte, and copying a matching string.
|
||||
|
||||
When returning, a "goto leave" is used to update the total counters, update
|
||||
the check value, and determine whether any progress has been made during
|
||||
that inflate() call in order to return the proper return code. Progress is
|
||||
defined as a change in either strm->avail_in or strm->avail_out. When there
|
||||
is a window, goto leave will update the window with the last output written.
|
||||
If a goto leave occurs in the middle of decompression and there is no window
|
||||
currently, goto leave will create one and copy output to the window for the
|
||||
next call of inflate().
|
||||
When returning, a "goto inf_leave" is used to update the total counters,
|
||||
update the check value, and determine whether any progress has been made
|
||||
during that inflate() call in order to return the proper return code.
|
||||
Progress is defined as a change in either strm->avail_in or strm->avail_out.
|
||||
When there is a window, goto inf_leave will update the window with the last
|
||||
output written. If a goto inf_leave occurs in the middle of decompression
|
||||
and there is no window currently, goto inf_leave will create one and copy
|
||||
output to the window for the next call of inflate().
|
||||
|
||||
In this implementation, the flush parameter of inflate() only affects the
|
||||
return code (per zlib.h). inflate() always writes as much as possible to
|
||||
|
@ -562,16 +566,19 @@ int flush;
|
|||
}
|
||||
NEEDBITS(16);
|
||||
#ifdef GUNZIP
|
||||
if (hold == 0x8b1f) { /* gzip header */
|
||||
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
|
||||
state->check = crc32(0L, Z_NULL, 0);
|
||||
CRC2(state->check, hold);
|
||||
INITBITS();
|
||||
state->mode = FLAGS;
|
||||
break;
|
||||
}
|
||||
state->flags = 0; /* expect zlib header */
|
||||
state->flags = 0; /* expect zlib header */
|
||||
if (!(state->wrap & 1) || /* check if zlib header allowed */
|
||||
#else
|
||||
if (
|
||||
#endif
|
||||
if (((BITS(8) << 8) + (hold >> 8)) % 31) {
|
||||
((BITS(8) << 8) + (hold >> 8)) % 31) {
|
||||
strm->msg = (char *)"incorrect header check";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
|
@ -638,12 +645,12 @@ int flush;
|
|||
next += copy;
|
||||
state->length -= copy;
|
||||
}
|
||||
if (state->length) goto leave;
|
||||
if (state->length) goto inf_leave;
|
||||
}
|
||||
state->mode = NAME;
|
||||
case NAME:
|
||||
if (state->flags & 0x0800) {
|
||||
if (have == 0) goto leave;
|
||||
if (have == 0) goto inf_leave;
|
||||
copy = 0;
|
||||
do {
|
||||
len = (unsigned)(next[copy++]);
|
||||
|
@ -652,12 +659,12 @@ int flush;
|
|||
state->check = crc32(state->check, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
if (len) goto leave;
|
||||
if (len) goto inf_leave;
|
||||
}
|
||||
state->mode = COMMENT;
|
||||
case COMMENT:
|
||||
if (state->flags & 0x1000) {
|
||||
if (have == 0) goto leave;
|
||||
if (have == 0) goto inf_leave;
|
||||
copy = 0;
|
||||
do {
|
||||
len = (unsigned)(next[copy++]);
|
||||
|
@ -666,7 +673,7 @@ int flush;
|
|||
state->check = crc32(state->check, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
if (len) goto leave;
|
||||
if (len) goto inf_leave;
|
||||
}
|
||||
state->mode = HCRC;
|
||||
case HCRC:
|
||||
|
@ -745,7 +752,7 @@ int flush;
|
|||
if (copy) {
|
||||
if (copy > have) copy = have;
|
||||
if (copy > left) copy = left;
|
||||
if (copy == 0) goto leave;
|
||||
if (copy == 0) goto inf_leave;
|
||||
zmemcpy(put, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
|
@ -958,7 +965,7 @@ int flush;
|
|||
Tracevv((stderr, "inflate: distance %u\n", state->offset));
|
||||
state->mode = MATCH;
|
||||
case MATCH:
|
||||
if (left == 0) goto leave;
|
||||
if (left == 0) goto inf_leave;
|
||||
copy = out - left;
|
||||
if (state->offset > copy) { /* copy from window */
|
||||
copy = state->offset - copy;
|
||||
|
@ -983,7 +990,7 @@ int flush;
|
|||
if (state->length == 0) state->mode = LEN;
|
||||
break;
|
||||
case LIT:
|
||||
if (left == 0) goto leave;
|
||||
if (left == 0) goto inf_leave;
|
||||
*put++ = (unsigned char)(state->length);
|
||||
left--;
|
||||
state->mode = LEN;
|
||||
|
@ -1015,7 +1022,7 @@ int flush;
|
|||
case LENGTH:
|
||||
if (state->wrap && state->flags) {
|
||||
NEEDBITS(32);
|
||||
if (hold != (state->total & 0xffffffff)) {
|
||||
if (hold != (state->total & 0xffffffffUL)) {
|
||||
strm->msg = (char *)"incorrect length check";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
|
@ -1027,10 +1034,10 @@ int flush;
|
|||
state->mode = DONE;
|
||||
case DONE:
|
||||
ret = Z_STREAM_END;
|
||||
goto leave;
|
||||
goto inf_leave;
|
||||
case BAD:
|
||||
ret = Z_DATA_ERROR;
|
||||
goto leave;
|
||||
goto inf_leave;
|
||||
case MEM:
|
||||
return Z_MEM_ERROR;
|
||||
case SYNC:
|
||||
|
@ -1044,7 +1051,7 @@ int flush;
|
|||
error. Call updatewindow() to create and/or update the window state.
|
||||
Note: a memory error from inflate() is non-recoverable.
|
||||
*/
|
||||
leave:
|
||||
inf_leave:
|
||||
RESTORE();
|
||||
if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
|
||||
if (updatewindow(strm, out)) {
|
||||
|
|
|
@ -80,7 +80,7 @@ typedef enum {
|
|||
struct inflate_state {
|
||||
inflate_mode mode; /* current inflate mode */
|
||||
int last; /* true if processing last block */
|
||||
int wrap; /* true to process header and trailer */
|
||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
||||
int havedict; /* true if dictionary provided */
|
||||
int flags; /* gzip header method and flags (0 if zlib) */
|
||||
unsigned long check; /* protected copy of check value */
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
#define MAXBITS 15
|
||||
|
||||
const char inflate_copyright[] =
|
||||
" inflate 1.2.0.1 Copyright 1995-2003 Mark Adler ";
|
||||
" inflate 1.2.0.2 Copyright 1995-2003 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
|
@ -62,7 +62,7 @@ unsigned short FAR *work;
|
|||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 205, 64};
|
||||
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 67, 201};
|
||||
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
|
|
|
@ -113,7 +113,7 @@ void gz_compress(in, out)
|
|||
if (gz_compress_mmap(in, out) == Z_OK) return;
|
||||
#endif
|
||||
for (;;) {
|
||||
len = fread(buf, 1, sizeof(buf), in);
|
||||
len = (int)fread(buf, 1, sizeof(buf), in);
|
||||
if (ferror(in)) {
|
||||
perror("fread");
|
||||
exit(1);
|
||||
|
@ -230,7 +230,7 @@ void file_uncompress(file)
|
|||
char *infile, *outfile;
|
||||
FILE *out;
|
||||
gzFile in;
|
||||
int len = strlen(file);
|
||||
int len = (int)strlen(file);
|
||||
|
||||
strcpy(buf, file);
|
||||
|
||||
|
|
107
old/zlib.3
107
old/zlib.3
|
@ -1,107 +0,0 @@
|
|||
.TH ZLIB 3 "11 March 2002"
|
||||
.SH NAME
|
||||
zlib \- compression/decompression library
|
||||
.SH SYNOPSIS
|
||||
[see
|
||||
.I zlib.h
|
||||
for full description]
|
||||
.SH DESCRIPTION
|
||||
The
|
||||
.I zlib
|
||||
library is a general purpose data compression library.
|
||||
The code is thread safe.
|
||||
It provides in-memory compression and decompression functions,
|
||||
including integrity checks of the uncompressed data.
|
||||
This version of the library supports only one compression method (deflation)
|
||||
but other algorithms will be added later and will have the same stream interface.
|
||||
.LP
|
||||
Compression can be done in a single step if the buffers are large enough
|
||||
(for example if an input file is mmap'ed),
|
||||
or can be done by repeated calls of the compression function.
|
||||
In the latter case,
|
||||
the application must provide more input and/or consume the output
|
||||
(providing more output space) before each call.
|
||||
.LP
|
||||
The library also supports reading and writing files in
|
||||
.I gzip
|
||||
(.gz) format
|
||||
with an interface similar to that of stdio.
|
||||
.LP
|
||||
The library does not install any signal handler. The decoder checks
|
||||
the consistency of the compressed data, so the library should never
|
||||
crash even in case of corrupted input.
|
||||
.LP
|
||||
All functions of the compression library are documented in the file
|
||||
.IR zlib.h.
|
||||
The distribution source includes examples of use of the library
|
||||
the files
|
||||
.I example.c
|
||||
and
|
||||
.IR minigzip.c .
|
||||
.LP
|
||||
A Java implementation of
|
||||
.IR zlib
|
||||
is available in the Java Development Kit 1.1
|
||||
.IP
|
||||
http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html
|
||||
.LP
|
||||
A Perl interface to
|
||||
.IR zlib ,
|
||||
written by Paul Marquess (pmarquess@bfsec.bt.co.uk)
|
||||
is available at CPAN (Comprehensive Perl Archive Network) sites,
|
||||
such as:
|
||||
.IP
|
||||
ftp://ftp.cis.ufl.edu/pub/perl/CPAN/modules/by-module/Compress/Compress-Zlib*
|
||||
.LP
|
||||
A Python interface to
|
||||
.IR zlib
|
||||
written by A.M. Kuchling <amk@magnet.com>
|
||||
is available from the Python Software Association sites, such as:
|
||||
.IP
|
||||
ftp://ftp.python.org/pub/python/contrib/Encoding/zlib*.tar.gz
|
||||
.SH "SEE ALSO"
|
||||
Questions about zlib should be sent to:
|
||||
.IP
|
||||
zlib@quest.jpl.nasa.gov
|
||||
or, if this fails, to the author addresses given below.
|
||||
The zlib home page is:
|
||||
.IP
|
||||
http://www.cdrom.com/pub/infozip/zlib/
|
||||
.LP
|
||||
The data format used by the zlib library is described by RFC
|
||||
(Request for Comments) 1950 to 1952 in the files:
|
||||
.IP
|
||||
ftp://ds.internic.net/rfc/rfc1950.txt (zlib format)
|
||||
.br
|
||||
rfc1951.txt (deflate format)
|
||||
.br
|
||||
rfc1952.txt (gzip format)
|
||||
.LP
|
||||
These documents are also available in other formats from:
|
||||
.IP
|
||||
ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
|
||||
.SH AUTHORS
|
||||
Version 1.1.4
|
||||
Copyright (C) 1995-2002 Jean-loup Gailly (jloup@gzip.org)
|
||||
and Mark Adler (madler@alumni.caltech.edu).
|
||||
.LP
|
||||
This software is provided "as-is,"
|
||||
without any express or implied warranty.
|
||||
In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
See the distribution directory with respect to requirements
|
||||
governing redistribution.
|
||||
The deflate format used by
|
||||
.I zlib
|
||||
was defined by Phil Katz.
|
||||
The deflate and
|
||||
.I zlib
|
||||
specifications were written by L. Peter Deutsch.
|
||||
Thanks to all the people who reported problems and suggested various
|
||||
improvements in
|
||||
.IR zlib ;
|
||||
who are too numerous to cite here.
|
||||
.LP
|
||||
UNIX manual page by R. P. C. Rodgers,
|
||||
U.S. National Library of Medicine (rodgers@nlm.nih.gov).
|
||||
.\" end of man page
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#define ZLIB_INTERNAL
|
||||
#include "zlib.h"
|
||||
|
||||
/* ===========================================================================
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
#
|
||||
|
||||
LIB = libz.a
|
||||
SHAREDLIB = libz.so
|
||||
SHAREDLIB = zlib.dll
|
||||
VER = 1.2.0
|
||||
|
||||
CC = gcc
|
||||
|
@ -32,6 +32,8 @@ LDFLAGS = $(LOC) -s
|
|||
AR = ar
|
||||
ARFLAGS = rcs
|
||||
|
||||
RC = windres
|
||||
|
||||
CP = cp -fp
|
||||
# If GNU install is available, replace $(CP) with install.
|
||||
INSTALL = $(CP)
|
||||
|
@ -43,12 +45,14 @@ exec_prefix = $(prefix)
|
|||
OBJS = adler32.o compress.o crc32.o deflate.o gzio.o infback.o \
|
||||
inffast.o inflate.o inftrees.o trees.o uncompr.o zutil.o
|
||||
|
||||
DLLDEF = win32/zlibgcc.def
|
||||
|
||||
# to use the asm code: make OBJA=match.o
|
||||
OBJA =
|
||||
|
||||
TEST_OBJS = example.o minigzip.o
|
||||
|
||||
all: $(LIB) example minigzip
|
||||
all: $(LIB) $(SHAREDLIB) example minigzip
|
||||
|
||||
test: all
|
||||
./example
|
||||
|
@ -60,12 +64,18 @@ test: all
|
|||
libz.a: $(OBJS)
|
||||
$(AR) $(ARFLAGS) $@ $(OBJS)
|
||||
|
||||
$(SHAREDLIB): $(OBJS) $(DLLDEF) zlibrc.o
|
||||
dllwrap --driver-name $(CC) --def $(DLLDEF) -o $@ $(OBJS) zlibrc.o
|
||||
|
||||
example: example.o $(LIB)
|
||||
$(LD) -o $@ $< $(LIB)
|
||||
|
||||
minigzip: minigzip.o $(LIB)
|
||||
$(LD) -o $@ $< $(LIB)
|
||||
|
||||
zlibrc.o: win32/zlib.rc
|
||||
-$(RC) -o $@ --define GCC_WINDRES win32/zlib.rc
|
||||
|
||||
|
||||
# INCLUDE_PATH and LIBRARY_PATH were set for [make] in djgpp.env .
|
||||
|
||||
|
@ -87,6 +97,7 @@ clean:
|
|||
$(RM) *.o
|
||||
$(RM) *.exe
|
||||
$(RM) libz.a
|
||||
$(RM) zlib.dll
|
||||
$(RM) foo.gz
|
||||
|
||||
adler32.o: zlib.h zconf.h
|
||||
|
|
|
@ -1,10 +1,13 @@
|
|||
# Makefile for (static) zlib -- Microsoft (Visual) C.
|
||||
# Author: Cosmin Truta, 11-Mar-2003.
|
||||
# Makefile for Win32 zlib.dll and the static library zlibstat.lib
|
||||
# -- Microsoft (Visual) C.
|
||||
# Author: Cosmin Truta, 11-Mar-2003
|
||||
# Christian Spieler, 19-Mar-2003
|
||||
#
|
||||
# Usage: nmake -f win32/Makefile.msc
|
||||
|
||||
CC = cl
|
||||
LD = cl
|
||||
RC = rc
|
||||
CFLAGS = -nologo -MD -O2
|
||||
LDFLAGS = -nologo
|
||||
|
||||
|
@ -12,19 +15,33 @@ OBJS = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj \
|
|||
inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
|
||||
|
||||
# targets
|
||||
all: zlib.lib example.exe minigzip.exe
|
||||
all: zlib.dll zlibstat.lib example.exe minigzip.exe exampl_s.exe minigz_s.exe
|
||||
|
||||
zlib.lib: $(OBJS)
|
||||
zlibstat.lib: $(OBJS)
|
||||
lib -out:$@ $(OBJS)
|
||||
|
||||
zlib.dll: $(OBJS) zlib.res win32/zlib.def
|
||||
link -release -def:win32/zlib.def -dll -out:$@ $(OBJS) zlib.res
|
||||
|
||||
zlib.lib: zlib.dll
|
||||
|
||||
example.exe: example.obj zlib.lib
|
||||
$(LD) $(LDFLAGS) example.obj zlib.lib
|
||||
|
||||
minigzip.exe: minigzip.obj zlib.lib
|
||||
$(LD) $(LDFLAGS) minigzip.obj zlib.lib
|
||||
|
||||
exampl_s.exe: example.obj zlibstat.lib
|
||||
$(LD) $(LDFLAGS) -o $@ example.obj zlibstat.lib
|
||||
|
||||
minigz_s.exe: minigzip.obj zlibstat.lib
|
||||
$(LD) $(LDFLAGS) -o $@ minigzip.obj zlibstat.lib
|
||||
|
||||
.c.obj:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
$(CC) -c $(CFLAGS) $<
|
||||
|
||||
zlib.res: win32/zlib.rc
|
||||
$(RC) /l 0x409 /fo$@ /d WIN32 win32/zlib.rc
|
||||
|
||||
adler32.obj: adler32.c zlib.h zconf.h
|
||||
|
||||
|
@ -62,8 +79,14 @@ test: example.exe minigzip.exe
|
|||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
teststat: exampl_s.exe minigz_s.exe
|
||||
exampl_s
|
||||
echo hello world | minigz_s | minigz_s -d
|
||||
|
||||
# cleanup
|
||||
clean:
|
||||
del *.obj
|
||||
del *.dll
|
||||
del *.lib
|
||||
del *.exp
|
||||
del *.exe
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
LIBRARY zlib.dll
|
||||
DESCRIPTION "zlib compression library for Windows"
|
||||
DESCRIPTION "zlib data compression library"
|
||||
|
||||
EXPORTS
|
||||
adler32 @1
|
||||
|
@ -43,7 +43,10 @@ EXPORTS
|
|||
compress2 @39
|
||||
gzputs @40
|
||||
gzgets @41
|
||||
; The following functions exist since zlib-1.2.0
|
||||
; deflateBound @42
|
||||
; compressBound @43
|
||||
; etc.
|
||||
; since zlib-1.2.0:
|
||||
inflateCopy @42
|
||||
inflateBackInit_ @43
|
||||
inflateBack @44
|
||||
inflateBackEnd @45
|
||||
compressBound @46
|
||||
deflateBound @47
|
||||
|
|
89
zconf.h
89
zconf.h
|
@ -5,8 +5,8 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#ifndef _ZCONF_H
|
||||
#define _ZCONF_H
|
||||
#ifndef ZCONF_H
|
||||
#define ZCONF_H
|
||||
|
||||
/*
|
||||
* If you *really* need a unique prefix for all types and library functions,
|
||||
|
@ -100,15 +100,6 @@
|
|||
# define NO_DUMMY_DECL
|
||||
#endif
|
||||
|
||||
/* Old Borland C incorrectly complains about missing returns: */
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x460)
|
||||
# define NEED_DUMMY_RETURN
|
||||
#endif
|
||||
#if defined(__TURBOC__) && !defined(__BORLANDC__)
|
||||
# define NEED_DUMMY_RETURN
|
||||
#endif
|
||||
|
||||
|
||||
/* Maximum value for memLevel in deflateInit2 */
|
||||
#ifndef MAX_MEM_LEVEL
|
||||
# ifdef MAXSEG_64K
|
||||
|
@ -172,46 +163,54 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(WIN32) && (!defined(ZLIB_WIN32_NODLL)) && (!defined(ZLIB_DLL))
|
||||
# define ZLIB_DLL
|
||||
#endif
|
||||
|
||||
/* Compile with -DZLIB_DLL for Windows DLL support */
|
||||
#if defined(ZLIB_DLL)
|
||||
# if defined(_WINDOWS) || defined(WINDOWS) || defined(WIN32)
|
||||
# ifndef WINAPIV
|
||||
# ifdef FAR
|
||||
# undef FAR
|
||||
# endif
|
||||
# include <windows.h>
|
||||
# endif
|
||||
# ifdef WIN32
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA WINAPIV
|
||||
# else
|
||||
# define ZEXPORT WINAPI _export
|
||||
# define ZEXPORTVA FAR _cdecl _export
|
||||
# endif
|
||||
/* If building or using a Windows DLL, compile with -DZLIB_DLL.
|
||||
* The calls to ZEXTERN functions will be more efficient this way.
|
||||
*/
|
||||
#if defined(_WINDOWS) || defined(WINDOWS) || defined(WIN32)
|
||||
# ifdef FAR
|
||||
# undef FAR
|
||||
# endif
|
||||
# if defined (__BORLANDC__)
|
||||
# if (__BORLANDC__ >= 0x0500) && defined (WIN32)
|
||||
# include <windows.h>
|
||||
# define ZEXPORT __declspec(dllexport) WINAPI
|
||||
# define ZEXPORTVA __declspec(dllexport) WINAPIV
|
||||
/* For zlib, the basic Win32 API declarations are sufficient. Whenever
|
||||
* a program that uses zlib requires the full Win32 API set, it has
|
||||
* to include <windows.h> prior to "zlib.h".
|
||||
*/
|
||||
# if defined(WIN32) && (!defined(WIN32_LEAN_AND_MEAN))
|
||||
# define WIN32_LEAN_AND_MEAN
|
||||
# endif
|
||||
# include <windows.h>
|
||||
# if !defined(WIN32) || (defined(__BORLANDC__) && (__BORLANDC__ < 0x500))
|
||||
# if defined(ZLIB_DLL) && defined(ZLIB_INTERNAL)
|
||||
# define ZEXPORT WINAPI _export
|
||||
# define ZEXPORTVA FAR _cdecl _export
|
||||
# else
|
||||
# if defined (_Windows) && defined (__DLL__)
|
||||
# define ZEXPORT _export
|
||||
# define ZEXPORTVA _export
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA FAR _cdecl
|
||||
# endif
|
||||
# else
|
||||
/* a fully Win32-compliant compiler */
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA CDECL
|
||||
# ifdef ZLIB_DLL
|
||||
# ifdef ZLIB_INTERNAL
|
||||
# define ZEXTERN extern __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXTERN extern __declspec(dllimport)
|
||||
# endif
|
||||
# else
|
||||
# define ZEXTERN extern
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined (__BEOS__)
|
||||
# if defined (ZLIB_DLL)
|
||||
# define ZEXTERN extern __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXTERN extern __declspec(dllimport)
|
||||
# ifdef ZLIB_DLL
|
||||
# ifdef ZLIB_INTERNAL
|
||||
# define ZEXPORT __declspec(dllexport)
|
||||
# define ZEXPORTVA __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXPORT __declspec(dllimport)
|
||||
# define ZEXPORTVA __declspec(dllimport)
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
@ -226,7 +225,7 @@
|
|||
#endif
|
||||
|
||||
#ifndef FAR
|
||||
# define FAR
|
||||
# define FAR
|
||||
#endif
|
||||
|
||||
#if !defined(__MACTYPES__)
|
||||
|
@ -290,4 +289,4 @@ typedef uLong FAR uLongf;
|
|||
# pragma map(inflate_copyright,"INCOPY")
|
||||
#endif
|
||||
|
||||
#endif /* _ZCONF_H */
|
||||
#endif /* ZCONF_H */
|
||||
|
|
89
zconf.in.h
89
zconf.in.h
|
@ -5,8 +5,8 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#ifndef _ZCONF_H
|
||||
#define _ZCONF_H
|
||||
#ifndef ZCONF_H
|
||||
#define ZCONF_H
|
||||
|
||||
/*
|
||||
* If you *really* need a unique prefix for all types and library functions,
|
||||
|
@ -100,15 +100,6 @@
|
|||
# define NO_DUMMY_DECL
|
||||
#endif
|
||||
|
||||
/* Old Borland C incorrectly complains about missing returns: */
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x460)
|
||||
# define NEED_DUMMY_RETURN
|
||||
#endif
|
||||
#if defined(__TURBOC__) && !defined(__BORLANDC__)
|
||||
# define NEED_DUMMY_RETURN
|
||||
#endif
|
||||
|
||||
|
||||
/* Maximum value for memLevel in deflateInit2 */
|
||||
#ifndef MAX_MEM_LEVEL
|
||||
# ifdef MAXSEG_64K
|
||||
|
@ -172,46 +163,54 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(WIN32) && (!defined(ZLIB_WIN32_NODLL)) && (!defined(ZLIB_DLL))
|
||||
# define ZLIB_DLL
|
||||
#endif
|
||||
|
||||
/* Compile with -DZLIB_DLL for Windows DLL support */
|
||||
#if defined(ZLIB_DLL)
|
||||
# if defined(_WINDOWS) || defined(WINDOWS) || defined(WIN32)
|
||||
# ifndef WINAPIV
|
||||
# ifdef FAR
|
||||
# undef FAR
|
||||
# endif
|
||||
# include <windows.h>
|
||||
# endif
|
||||
# ifdef WIN32
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA WINAPIV
|
||||
# else
|
||||
# define ZEXPORT WINAPI _export
|
||||
# define ZEXPORTVA FAR _cdecl _export
|
||||
# endif
|
||||
/* If building or using a Windows DLL, compile with -DZLIB_DLL.
|
||||
* The calls to ZEXTERN functions will be more efficient this way.
|
||||
*/
|
||||
#if defined(_WINDOWS) || defined(WINDOWS) || defined(WIN32)
|
||||
# ifdef FAR
|
||||
# undef FAR
|
||||
# endif
|
||||
# if defined (__BORLANDC__)
|
||||
# if (__BORLANDC__ >= 0x0500) && defined (WIN32)
|
||||
# include <windows.h>
|
||||
# define ZEXPORT __declspec(dllexport) WINAPI
|
||||
# define ZEXPORTVA __declspec(dllexport) WINAPIV
|
||||
/* For zlib, the basic Win32 API declarations are sufficient. Whenever
|
||||
* a program that uses zlib requires the full Win32 API set, it has
|
||||
* to include <windows.h> prior to "zlib.h".
|
||||
*/
|
||||
# if defined(WIN32) && (!defined(WIN32_LEAN_AND_MEAN))
|
||||
# define WIN32_LEAN_AND_MEAN
|
||||
# endif
|
||||
# include <windows.h>
|
||||
# if !defined(WIN32) || (defined(__BORLANDC__) && (__BORLANDC__ < 0x500))
|
||||
# if defined(ZLIB_DLL) && defined(ZLIB_INTERNAL)
|
||||
# define ZEXPORT WINAPI _export
|
||||
# define ZEXPORTVA FAR _cdecl _export
|
||||
# else
|
||||
# if defined (_Windows) && defined (__DLL__)
|
||||
# define ZEXPORT _export
|
||||
# define ZEXPORTVA _export
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA FAR _cdecl
|
||||
# endif
|
||||
# else
|
||||
/* a fully Win32-compliant compiler */
|
||||
# define ZEXPORT WINAPI
|
||||
# define ZEXPORTVA CDECL
|
||||
# ifdef ZLIB_DLL
|
||||
# ifdef ZLIB_INTERNAL
|
||||
# define ZEXTERN extern __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXTERN extern __declspec(dllimport)
|
||||
# endif
|
||||
# else
|
||||
# define ZEXTERN extern
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined (__BEOS__)
|
||||
# if defined (ZLIB_DLL)
|
||||
# define ZEXTERN extern __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXTERN extern __declspec(dllimport)
|
||||
# ifdef ZLIB_DLL
|
||||
# ifdef ZLIB_INTERNAL
|
||||
# define ZEXPORT __declspec(dllexport)
|
||||
# define ZEXPORTVA __declspec(dllexport)
|
||||
# else
|
||||
# define ZEXPORT __declspec(dllimport)
|
||||
# define ZEXPORTVA __declspec(dllimport)
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
@ -226,7 +225,7 @@
|
|||
#endif
|
||||
|
||||
#ifndef FAR
|
||||
# define FAR
|
||||
# define FAR
|
||||
#endif
|
||||
|
||||
#if !defined(__MACTYPES__)
|
||||
|
@ -290,4 +289,4 @@ typedef uLong FAR uLongf;
|
|||
# pragma map(inflate_copyright,"INCOPY")
|
||||
#endif
|
||||
|
||||
#endif /* _ZCONF_H */
|
||||
#endif /* ZCONF_H */
|
||||
|
|
|
@ -0,0 +1,159 @@
|
|||
.TH ZLIB 3 "12 May 2003"
|
||||
.SH NAME
|
||||
zlib \- compression/decompression library
|
||||
.SH SYNOPSIS
|
||||
[see
|
||||
.I zlib.h
|
||||
for full description]
|
||||
.SH DESCRIPTION
|
||||
The
|
||||
.I zlib
|
||||
library is a general purpose data compression library.
|
||||
The code is thread safe.
|
||||
It provides in-memory compression and decompression functions,
|
||||
including integrity checks of the uncompressed data.
|
||||
This version of the library supports only one compression method (deflation)
|
||||
but other algorithms will be added later
|
||||
and will have the same stream interface.
|
||||
.LP
|
||||
Compression can be done in a single step if the buffers are large enough
|
||||
(for example if an input file is mmap'ed),
|
||||
or can be done by repeated calls of the compression function.
|
||||
In the latter case,
|
||||
the application must provide more input and/or consume the output
|
||||
(providing more output space) before each call.
|
||||
.LP
|
||||
The library also supports reading and writing files in
|
||||
.IR gzip (1)
|
||||
(.gz) format
|
||||
with an interface similar to that of stdio.
|
||||
.LP
|
||||
The library does not install any signal handler.
|
||||
The decoder checks the consistency of the compressed data,
|
||||
so the library should never crash even in case of corrupted input.
|
||||
.LP
|
||||
All functions of the compression library are documented in the file
|
||||
.IR zlib.h .
|
||||
The distribution source includes examples of use of the library
|
||||
in the files
|
||||
.I example.c
|
||||
and
|
||||
.IR minigzip.c .
|
||||
.LP
|
||||
Changes to this version are documented in the file
|
||||
.I ChangeLog
|
||||
that accompanies the source,
|
||||
and are concerned primarily with bug fixes and portability enhancements.
|
||||
.LP
|
||||
A Java implementation of
|
||||
.I zlib
|
||||
is available in the Java Development Kit 1.1:
|
||||
.IP
|
||||
http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html
|
||||
.LP
|
||||
A Perl interface to
|
||||
.IR zlib ,
|
||||
written by Paul Marquess (pmqs@cpan.org),
|
||||
is available at CPAN (Comprehensive Perl Archive Network) sites,
|
||||
including:
|
||||
.IP
|
||||
http://www.cpan.org/modules/by-module/Compress/
|
||||
.LP
|
||||
A Python interface to
|
||||
.IR zlib ,
|
||||
written by A.M. Kuchling (amk@magnet.com),
|
||||
is available in Python 1.5 and later versions:
|
||||
.IP
|
||||
http://www.python.org/doc/lib/module-zlib.html
|
||||
.LP
|
||||
A
|
||||
.I zlib
|
||||
binding for
|
||||
.IR tcl (1),
|
||||
written by Andreas Kupries (a.kupries@westend.com),
|
||||
is availlable at:
|
||||
.IP
|
||||
http://www.westend.com/~kupries/doc/trf/man/man.html
|
||||
.LP
|
||||
An experimental package to read and write files in .zip format,
|
||||
written on top of
|
||||
.I zlib
|
||||
by Gilles Vollant (info@winimage.com),
|
||||
is available at:
|
||||
.IP
|
||||
http://www.winimage.com/zLibDll/unzip.html
|
||||
and also in the
|
||||
.I contrib/minizip
|
||||
directory of the main
|
||||
.I zlib
|
||||
web site.
|
||||
.SH "SEE ALSO"
|
||||
The
|
||||
.I zlib
|
||||
web site can be found at either of these locations:
|
||||
.IP
|
||||
http://www.zlib.org
|
||||
.br
|
||||
http://www.gzip.org/zlib/
|
||||
.LP
|
||||
The data format used by the zlib library is described by RFC
|
||||
(Request for Comments) 1950 to 1952 in the files:
|
||||
.IP
|
||||
http://www.ietf.org/rfc/rfc1950.txt (concerning zlib format)
|
||||
.br
|
||||
http://www.ietf.org/rfc/rfc1951.txt (concerning deflate format)
|
||||
.br
|
||||
http://www.ietf.org/rfc/rfc1952.txt (concerning gzip format)
|
||||
.LP
|
||||
These documents are also available in other formats from:
|
||||
.IP
|
||||
ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
|
||||
.LP
|
||||
Mark Nelson (markn@ieee.org) wrote an article about
|
||||
.I zlib
|
||||
for the Jan. 1997 issue of Dr. Dobb's Journal;
|
||||
a copy of the article is available at:
|
||||
.IP
|
||||
http://dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
.SH "REPORTING PROBLEMS"
|
||||
Before reporting a problem,
|
||||
please check the
|
||||
.I zlib
|
||||
web site to verify that you have the latest version of
|
||||
.IR zlib ;
|
||||
otherwise,
|
||||
obtain the latest version and see if the problem still exists.
|
||||
Please read the
|
||||
.I zlib
|
||||
FAQ at:
|
||||
.IP
|
||||
http://www.gzip.org/zlib/zlib_faq.html
|
||||
.LP
|
||||
before asking for help.
|
||||
Send questions and/or comments to zlib@gzip.org,
|
||||
or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
|
||||
.SH AUTHORS
|
||||
Version 1.2.0.1
|
||||
Copyright (C) 1995-2003 Jean-loup Gailly (jloup@gzip.org)
|
||||
and Mark Adler (madler@alumni.caltech.edu).
|
||||
.LP
|
||||
This software is provided "as-is,"
|
||||
without any express or implied warranty.
|
||||
In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
See the distribution directory with respect to requirements
|
||||
governing redistribution.
|
||||
The deflate format used by
|
||||
.I zlib
|
||||
was defined by Phil Katz.
|
||||
The deflate and
|
||||
.I zlib
|
||||
specifications were written by L. Peter Deutsch.
|
||||
Thanks to all the people who reported problems and suggested various
|
||||
improvements in
|
||||
.IR zlib ;
|
||||
who are too numerous to cite here.
|
||||
.LP
|
||||
UNIX manual page by R. P. C. Rodgers,
|
||||
U.S. National Library of Medicine (rodgers@nlm.nih.gov).
|
||||
.\" end of man page
|
107
zlib.h
107
zlib.h
|
@ -1,5 +1,5 @@
|
|||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||
version 1.2.0.1, March 17th, 2003
|
||||
version 1.2.0.2, July 13th, 2003
|
||||
|
||||
Copyright (C) 1995-2003 Jean-loup Gailly and Mark Adler
|
||||
|
||||
|
@ -28,8 +28,8 @@
|
|||
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
|
||||
*/
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#define _ZLIB_H
|
||||
#ifndef ZLIB_H
|
||||
#define ZLIB_H
|
||||
|
||||
#include "zconf.h"
|
||||
|
||||
|
@ -37,7 +37,8 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define ZLIB_VERSION "1.2.0.1"
|
||||
#define ZLIB_VERSION "1.2.0.2"
|
||||
#define ZLIB_VERNUM 0x1202
|
||||
|
||||
/*
|
||||
The 'zlib' compression library provides in-memory compression and
|
||||
|
@ -334,9 +335,9 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
|
|||
ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
||||
/*
|
||||
inflate decompresses as much data as possible, and stops when the input
|
||||
buffer becomes empty or the output buffer becomes full. It may some
|
||||
introduce some output latency (reading input without producing any output)
|
||||
except when forced to flush.
|
||||
buffer becomes empty or the output buffer becomes full. It may introduce
|
||||
some output latency (reading input without producing any output) except when
|
||||
forced to flush.
|
||||
|
||||
The detailed semantics are as follows. inflate performs one or both of the
|
||||
following actions:
|
||||
|
@ -586,20 +587,28 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
|||
The windowBits parameter is the base two logarithm of the maximum window
|
||||
size (the size of the history buffer). It should be in the range 8..15 for
|
||||
this version of the library. The default value is 15 if inflateInit is used
|
||||
instead. If a compressed stream with a larger window size is given as
|
||||
input, inflate() will return with the error code Z_DATA_ERROR instead of
|
||||
trying to allocate a larger window.
|
||||
instead. windowBits must be greater than or equal to the windowBits value
|
||||
provided to deflateInit2() while compressing, or it must be equal to 15 if
|
||||
deflateInit2() was not used. If a compressed stream with a larger window
|
||||
size is given as input, inflate() will return with the error code
|
||||
Z_DATA_ERROR instead of trying to allocate a larger window.
|
||||
|
||||
windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
|
||||
determines the window size. inflate() will then process raw deflate data,
|
||||
windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
|
||||
determines the window size. inflate() will then process raw deflate data,
|
||||
not looking for a zlib or gzip header, not generating a check value, and not
|
||||
looking for any check values for comparison at the end of the stream. This
|
||||
looking for any check values for comparison at the end of the stream. This
|
||||
is for use with other formats that use the deflate compressed data format
|
||||
such as zip. Those formats provide their own check values. If a custom
|
||||
such as zip. Those formats provide their own check values. If a custom
|
||||
format is developed using the raw deflate format for compressed data, it is
|
||||
recommended that a check value such as an adler32 or a crc32 be applied to
|
||||
the uncompressed data as is done in the zlib, gzip, and zip formats. For
|
||||
most applications, the zlib format should be used as is.
|
||||
most applications, the zlib format should be used as is. Note that comments
|
||||
above on the use in deflateInit2() applies to the magnitude of windowBits.
|
||||
|
||||
windowBits can also be greater than 15 for optional gzip decoding. Add
|
||||
32 to windowBits to enable zlib and gzip decoding with automatic header
|
||||
detection, or add 16 to decode only the gzip format (the zlib format will
|
||||
return a Z_DATA_ERROR).
|
||||
|
||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
|
||||
|
@ -771,6 +780,45 @@ ZEXTERN int ZEXPORT inflateBackEnd(z_stream FAR *strm);
|
|||
state was inconsistent.
|
||||
*/
|
||||
|
||||
ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
|
||||
/* Return flags indicating compile-time options.
|
||||
|
||||
Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
|
||||
1.0: size of uInt
|
||||
3.2: size of uLong
|
||||
5.4: size of voidpf (pointers)
|
||||
7.6: size of z_off_t
|
||||
|
||||
Debug options:
|
||||
8: DEBUG
|
||||
9-11: 0 (reserved)
|
||||
|
||||
One-time table building (smaller code, but not thread-safe if true):
|
||||
12: BUILDFIXED -- build static block decoding tables when needed
|
||||
13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
|
||||
14,15: 0 (reserved)
|
||||
|
||||
Library content (indicates missing functionality):
|
||||
16: NO_DEFLATE -- gz* functions cannot compress (to avoid linking deflate
|
||||
code when not needed)
|
||||
17: NO_GUNZIP -- inflate can't detect and decode gzip streams, to avoid
|
||||
linking crc code
|
||||
18-19: 0 (reserved)
|
||||
|
||||
Operation variations (changes in library functionality):
|
||||
20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
|
||||
21: FASTEST -- deflate algorithm with only one, lowest compression level
|
||||
22,23: 0 (reserved)
|
||||
|
||||
The sprintf variant used by gzprintf (zero is best):
|
||||
24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
|
||||
25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
|
||||
26: 0 = returns value, 1 = void -- 1 means inferred string length returned
|
||||
|
||||
Remainder:
|
||||
27-31: 0 (reserved)
|
||||
*/
|
||||
|
||||
|
||||
/* utility functions */
|
||||
|
||||
|
@ -901,10 +949,10 @@ ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
|
|||
control of the format string, as in fprintf. gzprintf returns the number of
|
||||
uncompressed bytes actually written (0 in case of error). The number of
|
||||
uncompressed bytes written is limited to 4095. The caller should assure that
|
||||
this limit is not exceeded. If it is exceeded, then either gzprintf() will
|
||||
return an error (0) with nothing written, or there will be a buffer overflow
|
||||
with unpredictable consequences. The latter is possible only if zlib was
|
||||
compiled with insecure variants of printf, i.e. sprintf() or vsprintf()
|
||||
this limit is not exceeded. If it is exceeded, then gzprintf() will return
|
||||
return an error (0) with nothing written. In this case, there may also be a
|
||||
buffer overflow with unpredictable consequences, which is possible only if
|
||||
zlib was compiled with the insecure functions sprintf() or vsprintf()
|
||||
because the secure snprintf() or vsnprintf() functions were not available.
|
||||
*/
|
||||
|
||||
|
@ -936,6 +984,16 @@ ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
|
|||
or -1 in case of end of file or error.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
|
||||
/*
|
||||
Push one character back onto the stream to be read again later.
|
||||
Only one character of push-back is allowed. gzungetc() returns the
|
||||
character pushed, or -1 on failure. gzungetc() will fail if a
|
||||
character has been pushed but not read yet, or if c is -1. The pushed
|
||||
character will be discarded if the stream is repositioned with gzseek()
|
||||
or gzrewind().
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
|
||||
/*
|
||||
Flushes all pending output into the compressed file. The parameter
|
||||
|
@ -1002,6 +1060,13 @@ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
|
|||
to get the exact error code.
|
||||
*/
|
||||
|
||||
ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
|
||||
/*
|
||||
Clears the error and end-of-file flags for file. This is analogous to the
|
||||
clearerr() function in stdio. This is useful for continuing to read a gzip
|
||||
file that is being written concurrently.
|
||||
*/
|
||||
|
||||
/* checksum functions */
|
||||
|
||||
/*
|
||||
|
@ -1077,7 +1142,7 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits,
|
|||
ZLIB_VERSION, sizeof(z_stream))
|
||||
|
||||
|
||||
#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
|
||||
#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
|
||||
struct internal_state {int dummy;}; /* hack for buggy compilers */
|
||||
#endif
|
||||
|
||||
|
@ -1089,4 +1154,4 @@ ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void));
|
|||
}
|
||||
#endif
|
||||
|
||||
#endif /* _ZLIB_H */
|
||||
#endif /* ZLIB_H */
|
||||
|
|
83
zutil.c
83
zutil.c
|
@ -7,7 +7,9 @@
|
|||
|
||||
#include "zutil.h"
|
||||
|
||||
#ifndef NO_DUMMY_DECL
|
||||
struct internal_state {int dummy;}; /* for buggy compilers */
|
||||
#endif
|
||||
|
||||
#ifndef STDC
|
||||
extern void exit OF((int));
|
||||
|
@ -31,6 +33,83 @@ const char * ZEXPORT zlibVersion()
|
|||
return ZLIB_VERSION;
|
||||
}
|
||||
|
||||
uLong ZEXPORT zlibCompileFlags()
|
||||
{
|
||||
uLong flags;
|
||||
|
||||
flags = 0;
|
||||
switch (sizeof(uInt)) {
|
||||
case 2: break;
|
||||
case 4: flags += 1; break;
|
||||
case 8: flags += 2; break;
|
||||
default: flags += 3;
|
||||
}
|
||||
switch (sizeof(uLong)) {
|
||||
case 2: break;
|
||||
case 4: flags += 1 << 2; break;
|
||||
case 8: flags += 2 << 2; break;
|
||||
default: flags += 3 << 2;
|
||||
}
|
||||
switch (sizeof(voidpf)) {
|
||||
case 2: break;
|
||||
case 4: flags += 1 << 4; break;
|
||||
case 8: flags += 2 << 4; break;
|
||||
default: flags += 3 << 4;
|
||||
}
|
||||
switch (sizeof(z_off_t)) {
|
||||
case 2: break;
|
||||
case 4: flags += 1 << 6; break;
|
||||
case 8: flags += 2 << 6; break;
|
||||
default: flags += 3 << 6;
|
||||
}
|
||||
#ifdef DEBUG
|
||||
flags += 1 << 8;
|
||||
#endif
|
||||
#ifdef BUILDFIXED
|
||||
flags += 1 << 12;
|
||||
#endif
|
||||
#ifdef DYNAMIC_CRC_TABLE
|
||||
flags += 1 << 13;
|
||||
#endif
|
||||
#ifdef NO_DEFLATE
|
||||
flags += 1 << 16;
|
||||
#endif
|
||||
#ifdef NO_GUNZIP
|
||||
flags += 1 << 17;
|
||||
#endif
|
||||
#ifdef PKZIP_BUG_WORKAROUND
|
||||
flags += 1 << 20;
|
||||
#endif
|
||||
#ifdef FASTEST
|
||||
flags += 1 << 21;
|
||||
#endif
|
||||
#ifdef STDC
|
||||
# ifdef NO_vsnprintf
|
||||
flags += 1 << 25;
|
||||
# ifdef HAS_vsprintf_void
|
||||
flags += 1 << 26;
|
||||
# endif
|
||||
# else
|
||||
# ifdef HAS_vsnprintf_void
|
||||
flags += 1 << 26;
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
flags += 1 << 24;
|
||||
# ifdef NO_snprintf
|
||||
flags += 1 << 25;
|
||||
# ifdef HAS_sprintf_void
|
||||
flags += 1 << 26;
|
||||
# endif
|
||||
# else
|
||||
# ifdef HAS_snprintf_void
|
||||
flags += 1 << 26;
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
return flags;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
|
||||
# ifndef verbose
|
||||
|
@ -55,6 +134,10 @@ const char * ZEXPORT zError(err)
|
|||
return ERR_MSG(err);
|
||||
}
|
||||
|
||||
#if defined(_WIN32_WCE)
|
||||
/* does not exist on WCE */
|
||||
int errno = 0;
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_MEMCPY
|
||||
|
||||
|
|
15
zutil.h
15
zutil.h
|
@ -10,9 +10,10 @@
|
|||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#ifndef _Z_UTIL_H
|
||||
#define _Z_UTIL_H
|
||||
#ifndef ZUTIL_H
|
||||
#define ZUTIL_H
|
||||
|
||||
#define ZLIB_INTERNAL
|
||||
#include "zlib.h"
|
||||
|
||||
#ifdef STDC
|
||||
|
@ -134,7 +135,11 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||
#endif
|
||||
|
||||
#if (defined(_MSC_VER) && (_MSC_VER > 600))
|
||||
# define fdopen(fd,type) _fdopen(fd,type)
|
||||
# if defined(_WIN32_WCE)
|
||||
# define fdopen(fd,mode) NULL /* No fdopen() */
|
||||
# else
|
||||
# define fdopen(fd,type) _fdopen(fd,type)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
|
@ -157,7 +162,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||
# endif
|
||||
# endif
|
||||
#endif
|
||||
#if !defined(STDC99) && !(defined(__TURBOC__) && __TURBOC__ >= 0x550) && !defined(VSNPRINTF_DEFINED)
|
||||
#if !defined(STDC99) && !(defined(__TURBOC__) && __TURBOC__ >= 0x550) && !defined(HAVE_VSNPRINTF)
|
||||
# ifdef MSDOS
|
||||
/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
|
||||
but for now we just assume it doesn't. */
|
||||
|
@ -239,4 +244,4 @@ void zcfree OF((voidpf opaque, voidpf ptr));
|
|||
#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
|
||||
#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
|
||||
|
||||
#endif /* _Z_UTIL_H */
|
||||
#endif /* ZUTIL_H */
|
||||
|
|
Loading…
Reference in New Issue