summaryrefslogtreecommitdiff
path: root/external
diff options
context:
space:
mode:
authorMatúš Kukan <matus.kukan@collabora.com>2014-05-13 17:19:36 +0200
committerMatúš Kukan <matus.kukan@collabora.com>2014-05-14 21:27:17 +0200
commit436f2aa8208decd022069c52544169030a6913db (patch)
tree26c6c9eb650185ce3e36728724d163efe3daa278 /external
parent969df2a069d5b9bd90467a0ed447fcf36a90557e (diff)
Add kmz support to collada2gltf and use it.
Change-Id: I37cda0e326af00ef369c4415bcec1e03c91ce401
Diffstat (limited to 'external')
-rw-r--r--external/collada2gltf/StaticLibrary_collada2gltf.mk6
-rw-r--r--external/collada2gltf/UnpackedTarball_collada2gltf.mk5
-rw-r--r--external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.38522
-rw-r--r--external/collada2gltf/write-only-.dae-file-which-we-need.patch.0128
4 files changed, 8661 insertions, 0 deletions
diff --git a/external/collada2gltf/StaticLibrary_collada2gltf.mk b/external/collada2gltf/StaticLibrary_collada2gltf.mk
index a25f63d9a5e9..0097f3f7bab0 100644
--- a/external/collada2gltf/StaticLibrary_collada2gltf.mk
+++ b/external/collada2gltf/StaticLibrary_collada2gltf.mk
@@ -50,6 +50,7 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,collada2gltf,\
UnpackedTarball/collada2gltf/COLLADA2GLTFWriter \
UnpackedTarball/collada2gltf/GitSHA1 \
UnpackedTarball/collada2gltf/GLTFOpenCOLLADAUtils \
+ UnpackedTarball/collada2gltf/KMZ2Collada \
UnpackedTarball/collada2gltf/assetModifiers/GLTFFlipUVModifier \
UnpackedTarball/collada2gltf/convert/meshConverter \
UnpackedTarball/collada2gltf/convert/animationConverter \
@@ -81,6 +82,11 @@ $(eval $(call gb_StaticLibrary_add_generated_exception_objects,collada2gltf,\
UnpackedTarball/collada2gltf/shaders/commonProfileShaders \
))
+$(eval $(call gb_StaticLibrary_add_generated_cobjects,collada2gltf,\
+ UnpackedTarball/collada2gltf/kmz/ioapi \
+ UnpackedTarball/collada2gltf/kmz/unzip \
+))
+
# o3dgc external library compiled from collada2gltf
$(eval $(call gb_StaticLibrary_set_include,collada2gltf,\
-I$(call gb_UnpackedTarball_get_dir,collada2gltf)/dependencies/o3dgc/src/o3dgc_common_lib/inc \
diff --git a/external/collada2gltf/UnpackedTarball_collada2gltf.mk b/external/collada2gltf/UnpackedTarball_collada2gltf.mk
index 92bc775e5989..3112cd98c9b7 100644
--- a/external/collada2gltf/UnpackedTarball_collada2gltf.mk
+++ b/external/collada2gltf/UnpackedTarball_collada2gltf.mk
@@ -13,4 +13,9 @@ $(eval $(call gb_UnpackedTarball_set_tarball,collada2gltf,$(COLLADA2GLTF_TARBALL
$(eval $(call gb_UnpackedTarball_add_file,collada2gltf,.,external/collada2gltf/GitSHA1.cpp))
+$(eval $(call gb_UnpackedTarball_add_patches,collada2gltf,\
+ external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3 \
+ external/collada2gltf/write-only-.dae-file-which-we-need.patch.0 \
+))
+
# vim: set noet sw=4 ts=4:
diff --git a/external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3 b/external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3
new file mode 100644
index 000000000000..d41a7f99b754
--- /dev/null
+++ b/external/collada2gltf/add-unzip-kmz-files-to-collada-files-module.patch.3
@@ -0,0 +1,8522 @@
+From a516e4953d16a87eee3f25a3067fa8ea930d3888 Mon Sep 17 00:00:00 2001
+From: jhuan <huan@multicorewareinc.com>
+Date: Mon, 12 May 2014 15:53:39 +0800
+Subject: [PATCH 1/2] Add unzip kmz files to collada files module:
+
+---
+ converter/COLLADA2GLTF/CMakeLists.txt | 16 +-
+ converter/COLLADA2GLTF/KMZ2Collada.cpp | 121 ++
+ converter/COLLADA2GLTF/KMZ2Collada.h | 28 +
+ converter/COLLADA2GLTF/kmz/ioapi.c | 247 ++++
+ converter/COLLADA2GLTF/kmz/ioapi.h | 208 ++++
+ converter/COLLADA2GLTF/kmz/iowin32.c | 461 +++++++
+ converter/COLLADA2GLTF/kmz/iowin32.h | 28 +
+ converter/COLLADA2GLTF/kmz/unzip.c | 2125 ++++++++++++++++++++++++++++++++
+ converter/COLLADA2GLTF/kmz/unzip.h | 437 +++++++
+ converter/COLLADA2GLTF/kmz/zconf.h | 513 ++++++++
+ converter/COLLADA2GLTF/kmz/zip.c | 2007 ++++++++++++++++++++++++++++++
+ converter/COLLADA2GLTF/kmz/zip.h | 362 ++++++
+ converter/COLLADA2GLTF/kmz/zlib.h | 1768 ++++++++++++++++++++++++++
+ converter/COLLADA2GLTF/main.cpp | 19 +
+ 14 files changed, 8338 insertions(+), 2 deletions(-)
+ create mode 100644 converter/COLLADA2GLTF/KMZ2Collada.cpp
+ create mode 100644 converter/COLLADA2GLTF/KMZ2Collada.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/ioapi.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/ioapi.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/iowin32.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/iowin32.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/unzip.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/unzip.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/zconf.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/zip.c
+ create mode 100644 converter/COLLADA2GLTF/kmz/zip.h
+ create mode 100644 converter/COLLADA2GLTF/kmz/zlib.h
+
+diff --git a/converter/COLLADA2GLTF/CMakeLists.txt b/converter/COLLADA2GLTF/CMakeLists.txt
+index 4dffbd4..f5f6465 100644
+--- a/converter/COLLADA2GLTF/CMakeLists.txt
++++ b/converter/COLLADA2GLTF/CMakeLists.txt
+@@ -26,7 +26,7 @@ get_git_head_revision(GIT_REFSPEC GIT_SHA1)
+
+ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/GitSHA1.cpp.in" "${CMAKE_CURRENT_BINARY_DIR}/GitSHA1.cpp" @ONLY)
+
+-set(TARGET_LIBS GeneratedSaxParser_static OpenCOLLADABaseUtils_static UTF_static ftoa_static MathMLSolver_static OpenCOLLADASaxFrameworkLoader_static OpenCOLLADAFramework_static buffer_static)
++set(TARGET_LIBS GeneratedSaxParser_static OpenCOLLADABaseUtils_static UTF_static ftoa_static MathMLSolver_static OpenCOLLADASaxFrameworkLoader_static OpenCOLLADAFramework_static buffer_static zlib zlibstat)
+
+ if (NOT WIN32)
+ set(CMAKE_FIND_LIBRARY_SUFFIXES .so .a .dylib)
+@@ -34,6 +34,7 @@ endif()
+
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/GLTF)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/JSON)
++include_directories(${COLLADA2GLTF_SOURCE_DIR}/kmz)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/shaders)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/helpers)
+ include_directories(${COLLADA2GLTF_SOURCE_DIR}/convert)
+@@ -65,6 +66,8 @@ if (NOT WIN32)
+ endif()
+
+ link_directories(${COLLADA2GLTF_BINARY_DIR}/lib)
++link_directories(${COLLADA2GLTF_SOURCE_DIR}/kmz)
++
+
+ if (WIN32)
+ add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+@@ -85,6 +88,15 @@ set(GLTF_SOURCES main.cpp
+ GLTFOpenCOLLADA.h
+ GLTFOpenCOLLADAUtils.h
+ GLTFOpenCOLLADAUtils.cpp
++
++ KMZ2Collada.h
++ KMZ2Collada.cpp
++ kmz/zlib.h
++ kmz/unzip.h
++ kmz/unzip.c
++ kmz/ioapi.h
++ kmz/ioapi.c
++
+
+ GLTF/GLTFAccessorCache.cpp
+ GLTF/GLTFAccessorCache.h
+@@ -173,7 +185,7 @@ LIST(APPEND TARGET_LIBS ${PNG_LIBRARY} ${ZLIB_LIBRARY})
+ endif()
+
+ if (USE_OPEN3DGC)
+-LIST(APPEND TARGET_LIBS o3dgc_common_lib o3dgc_enc_lib o3dgc_dec_lib)
++LIST(APPEND TARGET_LIBS o3dgc_common_lib o3dgc_enc_lib o3dgc_dec_lib zlib)
+ endif()
+
+ IF("${CMAKE_SYSTEM}" MATCHES "Linux")
+diff --git a/converter/COLLADA2GLTF/KMZ2Collada.cpp b/converter/COLLADA2GLTF/KMZ2Collada.cpp
+new file mode 100644
+index 0000000..d193784
+--- /dev/null
++++ b/converter/COLLADA2GLTF/KMZ2Collada.cpp
+@@ -0,0 +1,121 @@
++#include "KMZ2Collada.h"
++#include "kmz/unzip.h"
++#include "kmz/ioapi.h"
++
++#include <direct.h>
++
++using namespace std;
++
++namespace GLTF{
++ Kmz2Collada::Kmz2Collada() {
++
++ }
++ Kmz2Collada::~Kmz2Collada() {
++
++ }
++
++ void Kmz2Collada::setFileFolder(std::string& strSrc) {
++ std::string strFolderPath = "";
++ char *pFolderName = new char[strSrc.size()];
++
++ for (unsigned int i = 0; i < strSrc.size(); i++) {
++ if (strSrc[i] == '\\' || strSrc[i] == '/') {
++ pFolderName[i] = '\0';
++ strFolderPath = strKmzPath + pFolderName;
++ _mkdir(strFolderPath.c_str());
++ }
++ pFolderName[i] = strSrc[i];
++ }
++ strSrc = strKmzPath +strSrc;
++
++ delete[] pFolderName;
++ }
++ void Kmz2Collada::getFilePath(std::string& strSrc) {
++ char *pTemporaryContent = new char[strSrc.size()+1];
++ std::string strFilePath;
++
++ for (unsigned int ipos = 0; ipos < strSrc.size(); ipos ++) {
++ if (strSrc[ipos] == '\\' || strSrc[ipos] == '/') {
++ pTemporaryContent[ipos] = '\0';
++ strFilePath = pTemporaryContent;
++ _mkdir(strFilePath.c_str());
++ }
++ pTemporaryContent[ipos] = strSrc[ipos];
++ }
++
++ if (strFilePath != "")
++ strFilePath += '\\';
++ strSrc = strFilePath;
++ strKmzPath = strSrc;
++
++ delete[] pTemporaryContent;
++ }
++
++ std::string Kmz2Collada::operator()(std::string strInputFile) {
++ int iFileLength;
++ unzFile zFile;
++ unsigned int num = 512;
++ unz_file_info64 zFileInfo;
++ unz_global_info64 zGlobalInfo;
++ char *pFileName = new char[num];
++
++ zFile = unzOpen64(strInputFile.c_str());
++
++ if (zFile == NULL) {
++ printf("Open Kmz file error\n");
++ return "";
++ }
++ getFilePath(strInputFile);
++
++ if (UNZ_OK != unzGetGlobalInfo64(zFile, &zGlobalInfo)) {
++ printf("Parsing file error\n");
++ return "";
++ }
++
++ for (int i = 0; i < zGlobalInfo.number_entry; i++) {
++ if (UNZ_OK != unzGetCurrentFileInfo64(zFile, &zFileInfo,
++ pFileName, num, NULL, 0, NULL, 0)) {
++ printf("Read file error\n");
++ return "";
++ }
++ std::string strFilePath = pFileName;
++ setFileFolder(strFilePath);
++ if (strstr(strFilePath.c_str(), ".dae"))
++ strDaePath = strFilePath;
++
++ FILE *fp = fopen(strFilePath.c_str(),"wb");
++
++ if (UNZ_OK != unzOpenCurrentFile(zFile)) {
++ printf("Open current file error");
++ return "";
++ }
++
++ iFileLength = (int)zFileInfo.uncompressed_size;
++ char *pFileData = new char[iFileLength];
++ int len = 1;
++
++ while (len) {
++ len = unzReadCurrentFile(zFile, (voidp)pFileData,
++ iFileLength - 1);
++ pFileData[len] = '\0';
++
++ if ( len <= 0) {
++ break;
++ }
++ fwrite(pFileData, 1, len, fp);
++ }
++ fclose(fp);
++ delete[] pFileData;
++ pFileData = NULL;
++
++ unzGoToNextFile(zFile);
++ }
++ unzCloseCurrentFile(zFile);
++
++ delete[] pFileName;
++ pFileName = NULL;
++
++ return strDaePath;
++ }
++
++}
+\ No newline at end of file
+diff --git a/converter/COLLADA2GLTF/KMZ2Collada.h b/converter/COLLADA2GLTF/KMZ2Collada.h
+new file mode 100644
+index 0000000..5e8bdef
+--- /dev/null
++++ b/converter/COLLADA2GLTF/KMZ2Collada.h
+@@ -0,0 +1,28 @@
++#ifndef __KMZ2COLLADA_H__
++#define __KMZ2COLLADA_H__
++
++#include <string>
++
++namespace GLTF{
++ class Kmz2Collada
++ {
++ public:
++ Kmz2Collada();
++ ~Kmz2Collada();
++
++ /** get the kmz file path and set folder.*/
++ void setFileFolder(std::string& strSrc);
++
++ /** get kmz file path.*/
++ void getFilePath(std::string& strSrc);
++
++ /** copy function.*/
++ std::string operator()(std::string strInputFile);
++
++ private:
++ std::string strDaePath;
++ std::string strKmzPath;
++ };
++
++}
++#endif
+\ No newline at end of file
+diff --git a/converter/COLLADA2GLTF/kmz/ioapi.c b/converter/COLLADA2GLTF/kmz/ioapi.c
+new file mode 100644
+index 0000000..7f5c191
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/ioapi.c
+@@ -0,0 +1,247 @@
++/* ioapi.h -- IO base function header for compress/uncompress .zip
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++*/
++
++#if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS)))
++ #define _CRT_SECURE_NO_WARNINGS
++#endif
++
++#if defined(__APPLE__) || defined(IOAPI_NO_64)
++// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
++#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
++#define FTELLO_FUNC(stream) ftello(stream)
++#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
++#else
++#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
++#define FTELLO_FUNC(stream) ftello64(stream)
++#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
++#endif
++
++
++#include "ioapi.h"
++
++voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
++{
++ if (pfilefunc->zfile_func64.zopen64_file != NULL)
++ return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
++ else
++ {
++ return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
++ }
++}
++
++long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
++{
++ if (pfilefunc->zfile_func64.zseek64_file != NULL)
++ return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
++ else
++ {
++ uLong offsetTruncated = (uLong)offset;
++ if (offsetTruncated != offset)
++ return -1;
++ else
++ return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
++ }
++}
++
++ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
++{
++ if (pfilefunc->zfile_func64.zseek64_file != NULL)
++ return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
++ else
++ {
++ uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
++ if ((tell_uLong) == MAXU32)
++ return (ZPOS64_T)-1;
++ else
++ return tell_uLong;
++ }
++}
++
++void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
++{
++ p_filefunc64_32->zfile_func64.zopen64_file = NULL;
++ p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
++ p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
++ p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
++ p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
++ p_filefunc64_32->zfile_func64.ztell64_file = NULL;
++ p_filefunc64_32->zfile_func64.zseek64_file = NULL;
++ p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
++ p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
++ p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
++ p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
++ p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
++}
++
++
++
++static voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
++static uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
++static uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
++static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
++static long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
++static int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
++static int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
++
++static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
++{
++ FILE* file = NULL;
++ const char* mode_fopen = NULL;
++ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
++ mode_fopen = "rb";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
++ mode_fopen = "r+b";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_CREATE)
++ mode_fopen = "wb";
++
++ if ((filename!=NULL) && (mode_fopen != NULL))
++ file = fopen(filename, mode_fopen);
++ return file;
++}
++
++static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
++{
++ FILE* file = NULL;
++ const char* mode_fopen = NULL;
++ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
++ mode_fopen = "rb";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
++ mode_fopen = "r+b";
++ else
++ if (mode & ZLIB_FILEFUNC_MODE_CREATE)
++ mode_fopen = "wb";
++
++ if ((filename!=NULL) && (mode_fopen != NULL))
++ file = FOPEN_FUNC((const char*)filename, mode_fopen);
++ return file;
++}
++
++
++static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
++{
++ uLong ret;
++ ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
++ return ret;
++}
++
++static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
++{
++ uLong ret;
++ ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
++ return ret;
++}
++
++static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
++{
++ long ret;
++ ret = ftell((FILE *)stream);
++ return ret;
++}
++
++
++static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
++{
++ ZPOS64_T ret;
++ ret = FTELLO_FUNC((FILE *)stream);
++ return ret;
++}
++
++static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin)
++{
++ int fseek_origin=0;
++ long ret;
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ fseek_origin = SEEK_CUR;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ fseek_origin = SEEK_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ fseek_origin = SEEK_SET;
++ break;
++ default: return -1;
++ }
++ ret = 0;
++ if (fseek((FILE *)stream, offset, fseek_origin) != 0)
++ ret = -1;
++ return ret;
++}
++
++static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)
++{
++ int fseek_origin=0;
++ long ret;
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ fseek_origin = SEEK_CUR;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ fseek_origin = SEEK_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ fseek_origin = SEEK_SET;
++ break;
++ default: return -1;
++ }
++ ret = 0;
++
++ if(FSEEKO_FUNC((FILE *)stream, offset, fseek_origin) != 0)
++ ret = -1;
++
++ return ret;
++}
++
++
++static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
++{
++ int ret;
++ ret = fclose((FILE *)stream);
++ return ret;
++}
++
++static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
++{
++ int ret;
++ ret = ferror((FILE *)stream);
++ return ret;
++}
++
++void fill_fopen_filefunc (pzlib_filefunc_def)
++ zlib_filefunc_def* pzlib_filefunc_def;
++{
++ pzlib_filefunc_def->zopen_file = fopen_file_func;
++ pzlib_filefunc_def->zread_file = fread_file_func;
++ pzlib_filefunc_def->zwrite_file = fwrite_file_func;
++ pzlib_filefunc_def->ztell_file = ftell_file_func;
++ pzlib_filefunc_def->zseek_file = fseek_file_func;
++ pzlib_filefunc_def->zclose_file = fclose_file_func;
++ pzlib_filefunc_def->zerror_file = ferror_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++void fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = fopen64_file_func;
++ pzlib_filefunc_def->zread_file = fread_file_func;
++ pzlib_filefunc_def->zwrite_file = fwrite_file_func;
++ pzlib_filefunc_def->ztell64_file = ftell64_file_func;
++ pzlib_filefunc_def->zseek64_file = fseek64_file_func;
++ pzlib_filefunc_def->zclose_file = fclose_file_func;
++ pzlib_filefunc_def->zerror_file = ferror_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
+diff --git a/converter/COLLADA2GLTF/kmz/ioapi.h b/converter/COLLADA2GLTF/kmz/ioapi.h
+new file mode 100644
+index 0000000..8dcbdb0
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/ioapi.h
+@@ -0,0 +1,208 @@
++/* ioapi.h -- IO base function header for compress/uncompress .zip
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++ Changes
++
++ Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
++ Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
++ More if/def section may be needed to support other platforms
++ Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
++ (but you should use iowin32.c for windows instead)
++
++*/
++
++#ifndef _ZLIBIOAPI64_H
++#define _ZLIBIOAPI64_H
++
++#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
++
++ // Linux needs this to support file operation on files larger then 4+GB
++ // But might need better if/def to select just the platforms that needs them.
++
++ #ifndef __USE_FILE_OFFSET64
++ #define __USE_FILE_OFFSET64
++ #endif
++ #ifndef __USE_LARGEFILE64
++ #define __USE_LARGEFILE64
++ #endif
++ #ifndef _LARGEFILE64_SOURCE
++ #define _LARGEFILE64_SOURCE
++ #endif
++ #ifndef _FILE_OFFSET_BIT
++ #define _FILE_OFFSET_BIT 64
++ #endif
++
++#endif
++
++#include <stdio.h>
++#include <stdlib.h>
++#include "zlib.h"
++
++#if defined(USE_FILE32API)
++#define fopen64 fopen
++#define ftello64 ftell
++#define fseeko64 fseek
++#else
++#ifdef __FreeBSD__
++#define fopen64 fopen
++#define ftello64 ftello
++#define fseeko64 fseeko
++#endif
++#ifdef _MSC_VER
++ #define fopen64 fopen
++ #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
++ #define ftello64 _ftelli64
++ #define fseeko64 _fseeki64
++ #else // old MSC
++ #define ftello64 ftell
++ #define fseeko64 fseek
++ #endif
++#endif
++#endif
++
++/*
++#ifndef ZPOS64_T
++ #ifdef _WIN32
++ #define ZPOS64_T fpos_t
++ #else
++ #include <stdint.h>
++ #define ZPOS64_T uint64_t
++ #endif
++#endif
++*/
++
++#ifdef HAVE_MINIZIP64_CONF_H
++#include "mz64conf.h"
++#endif
++
++/* a type choosen by DEFINE */
++#ifdef HAVE_64BIT_INT_CUSTOM
++typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
++#else
++#ifdef HAS_STDINT_H
++#include "stdint.h"
++typedef uint64_t ZPOS64_T;
++#else
++
++/* Maximum unsigned 32-bit value used as placeholder for zip64 */
++#define MAXU32 0xffffffff
++
++#if defined(_MSC_VER) || defined(__BORLANDC__)
++typedef unsigned __int64 ZPOS64_T;
++#else
++typedef unsigned long long int ZPOS64_T;
++#endif
++#endif
++#endif
++
++
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++#define ZLIB_FILEFUNC_SEEK_CUR (1)
++#define ZLIB_FILEFUNC_SEEK_END (2)
++#define ZLIB_FILEFUNC_SEEK_SET (0)
++
++#define ZLIB_FILEFUNC_MODE_READ (1)
++#define ZLIB_FILEFUNC_MODE_WRITE (2)
++#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
++
++#define ZLIB_FILEFUNC_MODE_EXISTING (4)
++#define ZLIB_FILEFUNC_MODE_CREATE (8)
++
++
++#ifndef ZCALLBACK
++ #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
++ #define ZCALLBACK CALLBACK
++ #else
++ #define ZCALLBACK
++ #endif
++#endif
++
++
++
++
++typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
++typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
++typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
++typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
++typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
++
++typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
++typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
++
++
++/* here is the "old" 32 bits structure structure */
++typedef struct zlib_filefunc_def_s
++{
++ open_file_func zopen_file;
++ read_file_func zread_file;
++ write_file_func zwrite_file;
++ tell_file_func ztell_file;
++ seek_file_func zseek_file;
++ close_file_func zclose_file;
++ testerror_file_func zerror_file;
++ voidpf opaque;
++} zlib_filefunc_def;
++
++typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream));
++typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
++typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode));
++
++typedef struct zlib_filefunc64_def_s
++{
++ open64_file_func zopen64_file;
++ read_file_func zread_file;
++ write_file_func zwrite_file;
++ tell64_file_func ztell64_file;
++ seek64_file_func zseek64_file;
++ close_file_func zclose_file;
++ testerror_file_func zerror_file;
++ voidpf opaque;
++} zlib_filefunc64_def;
++
++void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
++void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
++
++/* now internal definition, only for zip.c and unzip.h */
++typedef struct zlib_filefunc64_32_def_s
++{
++ zlib_filefunc64_def zfile_func64;
++ open_file_func zopen32_file;
++ tell_file_func ztell32_file;
++ seek_file_func zseek32_file;
++} zlib_filefunc64_32_def;
++
++
++#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
++#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
++//#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
++//#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
++#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))
++#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))
++
++voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
++long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
++ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
++
++void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
++
++#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode)))
++#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream)))
++#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+diff --git a/converter/COLLADA2GLTF/kmz/iowin32.c b/converter/COLLADA2GLTF/kmz/iowin32.c
+new file mode 100644
+index 0000000..a46d96c
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/iowin32.c
+@@ -0,0 +1,461 @@
++/* iowin32.c -- IO base function header for compress/uncompress .zip
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++*/
++
++#include <stdlib.h>
++
++#include "zlib.h"
++#include "ioapi.h"
++#include "iowin32.h"
++
++#ifndef INVALID_HANDLE_VALUE
++#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
++#endif
++
++#ifndef INVALID_SET_FILE_POINTER
++#define INVALID_SET_FILE_POINTER ((DWORD)-1)
++#endif
++
++
++#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
++#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
++#define IOWIN32_USING_WINRT_API 1
++#endif
++#endif
++
++voidpf ZCALLBACK win32_open_file_func OF((voidpf opaque, const char* filename, int mode));
++uLong ZCALLBACK win32_read_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
++uLong ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
++ZPOS64_T ZCALLBACK win32_tell64_file_func OF((voidpf opaque, voidpf stream));
++long ZCALLBACK win32_seek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
++int ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
++int ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
++
++typedef struct
++{
++ HANDLE hf;
++ int error;
++} WIN32FILE_IOWIN;
++
++
++static void win32_translate_open_mode(int mode,
++ DWORD* lpdwDesiredAccess,
++ DWORD* lpdwCreationDisposition,
++ DWORD* lpdwShareMode,
++ DWORD* lpdwFlagsAndAttributes)
++{
++ *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;
++
++ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
++ {
++ *lpdwDesiredAccess = GENERIC_READ;
++ *lpdwCreationDisposition = OPEN_EXISTING;
++ *lpdwShareMode = FILE_SHARE_READ;
++ }
++ else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
++ {
++ *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
++ *lpdwCreationDisposition = OPEN_EXISTING;
++ }
++ else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
++ {
++ *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
++ *lpdwCreationDisposition = CREATE_ALWAYS;
++ }
++}
++
++static voidpf win32_build_iowin(HANDLE hFile)
++{
++ voidpf ret=NULL;
++
++ if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
++ {
++ WIN32FILE_IOWIN w32fiow;
++ w32fiow.hf = hFile;
++ w32fiow.error = 0;
++ ret = malloc(sizeof(WIN32FILE_IOWIN));
++
++ if (ret==NULL)
++ CloseHandle(hFile);
++ else
++ *((WIN32FILE_IOWIN*)ret) = w32fiow;
++ }
++ return ret;
++}
++
++voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++#ifdef UNICODE
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ {
++ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
++ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
++ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++ }
++#endif
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ {
++ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
++ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
++ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++ }
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
++{
++ const char* mode_fopen = NULL;
++ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
++ HANDLE hFile = NULL;
++
++ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
++
++#ifdef IOWIN32_USING_WINRT_API
++#ifdef UNICODE
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ {
++ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
++ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
++ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
++ }
++#endif
++#else
++ if ((filename!=NULL) && (dwDesiredAccess != 0))
++ hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
++#endif
++
++ return win32_build_iowin(hFile);
++}
++
++
++uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size)
++{
++ uLong ret=0;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++
++ if (hFile != NULL)
++ {
++ if (!ReadFile(hFile, buf, size, &ret, NULL))
++ {
++ DWORD dwErr = GetLastError();
++ if (dwErr == ERROR_HANDLE_EOF)
++ dwErr = 0;
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ }
++ }
++
++ return ret;
++}
++
++
++uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size)
++{
++ uLong ret=0;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++
++ if (hFile != NULL)
++ {
++ if (!WriteFile(hFile, buf, size, &ret, NULL))
++ {
++ DWORD dwErr = GetLastError();
++ if (dwErr == ERROR_HANDLE_EOF)
++ dwErr = 0;
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ }
++ }
++
++ return ret;
++}
++
++static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod)
++{
++#ifdef IOWIN32_USING_WINRT_API
++ return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
++#else
++ LONG lHigh = pos.HighPart;
++ DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, FILE_CURRENT);
++ BOOL fOk = TRUE;
++ if (dwNewPos == 0xFFFFFFFF)
++ if (GetLastError() != NO_ERROR)
++ fOk = FALSE;
++ if ((newPos != NULL) && (fOk))
++ {
++ newPos->LowPart = dwNewPos;
++ newPos->HighPart = lHigh;
++ }
++ return fOk;
++#endif
++}
++
++long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream)
++{
++ long ret=-1;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++ if (hFile != NULL)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = 0;
++
++ if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = -1;
++ }
++ else
++ ret=(long)pos.LowPart;
++ }
++ return ret;
++}
++
++ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream)
++{
++ ZPOS64_T ret= (ZPOS64_T)-1;
++ HANDLE hFile = NULL;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream)->hf;
++
++ if (hFile)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = 0;
++
++ if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = (ZPOS64_T)-1;
++ }
++ else
++ ret=pos.QuadPart;
++ }
++ return ret;
++}
++
++
++long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin)
++{
++ DWORD dwMoveMethod=0xFFFFFFFF;
++ HANDLE hFile = NULL;
++
++ long ret=-1;
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ dwMoveMethod = FILE_CURRENT;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ dwMoveMethod = FILE_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ dwMoveMethod = FILE_BEGIN;
++ break;
++ default: return -1;
++ }
++
++ if (hFile != NULL)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = offset;
++ if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = -1;
++ }
++ else
++ ret=0;
++ }
++ return ret;
++}
++
++long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin)
++{
++ DWORD dwMoveMethod=0xFFFFFFFF;
++ HANDLE hFile = NULL;
++ long ret=-1;
++
++ if (stream!=NULL)
++ hFile = ((WIN32FILE_IOWIN*)stream)->hf;
++
++ switch (origin)
++ {
++ case ZLIB_FILEFUNC_SEEK_CUR :
++ dwMoveMethod = FILE_CURRENT;
++ break;
++ case ZLIB_FILEFUNC_SEEK_END :
++ dwMoveMethod = FILE_END;
++ break;
++ case ZLIB_FILEFUNC_SEEK_SET :
++ dwMoveMethod = FILE_BEGIN;
++ break;
++ default: return -1;
++ }
++
++ if (hFile)
++ {
++ LARGE_INTEGER pos;
++ pos.QuadPart = offset;
++ if (!MySetFilePointerEx(hFile, pos, NULL, FILE_CURRENT))
++ {
++ DWORD dwErr = GetLastError();
++ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
++ ret = -1;
++ }
++ else
++ ret=0;
++ }
++ return ret;
++}
++
++int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream)
++{
++ int ret=-1;
++
++ if (stream!=NULL)
++ {
++ HANDLE hFile;
++ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
++ if (hFile != NULL)
++ {
++ CloseHandle(hFile);
++ ret=0;
++ }
++ free(stream);
++ }
++ return ret;
++}
++
++int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream)
++{
++ int ret=-1;
++ if (stream!=NULL)
++ {
++ ret = ((WIN32FILE_IOWIN*)stream) -> error;
++ }
++ return ret;
++}
++
++void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen_file = win32_open_file_func;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell_file = win32_tell_file_func;
++ pzlib_filefunc_def->zseek_file = win32_seek_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
++ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++
++void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
++ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
++
++
++void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
++ pzlib_filefunc_def->zread_file = win32_read_file_func;
++ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
++ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
++ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
++ pzlib_filefunc_def->zclose_file = win32_close_file_func;
++ pzlib_filefunc_def->zerror_file = win32_error_file_func;
++ pzlib_filefunc_def->opaque = NULL;
++}
+diff --git a/converter/COLLADA2GLTF/kmz/iowin32.h b/converter/COLLADA2GLTF/kmz/iowin32.h
+new file mode 100644
+index 0000000..0ca0969
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/iowin32.h
+@@ -0,0 +1,28 @@
++/* iowin32.h -- IO base function header for compress/uncompress .zip
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++*/
++
++#include <windows.h>
++
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
++void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def));
++void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def));
++void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def));
++
++#ifdef __cplusplus
++}
++#endif
+diff --git a/converter/COLLADA2GLTF/kmz/unzip.c b/converter/COLLADA2GLTF/kmz/unzip.c
+new file mode 100644
+index 0000000..9093504
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/unzip.c
+@@ -0,0 +1,2125 @@
++/* unzip.c -- IO for uncompress .zip files using zlib
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications of Unzip for Zip64
++ Copyright (C) 2007-2008 Even Rouault
++
++ Modifications for Zip64 support on both zip and unzip
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++
++ ------------------------------------------------------------------------------------
++ Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
++ compatibility with older software. The following is from the original crypt.c.
++ Code woven in by Terry Thorsen 1/2003.
++
++ Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
++
++ See the accompanying file LICENSE, version 2000-Apr-09 or later
++ (the contents of which are also included in zip.h) for terms of use.
++ If, for some reason, all these files are missing, the Info-ZIP license
++ also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
++
++ crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
++
++ The encryption/decryption parts of this source code (as opposed to the
++ non-echoing password parts) were originally written in Europe. The
++ whole source package can be freely distributed, including from the USA.
++ (Prior to January 2000, re-export from the US was a violation of US law.)
++
++ This encryption code is a direct transcription of the algorithm from
++ Roger Schlafly, described by Phil Katz in the file appnote.txt. This
++ file (appnote.txt) is distributed with the PKZIP program (even in the
++ version without encryption capabilities).
++
++ ------------------------------------------------------------------------------------
++
++ Changes in unzip.c
++
++ 2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
++ 2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
++ 2007-2008 - Even Rouault - Remove old C style function prototypes
++ 2007-2008 - Even Rouault - Add unzip support for ZIP64
++
++ Copyright (C) 2007-2008 Even Rouault
++
++
++ Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
++ Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
++ should only read the compressed/uncompressed size from the Zip64 format if
++ the size from normal header was 0xFFFFFFFF
++ Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
++ Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
++ Patch created by Daniel Borca
++
++ Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
++
++ Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
++
++*/
++
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#ifndef NOUNCRYPT
++ #define NOUNCRYPT
++#endif
++
++#include "zlib.h"
++#include "unzip.h"
++
++#ifdef STDC
++# include <stddef.h>
++# include <string.h>
++# include <stdlib.h>
++#endif
++#ifdef NO_ERRNO_H
++ extern int errno;
++#else
++# include <errno.h>
++#endif
++
++
++#ifndef local
++# define local static
++#endif
++/* compile with -Dlocal if your debugger can't find static symbols */
++
++
++#ifndef CASESENSITIVITYDEFAULT_NO
++# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
++# define CASESENSITIVITYDEFAULT_NO
++# endif
++#endif
++
++
++#ifndef UNZ_BUFSIZE
++#define UNZ_BUFSIZE (16384)
++#endif
++
++#ifndef UNZ_MAXFILENAMEINZIP
++#define UNZ_MAXFILENAMEINZIP (256)
++#endif
++
++#ifndef ALLOC
++# define ALLOC(size) (malloc(size))
++#endif
++#ifndef TRYFREE
++# define TRYFREE(p) {if (p) free(p);}
++#endif
++
++#define SIZECENTRALDIRITEM (0x2e)
++#define SIZEZIPLOCALHEADER (0x1e)
++
++
++const char unz_copyright[] =
++ " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
++
++/* unz_file_info_interntal contain internal info about a file in zipfile*/
++typedef struct unz_file_info64_internal_s
++{
++ ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
++} unz_file_info64_internal;
++
++
++/* file_in_zip_read_info_s contain internal information about a file in zipfile,
++ when reading and decompress it */
++typedef struct
++{
++ char *read_buffer; /* internal buffer for compressed data */
++ z_stream stream; /* zLib stream structure for inflate */
++
++#ifdef HAVE_BZIP2
++ bz_stream bstream; /* bzLib stream structure for bziped */
++#endif
++
++ ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
++ uLong stream_initialised; /* flag set if stream structure is initialised*/
++
++ ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
++ uInt size_local_extrafield;/* size of the local extra field */
++ ZPOS64_T pos_local_extrafield; /* position in the local extra field in read*/
++ ZPOS64_T total_out_64;
++
++ uLong crc32; /* crc32 of all data uncompressed */
++ uLong crc32_wait; /* crc32 we must obtain after decompress all */
++ ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
++ ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
++ zlib_filefunc64_32_def z_filefunc;
++ voidpf filestream; /* io structore of the zipfile */
++ uLong compression_method; /* compression method (0==store) */
++ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
++ int raw;
++} file_in_zip64_read_info_s;
++
++
++/* unz64_s contain internal information about the zipfile
++*/
++typedef struct
++{
++ zlib_filefunc64_32_def z_filefunc;
++ int is64bitOpenFunction;
++ voidpf filestream; /* io structore of the zipfile */
++ unz_global_info64 gi; /* public global information */
++ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
++ ZPOS64_T num_file; /* number of the current file in the zipfile*/
++ ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/
++ ZPOS64_T current_file_ok; /* flag about the usability of the current file*/
++ ZPOS64_T central_pos; /* position of the beginning of the central dir*/
++
++ ZPOS64_T size_central_dir; /* size of the central directory */
++ ZPOS64_T offset_central_dir; /* offset of start of central directory with
++ respect to the starting disk number */
++
++ unz_file_info64 cur_file_info; /* public info about the current file in zip*/
++ unz_file_info64_internal cur_file_info_internal; /* private info about it*/
++ file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
++ file if we are decompressing it */
++ int encrypted;
++
++ int isZip64;
++
++# ifndef NOUNCRYPT
++ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
++ const z_crc_t* pcrc_32_tab;
++# endif
++} unz64_s;
++
++
++#ifndef NOUNCRYPT
++#include "crypt.h"
++#endif
++
++/* ===========================================================================
++ Read a byte from a gz_stream; update next_in and avail_in. Return EOF
++ for end of file.
++ IN assertion: the stream s has been sucessfully opened for reading.
++*/
++
++
++local int unz64local_getByte OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ int *pi));
++
++local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)
++{
++ unsigned char c;
++ int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
++ if (err==1)
++ {
++ *pi = (int)c;
++ return UNZ_OK;
++ }
++ else
++ {
++ if (ZERROR64(*pzlib_filefunc_def,filestream))
++ return UNZ_ERRNO;
++ else
++ return UNZ_EOF;
++ }
++}
++
++
++/* ===========================================================================
++ Reads a long in LSB order from the given gz_stream. Sets
++*/
++local int unz64local_getShort OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX));
++
++local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX)
++{
++ uLong x ;
++ int i = 0;
++ int err;
++
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (uLong)i;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((uLong)i)<<8;
++
++ if (err==UNZ_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++local int unz64local_getLong OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX));
++
++local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ uLong *pX)
++{
++ uLong x ;
++ int i = 0;
++ int err;
++
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (uLong)i;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((uLong)i)<<8;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((uLong)i)<<16;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((uLong)i)<<24;
++
++ if (err==UNZ_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++local int unz64local_getLong64 OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ ZPOS64_T *pX));
++
++
++local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream,
++ ZPOS64_T *pX)
++{
++ ZPOS64_T x ;
++ int i = 0;
++ int err;
++
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (ZPOS64_T)i;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<8;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<16;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<24;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<32;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<40;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<48;
++
++ if (err==UNZ_OK)
++ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x |= ((ZPOS64_T)i)<<56;
++
++ if (err==UNZ_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++/* My own strcmpi / strcasecmp */
++local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
++{
++ for (;;)
++ {
++ char c1=*(fileName1++);
++ char c2=*(fileName2++);
++ if ((c1>='a') && (c1<='z'))
++ c1 -= 0x20;
++ if ((c2>='a') && (c2<='z'))
++ c2 -= 0x20;
++ if (c1=='\0')
++ return ((c2=='\0') ? 0 : -1);
++ if (c2=='\0')
++ return 1;
++ if (c1<c2)
++ return -1;
++ if (c1>c2)
++ return 1;
++ }
++}
++
++
++#ifdef CASESENSITIVITYDEFAULT_NO
++#define CASESENSITIVITYDEFAULTVALUE 2
++#else
++#define CASESENSITIVITYDEFAULTVALUE 1
++#endif
++
++#ifndef STRCMPCASENOSENTIVEFUNCTION
++#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
++#endif
++
++/*
++ Compare two filename (fileName1,fileName2).
++ If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
++ If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
++ or strcasecmp)
++ If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
++ (like 1 on Unix, 2 on Windows)
++
++*/
++extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,
++ const char* fileName2,
++ int iCaseSensitivity)
++
++{
++ if (iCaseSensitivity==0)
++ iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
++
++ if (iCaseSensitivity==1)
++ return strcmp(fileName1,fileName2);
++
++ return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
++}
++
++#ifndef BUFREADCOMMENT
++#define BUFREADCOMMENT (0x400)
++#endif
++
++/*
++ Locate the Central directory of a zipfile (at the end, just before
++ the global comment)
++*/
++local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
++local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
++{
++ unsigned char* buf;
++ ZPOS64_T uSizeFile;
++ ZPOS64_T uBackRead;
++ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
++ ZPOS64_T uPosFound=0;
++
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
++ return 0;
++
++
++ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
++
++ if (uMaxBack>uSizeFile)
++ uMaxBack = uSizeFile;
++
++ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
++ if (buf==NULL)
++ return 0;
++
++ uBackRead = 4;
++ while (uBackRead<uMaxBack)
++ {
++ uLong uReadSize;
++ ZPOS64_T uReadPos ;
++ int i;
++ if (uBackRead+BUFREADCOMMENT>uMaxBack)
++ uBackRead = uMaxBack;
++ else
++ uBackRead+=BUFREADCOMMENT;
++ uReadPos = uSizeFile-uBackRead ;
++
++ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
++ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ break;
++
++ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
++ break;
++
++ for (i=(int)uReadSize-3; (i--)>0;)
++ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
++ ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
++ {
++ uPosFound = uReadPos+i;
++ break;
++ }
++
++ if (uPosFound!=0)
++ break;
++ }
++ TRYFREE(buf);
++ return uPosFound;
++}
++
++
++/*
++ Locate the Central directory 64 of a zipfile (at the end, just before
++ the global comment)
++*/
++local ZPOS64_T unz64local_SearchCentralDir64 OF((
++ const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream));
++
++local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
++ voidpf filestream)
++{
++ unsigned char* buf;
++ ZPOS64_T uSizeFile;
++ ZPOS64_T uBackRead;
++ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
++ ZPOS64_T uPosFound=0;
++ uLong uL;
++ ZPOS64_T relativeOffset;
++
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
++ return 0;
++
++
++ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
++
++ if (uMaxBack>uSizeFile)
++ uMaxBack = uSizeFile;
++
++ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
++ if (buf==NULL)
++ return 0;
++
++ uBackRead = 4;
++ while (uBackRead<uMaxBack)
++ {
++ uLong uReadSize;
++ ZPOS64_T uReadPos;
++ int i;
++ if (uBackRead+BUFREADCOMMENT>uMaxBack)
++ uBackRead = uMaxBack;
++ else
++ uBackRead+=BUFREADCOMMENT;
++ uReadPos = uSizeFile-uBackRead ;
++
++ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
++ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ break;
++
++ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
++ break;
++
++ for (i=(int)uReadSize-3; (i--)>0;)
++ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
++ ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
++ {
++ uPosFound = uReadPos+i;
++ break;
++ }
++
++ if (uPosFound!=0)
++ break;
++ }
++ TRYFREE(buf);
++ if (uPosFound == 0)
++ return 0;
++
++ /* Zip64 end of central directory locator */
++ if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return 0;
++
++ /* the signature, already checked */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++
++ /* number of the disk with the start of the zip64 end of central directory */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++ if (uL != 0)
++ return 0;
++
++ /* relative offset of the zip64 end of central directory record */
++ if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
++ return 0;
++
++ /* total number of disks */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++ if (uL != 1)
++ return 0;
++
++ /* Goto end of central directory record */
++ if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return 0;
++
++ /* the signature */
++ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
++ return 0;
++
++ if (uL != 0x06064b50)
++ return 0;
++
++ return relativeOffset;
++}
++
++/*
++ Open a Zip file. path contain the full pathname (by example,
++ on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
++ "zlib/zlib114.zip".
++ If the zipfile cannot be opened (file doesn't exist or in not valid), the
++ return value is NULL.
++ Else, the return value is a unzFile Handle, usable with other function
++ of this unzip package.
++*/
++local unzFile unzOpenInternal (const void *path,
++ zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
++ int is64bitOpenFunction)
++{
++ unz64_s us;
++ unz64_s *s;
++ ZPOS64_T central_pos;
++ uLong uL;
++
++ uLong number_disk; /* number of the current dist, used for
++ spaning ZIP, unsupported, always 0*/
++ uLong number_disk_with_CD; /* number the the disk with central dir, used
++ for spaning ZIP, unsupported, always 0*/
++ ZPOS64_T number_entry_CD; /* total number of entries in
++ the central dir
++ (same than number_entry on nospan) */
++
++ int err=UNZ_OK;
++
++ if (unz_copyright[0]!=' ')
++ return NULL;
++
++ us.z_filefunc.zseek32_file = NULL;
++ us.z_filefunc.ztell32_file = NULL;
++ if (pzlib_filefunc64_32_def==NULL)
++ fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
++ else
++ us.z_filefunc = *pzlib_filefunc64_32_def;
++ us.is64bitOpenFunction = is64bitOpenFunction;
++
++
++
++ us.filestream = ZOPEN64(us.z_filefunc,
++ path,
++ ZLIB_FILEFUNC_MODE_READ |
++ ZLIB_FILEFUNC_MODE_EXISTING);
++ if (us.filestream==NULL)
++ return NULL;
++
++ central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
++ if (central_pos)
++ {
++ uLong uS;
++ ZPOS64_T uL64;
++
++ us.isZip64 = 1;
++
++ if (ZSEEK64(us.z_filefunc, us.filestream,
++ central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=UNZ_ERRNO;
++
++ /* the signature, already checked */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* size of zip64 end of central directory record */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* version made by */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* version needed to extract */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of this disk */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of the disk with the start of the central directory */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* total number of entries in the central directory on this disk */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* total number of entries in the central directory */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if ((number_entry_CD!=us.gi.number_entry) ||
++ (number_disk_with_CD!=0) ||
++ (number_disk!=0))
++ err=UNZ_BADZIPFILE;
++
++ /* size of the central directory */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* offset of start of central directory with respect to the
++ starting disk number */
++ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ us.gi.size_comment = 0;
++ }
++ else
++ {
++ central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
++ if (central_pos==0)
++ err=UNZ_ERRNO;
++
++ us.isZip64 = 0;
++
++ if (ZSEEK64(us.z_filefunc, us.filestream,
++ central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=UNZ_ERRNO;
++
++ /* the signature, already checked */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of this disk */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* number of the disk with the start of the central directory */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* total number of entries in the central dir on this disk */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ us.gi.number_entry = uL;
++
++ /* total number of entries in the central dir */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ number_entry_CD = uL;
++
++ if ((number_entry_CD!=us.gi.number_entry) ||
++ (number_disk_with_CD!=0) ||
++ (number_disk!=0))
++ err=UNZ_BADZIPFILE;
++
++ /* size of the central directory */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ us.size_central_dir = uL;
++
++ /* offset of start of central directory with respect to the
++ starting disk number */
++ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ us.offset_central_dir = uL;
++
++ /* zipfile comment length */
++ if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
++ (err==UNZ_OK))
++ err=UNZ_BADZIPFILE;
++
++ if (err!=UNZ_OK)
++ {
++ ZCLOSE64(us.z_filefunc, us.filestream);
++ return NULL;
++ }
++
++ us.byte_before_the_zipfile = central_pos -
++ (us.offset_central_dir+us.size_central_dir);
++ us.central_pos = central_pos;
++ us.pfile_in_zip_read = NULL;
++ us.encrypted = 0;
++
++
++ s=(unz64_s*)ALLOC(sizeof(unz64_s));
++ if( s != NULL)
++ {
++ *s=us;
++ unzGoToFirstFile((unzFile)s);
++ }
++ return (unzFile)s;
++}
++
++
++extern unzFile ZEXPORT unzOpen2 (const char *path,
++ zlib_filefunc_def* pzlib_filefunc32_def)
++{
++ if (pzlib_filefunc32_def != NULL)
++ {
++ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
++ fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
++ return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
++ }
++ else
++ return unzOpenInternal(path, NULL, 0);
++}
++
++extern unzFile ZEXPORT unzOpen2_64 (const void *path,
++ zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ if (pzlib_filefunc_def != NULL)
++ {
++ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
++ zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
++ zlib_filefunc64_32_def_fill.ztell32_file = NULL;
++ zlib_filefunc64_32_def_fill.zseek32_file = NULL;
++ return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
++ }
++ else
++ return unzOpenInternal(path, NULL, 1);
++}
++
++extern unzFile ZEXPORT unzOpen (const char *path)
++{
++ return unzOpenInternal(path, NULL, 0);
++}
++
++extern unzFile ZEXPORT unzOpen64 (const void *path)
++{
++ return unzOpenInternal(path, NULL, 1);
++}
++
++/*
++ Close a ZipFile opened with unzOpen.
++ If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
++ these files MUST be closed with unzCloseCurrentFile before call unzClose.
++ return UNZ_OK if there is no problem. */
++extern int ZEXPORT unzClose (unzFile file)
++{
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++
++ if (s->pfile_in_zip_read!=NULL)
++ unzCloseCurrentFile(file);
++
++ ZCLOSE64(s->z_filefunc, s->filestream);
++ TRYFREE(s);
++ return UNZ_OK;
++}
++
++
++/*
++ Write info about the ZipFile in the *pglobal_info structure.
++ No preparation of the structure is needed
++ return UNZ_OK if there is no problem. */
++extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
++{
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ *pglobal_info=s->gi;
++ return UNZ_OK;
++}
++
++extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
++{
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ /* to do : check if number_entry is not truncated */
++ pglobal_info32->number_entry = (uLong)s->gi.number_entry;
++ pglobal_info32->size_comment = s->gi.size_comment;
++ return UNZ_OK;
++}
++/*
++ Translate date/time from Dos format to tm_unz (readable more easilty)
++*/
++local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
++{
++ ZPOS64_T uDate;
++ uDate = (ZPOS64_T)(ulDosDate>>16);
++ ptm->tm_mday = (uInt)(uDate&0x1f) ;
++ ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
++ ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
++
++ ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
++ ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
++ ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
++}
++
++/*
++ Get Info about the current file in the zipfile, with internal only info
++*/
++local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
++ unz_file_info64 *pfile_info,
++ unz_file_info64_internal
++ *pfile_info_internal,
++ char *szFileName,
++ uLong fileNameBufferSize,
++ void *extraField,
++ uLong extraFieldBufferSize,
++ char *szComment,
++ uLong commentBufferSize));
++
++local int unz64local_GetCurrentFileInfoInternal (unzFile file,
++ unz_file_info64 *pfile_info,
++ unz_file_info64_internal
++ *pfile_info_internal,
++ char *szFileName,
++ uLong fileNameBufferSize,
++ void *extraField,
++ uLong extraFieldBufferSize,
++ char *szComment,
++ uLong commentBufferSize)
++{
++ unz64_s* s;
++ unz_file_info64 file_info;
++ unz_file_info64_internal file_info_internal;
++ int err=UNZ_OK;
++ uLong uMagic;
++ long lSeek=0;
++ uLong uL;
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (ZSEEK64(s->z_filefunc, s->filestream,
++ s->pos_in_central_dir+s->byte_before_the_zipfile,
++ ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=UNZ_ERRNO;
++
++
++ /* we check the magic */
++ if (err==UNZ_OK)
++ {
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if (uMagic!=0x02014b50)
++ err=UNZ_BADZIPFILE;
++ }
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ file_info.compressed_size = uL;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ file_info.uncompressed_size = uL;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ // relative offset of local header
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ file_info_internal.offset_curfile = uL;
++
++ lSeek+=file_info.size_filename;
++ if ((err==UNZ_OK) && (szFileName!=NULL))
++ {
++ uLong uSizeRead ;
++ if (file_info.size_filename<fileNameBufferSize)
++ {
++ *(szFileName+file_info.size_filename)='\0';
++ uSizeRead = file_info.size_filename;
++ }
++ else
++ uSizeRead = fileNameBufferSize;
++
++ if ((file_info.size_filename>0) && (fileNameBufferSize>0))
++ if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
++ err=UNZ_ERRNO;
++ lSeek -= uSizeRead;
++ }
++
++ // Read extrafield
++ if ((err==UNZ_OK) && (extraField!=NULL))
++ {
++ ZPOS64_T uSizeRead ;
++ if (file_info.size_file_extra<extraFieldBufferSize)
++ uSizeRead = file_info.size_file_extra;
++ else
++ uSizeRead = extraFieldBufferSize;
++
++ if (lSeek!=0)
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
++ lSeek=0;
++ else
++ err=UNZ_ERRNO;
++ }
++
++ if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
++ if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
++ err=UNZ_ERRNO;
++
++ lSeek += file_info.size_file_extra - (uLong)uSizeRead;
++ }
++ else
++ lSeek += file_info.size_file_extra;
++
++
++ if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
++ {
++ uLong acc = 0;
++
++ // since lSeek now points to after the extra field we need to move back
++ lSeek -= file_info.size_file_extra;
++
++ if (lSeek!=0)
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
++ lSeek=0;
++ else
++ err=UNZ_ERRNO;
++ }
++
++ while(acc < file_info.size_file_extra)
++ {
++ uLong headerId;
++ uLong dataSize;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ /* ZIP64 extra fields */
++ if (headerId == 0x0001)
++ {
++ uLong uL;
++
++ if(file_info.uncompressed_size == MAXU32)
++ {
++ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if(file_info.compressed_size == MAXU32)
++ {
++ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if(file_info_internal.offset_curfile == MAXU32)
++ {
++ /* Relative Header offset */
++ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ if(file_info.disk_num_start == MAXU32)
++ {
++ /* Disk Start Number */
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
++ err=UNZ_ERRNO;
++ }
++
++ }
++ else
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
++ err=UNZ_ERRNO;
++ }
++
++ acc += 2 + 2 + dataSize;
++ }
++ }
++
++ if ((err==UNZ_OK) && (szComment!=NULL))
++ {
++ uLong uSizeRead ;
++ if (file_info.size_file_comment<commentBufferSize)
++ {
++ *(szComment+file_info.size_file_comment)='\0';
++ uSizeRead = file_info.size_file_comment;
++ }
++ else
++ uSizeRead = commentBufferSize;
++
++ if (lSeek!=0)
++ {
++ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
++ lSeek=0;
++ else
++ err=UNZ_ERRNO;
++ }
++
++ if ((file_info.size_file_comment>0) && (commentBufferSize>0))
++ if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
++ err=UNZ_ERRNO;
++ lSeek+=file_info.size_file_comment - uSizeRead;
++ }
++ else
++ lSeek+=file_info.size_file_comment;
++
++
++ if ((err==UNZ_OK) && (pfile_info!=NULL))
++ *pfile_info=file_info;
++
++ if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
++ *pfile_info_internal=file_info_internal;
++
++ return err;
++}
++
++
++
++/*
++ Write info about the ZipFile in the *pglobal_info structure.
++ No preparation of the structure is needed
++ return UNZ_OK if there is no problem.
++*/
++extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
++ unz_file_info64 * pfile_info,
++ char * szFileName, uLong fileNameBufferSize,
++ void *extraField, uLong extraFieldBufferSize,
++ char* szComment, uLong commentBufferSize)
++{
++ return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
++ szFileName,fileNameBufferSize,
++ extraField,extraFieldBufferSize,
++ szComment,commentBufferSize);
++}
++
++extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
++ unz_file_info * pfile_info,
++ char * szFileName, uLong fileNameBufferSize,
++ void *extraField, uLong extraFieldBufferSize,
++ char* szComment, uLong commentBufferSize)
++{
++ int err;
++ unz_file_info64 file_info64;
++ err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
++ szFileName,fileNameBufferSize,
++ extraField,extraFieldBufferSize,
++ szComment,commentBufferSize);
++ if ((err==UNZ_OK) && (pfile_info != NULL))
++ {
++ pfile_info->version = file_info64.version;
++ pfile_info->version_needed = file_info64.version_needed;
++ pfile_info->flag = file_info64.flag;
++ pfile_info->compression_method = file_info64.compression_method;
++ pfile_info->dosDate = file_info64.dosDate;
++ pfile_info->crc = file_info64.crc;
++
++ pfile_info->size_filename = file_info64.size_filename;
++ pfile_info->size_file_extra = file_info64.size_file_extra;
++ pfile_info->size_file_comment = file_info64.size_file_comment;
++
++ pfile_info->disk_num_start = file_info64.disk_num_start;
++ pfile_info->internal_fa = file_info64.internal_fa;
++ pfile_info->external_fa = file_info64.external_fa;
++
++ pfile_info->tmu_date = file_info64.tmu_date,
++
++
++ pfile_info->compressed_size = (uLong)file_info64.compressed_size;
++ pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
++
++ }
++ return err;
++}
++/*
++ Set the current file of the zipfile to the first file.
++ return UNZ_OK if there is no problem
++*/
++extern int ZEXPORT unzGoToFirstFile (unzFile file)
++{
++ int err=UNZ_OK;
++ unz64_s* s;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ s->pos_in_central_dir=s->offset_central_dir;
++ s->num_file=0;
++ err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++/*
++ Set the current file of the zipfile to the next file.
++ return UNZ_OK if there is no problem
++ return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
++*/
++extern int ZEXPORT unzGoToNextFile (unzFile file)
++{
++ unz64_s* s;
++ int err;
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_END_OF_LIST_OF_FILE;
++ if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
++ if (s->num_file+1==s->gi.number_entry)
++ return UNZ_END_OF_LIST_OF_FILE;
++
++ s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
++ s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
++ s->num_file++;
++ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++
++/*
++ Try locate the file szFileName in the zipfile.
++ For the iCaseSensitivity signification, see unzStringFileNameCompare
++
++ return value :
++ UNZ_OK if the file is found. It becomes the current file.
++ UNZ_END_OF_LIST_OF_FILE if the file is not found
++*/
++extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
++{
++ unz64_s* s;
++ int err;
++
++ /* We remember the 'current' position in the file so that we can jump
++ * back there if we fail.
++ */
++ unz_file_info64 cur_file_infoSaved;
++ unz_file_info64_internal cur_file_info_internalSaved;
++ ZPOS64_T num_fileSaved;
++ ZPOS64_T pos_in_central_dirSaved;
++
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++
++ if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
++ return UNZ_PARAMERROR;
++
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_END_OF_LIST_OF_FILE;
++
++ /* Save the current state */
++ num_fileSaved = s->num_file;
++ pos_in_central_dirSaved = s->pos_in_central_dir;
++ cur_file_infoSaved = s->cur_file_info;
++ cur_file_info_internalSaved = s->cur_file_info_internal;
++
++ err = unzGoToFirstFile(file);
++
++ while (err == UNZ_OK)
++ {
++ char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
++ err = unzGetCurrentFileInfo64(file,NULL,
++ szCurrentFileName,sizeof(szCurrentFileName)-1,
++ NULL,0,NULL,0);
++ if (err == UNZ_OK)
++ {
++ if (unzStringFileNameCompare(szCurrentFileName,
++ szFileName,iCaseSensitivity)==0)
++ return UNZ_OK;
++ err = unzGoToNextFile(file);
++ }
++ }
++
++ /* We failed, so restore the state of the 'current file' to where we
++ * were.
++ */
++ s->num_file = num_fileSaved ;
++ s->pos_in_central_dir = pos_in_central_dirSaved ;
++ s->cur_file_info = cur_file_infoSaved;
++ s->cur_file_info_internal = cur_file_info_internalSaved;
++ return err;
++}
++
++
++/*
++///////////////////////////////////////////
++// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
++// I need random access
++//
++// Further optimization could be realized by adding an ability
++// to cache the directory in memory. The goal being a single
++// comprehensive file read to put the file I need in a memory.
++*/
++
++/*
++typedef struct unz_file_pos_s
++{
++ ZPOS64_T pos_in_zip_directory; // offset in file
++ ZPOS64_T num_of_file; // # of file
++} unz_file_pos;
++*/
++
++extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)
++{
++ unz64_s* s;
++
++ if (file==NULL || file_pos==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_END_OF_LIST_OF_FILE;
++
++ file_pos->pos_in_zip_directory = s->pos_in_central_dir;
++ file_pos->num_of_file = s->num_file;
++
++ return UNZ_OK;
++}
++
++extern int ZEXPORT unzGetFilePos(
++ unzFile file,
++ unz_file_pos* file_pos)
++{
++ unz64_file_pos file_pos64;
++ int err = unzGetFilePos64(file,&file_pos64);
++ if (err==UNZ_OK)
++ {
++ file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
++ file_pos->num_of_file = (uLong)file_pos64.num_of_file;
++ }
++ return err;
++}
++
++extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
++{
++ unz64_s* s;
++ int err;
++
++ if (file==NULL || file_pos==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++
++ /* jump to the right spot */
++ s->pos_in_central_dir = file_pos->pos_in_zip_directory;
++ s->num_file = file_pos->num_of_file;
++
++ /* set the current file */
++ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ /* return results */
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++extern int ZEXPORT unzGoToFilePos(
++ unzFile file,
++ unz_file_pos* file_pos)
++{
++ unz64_file_pos file_pos64;
++ if (file_pos == NULL)
++ return UNZ_PARAMERROR;
++
++ file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
++ file_pos64.num_of_file = file_pos->num_of_file;
++ return unzGoToFilePos64(file,&file_pos64);
++}
++
++/*
++// Unzip Helper Functions - should be here?
++///////////////////////////////////////////
++*/
++
++/*
++ Read the local header of the current zipfile
++ Check the coherency of the local header and info in the end of central
++ directory about this file
++ store in *piSizeVar the size of extra info in local header
++ (filename and size of extra field data)
++*/
++local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
++ ZPOS64_T * poffset_local_extrafield,
++ uInt * psize_local_extrafield)
++{
++ uLong uMagic,uData,uFlags;
++ uLong size_filename;
++ uLong size_extra_field;
++ int err=UNZ_OK;
++
++ *piSizeVar = 0;
++ *poffset_local_extrafield = 0;
++ *psize_local_extrafield = 0;
++
++ if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
++ s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return UNZ_ERRNO;
++
++
++ if (err==UNZ_OK)
++ {
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if (uMagic!=0x04034b50)
++ err=UNZ_BADZIPFILE;
++ }
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
++ err=UNZ_ERRNO;
++/*
++ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
++ err=UNZ_BADZIPFILE;
++*/
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
++ err=UNZ_ERRNO;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
++ err=UNZ_BADZIPFILE;
++
++ if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
++/* #ifdef HAVE_BZIP2 */
++ (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
++/* #endif */
++ (s->cur_file_info.compression_method!=Z_DEFLATED))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
++ err=UNZ_ERRNO;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
++ err=UNZ_ERRNO;
++ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
++ err=UNZ_ERRNO;
++ else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
++ err=UNZ_ERRNO;
++ else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
++ err=UNZ_BADZIPFILE;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
++ err=UNZ_ERRNO;
++ else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
++ err=UNZ_BADZIPFILE;
++
++ *piSizeVar += (uInt)size_filename;
++
++ if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
++ err=UNZ_ERRNO;
++ *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
++ SIZEZIPLOCALHEADER + size_filename;
++ *psize_local_extrafield = (uInt)size_extra_field;
++
++ *piSizeVar += (uInt)size_extra_field;
++
++ return err;
++}
++
++/*
++ Open for reading data the current file in the zipfile.
++ If there is no error and the file is opened, the return value is UNZ_OK.
++*/
++extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
++ int* level, int raw, const char* password)
++{
++ int err=UNZ_OK;
++ uInt iSizeVar;
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ ZPOS64_T offset_local_extrafield; /* offset of the local extra field */
++ uInt size_local_extrafield; /* size of the local extra field */
++# ifndef NOUNCRYPT
++ char source[12];
++# else
++ if (password != NULL)
++ return UNZ_PARAMERROR;
++# endif
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return UNZ_PARAMERROR;
++
++ if (s->pfile_in_zip_read != NULL)
++ unzCloseCurrentFile(file);
++
++ if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
++ return UNZ_BADZIPFILE;
++
++ pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_INTERNALERROR;
++
++ pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
++ pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
++ pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
++ pfile_in_zip_read_info->pos_local_extrafield=0;
++ pfile_in_zip_read_info->raw=raw;
++
++ if (pfile_in_zip_read_info->read_buffer==NULL)
++ {
++ TRYFREE(pfile_in_zip_read_info);
++ return UNZ_INTERNALERROR;
++ }
++
++ pfile_in_zip_read_info->stream_initialised=0;
++
++ if (method!=NULL)
++ *method = (int)s->cur_file_info.compression_method;
++
++ if (level!=NULL)
++ {
++ *level = 6;
++ switch (s->cur_file_info.flag & 0x06)
++ {
++ case 6 : *level = 1; break;
++ case 4 : *level = 2; break;
++ case 2 : *level = 9; break;
++ }
++ }
++
++ if ((s->cur_file_info.compression_method!=0) &&
++/* #ifdef HAVE_BZIP2 */
++ (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
++/* #endif */
++ (s->cur_file_info.compression_method!=Z_DEFLATED))
++
++ err=UNZ_BADZIPFILE;
++
++ pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
++ pfile_in_zip_read_info->crc32=0;
++ pfile_in_zip_read_info->total_out_64=0;
++ pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;
++ pfile_in_zip_read_info->filestream=s->filestream;
++ pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
++ pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
++
++ pfile_in_zip_read_info->stream.total_out = 0;
++
++ if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))
++ {
++#ifdef HAVE_BZIP2
++ pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
++ pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
++ pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
++ pfile_in_zip_read_info->bstream.state = (voidpf)0;
++
++ pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
++ pfile_in_zip_read_info->stream.zfree = (free_func)0;
++ pfile_in_zip_read_info->stream.opaque = (voidpf)0;
++ pfile_in_zip_read_info->stream.next_in = (voidpf)0;
++ pfile_in_zip_read_info->stream.avail_in = 0;
++
++ err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
++ if (err == Z_OK)
++ pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
++ else
++ {
++ TRYFREE(pfile_in_zip_read_info);
++ return err;
++ }
++#else
++ pfile_in_zip_read_info->raw=1;
++#endif
++ }
++ else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))
++ {
++ pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
++ pfile_in_zip_read_info->stream.zfree = (free_func)0;
++ pfile_in_zip_read_info->stream.opaque = (voidpf)0;
++ pfile_in_zip_read_info->stream.next_in = 0;
++ pfile_in_zip_read_info->stream.avail_in = 0;
++
++ err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
++ if (err == Z_OK)
++ pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
++ else
++ {
++ TRYFREE(pfile_in_zip_read_info);
++ return err;
++ }
++ /* windowBits is passed < 0 to tell that there is no zlib header.
++ * Note that in this case inflate *requires* an extra "dummy" byte
++ * after the compressed stream in order to complete decompression and
++ * return Z_STREAM_END.
++ * In unzip, i don't wait absolutely Z_STREAM_END because I known the
++ * size of both compressed and uncompressed data
++ */
++ }
++ pfile_in_zip_read_info->rest_read_compressed =
++ s->cur_file_info.compressed_size ;
++ pfile_in_zip_read_info->rest_read_uncompressed =
++ s->cur_file_info.uncompressed_size ;
++
++
++ pfile_in_zip_read_info->pos_in_zipfile =
++ s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
++ iSizeVar;
++
++ pfile_in_zip_read_info->stream.avail_in = (uInt)0;
++
++ s->pfile_in_zip_read = pfile_in_zip_read_info;
++ s->encrypted = 0;
++
++# ifndef NOUNCRYPT
++ if (password != NULL)
++ {
++ int i;
++ s->pcrc_32_tab = get_crc_table();
++ init_keys(password,s->keys,s->pcrc_32_tab);
++ if (ZSEEK64(s->z_filefunc, s->filestream,
++ s->pfile_in_zip_read->pos_in_zipfile +
++ s->pfile_in_zip_read->byte_before_the_zipfile,
++ SEEK_SET)!=0)
++ return UNZ_INTERNALERROR;
++ if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
++ return UNZ_INTERNALERROR;
++
++ for (i = 0; i<12; i++)
++ zdecode(s->keys,s->pcrc_32_tab,source[i]);
++
++ s->pfile_in_zip_read->pos_in_zipfile+=12;
++ s->encrypted=1;
++ }
++# endif
++
++
++ return UNZ_OK;
++}
++
++extern int ZEXPORT unzOpenCurrentFile (unzFile file)
++{
++ return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
++}
++
++extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password)
++{
++ return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
++}
++
++extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)
++{
++ return unzOpenCurrentFile3(file, method, level, raw, NULL);
++}
++
++/** Addition for GDAL : START */
++
++extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)
++{
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ s=(unz64_s*)file;
++ if (file==NULL)
++ return 0; //UNZ_PARAMERROR;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++ if (pfile_in_zip_read_info==NULL)
++ return 0; //UNZ_PARAMERROR;
++ return pfile_in_zip_read_info->pos_in_zipfile +
++ pfile_in_zip_read_info->byte_before_the_zipfile;
++}
++
++/** Addition for GDAL : END */
++
++/*
++ Read bytes from the current file.
++ buf contain buffer where data must be copied
++ len the size of buf.
++
++ return the number of byte copied if somes bytes are copied
++ return 0 if the end of file was reached
++ return <0 with error code if there is an error
++ (UNZ_ERRNO for IO error, or zLib error for uncompress error)
++*/
++extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)
++{
++ int err=UNZ_OK;
++ uInt iRead = 0;
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_PARAMERROR;
++
++
++ if (pfile_in_zip_read_info->read_buffer == NULL)
++ return UNZ_END_OF_LIST_OF_FILE;
++ if (len==0)
++ return 0;
++
++ pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
++
++ pfile_in_zip_read_info->stream.avail_out = (uInt)len;
++
++ if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
++ (!(pfile_in_zip_read_info->raw)))
++ pfile_in_zip_read_info->stream.avail_out =
++ (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
++
++ if ((len>pfile_in_zip_read_info->rest_read_compressed+
++ pfile_in_zip_read_info->stream.avail_in) &&
++ (pfile_in_zip_read_info->raw))
++ pfile_in_zip_read_info->stream.avail_out =
++ (uInt)pfile_in_zip_read_info->rest_read_compressed+
++ pfile_in_zip_read_info->stream.avail_in;
++
++ while (pfile_in_zip_read_info->stream.avail_out>0)
++ {
++ if ((pfile_in_zip_read_info->stream.avail_in==0) &&
++ (pfile_in_zip_read_info->rest_read_compressed>0))
++ {
++ uInt uReadThis = UNZ_BUFSIZE;
++ if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
++ uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
++ if (uReadThis == 0)
++ return UNZ_EOF;
++ if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
++ pfile_in_zip_read_info->filestream,
++ pfile_in_zip_read_info->pos_in_zipfile +
++ pfile_in_zip_read_info->byte_before_the_zipfile,
++ ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return UNZ_ERRNO;
++ if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
++ pfile_in_zip_read_info->filestream,
++ pfile_in_zip_read_info->read_buffer,
++ uReadThis)!=uReadThis)
++ return UNZ_ERRNO;
++
++
++# ifndef NOUNCRYPT
++ if(s->encrypted)
++ {
++ uInt i;
++ for(i=0;i<uReadThis;i++)
++ pfile_in_zip_read_info->read_buffer[i] =
++ zdecode(s->keys,s->pcrc_32_tab,
++ pfile_in_zip_read_info->read_buffer[i]);
++ }
++# endif
++
++
++ pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
++
++ pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
++
++ pfile_in_zip_read_info->stream.next_in =
++ (Bytef*)pfile_in_zip_read_info->read_buffer;
++ pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
++ }
++
++ if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
++ {
++ uInt uDoCopy,i ;
++
++ if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
++ (pfile_in_zip_read_info->rest_read_compressed == 0))
++ return (iRead==0) ? UNZ_EOF : iRead;
++
++ if (pfile_in_zip_read_info->stream.avail_out <
++ pfile_in_zip_read_info->stream.avail_in)
++ uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
++ else
++ uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
++
++ for (i=0;i<uDoCopy;i++)
++ *(pfile_in_zip_read_info->stream.next_out+i) =
++ *(pfile_in_zip_read_info->stream.next_in+i);
++
++ pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
++
++ pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
++ pfile_in_zip_read_info->stream.next_out,
++ uDoCopy);
++ pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
++ pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
++ pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
++ pfile_in_zip_read_info->stream.next_out += uDoCopy;
++ pfile_in_zip_read_info->stream.next_in += uDoCopy;
++ pfile_in_zip_read_info->stream.total_out += uDoCopy;
++ iRead += uDoCopy;
++ }
++ else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)
++ {
++#ifdef HAVE_BZIP2
++ uLong uTotalOutBefore,uTotalOutAfter;
++ const Bytef *bufBefore;
++ uLong uOutThis;
++
++ pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in;
++ pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in;
++ pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in;
++ pfile_in_zip_read_info->bstream.total_in_hi32 = 0;
++ pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out;
++ pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out;
++ pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
++ pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
++
++ uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
++ bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
++
++ err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
++
++ uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
++ uOutThis = uTotalOutAfter-uTotalOutBefore;
++
++ pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
++
++ pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
++ pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
++ iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
++
++ pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
++ pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in;
++ pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32;
++ pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
++ pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
++ pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
++
++ if (err==BZ_STREAM_END)
++ return (iRead==0) ? UNZ_EOF : iRead;
++ if (err!=BZ_OK)
++ break;
++#endif
++ } // end Z_BZIP2ED
++ else
++ {
++ ZPOS64_T uTotalOutBefore,uTotalOutAfter;
++ const Bytef *bufBefore;
++ ZPOS64_T uOutThis;
++ int flush=Z_SYNC_FLUSH;
++
++ uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
++ bufBefore = pfile_in_zip_read_info->stream.next_out;
++
++ /*
++ if ((pfile_in_zip_read_info->rest_read_uncompressed ==
++ pfile_in_zip_read_info->stream.avail_out) &&
++ (pfile_in_zip_read_info->rest_read_compressed == 0))
++ flush = Z_FINISH;
++ */
++ err=inflate(&pfile_in_zip_read_info->stream,flush);
++
++ if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
++ err = Z_DATA_ERROR;
++
++ uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
++ uOutThis = uTotalOutAfter-uTotalOutBefore;
++
++ pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
++
++ pfile_in_zip_read_info->crc32 =
++ crc32(pfile_in_zip_read_info->crc32,bufBefore,
++ (uInt)(uOutThis));
++
++ pfile_in_zip_read_info->rest_read_uncompressed -=
++ uOutThis;
++
++ iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
++
++ if (err==Z_STREAM_END)
++ return (iRead==0) ? UNZ_EOF : iRead;
++ if (err!=Z_OK)
++ break;
++ }
++ }
++
++ if (err==Z_OK)
++ return iRead;
++ return err;
++}
++
++
++/*
++ Give the current position in uncompressed data
++*/
++extern z_off_t ZEXPORT unztell (unzFile file)
++{
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_PARAMERROR;
++
++ return (z_off_t)pfile_in_zip_read_info->stream.total_out;
++}
++
++extern ZPOS64_T ZEXPORT unztell64 (unzFile file)
++{
++
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ if (file==NULL)
++ return (ZPOS64_T)-1;
++ s=(unz64_s*)file;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++
++ if (pfile_in_zip_read_info==NULL)
++ return (ZPOS64_T)-1;
++
++ return pfile_in_zip_read_info->total_out_64;
++}
++
++
++/*
++ return 1 if the end of file was reached, 0 elsewhere
++*/
++extern int ZEXPORT unzeof (unzFile file)
++{
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_PARAMERROR;
++
++ if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
++ return 1;
++ else
++ return 0;
++}
++
++
++
++/*
++Read extra field from the current file (opened by unzOpenCurrentFile)
++This is the local-header version of the extra field (sometimes, there is
++more info in the local-header version than in the central-header)
++
++ if buf==NULL, it return the size of the local extra field that can be read
++
++ if buf!=NULL, len is the size of the buffer, the extra header is copied in
++ buf.
++ the return value is the number of bytes copied in buf, or (if <0)
++ the error code
++*/
++extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)
++{
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ uInt read_now;
++ ZPOS64_T size_to_read;
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_PARAMERROR;
++
++ size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
++ pfile_in_zip_read_info->pos_local_extrafield);
++
++ if (buf==NULL)
++ return (int)size_to_read;
++
++ if (len>size_to_read)
++ read_now = (uInt)size_to_read;
++ else
++ read_now = (uInt)len ;
++
++ if (read_now==0)
++ return 0;
++
++ if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
++ pfile_in_zip_read_info->filestream,
++ pfile_in_zip_read_info->offset_local_extrafield +
++ pfile_in_zip_read_info->pos_local_extrafield,
++ ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return UNZ_ERRNO;
++
++ if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
++ pfile_in_zip_read_info->filestream,
++ buf,read_now)!=read_now)
++ return UNZ_ERRNO;
++
++ return (int)read_now;
++}
++
++/*
++ Close the file in zip opened with unzOpenCurrentFile
++ Return UNZ_CRCERROR if all the file was read but the CRC is not good
++*/
++extern int ZEXPORT unzCloseCurrentFile (unzFile file)
++{
++ int err=UNZ_OK;
++
++ unz64_s* s;
++ file_in_zip64_read_info_s* pfile_in_zip_read_info;
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ pfile_in_zip_read_info=s->pfile_in_zip_read;
++
++ if (pfile_in_zip_read_info==NULL)
++ return UNZ_PARAMERROR;
++
++
++ if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
++ (!pfile_in_zip_read_info->raw))
++ {
++ if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
++ err=UNZ_CRCERROR;
++ }
++
++
++ TRYFREE(pfile_in_zip_read_info->read_buffer);
++ pfile_in_zip_read_info->read_buffer = NULL;
++ if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
++ inflateEnd(&pfile_in_zip_read_info->stream);
++#ifdef HAVE_BZIP2
++ else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
++ BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
++#endif
++
++
++ pfile_in_zip_read_info->stream_initialised = 0;
++ TRYFREE(pfile_in_zip_read_info);
++
++ s->pfile_in_zip_read=NULL;
++
++ return err;
++}
++
++
++/*
++ Get the global comment string of the ZipFile, in the szComment buffer.
++ uSizeBuf is the size of the szComment buffer.
++ return the number of byte copied or an error code <0
++*/
++extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)
++{
++ unz64_s* s;
++ uLong uReadThis ;
++ if (file==NULL)
++ return (int)UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++
++ uReadThis = uSizeBuf;
++ if (uReadThis>s->gi.size_comment)
++ uReadThis = s->gi.size_comment;
++
++ if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return UNZ_ERRNO;
++
++ if (uReadThis>0)
++ {
++ *szComment='\0';
++ if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
++ return UNZ_ERRNO;
++ }
++
++ if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
++ *(szComment+s->gi.size_comment)='\0';
++ return (int)uReadThis;
++}
++
++/* Additions by RX '2004 */
++extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
++{
++ unz64_s* s;
++
++ if (file==NULL)
++ return 0; //UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++ if (!s->current_file_ok)
++ return 0;
++ if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
++ if (s->num_file==s->gi.number_entry)
++ return 0;
++ return s->pos_in_central_dir;
++}
++
++extern uLong ZEXPORT unzGetOffset (unzFile file)
++{
++ ZPOS64_T offset64;
++
++ if (file==NULL)
++ return 0; //UNZ_PARAMERROR;
++ offset64 = unzGetOffset64(file);
++ return (uLong)offset64;
++}
++
++extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
++{
++ unz64_s* s;
++ int err;
++
++ if (file==NULL)
++ return UNZ_PARAMERROR;
++ s=(unz64_s*)file;
++
++ s->pos_in_central_dir = pos;
++ s->num_file = s->gi.number_entry; /* hack */
++ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
++ &s->cur_file_info_internal,
++ NULL,0,NULL,0,NULL,0);
++ s->current_file_ok = (err == UNZ_OK);
++ return err;
++}
++
++extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)
++{
++ return unzSetOffset64(file,pos);
++}
+diff --git a/converter/COLLADA2GLTF/kmz/unzip.h b/converter/COLLADA2GLTF/kmz/unzip.h
+new file mode 100644
+index 0000000..2104e39
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/unzip.h
+@@ -0,0 +1,437 @@
++/* unzip.h -- IO for uncompress .zip files using zlib
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications of Unzip for Zip64
++ Copyright (C) 2007-2008 Even Rouault
++
++ Modifications for Zip64 support on both zip and unzip
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++ ---------------------------------------------------------------------------------
++
++ 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.
++
++ ---------------------------------------------------------------------------------
++
++ Changes
++
++ See header of unzip64.c
++
++*/
++
++#ifndef _unz64_H
++#define _unz64_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#ifndef _ZLIB_H
++#include "zlib.h"
++#endif
++
++#ifndef _ZLIBIOAPI_H
++#include "ioapi.h"
++#endif
++
++#ifdef HAVE_BZIP2
++#include "bzlib.h"
++#endif
++
++#define Z_BZIP2ED 12
++
++#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
++/* like the STRICT of WIN32, we define a pointer that cannot be converted
++ from (void*) without cast */
++typedef struct TagunzFile__ { int unused; } unzFile__;
++typedef unzFile__ *unzFile;
++#else
++typedef voidp unzFile;
++#endif
++
++
++#define UNZ_OK (0)
++#define UNZ_END_OF_LIST_OF_FILE (-100)
++#define UNZ_ERRNO (Z_ERRNO)
++#define UNZ_EOF (0)
++#define UNZ_PARAMERROR (-102)
++#define UNZ_BADZIPFILE (-103)
++#define UNZ_INTERNALERROR (-104)
++#define UNZ_CRCERROR (-105)
++
++/* tm_unz contain date/time info */
++typedef struct tm_unz_s
++{
++ uInt tm_sec; /* seconds after the minute - [0,59] */
++ uInt tm_min; /* minutes after the hour - [0,59] */
++ uInt tm_hour; /* hours since midnight - [0,23] */
++ uInt tm_mday; /* day of the month - [1,31] */
++ uInt tm_mon; /* months since January - [0,11] */
++ uInt tm_year; /* years - [1980..2044] */
++} tm_unz;
++
++/* unz_global_info structure contain global data about the ZIPfile
++ These data comes from the end of central dir */
++typedef struct unz_global_info64_s
++{
++ ZPOS64_T number_entry; /* total number of entries in
++ the central dir on this disk */
++ uLong size_comment; /* size of the global comment of the zipfile */
++} unz_global_info64;
++
++typedef struct unz_global_info_s
++{
++ uLong number_entry; /* total number of entries in
++ the central dir on this disk */
++ uLong size_comment; /* size of the global comment of the zipfile */
++} unz_global_info;
++
++/* unz_file_info contain information about a file in the zipfile */
++typedef struct unz_file_info64_s
++{
++ uLong version; /* version made by 2 bytes */
++ uLong version_needed; /* version needed to extract 2 bytes */
++ uLong flag; /* general purpose bit flag 2 bytes */
++ uLong compression_method; /* compression method 2 bytes */
++ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
++ uLong crc; /* crc-32 4 bytes */
++ ZPOS64_T compressed_size; /* compressed size 8 bytes */
++ ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */
++ uLong size_filename; /* filename length 2 bytes */
++ uLong size_file_extra; /* extra field length 2 bytes */
++ uLong size_file_comment; /* file comment length 2 bytes */
++
++ uLong disk_num_start; /* disk number start 2 bytes */
++ uLong internal_fa; /* internal file attributes 2 bytes */
++ uLong external_fa; /* external file attributes 4 bytes */
++
++ tm_unz tmu_date;
++} unz_file_info64;
++
++typedef struct unz_file_info_s
++{
++ uLong version; /* version made by 2 bytes */
++ uLong version_needed; /* version needed to extract 2 bytes */
++ uLong flag; /* general purpose bit flag 2 bytes */
++ uLong compression_method; /* compression method 2 bytes */
++ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
++ uLong crc; /* crc-32 4 bytes */
++ uLong compressed_size; /* compressed size 4 bytes */
++ uLong uncompressed_size; /* uncompressed size 4 bytes */
++ uLong size_filename; /* filename length 2 bytes */
++ uLong size_file_extra; /* extra field length 2 bytes */
++ uLong size_file_comment; /* file comment length 2 bytes */
++
++ uLong disk_num_start; /* disk number start 2 bytes */
++ uLong internal_fa; /* internal file attributes 2 bytes */
++ uLong external_fa; /* external file attributes 4 bytes */
++
++ tm_unz tmu_date;
++} unz_file_info;
++
++extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
++ const char* fileName2,
++ int iCaseSensitivity));
++/*
++ Compare two filename (fileName1,fileName2).
++ If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
++ If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
++ or strcasecmp)
++ If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
++ (like 1 on Unix, 2 on Windows)
++*/
++
++
++extern unzFile ZEXPORT unzOpen OF((const char *path));
++extern unzFile ZEXPORT unzOpen64 OF((const void *path));
++/*
++ Open a Zip file. path contain the full pathname (by example,
++ on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
++ "zlib/zlib113.zip".
++ If the zipfile cannot be opened (file don't exist or in not valid), the
++ return value is NULL.
++ Else, the return value is a unzFile Handle, usable with other function
++ of this unzip package.
++ the "64" function take a const void* pointer, because the path is just the
++ value passed to the open64_file_func callback.
++ Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
++ is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char*
++ does not describe the reality
++*/
++
++
++extern unzFile ZEXPORT unzOpen2 OF((const char *path,
++ zlib_filefunc_def* pzlib_filefunc_def));
++/*
++ Open a Zip file, like unzOpen, but provide a set of file low level API
++ for read/write the zip file (see ioapi.h)
++*/
++
++extern unzFile ZEXPORT unzOpen2_64 OF((const void *path,
++ zlib_filefunc64_def* pzlib_filefunc_def));
++/*
++ Open a Zip file, like unz64Open, but provide a set of file low level API
++ for read/write the zip file (see ioapi.h)
++*/
++
++extern int ZEXPORT unzClose OF((unzFile file));
++/*
++ Close a ZipFile opened with unzOpen.
++ If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
++ these files MUST be closed with unzCloseCurrentFile before call unzClose.
++ return UNZ_OK if there is no problem. */
++
++extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
++ unz_global_info *pglobal_info));
++
++extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file,
++ unz_global_info64 *pglobal_info));
++/*
++ Write info about the ZipFile in the *pglobal_info structure.
++ No preparation of the structure is needed
++ return UNZ_OK if there is no problem. */
++
++
++extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
++ char *szComment,
++ uLong uSizeBuf));
++/*
++ Get the global comment string of the ZipFile, in the szComment buffer.
++ uSizeBuf is the size of the szComment buffer.
++ return the number of byte copied or an error code <0
++*/
++
++
++/***************************************************************************/
++/* Unzip package allow you browse the directory of the zipfile */
++
++extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
++/*
++ Set the current file of the zipfile to the first file.
++ return UNZ_OK if there is no problem
++*/
++
++extern int ZEXPORT unzGoToNextFile OF((unzFile file));
++/*
++ Set the current file of the zipfile to the next file.
++ return UNZ_OK if there is no problem
++ return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
++*/
++
++extern int ZEXPORT unzLocateFile OF((unzFile file,
++ const char *szFileName,
++ int iCaseSensitivity));
++/*
++ Try locate the file szFileName in the zipfile.
++ For the iCaseSensitivity signification, see unzStringFileNameCompare
++
++ return value :
++ UNZ_OK if the file is found. It becomes the current file.
++ UNZ_END_OF_LIST_OF_FILE if the file is not found
++*/
++
++
++/* ****************************************** */
++/* Ryan supplied functions */
++/* unz_file_info contain information about a file in the zipfile */
++typedef struct unz_file_pos_s
++{
++ uLong pos_in_zip_directory; /* offset in zip file directory */
++ uLong num_of_file; /* # of file */
++} unz_file_pos;
++
++extern int ZEXPORT unzGetFilePos(
++ unzFile file,
++ unz_file_pos* file_pos);
++
++extern int ZEXPORT unzGoToFilePos(
++ unzFile file,
++ unz_file_pos* file_pos);
++
++typedef struct unz64_file_pos_s
++{
++ ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */
++ ZPOS64_T num_of_file; /* # of file */
++} unz64_file_pos;
++
++extern int ZEXPORT unzGetFilePos64(
++ unzFile file,
++ unz64_file_pos* file_pos);
++
++extern int ZEXPORT unzGoToFilePos64(
++ unzFile file,
++ const unz64_file_pos* file_pos);
++
++/* ****************************************** */
++
++extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file,
++ unz_file_info64 *pfile_info,
++ char *szFileName,
++ uLong fileNameBufferSize,
++ void *extraField,
++ uLong extraFieldBufferSize,
++ char *szComment,
++ uLong commentBufferSize));
++
++extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
++ unz_file_info *pfile_info,
++ char *szFileName,
++ uLong fileNameBufferSize,
++ void *extraField,
++ uLong extraFieldBufferSize,
++ char *szComment,
++ uLong commentBufferSize));
++/*
++ Get Info about the current file
++ if pfile_info!=NULL, the *pfile_info structure will contain somes info about
++ the current file
++ if szFileName!=NULL, the filemane string will be copied in szFileName
++ (fileNameBufferSize is the size of the buffer)
++ if extraField!=NULL, the extra field information will be copied in extraField
++ (extraFieldBufferSize is the size of the buffer).
++ This is the Central-header version of the extra field
++ if szComment!=NULL, the comment string of the file will be copied in szComment
++ (commentBufferSize is the size of the buffer)
++*/
++
++
++/** Addition for GDAL : START */
++
++extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));
++
++/** Addition for GDAL : END */
++
++
++/***************************************************************************/
++/* for reading the content of the current zipfile, you can open it, read data
++ from it, and close it (you can close it before reading all the file)
++ */
++
++extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
++/*
++ Open for reading data the current file in the zipfile.
++ If there is no error, the return value is UNZ_OK.
++*/
++
++extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
++ const char* password));
++/*
++ Open for reading data the current file in the zipfile.
++ password is a crypting password
++ If there is no error, the return value is UNZ_OK.
++*/
++
++extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
++ int* method,
++ int* level,
++ int raw));
++/*
++ Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
++ if raw==1
++ *method will receive method of compression, *level will receive level of
++ compression
++ note : you can set level parameter as NULL (if you did not want known level,
++ but you CANNOT set method parameter as NULL
++*/
++
++extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
++ int* method,
++ int* level,
++ int raw,
++ const char* password));
++/*
++ Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
++ if raw==1
++ *method will receive method of compression, *level will receive level of
++ compression
++ note : you can set level parameter as NULL (if you did not want known level,
++ but you CANNOT set method parameter as NULL
++*/
++
++
++extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
++/*
++ Close the file in zip opened with unzOpenCurrentFile
++ Return UNZ_CRCERROR if all the file was read but the CRC is not good
++*/
++
++extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
++ voidp buf,
++ unsigned len));
++/*
++ Read bytes from the current file (opened by unzOpenCurrentFile)
++ buf contain buffer where data must be copied
++ len the size of buf.
++
++ return the number of byte copied if somes bytes are copied
++ return 0 if the end of file was reached
++ return <0 with error code if there is an error
++ (UNZ_ERRNO for IO error, or zLib error for uncompress error)
++*/
++
++extern z_off_t ZEXPORT unztell OF((unzFile file));
++
++extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));
++/*
++ Give the current position in uncompressed data
++*/
++
++extern int ZEXPORT unzeof OF((unzFile file));
++/*
++ return 1 if the end of file was reached, 0 elsewhere
++*/
++
++extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
++ voidp buf,
++ unsigned len));
++/*
++ Read extra field from the current file (opened by unzOpenCurrentFile)
++ This is the local-header version of the extra field (sometimes, there is
++ more info in the local-header version than in the central-header)
++
++ if buf==NULL, it return the size of the local extra field
++
++ if buf!=NULL, len is the size of the buffer, the extra header is copied in
++ buf.
++ the return value is the number of bytes copied in buf, or (if <0)
++ the error code
++*/
++
++/***************************************************************************/
++
++/* Get the current file offset */
++extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file);
++extern uLong ZEXPORT unzGetOffset (unzFile file);
++
++/* Set the current file offset */
++extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos);
++extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
++
++
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* _unz64_H */
+diff --git a/converter/COLLADA2GLTF/kmz/zconf.h b/converter/COLLADA2GLTF/kmz/zconf.h
+new file mode 100644
+index 0000000..9ccbb0a
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/zconf.h
+@@ -0,0 +1,513 @@
++/* zconf.h -- configuration of the zlib compression library
++ * Copyright (C) 1995-2013 Jean-loup Gailly.
++ * For conditions of distribution and use, see copyright notice in zlib.h
++ */
++
++/* @(#) $Id$ */
++
++#ifndef ZCONF_H
++#define ZCONF_H
++/* #undef Z_PREFIX */
++/* #undef Z_HAVE_UNISTD_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.
++ * Even better than compiling with -DZ_PREFIX would be to use configure to set
++ * this permanently in zconf.h using "./configure --zprefix".
++ */
++#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
++# define Z_PREFIX_SET
++
++/* all linked symbols */
++# define _dist_code z__dist_code
++# define _length_code z__length_code
++# define _tr_align z__tr_align
++# define _tr_flush_bits z__tr_flush_bits
++# define _tr_flush_block z__tr_flush_block
++# define _tr_init z__tr_init
++# define _tr_stored_block z__tr_stored_block
++# define _tr_tally z__tr_tally
++# define adler32 z_adler32
++# define adler32_combine z_adler32_combine
++# define adler32_combine64 z_adler32_combine64
++# ifndef Z_SOLO
++# define compress z_compress
++# define compress2 z_compress2
++# define compressBound z_compressBound
++# endif
++# define crc32 z_crc32
++# define crc32_combine z_crc32_combine
++# define crc32_combine64 z_crc32_combine64
++# define deflate z_deflate
++# define deflateBound z_deflateBound
++# define deflateCopy z_deflateCopy
++# define deflateEnd z_deflateEnd
++# define deflateInit2_ z_deflateInit2_
++# define deflateInit_ z_deflateInit_
++# define deflateParams z_deflateParams
++# define deflatePending z_deflatePending
++# define deflatePrime z_deflatePrime
++# define deflateReset z_deflateReset
++# define deflateResetKeep z_deflateResetKeep
++# define deflateSetDictionary z_deflateSetDictionary
++# define deflateSetHeader z_deflateSetHeader
++# define deflateTune z_deflateTune
++# define deflate_copyright z_deflate_copyright
++# define get_crc_table z_get_crc_table
++# ifndef Z_SOLO
++# define gz_error z_gz_error
++# define gz_intmax z_gz_intmax
++# define gz_strwinerror z_gz_strwinerror
++# define gzbuffer z_gzbuffer
++# define gzclearerr z_gzclearerr
++# define gzclose z_gzclose
++# define gzclose_r z_gzclose_r
++# define gzclose_w z_gzclose_w
++# define gzdirect z_gzdirect
++# define gzdopen z_gzdopen
++# define gzeof z_gzeof
++# define gzerror z_gzerror
++# define gzflush z_gzflush
++# define gzgetc z_gzgetc
++# define gzgetc_ z_gzgetc_
++# define gzgets z_gzgets
++# define gzoffset z_gzoffset
++# define gzoffset64 z_gzoffset64
++# define gzopen z_gzopen
++# define gzopen64 z_gzopen64
++# ifdef _WIN32
++# define gzopen_w z_gzopen_w
++# endif
++# define gzprintf z_gzprintf
++# define gzvprintf z_gzvprintf
++# define gzputc z_gzputc
++# define gzputs z_gzputs
++# define gzread z_gzread
++# define gzrewind z_gzrewind
++# define gzseek z_gzseek
++# define gzseek64 z_gzseek64
++# define gzsetparams z_gzsetparams
++# define gztell z_gztell
++# define gztell64 z_gztell64
++# define gzungetc z_gzungetc
++# define gzwrite z_gzwrite
++# endif
++# define inflate z_inflate
++# define inflateBack z_inflateBack
++# define inflateBackEnd z_inflateBackEnd
++# define inflateBackInit_ z_inflateBackInit_
++# define inflateCopy z_inflateCopy
++# define inflateEnd z_inflateEnd
++# define inflateGetHeader z_inflateGetHeader
++# define inflateInit2_ z_inflateInit2_
++# define inflateInit_ z_inflateInit_
++# define inflateMark z_inflateMark
++# define inflatePrime z_inflatePrime
++# define inflateReset z_inflateReset
++# define inflateReset2 z_inflateReset2
++# define inflateSetDictionary z_inflateSetDictionary
++# define inflateGetDictionary z_inflateGetDictionary
++# define inflateSync z_inflateSync
++# define inflateSyncPoint z_inflateSyncPoint
++# define inflateUndermine z_inflateUndermine
++# define inflateResetKeep z_inflateResetKeep
++# define inflate_copyright z_inflate_copyright
++# define inflate_fast z_inflate_fast
++# define inflate_table z_inflate_table
++# ifndef Z_SOLO
++# define uncompress z_uncompress
++# endif
++# define zError z_zError
++# ifndef Z_SOLO
++# define zcalloc z_zcalloc
++# define zcfree z_zcfree
++# endif
++# define zlibCompileFlags z_zlibCompileFlags
++# define zlibVersion z_zlibVersion
++
++/* all zlib typedefs in zlib.h and zconf.h */
++# define Byte z_Byte
++# define Bytef z_Bytef
++# define alloc_func z_alloc_func
++# define charf z_charf
++# define free_func z_free_func
++# ifndef Z_SOLO
++# define gzFile z_gzFile
++# endif
++# define gz_header z_gz_header
++# define gz_headerp z_gz_headerp
++# define in_func z_in_func
++# define intf z_intf
++# define out_func z_out_func
++# define uInt z_uInt
++# define uIntf z_uIntf
++# define uLong z_uLong
++# define uLongf z_uLongf
++# define voidp z_voidp
++# define voidpc z_voidpc
++# define voidpf z_voidpf
++
++/* all zlib structs in zlib.h and zconf.h */
++# define gz_header_s z_gz_header_s
++# define internal_state z_internal_state
++
++#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
++
++#if defined(ZLIB_CONST) && !defined(z_const)
++# define z_const const
++#else
++# define z_const
++#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
++
++#ifndef Z_ARG /* function prototypes for stdarg */
++# if defined(STDC) || defined(Z_HAVE_STDARG_H)
++# define Z_ARG(args) args
++# else
++# define Z_ARG(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 !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
++# include <limits.h>
++# if (UINT_MAX == 0xffffffffUL)
++# define Z_U4 unsigned
++# elif (ULONG_MAX == 0xffffffffUL)
++# define Z_U4 unsigned long
++# elif (USHRT_MAX == 0xffffffffUL)
++# define Z_U4 unsigned short
++# endif
++#endif
++
++#ifdef Z_U4
++ typedef Z_U4 z_crc_t;
++#else
++ typedef unsigned long z_crc_t;
++#endif
++
++#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
++# define Z_HAVE_UNISTD_H
++#endif
++
++#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
++# define Z_HAVE_STDARG_H
++#endif
++
++#ifdef STDC
++# ifndef Z_SOLO
++# include <sys/types.h> /* for off_t */
++# endif
++#endif
++
++#if defined(STDC) || defined(Z_HAVE_STDARG_H)
++# ifndef Z_SOLO
++# include <stdarg.h> /* for va_list */
++# endif
++#endif
++
++#ifdef _WIN32
++# ifndef Z_SOLO
++# include <stddef.h> /* for wchar_t */
++# endif
++#endif
++
++/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
++ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
++ * though the former does not conform to the LFS document), but considering
++ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
++ * equivalently requesting no 64-bit operations
++ */
++#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
++# undef _LARGEFILE64_SOURCE
++#endif
++
++#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
++# define Z_HAVE_UNISTD_H
++#endif
++#ifndef Z_SOLO
++# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
++# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
++# ifdef VMS
++# include <unixio.h> /* for off_t */
++# endif
++# ifndef z_off_t
++# define z_off_t off_t
++# endif
++# endif
++#endif
++
++#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
++# define Z_LFS64
++#endif
++
++#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
++# define Z_LARGE64
++#endif
++
++#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
++# define Z_WANT64
++#endif
++
++#if !defined(SEEK_SET) && !defined(Z_SOLO)
++# 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(_WIN32) && defined(Z_LARGE64)
++# define z_off64_t off64_t
++#else
++# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
++# define z_off64_t __int64
++# else
++# define z_off64_t z_off_t
++# 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 */
+diff --git a/converter/COLLADA2GLTF/kmz/zip.c b/converter/COLLADA2GLTF/kmz/zip.c
+new file mode 100644
+index 0000000..ea54853
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/zip.c
+@@ -0,0 +1,2007 @@
++/* zip.c -- IO on .zip files using zlib
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++ Changes
++ Oct-2009 - Mathias Svensson - Remove old C style function prototypes
++ Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
++ Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions.
++ Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data
++ It is used when recreting zip archive with RAW when deleting items from a zip.
++ ZIP64 data is automaticly added to items that needs it, and existing ZIP64 data need to be removed.
++ Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required)
++ Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
++
++*/
++
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <time.h>
++#include "zlib.h"
++#include "zip.h"
++
++#ifdef STDC
++# include <stddef.h>
++# include <string.h>
++# include <stdlib.h>
++#endif
++#ifdef NO_ERRNO_H
++ extern int errno;
++#else
++# include <errno.h>
++#endif
++
++
++#ifndef local
++# define local static
++#endif
++/* compile with -Dlocal if your debugger can't find static symbols */
++
++#ifndef VERSIONMADEBY
++# define VERSIONMADEBY (0x0) /* platform depedent */
++#endif
++
++#ifndef Z_BUFSIZE
++#define Z_BUFSIZE (64*1024) //(16384)
++#endif
++
++#ifndef Z_MAXFILENAMEINZIP
++#define Z_MAXFILENAMEINZIP (256)
++#endif
++
++#ifndef ALLOC
++# define ALLOC(size) (malloc(size))
++#endif
++#ifndef TRYFREE
++# define TRYFREE(p) {if (p) free(p);}
++#endif
++
++/*
++#define SIZECENTRALDIRITEM (0x2e)
++#define SIZEZIPLOCALHEADER (0x1e)
++*/
++
++/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
++
++
++// NOT sure that this work on ALL platform
++#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32))
++
++#ifndef SEEK_CUR
++#define SEEK_CUR 1
++#endif
++
++#ifndef SEEK_END
++#define SEEK_END 2
++#endif
++
++#ifndef SEEK_SET
++#define SEEK_SET 0
++#endif
++
++#ifndef DEF_MEM_LEVEL
++#if MAX_MEM_LEVEL >= 8
++# define DEF_MEM_LEVEL 8
++#else
++# define DEF_MEM_LEVEL MAX_MEM_LEVEL
++#endif
++#endif
++const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
++
++
++#define SIZEDATA_INDATABLOCK (4096-(4*4))
++
++#define LOCALHEADERMAGIC (0x04034b50)
++#define CENTRALHEADERMAGIC (0x02014b50)
++#define ENDHEADERMAGIC (0x06054b50)
++#define ZIP64ENDHEADERMAGIC (0x6064b50)
++#define ZIP64ENDLOCHEADERMAGIC (0x7064b50)
++
++#define FLAG_LOCALHEADER_OFFSET (0x06)
++#define CRC_LOCALHEADER_OFFSET (0x0e)
++
++#define SIZECENTRALHEADER (0x2e) /* 46 */
++
++typedef struct linkedlist_datablock_internal_s
++{
++ struct linkedlist_datablock_internal_s* next_datablock;
++ uLong avail_in_this_block;
++ uLong filled_in_this_block;
++ uLong unused; /* for future use and alignement */
++ unsigned char data[SIZEDATA_INDATABLOCK];
++} linkedlist_datablock_internal;
++
++typedef struct linkedlist_data_s
++{
++ linkedlist_datablock_internal* first_block;
++ linkedlist_datablock_internal* last_block;
++} linkedlist_data;
++
++
++typedef struct
++{
++ z_stream stream; /* zLib stream structure for inflate */
++#ifdef HAVE_BZIP2
++ bz_stream bstream; /* bzLib stream structure for bziped */
++#endif
++
++ int stream_initialised; /* 1 is stream is initialised */
++ uInt pos_in_buffered_data; /* last written byte in buffered_data */
++
++ ZPOS64_T pos_local_header; /* offset of the local header of the file
++ currenty writing */
++ char* central_header; /* central header data for the current file */
++ uLong size_centralExtra;
++ uLong size_centralheader; /* size of the central header for cur file */
++ uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */
++ uLong flag; /* flag of the file currently writing */
++
++ int method; /* compression method of file currenty wr.*/
++ int raw; /* 1 for directly writing raw data */
++ Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
++ uLong dosDate;
++ uLong crc32;
++ int encrypt;
++ int zip64; /* Add ZIP64 extened information in the extra field */
++ ZPOS64_T pos_zip64extrainfo;
++ ZPOS64_T totalCompressedData;
++ ZPOS64_T totalUncompressedData;
++#ifndef NOCRYPT
++ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
++ const z_crc_t* pcrc_32_tab;
++ int crypt_header_size;
++#endif
++} curfile64_info;
++
++typedef struct
++{
++ zlib_filefunc64_32_def z_filefunc;
++ voidpf filestream; /* io structore of the zipfile */
++ linkedlist_data central_dir;/* datablock with central dir in construction*/
++ int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
++ curfile64_info ci; /* info on the file curretly writing */
++
++ ZPOS64_T begin_pos; /* position of the beginning of the zipfile */
++ ZPOS64_T add_position_when_writting_offset;
++ ZPOS64_T number_entry;
++
++#ifndef NO_ADDFILEINEXISTINGZIP
++ char *globalcomment;
++#endif
++
++} zip64_internal;
++
++
++#ifndef NOCRYPT
++#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
++#include "crypt.h"
++#endif
++
++local linkedlist_datablock_internal* allocate_new_datablock()
++{
++ linkedlist_datablock_internal* ldi;
++ ldi = (linkedlist_datablock_internal*)
++ ALLOC(sizeof(linkedlist_datablock_internal));
++ if (ldi!=NULL)
++ {
++ ldi->next_datablock = NULL ;
++ ldi->filled_in_this_block = 0 ;
++ ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
++ }
++ return ldi;
++}
++
++local void free_datablock(linkedlist_datablock_internal* ldi)
++{
++ while (ldi!=NULL)
++ {
++ linkedlist_datablock_internal* ldinext = ldi->next_datablock;
++ TRYFREE(ldi);
++ ldi = ldinext;
++ }
++}
++
++local void init_linkedlist(linkedlist_data* ll)
++{
++ ll->first_block = ll->last_block = NULL;
++}
++
++local void free_linkedlist(linkedlist_data* ll)
++{
++ free_datablock(ll->first_block);
++ ll->first_block = ll->last_block = NULL;
++}
++
++
++local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
++{
++ linkedlist_datablock_internal* ldi;
++ const unsigned char* from_copy;
++
++ if (ll==NULL)
++ return ZIP_INTERNALERROR;
++
++ if (ll->last_block == NULL)
++ {
++ ll->first_block = ll->last_block = allocate_new_datablock();
++ if (ll->first_block == NULL)
++ return ZIP_INTERNALERROR;
++ }
++
++ ldi = ll->last_block;
++ from_copy = (unsigned char*)buf;
++
++ while (len>0)
++ {
++ uInt copy_this;
++ uInt i;
++ unsigned char* to_copy;
++
++ if (ldi->avail_in_this_block==0)
++ {
++ ldi->next_datablock = allocate_new_datablock();
++ if (ldi->next_datablock == NULL)
++ return ZIP_INTERNALERROR;
++ ldi = ldi->next_datablock ;
++ ll->last_block = ldi;
++ }
++
++ if (ldi->avail_in_this_block < len)
++ copy_this = (uInt)ldi->avail_in_this_block;
++ else
++ copy_this = (uInt)len;
++
++ to_copy = &(ldi->data[ldi->filled_in_this_block]);
++
++ for (i=0;i<copy_this;i++)
++ *(to_copy+i)=*(from_copy+i);
++
++ ldi->filled_in_this_block += copy_this;
++ ldi->avail_in_this_block -= copy_this;
++ from_copy += copy_this ;
++ len -= copy_this;
++ }
++ return ZIP_OK;
++}
++
++
++
++/****************************************************************************/
++
++#ifndef NO_ADDFILEINEXISTINGZIP
++/* ===========================================================================
++ Inputs a long in LSB order to the given file
++ nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)
++*/
++
++local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte));
++local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)
++{
++ unsigned char buf[8];
++ int n;
++ for (n = 0; n < nbByte; n++)
++ {
++ buf[n] = (unsigned char)(x & 0xff);
++ x >>= 8;
++ }
++ if (x != 0)
++ { /* data overflow - hack for ZIP64 (X Roche) */
++ for (n = 0; n < nbByte; n++)
++ {
++ buf[n] = 0xff;
++ }
++ }
++
++ if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
++ return ZIP_ERRNO;
++ else
++ return ZIP_OK;
++}
++
++local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));
++local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)
++{
++ unsigned char* buf=(unsigned char*)dest;
++ int n;
++ for (n = 0; n < nbByte; n++) {
++ buf[n] = (unsigned char)(x & 0xff);
++ x >>= 8;
++ }
++
++ if (x != 0)
++ { /* data overflow - hack for ZIP64 */
++ for (n = 0; n < nbByte; n++)
++ {
++ buf[n] = 0xff;
++ }
++ }
++}
++
++/****************************************************************************/
++
++
++local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)
++{
++ uLong year = (uLong)ptm->tm_year;
++ if (year>=1980)
++ year-=1980;
++ else if (year>=80)
++ year-=80;
++ return
++ (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
++ ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
++}
++
++
++/****************************************************************************/
++
++local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));
++
++local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)
++{
++ unsigned char c;
++ int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
++ if (err==1)
++ {
++ *pi = (int)c;
++ return ZIP_OK;
++ }
++ else
++ {
++ if (ZERROR64(*pzlib_filefunc_def,filestream))
++ return ZIP_ERRNO;
++ else
++ return ZIP_EOF;
++ }
++}
++
++
++/* ===========================================================================
++ Reads a long in LSB order from the given gz_stream. Sets
++*/
++local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
++
++local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
++{
++ uLong x ;
++ int i = 0;
++ int err;
++
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (uLong)i;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((uLong)i)<<8;
++
++ if (err==ZIP_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
++
++local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
++{
++ uLong x ;
++ int i = 0;
++ int err;
++
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (uLong)i;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((uLong)i)<<8;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((uLong)i)<<16;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((uLong)i)<<24;
++
++ if (err==ZIP_OK)
++ *pX = x;
++ else
++ *pX = 0;
++ return err;
++}
++
++local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));
++
++
++local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
++{
++ ZPOS64_T x;
++ int i = 0;
++ int err;
++
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x = (ZPOS64_T)i;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<8;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<16;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<24;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<32;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<40;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<48;
++
++ if (err==ZIP_OK)
++ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
++ x += ((ZPOS64_T)i)<<56;
++
++ if (err==ZIP_OK)
++ *pX = x;
++ else
++ *pX = 0;
++
++ return err;
++}
++
++#ifndef BUFREADCOMMENT
++#define BUFREADCOMMENT (0x400)
++#endif
++/*
++ Locate the Central directory of a zipfile (at the end, just before
++ the global comment)
++*/
++local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
++
++local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
++{
++ unsigned char* buf;
++ ZPOS64_T uSizeFile;
++ ZPOS64_T uBackRead;
++ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
++ ZPOS64_T uPosFound=0;
++
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
++ return 0;
++
++
++ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
++
++ if (uMaxBack>uSizeFile)
++ uMaxBack = uSizeFile;
++
++ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
++ if (buf==NULL)
++ return 0;
++
++ uBackRead = 4;
++ while (uBackRead<uMaxBack)
++ {
++ uLong uReadSize;
++ ZPOS64_T uReadPos ;
++ int i;
++ if (uBackRead+BUFREADCOMMENT>uMaxBack)
++ uBackRead = uMaxBack;
++ else
++ uBackRead+=BUFREADCOMMENT;
++ uReadPos = uSizeFile-uBackRead ;
++
++ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
++ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ break;
++
++ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
++ break;
++
++ for (i=(int)uReadSize-3; (i--)>0;)
++ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
++ ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
++ {
++ uPosFound = uReadPos+i;
++ break;
++ }
++
++ if (uPosFound!=0)
++ break;
++ }
++ TRYFREE(buf);
++ return uPosFound;
++}
++
++/*
++Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
++the global comment)
++*/
++local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
++
++local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
++{
++ unsigned char* buf;
++ ZPOS64_T uSizeFile;
++ ZPOS64_T uBackRead;
++ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
++ ZPOS64_T uPosFound=0;
++ uLong uL;
++ ZPOS64_T relativeOffset;
++
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
++ return 0;
++
++ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
++
++ if (uMaxBack>uSizeFile)
++ uMaxBack = uSizeFile;
++
++ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
++ if (buf==NULL)
++ return 0;
++
++ uBackRead = 4;
++ while (uBackRead<uMaxBack)
++ {
++ uLong uReadSize;
++ ZPOS64_T uReadPos;
++ int i;
++ if (uBackRead+BUFREADCOMMENT>uMaxBack)
++ uBackRead = uMaxBack;
++ else
++ uBackRead+=BUFREADCOMMENT;
++ uReadPos = uSizeFile-uBackRead ;
++
++ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
++ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
++ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ break;
++
++ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
++ break;
++
++ for (i=(int)uReadSize-3; (i--)>0;)
++ {
++ // Signature "0x07064b50" Zip64 end of central directory locater
++ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
++ {
++ uPosFound = uReadPos+i;
++ break;
++ }
++ }
++
++ if (uPosFound!=0)
++ break;
++ }
++
++ TRYFREE(buf);
++ if (uPosFound == 0)
++ return 0;
++
++ /* Zip64 end of central directory locator */
++ if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return 0;
++
++ /* the signature, already checked */
++ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
++ return 0;
++
++ /* number of the disk with the start of the zip64 end of central directory */
++ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
++ return 0;
++ if (uL != 0)
++ return 0;
++
++ /* relative offset of the zip64 end of central directory record */
++ if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)
++ return 0;
++
++ /* total number of disks */
++ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
++ return 0;
++ if (uL != 1)
++ return 0;
++
++ /* Goto Zip64 end of central directory record */
++ if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ return 0;
++
++ /* the signature */
++ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
++ return 0;
++
++ if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
++ return 0;
++
++ return relativeOffset;
++}
++
++int LoadCentralDirectoryRecord(zip64_internal* pziinit)
++{
++ int err=ZIP_OK;
++ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
++
++ ZPOS64_T size_central_dir; /* size of the central directory */
++ ZPOS64_T offset_central_dir; /* offset of start of central directory */
++ ZPOS64_T central_pos;
++ uLong uL;
++
++ uLong number_disk; /* number of the current dist, used for
++ spaning ZIP, unsupported, always 0*/
++ uLong number_disk_with_CD; /* number the the disk with central dir, used
++ for spaning ZIP, unsupported, always 0*/
++ ZPOS64_T number_entry;
++ ZPOS64_T number_entry_CD; /* total number of entries in
++ the central dir
++ (same than number_entry on nospan) */
++ uLong VersionMadeBy;
++ uLong VersionNeeded;
++ uLong size_comment;
++
++ int hasZIP64Record = 0;
++
++ // check first if we find a ZIP64 record
++ central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
++ if(central_pos > 0)
++ {
++ hasZIP64Record = 1;
++ }
++ else if(central_pos == 0)
++ {
++ central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);
++ }
++
++/* disable to allow appending to empty ZIP archive
++ if (central_pos==0)
++ err=ZIP_ERRNO;
++*/
++
++ if(hasZIP64Record)
++ {
++ ZPOS64_T sizeEndOfCentralDirectory;
++ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
++ err=ZIP_ERRNO;
++
++ /* the signature, already checked */
++ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* size of zip64 end of central directory record */
++ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* version made by */
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* version needed to extract */
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* number of this disk */
++ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* number of the disk with the start of the central directory */
++ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* total number of entries in the central directory on this disk */
++ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* total number of entries in the central directory */
++ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
++ err=ZIP_BADZIPFILE;
++
++ /* size of the central directory */
++ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* offset of start of central directory with respect to the
++ starting disk number */
++ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ // TODO..
++ // read the comment from the standard central header.
++ size_comment = 0;
++ }
++ else
++ {
++ // Read End of central Directory info
++ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err=ZIP_ERRNO;
++
++ /* the signature, already checked */
++ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* number of this disk */
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* number of the disk with the start of the central directory */
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
++ err=ZIP_ERRNO;
++
++ /* total number of entries in the central dir on this disk */
++ number_entry = 0;
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
++ err=ZIP_ERRNO;
++ else
++ number_entry = uL;
++
++ /* total number of entries in the central dir */
++ number_entry_CD = 0;
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
++ err=ZIP_ERRNO;
++ else
++ number_entry_CD = uL;
++
++ if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
++ err=ZIP_BADZIPFILE;
++
++ /* size of the central directory */
++ size_central_dir = 0;
++ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
++ err=ZIP_ERRNO;
++ else
++ size_central_dir = uL;
++
++ /* offset of start of central directory with respect to the starting disk number */
++ offset_central_dir = 0;
++ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
++ err=ZIP_ERRNO;
++ else
++ offset_central_dir = uL;
++
++
++ /* zipfile global comment length */
++ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)
++ err=ZIP_ERRNO;
++ }
++
++ if ((central_pos<offset_central_dir+size_central_dir) &&
++ (err==ZIP_OK))
++ err=ZIP_BADZIPFILE;
++
++ if (err!=ZIP_OK)
++ {
++ ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
++ return ZIP_ERRNO;
++ }
++
++ if (size_comment>0)
++ {
++ pziinit->globalcomment = (char*)ALLOC(size_comment+1);
++ if (pziinit->globalcomment)
++ {
++ size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);
++ pziinit->globalcomment[size_comment]=0;
++ }
++ }
++
++ byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);
++ pziinit->add_position_when_writting_offset = byte_before_the_zipfile;
++
++ {
++ ZPOS64_T size_central_dir_to_read = size_central_dir;
++ size_t buf_size = SIZEDATA_INDATABLOCK;
++ void* buf_read = (void*)ALLOC(buf_size);
++ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
++ err=ZIP_ERRNO;
++
++ while ((size_central_dir_to_read>0) && (err==ZIP_OK))
++ {
++ ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
++ if (read_this > size_central_dir_to_read)
++ read_this = size_central_dir_to_read;
++
++ if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)
++ err=ZIP_ERRNO;
++
++ if (err==ZIP_OK)
++ err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
++
++ size_central_dir_to_read-=read_this;
++ }
++ TRYFREE(buf_read);
++ }
++ pziinit->begin_pos = byte_before_the_zipfile;
++ pziinit->number_entry = number_entry_CD;
++
++ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
++ err=ZIP_ERRNO;
++
++ return err;
++}
++
++
++#endif /* !NO_ADDFILEINEXISTINGZIP*/
++
++
++/************************************************************/
++extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)
++{
++ zip64_internal ziinit;
++ zip64_internal* zi;
++ int err=ZIP_OK;
++
++ ziinit.z_filefunc.zseek32_file = NULL;
++ ziinit.z_filefunc.ztell32_file = NULL;
++ if (pzlib_filefunc64_32_def==NULL)
++ fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);
++ else
++ ziinit.z_filefunc = *pzlib_filefunc64_32_def;
++
++ ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
++ pathname,
++ (append == APPEND_STATUS_CREATE) ?
++ (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
++ (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
++
++ if (ziinit.filestream == NULL)
++ return NULL;
++
++ if (append == APPEND_STATUS_CREATEAFTER)
++ ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);
++
++ ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);
++ ziinit.in_opened_file_inzip = 0;
++ ziinit.ci.stream_initialised = 0;
++ ziinit.number_entry = 0;
++ ziinit.add_position_when_writting_offset = 0;
++ init_linkedlist(&(ziinit.central_dir));
++
++
++
++ zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));
++ if (zi==NULL)
++ {
++ ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
++ return NULL;
++ }
++
++ /* now we add file in a zipfile */
++# ifndef NO_ADDFILEINEXISTINGZIP
++ ziinit.globalcomment = NULL;
++ if (append == APPEND_STATUS_ADDINZIP)
++ {
++ // Read and Cache Central Directory Records
++ err = LoadCentralDirectoryRecord(&ziinit);
++ }
++
++ if (globalcomment)
++ {
++ *globalcomment = ziinit.globalcomment;
++ }
++# endif /* !NO_ADDFILEINEXISTINGZIP*/
++
++ if (err != ZIP_OK)
++ {
++# ifndef NO_ADDFILEINEXISTINGZIP
++ TRYFREE(ziinit.globalcomment);
++# endif /* !NO_ADDFILEINEXISTINGZIP*/
++ TRYFREE(zi);
++ return NULL;
++ }
++ else
++ {
++ *zi = ziinit;
++ return (zipFile)zi;
++ }
++}
++
++extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def)
++{
++ if (pzlib_filefunc32_def != NULL)
++ {
++ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
++ fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
++ return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
++ }
++ else
++ return zipOpen3(pathname, append, globalcomment, NULL);
++}
++
++extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def)
++{
++ if (pzlib_filefunc_def != NULL)
++ {
++ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
++ zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
++ zlib_filefunc64_32_def_fill.ztell32_file = NULL;
++ zlib_filefunc64_32_def_fill.zseek32_file = NULL;
++ return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
++ }
++ else
++ return zipOpen3(pathname, append, globalcomment, NULL);
++}
++
++
++
++extern zipFile ZEXPORT zipOpen (const char* pathname, int append)
++{
++ return zipOpen3((const void*)pathname,append,NULL,NULL);
++}
++
++extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
++{
++ return zipOpen3(pathname,append,NULL,NULL);
++}
++
++int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local)
++{
++ /* write the local header */
++ int err;
++ uInt size_filename = (uInt)strlen(filename);
++ uInt size_extrafield = size_extrafield_local;
++
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);
++
++ if (err==ZIP_OK)
++ {
++ if(zi->ci.zip64)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */
++ else
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
++ }
++
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
++
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
++
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
++
++ // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
++ if (err==ZIP_OK)
++ {
++ if(zi->ci.zip64)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */
++ else
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
++ }
++ if (err==ZIP_OK)
++ {
++ if(zi->ci.zip64)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */
++ else
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
++ }
++
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
++
++ if(zi->ci.zip64)
++ {
++ size_extrafield += 20;
++ }
++
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);
++
++ if ((err==ZIP_OK) && (size_filename > 0))
++ {
++ if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
++ err = ZIP_ERRNO;
++ }
++
++ if ((err==ZIP_OK) && (size_extrafield_local > 0))
++ {
++ if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)
++ err = ZIP_ERRNO;
++ }
++
++
++ if ((err==ZIP_OK) && (zi->ci.zip64))
++ {
++ // write the Zip64 extended info
++ short HeaderID = 1;
++ short DataSize = 16;
++ ZPOS64_T CompressedSize = 0;
++ ZPOS64_T UncompressedSize = 0;
++
++ // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
++ zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
++
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);
++
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
++ }
++
++ return err;
++}
++
++/*
++ NOTE.
++ When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped
++ before calling this function it can be done with zipRemoveExtraInfoBlock
++
++ It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize
++ unnecessary allocations.
++ */
++extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void* extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int raw,
++ int windowBits,int memLevel, int strategy,
++ const char* password, uLong crcForCrypting,
++ uLong versionMadeBy, uLong flagBase, int zip64)
++{
++ zip64_internal* zi;
++ uInt size_filename;
++ uInt size_comment;
++ uInt i;
++ int err = ZIP_OK;
++
++# ifdef NOCRYPT
++ (crcForCrypting);
++ if (password != NULL)
++ return ZIP_PARAMERROR;
++# endif
++
++ if (file == NULL)
++ return ZIP_PARAMERROR;
++
++#ifdef HAVE_BZIP2
++ if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED))
++ return ZIP_PARAMERROR;
++#else
++ if ((method!=0) && (method!=Z_DEFLATED))
++ return ZIP_PARAMERROR;
++#endif
++
++ zi = (zip64_internal*)file;
++
++ if (zi->in_opened_file_inzip == 1)
++ {
++ err = zipCloseFileInZip (file);
++ if (err != ZIP_OK)
++ return err;
++ }
++
++ if (filename==NULL)
++ filename="-";
++
++ if (comment==NULL)
++ size_comment = 0;
++ else
++ size_comment = (uInt)strlen(comment);
++
++ size_filename = (uInt)strlen(filename);
++
++ if (zipfi == NULL)
++ zi->ci.dosDate = 0;
++ else
++ {
++ if (zipfi->dosDate != 0)
++ zi->ci.dosDate = zipfi->dosDate;
++ else
++ zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);
++ }
++
++ zi->ci.flag = flagBase;
++ if ((level==8) || (level==9))
++ zi->ci.flag |= 2;
++ if (level==2)
++ zi->ci.flag |= 4;
++ if (level==1)
++ zi->ci.flag |= 6;
++ if (password != NULL)
++ zi->ci.flag |= 1;
++
++ zi->ci.crc32 = 0;
++ zi->ci.method = method;
++ zi->ci.encrypt = 0;
++ zi->ci.stream_initialised = 0;
++ zi->ci.pos_in_buffered_data = 0;
++ zi->ci.raw = raw;
++ zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
++
++ zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
++ zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
++
++ zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
++
++ zi->ci.size_centralExtra = size_extrafield_global;
++ zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
++ /* version info */
++ zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
++ zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
++ zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
++ zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
++ zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
++ zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
++
++ if (zipfi==NULL)
++ zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
++ else
++ zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
++
++ if (zipfi==NULL)
++ zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
++ else
++ zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
++
++ if(zi->ci.pos_local_header >= 0xffffffff)
++ zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);
++ else
++ zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4);
++
++ for (i=0;i<size_filename;i++)
++ *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
++
++ for (i=0;i<size_extrafield_global;i++)
++ *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
++ *(((const char*)extrafield_global)+i);
++
++ for (i=0;i<size_comment;i++)
++ *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
++ size_extrafield_global+i) = *(comment+i);
++ if (zi->ci.central_header == NULL)
++ return ZIP_INTERNALERROR;
++
++ zi->ci.zip64 = zip64;
++ zi->ci.totalCompressedData = 0;
++ zi->ci.totalUncompressedData = 0;
++ zi->ci.pos_zip64extrainfo = 0;
++
++ err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local);
++
++#ifdef HAVE_BZIP2
++ zi->ci.bstream.avail_in = (uInt)0;
++ zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
++ zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
++ zi->ci.bstream.total_in_hi32 = 0;
++ zi->ci.bstream.total_in_lo32 = 0;
++ zi->ci.bstream.total_out_hi32 = 0;
++ zi->ci.bstream.total_out_lo32 = 0;
++#endif
++
++ zi->ci.stream.avail_in = (uInt)0;
++ zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
++ zi->ci.stream.next_out = zi->ci.buffered_data;
++ zi->ci.stream.total_in = 0;
++ zi->ci.stream.total_out = 0;
++ zi->ci.stream.data_type = Z_BINARY;
++
++#ifdef HAVE_BZIP2
++ if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
++#else
++ if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
++#endif
++ {
++ if(zi->ci.method == Z_DEFLATED)
++ {
++ zi->ci.stream.zalloc = (alloc_func)0;
++ zi->ci.stream.zfree = (free_func)0;
++ zi->ci.stream.opaque = (voidpf)0;
++
++ if (windowBits>0)
++ windowBits = -windowBits;
++
++ err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
++
++ if (err==Z_OK)
++ zi->ci.stream_initialised = Z_DEFLATED;
++ }
++ else if(zi->ci.method == Z_BZIP2ED)
++ {
++#ifdef HAVE_BZIP2
++ // Init BZip stuff here
++ zi->ci.bstream.bzalloc = 0;
++ zi->ci.bstream.bzfree = 0;
++ zi->ci.bstream.opaque = (voidpf)0;
++
++ err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35);
++ if(err == BZ_OK)
++ zi->ci.stream_initialised = Z_BZIP2ED;
++#endif
++ }
++
++ }
++
++# ifndef NOCRYPT
++ zi->ci.crypt_header_size = 0;
++ if ((err==Z_OK) && (password != NULL))
++ {
++ unsigned char bufHead[RAND_HEAD_LEN];
++ unsigned int sizeHead;
++ zi->ci.encrypt = 1;
++ zi->ci.pcrc_32_tab = get_crc_table();
++ /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
++
++ sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
++ zi->ci.crypt_header_size = sizeHead;
++
++ if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
++ err = ZIP_ERRNO;
++ }
++# endif
++
++ if (err==Z_OK)
++ zi->in_opened_file_inzip = 1;
++ return err;
++}
++
++extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void* extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int raw,
++ int windowBits,int memLevel, int strategy,
++ const char* password, uLong crcForCrypting,
++ uLong versionMadeBy, uLong flagBase)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, raw,
++ windowBits, memLevel, strategy,
++ password, crcForCrypting, versionMadeBy, flagBase, 0);
++}
++
++extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void* extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int raw,
++ int windowBits,int memLevel, int strategy,
++ const char* password, uLong crcForCrypting)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, raw,
++ windowBits, memLevel, strategy,
++ password, crcForCrypting, VERSIONMADEBY, 0, 0);
++}
++
++extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void* extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int raw,
++ int windowBits,int memLevel, int strategy,
++ const char* password, uLong crcForCrypting, int zip64)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, raw,
++ windowBits, memLevel, strategy,
++ password, crcForCrypting, VERSIONMADEBY, 0, zip64);
++}
++
++extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void* extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int raw)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, raw,
++ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
++ NULL, 0, VERSIONMADEBY, 0, 0);
++}
++
++extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void* extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int raw, int zip64)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, raw,
++ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
++ NULL, 0, VERSIONMADEBY, 0, zip64);
++}
++
++extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void*extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level, int zip64)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, 0,
++ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
++ NULL, 0, VERSIONMADEBY, 0, zip64);
++}
++
++extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi,
++ const void* extrafield_local, uInt size_extrafield_local,
++ const void*extrafield_global, uInt size_extrafield_global,
++ const char* comment, int method, int level)
++{
++ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
++ extrafield_local, size_extrafield_local,
++ extrafield_global, size_extrafield_global,
++ comment, method, level, 0,
++ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
++ NULL, 0, VERSIONMADEBY, 0, 0);
++}
++
++local int zip64FlushWriteBuffer(zip64_internal* zi)
++{
++ int err=ZIP_OK;
++
++ if (zi->ci.encrypt != 0)
++ {
++#ifndef NOCRYPT
++ uInt i;
++ int t;
++ for (i=0;i<zi->ci.pos_in_buffered_data;i++)
++ zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
++#endif
++ }
++
++ if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
++ err = ZIP_ERRNO;
++
++ zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
++
++#ifdef HAVE_BZIP2
++ if(zi->ci.method == Z_BZIP2ED)
++ {
++ zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
++ zi->ci.bstream.total_in_lo32 = 0;
++ zi->ci.bstream.total_in_hi32 = 0;
++ }
++ else
++#endif
++ {
++ zi->ci.totalUncompressedData += zi->ci.stream.total_in;
++ zi->ci.stream.total_in = 0;
++ }
++
++
++ zi->ci.pos_in_buffered_data = 0;
++
++ return err;
++}
++
++extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len)
++{
++ zip64_internal* zi;
++ int err=ZIP_OK;
++
++ if (file == NULL)
++ return ZIP_PARAMERROR;
++ zi = (zip64_internal*)file;
++
++ if (zi->in_opened_file_inzip == 0)
++ return ZIP_PARAMERROR;
++
++ zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);
++
++#ifdef HAVE_BZIP2
++ if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw))
++ {
++ zi->ci.bstream.next_in = (void*)buf;
++ zi->ci.bstream.avail_in = len;
++ err = BZ_RUN_OK;
++
++ while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
++ {
++ if (zi->ci.bstream.avail_out == 0)
++ {
++ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
++ err = ZIP_ERRNO;
++ zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
++ zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
++ }
++
++
++ if(err != BZ_RUN_OK)
++ break;
++
++ if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
++ {
++ uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
++// uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
++ err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN);
++
++ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
++ }
++ }
++
++ if(err == BZ_RUN_OK)
++ err = ZIP_OK;
++ }
++ else
++#endif
++ {
++ zi->ci.stream.next_in = (Bytef*)buf;
++ zi->ci.stream.avail_in = len;
++
++ while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
++ {
++ if (zi->ci.stream.avail_out == 0)
++ {
++ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
++ err = ZIP_ERRNO;
++ zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
++ zi->ci.stream.next_out = zi->ci.buffered_data;
++ }
++
++
++ if(err != ZIP_OK)
++ break;
++
++ if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
++ {
++ uLong uTotalOutBefore = zi->ci.stream.total_out;
++ err=deflate(&zi->ci.stream, Z_NO_FLUSH);
++ if(uTotalOutBefore > zi->ci.stream.total_out)
++ {
++ int bBreak = 0;
++ bBreak++;
++ }
++
++ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
++ }
++ else
++ {
++ uInt copy_this,i;
++ if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
++ copy_this = zi->ci.stream.avail_in;
++ else
++ copy_this = zi->ci.stream.avail_out;
++
++ for (i = 0; i < copy_this; i++)
++ *(((char*)zi->ci.stream.next_out)+i) =
++ *(((const char*)zi->ci.stream.next_in)+i);
++ {
++ zi->ci.stream.avail_in -= copy_this;
++ zi->ci.stream.avail_out-= copy_this;
++ zi->ci.stream.next_in+= copy_this;
++ zi->ci.stream.next_out+= copy_this;
++ zi->ci.stream.total_in+= copy_this;
++ zi->ci.stream.total_out+= copy_this;
++ zi->ci.pos_in_buffered_data += copy_this;
++ }
++ }
++ }// while(...)
++ }
++
++ return err;
++}
++
++extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)
++{
++ return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
++}
++
++extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32)
++{
++ zip64_internal* zi;
++ ZPOS64_T compressed_size;
++ uLong invalidValue = 0xffffffff;
++ short datasize = 0;
++ int err=ZIP_OK;
++
++ if (file == NULL)
++ return ZIP_PARAMERROR;
++ zi = (zip64_internal*)file;
++
++ if (zi->in_opened_file_inzip == 0)
++ return ZIP_PARAMERROR;
++ zi->ci.stream.avail_in = 0;
++
++ if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
++ {
++ while (err==ZIP_OK)
++ {
++ uLong uTotalOutBefore;
++ if (zi->ci.stream.avail_out == 0)
++ {
++ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
++ err = ZIP_ERRNO;
++ zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
++ zi->ci.stream.next_out = zi->ci.buffered_data;
++ }
++ uTotalOutBefore = zi->ci.stream.total_out;
++ err=deflate(&zi->ci.stream, Z_FINISH);
++ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
++ }
++ }
++ else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
++ {
++#ifdef HAVE_BZIP2
++ err = BZ_FINISH_OK;
++ while (err==BZ_FINISH_OK)
++ {
++ uLong uTotalOutBefore;
++ if (zi->ci.bstream.avail_out == 0)
++ {
++ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
++ err = ZIP_ERRNO;
++ zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
++ zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
++ }
++ uTotalOutBefore = zi->ci.bstream.total_out_lo32;
++ err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH);
++ if(err == BZ_STREAM_END)
++ err = Z_STREAM_END;
++
++ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore);
++ }
++
++ if(err == BZ_FINISH_OK)
++ err = ZIP_OK;
++#endif
++ }
++
++ if (err==Z_STREAM_END)
++ err=ZIP_OK; /* this is normal */
++
++ if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
++ {
++ if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)
++ err = ZIP_ERRNO;
++ }
++
++ if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
++ {
++ int tmp_err = deflateEnd(&zi->ci.stream);
++ if (err == ZIP_OK)
++ err = tmp_err;
++ zi->ci.stream_initialised = 0;
++ }
++#ifdef HAVE_BZIP2
++ else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
++ {
++ int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);
++ if (err==ZIP_OK)
++ err = tmperr;
++ zi->ci.stream_initialised = 0;
++ }
++#endif
++
++ if (!zi->ci.raw)
++ {
++ crc32 = (uLong)zi->ci.crc32;
++ uncompressed_size = zi->ci.totalUncompressedData;
++ }
++ compressed_size = zi->ci.totalCompressedData;
++
++# ifndef NOCRYPT
++ compressed_size += zi->ci.crypt_header_size;
++# endif
++
++ // update Current Item crc and sizes,
++ if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)
++ {
++ /*version Made by*/
++ zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);
++ /*version needed*/
++ zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);
++
++ }
++
++ zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
++
++
++ if(compressed_size >= 0xffffffff)
++ zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/
++ else
++ zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/
++
++ /// set internal file attributes field
++ if (zi->ci.stream.data_type == Z_ASCII)
++ zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
++
++ if(uncompressed_size >= 0xffffffff)
++ zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/
++ else
++ zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/
++
++ // Add ZIP64 extra info field for uncompressed size
++ if(uncompressed_size >= 0xffffffff)
++ datasize += 8;
++
++ // Add ZIP64 extra info field for compressed size
++ if(compressed_size >= 0xffffffff)
++ datasize += 8;
++
++ // Add ZIP64 extra info field for relative offset to local file header of current file
++ if(zi->ci.pos_local_header >= 0xffffffff)
++ datasize += 8;
++
++ if(datasize > 0)
++ {
++ char* p = NULL;
++
++ if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
++ {
++ // we can not write more data to the buffer that we have room for.
++ return ZIP_BADZIPFILE;
++ }
++
++ p = zi->ci.central_header + zi->ci.size_centralheader;
++
++ // Add Extra Information Header for 'ZIP64 information'
++ zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
++ p += 2;
++ zip64local_putValue_inmemory(p, datasize, 2); // DataSize
++ p += 2;
++
++ if(uncompressed_size >= 0xffffffff)
++ {
++ zip64local_putValue_inmemory(p, uncompressed_size, 8);
++ p += 8;
++ }
++
++ if(compressed_size >= 0xffffffff)
++ {
++ zip64local_putValue_inmemory(p, compressed_size, 8);
++ p += 8;
++ }
++
++ if(zi->ci.pos_local_header >= 0xffffffff)
++ {
++ zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);
++ p += 8;
++ }
++
++ // Update how much extra free space we got in the memory buffer
++ // and increase the centralheader size so the new ZIP64 fields are included
++ // ( 4 below is the size of HeaderID and DataSize field )
++ zi->ci.size_centralExtraFree -= datasize + 4;
++ zi->ci.size_centralheader += datasize + 4;
++
++ // Update the extra info size field
++ zi->ci.size_centralExtra += datasize + 4;
++ zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
++ }
++
++ if (err==ZIP_OK)
++ err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);
++
++ free(zi->ci.central_header);
++
++ if (err==ZIP_OK)
++ {
++ // Update the LocalFileHeader with the new values.
++
++ ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
++
++ if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err = ZIP_ERRNO;
++
++ if (err==ZIP_OK)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
++
++ if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff )
++ {
++ if(zi->ci.pos_zip64extrainfo > 0)
++ {
++ // Update the size in the ZIP64 extended field.
++ if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err = ZIP_ERRNO;
++
++ if (err==ZIP_OK) /* compressed size, unknown */
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);
++
++ if (err==ZIP_OK) /* uncompressed size, unknown */
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
++ }
++ else
++ err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
++ }
++ else
++ {
++ if (err==ZIP_OK) /* compressed size, unknown */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
++
++ if (err==ZIP_OK) /* uncompressed size, unknown */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
++ }
++
++ if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
++ err = ZIP_ERRNO;
++ }
++
++ zi->number_entry ++;
++ zi->in_opened_file_inzip = 0;
++
++ return err;
++}
++
++extern int ZEXPORT zipCloseFileInZip (zipFile file)
++{
++ return zipCloseFileInZipRaw (file,0,0);
++}
++
++int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip)
++{
++ int err = ZIP_OK;
++ ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset;
++
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
++
++ /*num disks*/
++ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
++
++ /*relative offset*/
++ if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);
++
++ /*total disks*/ /* Do not support spawning of disk so always say 1 here*/
++ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
++
++ return err;
++}
++
++int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
++{
++ int err = ZIP_OK;
++
++ uLong Zip64DataSize = 44;
++
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
++
++ if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
++
++ if (err==ZIP_OK) /* version made by */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
++
++ if (err==ZIP_OK) /* version needed */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
++
++ if (err==ZIP_OK) /* number of this disk */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
++
++ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
++
++ if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
++
++ if (err==ZIP_OK) /* total number of entries in the central dir */
++ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
++
++ if (err==ZIP_OK) /* size of the central directory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);
++
++ if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
++ {
++ ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
++ }
++ return err;
++}
++int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
++{
++ int err = ZIP_OK;
++
++ /*signature*/
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
++
++ if (err==ZIP_OK) /* number of this disk */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
++
++ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
++
++ if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
++ {
++ {
++ if(zi->number_entry >= 0xFFFF)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
++ else
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
++ }
++ }
++
++ if (err==ZIP_OK) /* total number of entries in the central dir */
++ {
++ if(zi->number_entry >= 0xFFFF)
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
++ else
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
++ }
++
++ if (err==ZIP_OK) /* size of the central directory */
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
++
++ if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
++ {
++ ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
++ if(pos >= 0xffffffff)
++ {
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);
++ }
++ else
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
++ }
++
++ return err;
++}
++
++int Write_GlobalComment(zip64_internal* zi, const char* global_comment)
++{
++ int err = ZIP_OK;
++ uInt size_global_comment = 0;
++
++ if(global_comment != NULL)
++ size_global_comment = (uInt)strlen(global_comment);
++
++ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
++
++ if (err == ZIP_OK && size_global_comment > 0)
++ {
++ if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
++ err = ZIP_ERRNO;
++ }
++ return err;
++}
++
++extern int ZEXPORT zipClose (zipFile file, const char* global_comment)
++{
++ zip64_internal* zi;
++ int err = 0;
++ uLong size_centraldir = 0;
++ ZPOS64_T centraldir_pos_inzip;
++ ZPOS64_T pos;
++
++ if (file == NULL)
++ return ZIP_PARAMERROR;
++
++ zi = (zip64_internal*)file;
++
++ if (zi->in_opened_file_inzip == 1)
++ {
++ err = zipCloseFileInZip (file);
++ }
++
++#ifndef NO_ADDFILEINEXISTINGZIP
++ if (global_comment==NULL)
++ global_comment = zi->globalcomment;
++#endif
++
++ centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
++
++ if (err==ZIP_OK)
++ {
++ linkedlist_datablock_internal* ldi = zi->central_dir.first_block;
++ while (ldi!=NULL)
++ {
++ if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
++ {
++ if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block)
++ err = ZIP_ERRNO;
++ }
++
++ size_centraldir += ldi->filled_in_this_block;
++ ldi = ldi->next_datablock;
++ }
++ }
++ free_linkedlist(&(zi->central_dir));
++
++ pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
++ if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)
++ {
++ ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
++ Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
++
++ Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
++ }
++
++ if (err==ZIP_OK)
++ err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
++
++ if(err == ZIP_OK)
++ err = Write_GlobalComment(zi, global_comment);
++
++ if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
++ if (err == ZIP_OK)
++ err = ZIP_ERRNO;
++
++#ifndef NO_ADDFILEINEXISTINGZIP
++ TRYFREE(zi->globalcomment);
++#endif
++ TRYFREE(zi);
++
++ return err;
++}
++
++extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader)
++{
++ char* p = pData;
++ int size = 0;
++ char* pNewHeader;
++ char* pTmp;
++ short header;
++ short dataSize;
++
++ int retVal = ZIP_OK;
++
++ if(pData == NULL || *dataLen < 4)
++ return ZIP_PARAMERROR;
++
++ pNewHeader = (char*)ALLOC(*dataLen);
++ pTmp = pNewHeader;
++
++ while(p < (pData + *dataLen))
++ {
++ header = *(short*)p;
++ dataSize = *(((short*)p)+1);
++
++ if( header == sHeader ) // Header found.
++ {
++ p += dataSize + 4; // skip it. do not copy to temp buffer
++ }
++ else
++ {
++ // Extra Info block should not be removed, So copy it to the temp buffer.
++ memcpy(pTmp, p, dataSize + 4);
++ p += dataSize + 4;
++ size += dataSize + 4;
++ }
++
++ }
++
++ if(size < *dataLen)
++ {
++ // clean old extra info block.
++ memset(pData,0, *dataLen);
++
++ // copy the new extra info block over the old
++ if(size > 0)
++ memcpy(pData, pNewHeader, size);
++
++ // set the new extra info size
++ *dataLen = size;
++
++ retVal = ZIP_OK;
++ }
++ else
++ retVal = ZIP_ERRNO;
++
++ TRYFREE(pNewHeader);
++
++ return retVal;
++}
+diff --git a/converter/COLLADA2GLTF/kmz/zip.h b/converter/COLLADA2GLTF/kmz/zip.h
+new file mode 100644
+index 0000000..8aaebb6
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/zip.h
+@@ -0,0 +1,362 @@
++/* zip.h -- IO on .zip files using zlib
++ Version 1.1, February 14h, 2010
++ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
++
++ Modifications for Zip64 support
++ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
++
++ For more info read MiniZip_info.txt
++
++ ---------------------------------------------------------------------------
++
++ 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.
++
++ ---------------------------------------------------------------------------
++
++ Changes
++
++ See header of zip.h
++
++*/
++
++#ifndef _zip12_H
++#define _zip12_H
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++//#define HAVE_BZIP2
++
++#ifndef _ZLIB_H
++#include "zlib.h"
++#endif
++
++#ifndef _ZLIBIOAPI_H
++#include "ioapi.h"
++#endif
++
++#ifdef HAVE_BZIP2
++#include "bzlib.h"
++#endif
++
++#define Z_BZIP2ED 12
++
++#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
++/* like the STRICT of WIN32, we define a pointer that cannot be converted
++ from (void*) without cast */
++typedef struct TagzipFile__ { int unused; } zipFile__;
++typedef zipFile__ *zipFile;
++#else
++typedef voidp zipFile;
++#endif
++
++#define ZIP_OK (0)
++#define ZIP_EOF (0)
++#define ZIP_ERRNO (Z_ERRNO)
++#define ZIP_PARAMERROR (-102)
++#define ZIP_BADZIPFILE (-103)
++#define ZIP_INTERNALERROR (-104)
++
++#ifndef DEF_MEM_LEVEL
++# if MAX_MEM_LEVEL >= 8
++# define DEF_MEM_LEVEL 8
++# else
++# define DEF_MEM_LEVEL MAX_MEM_LEVEL
++# endif
++#endif
++/* default memLevel */
++
++/* tm_zip contain date/time info */
++typedef struct tm_zip_s
++{
++ uInt tm_sec; /* seconds after the minute - [0,59] */
++ uInt tm_min; /* minutes after the hour - [0,59] */
++ uInt tm_hour; /* hours since midnight - [0,23] */
++ uInt tm_mday; /* day of the month - [1,31] */
++ uInt tm_mon; /* months since January - [0,11] */
++ uInt tm_year; /* years - [1980..2044] */
++} tm_zip;
++
++typedef struct
++{
++ tm_zip tmz_date; /* date in understandable format */
++ uLong dosDate; /* if dos_date == 0, tmu_date is used */
++/* uLong flag; */ /* general purpose bit flag 2 bytes */
++
++ uLong internal_fa; /* internal file attributes 2 bytes */
++ uLong external_fa; /* external file attributes 4 bytes */
++} zip_fileinfo;
++
++typedef const char* zipcharpc;
++
++
++#define APPEND_STATUS_CREATE (0)
++#define APPEND_STATUS_CREATEAFTER (1)
++#define APPEND_STATUS_ADDINZIP (2)
++
++extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
++extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
++/*
++ Create a zipfile.
++ pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
++ an Unix computer "zlib/zlib113.zip".
++ if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
++ will be created at the end of the file.
++ (useful if the file contain a self extractor code)
++ if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
++ add files in existing zip (be sure you don't add file that doesn't exist)
++ If the zipfile cannot be opened, the return value is NULL.
++ Else, the return value is a zipFile Handle, usable with other function
++ of this zip package.
++*/
++
++/* Note : there is no delete function into a zipfile.
++ If you want delete file into a zipfile, you must open a zipfile, and create another
++ Of couse, you can use RAW reading and writing to copy the file you did not want delte
++*/
++
++extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
++ int append,
++ zipcharpc* globalcomment,
++ zlib_filefunc_def* pzlib_filefunc_def));
++
++extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
++ int append,
++ zipcharpc* globalcomment,
++ zlib_filefunc64_def* pzlib_filefunc_def));
++
++extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level));
++
++extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int zip64));
++
++/*
++ Open a file in the ZIP for writing.
++ filename : the filename in zip (if NULL, '-' without quote will be used
++ *zipfi contain supplemental information
++ if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
++ contains the extrafield data the the local header
++ if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
++ contains the extrafield data the the local header
++ if comment != NULL, comment contain the comment string
++ method contain the compression method (0 for store, Z_DEFLATED for deflate)
++ level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
++ zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
++ this MUST be '1' if the uncompressed size is >= 0xffffffff.
++
++*/
++
++
++extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int raw));
++
++
++extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int raw,
++ int zip64));
++/*
++ Same than zipOpenNewFileInZip, except if raw=1, we write raw file
++ */
++
++extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int raw,
++ int windowBits,
++ int memLevel,
++ int strategy,
++ const char* password,
++ uLong crcForCrypting));
++
++extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int raw,
++ int windowBits,
++ int memLevel,
++ int strategy,
++ const char* password,
++ uLong crcForCrypting,
++ int zip64
++ ));
++
++/*
++ Same than zipOpenNewFileInZip2, except
++ windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
++ password : crypting password (NULL for no crypting)
++ crcForCrypting : crc of file to compress (needed for crypting)
++ */
++
++extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int raw,
++ int windowBits,
++ int memLevel,
++ int strategy,
++ const char* password,
++ uLong crcForCrypting,
++ uLong versionMadeBy,
++ uLong flagBase
++ ));
++
++
++extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
++ const char* filename,
++ const zip_fileinfo* zipfi,
++ const void* extrafield_local,
++ uInt size_extrafield_local,
++ const void* extrafield_global,
++ uInt size_extrafield_global,
++ const char* comment,
++ int method,
++ int level,
++ int raw,
++ int windowBits,
++ int memLevel,
++ int strategy,
++ const char* password,
++ uLong crcForCrypting,
++ uLong versionMadeBy,
++ uLong flagBase,
++ int zip64
++ ));
++/*
++ Same than zipOpenNewFileInZip4, except
++ versionMadeBy : value for Version made by field
++ flag : value for flag field (compression level info will be added)
++ */
++
++
++extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
++ const void* buf,
++ unsigned len));
++/*
++ Write data in the zipfile
++*/
++
++extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
++/*
++ Close the current file in the zipfile
++*/
++
++extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
++ uLong uncompressed_size,
++ uLong crc32));
++
++extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
++ ZPOS64_T uncompressed_size,
++ uLong crc32));
++
++/*
++ Close the current file in the zipfile, for file opened with
++ parameter raw=1 in zipOpenNewFileInZip2
++ uncompressed_size and crc32 are value for the uncompressed size
++*/
++
++extern int ZEXPORT zipClose OF((zipFile file,
++ const char* global_comment));
++/*
++ Close the zipfile
++*/
++
++
++extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
++/*
++ zipRemoveExtraInfoBlock - Added by Mathias Svensson
++
++ Remove extra information block from a extra information data for the local file header or central directory header
++
++ It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
++
++ 0x0001 is the signature header for the ZIP64 extra information blocks
++
++ usage.
++ Remove ZIP64 Extra information from a central director extra field data
++ zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
++
++ Remove ZIP64 Extra information from a Local File Header extra field data
++ zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
++*/
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* _zip64_H */
+diff --git a/converter/COLLADA2GLTF/kmz/zlib.h b/converter/COLLADA2GLTF/kmz/zlib.h
+new file mode 100644
+index 0000000..3e0c767
+--- /dev/null
++++ b/converter/COLLADA2GLTF/kmz/zlib.h
+@@ -0,0 +1,1768 @@
++/* zlib.h -- interface of the 'zlib' general purpose compression library
++ version 1.2.8, April 28th, 2013
++
++ Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
++
++ 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.
++
++ Jean-loup Gailly Mark Adler
++ jloup@gzip.org madler@alumni.caltech.edu
++
++
++ The data format used by the zlib library is described by RFCs (Request for
++ Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
++ (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
++*/
++
++#ifndef ZLIB_H
++#define ZLIB_H
++
++#include "zconf.h"
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#define ZLIB_VERSION "1.2.8"
++#define ZLIB_VERNUM 0x1280
++#define ZLIB_VER_MAJOR 1
++#define ZLIB_VER_MINOR 2
++#define ZLIB_VER_REVISION 8
++#define ZLIB_VER_SUBREVISION 0
++
++/*
++ The 'zlib' compression library provides in-memory compression and
++ decompression functions, including integrity checks of the uncompressed data.
++ This version of the library supports only one compression method (deflation)
++ but other algorithms will be added later and will have the same stream
++ interface.
++
++ Compression can be done in a single step if the buffers are large enough,
++ or can be done by repeated calls of the compression function. In the latter
++ case, the application must provide more input and/or consume the output
++ (providing more output space) before each call.
++
++ The compressed data format used by default by the in-memory functions is
++ the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
++ around a deflate stream, which is itself documented in RFC 1951.
++
++ The library also supports reading and writing files in gzip (.gz) format
++ with an interface similar to that of stdio using the functions that start
++ with "gz". The gzip format is different from the zlib format. gzip is a
++ gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
++
++ This library can optionally read and write gzip streams in memory as well.
++
++ The zlib format was designed to be compact and fast for use in memory
++ and on communications channels. The gzip format was designed for single-
++ file compression on file systems, has a larger header than zlib to maintain
++ directory information, and uses a different, slower check method than zlib.
++
++ The library does not install any signal handler. The decoder checks
++ the consistency of the compressed data, so the library should never crash
++ even in case of corrupted input.
++*/
++
++typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
++typedef void (*free_func) OF((voidpf opaque, voidpf address));
++
++struct internal_state;
++
++typedef struct z_stream_s {
++ z_const Bytef *next_in; /* next input byte */
++ uInt avail_in; /* number of bytes available at next_in */
++ uLong total_in; /* total number of input bytes read so far */
++
++ Bytef *next_out; /* next output byte should be put there */
++ uInt avail_out; /* remaining free space at next_out */
++ uLong total_out; /* total number of bytes output so far */
++
++ z_const char *msg; /* last error message, NULL if no error */
++ struct internal_state FAR *state; /* not visible by applications */
++
++ alloc_func zalloc; /* used to allocate the internal state */
++ free_func zfree; /* used to free the internal state */
++ voidpf opaque; /* private data object passed to zalloc and zfree */
++
++ int data_type; /* best guess about the data type: binary or text */
++ uLong adler; /* adler32 value of the uncompressed data */
++ uLong reserved; /* reserved for future use */
++} z_stream;
++
++typedef z_stream FAR *z_streamp;
++
++/*
++ gzip header information passed to and from zlib routines. See RFC 1952
++ for more details on the meanings of these fields.
++*/
++typedef struct gz_header_s {
++ int text; /* true if compressed data believed to be text */
++ uLong time; /* modification time */
++ int xflags; /* extra flags (not used when writing a gzip file) */
++ int os; /* operating system */
++ Bytef *extra; /* pointer to extra field or Z_NULL if none */
++ uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
++ uInt extra_max; /* space at extra (only when reading header) */
++ Bytef *name; /* pointer to zero-terminated file name or Z_NULL */
++ uInt name_max; /* space at name (only when reading header) */
++ Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
++ uInt comm_max; /* space at comment (only when reading header) */
++ int hcrc; /* true if there was or will be a header crc */
++ int done; /* true when done reading gzip header (not used
++ when writing a gzip file) */
++} gz_header;
++
++typedef gz_header FAR *gz_headerp;
++
++/*
++ The application must update next_in and avail_in when avail_in has dropped
++ to zero. It must update next_out and avail_out when avail_out has dropped
++ to zero. The application must initialize zalloc, zfree and opaque before
++ calling the init function. All other fields are set by the compression
++ library and must not be updated by the application.
++
++ The opaque value provided by the application will be passed as the first
++ parameter for calls of zalloc and zfree. This can be useful for custom
++ memory management. The compression library attaches no meaning to the
++ opaque value.
++
++ zalloc must return Z_NULL if there is not enough memory for the object.
++ If zlib is used in a multi-threaded application, zalloc and zfree must be
++ thread safe.
++
++ On 16-bit systems, the functions zalloc and zfree must be able to allocate
++ exactly 65536 bytes, but will not be required to allocate more than this if
++ the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers
++ returned by zalloc for objects of exactly 65536 bytes *must* have their
++ offset normalized to zero. The default allocation function provided by this
++ library ensures this (see zutil.c). To reduce memory requirements and avoid
++ any allocation of 64K objects, at the expense of compression ratio, compile
++ the library with -DMAX_WBITS=14 (see zconf.h).
++
++ The fields total_in and total_out can be used for statistics or progress
++ reports. After compression, total_in holds the total size of the
++ uncompressed data and may be saved for use in the decompressor (particularly
++ if the decompressor wants to decompress everything in a single step).
++*/
++
++ /* constants */
++
++#define Z_NO_FLUSH 0
++#define Z_PARTIAL_FLUSH 1
++#define Z_SYNC_FLUSH 2
++#define Z_FULL_FLUSH 3
++#define Z_FINISH 4
++#define Z_BLOCK 5
++#define Z_TREES 6
++/* Allowed flush values; see deflate() and inflate() below for details */
++
++#define Z_OK 0
++#define Z_STREAM_END 1
++#define Z_NEED_DICT 2
++#define Z_ERRNO (-1)
++#define Z_STREAM_ERROR (-2)
++#define Z_DATA_ERROR (-3)
++#define Z_MEM_ERROR (-4)
++#define Z_BUF_ERROR (-5)
++#define Z_VERSION_ERROR (-6)
++/* Return codes for the compression/decompression functions. Negative values
++ * are errors, positive values are used for special but normal events.
++ */
++
++#define Z_NO_COMPRESSION 0
++#define Z_BEST_SPEED 1
++#define Z_BEST_COMPRESSION 9
++#define Z_DEFAULT_COMPRESSION (-1)
++/* compression levels */
++
++#define Z_FILTERED 1
++#define Z_HUFFMAN_ONLY 2
++#define Z_RLE 3
++#define Z_FIXED 4
++#define Z_DEFAULT_STRATEGY 0
++/* compression strategy; see deflateInit2() below for details */
++
++#define Z_BINARY 0
++#define Z_TEXT 1
++#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
++#define Z_UNKNOWN 2
++/* Possible values of the data_type field (though see inflate()) */
++
++#define Z_DEFLATED 8
++/* The deflate compression method (the only one supported in this version) */
++
++#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
++
++#define zlib_version zlibVersion()
++/* for compatibility with versions < 1.0.2 */
++
++
++ /* basic functions */
++
++ZEXTERN const char * ZEXPORT zlibVersion OF((void));
++/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
++ If the first character differs, the library code actually used is not
++ compatible with the zlib.h header file used by the application. This check
++ is automatically made by deflateInit and inflateInit.
++ */
++
++/*
++ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
++
++ Initializes the internal stream state for compression. The fields
++ zalloc, zfree and opaque must be initialized before by the caller. If
++ zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
++ allocation functions.
++
++ The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
++ 1 gives best speed, 9 gives best compression, 0 gives no compression at all
++ (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION
++ requests a default compromise between speed and compression (currently
++ equivalent to level 6).
++
++ deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
++ memory, Z_STREAM_ERROR if level is not a valid compression level, or
++ Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
++ with the version assumed by the caller (ZLIB_VERSION). msg is set to null
++ if there is no error message. deflateInit does not perform any compression:
++ this will be done by deflate().
++*/
++
++
++ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
++/*
++ deflate compresses as much data as possible, and stops when the input
++ buffer becomes empty or the output buffer becomes full. It may introduce
++ some output latency (reading input without producing any output) except when
++ forced to flush.
++
++ The detailed semantics are as follows. deflate performs one or both of the
++ following actions:
++
++ - Compress more input starting at next_in and update next_in and avail_in
++ accordingly. If not all input can be processed (because there is not
++ enough room in the output buffer), next_in and avail_in are updated and
++ processing will resume at this point for the next call of deflate().
++
++ - Provide more output starting at next_out and update next_out and avail_out
++ accordingly. This action is forced if the parameter flush is non zero.
++ Forcing flush frequently degrades the compression ratio, so this parameter
++ should be set only when necessary (in interactive applications). Some
++ output may be provided even if flush is not set.
++
++ Before the call of deflate(), the application should ensure that at least
++ one of the actions is possible, by providing more input and/or consuming more
++ output, and updating avail_in or avail_out accordingly; avail_out should
++ never be zero before the call. The application can consume the compressed
++ output when it wants, for example when the output buffer is full (avail_out
++ == 0), or after each call of deflate(). If deflate returns Z_OK and with
++ zero avail_out, it must be called again after making room in the output
++ buffer because there might be more output pending.
++
++ Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
++ decide how much data to accumulate before producing output, in order to
++ maximize compression.
++
++ If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
++ flushed to the output buffer and the output is aligned on a byte boundary, so
++ that the decompressor can get all input data available so far. (In
++ particular avail_in is zero after the call if enough output space has been
++ provided before the call.) Flushing may degrade compression for some
++ compression algorithms and so it should be used only when necessary. This
++ completes the current deflate block and follows it with an empty stored block
++ that is three bits plus filler bits to the next byte, followed by four bytes
++ (00 00 ff ff).
++
++ If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
++ output buffer, but the output is not aligned to a byte boundary. All of the
++ input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
++ This completes the current deflate block and follows it with an empty fixed
++ codes block that is 10 bits long. This assures that enough bytes are output
++ in order for the decompressor to finish the block before the empty fixed code
++ block.
++
++ If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
++ for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
++ seven bits of the current block are held to be written as the next byte after
++ the next deflate block is completed. In this case, the decompressor may not
++ be provided enough bits at this point in order to complete decompression of
++ the data provided so far to the compressor. It may need to wait for the next
++ block to be emitted. This is for advanced applications that need to control
++ the emission of deflate blocks.
++
++ If flush is set to Z_FULL_FLUSH, all output is flushed as with
++ Z_SYNC_FLUSH, and the compression state is reset so that decompression can
++ restart from this point if previous compressed data has been damaged or if
++ random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
++ compression.
++
++ If deflate returns with avail_out == 0, this function must be called again
++ with the same value of the flush parameter and more output space (updated
++ avail_out), until the flush is complete (deflate returns with non-zero
++ avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
++ avail_out is greater than six to avoid repeated flush markers due to
++ avail_out == 0 on return.
++
++ If the parameter flush is set to Z_FINISH, pending input is processed,
++ pending output is flushed and deflate returns with Z_STREAM_END if there was
++ enough output space; if deflate returns with Z_OK, this function must be
++ called again with Z_FINISH and more output space (updated avail_out) but no
++ more input data, until it returns with Z_STREAM_END or an error. After
++ deflate has returned Z_STREAM_END, the only possible operations on the stream
++ are deflateReset or deflateEnd.
++
++ Z_FINISH can be used immediately after deflateInit if all the compression
++ is to be done in a single step. In this case, avail_out must be at least the
++ value returned by deflateBound (see below). Then deflate is guaranteed to
++ return Z_STREAM_END. If not enough output space is provided, deflate will
++ not return Z_STREAM_END, and it must be called again as described above.
++
++ deflate() sets strm->adler to the adler32 checksum of all input read
++ so far (that is, total_in bytes).
++
++ deflate() may update strm->data_type if it can make a good guess about
++ the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
++ binary. This field is only for information purposes and does not affect the
++ compression algorithm in any manner.
++
++ deflate() returns Z_OK if some progress has been made (more input
++ processed or more output produced), Z_STREAM_END if all input has been
++ consumed and all output has been produced (only when flush is set to
++ Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
++ if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
++ (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
++ fatal, and deflate() can be called again with more input and more output
++ space to continue compressing.
++*/
++
++
++ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
++/*
++ All dynamically allocated data structures for this stream are freed.
++ This function discards any unprocessed input and does not flush any pending
++ output.
++
++ deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
++ stream state was inconsistent, Z_DATA_ERROR if the stream was freed
++ prematurely (some input or output was discarded). In the error case, msg
++ may be set but then points to a static string (which must not be
++ deallocated).
++*/
++
++
++/*
++ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
++
++ Initializes the internal stream state for decompression. The fields
++ next_in, avail_in, zalloc, zfree and opaque must be initialized before by
++ the caller. If next_in is not Z_NULL and avail_in is large enough (the
++ exact value depends on the compression method), inflateInit determines the
++ compression method from the zlib header and allocates all data structures
++ accordingly; otherwise the allocation will be deferred to the first call of
++ inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
++ use default allocation functions.
++
++ inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
++ memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
++ version assumed by the caller, or Z_STREAM_ERROR if the parameters are
++ invalid, such as a null pointer to the structure. msg is set to null if
++ there is no error message. inflateInit does not perform any decompression
++ apart from possibly reading the zlib header if present: actual decompression
++ will be done by inflate(). (So next_in and avail_in may be modified, but
++ next_out and avail_out are unused and unchanged.) The current implementation
++ of inflateInit() does not process any header information -- that is deferred
++ until inflate() is called.
++*/
++
++
++ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
++/*
++ inflate decompresses as much data as possible, and stops when the input
++ buffer becomes empty or the output buffer becomes full. It may introduce
++ some output latency (reading input without producing any output) except when
++ forced to flush.
++
++ The detailed semantics are as follows. inflate performs one or both of the
++ following actions:
++
++ - Decompress more input starting at next_in and update next_in and avail_in
++ accordingly. If not all input can be processed (because there is not
++ enough room in the output buffer), next_in is updated and processing will
++ resume at this point for the next call of inflate().
++
++ - Provide more output starting at next_out and update next_out and avail_out
++ accordingly. inflate() provides as much output as possible, until there is
++ no more input data or no more space in the output buffer (see below about
++ the flush parameter).
++
++ Before the call of inflate(), the application should ensure that at least
++ one of the actions is possible, by providing more input and/or consuming more
++ output, and updating the next_* and avail_* values accordingly. The
++ application can consume the uncompressed output when it wants, for example
++ when the output buffer is full (avail_out == 0), or after each call of
++ inflate(). If inflate returns Z_OK and with zero avail_out, it must be
++ called again after making room in the output buffer because there might be
++ more output pending.
++
++ The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
++ Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much
++ output as possible to the output buffer. Z_BLOCK requests that inflate()
++ stop if and when it gets to the next deflate block boundary. When decoding
++ the zlib or gzip format, this will cause inflate() to return immediately
++ after the header and before the first block. When doing a raw inflate,
++ inflate() will go ahead and process the first block, and will return when it
++ gets to the end of that block, or when it runs out of data.
++
++ The Z_BLOCK option assists in appending to or combining deflate streams.
++ Also to assist in this, on return inflate() will set strm->data_type to the
++ number of unused bits in the last byte taken from strm->next_in, plus 64 if
++ inflate() is currently decoding the last block in the deflate stream, plus
++ 128 if inflate() returned immediately after decoding an end-of-block code or
++ decoding the complete header up to just before the first byte of the deflate
++ stream. The end-of-block will not be indicated until all of the uncompressed
++ data from that block has been written to strm->next_out. The number of
++ unused bits may in general be greater than seven, except when bit 7 of
++ data_type is set, in which case the number of unused bits will be less than
++ eight. data_type is set as noted here every time inflate() returns for all
++ flush options, and so can be used to determine the amount of currently
++ consumed input in bits.
++
++ The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
++ end of each deflate block header is reached, before any actual data in that
++ block is decoded. This allows the caller to determine the length of the
++ deflate block header for later use in random access within a deflate block.
++ 256 is added to the value of strm->data_type when inflate() returns
++ immediately after reaching the end of the deflate block header.
++
++ inflate() should normally be called until it returns Z_STREAM_END or an
++ error. However if all decompression is to be performed in a single step (a
++ single call of inflate), the parameter flush should be set to Z_FINISH. In
++ this case all pending input is processed and all pending output is flushed;
++ avail_out must be large enough to hold all of the uncompressed data for the
++ operation to complete. (The size of the uncompressed data may have been
++ saved by the compressor for this purpose.) The use of Z_FINISH is not
++ required to perform an inflation in one step. However it may be used to
++ inform inflate that a faster approach can be used for the single inflate()
++ call. Z_FINISH also informs inflate to not maintain a sliding window if the
++ stream completes, which reduces inflate's memory footprint. If the stream
++ does not complete, either because not all of the stream is provided or not
++ enough output space is provided, then a sliding window will be allocated and
++ inflate() can be called again to continue the operation as if Z_NO_FLUSH had
++ been used.
++
++ In this implementation, inflate() always flushes as much output as
++ possible to the output buffer, and always uses the faster approach on the
++ first call. So the effects of the flush parameter in this implementation are
++ on the return value of inflate() as noted below, when inflate() returns early
++ when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
++ memory for a sliding window when Z_FINISH is used.
++
++ If a preset dictionary is needed after this call (see inflateSetDictionary
++ below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
++ chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
++ strm->adler to the Adler-32 checksum of all output produced so far (that is,
++ total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
++ below. At the end of the stream, inflate() checks that its computed adler32
++ checksum is equal to that saved by the compressor and returns Z_STREAM_END
++ only if the checksum is correct.
++
++ inflate() can decompress and check either zlib-wrapped or gzip-wrapped
++ deflate data. The header type is detected automatically, if requested when
++ initializing with inflateInit2(). Any information contained in the gzip
++ header is not retained, so applications that need that information should
++ instead use raw inflate, see inflateInit2() below, or inflateBack() and
++ perform their own processing of the gzip header and trailer. When processing
++ gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
++ producted so far. The CRC-32 is checked against the gzip trailer.
++
++ inflate() returns Z_OK if some progress has been made (more input processed
++ or more output produced), Z_STREAM_END if the end of the compressed data has
++ been reached and all uncompressed output has been produced, Z_NEED_DICT if a
++ preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
++ corrupted (input stream not conforming to the zlib format or incorrect check
++ value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
++ next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
++ Z_BUF_ERROR if no progress is possible or if there was not enough room in the
++ output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
++ inflate() can be called again with more input and more output space to
++ continue decompressing. If Z_DATA_ERROR is returned, the application may
++ then call inflateSync() to look for a good compression block if a partial
++ recovery of the data is desired.
++*/
++
++
++ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
++/*
++ All dynamically allocated data structures for this stream are freed.
++ This function discards any unprocessed input and does not flush any pending
++ output.
++
++ inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
++ was inconsistent. In the error case, msg may be set but then points to a
++ static string (which must not be deallocated).
++*/
++
++
++ /* Advanced functions */
++
++/*
++ The following functions are needed only in some special applications.
++*/
++
++/*
++ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
++ int level,
++ int method,
++ int windowBits,
++ int memLevel,
++ int strategy));
++
++ This is another version of deflateInit with more compression options. The
++ fields next_in, zalloc, zfree and opaque must be initialized before by the
++ caller.
++
++ The method parameter is the compression method. It must be Z_DEFLATED in
++ this version of the library.
++
++ The windowBits parameter is the base two logarithm of the window size
++ (the size of the history buffer). It should be in the range 8..15 for this
++ version of the library. Larger values of this parameter result in better
++ compression at the expense of memory usage. The default value is 15 if
++ deflateInit is used instead.
++
++ windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
++ determines the window size. deflate() will then generate raw deflate data
++ with no zlib header or trailer, and will not compute an adler32 check value.
++
++ windowBits can also be greater than 15 for optional gzip encoding. Add
++ 16 to windowBits to write a simple gzip header and trailer around the
++ compressed data instead of a zlib wrapper. The gzip header will have no
++ file name, no extra data, no comment, no modification time (set to zero), no
++ header crc, and the operating system will be set to 255 (unknown). If a
++ gzip stream is being written, strm->adler is a crc32 instead of an adler32.
++
++ The memLevel parameter specifies how much memory should be allocated
++ for the internal compression state. memLevel=1 uses minimum memory but is
++ slow and reduces compression ratio; memLevel=9 uses maximum memory for
++ optimal speed. The default value is 8. See zconf.h for total memory usage
++ as a function of windowBits and memLevel.
++
++ The strategy parameter is used to tune the compression algorithm. Use the
++ value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
++ filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
++ string match), or Z_RLE to limit match distances to one (run-length
++ encoding). Filtered data consists mostly of small values with a somewhat
++ random distribution. In this case, the compression algorithm is tuned to
++ compress them better. The effect of Z_FILTERED is to force more Huffman
++ coding and less string matching; it is somewhat intermediate between
++ Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as
++ fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The
++ strategy parameter only affects the compression ratio but not the
++ correctness of the compressed output even if it is not set appropriately.
++ Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
++ decoder for special applications.
++
++ deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
++ memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
++ method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
++ incompatible with the version assumed by the caller (ZLIB_VERSION). msg is
++ set to null if there is no error message. deflateInit2 does not perform any
++ compression: this will be done by deflate().
++*/
++
++ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
++ const Bytef *dictionary,
++ uInt dictLength));
++/*
++ Initializes the compression dictionary from the given byte sequence
++ without producing any compressed output. When using the zlib format, this
++ function must be called immediately after deflateInit, deflateInit2 or
++ deflateReset, and before any call of deflate. When doing raw deflate, this
++ function must be called either before any call of deflate, or immediately
++ after the completion of a deflate block, i.e. after all input has been
++ consumed and all output has been delivered when using any of the flush
++ options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The
++ compressor and decompressor must use exactly the same dictionary (see
++ inflateSetDictionary).
++
++ The dictionary should consist of strings (byte sequences) that are likely
++ to be encountered later in the data to be compressed, with the most commonly
++ used strings preferably put towards the end of the dictionary. Using a
++ dictionary is most useful when the data to be compressed is short and can be
++ predicted with good accuracy; the data can then be compressed better than
++ with the default empty dictionary.
++
++ Depending on the size of the compression data structures selected by
++ deflateInit or deflateInit2, a part of the dictionary may in effect be
++ discarded, for example if the dictionary is larger than the window size
++ provided in deflateInit or deflateInit2. Thus the strings most likely to be
++ useful should be put at the end of the dictionary, not at the front. In
++ addition, the current implementation of deflate will use at most the window
++ size minus 262 bytes of the provided dictionary.
++
++ Upon return of this function, strm->adler is set to the adler32 value
++ of the dictionary; the decompressor may later use this value to determine
++ which dictionary has been used by the compressor. (The adler32 value
++ applies to the whole dictionary even if only a subset of the dictionary is
++ actually used by the compressor.) If a raw deflate was requested, then the
++ adler32 value is not computed and strm->adler is not set.
++
++ deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
++ parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
++ inconsistent (for example if deflate has already been called for this stream
++ or if not at a block boundary for raw deflate). deflateSetDictionary does
++ not perform any compression: this will be done by deflate().
++*/
++
++ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
++ z_streamp source));
++/*
++ Sets the destination stream as a complete copy of the source stream.
++
++ This function can be useful when several compression strategies will be
++ tried, for example when there are several ways of pre-processing the input
++ data with a filter. The streams that will be discarded should then be freed
++ by calling deflateEnd. Note that deflateCopy duplicates the internal
++ compression state which can be quite large, so this strategy is slow and can
++ consume lots of memory.
++
++ deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
++ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
++ (such as zalloc being Z_NULL). msg is left unchanged in both source and
++ destination.
++*/
++
++ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
++/*
++ This function is equivalent to deflateEnd followed by deflateInit,
++ but does not free and reallocate all the internal compression state. The
++ stream will keep the same compression level and any other attributes that
++ may have been set by deflateInit2.
++
++ deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent (such as zalloc or state being Z_NULL).
++*/
++
++ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
++ int level,
++ int strategy));
++/*
++ Dynamically update the compression level and compression strategy. The
++ interpretation of level and strategy is as in deflateInit2. This can be
++ used to switch between compression and straight copy of the input data, or
++ to switch to a different kind of input data requiring a different strategy.
++ If the compression level is changed, the input available so far is
++ compressed with the old level (and may be flushed); the new level will take
++ effect only at the next call of deflate().
++
++ Before the call of deflateParams, the stream state must be set as for
++ a call of deflate(), since the currently available input may have to be
++ compressed and flushed. In particular, strm->avail_out must be non-zero.
++
++ deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
++ stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
++ strm->avail_out was zero.
++*/
++
++ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
++ int good_length,
++ int max_lazy,
++ int nice_length,
++ int max_chain));
++/*
++ Fine tune deflate's internal compression parameters. This should only be
++ used by someone who understands the algorithm used by zlib's deflate for
++ searching for the best matching string, and even then only by the most
++ fanatic optimizer trying to squeeze out the last compressed bit for their
++ specific input data. Read the deflate.c source code for the meaning of the
++ max_lazy, good_length, nice_length, and max_chain parameters.
++
++ deflateTune() can be called after deflateInit() or deflateInit2(), and
++ returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
++ */
++
++ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
++ uLong sourceLen));
++/*
++ deflateBound() returns an upper bound on the compressed size after
++ deflation of sourceLen bytes. It must be called after deflateInit() or
++ deflateInit2(), and after deflateSetHeader(), if used. This would be used
++ to allocate an output buffer for deflation in a single pass, and so would be
++ called before deflate(). If that first deflate() call is provided the
++ sourceLen input bytes, an output buffer allocated to the size returned by
++ deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
++ to return Z_STREAM_END. Note that it is possible for the compressed size to
++ be larger than the value returned by deflateBound() if flush options other
++ than Z_FINISH or Z_NO_FLUSH are used.
++*/
++
++ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
++ unsigned *pending,
++ int *bits));
++/*
++ deflatePending() returns the number of bytes and bits of output that have
++ been generated, but not yet provided in the available output. The bytes not
++ provided would be due to the available output space having being consumed.
++ The number of bits of output not provided are between 0 and 7, where they
++ await more bits to join them in order to fill out a full byte. If pending
++ or bits are Z_NULL, then those values are not set.
++
++ deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent.
++ */
++
++ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
++ int bits,
++ int value));
++/*
++ deflatePrime() inserts bits in the deflate output stream. The intent
++ is that this function is used to start off the deflate output with the bits
++ leftover from a previous deflate stream when appending to it. As such, this
++ function can only be used for raw deflate, and must be used before the first
++ deflate() call after a deflateInit2() or deflateReset(). bits must be less
++ than or equal to 16, and that many of the least significant bits of value
++ will be inserted in the output.
++
++ deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
++ room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
++ source stream state was inconsistent.
++*/
++
++ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
++ gz_headerp head));
++/*
++ deflateSetHeader() provides gzip header information for when a gzip
++ stream is requested by deflateInit2(). deflateSetHeader() may be called
++ after deflateInit2() or deflateReset() and before the first call of
++ deflate(). The text, time, os, extra field, name, and comment information
++ in the provided gz_header structure are written to the gzip header (xflag is
++ ignored -- the extra flags are set according to the compression level). The
++ caller must assure that, if not Z_NULL, name and comment are terminated with
++ a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
++ available there. If hcrc is true, a gzip header crc is included. Note that
++ the current versions of the command-line version of gzip (up through version
++ 1.3.x) do not support header crc's, and will report that it is a "multi-part
++ gzip file" and give up.
++
++ If deflateSetHeader is not used, the default gzip header has text false,
++ the time set to zero, and os set to 255, with no extra, name, or comment
++ fields. The gzip header is returned to the default state by deflateReset().
++
++ deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent.
++*/
++
++/*
++ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
++ int windowBits));
++
++ This is another version of inflateInit with an extra parameter. The
++ fields next_in, avail_in, zalloc, zfree and opaque must be initialized
++ before by the caller.
++
++ The windowBits parameter is the base two logarithm of the maximum window
++ size (the size of the history buffer). It should be in the range 8..15 for
++ this version of the library. The default value is 15 if inflateInit is used
++ instead. windowBits must be greater than or equal to the windowBits value
++ provided to deflateInit2() while compressing, or it must be equal to 15 if
++ deflateInit2() was not used. If a compressed stream with a larger window
++ size is given as input, inflate() will return with the error code
++ Z_DATA_ERROR instead of trying to allocate a larger window.
++
++ windowBits can also be zero to request that inflate use the window size in
++ the zlib header of the compressed stream.
++
++ windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
++ determines the window size. inflate() will then process raw deflate data,
++ not looking for a zlib or gzip header, not generating a check value, and not
++ looking for any check values for comparison at the end of the stream. This
++ is for use with other formats that use the deflate compressed data format
++ such as zip. Those formats provide their own check values. If a custom
++ format is developed using the raw deflate format for compressed data, it is
++ recommended that a check value such as an adler32 or a crc32 be applied to
++ the uncompressed data as is done in the zlib, gzip, and zip formats. For
++ most applications, the zlib format should be used as is. Note that comments
++ above on the use in deflateInit2() applies to the magnitude of windowBits.
++
++ windowBits can also be greater than 15 for optional gzip decoding. Add
++ 32 to windowBits to enable zlib and gzip decoding with automatic header
++ detection, or add 16 to decode only the gzip format (the zlib format will
++ return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
++ crc32 instead of an adler32.
++
++ inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
++ memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
++ version assumed by the caller, or Z_STREAM_ERROR if the parameters are
++ invalid, such as a null pointer to the structure. msg is set to null if
++ there is no error message. inflateInit2 does not perform any decompression
++ apart from possibly reading the zlib header if present: actual decompression
++ will be done by inflate(). (So next_in and avail_in may be modified, but
++ next_out and avail_out are unused and unchanged.) The current implementation
++ of inflateInit2() does not process any header information -- that is
++ deferred until inflate() is called.
++*/
++
++ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
++ const Bytef *dictionary,
++ uInt dictLength));
++/*
++ Initializes the decompression dictionary from the given uncompressed byte
++ sequence. This function must be called immediately after a call of inflate,
++ if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
++ can be determined from the adler32 value returned by that call of inflate.
++ The compressor and decompressor must use exactly the same dictionary (see
++ deflateSetDictionary). For raw inflate, this function can be called at any
++ time to set the dictionary. If the provided dictionary is smaller than the
++ window and there is already data in the window, then the provided dictionary
++ will amend what's there. The application must insure that the dictionary
++ that was used for compression is provided.
++
++ inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
++ parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
++ inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
++ expected one (incorrect adler32 value). inflateSetDictionary does not
++ perform any decompression: this will be done by subsequent calls of
++ inflate().
++*/
++
++ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
++ Bytef *dictionary,
++ uInt *dictLength));
++/*
++ Returns the sliding dictionary being maintained by inflate. dictLength is
++ set to the number of bytes in the dictionary, and that many bytes are copied
++ to dictionary. dictionary must have enough space, where 32768 bytes is
++ always enough. If inflateGetDictionary() is called with dictionary equal to
++ Z_NULL, then only the dictionary length is returned, and nothing is copied.
++ Similary, if dictLength is Z_NULL, then it is not set.
++
++ inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
++ stream state is inconsistent.
++*/
++
++ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
++/*
++ Skips invalid compressed data until a possible full flush point (see above
++ for the description of deflate with Z_FULL_FLUSH) can be found, or until all
++ available input is skipped. No output is provided.
++
++ inflateSync searches for a 00 00 FF FF pattern in the compressed data.
++ All full flush points have this pattern, but not all occurrences of this
++ pattern are full flush points.
++
++ inflateSync returns Z_OK if a possible full flush point has been found,
++ Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
++ has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
++ In the success case, the application may save the current current value of
++ total_in which indicates where valid compressed data was found. In the
++ error case, the application may repeatedly call inflateSync, providing more
++ input each time, until success or end of the input data.
++*/
++
++ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
++ z_streamp source));
++/*
++ Sets the destination stream as a complete copy of the source stream.
++
++ This function can be useful when randomly accessing a large stream. The
++ first pass through the stream can periodically record the inflate state,
++ allowing restarting inflate at those points when randomly accessing the
++ stream.
++
++ inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
++ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
++ (such as zalloc being Z_NULL). msg is left unchanged in both source and
++ destination.
++*/
++
++ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
++/*
++ This function is equivalent to inflateEnd followed by inflateInit,
++ but does not free and reallocate all the internal decompression state. The
++ stream will keep attributes that may have been set by inflateInit2.
++
++ inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent (such as zalloc or state being Z_NULL).
++*/
++
++ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
++ int windowBits));
++/*
++ This function is the same as inflateReset, but it also permits changing
++ the wrap and window size requests. The windowBits parameter is interpreted
++ the same as it is for inflateInit2.
++
++ inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent (such as zalloc or state being Z_NULL), or if
++ the windowBits parameter is invalid.
++*/
++
++ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
++ int bits,
++ int value));
++/*
++ This function inserts bits in the inflate input stream. The intent is
++ that this function is used to start inflating at a bit position in the
++ middle of a byte. The provided bits will be used before any bytes are used
++ from next_in. This function should only be used with raw inflate, and
++ should be used before the first inflate() call after inflateInit2() or
++ inflateReset(). bits must be less than or equal to 16, and that many of the
++ least significant bits of value will be inserted in the input.
++
++ If bits is negative, then the input stream bit buffer is emptied. Then
++ inflatePrime() can be called again to put bits in the buffer. This is used
++ to clear out bits leftover after feeding inflate a block description prior
++ to feeding inflate codes.
++
++ inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent.
++*/
++
++ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
++/*
++ This function returns two values, one in the lower 16 bits of the return
++ value, and the other in the remaining upper bits, obtained by shifting the
++ return value down 16 bits. If the upper value is -1 and the lower value is
++ zero, then inflate() is currently decoding information outside of a block.
++ If the upper value is -1 and the lower value is non-zero, then inflate is in
++ the middle of a stored block, with the lower value equaling the number of
++ bytes from the input remaining to copy. If the upper value is not -1, then
++ it is the number of bits back from the current bit position in the input of
++ the code (literal or length/distance pair) currently being processed. In
++ that case the lower value is the number of bytes already emitted for that
++ code.
++
++ A code is being processed if inflate is waiting for more input to complete
++ decoding of the code, or if it has completed decoding but is waiting for
++ more output space to write the literal or match data.
++
++ inflateMark() is used to mark locations in the input data for random
++ access, which may be at bit positions, and to note those cases where the
++ output of a code may span boundaries of random access blocks. The current
++ location in the input stream can be determined from avail_in and data_type
++ as noted in the description for the Z_BLOCK flush parameter for inflate.
++
++ inflateMark returns the value noted above or -1 << 16 if the provided
++ source stream state was inconsistent.
++*/
++
++ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
++ gz_headerp head));
++/*
++ inflateGetHeader() requests that gzip header information be stored in the
++ provided gz_header structure. inflateGetHeader() may be called after
++ inflateInit2() or inflateReset(), and before the first call of inflate().
++ As inflate() processes the gzip stream, head->done is zero until the header
++ is completed, at which time head->done is set to one. If a zlib stream is
++ being decoded, then head->done is set to -1 to indicate that there will be
++ no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be
++ used to force inflate() to return immediately after header processing is
++ complete and before any actual data is decompressed.
++
++ The text, time, xflags, and os fields are filled in with the gzip header
++ contents. hcrc is set to true if there is a header CRC. (The header CRC
++ was valid if done is set to one.) If extra is not Z_NULL, then extra_max
++ contains the maximum number of bytes to write to extra. Once done is true,
++ extra_len contains the actual extra field length, and extra contains the
++ extra field, or that field truncated if extra_max is less than extra_len.
++ If name is not Z_NULL, then up to name_max characters are written there,
++ terminated with a zero unless the length is greater than name_max. If
++ comment is not Z_NULL, then up to comm_max characters are written there,
++ terminated with a zero unless the length is greater than comm_max. When any
++ of extra, name, or comment are not Z_NULL and the respective field is not
++ present in the header, then that field is set to Z_NULL to signal its
++ absence. This allows the use of deflateSetHeader() with the returned
++ structure to duplicate the header. However if those fields are set to
++ allocated memory, then the application will need to save those pointers
++ elsewhere so that they can be eventually freed.
++
++ If inflateGetHeader is not used, then the header information is simply
++ discarded. The header is always checked for validity, including the header
++ CRC if present. inflateReset() will reset the process to discard the header
++ information. The application would need to call inflateGetHeader() again to
++ retrieve the header from the next gzip stream.
++
++ inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
++ stream state was inconsistent.
++*/
++
++/*
++ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
++ unsigned char FAR *window));
++
++ Initialize the internal stream state for decompression using inflateBack()
++ calls. The fields zalloc, zfree and opaque in strm must be initialized
++ before the call. If zalloc and zfree are Z_NULL, then the default library-
++ derived memory allocation routines are used. windowBits is the base two
++ logarithm of the window size, in the range 8..15. window is a caller
++ supplied buffer of that size. Except for special applications where it is
++ assured that deflate was used with small window sizes, windowBits must be 15
++ and a 32K byte window must be supplied to be able to decompress general
++ deflate streams.
++
++ See inflateBack() for the usage of these routines.
++
++ inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
++ the parameters are invalid, Z_MEM_ERROR if the internal state could not be
++ allocated, or Z_VERSION_ERROR if the version of the library does not match
++ the version of the header file.
++*/
++
++typedef unsigned (*in_func) OF((void FAR *,
++ z_const unsigned char FAR * FAR *));
++typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
++
++ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
++ in_func in, void FAR *in_desc,
++ out_func out, void FAR *out_desc));
++/*
++ inflateBack() does a raw inflate with a single call using a call-back
++ interface for input and output. This is potentially more efficient than
++ inflate() for file i/o applications, in that it avoids copying between the
++ output and the sliding window by simply making the window itself the output
++ buffer. inflate() can be faster on modern CPUs when used with large
++ buffers. inflateBack() trusts the application to not change the output
++ buffer passed by the output function, at least until inflateBack() returns.
++
++ inflateBackInit() must be called first to allocate the internal state
++ and to initialize the state with the user-provided window buffer.
++ inflateBack() may then be used multiple times to inflate a complete, raw
++ deflate stream with each call. inflateBackEnd() is then called to free the
++ allocated state.
++
++ A raw deflate stream is one with no zlib or gzip header or trailer.
++ This routine would normally be used in a utility that reads zip or gzip
++ files and writes out uncompressed files. The utility would decode the
++ header and process the trailer on its own, hence this routine expects only
++ the raw deflate stream to decompress. This is different from the normal
++ behavior of inflate(), which expects either a zlib or gzip header and
++ trailer around the deflate stream.
++
++ inflateBack() uses two subroutines supplied by the caller that are then
++ called by inflateBack() for input and output. inflateBack() calls those
++ routines until it reads a complete deflate stream and writes out all of the
++ uncompressed data, or until it encounters an error. The function's
++ parameters and return types are defined above in the in_func and out_func
++ typedefs. inflateBack() will call in(in_desc, &buf) which should return the
++ number of bytes of provided input, and a pointer to that input in buf. If
++ there is no input available, in() must return zero--buf is ignored in that
++ case--and inflateBack() will return a buffer error. inflateBack() will call
++ out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
++ should return zero on success, or non-zero on failure. If out() returns
++ non-zero, inflateBack() will return with an error. Neither in() nor out()
++ are permitted to change the contents of the window provided to
++ inflateBackInit(), which is also the buffer that out() uses to write from.
++ The length written by out() will be at most the window size. Any non-zero
++ amount of input may be provided by in().
++
++ For convenience, inflateBack() can be provided input on the first call by
++ setting strm->next_in and strm->avail_in. If that input is exhausted, then
++ in() will be called. Therefore strm->next_in must be initialized before
++ calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called
++ immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in
++ must also be initialized, and then if strm->avail_in is not zero, input will
++ initially be taken from strm->next_in[0 .. strm->avail_in - 1].
++
++ The in_desc and out_desc parameters of inflateBack() is passed as the
++ first parameter of in() and out() respectively when they are called. These
++ descriptors can be optionally used to pass any information that the caller-
++ supplied in() and out() functions need to do their job.
++
++ On return, inflateBack() will set strm->next_in and strm->avail_in to
++ pass back any unused input that was provided by the last in() call. The
++ return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
++ if in() or out() returned an error, Z_DATA_ERROR if there was a format error
++ in the deflate stream (in which case strm->msg is set to indicate the nature
++ of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
++ In the case of Z_BUF_ERROR, an input or output error can be distinguished
++ using strm->next_in which will be Z_NULL only if in() returned an error. If
++ strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
++ non-zero. (in() will always be called before out(), so strm->next_in is
++ assured to be defined if out() returns non-zero.) Note that inflateBack()
++ cannot return Z_OK.
++*/
++
++ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
++/*
++ All memory allocated by inflateBackInit() is freed.
++
++ inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
++ state was inconsistent.
++*/
++
++ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
++/* Return flags indicating compile-time options.
++
++ Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
++ 1.0: size of uInt
++ 3.2: size of uLong
++ 5.4: size of voidpf (pointer)
++ 7.6: size of z_off_t
++
++ Compiler, assembler, and debug options:
++ 8: DEBUG
++ 9: ASMV or ASMINF -- use ASM code
++ 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
++ 11: 0 (reserved)
++
++ One-time table building (smaller code, but not thread-safe if true):
++ 12: BUILDFIXED -- build static block decoding tables when needed
++ 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
++ 14,15: 0 (reserved)
++
++ Library content (indicates missing functionality):
++ 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
++ deflate code when not needed)
++ 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
++ and decode gzip streams (to avoid linking crc code)
++ 18-19: 0 (reserved)
++
++ Operation variations (changes in library functionality):
++ 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
++ 21: FASTEST -- deflate algorithm with only one, lowest compression level
++ 22,23: 0 (reserved)
++
++ The sprintf variant used by gzprintf (zero is best):
++ 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
++ 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
++ 26: 0 = returns value, 1 = void -- 1 means inferred string length returned
++
++ Remainder:
++ 27-31: 0 (reserved)
++ */
++
++#ifndef Z_SOLO
++
++ /* utility functions */
++
++/*
++ The following utility functions are implemented on top of the basic
++ stream-oriented functions. To simplify the interface, some default options
++ are assumed (compression level and memory usage, standard memory allocation
++ functions). The source code of these utility functions can be modified if
++ you need special options.
++*/
++
++ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
++ const Bytef *source, uLong sourceLen));
++/*
++ Compresses the source buffer into the destination buffer. sourceLen is
++ the byte length of the source buffer. Upon entry, destLen is the total size
++ of the destination buffer, which must be at least the value returned by
++ compressBound(sourceLen). Upon exit, destLen is the actual size of the
++ compressed buffer.
++
++ compress returns Z_OK if success, Z_MEM_ERROR if there was not
++ enough memory, Z_BUF_ERROR if there was not enough room in the output
++ buffer.
++*/
++
++ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
++ const Bytef *source, uLong sourceLen,
++ int level));
++/*
++ Compresses the source buffer into the destination buffer. The level
++ parameter has the same meaning as in deflateInit. sourceLen is the byte
++ length of the source buffer. Upon entry, destLen is the total size of the
++ destination buffer, which must be at least the value returned by
++ compressBound(sourceLen). Upon exit, destLen is the actual size of the
++ compressed buffer.
++
++ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
++ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
++ Z_STREAM_ERROR if the level parameter is invalid.
++*/
++
++ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
++/*
++ compressBound() returns an upper bound on the compressed size after
++ compress() or compress2() on sourceLen bytes. It would be used before a
++ compress() or compress2() call to allocate the destination buffer.
++*/
++
++ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
++ const Bytef *source, uLong sourceLen));
++/*
++ Decompresses the source buffer into the destination buffer. sourceLen is
++ the byte length of the source buffer. Upon entry, destLen is the total size
++ of the destination buffer, which must be large enough to hold the entire
++ uncompressed data. (The size of the uncompressed data must have been saved
++ previously by the compressor and transmitted to the decompressor by some
++ mechanism outside the scope of this compression library.) Upon exit, destLen
++ is the actual size of the uncompressed buffer.
++
++ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
++ enough memory, Z_BUF_ERROR if there was not enough room in the output
++ buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In
++ the case where there is not enough room, uncompress() will fill the output
++ buffer with the uncompressed data up to that point.
++*/
++
++ /* gzip file access functions */
++
++/*
++ This library supports reading and writing files in gzip (.gz) format with
++ an interface similar to that of stdio, using the functions that start with
++ "gz". The gzip format is different from the zlib format. gzip is a gzip
++ wrapper, documented in RFC 1952, wrapped around a deflate stream.
++*/
++
++typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */
++
++/*
++ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
++
++ Opens a gzip (.gz) file for reading or writing. The mode parameter is as
++ in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
++ a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
++ compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
++ for fixed code compression as in "wb9F". (See the description of
++ deflateInit2 for more information about the strategy parameter.) 'T' will
++ request transparent writing or appending with no compression and not using
++ the gzip format.
++
++ "a" can be used instead of "w" to request that the gzip stream that will
++ be written be appended to the file. "+" will result in an error, since
++ reading and writing to the same gzip file is not supported. The addition of
++ "x" when writing will create the file exclusively, which fails if the file
++ already exists. On systems that support it, the addition of "e" when
++ reading or writing will set the flag to close the file on an execve() call.
++
++ These functions, as well as gzip, will read and decode a sequence of gzip
++ streams in a file. The append function of gzopen() can be used to create
++ such a file. (Also see gzflush() for another way to do this.) When
++ appending, gzopen does not test whether the file begins with a gzip stream,
++ nor does it look for the end of the gzip streams to begin appending. gzopen
++ will simply append a gzip stream to the existing file.
++
++ gzopen can be used to read a file which is not in gzip format; in this
++ case gzread will directly read from the file without decompression. When
++ reading, this will be detected automatically by looking for the magic two-
++ byte gzip header.
++
++ gzopen returns NULL if the file could not be opened, if there was
++ insufficient memory to allocate the gzFile state, or if an invalid mode was
++ specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
++ errno can be checked to determine if the reason gzopen failed was that the
++ file could not be opened.
++*/
++
++ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
++/*
++ gzdopen associates a gzFile with the file descriptor fd. File descriptors
++ are obtained from calls like open, dup, creat, pipe or fileno (if the file
++ has been previously opened with fopen). The mode parameter is as in gzopen.
++
++ The next call of gzclose on the returned gzFile will also close the file
++ descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
++ fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
++ mode);. The duplicated descriptor should be saved to avoid a leak, since
++ gzdopen does not close fd if it fails. If you are using fileno() to get the
++ file descriptor from a FILE *, then you will have to use dup() to avoid
++ double-close()ing the file descriptor. Both gzclose() and fclose() will
++ close the associated file descriptor, so they need to have different file
++ descriptors.
++
++ gzdopen returns NULL if there was insufficient memory to allocate the
++ gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
++ provided, or '+' was provided), or if fd is -1. The file descriptor is not
++ used until the next gz* read, write, seek, or close operation, so gzdopen
++ will not detect if fd is invalid (unless fd is -1).
++*/
++
++ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
++/*
++ Set the internal buffer size used by this library's functions. The
++ default buffer size is 8192 bytes. This function must be called after
++ gzopen() or gzdopen(), and before any other calls that read or write the
++ file. The buffer memory allocation is always deferred to the first read or
++ write. Two buffers are allocated, either both of the specified size when
++ writing, or one of the specified size and the other twice that size when
++ reading. A larger buffer size of, for example, 64K or 128K bytes will
++ noticeably increase the speed of decompression (reading).
++
++ The new buffer size also affects the maximum length for gzprintf().
++
++ gzbuffer() returns 0 on success, or -1 on failure, such as being called
++ too late.
++*/
++
++ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
++/*
++ Dynamically update the compression level or strategy. See the description
++ of deflateInit2 for the meaning of these parameters.
++
++ gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
++ opened for writing.
++*/
++
++ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
++/*
++ Reads the given number of uncompressed bytes from the compressed file. If
++ the input file is not in gzip format, gzread copies the given number of
++ bytes into the buffer directly from the file.
++
++ After reaching the end of a gzip stream in the input, gzread will continue
++ to read, looking for another gzip stream. Any number of gzip streams may be
++ concatenated in the input file, and will all be decompressed by gzread().
++ If something other than a gzip stream is encountered after a gzip stream,
++ that remaining trailing garbage is ignored (and no error is returned).
++
++ gzread can be used to read a gzip file that is being concurrently written.
++ Upon reaching the end of the input, gzread will return with the available
++ data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
++ gzclearerr can be used to clear the end of file indicator in order to permit
++ gzread to be tried again. Z_OK indicates that a gzip stream was completed
++ on the last gzread. Z_BUF_ERROR indicates that the input file ended in the
++ middle of a gzip stream. Note that gzread does not return -1 in the event
++ of an incomplete gzip stream. This error is deferred until gzclose(), which
++ will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
++ stream. Alternatively, gzerror can be used before gzclose to detect this
++ case.
++
++ gzread returns the number of uncompressed bytes actually read, less than
++ len for end of file, or -1 for error.
++*/
++
++ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
++ voidpc buf, unsigned len));
++/*
++ Writes the given number of uncompressed bytes into the compressed file.
++ gzwrite returns the number of uncompressed bytes written or 0 in case of
++ error.
++*/
++
++ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
++/*
++ Converts, formats, and writes the arguments to the compressed file under
++ control of the format string, as in fprintf. gzprintf returns the number of
++ uncompressed bytes actually written, or 0 in case of error. The number of
++ uncompressed bytes written is limited to 8191, or one less than the buffer
++ size given to gzbuffer(). The caller should assure that this limit is not
++ exceeded. If it is exceeded, then gzprintf() will return an error (0) with
++ nothing written. In this case, there may also be a buffer overflow with
++ unpredictable consequences, which is possible only if zlib was compiled with
++ the insecure functions sprintf() or vsprintf() because the secure snprintf()
++ or vsnprintf() functions were not available. This can be determined using
++ zlibCompileFlags().
++*/
++
++ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
++/*
++ Writes the given null-terminated string to the compressed file, excluding
++ the terminating null character.
++
++ gzputs returns the number of characters written, or -1 in case of error.
++*/
++
++ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
++/*
++ Reads bytes from the compressed file until len-1 characters are read, or a
++ newline character is read and transferred to buf, or an end-of-file
++ condition is encountered. If any characters are read or if len == 1, the
++ string is terminated with a null character. If no characters are read due
++ to an end-of-file or len < 1, then the buffer is left untouched.
++
++ gzgets returns buf which is a null-terminated string, or it returns NULL
++ for end-of-file or in case of error. If there was an error, the contents at
++ buf are indeterminate.
++*/
++
++ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
++/*
++ Writes c, converted to an unsigned char, into the compressed file. gzputc
++ returns the value that was written, or -1 in case of error.
++*/
++
++ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
++/*
++ Reads one byte from the compressed file. gzgetc returns this byte or -1
++ in case of end of file or error. This is implemented as a macro for speed.
++ As such, it does not do all of the checking the other functions do. I.e.
++ it does not check to see if file is NULL, nor whether the structure file
++ points to has been clobbered or not.
++*/
++
++ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
++/*
++ Push one character back onto the stream to be read as the first character
++ on the next read. At least one character of push-back is allowed.
++ gzungetc() returns the character pushed, or -1 on failure. gzungetc() will
++ fail if c is -1, and may fail if a character has been pushed but not read
++ yet. If gzungetc is used immediately after gzopen or gzdopen, at least the
++ output buffer size of pushed characters is allowed. (See gzbuffer above.)
++ The pushed character will be discarded if the stream is repositioned with
++ gzseek() or gzrewind().
++*/
++
++ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
++/*
++ Flushes all pending output into the compressed file. The parameter flush
++ is as in the deflate() function. The return value is the zlib error number
++ (see function gzerror below). gzflush is only permitted when writing.
++
++ If the flush parameter is Z_FINISH, the remaining data is written and the
++ gzip stream is completed in the output. If gzwrite() is called again, a new
++ gzip stream will be started in the output. gzread() is able to read such
++ concatented gzip streams.
++
++ gzflush should be called only when strictly necessary because it will
++ degrade compression if called too often.
++*/
++
++/*
++ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
++ z_off_t offset, int whence));
++
++ Sets the starting position for the next gzread or gzwrite on the given
++ compressed file. The offset represents a number of bytes in the
++ uncompressed data stream. The whence parameter is defined as in lseek(2);
++ the value SEEK_END is not supported.
++
++ If the file is opened for reading, this function is emulated but can be
++ extremely slow. If the file is opened for writing, only forward seeks are
++ supported; gzseek then compresses a sequence of zeroes up to the new
++ starting position.
++
++ gzseek returns the resulting offset location as measured in bytes from
++ the beginning of the uncompressed stream, or -1 in case of error, in
++ particular if the file is opened for writing and the new starting position
++ would be before the current position.
++*/
++
++ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
++/*
++ Rewinds the given file. This function is supported only for reading.
++
++ gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
++*/
++
++/*
++ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
++
++ Returns the starting position for the next gzread or gzwrite on the given
++ compressed file. This position represents a number of bytes in the
++ uncompressed data stream, and is zero when starting, even if appending or
++ reading a gzip stream from the middle of a file using gzdopen().
++
++ gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
++*/
++
++/*
++ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
++
++ Returns the current offset in the file being read or written. This offset
++ includes the count of bytes that precede the gzip stream, for example when
++ appending or when using gzdopen() for reading. When reading, the offset
++ does not include as yet unused buffered input. This information can be used
++ for a progress indicator. On error, gzoffset() returns -1.
++*/
++
++ZEXTERN int ZEXPORT gzeof OF((gzFile file));
++/*
++ Returns true (1) if the end-of-file indicator has been set while reading,
++ false (0) otherwise. Note that the end-of-file indicator is set only if the
++ read tried to go past the end of the input, but came up short. Therefore,
++ just like feof(), gzeof() may return false even if there is no more data to
++ read, in the event that the last read request was for the exact number of
++ bytes remaining in the input file. This will happen if the input file size
++ is an exact multiple of the buffer size.
++
++ If gzeof() returns true, then the read functions will return no more data,
++ unless the end-of-file indicator is reset by gzclearerr() and the input file
++ has grown since the previous end of file was detected.
++*/
++
++ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
++/*
++ Returns true (1) if file is being copied directly while reading, or false
++ (0) if file is a gzip stream being decompressed.
++
++ If the input file is empty, gzdirect() will return true, since the input
++ does not contain a gzip stream.
++
++ If gzdirect() is used immediately after gzopen() or gzdopen() it will
++ cause buffers to be allocated to allow reading the file to determine if it
++ is a gzip file. Therefore if gzbuffer() is used, it should be called before
++ gzdirect().
++
++ When writing, gzdirect() returns true (1) if transparent writing was
++ requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note:
++ gzdirect() is not needed when writing. Transparent writing must be
++ explicitly requested, so the application already knows the answer. When
++ linking statically, using gzdirect() will include all of the zlib code for
++ gzip file reading and decompression, which may not be desired.)
++*/
++
++ZEXTERN int ZEXPORT gzclose OF((gzFile file));
++/*
++ Flushes all pending output if necessary, closes the compressed file and
++ deallocates the (de)compression state. Note that once file is closed, you
++ cannot call gzerror with file, since its structures have been deallocated.
++ gzclose must not be called more than once on the same file, just as free
++ must not be called more than once on the same allocation.
++
++ gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
++ file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
++ last read ended in the middle of a gzip stream, or Z_OK on success.
++*/
++
++ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
++ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
++/*
++ Same as gzclose(), but gzclose_r() is only for use when reading, and
++ gzclose_w() is only for use when writing or appending. The advantage to
++ using these instead of gzclose() is that they avoid linking in zlib
++ compression or decompression code that is not used when only reading or only
++ writing respectively. If gzclose() is used, then both compression and
++ decompression code will be included the application when linking to a static
++ zlib library.
++*/
++
++ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
++/*
++ Returns the error message for the last error which occurred on the given
++ compressed file. errnum is set to zlib error number. If an error occurred
++ in the file system and not in the compression library, errnum is set to
++ Z_ERRNO and the application may consult errno to get the exact error code.
++
++ The application must not modify the returned string. Future calls to
++ this function may invalidate the previously returned string. If file is
++ closed, then the string previously returned by gzerror will no longer be
++ available.
++
++ gzerror() should be used to distinguish errors from end-of-file for those
++ functions above that do not distinguish those cases in their return values.
++*/
++
++ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
++/*
++ Clears the error and end-of-file flags for file. This is analogous to the
++ clearerr() function in stdio. This is useful for continuing to read a gzip
++ file that is being written concurrently.
++*/
++
++#endif /* !Z_SOLO */
++
++ /* checksum functions */
++
++/*
++ These functions are not related to compression but are exported
++ anyway because they might be useful in applications using the compression
++ library.
++*/
++
++ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
++/*
++ Update a running Adler-32 checksum with the bytes buf[0..len-1] and
++ return the updated checksum. If buf is Z_NULL, this function returns the
++ required initial value for the checksum.
++
++ An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
++ much faster.
++
++ Usage example:
++
++ uLong adler = adler32(0L, Z_NULL, 0);
++
++ while (read_buffer(buffer, length) != EOF) {
++ adler = adler32(adler, buffer, length);
++ }
++ if (adler != original_adler) error();
++*/
++
++/*
++ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
++ z_off_t len2));
++
++ Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
++ and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
++ each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
++ seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note
++ that the z_off_t type (like off_t) is a signed integer. If len2 is
++ negative, the result has no meaning or utility.
++*/
++
++ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
++/*
++ Update a running CRC-32 with the bytes buf[0..len-1] and return the
++ updated CRC-32. If buf is Z_NULL, this function returns the required
++ initial value for the crc. Pre- and post-conditioning (one's complement) is
++ performed within this function so it shouldn't be done by the application.
++
++ Usage example:
++
++ uLong crc = crc32(0L, Z_NULL, 0);
++
++ while (read_buffer(buffer, length) != EOF) {
++ crc = crc32(crc, buffer, length);
++ }
++ if (crc != original_crc) error();
++*/
++
++/*
++ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
++
++ Combine two CRC-32 check values into one. For two sequences of bytes,
++ seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
++ calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32
++ check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
++ len2.
++*/
++
++
++ /* various hacks, don't look :) */
++
++/* deflateInit and inflateInit are macros to allow checking the zlib version
++ * and the compiler's view of z_stream:
++ */
++ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
++ const char *version, int stream_size));
++ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
++ const char *version, int stream_size));
++ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
++ int windowBits, int memLevel,
++ int strategy, const char *version,
++ int stream_size));
++ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
++ const char *version, int stream_size));
++ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
++ unsigned char FAR *window,
++ const char *version,
++ int stream_size));
++#define deflateInit(strm, level) \
++ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
++#define inflateInit(strm) \
++ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
++#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
++ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
++ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
++#define inflateInit2(strm, windowBits) \
++ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
++ (int)sizeof(z_stream))
++#define inflateBackInit(strm, windowBits, window) \
++ inflateBackInit_((strm), (windowBits), (window), \
++ ZLIB_VERSION, (int)sizeof(z_stream))
++
++#ifndef Z_SOLO
++
++/* gzgetc() macro and its supporting function and exposed data structure. Note
++ * that the real internal state is much larger than the exposed structure.
++ * This abbreviated structure exposes just enough for the gzgetc() macro. The
++ * user should not mess with these exposed elements, since their names or
++ * behavior could change in the future, perhaps even capriciously. They can
++ * only be used by the gzgetc() macro. You have been warned.
++ */
++struct gzFile_s {
++ unsigned have;
++ unsigned char *next;
++ z_off64_t pos;
++};
++ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
++#ifdef Z_PREFIX_SET
++# undef z_gzgetc
++# define z_gzgetc(g) \
++ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
++#else
++# define gzgetc(g) \
++ ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
++#endif
++
++/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
++ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
++ * both are true, the application gets the *64 functions, and the regular
++ * functions are changed to 64 bits) -- in case these are set on systems
++ * without large file support, _LFS64_LARGEFILE must also be true
++ */
++#ifdef Z_LARGE64
++ ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
++ ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
++ ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
++ ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
++ ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
++ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
++#endif
++
++#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
++# ifdef Z_PREFIX_SET
++# define z_gzopen z_gzopen64
++# define z_gzseek z_gzseek64
++# define z_gztell z_gztell64
++# define z_gzoffset z_gzoffset64
++# define z_adler32_combine z_adler32_combine64
++# define z_crc32_combine z_crc32_combine64
++# else
++# define gzopen gzopen64
++# define gzseek gzseek64
++# define gztell gztell64
++# define gzoffset gzoffset64
++# define adler32_combine adler32_combine64
++# define crc32_combine crc32_combine64
++# endif
++# ifndef Z_LARGE64
++ ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
++ ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
++ ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
++ ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
++ ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
++ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
++# endif
++#else
++ ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
++ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
++ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
++ ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
++ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
++ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
++#endif
++
++#else /* Z_SOLO */
++
++ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
++ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
++
++#endif /* !Z_SOLO */
++
++/* hack for buggy compilers */
++#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
++ struct internal_state {int dummy;};
++#endif
++
++/* undocumented functions */
++ZEXTERN const char * ZEXPORT zError OF((int));
++ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
++ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
++ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
++ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
++ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
++#if defined(_WIN32) && !defined(Z_SOLO)
++ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
++ const char *mode));
++#endif
++#if defined(STDC) || defined(Z_HAVE_STDARG_H)
++# ifndef Z_SOLO
++ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file,
++ const char *format,
++ va_list va));
++# endif
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* ZLIB_H */
+diff --git a/converter/COLLADA2GLTF/main.cpp b/converter/COLLADA2GLTF/main.cpp
+index 3906760..651ea0c 100644
+--- a/converter/COLLADA2GLTF/main.cpp
++++ b/converter/COLLADA2GLTF/main.cpp
+@@ -39,6 +39,7 @@
+
+ #include "COLLADA2GLTFWriter.h"
+ #include "JSONObject.h"
++#include "KMZ2Collada.h"
+
+ using namespace rapidjson;
+ #if __cplusplus <= 199711L
+@@ -130,6 +131,7 @@ static bool processArgs(int argc, char * const * argv, GLTF::GLTFAsset *asset) {
+ int ch;
+ std::string file;
+ std::string output;
++ std::string strFileName;
+ bool hasOutputPath = false;
+ bool hasInputPath = false;
+ bool shouldShowHelp = false;
+@@ -160,6 +162,12 @@ static bool processArgs(int argc, char * const * argv, GLTF::GLTFAsset *asset) {
+ return false;
+ case 'f':
+ asset->setInputFilePath(optarg);
++ strFileName = optarg;
++ strFileName = strFileName.substr(strFileName.length()-3, 3);
++ transform(strFileName.begin(), strFileName.end(),
++ strFileName.begin(), tolower);
++ if (strcmp(strFileName.c_str(), "kmz") == 0)
++ converterConfig->config()->setBool("isKmz", true);
+ hasInputPath = true;
+ break;
+ case 'b':
+@@ -269,6 +277,17 @@ int main (int argc, char * const argv[]) {
+ } else {
+ asset->log("converting:%s ... as %s \n",asset->getInputFilePath().c_str(), asset->getOutputFilePath().c_str());
+ }
++
++ if (asset->converterConfig()->config()->getBool("isKmz")) {
++ std::string strJsonFilePath;
++ strJsonFilePath = GLTF::Kmz2Collada()(asset->getInputFilePath());
++ if (strJsonFilePath == "")
++ return -1;
++ asset->setInputFilePath(strJsonFilePath);
++ asset->setOutputFilePath(
++ replacePathExtensionWith(strJsonFilePath, "json"));
++ }
++
+ GLTF::COLLADA2GLTFWriter* writer = new GLTF::COLLADA2GLTFWriter(asset);
+ writer->write();
+ if (asset->converterConfig()->config()->getBool("outputProgress")) {
+--
+1.8.1.4
+
diff --git a/external/collada2gltf/write-only-.dae-file-which-we-need.patch.0 b/external/collada2gltf/write-only-.dae-file-which-we-need.patch.0
new file mode 100644
index 000000000000..68980e2bb15f
--- /dev/null
+++ b/external/collada2gltf/write-only-.dae-file-which-we-need.patch.0
@@ -0,0 +1,128 @@
+diff --git KMZ2Collada.cpp KMZ2Collada.cpp
+index d193784..3b5bdfc 100644
+--- KMZ2Collada.cpp
++++ KMZ2Collada.cpp
+@@ -2,7 +2,7 @@
+ #include "kmz/unzip.h"
+ #include "kmz/ioapi.h"
+
+-#include <direct.h>
++#include <string.h>
+
+ using namespace std;
+
+@@ -14,39 +14,19 @@ namespace GLTF{
+
+ }
+
+- void Kmz2Collada::setFileFolder(std::string& strSrc) {
+- std::string strFolderPath = "";
+- char *pFolderName = new char[strSrc.size()];
+-
+- for (unsigned int i = 0; i < strSrc.size(); i++) {
+- if (strSrc[i] == '\\' || strSrc[i] == '/') {
+- pFolderName[i] = '\0';
+- strFolderPath = strKmzPath + pFolderName;
+- _mkdir(strFolderPath.c_str());
+- }
+- pFolderName[i] = strSrc[i];
+- }
+- strSrc = strKmzPath +strSrc;
+-
+- delete[] pFolderName;
+- }
+- void Kmz2Collada::getFilePath(std::string& strSrc) {
++ void Kmz2Collada::getFilePath(const std::string& strSrc) {
+ char *pTemporaryContent = new char[strSrc.size()+1];
+ std::string strFilePath;
+
+ for (unsigned int ipos = 0; ipos < strSrc.size(); ipos ++) {
++ pTemporaryContent[ipos] = strSrc[ipos];
+ if (strSrc[ipos] == '\\' || strSrc[ipos] == '/') {
+- pTemporaryContent[ipos] = '\0';
++ pTemporaryContent[ipos+1] = '\0';
+ strFilePath = pTemporaryContent;
+- _mkdir(strFilePath.c_str());
+ }
+- pTemporaryContent[ipos] = strSrc[ipos];
+ }
+
+- if (strFilePath != "")
+- strFilePath += '\\';
+- strSrc = strFilePath;
+- strKmzPath = strSrc;
++ strKmzPath = strFilePath;
+
+ delete[] pTemporaryContent;
+ }
+@@ -72,18 +52,24 @@ namespace GLTF{
+ return "";
+ }
+
+- for (int i = 0; i < zGlobalInfo.number_entry; i++) {
++ for (int i = 0; i < zGlobalInfo.number_entry; i++, unzGoToNextFile(zFile)) {
+ if (UNZ_OK != unzGetCurrentFileInfo64(zFile, &zFileInfo,
+ pFileName, num, NULL, 0, NULL, 0)) {
+ printf("Read file error\n");
+ return "";
+ }
+- std::string strFilePath = pFileName;
+- setFileFolder(strFilePath);
+- if (strstr(strFilePath.c_str(), ".dae"))
+- strDaePath = strFilePath;
++ if (!strstr(pFileName, ".dae"))
++ continue;
+
+- FILE *fp = fopen(strFilePath.c_str(),"wb");
++ unsigned int pos = strlen(pFileName) - 1;
++ while (pos >= 0) {
++ if (pFileName[pos] == '\\' || pFileName[pos] == '/')
++ break;
++ pos--;
++ }
++ strDaePath = strKmzPath + std::string(&pFileName[pos + 1]);
++
++ FILE *fp = fopen(strDaePath.c_str(),"wb");
+
+ if (UNZ_OK != unzOpenCurrentFile(zFile)) {
+ printf("Open current file error");
+@@ -107,8 +93,6 @@ namespace GLTF{
+ fclose(fp);
+ delete[] pFileData;
+ pFileData = NULL;
+-
+- unzGoToNextFile(zFile);
+ }
+ unzCloseCurrentFile(zFile);
+
+@@ -118,4 +102,4 @@ namespace GLTF{
+ return strDaePath;
+ }
+
+-}
+\ No newline at end of file
++}
+diff --git KMZ2Collada.h KMZ2Collada.h
+index 5e8bdef..df7e92f 100644
+--- KMZ2Collada.h
++++ KMZ2Collada.h
+@@ -10,11 +10,8 @@ namespace GLTF{
+ Kmz2Collada();
+ ~Kmz2Collada();
+
+- /** get the kmz file path and set folder.*/
+- void setFileFolder(std::string& strSrc);
+-
+ /** get kmz file path.*/
+- void getFilePath(std::string& strSrc);
++ void getFilePath(const std::string& strSrc);
+
+ /** copy function.*/
+ std::string operator()(std::string strInputFile);
+@@ -25,4 +22,4 @@ namespace GLTF{
+ };
+
+ }
+-#endif
+\ No newline at end of file
++#endif