mirror of https://github.com/madler/zlib.git
Mark Adler
13 years ago
parent
f6194ef39a
commit
d004b04783
74 changed files with 7120 additions and 1855 deletions
@ -0,0 +1,177 @@ |
||||
cmake_minimum_required(VERSION 2.4.4) |
||||
set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON) |
||||
|
||||
project(zlib C) |
||||
|
||||
if(NOT DEFINED BUILD_SHARED_LIBS) |
||||
option(BUILD_SHARED_LIBS "Build a shared library form of zlib" ON) |
||||
endif() |
||||
|
||||
include(CheckTypeSize) |
||||
include(CheckFunctionExists) |
||||
include(CheckIncludeFile) |
||||
include(CheckCSourceCompiles) |
||||
enable_testing() |
||||
|
||||
check_include_file(sys/types.h HAVE_SYS_TYPES_H) |
||||
check_include_file(stdint.h HAVE_STDINT_H) |
||||
check_include_file(stddef.h HAVE_STDDEF_H) |
||||
|
||||
# |
||||
# Check to see if we have large file support |
||||
# |
||||
set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE) |
||||
|
||||
# We add these other definitions here because CheckTypeSize.cmake |
||||
# in CMake 2.4.x does not automatically do so and we want |
||||
# compatibility with CMake 2.4.x. |
||||
if(HAVE_SYS_TYPES_H) |
||||
list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H) |
||||
endif() |
||||
if(HAVE_STDINT_H) |
||||
list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H) |
||||
endif() |
||||
if(HAVE_STDDEF_H) |
||||
list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H) |
||||
endif() |
||||
|
||||
check_type_size(off64_t OFF64_T) |
||||
|
||||
if(HAVE_OFF64_T) |
||||
add_definitions(-D_LARGEFILE64_SOURCE) |
||||
endif() |
||||
set(CMAKE_REQUIRED_DEFINITIONS) # clear variable |
||||
|
||||
# |
||||
# Check for fseeko |
||||
# |
||||
check_function_exists(fseeko HAVE_FSEEKO) |
||||
if(NOT HAVE_FSEEKO) |
||||
add_definitions(-DNO_FSEEKO) |
||||
endif() |
||||
|
||||
# |
||||
# Check for unistd.h |
||||
# |
||||
check_include_file(unistd.h HAVE_UNISTD_H) |
||||
|
||||
# |
||||
# Check for errno.h |
||||
check_include_file(errno.h HAVE_ERRNO_H) |
||||
if(NOT HAVE_ERRNO_H) |
||||
add_definitions(-DNO_ERRNO_H) |
||||
endif() |
||||
|
||||
# |
||||
# Check for mmap support |
||||
# |
||||
set(mmap_test_code " |
||||
#include <sys/types.h> |
||||
#include <sys/mman.h> |
||||
#include <sys/stat.h> |
||||
caddr_t hello() { |
||||
return mmap((caddr_t)0, (off_t)0, PROT_READ, MAP_SHARED, 0, (off_t)0); |
||||
} |
||||
int main() { return 0; } |
||||
") |
||||
check_c_source_compiles("${mmap_test_code}" USE_MMAP) |
||||
if(USE_MMAP) |
||||
add_definitions(-DUSE_MMAP) |
||||
endif() |
||||
|
||||
# |
||||
# Create the zlibdefs.h file. |
||||
# Note: we create it in CMAKE_CURRENT_SOURCE_DIR instead |
||||
# of CMAKE_CURRENT_BINARY_DIR because an empty zlibdefs.h |
||||
# is shipped with zlib in the source tree. |
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/zlibdefs.h.cmakein |
||||
${CMAKE_CURRENT_SOURCE_DIR}/zlibdefs.h) |
||||
|
||||
if(MSVC) |
||||
set(CMAKE_DEBUG_POSTFIX "D") |
||||
add_definitions(-D_CRT_SECURE_NO_DEPRECATE) |
||||
add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE) |
||||
endif() |
||||
|
||||
#============================================================================ |
||||
# zlib |
||||
#============================================================================ |
||||
|
||||
set(ZLIB_PUBLIC_HDRS |
||||
zconf.h |
||||
zlib.h |
||||
zlibdefs.h |
||||
) |
||||
set(ZLIB_PRIVATE_HDRS |
||||
crc32.h |
||||
deflate.h |
||||
gzguts.h |
||||
inffast.h |
||||
inffixed.h |
||||
inflate.h |
||||
inftrees.h |
||||
trees.h |
||||
zutil.h |
||||
) |
||||
set(ZLIB_SRCS |
||||
adler32.c |
||||
compress.c |
||||
crc32.c |
||||
deflate.c |
||||
gzclose.c |
||||
gzio.c |
||||
gzlib.c |
||||
gzread.c |
||||
gzwrite.c |
||||
inflate.c |
||||
infback.c |
||||
inftrees.c |
||||
inffast.c |
||||
trees.c |
||||
uncompr.c |
||||
zutil.c |
||||
) |
||||
|
||||
add_library(zlib ${ZLIB_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) |
||||
set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL) |
||||
set_target_properties(zlib PROPERTIES VERSION 1.2.3.4) |
||||
set_target_properties(zlib PROPERTIES SOVERSION 1) |
||||
if(UNIX) |
||||
# On unix like platforms the library is almost always called libz |
||||
set_target_properties(zlib PROPERTIES OUTPUT_NAME z) |
||||
endif() |
||||
|
||||
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL ) |
||||
install(TARGETS zlib |
||||
RUNTIME DESTINATION bin |
||||
ARCHIVE DESTINATION lib |
||||
LIBRARY DESTINATION lib ) |
||||
endif() |
||||
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL ) |
||||
install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION include) |
||||
endif() |
||||
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL ) |
||||
install(FILES zlib.3 DESTINATION share/man/man3) |
||||
endif() |
||||
|
||||
#============================================================================ |
||||
# Example binaries |
||||
#============================================================================ |
||||
|
||||
add_executable(example example.c) |
||||
target_link_libraries(example zlib) |
||||
add_test(example example) |
||||
|
||||
add_executable(minigzip minigzip.c) |
||||
target_link_libraries(minigzip zlib) |
||||
|
||||
if(HAVE_OFF64_T) |
||||
add_executable(example64 example.c) |
||||
target_link_libraries(example64 zlib) |
||||
set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64") |
||||
add_test(example64 example64) |
||||
|
||||
add_executable(minigzip64 minigzip.c) |
||||
target_link_libraries(minigzip64 zlib) |
||||
set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64") |
||||
endif() |
||||
@ -1,67 +0,0 @@ |
||||
Change in 1.01e (12 feb 05) |
||||
- Fix in zipOpen2 for globalcomment (Rolf Kalbermatter) |
||||
- Fix possible memory leak in unzip.c (Zoran Stevanovic) |
||||
|
||||
Change in 1.01b (20 may 04) |
||||
- Integrate patch from Debian package (submited by Mark Brown) |
||||
- Add tools mztools from Xavier Roche |
||||
|
||||
Change in 1.01 (8 may 04) |
||||
- fix buffer overrun risk in unzip.c (Xavier Roche) |
||||
- fix a minor buffer insecurity in minizip.c (Mike Whittaker) |
||||
|
||||
Change in 1.00: (10 sept 03) |
||||
- rename to 1.00 |
||||
- cosmetic code change |
||||
|
||||
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
|
||||
|
||||
@ -0,0 +1,7 @@ |
||||
|
||||
MiniZip64 was derrived from MiniZip at version 1.01f |
||||
|
||||
Change in 1.0 (Okt 2009) |
||||
- **TODO - Add history** |
||||
|
||||
|
||||
@ -0,0 +1,79 @@ |
||||
MiniZip64 - Copyright (c) 2009-2010 - Mathias Svensson - Built from MiniZip by Gilles Vollant |
||||
|
||||
Introduction |
||||
--------------------- |
||||
MiniZip64 is built from MiniZip by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html ) |
||||
|
||||
When adding ZIP64 support into minizip it would result into breaking compatibility with current minizip. |
||||
And since breaking compatibility in minizip is not wanted. I decided to create a fork of minizip |
||||
and create minizip64. |
||||
|
||||
Even though MiniZip64 is build from MiniZip, all functions and struct's have changed name so that it |
||||
would not collide with each other. |
||||
|
||||
|
||||
Background |
||||
--------------------- |
||||
When adding ZIP64 support I found that Even Rouault have added ZIP64 support for unzip.c into minizip |
||||
for a open source project called gdal ( http://www.gdal.org/ ) |
||||
|
||||
That was used as a starting point. And after that ZIP64 support was added to zip.c |
||||
some refactoring and code cleanup was also done. |
||||
|
||||
|
||||
Changed from MiniZip to MiniZip64 |
||||
------------------------------------- |
||||
* Filenames has got a '64' at the end of them . eg unzip.c is now called unzip64.c |
||||
* Added ZIP64 support for unzip ( by Even Rouault ) |
||||
* Added ZIP64 support for zip ( by Mathias Svensson ) |
||||
* Reverted some changed that Even Rouault did. |
||||
* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users. |
||||
* Added unzip patch for BZIP Compression method (patch create by Daniel Borca) |
||||
* Added BZIP Compress method for zip |
||||
* Did some refactoring and code cleanup |
||||
|
||||
|
||||
Credits |
||||
|
||||
Gilles Vollant - Original MiniZip author |
||||
Even Rouault - ZIP64 unzip Support |
||||
Daniel Borca - BZip Compression method support in unzip |
||||
Mathias Svensson - ZIP64 zip support |
||||
Mathias Svensson - BZip Compression method support in zip |
||||
|
||||
Resources |
||||
|
||||
ZipLayout http://result42.com/projects/ZipFileLayout |
||||
Command line tool for Windows that shows the layout and information of the headers in a zip archive. |
||||
Used when debugging and validating the creation of zip files using MiniZip64 |
||||
|
||||
|
||||
ZIP App Note http://www.pkware.com/documents/casestudies/APPNOTE.TXT |
||||
Zip File specification |
||||
|
||||
|
||||
Notes. |
||||
* To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined. |
||||
|
||||
License |
||||
---------------------------------------------------------- |
||||
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. |
||||
|
||||
---------------------------------------------------------- |
||||
|
||||
@ -1,281 +1,281 @@ |
||||
/*
|
||||
Additional tools for Minizip |
||||
Code: Xavier Roche '2004 |
||||
License: Same as ZLIB (www.gzip.org) |
||||
*/ |
||||
|
||||
/* Code */ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include "zlib.h" |
||||
#include "unzip.h" |
||||
|
||||
#define READ_8(adr) ((unsigned char)*(adr)) |
||||
#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) |
||||
#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) |
||||
|
||||
#define WRITE_8(buff, n) do { \ |
||||
*((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
|
||||
} while(0) |
||||
#define WRITE_16(buff, n) do { \ |
||||
WRITE_8((unsigned char*)(buff), n); \
|
||||
WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
|
||||
} while(0) |
||||
#define WRITE_32(buff, n) do { \ |
||||
WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
|
||||
WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
|
||||
} while(0) |
||||
|
||||
extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) |
||||
const char* file; |
||||
const char* fileOut; |
||||
const char* fileOutTmp; |
||||
uLong* nRecovered; |
||||
uLong* bytesRecovered; |
||||
{ |
||||
int err = Z_OK; |
||||
FILE* fpZip = fopen(file, "rb"); |
||||
FILE* fpOut = fopen(fileOut, "wb"); |
||||
FILE* fpOutCD = fopen(fileOutTmp, "wb"); |
||||
if (fpZip != NULL && fpOut != NULL) { |
||||
int entries = 0; |
||||
uLong totalBytes = 0; |
||||
char header[30]; |
||||
char filename[256]; |
||||
char extra[1024]; |
||||
int offset = 0; |
||||
int offsetCD = 0; |
||||
while ( fread(header, 1, 30, fpZip) == 30 ) { |
||||
int currentOffset = offset; |
||||
|
||||
/* File entry */ |
||||
if (READ_32(header) == 0x04034b50) { |
||||
unsigned int version = READ_16(header + 4); |
||||
unsigned int gpflag = READ_16(header + 6); |
||||
unsigned int method = READ_16(header + 8); |
||||
unsigned int filetime = READ_16(header + 10); |
||||
unsigned int filedate = READ_16(header + 12); |
||||
unsigned int crc = READ_32(header + 14); /* crc */ |
||||
unsigned int cpsize = READ_32(header + 18); /* compressed size */ |
||||
unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ |
||||
unsigned int fnsize = READ_16(header + 26); /* file name length */ |
||||
unsigned int extsize = READ_16(header + 28); /* extra field length */ |
||||
filename[0] = extra[0] = '\0'; |
||||
|
||||
/* Header */ |
||||
if (fwrite(header, 1, 30, fpOut) == 30) { |
||||
offset += 30; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
|
||||
/* Filename */ |
||||
if (fnsize > 0) { |
||||
if (fread(filename, 1, fnsize, fpZip) == fnsize) { |
||||
if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { |
||||
offset += fnsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_STREAM_ERROR; |
||||
break; |
||||
} |
||||
|
||||
/* Extra field */ |
||||
if (extsize > 0) { |
||||
if (fread(extra, 1, extsize, fpZip) == extsize) { |
||||
if (fwrite(extra, 1, extsize, fpOut) == extsize) { |
||||
offset += extsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Data */ |
||||
{ |
||||
int dataSize = cpsize; |
||||
if (dataSize == 0) { |
||||
dataSize = uncpsize; |
||||
} |
||||
if (dataSize > 0) { |
||||
char* data = malloc(dataSize); |
||||
if (data != NULL) { |
||||
if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { |
||||
if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { |
||||
offset += dataSize; |
||||
totalBytes += dataSize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
} |
||||
} else { |
||||
err = Z_ERRNO; |
||||
} |
||||
free(data); |
||||
if (err != Z_OK) { |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_MEM_ERROR; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* Central directory entry */ |
||||
{ |
||||
char header[46]; |
||||
char* comment = ""; |
||||
int comsize = (int) strlen(comment); |
||||
WRITE_32(header, 0x02014b50); |
||||
WRITE_16(header + 4, version); |
||||
WRITE_16(header + 6, version); |
||||
WRITE_16(header + 8, gpflag); |
||||
WRITE_16(header + 10, method); |
||||
WRITE_16(header + 12, filetime); |
||||
WRITE_16(header + 14, filedate); |
||||
WRITE_32(header + 16, crc); |
||||
WRITE_32(header + 20, cpsize); |
||||
WRITE_32(header + 24, uncpsize); |
||||
WRITE_16(header + 28, fnsize); |
||||
WRITE_16(header + 30, extsize); |
||||
WRITE_16(header + 32, comsize); |
||||
WRITE_16(header + 34, 0); /* disk # */ |
||||
WRITE_16(header + 36, 0); /* int attrb */ |
||||
WRITE_32(header + 38, 0); /* ext attrb */ |
||||
WRITE_32(header + 42, currentOffset); |
||||
/* Header */ |
||||
if (fwrite(header, 1, 46, fpOutCD) == 46) { |
||||
offsetCD += 46; |
||||
|
||||
/* Filename */ |
||||
if (fnsize > 0) { |
||||
if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { |
||||
offsetCD += fnsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_STREAM_ERROR; |
||||
break; |
||||
} |
||||
|
||||
/* Extra field */ |
||||
if (extsize > 0) { |
||||
if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { |
||||
offsetCD += extsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Comment field */ |
||||
if (comsize > 0) { |
||||
if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { |
||||
offsetCD += comsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
|
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Success */ |
||||
entries++; |
||||
|
||||
} else { |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Final central directory */ |
||||
{ |
||||
int entriesZip = entries; |
||||
char header[22]; |
||||
char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
|
||||
int comsize = (int) strlen(comment); |
||||
if (entriesZip > 0xffff) { |
||||
entriesZip = 0xffff; |
||||
} |
||||
WRITE_32(header, 0x06054b50); |
||||
WRITE_16(header + 4, 0); /* disk # */ |
||||
WRITE_16(header + 6, 0); /* disk # */ |
||||
WRITE_16(header + 8, entriesZip); /* hack */ |
||||
WRITE_16(header + 10, entriesZip); /* hack */ |
||||
WRITE_32(header + 12, offsetCD); /* size of CD */ |
||||
WRITE_32(header + 16, offset); /* offset to CD */ |
||||
WRITE_16(header + 20, comsize); /* comment */ |
||||
|
||||
/* Header */ |
||||
if (fwrite(header, 1, 22, fpOutCD) == 22) { |
||||
|
||||
/* Comment field */ |
||||
if (comsize > 0) { |
||||
if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { |
||||
err = Z_ERRNO; |
||||
} |
||||
} |
||||
|
||||
} else { |
||||
err = Z_ERRNO; |
||||
} |
||||
} |
||||
|
||||
/* Final merge (file + central directory) */ |
||||
fclose(fpOutCD); |
||||
if (err == Z_OK) { |
||||
fpOutCD = fopen(fileOutTmp, "rb"); |
||||
if (fpOutCD != NULL) { |
||||
int nRead; |
||||
char buffer[8192]; |
||||
while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { |
||||
if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
fclose(fpOutCD); |
||||
} |
||||
} |
||||
|
||||
/* Close */ |
||||
fclose(fpZip); |
||||
fclose(fpOut); |
||||
|
||||
/* Wipe temporary file */ |
||||
(void)remove(fileOutTmp); |
||||
|
||||
/* Number of recovered entries */ |
||||
if (err == Z_OK) { |
||||
if (nRecovered != NULL) { |
||||
*nRecovered = entries; |
||||
} |
||||
if (bytesRecovered != NULL) { |
||||
*bytesRecovered = totalBytes; |
||||
} |
||||
} |
||||
} else { |
||||
err = Z_STREAM_ERROR; |
||||
} |
||||
return err; |
||||
} |
||||
/*
|
||||
Additional tools for Minizip |
||||
Code: Xavier Roche '2004 |
||||
License: Same as ZLIB (www.gzip.org) |
||||
*/ |
||||
|
||||
/* Code */ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include "zlib.h" |
||||
#include "unzip.h" |
||||
|
||||
#define READ_8(adr) ((unsigned char)*(adr)) |
||||
#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) |
||||
#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) |
||||
|
||||
#define WRITE_8(buff, n) do { \ |
||||
*((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
|
||||
} while(0) |
||||
#define WRITE_16(buff, n) do { \ |
||||
WRITE_8((unsigned char*)(buff), n); \
|
||||
WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
|
||||
} while(0) |
||||
#define WRITE_32(buff, n) do { \ |
||||
WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
|
||||
WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
|
||||
} while(0) |
||||
|
||||
extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) |
||||
const char* file; |
||||
const char* fileOut; |
||||
const char* fileOutTmp; |
||||
uLong* nRecovered; |
||||
uLong* bytesRecovered; |
||||
{ |
||||
int err = Z_OK; |
||||
FILE* fpZip = fopen(file, "rb"); |
||||
FILE* fpOut = fopen(fileOut, "wb"); |
||||
FILE* fpOutCD = fopen(fileOutTmp, "wb"); |
||||
if (fpZip != NULL && fpOut != NULL) { |
||||
int entries = 0; |
||||
uLong totalBytes = 0; |
||||
char header[30]; |
||||
char filename[256]; |
||||
char extra[1024]; |
||||
int offset = 0; |
||||
int offsetCD = 0; |
||||
while ( fread(header, 1, 30, fpZip) == 30 ) { |
||||
int currentOffset = offset; |
||||
|
||||
/* File entry */ |
||||
if (READ_32(header) == 0x04034b50) { |
||||
unsigned int version = READ_16(header + 4); |
||||
unsigned int gpflag = READ_16(header + 6); |
||||
unsigned int method = READ_16(header + 8); |
||||
unsigned int filetime = READ_16(header + 10); |
||||
unsigned int filedate = READ_16(header + 12); |
||||
unsigned int crc = READ_32(header + 14); /* crc */ |
||||
unsigned int cpsize = READ_32(header + 18); /* compressed size */ |
||||
unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ |
||||
unsigned int fnsize = READ_16(header + 26); /* file name length */ |
||||
unsigned int extsize = READ_16(header + 28); /* extra field length */ |
||||
filename[0] = extra[0] = '\0'; |
||||
|
||||
/* Header */ |
||||
if (fwrite(header, 1, 30, fpOut) == 30) { |
||||
offset += 30; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
|
||||
/* Filename */ |
||||
if (fnsize > 0) { |
||||
if (fread(filename, 1, fnsize, fpZip) == fnsize) { |
||||
if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { |
||||
offset += fnsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_STREAM_ERROR; |
||||
break; |
||||
} |
||||
|
||||
/* Extra field */ |
||||
if (extsize > 0) { |
||||
if (fread(extra, 1, extsize, fpZip) == extsize) { |
||||
if (fwrite(extra, 1, extsize, fpOut) == extsize) { |
||||
offset += extsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Data */ |
||||
{ |
||||
int dataSize = cpsize; |
||||
if (dataSize == 0) { |
||||
dataSize = uncpsize; |
||||
} |
||||
if (dataSize > 0) { |
||||
char* data = malloc(dataSize); |
||||
if (data != NULL) { |
||||
if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { |
||||
if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { |
||||
offset += dataSize; |
||||
totalBytes += dataSize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
} |
||||
} else { |
||||
err = Z_ERRNO; |
||||
} |
||||
free(data); |
||||
if (err != Z_OK) { |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_MEM_ERROR; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* Central directory entry */ |
||||
{ |
||||
char header[46]; |
||||
char* comment = ""; |
||||
int comsize = (int) strlen(comment); |
||||
WRITE_32(header, 0x02014b50); |
||||
WRITE_16(header + 4, version); |
||||
WRITE_16(header + 6, version); |
||||
WRITE_16(header + 8, gpflag); |
||||
WRITE_16(header + 10, method); |
||||
WRITE_16(header + 12, filetime); |
||||
WRITE_16(header + 14, filedate); |
||||
WRITE_32(header + 16, crc); |
||||
WRITE_32(header + 20, cpsize); |
||||
WRITE_32(header + 24, uncpsize); |
||||
WRITE_16(header + 28, fnsize); |
||||
WRITE_16(header + 30, extsize); |
||||
WRITE_16(header + 32, comsize); |
||||
WRITE_16(header + 34, 0); /* disk # */ |
||||
WRITE_16(header + 36, 0); /* int attrb */ |
||||
WRITE_32(header + 38, 0); /* ext attrb */ |
||||
WRITE_32(header + 42, currentOffset); |
||||
/* Header */ |
||||
if (fwrite(header, 1, 46, fpOutCD) == 46) { |
||||
offsetCD += 46; |
||||
|
||||
/* Filename */ |
||||
if (fnsize > 0) { |
||||
if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { |
||||
offsetCD += fnsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} else { |
||||
err = Z_STREAM_ERROR; |
||||
break; |
||||
} |
||||
|
||||
/* Extra field */ |
||||
if (extsize > 0) { |
||||
if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { |
||||
offsetCD += extsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Comment field */ |
||||
if (comsize > 0) { |
||||
if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { |
||||
offsetCD += comsize; |
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
|
||||
} else { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Success */ |
||||
entries++; |
||||
|
||||
} else { |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/* Final central directory */ |
||||
{ |
||||
int entriesZip = entries; |
||||
char header[22]; |
||||
char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
|
||||
int comsize = (int) strlen(comment); |
||||
if (entriesZip > 0xffff) { |
||||
entriesZip = 0xffff; |
||||
} |
||||
WRITE_32(header, 0x06054b50); |
||||
WRITE_16(header + 4, 0); /* disk # */ |
||||
WRITE_16(header + 6, 0); /* disk # */ |
||||
WRITE_16(header + 8, entriesZip); /* hack */ |
||||
WRITE_16(header + 10, entriesZip); /* hack */ |
||||
WRITE_32(header + 12, offsetCD); /* size of CD */ |
||||
WRITE_32(header + 16, offset); /* offset to CD */ |
||||
WRITE_16(header + 20, comsize); /* comment */ |
||||
|
||||
/* Header */ |
||||
if (fwrite(header, 1, 22, fpOutCD) == 22) { |
||||
|
||||
/* Comment field */ |
||||
if (comsize > 0) { |
||||
if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { |
||||
err = Z_ERRNO; |
||||
} |
||||
} |
||||
|
||||
} else { |
||||
err = Z_ERRNO; |
||||
} |
||||
} |
||||
|
||||
/* Final merge (file + central directory) */ |
||||
fclose(fpOutCD); |
||||
if (err == Z_OK) { |
||||
fpOutCD = fopen(fileOutTmp, "rb"); |
||||
if (fpOutCD != NULL) { |
||||
int nRead; |
||||
char buffer[8192]; |
||||
while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { |
||||
if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { |
||||
err = Z_ERRNO; |
||||
break; |
||||
} |
||||
} |
||||
fclose(fpOutCD); |
||||
} |
||||
} |
||||
|
||||
/* Close */ |
||||
fclose(fpZip); |
||||
fclose(fpOut); |
||||
|
||||
/* Wipe temporary file */ |
||||
(void)remove(fileOutTmp); |
||||
|
||||
/* Number of recovered entries */ |
||||
if (err == Z_OK) { |
||||
if (nRecovered != NULL) { |
||||
*nRecovered = entries; |
||||
} |
||||
if (bytesRecovered != NULL) { |
||||
*bytesRecovered = totalBytes; |
||||
} |
||||
} |
||||
} else { |
||||
err = Z_STREAM_ERROR; |
||||
} |
||||
return err; |
||||
} |
||||
|
||||
@ -1,31 +1,31 @@ |
||||
/*
|
||||
Additional tools for Minizip |
||||
Code: Xavier Roche '2004 |
||||
License: Same as ZLIB (www.gzip.org) |
||||
*/ |
||||
|
||||
#ifndef _zip_tools_H |
||||
#define _zip_tools_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef _ZLIB_H |
||||
#include "zlib.h" |
||||
#endif |
||||
|
||||
#include "unzip.h" |
||||
|
||||
/* Repair a ZIP file (missing central directory)
|
||||
file: file to recover |
||||
fileOut: output file after recovery |
||||
fileOutTmp: temporary file name used for recovery |
||||
*/ |
||||
extern int ZEXPORT unzRepair(const char* file,
|
||||
const char* fileOut,
|
||||
const char* fileOutTmp,
|
||||
uLong* nRecovered, |
||||
uLong* bytesRecovered); |
||||
|
||||
#endif |
||||
/*
|
||||
Additional tools for Minizip |
||||
Code: Xavier Roche '2004 |
||||
License: Same as ZLIB (www.gzip.org) |
||||
*/ |
||||
|
||||
#ifndef _zip_tools_H |
||||
#define _zip_tools_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef _ZLIB_H |
||||
#include "zlib.h" |
||||
#endif |
||||
|
||||
#include "unzip.h" |
||||
|
||||
/* Repair a ZIP file (missing central directory)
|
||||
file: file to recover |
||||
fileOut: output file after recovery |
||||
fileOutTmp: temporary file name used for recovery |
||||
*/ |
||||
extern int ZEXPORT unzRepair(const char* file,
|
||||
const char* fileOut,
|
||||
const char* fileOutTmp,
|
||||
uLong* nRecovered, |
||||
uLong* bytesRecovered); |
||||
|
||||
#endif |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,332 @@ |
||||
/* zconf.h -- configuration of the zlib compression library
|
||||
* Copyright (C) 1995-2005 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 deflatePrime z_deflatePrime |
||||
# 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 inflateBack z_inflateBack |
||||
# define inflateBackEnd z_inflateBackEnd |
||||
# 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 zError z_zError |
||||
|
||||
# define alloc_func z_alloc_func |
||||
# define free_func z_free_func |
||||
# define in_func z_in_func |
||||
# define out_func z_out_func |
||||
# 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 |
||||
|
||||
#if defined(__MSDOS__) && !defined(MSDOS) |
||||
# define MSDOS |
||||
#endif |
||||
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) |
||||
# define OS2 |
||||
#endif |
||||
#if defined(_WINDOWS) && !defined(WINDOWS) |
||||
# define WINDOWS |
||||
#endif |
||||
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) |
||||
# ifndef WIN32 |
||||
# define WIN32 |
||||
# endif |
||||
#endif |
||||
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) |
||||
# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) |
||||
# ifndef SYS16BIT |
||||
# define SYS16BIT |
||||
# endif |
||||
# endif |
||||
#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). |
||||
*/ |
||||
#ifdef SYS16BIT |
||||
# define MAXSEG_64K |
||||
#endif |
||||
#ifdef MSDOS |
||||
# define UNALIGNED_OK |
||||
#endif |
||||
|
||||
#ifdef __STDC_VERSION__ |
||||
# ifndef STDC |
||||
# define STDC |
||||
# endif |
||||
# if __STDC_VERSION__ >= 199901L |
||||
# ifndef STDC99 |
||||
# define STDC99 |
||||
# endif |
||||
# endif |
||||
#endif |
||||
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) |
||||
# define STDC |
||||
#endif |
||||
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) |
||||
# define STDC |
||||
#endif |
||||
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) |
||||
# define STDC |
||||
#endif |
||||
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) |
||||
# define STDC |
||||
#endif |
||||
|
||||
#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ |
||||
# define STDC |
||||
#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 |
||||
|
||||
/* 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 |
||||
|
||||
/* 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. |
||||
*/ |
||||
#ifdef SYS16BIT |
||||
# if defined(M_I86SM) || defined(M_I86MM) |
||||
/* MSC small or medium model */ |
||||
# define SMALL_MEDIUM |
||||
# ifdef _MSC_VER |
||||
# define FAR _far |
||||
# else |
||||
# define FAR far |
||||
# endif |
||||
# endif |
||||
# if (defined(__SMALL__) || defined(__MEDIUM__)) |
||||
/* Turbo C small or medium model */ |
||||
# define SMALL_MEDIUM |
||||
# ifdef __BORLANDC__ |
||||
# define FAR _far |
||||
# else |
||||
# define FAR far |
||||
# endif |
||||
# endif |
||||
#endif |
||||
|
||||
#if defined(WINDOWS) || defined(WIN32) |
||||
/* If building or using zlib as a DLL, define ZLIB_DLL.
|
||||
* This is not mandatory, but it offers a little performance increase. |
||||
*/ |
||||
# ifdef ZLIB_DLL |
||||
# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) |
||||
# ifdef ZLIB_INTERNAL |
||||
# define ZEXTERN extern __declspec(dllexport) |
||||
# else |
||||
# define ZEXTERN extern __declspec(dllimport) |
||||
# endif |
||||
# endif |
||||
# endif /* ZLIB_DLL */ |
||||
/* If building or using zlib with the WINAPI/WINAPIV calling convention,
|
||||
* define ZLIB_WINAPI. |
||||
* Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. |
||||
*/ |
||||
# ifdef ZLIB_WINAPI |
||||
# ifdef FAR |
||||
# undef FAR |
||||
# endif |
||||
# include <windows.h> |
||||
/* No need for _export, use ZLIB.DEF instead. */ |
||||
/* For complete Windows compatibility, use WINAPI, not __stdcall. */ |
||||
# define ZEXPORT WINAPI |
||||
# ifdef WIN32 |
||||
# define ZEXPORTVA WINAPIV |
||||
# else |
||||
# define ZEXPORTVA FAR CDECL |
||||
# endif |
||||
# endif |
||||
#endif |
||||
|
||||
#if defined (__BEOS__) |
||||
# 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 |
||||
|
||||
#ifndef ZEXTERN |
||||
# define ZEXTERN extern |
||||
#endif |
||||
#ifndef ZEXPORT |
||||
# define ZEXPORT |
||||
#endif |
||||
#ifndef ZEXPORTVA |
||||
# define ZEXPORTVA |
||||
#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 |
||||
|
||||
#if defined(__OS400__) |
||||
# define NO_vsnprintf |
||||
#endif |
||||
|
||||
#if defined(__MVS__) |
||||
# define NO_vsnprintf |
||||
# ifdef FAR |
||||
# undef FAR |
||||
# endif |
||||
#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 */ |
||||
@ -0,0 +1,332 @@ |
||||
/* zconf.h -- configuration of the zlib compression library
|
||||
* Copyright (C) 1995-2005 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 deflatePrime z_deflatePrime |
||||
# 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 inflateBack z_inflateBack |
||||
# define inflateBackEnd z_inflateBackEnd |
||||
# 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 zError z_zError |
||||
|
||||
# define alloc_func z_alloc_func |
||||
# define free_func z_free_func |
||||
# define in_func z_in_func |
||||
# define out_func z_out_func |
||||
# 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 |
||||
|
||||
#if defined(__MSDOS__) && !defined(MSDOS) |
||||
# define MSDOS |
||||
#endif |
||||
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) |
||||
# define OS2 |
||||
#endif |
||||
#if defined(_WINDOWS) && !defined(WINDOWS) |
||||
# define WINDOWS |
||||
#endif |
||||
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) |
||||
# ifndef WIN32 |
||||
# define WIN32 |
||||
# endif |
||||
#endif |
||||
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) |
||||
# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) |
||||
# ifndef SYS16BIT |
||||
# define SYS16BIT |
||||
# endif |
||||
# endif |
||||
#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). |
||||
*/ |
||||
#ifdef SYS16BIT |
||||
# define MAXSEG_64K |
||||
#endif |
||||
#ifdef MSDOS |
||||
# define UNALIGNED_OK |
||||
#endif |
||||
|
||||
#ifdef __STDC_VERSION__ |
||||
# ifndef STDC |
||||
# define STDC |
||||
# endif |
||||
# if __STDC_VERSION__ >= 199901L |
||||
# ifndef STDC99 |
||||
# define STDC99 |
||||
# endif |
||||
# endif |
||||
#endif |
||||
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) |
||||
# define STDC |
||||
#endif |
||||
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) |
||||
# define STDC |
||||
#endif |
||||
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) |
||||
# define STDC |
||||
#endif |
||||
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) |
||||
# define STDC |
||||
#endif |
||||
|
||||
#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ |
||||
# define STDC |
||||
#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 |
||||
|
||||
/* 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 |
||||
|
||||
/* 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. |
||||
*/ |
||||
#ifdef SYS16BIT |
||||
# if defined(M_I86SM) || defined(M_I86MM) |
||||
/* MSC small or medium model */ |
||||
# define SMALL_MEDIUM |
||||
# ifdef _MSC_VER |
||||
# define FAR _far |
||||
# else |
||||
# define FAR far |
||||
# endif |
||||
# endif |
||||
# if (defined(__SMALL__) || defined(__MEDIUM__)) |
||||
/* Turbo C small or medium model */ |
||||
# define SMALL_MEDIUM |
||||
# ifdef __BORLANDC__ |
||||
# define FAR _far |
||||
# else |
||||
# define FAR far |
||||
# endif |
||||
# endif |
||||
#endif |
||||
|
||||
#if defined(WINDOWS) || defined(WIN32) |
||||
/* If building or using zlib as a DLL, define ZLIB_DLL.
|
||||
* This is not mandatory, but it offers a little performance increase. |
||||
*/ |
||||
# ifdef ZLIB_DLL |
||||
# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) |
||||
# ifdef ZLIB_INTERNAL |
||||
# define ZEXTERN extern __declspec(dllexport) |
||||
# else |
||||
# define ZEXTERN extern __declspec(dllimport) |
||||
# endif |
||||
# endif |
||||
# endif /* ZLIB_DLL */ |
||||
/* If building or using zlib with the WINAPI/WINAPIV calling convention,
|
||||
* define ZLIB_WINAPI. |
||||
* Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. |
||||
*/ |
||||
# ifdef ZLIB_WINAPI |
||||
# ifdef FAR |
||||
# undef FAR |
||||
# endif |
||||
# include <windows.h> |
||||
/* No need for _export, use ZLIB.DEF instead. */ |
||||
/* For complete Windows compatibility, use WINAPI, not __stdcall. */ |
||||
# define ZEXPORT WINAPI |
||||
# ifdef WIN32 |
||||
# define ZEXPORTVA WINAPIV |
||||
# else |
||||
# define ZEXPORTVA FAR CDECL |
||||
# endif |
||||
# endif |
||||
#endif |
||||
|
||||
#if defined (__BEOS__) |
||||
# 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 |
||||
|
||||
#ifndef ZEXTERN |
||||
# define ZEXTERN extern |
||||
#endif |
||||
#ifndef ZEXPORT |
||||
# define ZEXPORT |
||||
#endif |
||||
#ifndef ZEXPORTVA |
||||
# define ZEXPORTVA |
||||
#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 |
||||
|
||||
#if defined(__OS400__) |
||||
# define NO_vsnprintf |
||||
#endif |
||||
|
||||
#if defined(__MVS__) |
||||
# define NO_vsnprintf |
||||
# ifdef FAR |
||||
# undef FAR |
||||
# endif |
||||
#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
@ -0,0 +1,29 @@ |
||||
/* gzclose.c -- zlib gzclose() function
|
||||
* Copyright (C) 2004, 2010 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#ifndef OLD_GZIO |
||||
|
||||
#include "gzguts.h" |
||||
|
||||
/* gzclose() is in a separate file so that it is linked in only if it is used.
|
||||
That way the other gzclose functions can be used instead to avoid linking in |
||||
unneeded compression or decompression routines. */ |
||||
int ZEXPORT gzclose(file) |
||||
gzFile file; |
||||
{ |
||||
#ifndef NO_GZCOMPRESS |
||||
gz_statep state; |
||||
|
||||
if (file == NULL) |
||||
return EOF; |
||||
state = (gz_statep)file; |
||||
|
||||
return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); |
||||
#else |
||||
return gzclose_r(file); |
||||
#endif |
||||
} |
||||
|
||||
#endif /* !OLD_GZIO */ |
||||
@ -0,0 +1,109 @@ |
||||
/* gzguts.h -- zlib internal header definitions for gz* operations
|
||||
* Copyright (C) 2004, 2005, 2010 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#ifdef _LARGEFILE64_SOURCE |
||||
# ifndef _LARGEFILE_SOURCE |
||||
# define _LARGEFILE_SOURCE |
||||
# endif |
||||
# ifdef _FILE_OFFSET_BITS |
||||
# undef _FILE_OFFSET_BITS |
||||
# endif |
||||
#endif |
||||
|
||||
#define ZLIB_INTERNAL |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <fcntl.h> |
||||
#include "zlib.h" |
||||
|
||||
#ifdef NO_DEFLATE /* for compatibility with old definition */ |
||||
# define NO_GZCOMPRESS |
||||
#endif |
||||
|
||||
#ifdef WIN32 |
||||
# include <io.h> |
||||
# define vsnprintf _vsnprintf |
||||
#endif |
||||
|
||||
#ifndef local |
||||
# define local static |
||||
#endif |
||||
/* compile with -Dlocal if your debugger can't find static symbols */ |
||||
|
||||
/* gz* functions always use library allocation functions */ |
||||
#ifndef STDC |
||||
extern voidp malloc OF((uInt size)); |
||||
extern void free OF((voidpf ptr)); |
||||
#endif |
||||
|
||||
/* get errno and strerror definition */ |
||||
#if defined UNDER_CE && defined NO_ERRNO_H |
||||
# define zstrerror(errnum) strwinerror((DWORD)errnum) |
||||
#else |
||||
# ifdef STDC |
||||
# include <errno.h> |
||||
# define zstrerror() strerror(errno) |
||||
# else |
||||
# define zstrerror() "stdio error (consult errno)" |
||||
# endif |
||||
#endif |
||||
|
||||
/* MVS fdopen() */ |
||||
#ifdef __MVS__ |
||||
# pragma map (fdopen , "\174\174FDOPEN") |
||||
FILE *fdopen(int, const char *); |
||||
#endif |
||||
|
||||
#ifdef _LARGEFILE64_SOURCE |
||||
# define z_off64_t off64_t |
||||
#else |
||||
# define z_off64_t z_off_t |
||||
#endif |
||||
|
||||
/* default i/o buffer size -- double this for output when reading */ |
||||
#define GZBUFSIZE 8192 |
||||
|
||||
/* gzip modes, also provide a little integrity check on the passed structure */ |
||||
#define GZ_NONE 0 |
||||
#define GZ_READ 7247 |
||||
#define GZ_WRITE 31153 |
||||
#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ |
||||
|
||||
/* internal gzip file state data structure */ |
||||
typedef struct { |
||||
/* used for both reading and writing */ |
||||
int mode; /* see gzip modes above */ |
||||
int fd; /* file descriptor */ |
||||
char *path; /* path or fd for error messages */ |
||||
z_off64_t pos; /* current position in uncompressed data */ |
||||
unsigned size; /* buffer size, zero if not allocated yet */ |
||||
unsigned want; /* requested buffer size, default is GZBUFSIZE */ |
||||
unsigned char *in; /* input buffer */ |
||||
unsigned char *out; /* output buffer (double-sized when reading) */ |
||||
unsigned char *next; /* next output data to deliver or write */ |
||||
/* just for reading */ |
||||
int how; /* 0: get header, 1: copy, 2: decompress */ |
||||
unsigned have; /* amount of output data unused */ |
||||
z_off64_t start; /* where the gzip data started, for rewinding */ |
||||
z_off64_t raw; /* where the raw data started, for seeking */ |
||||
int eof; /* true if end of input file reached */ |
||||
/* just for writing */ |
||||
int level; /* compression level */ |
||||
int strategy; /* compression strategy */ |
||||
/* seek request */ |
||||
int seek; /* true if seek request pending */ |
||||
z_off64_t skip; /* amount to skip (already rewound if backwards) */ |
||||
/* error information */ |
||||
int err; /* error code */ |
||||
char *msg; /* error message */ |
||||
/* zlib inflate or deflate stream */ |
||||
z_stream strm; /* stream structure in-place (not a pointer) */ |
||||
} gz_state; |
||||
typedef gz_state FAR *gz_statep; |
||||
|
||||
/* shared functions */ |
||||
ZEXTERN void ZEXPORT gz_error OF((gz_statep, int, char *)); |
||||
@ -0,0 +1,513 @@ |
||||
/* gzlib.c -- zlib functions common to reading and writing gzip files
|
||||
* Copyright (C) 2004, 2010 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#ifndef OLD_GZIO |
||||
|
||||
#include "gzguts.h" |
||||
|
||||
#ifdef _LARGEFILE64_SOURCE |
||||
# define LSEEK lseek64 |
||||
#else |
||||
# define LSEEK lseek |
||||
#endif |
||||
|
||||
/* Local functions */ |
||||
local void gz_reset OF((gz_statep)); |
||||
local gzFile gz_open OF((const char *, int, const char *, int)); |
||||
|
||||
#if defined UNDER_CE && defined NO_ERRNO_H |
||||
local char *strwinerror OF((DWORD error)); |
||||
|
||||
# include <windows.h> |
||||
|
||||
/* Map the Windows error number in ERROR to a locale-dependent error
|
||||
message string and return a pointer to it. Typically, the values |
||||
for ERROR come from GetLastError. |
||||
|
||||
The string pointed to shall not be modified by the application, |
||||
but may be overwritten by a subsequent call to strwinerror |
||||
|
||||
The strwinerror function does not change the current setting |
||||
of GetLastError. */ |
||||
|
||||
local char *strwinerror (error) |
||||
DWORD error; |
||||
{ |
||||
static char buf[1024]; |
||||
|
||||
wchar_t *msgbuf; |
||||
DWORD lasterr = GetLastError(); |
||||
DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
||||
| FORMAT_MESSAGE_ALLOCATE_BUFFER, |
||||
NULL, |
||||
error, |
||||
0, /* Default language */ |
||||
(LPVOID)&msgbuf, |
||||
0, |
||||
NULL); |
||||
if (chars != 0) { |
||||
/* If there is an \r\n appended, zap it. */ |
||||
if (chars >= 2 |
||||
&& msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { |
||||
chars -= 2; |
||||
msgbuf[chars] = 0; |
||||
} |
||||
|
||||
if (chars > sizeof (buf) - 1) { |
||||
chars = sizeof (buf) - 1; |
||||
msgbuf[chars] = 0; |
||||
} |
||||
|
||||
wcstombs(buf, msgbuf, chars + 1); |
||||
LocalFree(msgbuf); |
||||
} |
||||
else { |
||||
sprintf(buf, "unknown win32 error (%ld)", error); |
||||
} |
||||
|
||||
SetLastError(lasterr); |
||||
return buf; |
||||
} |
||||
|
||||
#endif /* UNDER_CE && NO_ERRNO_H */ |
||||
|
||||
/* Reset gzip file state */ |
||||
local void gz_reset(state) |
||||
gz_statep state; |
||||
{ |
||||
state->how = 0; /* look for gzip header */ |
||||
if (state->mode == GZ_READ) { /* for reading ... */ |
||||
state->have = 0; /* no output data available */ |
||||
state->eof = 0; /* not at end of file */ |
||||
} |
||||
state->seek = 0; /* no seek request pending */ |
||||
gz_error(state, Z_OK, NULL); /* clear error */ |
||||
state->pos = 0; /* no uncompressed data yet */ |
||||
state->strm.avail_in = 0; /* no input data yet */ |
||||
} |
||||
|
||||
/* Open a gzip file either by name or file descriptor. */ |
||||
local gzFile gz_open(path, fd, mode, use64) |
||||
const char *path; |
||||
int fd; |
||||
const char *mode; |
||||
int use64; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* allocate gzFile structure to return */ |
||||
state = malloc(sizeof(gz_state)); |
||||
if (state == NULL) |
||||
return NULL; |
||||
state->size = 0; /* no buffers allocated yet */ |
||||
state->want = GZBUFSIZE; /* requested buffer size */ |
||||
state->msg = NULL; /* no error message yet */ |
||||
|
||||
/* interpret mode */ |
||||
state->mode = GZ_NONE; |
||||
state->level = Z_DEFAULT_COMPRESSION; |
||||
state->strategy = Z_DEFAULT_STRATEGY; |
||||
while (*mode) { |
||||
if (*mode >= '0' && *mode <= '9') |
||||
state->level = *mode - '0'; |
||||
else |
||||
switch (*mode) { |
||||
case 'r': |
||||
state->mode = GZ_READ; |
||||
break; |
||||
#ifndef NO_GZCOMPRESS |
||||
case 'w': |
||||
state->mode = GZ_WRITE; |
||||
break; |
||||
case 'a': |
||||
state->mode = GZ_APPEND; |
||||
break; |
||||
#endif |
||||
case '+': /* can't read and write at the same time */ |
||||
free(state); |
||||
return NULL; |
||||
case 'b': /* ignore -- will request binary anyway */ |
||||
break; |
||||
case 'f': |
||||
state->strategy = Z_FILTERED; |
||||
break; |
||||
case 'h': |
||||
state->strategy = Z_HUFFMAN_ONLY; |
||||
break; |
||||
case 'R': |
||||
state->strategy = Z_RLE; |
||||
break; |
||||
case 'F': |
||||
state->strategy = Z_FIXED; |
||||
default: /* could consider as an error, but just ignore */ |
||||
; |
||||
} |
||||
mode++; |
||||
} |
||||
|
||||
/* must provide an "r", "w", or "a" */ |
||||
if (state->mode == GZ_NONE) { |
||||
free(state); |
||||
return NULL; |
||||
} |
||||
|
||||
/* open the file with the appropriate mode (or just use fd) */ |
||||
state->fd = fd != -1 ? fd : |
||||
open(path, |
||||
#ifdef O_LARGEFILE |
||||
(use64 ? O_LARGEFILE : 0) | |
||||
#endif |
||||
#ifdef O_BINARY |
||||
O_BINARY | |
||||
#endif |
||||
(state->mode == GZ_READ ? |
||||
O_RDONLY : |
||||
(O_WRONLY | O_CREAT | ( |
||||
state->mode == GZ_WRITE ? |
||||
O_TRUNC : |
||||
O_APPEND))), |
||||
0666); |
||||
if (state->fd == -1) { |
||||
free(state); |
||||
return NULL; |
||||
} |
||||
if (state->mode == GZ_APPEND) |
||||
state->mode = GZ_WRITE; /* simplify later checks */ |
||||
|
||||
/* save the path name for error messages */ |
||||
state->path = malloc(strlen(path) + 1); |
||||
strcpy(state->path, path); |
||||
|
||||
/* save the current position for rewinding (only if reading) */ |
||||
if (state->mode == GZ_READ) { |
||||
state->start = LSEEK(state->fd, 0, SEEK_CUR); |
||||
if (state->start == -1) state->start = 0; |
||||
} |
||||
|
||||
/* initialize stream */ |
||||
gz_reset(state); |
||||
|
||||
/* return stream */ |
||||
return (gzFile)state; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
gzFile ZEXPORT gzopen(path, mode) |
||||
const char *path; |
||||
const char *mode; |
||||
{ |
||||
return gz_open(path, -1, mode, 0); |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
gzFile ZEXPORT gzopen64(path, mode) |
||||
const char *path; |
||||
const char *mode; |
||||
{ |
||||
return gz_open(path, -1, mode, 1); |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
gzFile ZEXPORT gzdopen(fd, mode) |
||||
int fd; |
||||
const char *mode; |
||||
{ |
||||
char path[46]; /* allow up to 128-bit integers, so don't worry --
|
||||
the sprintf() is safe */ |
||||
|
||||
if (fd < 0) |
||||
return NULL; |
||||
sprintf(path, "<fd:%d>", fd); /* for error messages */ |
||||
return gz_open(path, fd, mode, 1); |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzbuffer(file, size) |
||||
gzFile file; |
||||
unsigned size; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return -1; |
||||
|
||||
/* make sure we haven't already allocated memory */ |
||||
if (state->size != 0) |
||||
return -1; |
||||
|
||||
/* check and set requested size */ |
||||
if (size == 0) |
||||
return -1; |
||||
state->want = size; |
||||
return 0; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzrewind(file) |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're reading and that there's no error */ |
||||
if (state->mode != GZ_READ || state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* back up and start over */ |
||||
if (LSEEK(state->fd, state->start, SEEK_SET) == -1) |
||||
return -1; |
||||
gz_reset(state); |
||||
return 0; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
z_off64_t ZEXPORT gzseek64(file, offset, whence) |
||||
gzFile file; |
||||
z_off64_t offset; |
||||
int whence; |
||||
{ |
||||
unsigned n; |
||||
z_off64_t ret; |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return -1; |
||||
|
||||
/* check that there's no error */ |
||||
if (state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* can only seek from start or relative to current position */ |
||||
if (whence != SEEK_SET && whence != SEEK_CUR) |
||||
return -1; |
||||
|
||||
/* normalize offset to a SEEK_CUR specification */ |
||||
if (whence == SEEK_SET) |
||||
offset -= state->pos; |
||||
|
||||
/* if within raw area while reading, just go there */ |
||||
if (state->mode == GZ_READ && state->how == 1 && |
||||
state->pos + offset >= state->raw) { |
||||
ret = LSEEK(state->fd, offset, SEEK_CUR); |
||||
if (ret == -1) |
||||
return -1; |
||||
state->have = 0; |
||||
state->eof = 0; |
||||
state->seek = 0; |
||||
gz_error(state, Z_OK, NULL); |
||||
state->strm.avail_in = 0; |
||||
state->pos += offset; |
||||
return state->pos; |
||||
} |
||||
|
||||
/* calculate skip amount, rewinding if needed for back seek when reading */ |
||||
if (offset < 0) { |
||||
if (state->mode != GZ_READ) /* writing -- can't go backwards */ |
||||
return -1; |
||||
offset += state->pos; |
||||
if (offset < 0) /* before start of file! */ |
||||
return -1; |
||||
if (gzrewind(file) == -1) /* rewind, then skip to offset */ |
||||
return -1; |
||||
} |
||||
|
||||
/* if reading, skip what's in output buffer (one less gz_getc() check) */ |
||||
if (state->mode == GZ_READ) { |
||||
n = state->have > offset ? (unsigned)offset : state->have; |
||||
state->have -= n; |
||||
state->next += n; |
||||
state->pos += n; |
||||
offset -= n; |
||||
} |
||||
|
||||
/* request skip (if not zero) */ |
||||
if (offset) { |
||||
state->seek = 1; |
||||
state->skip = offset; |
||||
} |
||||
return state->pos + offset; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
z_off_t ZEXPORT gzseek(file, offset, whence) |
||||
gzFile file; |
||||
z_off_t offset; |
||||
int whence; |
||||
{ |
||||
z_off64_t ret; |
||||
|
||||
ret = gzseek64(file, (z_off64_t)offset, whence); |
||||
return ret == (z_off_t)ret ? (z_off_t)ret : -1; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
z_off64_t ZEXPORT gztell64(file) |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return -1; |
||||
|
||||
/* return position */ |
||||
return state->pos + (state->seek ? state->skip : 0); |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
z_off_t ZEXPORT gztell(file) |
||||
gzFile file; |
||||
{ |
||||
z_off64_t ret; |
||||
|
||||
ret = gztell64(file); |
||||
return ret == (z_off_t)ret ? (z_off_t)ret : -1; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
z_off64_t ZEXPORT gzoffset64(file) |
||||
gzFile file; |
||||
{ |
||||
z_off64_t offset; |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return -1; |
||||
|
||||
/* compute and return effective offset in file */ |
||||
offset = LSEEK(state->fd, 0, SEEK_CUR); |
||||
if (offset == -1) |
||||
return -1; |
||||
if (state->mode == GZ_READ) /* reading */ |
||||
offset -= state->strm.avail_in; /* don't count buffered input */ |
||||
return offset; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
z_off_t ZEXPORT gzoffset(file) |
||||
gzFile file; |
||||
{ |
||||
z_off64_t ret; |
||||
|
||||
ret = gzoffset64(file); |
||||
return ret == (z_off_t)ret ? (z_off_t)ret : -1; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzeof(file) |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return -1; |
||||
|
||||
/* return end-of-file state */ |
||||
return state->mode == GZ_READ ? (state->eof && state->have == 0) : 0; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
const char * ZEXPORT gzerror(file, errnum) |
||||
gzFile file; |
||||
int *errnum; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return NULL; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return NULL; |
||||
|
||||
/* return error information */ |
||||
*errnum = state->err; |
||||
return state->msg == NULL ? "" : state->msg; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
void ZEXPORT gzclearerr(file) |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure and check integrity */ |
||||
if (file == NULL) |
||||
return; |
||||
state = (gz_statep)file; |
||||
if (state->mode != GZ_READ && state->mode != GZ_WRITE) |
||||
return; |
||||
|
||||
/* clear error and end-of-file */ |
||||
if (state->mode == GZ_READ) |
||||
state->eof = 0; |
||||
gz_error(state, Z_OK, NULL); |
||||
} |
||||
|
||||
/* Create an error message in allocated memory and set state->err and
|
||||
state->msg accordingly. Free any previous error message already there. Do |
||||
not try to free or allocate space if the error is Z_MEM_ERROR (out of |
||||
memory). Simply save the error message as a static string. If there is |
||||
an allocation failure constructing the error message, then convert the |
||||
error to out of memory. */ |
||||
void ZEXPORT gz_error(state, err, msg) |
||||
gz_statep state; |
||||
int err; |
||||
char *msg; |
||||
{ |
||||
/* free previously allocated message and clear */ |
||||
if (state->msg != NULL) { |
||||
if (state->err != Z_MEM_ERROR) |
||||
free(state->msg); |
||||
state->msg = NULL; |
||||
} |
||||
|
||||
/* set error code, and if no message, then done */ |
||||
state->err = err; |
||||
if (msg == NULL) |
||||
return; |
||||
|
||||
/* for an out of memory error, save as static string */ |
||||
if (err == Z_MEM_ERROR) { |
||||
state->msg = msg; |
||||
return; |
||||
} |
||||
|
||||
/* construct error message with path */ |
||||
if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) { |
||||
state->err = Z_MEM_ERROR; |
||||
state->msg = "out of memory"; |
||||
return; |
||||
} |
||||
strcpy(state->msg, state->path); |
||||
strcat(state->msg, ": "); |
||||
strcat(state->msg, msg); |
||||
return; |
||||
} |
||||
|
||||
#endif /* !OLD_GZIO */ |
||||
@ -0,0 +1,632 @@ |
||||
/* gzread.c -- zlib functions for reading gzip files
|
||||
* Copyright (C) 2004, 2005, 2010 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#ifndef OLD_GZIO |
||||
|
||||
#include "gzguts.h" |
||||
|
||||
/* Local functions */ |
||||
local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); |
||||
local int gz_avail OF((gz_statep)); |
||||
local int gz_next4 OF((gz_statep, unsigned long *)); |
||||
local int gz_head OF((gz_statep)); |
||||
local int gz_decomp OF((gz_statep)); |
||||
local int gz_make OF((gz_statep)); |
||||
local int gz_skip OF((gz_statep, z_off_t)); |
||||
|
||||
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
|
||||
state->fd, and update state->eof, state->err, and state->msg as appropriate. |
||||
This function needs to loop on read(), since read() is not guaranteed to |
||||
read the number of bytes requested, depending on the type of descriptor. */ |
||||
local int gz_load(state, buf, len, have) |
||||
gz_statep state; |
||||
unsigned char *buf; |
||||
unsigned len; |
||||
unsigned *have; |
||||
{ |
||||
int ret; |
||||
|
||||
*have = 0; |
||||
do { |
||||
ret = read(state->fd, buf + *have, len - *have); |
||||
if (ret <= 0) |
||||
break; |
||||
*have += ret; |
||||
} while (*have < len); |
||||
if (ret < 0) { |
||||
gz_error(state, Z_ERRNO, zstrerror()); |
||||
return -1; |
||||
} |
||||
if (ret == 0) |
||||
state->eof = 1; |
||||
return 0; |
||||
} |
||||
|
||||
/* Load up input buffer and set eof flag if last data loaded -- return -1 on
|
||||
error, 0 otherwise. Note that the eof flag is set when the end of the input |
||||
file is reached, even though there may be unused data in the buffer. Once |
||||
that data has been used, no more attempts will be made to read the file. |
||||
gz_avail() assumes that strm->avail_in == 0. */ |
||||
local int gz_avail(state) |
||||
gz_statep state; |
||||
{ |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
if (state->err != Z_OK) |
||||
return -1; |
||||
if (state->eof == 0) { |
||||
if (gz_load(state, state->in, state->size, &(strm->avail_in)) == -1) |
||||
return -1; |
||||
strm->next_in = state->in; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
/* Get next byte from input, or -1 if end or error. */ |
||||
#define NEXT() ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \ |
||||
(strm->avail_in == 0 ? -1 : \
|
||||
(strm->avail_in--, *(strm->next_in)++))) |
||||
|
||||
/* Get a four-byte little-endian integer and return 0 on success and the
|
||||
value in *ret. Otherwise -1 is returned and *ret is not modified. */ |
||||
local int gz_next4(state, ret) |
||||
gz_statep state; |
||||
unsigned long *ret; |
||||
{ |
||||
int ch; |
||||
unsigned long val; |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
val = NEXT(); |
||||
val += (unsigned)NEXT() << 8; |
||||
val += (unsigned long)NEXT() << 16; |
||||
ch = NEXT(); |
||||
if (ch == -1) |
||||
return -1; |
||||
val += (unsigned long)ch << 24; |
||||
*ret = val; |
||||
return 0; |
||||
} |
||||
|
||||
/* Look for gzip header, set up for inflate or copy. state->have must be zero.
|
||||
If this is the first time in, allocate required memory. state->how will be |
||||
left unchanged if there is no more input data available, will be set to 1 if |
||||
there is no gzip header and direct copying will be performned, or it will be |
||||
set to 2 for decompression, and the gzip header will be skipped so that the |
||||
next available input data is the raw deflate stream. If direct copying, |
||||
then leftover input data from the input buffer will be copied to the output |
||||
buffer. In that case, all further file reads will be directly to either the |
||||
output buffer or a user buffer. If decompressing, the inflate state and the |
||||
check value will be initialized. gz_head() will return 0 on success or -1 |
||||
on failure. Failures may include read errors or gzip header errors. */ |
||||
local int gz_head(state) |
||||
gz_statep state; |
||||
{ |
||||
z_streamp strm = &(state->strm); |
||||
int flags; |
||||
unsigned len; |
||||
|
||||
/* allocate read buffers and inflate memory */ |
||||
if (state->size == 0) { |
||||
/* allocate buffers */ |
||||
state->in = malloc(state->want); |
||||
state->out = malloc(state->want << 1); |
||||
if (state->in == NULL || state->out == NULL) { |
||||
if (state->out != NULL) |
||||
free(state->out); |
||||
if (state->in != NULL) |
||||
free(state->in); |
||||
gz_error(state, Z_MEM_ERROR, "out of memory"); |
||||
return -1; |
||||
} |
||||
state->size = state->want; |
||||
|
||||
/* allocate inflate memory */ |
||||
state->strm.zalloc = Z_NULL; |
||||
state->strm.zfree = Z_NULL; |
||||
state->strm.opaque = Z_NULL; |
||||
state->strm.avail_in = 0; |
||||
state->strm.next_in = Z_NULL; |
||||
if (inflateInit2(&(state->strm), -15) != Z_OK) { /* raw inflate */ |
||||
free(state->out); |
||||
free(state->in); |
||||
state->size = 0; |
||||
gz_error(state, Z_MEM_ERROR, "out of memory"); |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
/* get some data in the input buffer */ |
||||
if (strm->avail_in == 0) { |
||||
if (gz_avail(state) == -1) |
||||
return -1; |
||||
if (strm->avail_in == 0) |
||||
return 0; |
||||
} |
||||
|
||||
/* look for the gzip magic header bytes 31 and 139 */ |
||||
if (strm->next_in[0] == 31) { |
||||
strm->avail_in--; |
||||
strm->next_in++; |
||||
if (strm->avail_in == 0 && gz_avail(state) == -1) |
||||
return -1; |
||||
if (strm->avail_in && strm->next_in[0] == 139) { |
||||
/* we have a gzip header, woo hoo! */ |
||||
strm->avail_in--; |
||||
strm->next_in++; |
||||
|
||||
/* skip rest of header */ |
||||
if (NEXT() != 8) { /* compression method */ |
||||
gz_error(state, Z_DATA_ERROR, "unknown compression method"); |
||||
return -1; |
||||
} |
||||
flags = NEXT(); |
||||
if (flags & 0xe0) { /* reserved flag bits */ |
||||
gz_error(state, Z_DATA_ERROR, "unknown header flags set"); |
||||
return -1; |
||||
} |
||||
NEXT(); /* modification time */ |
||||
NEXT(); |
||||
NEXT(); |
||||
NEXT(); |
||||
NEXT(); /* extra flags */ |
||||
NEXT(); /* operating system */ |
||||
if (flags & 4) { /* extra field */ |
||||
len = (unsigned)NEXT(); |
||||
len += (unsigned)NEXT() << 8; |
||||
while (len--) |
||||
if (NEXT() < 0) |
||||
break; |
||||
} |
||||
if (flags & 8) /* file name */ |
||||
while (NEXT() > 0) |
||||
; |
||||
if (flags & 16) /* comment */ |
||||
while (NEXT() > 0) |
||||
; |
||||
if (flags & 2) { /* header crc */ |
||||
NEXT(); |
||||
NEXT(); |
||||
} |
||||
|
||||
/* set up for decompression */ |
||||
inflateReset(strm); |
||||
strm->adler = crc32(0L, Z_NULL, 0); |
||||
state->how = 2; |
||||
return 0; |
||||
} |
||||
else { |
||||
/* not a gzip file -- save first byte (31) and fall to raw i/o */ |
||||
state->out[0] = 31; |
||||
state->have = 1; |
||||
} |
||||
} |
||||
|
||||
/* doing raw i/o, save start of raw data for seeking, copy any leftover
|
||||
input to output -- this assumes that the output buffer is larger than |
||||
the input buffer */ |
||||
state->raw = state->pos; |
||||
state->next = state->out; |
||||
if (strm->avail_in) { |
||||
memcpy(state->next + state->have, strm->next_in, strm->avail_in); |
||||
state->have += strm->avail_in; |
||||
strm->avail_in = 0; |
||||
} |
||||
state->how = 1; |
||||
return 0; |
||||
} |
||||
|
||||
/* Decompress from input to the provided next_out and avail_out in the state.
|
||||
If the end of the compressed data is reached, then verify the gzip trailer |
||||
check value and length (modulo 2^32). state->have and state->next are |
||||
set to point to the just decompressed data, and the crc is updated. If the |
||||
trailer is verified, state->how is reset to zero to look for the next gzip |
||||
stream or raw data, once state->have is depleted. Returns 0 on success, -1 |
||||
on failure. Failures may include invalid compressed data or a failed gzip |
||||
trailer verification. */ |
||||
local int gz_decomp(state) |
||||
gz_statep state; |
||||
{ |
||||
int ret; |
||||
unsigned had; |
||||
unsigned long crc, len; |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
/* fill output buffer up to end of deflate stream */ |
||||
had = strm->avail_out; |
||||
do { |
||||
/* get more input for inflate() */ |
||||
if (strm->avail_in == 0 && gz_avail(state) == -1) |
||||
return -1; |
||||
if (strm->avail_in == 0) { |
||||
gz_error(state, Z_DATA_ERROR, "unexpected end of file"); |
||||
return -1; |
||||
} |
||||
|
||||
/* decompress and handle errors */ |
||||
ret = inflate(strm, Z_NO_FLUSH); |
||||
if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) { |
||||
gz_error(state, Z_STREAM_ERROR, |
||||
"internal error: inflate stream corrupt"); |
||||
return -1; |
||||
} |
||||
if (ret == Z_MEM_ERROR) { |
||||
gz_error(state, Z_MEM_ERROR, "out of memory"); |
||||
return -1; |
||||
} |
||||
if (ret == Z_DATA_ERROR) { /* deflate stream invalid */ |
||||
gz_error(state, Z_DATA_ERROR, |
||||
strm->msg == NULL ? "compressed data error" : strm->msg); |
||||
return -1; |
||||
} |
||||
} while (strm->avail_out && ret != Z_STREAM_END); |
||||
|
||||
/* update available output and crc check value */ |
||||
state->have = had - strm->avail_out; |
||||
state->next = strm->next_out - state->have; |
||||
strm->adler = crc32(strm->adler, state->next, state->have); |
||||
|
||||
/* check gzip trailer if at end of deflate stream */ |
||||
if (ret == Z_STREAM_END) { |
||||
if (gz_next4(state, &crc) == -1 || gz_next4(state, &len) == -1) { |
||||
gz_error(state, Z_DATA_ERROR, "unexpected end of file"); |
||||
return -1; |
||||
} |
||||
if (crc != strm->adler) { |
||||
gz_error(state, Z_DATA_ERROR, "incorrect data check"); |
||||
return -1; |
||||
} |
||||
if (len != (strm->total_out & 0xffffffffL)) { |
||||
gz_error(state, Z_DATA_ERROR, "incorrect length check"); |
||||
return -1; |
||||
} |
||||
state->how = 0; /* ready for next stream, once have is 0 */ |
||||
} |
||||
|
||||
/* good decompression */ |
||||
return 0; |
||||
} |
||||
|
||||
/* Make data and put in the output buffer. Assumes that state->have == 0.
|
||||
Data is either copied from the input file or decompressed from the input |
||||
file depending on state->how. If state->how is zero, then a gzip header is |
||||
looked for (and skipped if found) to determine wither to copy or decompress. |
||||
Returns -1 on error, otherwise 0. gz_make() will leave state->have non-zero |
||||
unless the end of the input file has been reached and all data has been |
||||
processed. */ |
||||
local int gz_make(state) |
||||
gz_statep state; |
||||
{ |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
if (state->how == 0) { /* look for gzip header */ |
||||
if (gz_head(state) == -1) |
||||
return -1; |
||||
if (state->have) /* got some data from gz_head() */ |
||||
return 0; |
||||
} |
||||
if (state->how == 1) { /* straight copy */ |
||||
if (gz_load(state, state->out, state->size << 1, &(state->have)) == -1) |
||||
return -1; |
||||
state->next = state->out; |
||||
} |
||||
else if (state->how == 2) { /* decompress */ |
||||
strm->avail_out = state->size << 1; |
||||
strm->next_out = state->out; |
||||
if (gz_decomp(state) == -1) |
||||
return -1; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
/* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */ |
||||
local int gz_skip(state, len) |
||||
gz_statep state; |
||||
z_off_t len; |
||||
{ |
||||
unsigned n; |
||||
|
||||
/* skip over len bytes or reach end-of-file, whichever comes first */ |
||||
while (len) |
||||
/* skip over whatever is in output buffer */ |
||||
if (state->have) { |
||||
n = state->have > len ? (unsigned)len : state->have; |
||||
state->have -= n; |
||||
state->next += n; |
||||
state->pos += n; |
||||
len -= n; |
||||
} |
||||
|
||||
/* output buffer empty -- return if we're at the end of the input */ |
||||
else if (state->eof && state->strm.avail_in == 0) |
||||
break; |
||||
|
||||
/* need more data to skip -- load up output buffer */ |
||||
else { |
||||
/* get more output, looking for header if required */ |
||||
if (gz_make(state) == -1) |
||||
return -1; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzread(file, buf, len) |
||||
gzFile file; |
||||
voidp buf; |
||||
unsigned len; |
||||
{ |
||||
unsigned got, n; |
||||
gz_statep state; |
||||
z_streamp strm; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
strm = &(state->strm); |
||||
|
||||
/* check that we're reading and that there's no error */ |
||||
if (state->mode != GZ_READ || state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* process a skip request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_skip(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* get len bytes to buf, or less than len if at the end */ |
||||
got = 0; |
||||
while (len) { |
||||
|
||||
/* first just try copying data from the output buffer */ |
||||
if (state->have) { |
||||
n = state->have > len ? len : state->have; |
||||
memcpy(buf, state->next, n); |
||||
state->next += n; |
||||
state->have -= n; |
||||
} |
||||
|
||||
/* output buffer empty -- return if we're at the end of the input */ |
||||
else if (state->eof && strm->avail_in == 0) |
||||
break; |
||||
|
||||
/* need output data -- for small len or new stream load up our output
|
||||
buffer */ |
||||
else if (state->how == 0 || len < (state->size << 1)) { |
||||
/* get more output, looking for header if required */ |
||||
if (gz_make(state) == -1) |
||||
return -1; |
||||
continue; /* no progress yet -- go back to memcpy() above */ |
||||
} |
||||
|
||||
/* large len -- read directly into user buffer */ |
||||
else if (state->how == 1) { /* read directly */ |
||||
if (gz_load(state, buf, len, &n) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* large len -- decompress directly into user buffer */ |
||||
else { /* state->how == 2 */ |
||||
strm->avail_out = len; |
||||
strm->next_out = buf; |
||||
if (gz_decomp(state) == -1) |
||||
return -1; |
||||
n = state->have; |
||||
state->have = 0; |
||||
} |
||||
|
||||
/* update progress */ |
||||
len -= n; |
||||
buf += n; |
||||
got += n; |
||||
state->pos += n; |
||||
} |
||||
|
||||
/* return number of bytes read into user buffer */ |
||||
return (int)got; /* len had better fit in int -- interface flaw */ |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzgetc(file) |
||||
gzFile file; |
||||
{ |
||||
int ret; |
||||
unsigned char buf[1]; |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're reading and that there's no error */ |
||||
if (state->mode != GZ_READ || state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* try output buffer */ |
||||
if (state->have) { |
||||
state->have--; |
||||
state->pos++; |
||||
return *(state->next)++; |
||||
} |
||||
|
||||
/* nothing there -- try gzread() */ |
||||
ret = gzread(file, buf, 1); |
||||
return ret < 1 ? -1 : buf[0]; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzungetc(c, file) |
||||
int c; |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're reading and that there's no error */ |
||||
if (state->mode != GZ_READ || state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* process a skip request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_skip(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* can't push EOF */ |
||||
if (c < 0) |
||||
return -1; |
||||
|
||||
/* if output buffer empty, put byte at end (allows more pushing) */ |
||||
if (state->have == 0) { |
||||
state->have = 1; |
||||
state->next = state->out + (state->size << 1) - 1; |
||||
state->next[0] = c; |
||||
state->pos--; |
||||
return c; |
||||
} |
||||
|
||||
/* if no room, give up (must have already done a gz_ungetc()) */ |
||||
if (state->have == (state->size << 1)) |
||||
return -1; |
||||
|
||||
/* slide output data if needed and insert byte before existing data */ |
||||
if (state->next == state->out) { |
||||
unsigned char *src = state->out + state->have; |
||||
unsigned char *dest = state->out + (state->size << 1); |
||||
while (src > state->out) |
||||
*--dest = *--src; |
||||
state->next = dest; |
||||
} |
||||
state->have++; |
||||
state->next--; |
||||
state->next[0] = c; |
||||
state->pos--; |
||||
return c; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
char * ZEXPORT gzgets(file, buf, len) |
||||
gzFile file; |
||||
char *buf; |
||||
int len; |
||||
{ |
||||
unsigned left, n; |
||||
char *str; |
||||
unsigned char *eol; |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return NULL; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're reading and that there's no error */ |
||||
if (state->mode != GZ_READ || state->err != Z_OK) |
||||
return NULL; |
||||
|
||||
/* process a skip request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_skip(state, state->skip) == -1) |
||||
return NULL; |
||||
} |
||||
|
||||
/* check for a dumb length */ |
||||
if (len < 2) |
||||
return NULL; |
||||
|
||||
/* copy output bytes up to new line or len - 1, whichever comes first --
|
||||
append a terminating zero to the string (we don't check for a zero in |
||||
the contents, let the user worry about that) */ |
||||
str = buf; |
||||
left = (unsigned)len - 1; |
||||
do { |
||||
/* assure that something is in the output buffer */ |
||||
if (state->have == 0) { |
||||
if (gz_make(state) == -1) |
||||
return NULL; /* error */ |
||||
if (state->have == 0) { /* end of file */ |
||||
if (buf == str) /* got bupkus */ |
||||
return NULL; |
||||
break; /* got something -- return it */ |
||||
} |
||||
} |
||||
|
||||
/* look for end-of-line in current output buffer */ |
||||
n = state->have > left ? left : state->have; |
||||
eol = memchr(state->next, '\n', n); |
||||
if (eol != NULL) |
||||
n = (eol - state->next) + 1; |
||||
|
||||
/* copy through end-of-line, or remainder if not found */ |
||||
memcpy(buf, state->next, n); |
||||
state->have -= n; |
||||
state->next += n; |
||||
state->pos += n; |
||||
left -= n; |
||||
buf += n; |
||||
} while (left && eol == NULL); |
||||
|
||||
/* found end-of-line or out of space -- terminate string and return it */ |
||||
buf[0] = 0; |
||||
return str; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzdirect(file) |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return 0; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're reading */ |
||||
if (state->mode != GZ_READ) |
||||
return 0; |
||||
|
||||
/* return true if reading without decompression */ |
||||
return state->how == 1; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzclose_r(file) |
||||
gzFile file; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return Z_STREAM_ERROR; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're reading */ |
||||
if (state->mode != GZ_READ) |
||||
return Z_STREAM_ERROR; |
||||
|
||||
/* free memory and close file */ |
||||
if (state->size) { |
||||
inflateEnd(&(state->strm)); |
||||
free(state->out); |
||||
free(state->in); |
||||
} |
||||
gz_error(state, Z_OK, NULL); |
||||
close(state->fd); |
||||
free(state); |
||||
return Z_OK; |
||||
} |
||||
|
||||
#endif /* !OLD_GZIO */ |
||||
@ -0,0 +1,529 @@ |
||||
/* gzwrite.c -- zlib functions for writing gzip files
|
||||
* Copyright (C) 2004, 2005, 2010 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#ifndef OLD_GZIO |
||||
|
||||
#include "gzguts.h" |
||||
|
||||
/* Local functions */ |
||||
local int gz_init OF((gz_statep)); |
||||
local int gz_comp OF((gz_statep, int)); |
||||
local int gz_zero OF((gz_statep, z_off_t)); |
||||
|
||||
/* Initialize state for writing a gzip file. Mark initialization by setting
|
||||
state->size to non-zero. Return -1 on failure or 0 on success. */ |
||||
local int gz_init(state) |
||||
gz_statep state; |
||||
{ |
||||
int ret; |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
/* check version of zlib -- need 1.2.1 or later for gzip deflate() */ |
||||
#ifdef ZLIB_VERNUM |
||||
if (ZLIB_VERNUM < 0x1210) |
||||
#endif |
||||
{ |
||||
gz_error(state, Z_VERSION_ERROR, "need zlib 1.2.1 or later"); |
||||
return -1; |
||||
} |
||||
|
||||
/* allocate input and output buffers */ |
||||
state->in = malloc(state->want); |
||||
state->out = malloc(state->want); |
||||
if (state->in == NULL || state->out == NULL) { |
||||
if (state->out != NULL) |
||||
free(state->out); |
||||
if (state->in != NULL) |
||||
free(state->in); |
||||
gz_error(state, Z_MEM_ERROR, "out of memory"); |
||||
return -1; |
||||
} |
||||
|
||||
/* allocate deflate memory, set up for gzip compression */ |
||||
strm->zalloc = Z_NULL; |
||||
strm->zfree = Z_NULL; |
||||
strm->opaque = Z_NULL; |
||||
ret = deflateInit2(strm, state->level, Z_DEFLATED, |
||||
15 + 16, 8, state->strategy); |
||||
if (ret != Z_OK) { |
||||
free(state->in); |
||||
gz_error(state, Z_MEM_ERROR, "out of memory"); |
||||
return -1; |
||||
} |
||||
|
||||
/* mark state as initialized */ |
||||
state->size = state->want; |
||||
|
||||
/* initialize write buffer */ |
||||
strm->avail_out = state->size; |
||||
strm->next_out = state->out; |
||||
state->next = strm->next_out; |
||||
return 0; |
||||
} |
||||
|
||||
/* Compress whatever is at avail_in and next_in and write to the output file.
|
||||
Return -1 if there is an error writing to the output file, otherwise 0. |
||||
flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH, |
||||
then the deflate() state is reset to start a new gzip stream. */ |
||||
local int gz_comp(state, flush) |
||||
gz_statep state; |
||||
int flush; |
||||
{ |
||||
int ret; |
||||
unsigned have; |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
/* allocate memory if this is the first time through */ |
||||
if (state->size == 0 && gz_init(state) == -1) |
||||
return -1; |
||||
|
||||
/* run deflate() on provided input until it produces no more output */ |
||||
ret = Z_OK; |
||||
do { |
||||
/* write out current buffer contents if full, or if flushing, but if
|
||||
doing Z_FINISH then don't write until we get to Z_STREAM_END */ |
||||
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH && |
||||
(flush != Z_FINISH || ret == Z_STREAM_END))) { |
||||
have = strm->next_out - state->next; |
||||
if (have && write(state->fd, state->next, have) != have) { |
||||
gz_error(state, Z_ERRNO, zstrerror()); |
||||
return -1; |
||||
} |
||||
if (strm->avail_out == 0) { |
||||
strm->avail_out = state->size; |
||||
strm->next_out = state->out; |
||||
} |
||||
state->next = strm->next_out; |
||||
} |
||||
|
||||
/* compress */ |
||||
have = strm->avail_out; |
||||
ret = deflate(strm, flush); |
||||
if (ret == Z_STREAM_ERROR) { |
||||
gz_error(state, Z_STREAM_ERROR, |
||||
"internal error: deflate stream corrupt"); |
||||
return -1; |
||||
} |
||||
have -= strm->avail_out; |
||||
} while (have); |
||||
|
||||
/* if that completed a deflate stream, allow another to start */ |
||||
if (flush == Z_FINISH) |
||||
deflateReset(strm); |
||||
|
||||
/* all done, no errors */ |
||||
return 0; |
||||
} |
||||
|
||||
/* Compress len zeros to output. Return -1 on error, 0 on success. */ |
||||
local int gz_zero(state, len) |
||||
gz_statep state; |
||||
z_off_t len; |
||||
{ |
||||
int first; |
||||
unsigned n; |
||||
z_streamp strm = &(state->strm); |
||||
|
||||
/* consume whatever's left in the input buffer */ |
||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return -1; |
||||
|
||||
/* compress len zeros */ |
||||
first = 1; |
||||
while (len) { |
||||
n = len < state->size ? (unsigned)len : state->size; |
||||
if (first) { |
||||
memset(state->in, 0, n); |
||||
first = 0; |
||||
} |
||||
strm->avail_in = n; |
||||
strm->next_in = state->in; |
||||
state->pos += n; |
||||
if (gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return -1; |
||||
len -= n; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzwrite(file, buf, len) |
||||
gzFile file; |
||||
voidpc buf; |
||||
unsigned len; |
||||
{ |
||||
unsigned put = len; |
||||
unsigned n; |
||||
gz_statep state; |
||||
z_streamp strm; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
strm = &(state->strm); |
||||
|
||||
/* check that we're writing and that there's no error */ |
||||
if (state->mode != GZ_WRITE || state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* allocate memory if this is the first time through */ |
||||
if (state->size == 0 && gz_init(state) == -1) |
||||
return -1; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* for small len, copy to input buffer, otherwise compress directly */ |
||||
if (len < state->size) { |
||||
/* copy to input buffer, compress when full */ |
||||
while (len) { |
||||
if (strm->avail_in == 0) |
||||
strm->next_in = state->in; |
||||
n = state->size - strm->avail_in; |
||||
if (n > len) |
||||
n = len; |
||||
memcpy(strm->next_in + strm->avail_in, buf, n); |
||||
strm->avail_in += n; |
||||
state->pos += n; |
||||
buf += n; |
||||
len -= n; |
||||
if (len && gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return -1; |
||||
} |
||||
} |
||||
else { |
||||
/* consume whatever's left in the input buffer */ |
||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return -1; |
||||
|
||||
/* directly compress user buffer to file */ |
||||
strm->avail_in = len; |
||||
strm->next_in = (voidp)buf; |
||||
state->pos += len; |
||||
if (gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* input was all buffered or compressed */ |
||||
return (int)put; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzputc(file, c) |
||||
gzFile file; |
||||
int c; |
||||
{ |
||||
unsigned char buf[1]; |
||||
gz_statep state; |
||||
z_streamp strm; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
strm = &(state->strm); |
||||
|
||||
/* check that we're writing and that there's no error */ |
||||
if (state->mode != GZ_WRITE || state->err != Z_OK) |
||||
return -1; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* try writing to input buffer for speed (state->size == 0 if buffer not
|
||||
initialized) */ |
||||
if (strm->avail_in < state->size) { |
||||
if (strm->avail_in == 0) |
||||
strm->next_in = state->in; |
||||
strm->next_in[strm->avail_in++] = c; |
||||
state->pos++; |
||||
return c; |
||||
} |
||||
|
||||
/* no room in buffer or not initialized, use gz_write() */ |
||||
buf[0] = c; |
||||
if (gzwrite(file, buf, 1) != 1) |
||||
return -1; |
||||
return c; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzputs(file, str) |
||||
gzFile file; |
||||
const char *str; |
||||
{ |
||||
/* write string */ |
||||
return gzwrite(file, str, strlen(str)); |
||||
} |
||||
|
||||
#ifdef STDC |
||||
#include <stdarg.h> |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) |
||||
{ |
||||
int size, len; |
||||
gz_statep state; |
||||
z_streamp strm; |
||||
va_list va; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
strm = &(state->strm); |
||||
|
||||
/* check that we're writing and that there's no error */ |
||||
if (state->mode != GZ_WRITE || state->err != Z_OK) |
||||
return 0; |
||||
|
||||
/* make sure we have some buffer space */ |
||||
if (state->size == 0 && gz_init(state) == -1) |
||||
return 0; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return 0; |
||||
} |
||||
|
||||
/* consume whatever's left in the input buffer */ |
||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return 0; |
||||
|
||||
/* do the printf() into the input buffer, put length in len */ |
||||
size = (int)(state->size); |
||||
state->in[size - 1] = 0; |
||||
va_start(va, format); |
||||
#ifdef NO_vsnprintf |
||||
# ifdef HAS_vsprintf_void |
||||
(void)vsprintf(state->in, format, va); |
||||
va_end(va); |
||||
for (len = 0; len < state->in; len++) |
||||
if (state->in[len] == 0) break; |
||||
# else |
||||
len = vsprintf(state->in, format, va); |
||||
va_end(va); |
||||
# endif |
||||
#else |
||||
# ifdef HAS_vsnprintf_void |
||||
(void)vsnprintf(state->in, size, format, va); |
||||
va_end(va); |
||||
len = strlen(state->in); |
||||
# else |
||||
len = vsnprintf((char *)(state->in), size, format, va); |
||||
va_end(va); |
||||
# endif |
||||
#endif |
||||
|
||||
/* check that printf() results fit in buffer */ |
||||
if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) |
||||
return 0; |
||||
|
||||
/* write out result of printf() */ |
||||
strm->avail_in = (unsigned)len; |
||||
strm->next_in = state->in; |
||||
state->pos += len; |
||||
if (gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return 0; |
||||
return len; |
||||
} |
||||
|
||||
#else /* !STDC */ |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, |
||||
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) |
||||
gzFile file; |
||||
const char *format; |
||||
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, |
||||
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; |
||||
{ |
||||
int size, len; |
||||
gz_statep state; |
||||
z_streamp strm; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
strm = &(state->strm); |
||||
|
||||
/* check that we're writing and that there's no error */ |
||||
if (state->mode != GZ_WRITE || state->err != Z_OK) |
||||
return 0; |
||||
|
||||
/* make sure we have some buffer space */ |
||||
if (state->size == 0 && gz_init(state) == -1) |
||||
return 0; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return 0; |
||||
} |
||||
|
||||
/* consume whatever's left in the input buffer */ |
||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return 0; |
||||
|
||||
/* do the printf() into the input buffer, put length in len */ |
||||
size = (int)(state->size); |
||||
state->in[size - 1] = 0; |
||||
#ifdef NO_snprintf |
||||
# ifdef HAS_sprintf_void |
||||
sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, |
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
||||
for (len = 0; len < size; len++) |
||||
if (state->in[len] == 0) break; |
||||
# else |
||||
len = sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, |
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
||||
# endif |
||||
#else |
||||
# ifdef HAS_snprintf_void |
||||
snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, |
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
||||
len = strlen(state->in); |
||||
# else |
||||
len = snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, |
||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
||||
# endif |
||||
#endif |
||||
|
||||
/* check that printf() results fit in buffer */ |
||||
if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) |
||||
return 0; |
||||
|
||||
/* write out result of printf() */ |
||||
strm->avail_in = (unsigned)len; |
||||
strm->next_in = state->in; |
||||
state->pos += len; |
||||
if (gz_comp(state, Z_NO_FLUSH) == -1) |
||||
return 0; |
||||
return len; |
||||
} |
||||
|
||||
#endif |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzflush(file, flush) |
||||
gzFile file; |
||||
int flush; |
||||
{ |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return -1; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're writing and that there's no error */ |
||||
if (state->mode != GZ_WRITE|| state->err != Z_OK) |
||||
|
||||
/* check flush parameter */ |
||||
if (flush < 0 || flush > Z_FINISH) |
||||
return Z_STREAM_ERROR; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* compress remaining data with requested flush */ |
||||
gz_comp(state, flush); |
||||
return state->err; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzsetparams(file, level, strategy) |
||||
gzFile file; |
||||
int level; |
||||
int strategy; |
||||
{ |
||||
gz_statep state; |
||||
z_streamp strm; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return Z_STREAM_ERROR; |
||||
state = (gz_statep)file; |
||||
strm = &(state->strm); |
||||
|
||||
/* check that we're writing and that there's no error */ |
||||
if (state->mode != GZ_WRITE || state->err != Z_OK) |
||||
return Z_STREAM_ERROR; |
||||
|
||||
/* if no change is requested, then do nothing */ |
||||
if (level == state->level && strategy == state->strategy) |
||||
return Z_OK; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* change compression parameters for subsequent input */ |
||||
if (state->size) { |
||||
/* flush previous input with previous parameters before changing */ |
||||
if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1) |
||||
return state->err; |
||||
deflateParams(strm, level, strategy); |
||||
} |
||||
state->level = level; |
||||
state->strategy = strategy; |
||||
return Z_OK; |
||||
} |
||||
|
||||
/* -- see zlib.h -- */ |
||||
int ZEXPORT gzclose_w(file) |
||||
gzFile file; |
||||
{ |
||||
int ret; |
||||
gz_statep state; |
||||
|
||||
/* get internal structure */ |
||||
if (file == NULL) |
||||
return Z_STREAM_ERROR; |
||||
state = (gz_statep)file; |
||||
|
||||
/* check that we're writing */ |
||||
if (state->mode != GZ_WRITE) |
||||
return Z_STREAM_ERROR; |
||||
|
||||
/* check for seek request */ |
||||
if (state->seek) { |
||||
state->seek = 0; |
||||
if (gz_zero(state, state->skip) == -1) |
||||
return -1; |
||||
} |
||||
|
||||
/* flush, free memory, and close file */ |
||||
ret = gz_comp(state, Z_FINISH); |
||||
deflateEnd(&(state->strm)); |
||||
free(state->out); |
||||
free(state->in); |
||||
ret += close(state->fd); |
||||
gz_error(state, Z_OK, NULL); |
||||
free(state); |
||||
return ret ? Z_ERRNO : Z_OK; |
||||
} |
||||
|
||||
#endif /* !OLD_GZIO */ |
||||
@ -0,0 +1,141 @@ |
||||
# Makefile for zlib, derived from Makefile.dj2.
|
||||
# Modified for mingw32 by C. Spieler, 6/16/98.
|
||||
# Updated for zlib 1.2.x by Christian Spieler and Cosmin Truta, Mar-2003.
|
||||
# Last updated: 1-Aug-2003.
|
||||
# Tested under Cygwin and MinGW.
|
||||
|
||||
# Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
# For conditions of distribution and use, see copyright notice in zlib.h
|
||||
|
||||
# To compile, or to compile and test, type:
|
||||
#
|
||||
# make -fmakefile.gcc; make test testdll -fmakefile.gcc
|
||||
#
|
||||
# To use the asm code, type:
|
||||
# cp contrib/asm?86/match.S ./match.S
|
||||
# make LOC=-DASMV OBJA=match.o -fmakefile.gcc
|
||||
#
|
||||
# To install libz.a, zconf.h and zlib.h in the system directories, type:
|
||||
#
|
||||
# make install -fmakefile.gcc
|
||||
|
||||
# Note:
|
||||
# If the platform is *not* MinGW (e.g. it is Cygwin or UWIN),
|
||||
# the DLL name should be changed from "zlib1.dll".
|
||||
|
||||
STATICLIB = libz.a
|
||||
SHAREDLIB = zlib1.dll
|
||||
IMPLIB = libzdll.a
|
||||
|
||||
#LOC = -DASMV
|
||||
#LOC = -DDEBUG -g
|
||||
|
||||
CC = gcc
|
||||
CFLAGS = $(LOC) -O3 -Wall
|
||||
|
||||
AS = $(CC)
|
||||
ASFLAGS = $(LOC) -Wall
|
||||
|
||||
LD = $(CC)
|
||||
LDFLAGS = $(LOC) -s
|
||||
|
||||
AR = ar
|
||||
ARFLAGS = rcs
|
||||
|
||||
RC = windres
|
||||
RCFLAGS = --define GCC_WINDRES
|
||||
|
||||
CP = cp -fp
|
||||
# If GNU install is available, replace $(CP) with install.
|
||||
INSTALL = $(CP)
|
||||
RM = rm -f
|
||||
|
||||
prefix = /usr/local
|
||||
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
|
||||
OBJA =
|
||||
|
||||
all: $(STATICLIB) $(SHAREDLIB) $(IMPLIB) example minigzip example_d minigzip_d |
||||
|
||||
test: example minigzip |
||||
./example
|
||||
echo hello world | ./minigzip | ./minigzip -d
|
||||
|
||||
testdll: example_d minigzip_d |
||||
./example_d
|
||||
echo hello world | ./minigzip_d | ./minigzip_d -d
|
||||
|
||||
.c.o: |
||||
$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
.S.o: |
||||
$(AS) $(ASFLAGS) -c -o $@ $<
|
||||
|
||||
$(STATICLIB): $(OBJS) $(OBJA) |
||||
$(AR) $(ARFLAGS) $@ $(OBJS) $(OBJA)
|
||||
|
||||
$(IMPLIB): $(SHAREDLIB) |
||||
|
||||
$(SHAREDLIB): win32/zlib.def $(OBJS) $(OBJA) zlibrc.o |
||||
dllwrap --driver-name $(CC) --def win32/zlib.def \
|
||||
--implib $(IMPLIB) -o $@ $(OBJS) $(OBJA) zlibrc.o
|
||||
strip $@
|
||||
|
||||
example: example.o $(STATICLIB) |
||||
$(LD) $(LDFLAGS) -o $@ example.o $(STATICLIB)
|
||||
|
||||
minigzip: minigzip.o $(STATICLIB) |
||||
$(LD) $(LDFLAGS) -o $@ minigzip.o $(STATICLIB)
|
||||
|
||||
example_d: example.o $(IMPLIB) |
||||
$(LD) $(LDFLAGS) -o $@ example.o $(IMPLIB)
|
||||
|
||||
minigzip_d: minigzip.o $(IMPLIB) |
||||
$(LD) $(LDFLAGS) -o $@ minigzip.o $(IMPLIB)
|
||||
|
||||
zlibrc.o: win32/zlib1.rc |
||||
$(RC) $(RCFLAGS) -o $@ win32/zlib1.rc
|
||||
|
||||
|
||||
# INCLUDE_PATH and LIBRARY_PATH must be set.
|
||||
|
||||
.PHONY: install uninstall clean |
||||
|
||||
install: zlib.h zconf.h $(LIB) |
||||
-@if not exist $(INCLUDE_PATH)/nul mkdir $(INCLUDE_PATH)
|
||||
-@if not exist $(LIBRARY_PATH)/nul mkdir $(LIBRARY_PATH)
|
||||
-$(INSTALL) zlib.h $(INCLUDE_PATH)
|
||||
-$(INSTALL) zconf.h $(INCLUDE_PATH)
|
||||
-$(INSTALL) $(STATICLIB) $(LIBRARY_PATH)
|
||||
-$(INSTALL) $(IMPLIB) $(LIBRARY_PATH)
|
||||
|
||||
uninstall: |
||||
-$(RM) $(INCLUDE_PATH)/zlib.h
|
||||
-$(RM) $(INCLUDE_PATH)/zconf.h
|
||||
-$(RM) $(LIBRARY_PATH)/$(STATICLIB)
|
||||
-$(RM) $(LIBRARY_PATH)/$(IMPLIB)
|
||||
|
||||
clean: |
||||
-$(RM) $(STATICLIB)
|
||||
-$(RM) $(SHAREDLIB)
|
||||
-$(RM) $(IMPLIB)
|
||||
-$(RM) *.o
|
||||
-$(RM) *.exe
|
||||
-$(RM) foo.gz
|
||||
|
||||
adler32.o: zlib.h zconf.h |
||||
compress.o: zlib.h zconf.h |
||||
crc32.o: crc32.h zlib.h zconf.h |
||||
deflate.o: deflate.h zutil.h zlib.h zconf.h |
||||
example.o: zlib.h zconf.h |
||||
gzio.o: zutil.h zlib.h zconf.h |
||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h |
||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h |
||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h |
||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h |
||||
minigzip.o: zlib.h zconf.h |
||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h |
||||
uncompr.o: zlib.h zconf.h |
||||
zutil.o: zutil.h zlib.h zconf.h |
||||
@ -0,0 +1,16 @@ |
||||
/* zlibdefs.h -- compile-time definitions for the zlib compression library |
||||
* Copyright (C) 1995-2006 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
#cmakedefine HAVE_UNISTD_H |
||||
#ifdef HAVE_UNISTD_H |
||||
#include <sys/types.h> /* for off_t */ |
||||
#include <unistd.h> /* for SEEK_* and off_t */ |
||||
#ifdef VMS |
||||
# include <unixio.h> /* for off_t */ |
||||
#endif |
||||
#ifndef z_off_t |
||||
# define z_off_t off_t |
||||
#endif |
||||
#endif |
||||
Loading…
Reference in new issue