No OneTemporary
Actions

Size

195 KB

Subscribers

None

View Options

	diff --git a/project.diff b/project.diff
	--- a/project.diff
	+++ b/project.diff
	@@ -1,60 +1,60 @@
	---- a/quazip/quazip.pri 2019-09-12 12:50:50.932633078 +0300
	-+++ b/quazip/quazip.pri 2019-09-12 13:47:01.683852447 +0300
	-@@ -1,15 +1,8 @@
	- INCLUDEPATH += $$PWD
	- DEPENDPATH += $$PWD
	+diff -u a/quazip/quazip.pri b/quazip/quazip.pri
	+--- a/quazip/quazip.pri 2023-05-31 17:48:37.368339456 +0300
	++++ b/quazip/quazip.pri 2021-11-26 15:47:56.789035840 +0300
	+@@ -3,13 +3,7 @@
	HEADERS += \
	-- $$PWD/minizip_crypt.h \
	+ $$PWD/minizip_crypt.h \
	$$PWD/ioapi.h \
	- $$PWD/JlCompress.h \
	- $$PWD/quaadler32.h \
	- $$PWD/quachecksum32.h \
	- $$PWD/quacrc32.h \
	- $$PWD/quagzipfile.h \
	$$PWD/quaziodevice.h \
	- $$PWD/quazipdir.h \
	$$PWD/quazipfile.h \
	$$PWD/quazipfileinfo.h \
	$$PWD/quazip_global.h \
	-@@ -19,13 +12,8 @@
	+@@ -19,13 +13,8 @@
	$$PWD/zip.h

	SOURCES += $$PWD/qioapi.cpp \
	- $$PWD/JlCompress.cpp \
	- $$PWD/quaadler32.cpp \
	- $$PWD/quacrc32.cpp \
	- $$PWD/quagzipfile.cpp \
	$$PWD/quaziodevice.cpp \
	$$PWD/quazip.cpp \
	- $$PWD/quazipdir.cpp \
	$$PWD/quazipfile.cpp \
	$$PWD/quazipfileinfo.cpp \
	$$PWD/quazipnewinfo.cpp \
	---- a/qztest/qztest.pro 2019-09-12 12:50:50.956633046 +0300
	-+++ b/qztest/qztest.pro 2019-09-12 13:48:07.143753675 +0300
	+diff -u a/qztest/qztest.pro b/qztest/qztest.pro
	+--- a/qztest/qztest.pro 2023-05-31 17:48:37.376339390 +0300
	++++ b/qztest/qztest.pro 2019-09-12 15:40:14.057107000 +0300
	@@ -16,23 +16,19 @@

	# Input
	HEADERS += qztest.h \
	+JlCompress.h \
	testjlcompress.h \
	-testquachecksum32.h \
	-testquagzipfile.h \
	testquaziodevice.h \
	-testquazipdir.h \
	testquazipfile.h \
	testquazip.h \
	testquazipnewinfo.h \
	testquazipfileinfo.h

	SOURCES += qztest.cpp \
	+JlCompress.cpp \
	testjlcompress.cpp \
	-testquachecksum32.cpp \
	-testquagzipfile.cpp \
	testquaziodevice.cpp \
	testquazip.cpp \
	-testquazipdir.cpp \
	testquazipfile.cpp \
	testquazipnewinfo.cpp \
	testquazipfileinfo.cpp
	diff --git a/quazip/minizip_crypt.h b/quazip/minizip_crypt.h
	new file mode 100644
	--- /dev/null
	+++ b/quazip/minizip_crypt.h
	@@ -0,0 +1,135 @@
	+/* crypt.h -- base code for crypt/uncrypt ZIPfile
	+
	+
	+ Version 1.01e, February 12th, 2005
	+
	+ Copyright (C) 1998-2005 Gilles Vollant
	+
	+ This code is a modified version of crypting code in Infozip distribution
	+
	+ 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).
	+
	+ If you don't need crypting in your application, just define symbols
	+ NOCRYPT and NOUNCRYPT.
	+
	+ This code support the "Traditional PKWARE Encryption".
	+
	+ The new AES encryption added on Zip format by Winzip (see the page
	+ http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
	+ Encryption is not supported.
	+*/
	+
	+#include "quazip_global.h"
	+
	+#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
	+
	+/***********************************************************************
	+ * Return the next byte in the pseudo-random sequence
	+ */
	+static int decrypt_byte(unsigned long* pkeys, const z_crc_t FAR * pcrc_32_tab QUAZIP_UNUSED)
	+{
	+ //(void) pcrc_32_tab; /* avoid "unused parameter" warning */
	+ unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
	+ * unpredictable manner on 16-bit systems; not a problem
	+ * with any known compiler so far, though */
	+
	+ temp = ((unsigned)(*(pkeys+2)) & 0xffff) \| 2;
	+ return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
	+}
	+
	+/***********************************************************************
	+ * Update the encryption keys with the next byte of plain text
	+ */
	+static int update_keys(unsigned long* pkeys,const z_crc_t FAR * pcrc_32_tab,int c)
	+{
	+ ((pkeys+0)) = CRC32(((pkeys+0)), c);
	+ ((pkeys+1)) += ((pkeys+0)) & 0xff;
	+ ((pkeys+1)) = ((pkeys+1)) * 134775813L + 1;
	+ {
	+ register int keyshift = (int)((*(pkeys+1)) >> 24);
	+ ((pkeys+2)) = CRC32(((pkeys+2)), keyshift);
	+ }
	+ return c;
	+}
	+
	+
	+/***********************************************************************
	+ * Initialize the encryption keys and the random header according to
	+ * the given password.
	+ */
	+static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t FAR * pcrc_32_tab)
	+{
	+ *(pkeys+0) = 305419896L;
	+ *(pkeys+1) = 591751049L;
	+ *(pkeys+2) = 878082192L;
	+ while (*passwd != '\0') {
	+ update_keys(pkeys,pcrc_32_tab,(int)*passwd);
	+ passwd++;
	+ }
	+}
	+
	+#define zdecode(pkeys,pcrc_32_tab,c) \
	+ (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
	+
	+#define zencode(pkeys,pcrc_32_tab,c,t) \
	+ (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
	+
	+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
	+
	+#define RAND_HEAD_LEN 12
	+ /* "last resort" source for second part of crypt seed pattern */
	+# ifndef ZCR_SEED2
	+# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
	+# endif
	+
	+static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
	+ const char passwd; / password string */
	+ unsigned char buf; / where to write header */
	+ int bufSize;
	+ unsigned long* pkeys;
	+ const z_crc_t FAR * pcrc_32_tab;
	+ unsigned long crcForCrypting;
	+{
	+ int n; /* index in random header */
	+ int t; /* temporary */
	+ int c; /* random byte */
	+ unsigned char header[RAND_HEAD_LEN-2]; /* random header */
	+ static unsigned calls = 0; /* ensure different random header each time */
	+
	+ if (bufSize<RAND_HEAD_LEN)
	+ return 0;
	+
	+ /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
	+ * output of rand() to get less predictability, since rand() is
	+ * often poorly implemented.
	+ */
	+ if (++calls == 1)
	+ {
	+ srand((unsigned)(time(NULL) ^ ZCR_SEED2));
	+ }
	+ init_keys(passwd, pkeys, pcrc_32_tab);
	+ for (n = 0; n < RAND_HEAD_LEN-2; n++)
	+ {
	+ c = (rand() >> 7) & 0xff;
	+ header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
	+ }
	+ /* Encrypt random header (last two bytes is high word of crc) */
	+ init_keys(passwd, pkeys, pcrc_32_tab);
	+ for (n = 0; n < RAND_HEAD_LEN-2; n++)
	+ {
	+ buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
	+ }
	+ buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
	+ buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
	+ return n;
	+}
	+
	+#endif
	diff --git a/quazip/quazip.pri b/quazip/quazip.pri
	--- a/quazip/quazip.pri
	+++ b/quazip/quazip.pri
	@@ -1,21 +1,22 @@
	INCLUDEPATH += $$PWD
	DEPENDPATH += $$PWD
	HEADERS += \
	+ $$PWD/minizip_crypt.h \
	$$PWD/ioapi.h \
	$$PWD/quaziodevice.h \
	$$PWD/quazipfile.h \
	$$PWD/quazipfileinfo.h \
	$$PWD/quazip_global.h \
	$$PWD/quazip.h \
	$$PWD/quazipnewinfo.h \
	$$PWD/unzip.h \
	$$PWD/zip.h

	SOURCES += $$PWD/qioapi.cpp \
	$$PWD/quaziodevice.cpp \
	$$PWD/quazip.cpp \
	$$PWD/quazipfile.cpp \
	$$PWD/quazipfileinfo.cpp \
	$$PWD/quazipnewinfo.cpp \
	$$PWD/unzip.c \
	$$PWD/zip.c
	diff --git a/quazip/unzip.c b/quazip/unzip.c
	--- a/quazip/unzip.c
	+++ b/quazip/unzip.c
	@@ -1,2020 +1,2067 @@
	/* 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 )

	Modifications for QIODevice support and other QuaZIP fixes
	Copyright (C) 2005-2014 Sergey A. Tachenov

	For more info read MiniZip_info.txt

	Modifications for static code analysis report
	Copyright (C) 2016 Intel Deutschland GmbH

	------------------------------------------------------------------------------------
	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 minizip_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>

	#include "zlib.h"
	#if (ZLIB_VERNUM < 0x1270)
	typedef uLongf z_crc_t;
	#endif
	#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 */

	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;
	unsigned flags;

	+# ifndef NOUNCRYPT
	+ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
	+ const z_crc_t FAR * pcrc_32_tab;
	+# endif
	} unz64_s;


	+#ifndef NOUNCRYPT
	+#include "minizip_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.
	*/
	extern unzFile unzOpenInternal (voidpf file,
	zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
	int is64bitOpenFunction, unsigned flags)
	{
	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.flags = flags;
	us.z_filefunc.zseek32_file = NULL;
	us.z_filefunc.ztell32_file = NULL;
	if (pzlib_filefunc64_32_def==NULL)
	fill_qiodevice64_filefunc(&us.z_filefunc.zfile_func64);
	else
	us.z_filefunc = *pzlib_filefunc64_32_def;
	us.is64bitOpenFunction = is64bitOpenFunction;



	us.filestream = ZOPEN64(us.z_filefunc,
	file,
	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)
	{
	if ((us.flags & UNZ_AUTO_CLOSE) != 0)
	ZCLOSE64(us.z_filefunc, us.filestream);
	else
	ZFAKECLOSE64(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 (voidpf file,
	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(file, &zlib_filefunc64_32_def_fill, 0, UNZ_DEFAULT_FLAGS);
	}
	else
	return unzOpenInternal(file, NULL, 0, UNZ_DEFAULT_FLAGS);
	}

	extern unzFile ZEXPORT unzOpen2_64 (voidpf file,
	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(file, &zlib_filefunc64_32_def_fill, 1, UNZ_DEFAULT_FLAGS);
	}
	else
	return unzOpenInternal(file, NULL, 1, UNZ_DEFAULT_FLAGS);
	}

	extern unzFile ZEXPORT unzOpen (voidpf file)
	{
	return unzOpenInternal(file, NULL, 0, UNZ_DEFAULT_FLAGS);
	}

	extern unzFile ZEXPORT unzOpen64 (voidpf file)
	{
	return unzOpenInternal(file, NULL, 1, UNZ_DEFAULT_FLAGS);
	}

	/*
	Close a ZipFile opened with unzipOpen.
	If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
	these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
	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);

	if ((s->flags & UNZ_AUTO_CLOSE) != 0)
	ZCLOSE64(s->z_filefunc, s->filestream);
	else
	ZFAKECLOSE64(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;
	ZPOS64_T llSeek=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;

	llSeek+=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;
	llSeek -= 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 (llSeek!=0)
	{
	if (ZSEEK64(s->z_filefunc, s->filestream,llSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
	llSeek=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;

	llSeek += file_info.size_file_extra - (uLong)uSizeRead;
	}
	else
	llSeek += 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 */
	llSeek -= file_info.size_file_extra;

	if (llSeek!=0)
	{
	if (ZSEEK64(s->z_filefunc, s->filestream,llSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
	llSeek=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 == (ZPOS64_T)0xFFFFFFFFu)
	{
	if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
	err=UNZ_ERRNO;
	}

	if(file_info.compressed_size == (ZPOS64_T)0xFFFFFFFFu)
	{
	if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
	err=UNZ_ERRNO;
	}

	if(file_info_internal.offset_curfile == (ZPOS64_T)0xFFFFFFFFu)
	{
	/* 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 == 0xFFFFFFFFu)
	{
	/* 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 (llSeek!=0)
	{
	if (ZSEEK64(s->z_filefunc, s->filestream,llSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
	llSeek=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;
	llSeek+=file_info.size_file_comment - uSizeRead;
	}
	else
	llSeek+=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 unzipStringFileNameCompare

	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) &&
	(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) &&
	(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_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->read_buffer);
	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
	{
	uInt uAvailOutBefore,uAvailOutAfter;
	const Bytef *bufBefore;
	uInt uOutThis;
	int flush=Z_SYNC_FLUSH;

	uAvailOutBefore = pfile_in_zip_read_info->stream.avail_out;
	bufBefore = pfile_in_zip_read_info->stream.next_out;

	err=inflate(&pfile_in_zip_read_info->stream,flush);

	if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
	err = Z_DATA_ERROR;

	uAvailOutAfter = pfile_in_zip_read_info->stream.avail_out;
	uOutThis = uAvailOutBefore - uAvailOutAfter;

	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, uOutThis);

	pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;

	iRead += uAvailOutBefore - uAvailOutAfter;

	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 unzipOpenCurrentFile
	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);


	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);
	}


	int ZEXPORT unzSetFlags(unzFile file, unsigned flags)
	{
	unz64_s* s;
	if (file == NULL)
	return UNZ_PARAMERROR;
	s = (unz64_s*)file;
	s->flags \|= flags;
	return UNZ_OK;
	}


	int ZEXPORT unzClearFlags(unzFile file, unsigned flags)
	{
	unz64_s* s;
	if (file == NULL)
	return UNZ_PARAMERROR;
	s = (unz64_s*)file;
	s->flags &= ~flags;
	return UNZ_OK;
	}
	diff --git a/quazip/zip.c b/quazip/zip.c
	--- a/quazip/zip.c
	+++ b/quazip/zip.c
	@@ -1,1955 +1,1996 @@
	/* 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

	Modifications for QIODevice support and other QuaZIP fixes
	Copyright (C) 2005-2014 Sergey A. Tachenov

	Fixing static code analysis issues
	Copyright (C) 2016 Intel Deutschland GmbH

	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"
	#if (ZLIB_VERNUM < 0x1270)
	typedef uLongf z_crc_t;
	#endif
	#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 (0x031e) /* best for standard pkware crypt */
	#endif

	#ifndef Z_BUFSIZE
	#define Z_BUFSIZE (641024) / (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 DESCRIPTORHEADERMAGIC (0x08074b50)
	#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 */

	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 FAR * 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

	unsigned flags;

	} zip64_internal;


	+#ifndef NOCRYPT
	+#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
	+#include "minizip_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)
	{
	if ((pziinit->flags & ZIP_AUTO_CLOSE) != 0) {
	ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
	} else {
	ZFAKECLOSE64(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 (voidpf file, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
	unsigned flags)
	{
	zip64_internal ziinit;
	zip64_internal* zi;
	int err=ZIP_OK;

	ziinit.flags = flags;
	ziinit.z_filefunc.zseek32_file = NULL;
	ziinit.z_filefunc.ztell32_file = NULL;
	if (pzlib_filefunc64_32_def==NULL)
	fill_qiodevice64_filefunc(&ziinit.z_filefunc.zfile_func64);
	else
	ziinit.z_filefunc = *pzlib_filefunc64_32_def;

	ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
	file,
	(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)
	{
	if ((ziinit.flags & ZIP_AUTO_CLOSE) != 0) {
	ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
	} else {
	ZFAKECLOSE64(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 (voidpf file, 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(file, append, globalcomment, &zlib_filefunc64_32_def_fill, ZIP_DEFAULT_FLAGS);
	}
	else
	return zipOpen3(file, append, globalcomment, NULL, ZIP_DEFAULT_FLAGS);
	}

	extern zipFile ZEXPORT zipOpen2_64 (voidpf file, 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(file, append, globalcomment, &zlib_filefunc64_32_def_fill, ZIP_DEFAULT_FLAGS);
	}
	else
	return zipOpen3(file, append, globalcomment, NULL, ZIP_DEFAULT_FLAGS);
	}



	extern zipFile ZEXPORT zipOpen (voidpf file, int append)
	{
	return zipOpen3(file,append,NULL,NULL, ZIP_DEFAULT_FLAGS);
	}

	extern zipFile ZEXPORT zipOpen64 (voidpf file, int append)
	{
	return zipOpen3(file,append,NULL,NULL, ZIP_DEFAULT_FLAGS);
	}

	int Write_LocalFileHeader(zip64_internal* zi, const char* filename,
	uInt size_extrafield_local,
	const void* extrafield_local,
	uLong version_to_extract)
	{
	/* 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)version_to_extract,2);
	}

	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)
	{
	- crcForCrypting = crcForCrypting;
	zip64_internal* zi;
	uInt size_filename;
	uInt size_comment;
	uInt i;
	int err = ZIP_OK;
	uLong version_to_extract;

	+# ifdef NOCRYPT
	if (password != NULL)
	return ZIP_PARAMERROR;
	+# endif

	if (file == NULL)
	return ZIP_PARAMERROR;

	if ((method!=0) && (method!=Z_DEFLATED))
	return ZIP_PARAMERROR;

	zi = (zip64_internal*)file;

	if (zi->in_opened_file_inzip == 1)
	{
	err = zipCloseFileInZip (file);
	if (err != ZIP_OK)
	return err;
	}

	if (method == 0
	&& (level == 0 \|\| (zi->flags & ZIP_WRITE_DATA_DESCRIPTOR) == 0)
	&& (zi->flags & ZIP_SEQUENTIAL) == 0)
	{
	version_to_extract = 10;
	}
	else
	{
	version_to_extract = 20;
	}

	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;
	if (version_to_extract >= 20
	&& ((zi->flags & ZIP_WRITE_DATA_DESCRIPTOR) != 0
	\|\| (zi->flags & ZIP_SEQUENTIAL) != 0))
	zi->ci.flag \|= 8;

	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);
	if(!zi->ci.central_header) {
	return (Z_MEM_ERROR);
	}

	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)version_to_extract,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, version_to_extract);

	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;

	if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
	{
	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;
	}

	}

	+# 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);/
	+ if (crcForCrypting == 0) {
	+ crcForCrypting = (uLong)zi->ci.dosDate << 16; /* ATTANTION! Without this row, you don't unpack your password protected archive in other app. */
	+ }
	+ 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;
	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);

	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))
	{
	uInt uAvailOutBefore = zi->ci.stream.avail_out;
	err=deflate(&zi->ci.stream, Z_NO_FLUSH);
	zi->ci.pos_in_buffered_data += uAvailOutBefore - zi->ci.stream.avail_out;
	}
	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 uAvailOutBefore;
	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;
	}
	uAvailOutBefore = zi->ci.stream.avail_out;
	err=deflate(&zi->ci.stream, Z_FINISH);
	zi->ci.pos_in_buffered_data += uAvailOutBefore - zi->ci.stream.avail_out;
	}
	}

	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)
	{
	if ((zi->flags & ZIP_SEQUENTIAL) == 0) {
	/* 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
	{
	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;
	}

	if ((zi->ci.flag & 8) != 0) {
	/* Write local Descriptor after file data */
	if (err==ZIP_OK)
	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)DESCRIPTORHEADERMAGIC,4);
	if (err==ZIP_OK)
	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
	if (zi->ci.zip64) {
	if (err==ZIP_OK) /* compressed size, unknown */
	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,8);

	if (err==ZIP_OK) /* uncompressed size, unknown */
	err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,8);
	} 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);
	}
	}
	}

	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 ((zi->flags & ZIP_AUTO_CLOSE) != 0) {
	if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0) {
	if (err == ZIP_OK)
	err = ZIP_ERRNO;
	}
	} else {
	if (ZFAKECLOSE64(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);
	if(!pNewHeader) {
	return Z_MEM_ERROR;
	}
	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;
	}

	int ZEXPORT zipSetFlags(zipFile file, unsigned flags)
	{
	zip64_internal* zi;
	if (file == NULL)
	return ZIP_PARAMERROR;
	zi = (zip64_internal*)file;
	zi->flags \|= flags;
	// If the output is non-seekable, the data descriptor is needed.
	if ((zi->flags & ZIP_SEQUENTIAL) != 0) {
	zi->flags \|= ZIP_WRITE_DATA_DESCRIPTOR;
	}
	return ZIP_OK;
	}

	int ZEXPORT zipClearFlags(zipFile file, unsigned flags)
	{
	zip64_internal* zi;
	if (file == NULL)
	return ZIP_PARAMERROR;
	zi = (zip64_internal*)file;
	zi->flags &= ~flags;
	// If the data descriptor is not written, we can't use a non-seekable output.
	if ((zi->flags & ZIP_WRITE_DATA_DESCRIPTOR) == 0) {
	zi->flags &= ~ZIP_SEQUENTIAL;
	}
	return ZIP_OK;
	}
	diff --git a/qztest/testquazipfile.cpp b/qztest/testquazipfile.cpp
	--- a/qztest/testquazipfile.cpp
	+++ b/qztest/testquazipfile.cpp
	@@ -1,572 +1,575 @@
	/*
	Copyright (C) 2005-2014 Sergey A. Tachenov

	This file is part of QuaZIP test suite.

	QuaZIP is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 2.1 of the License, or
	(at your option) any later version.

	QuaZIP is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with QuaZIP. If not, see <http://www.gnu.org/licenses/>.

	See COPYING file for the full LGPL text.

	Original ZIP package is copyrighted by Gilles Vollant and contributors,
	see quazip/(un)zip.h files for details. Basically it's the zlib license.
	*/

	#include "testquazipfile.h"

	#include "qztest.h"

	#include "JlCompress.h"
	#include <quazip/quazipfile.h>
	#include <quazip/quazip.h>

	#include <QFile>
	#include <QString>
	#include <QStringList>

	#include <QtTest/QtTest>

	void TestQuaZipFile::zipUnzip_data()
	{
	QTest::addColumn<QString>("zipName");
	QTest::addColumn<QStringList>("fileNames");
	QTest::addColumn<QByteArray>("fileNameCodec");
	QTest::addColumn<QByteArray>("password");
	QTest::addColumn<bool>("zip64");
	QTest::addColumn<int>("size");
	QTest::newRow("simple") << "simple.zip" << (
	QStringList() << "test0.txt" << "testdir1/test1.txt"
	<< "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
	<< QByteArray() << QByteArray() << false << -1;
	QTest::newRow("Cyrillic") << "cyrillic.zip" << (
	QStringList()
	<< QString::fromUtf8("русское имя файла с пробелами.txt"))
	<< QByteArray("IBM866") << QByteArray() << false << -1;
	+ QTest::newRow("password") << "password.zip" << (
	+ QStringList() << "test.txt")
	+ << QByteArray() << QByteArray("PassPass") << false << -1;
	QTest::newRow("zip64") << "zip64.zip" << (
	QStringList() << "test64.txt")
	<< QByteArray() << QByteArray() << true << -1;
	QTest::newRow("large enough to flush") << "flush.zip" << (
	QStringList() << "flush.txt")
	<< QByteArray() << QByteArray() << true << 65536 * 2;
	}

	void TestQuaZipFile::zipUnzip()
	{
	QFETCH(QString, zipName);
	QFETCH(QStringList, fileNames);
	QFETCH(QByteArray, fileNameCodec);
	QFETCH(QByteArray, password);
	QFETCH(bool, zip64);
	QFETCH(int, size);
	QFile testFile(zipName);
	if (testFile.exists()) {
	if (!testFile.remove()) {
	QFAIL("Couldn't remove existing archive to create a new one");
	}
	}
	if (!createTestFiles(fileNames, size)) {
	QFAIL("Couldn't create test files for zipping");
	}
	QuaZip testZip(&testFile);
	testZip.setZip64Enabled(zip64);
	if (!fileNameCodec.isEmpty())
	testZip.setFileNameCodec(fileNameCodec);
	QVERIFY(testZip.open(QuaZip::mdCreate));
	QString comment = "Test comment";
	testZip.setComment(comment);
	foreach (QString fileName, fileNames) {
	QFile inFile("tmp/" + fileName);
	if (!inFile.open(QIODevice::ReadOnly)) {
	qDebug("File name: %s", fileName.toUtf8().constData());
	QFAIL("Couldn't open input file");
	}
	QuaZipFile outFile(&testZip);
	QVERIFY(outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileName,
	inFile.fileName()),
	password.isEmpty() ? NULL : password.constData()));
	for (qint64 pos = 0, len = inFile.size(); pos < len; ) {
	char buf[4096];
	qint64 readSize = qMin(static_cast<qint64>(4096), len - pos);
	qint64 l;
	if ((l = inFile.read(buf, readSize)) != readSize) {
	qDebug("Reading %ld bytes from %s at %ld returned %ld",
	static_cast<long>(readSize),
	fileName.toUtf8().constData(),
	static_cast<long>(pos),
	static_cast<long>(l));
	QFAIL("Read failure");
	}
	QVERIFY(outFile.write(buf, readSize));
	pos += readSize;
	}
	inFile.close();
	outFile.close();
	QCOMPARE(outFile.getZipError(), ZIP_OK);
	}
	testZip.close();
	QCOMPARE(testZip.getZipError(), ZIP_OK);
	// now test unzip
	QuaZip testUnzip(&testFile);
	if (!fileNameCodec.isEmpty())
	testUnzip.setFileNameCodec(fileNameCodec);
	QVERIFY(testUnzip.open(QuaZip::mdUnzip));
	QCOMPARE(testUnzip.getComment(), comment);
	QVERIFY(testUnzip.goToFirstFile());
	foreach (QString fileName, fileNames) {
	QuaZipFileInfo64 info;
	QVERIFY(testUnzip.getCurrentFileInfo(&info));
	QCOMPARE(info.name, fileName);
	QCOMPARE(info.isEncrypted(), !password.isEmpty());
	QFile original("tmp/" + fileName);
	QVERIFY(original.open(QIODevice::ReadOnly));
	QuaZipFile archived(&testUnzip);
	QVERIFY(archived.open(QIODevice::ReadOnly,
	password.isEmpty() ? NULL : password.constData()));
	QByteArray originalData = original.readAll();
	QByteArray archivedData = archived.readAll();
	QCOMPARE(archivedData, originalData);
	testUnzip.goToNextFile();
	}
	if (!password.isEmpty()) {
	QVERIFY(testUnzip.goToFirstFile());
	QuaZipFileInfo64 info;
	QVERIFY(testUnzip.getCurrentFileInfo(&info));
	QFile original("tmp/" + info.name);
	QVERIFY(original.open(QIODevice::ReadOnly));
	QuaZipFile archived(&testUnzip);
	QVERIFY(archived.open(QIODevice::ReadOnly, "WrongPassword"));
	QByteArray originalData = original.readAll();
	QByteArray archivedData = archived.readAll();
	QVERIFY(archivedData != originalData);
	}
	testUnzip.close();
	QCOMPARE(testUnzip.getZipError(), UNZ_OK);
	// clean up
	removeTestFiles(fileNames);
	testFile.remove();
	}

	void TestQuaZipFile::bytesAvailable_data()
	{
	QTest::addColumn<QString>("zipName");
	QTest::addColumn<QStringList>("fileNames");
	QTest::addColumn<int>("size");
	QTest::newRow("simple") << "test.zip" << (
	QStringList() << "test0.txt" << "testdir1/test1.txt"
	<< "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt") << -1;
	QTest::newRow("large enough to flush")
	<< "flush.zip" << (QStringList() << "test.txt") << 65536 * 4;
	}

	void TestQuaZipFile::bytesAvailable()
	{
	QFETCH(QString, zipName);
	QFETCH(QStringList, fileNames);
	QFETCH(int, size);
	QDir curDir;
	if (!createTestFiles(fileNames, size)) {
	QFAIL("Couldn't create test files");
	}
	if (!JlCompress::compressDir(zipName, "tmp")) {
	QFAIL("Couldn't create test archive");
	}
	QuaZip testZip(zipName);
	QVERIFY(testZip.open(QuaZip::mdUnzip));
	foreach (QString fileName, fileNames) {
	QFileInfo fileInfo("tmp/" + fileName);
	QVERIFY(testZip.setCurrentFile(fileName));
	QuaZipFile zipFile(&testZip);
	QVERIFY(zipFile.open(QIODevice::ReadOnly));
	QCOMPARE(zipFile.bytesAvailable(), fileInfo.size());
	QCOMPARE(zipFile.read(1).size(), 1);
	QCOMPARE(zipFile.bytesAvailable(), fileInfo.size() - 1);
	QCOMPARE(zipFile.read(fileInfo.size() - 1).size(),
	static_cast<int>(fileInfo.size() - 1));
	QCOMPARE(zipFile.bytesAvailable(), (qint64) 0);
	}
	removeTestFiles(fileNames);
	testZip.close();
	curDir.remove(zipName);
	}

	void TestQuaZipFile::atEnd_data()
	{
	bytesAvailable_data();
	}

	void TestQuaZipFile::atEnd()
	{
	QFETCH(QString, zipName);
	QFETCH(QStringList, fileNames);
	QFETCH(int, size);
	QDir curDir;
	if (!createTestFiles(fileNames, size)) {
	QFAIL("Couldn't create test files");
	}
	if (!JlCompress::compressDir(zipName, "tmp")) {
	QFAIL("Couldn't create test archive");
	}
	QuaZip testZip(zipName);
	QVERIFY(testZip.open(QuaZip::mdUnzip));
	foreach (QString fileName, fileNames) {
	QFileInfo fileInfo("tmp/" + fileName);
	QVERIFY(testZip.setCurrentFile(fileName));
	QuaZipFile zipFile(&testZip);
	QVERIFY(zipFile.open(QIODevice::ReadOnly));
	QCOMPARE(zipFile.atEnd(), false);
	QCOMPARE(zipFile.read(1).size(), 1);
	QCOMPARE(zipFile.atEnd(), false);
	QCOMPARE(zipFile.read(fileInfo.size() - 1).size(),
	static_cast<int>(fileInfo.size() - 1));
	QCOMPARE(zipFile.atEnd(), true);
	}
	removeTestFiles(fileNames);
	testZip.close();
	curDir.remove(zipName);
	}

	void TestQuaZipFile::posRead_data()
	{
	bytesAvailable_data();
	}

	void TestQuaZipFile::posRead()
	{
	QFETCH(QString, zipName);
	QFETCH(QStringList, fileNames);
	QFETCH(int, size);
	QDir curDir;
	if (!createTestFiles(fileNames, size)) {
	QFAIL("Couldn't create test files");
	}
	if (!JlCompress::compressDir(zipName, "tmp")) {
	QFAIL("Couldn't create test archive");
	}
	QuaZip testZip(zipName);
	QVERIFY(testZip.open(QuaZip::mdUnzip));
	foreach (QString fileName, fileNames) {
	QFileInfo fileInfo("tmp/" + fileName);
	QVERIFY(testZip.setCurrentFile(fileName));
	QuaZipFile zipFile(&testZip);
	QVERIFY(zipFile.open(QIODevice::ReadOnly));
	QCOMPARE(zipFile.pos(), (qint64) 0);
	QCOMPARE(zipFile.read(1).size(), 1);
	QCOMPARE(zipFile.pos(), (qint64) 1);
	QCOMPARE(zipFile.read(fileInfo.size() - 1).size(),
	static_cast<int>(fileInfo.size() - 1));
	QCOMPARE(zipFile.pos(), fileInfo.size());
	}
	removeTestFiles(fileNames);
	testZip.close();
	curDir.remove(zipName);
	}

	void TestQuaZipFile::posWrite_data()
	{
	posRead_data();
	}

	void TestQuaZipFile::posWrite()
	{
	QFETCH(QString, zipName);
	QFETCH(QStringList, fileNames);
	QFETCH(int, size);
	if (size == -1)
	size = 20;
	QDir curDir;
	QuaZip testZip(zipName);
	QVERIFY(testZip.open(QuaZip::mdCreate));
	foreach (QString fileName, fileNames) {
	QuaZipFile zipFile(&testZip);
	QVERIFY(zipFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileName)));
	QCOMPARE(zipFile.pos(), (qint64) 0);
	zipFile.putChar('0');
	QCOMPARE(zipFile.pos(), (qint64) 1);
	QByteArray buffer(size / 2 - 1, '\0');
	for (int i = 0; i < buffer.size(); ++i)
	buffer[i] = static_cast<char>(qrand());
	zipFile.write(buffer);
	QCOMPARE(zipFile.pos(), qint64(size / 2));
	for (int i = 0; i < size - size / 2; ++i) {
	zipFile.putChar(static_cast<char>(qrand()));
	}
	QCOMPARE(zipFile.pos(), qint64(size));
	}
	testZip.close();
	curDir.remove(zipName);
	}

	void TestQuaZipFile::getZip()
	{
	QuaZip testZip;
	QuaZipFile f1(&testZip);
	QCOMPARE(f1.getZip(), &testZip);
	QuaZipFile f2("doesntexist.zip", "someFile");
	QCOMPARE(f2.getZip(), static_cast<QuaZip*>(NULL));
	f2.setZip(&testZip);
	QCOMPARE(f2.getZip(), &testZip);
	}

	void TestQuaZipFile::setZipName()
	{
	QString testFileName = "testZipName.txt";
	QString testZipName = "testZipName.zip";
	QVERIFY(createTestFiles(QStringList() << testFileName));
	QVERIFY(createTestArchive(testZipName, QStringList() << testFileName));
	QuaZipFile testFile;
	testFile.setZipName(testZipName);
	QCOMPARE(testFile.getZipName(), testZipName);
	testFile.setFileName(testFileName);
	QVERIFY(testFile.open(QIODevice::ReadOnly));
	testFile.close();
	removeTestFiles(QStringList() << testFileName);
	QDir curDir;
	curDir.remove(testZipName);
	}

	void TestQuaZipFile::getFileInfo()
	{
	QuaZipFileInfo info32;
	QuaZipFileInfo64 info64;
	QString testFileName = "testZipName.txt";
	QStringList testFiles;
	testFiles << testFileName;
	QString testZipName = "testZipName.zip";
	QVERIFY(createTestFiles(testFiles));
	QVERIFY(createTestArchive(testZipName, testFiles));
	QuaZipFile testFile;
	testFile.setZipName(testZipName);
	testFile.setFileName(testFileName);
	QVERIFY(testFile.open(QIODevice::ReadOnly));
	QVERIFY(testFile.getFileInfo(&info32));
	QVERIFY(testFile.getFileInfo(&info64));
	QCOMPARE(info32.name, info64.name);
	QCOMPARE(info32.versionCreated, info64.versionCreated);
	QCOMPARE(info32.versionNeeded, info64.versionNeeded);
	QCOMPARE(info32.flags, info64.flags);
	QCOMPARE(info32.method, info64.method);
	QCOMPARE(info32.dateTime, info64.dateTime);
	QCOMPARE(info32.crc, info64.crc);
	QCOMPARE(info32.compressedSize,
	static_cast<quint32>(info64.compressedSize));
	QCOMPARE(info32.uncompressedSize,
	static_cast<quint32>(info64.uncompressedSize));
	QCOMPARE(info32.diskNumberStart, info64.diskNumberStart);
	QCOMPARE(info32.internalAttr, info64.internalAttr);
	QCOMPARE(info32.externalAttr, info64.externalAttr);
	QCOMPARE(info32.comment, info64.comment);
	QCOMPARE(info32.extra, info64.extra);
	testFile.close();
	removeTestFiles(testFiles);
	QDir curDir;
	curDir.remove(testZipName);
	}

	void TestQuaZipFile::setFileName()
	{
	QString testFileName = "testZipName.txt";
	QString testZipName = "testZipName.zip";
	QVERIFY(createTestFiles(QStringList() << testFileName));
	QVERIFY(createTestArchive(testZipName, QStringList() << testFileName));
	QuaZipFile testFile(testZipName);
	testFile.setFileName(testFileName.toUpper());
	#ifdef Q_OS_WIN
	QVERIFY(testFile.open(QIODevice::ReadOnly));
	testFile.close();
	#else
	QVERIFY(!testFile.open(QIODevice::ReadOnly));
	#endif
	testFile.setFileName(testFileName.toUpper(), QuaZip::csInsensitive);
	QCOMPARE(testFile.getCaseSensitivity(), QuaZip::csInsensitive);
	QVERIFY(testFile.open(QIODevice::ReadOnly));
	QCOMPARE(testFile.getActualFileName(), testFileName);
	testFile.close();
	testFile.setFileName(testFileName.toUpper(), QuaZip::csSensitive);
	QCOMPARE(testFile.getFileName(), testFileName.toUpper());
	QCOMPARE(testFile.getActualFileName(), QString());
	QVERIFY(!testFile.open(QIODevice::ReadOnly));
	testFile.setFileName(testFileName);
	removeTestFiles(QStringList() << testFileName);
	QDir curDir;
	curDir.remove(testZipName);
	}

	void TestQuaZipFile::constructorDestructor()
	{
	// Just test that all constructors and destructors are available.
	// (So there are none that are declared but not defined.)
	QuaZip testZip;
	QuaZipFile *f1 = new QuaZipFile();
	delete f1; // test D0 destructor
	QObject parent;
	QuaZipFile f2(&testZip, &parent);
	QuaZipFile f3(&parent);
	QuaZipFile f4("zipName.zip");
	QuaZipFile f5("zipName.zip", "fileName.txt", QuaZip::csDefault, &parent);
	}

	void TestQuaZipFile::setFileAttrs()
	{
	QuaZip testZip("setFileAttrs.zip");
	QVERIFY(testZip.open(QuaZip::mdCreate));
	QuaZipFile zipFile(&testZip);
	QuaZipNewInfo newInfo("testPerm.txt");
	newInfo.setPermissions(QFile::ReadOwner);
	QVERIFY(zipFile.open(QIODevice::WriteOnly, newInfo));
	zipFile.close();
	QString fileTestAttr = "testAttr.txt";
	QStringList fileNames;
	fileNames << fileTestAttr;
	QVERIFY(createTestFiles(fileNames));
	newInfo.name = fileTestAttr;
	newInfo.setFileDateTime("tmp/" + fileTestAttr);
	newInfo.setFilePermissions("tmp/" + fileTestAttr);
	QVERIFY(zipFile.open(QIODevice::WriteOnly, newInfo));
	zipFile.close();
	testZip.close();
	QuaZipFileInfo64 info;
	{
	QuaZipFile readFilePerm("setFileAttrs.zip", "testPerm.txt");
	QVERIFY(readFilePerm.open(QIODevice::ReadOnly));
	QVERIFY(readFilePerm.getFileInfo(&info));
	QCOMPARE(info.getPermissions(), QFile::ReadOwner);
	readFilePerm.close();
	}
	{
	QuaZipFile readFileAttrs("setFileAttrs.zip", "testAttr.txt");
	QVERIFY(readFileAttrs.open(QIODevice::ReadOnly));
	QVERIFY(readFileAttrs.getFileInfo(&info));
	QFileInfo srcInfo("tmp/" + fileTestAttr);
	QFile::Permissions usedPermissions =
	QFile::WriteOwner \| QFile::ReadOwner \| QFile::ExeOwner \|
	QFile::WriteGroup \| QFile::ReadGroup \| QFile::ExeGroup \|
	QFile::WriteOther \| QFile::ReadOther \| QFile::ExeOther;
	QCOMPARE(info.getPermissions() & usedPermissions,
	srcInfo.permissions() & usedPermissions);
	// I really hope Qt 6 will use quint64 for time_t!
	quint64 newTime = info.dateTime.toTime_t();
	quint64 oldTime = srcInfo.lastModified().toTime_t();
	// ZIP uses weird format with 2 second precision
	QCOMPARE(newTime / 2, oldTime / 2);
	readFileAttrs.close();
	}
	removeTestFiles(fileNames);
	QDir().remove(testZip.getZipName());
	}

	void TestQuaZipFile::largeFile()
	{
	QDir curDir;
	QVERIFY(curDir.mkpath("tmp"));
	QFile fakeLargeFile("tmp/large.zip");
	QVERIFY(fakeLargeFile.open(QIODevice::WriteOnly));
	QDataStream ds(&fakeLargeFile);
	ds.setByteOrder(QDataStream::LittleEndian);
	QList<qint64> localOffsets;
	const int numFiles = 2; // name fixed to 5 bytes, so MAX 10 FILES!!!
	for (int i = 0; i < numFiles; ++i) {
	localOffsets.append(fakeLargeFile.pos());
	QBuffer extra;
	extra.open(QIODevice::WriteOnly);
	QDataStream es(&extra);
	es.setByteOrder(QDataStream::LittleEndian);
	// prepare extra
	es << static_cast<quint16>(0x0001u); // zip64
	es << static_cast<quint16>(16); // extra data size
	es << static_cast<quint64>(0); // uncompressed size
	es << static_cast<quint64>(0); // compressed size
	// now the local header
	ds << static_cast<quint32>(0x04034b50u); // local magic
	ds << static_cast<quint16>(45); // version needed
	ds << static_cast<quint16>(0); // flags
	ds << static_cast<quint16>(0); // method
	ds << static_cast<quint16>(0); // time 00:00:00
	ds << static_cast<quint16>(0x21); // date 1980-01-01
	ds << static_cast<quint32>(0); // CRC-32
	ds << static_cast<quint32>(0xFFFFFFFFu); // compressed size
	ds << static_cast<quint32>(0xFFFFFFFFu); // uncompressed size
	ds << static_cast<quint16>(5); // name length
	ds << static_cast<quint16>(extra.size()); // extra length
	ds.writeRawData("file", 4); // name
	ds << static_cast<qint8>('0' + i); // name (contd.)
	ds.writeRawData(extra.buffer(), extra.size());
	}
	// central dir:
	qint64 centralStart = fakeLargeFile.pos();
	for (int i = 0; i < numFiles; ++i) {
	QBuffer extra;
	extra.open(QIODevice::WriteOnly);
	QDataStream es(&extra);
	es.setByteOrder(QDataStream::LittleEndian);
	// prepare extra
	es << static_cast<quint16>(0x0001u); // zip64
	es << static_cast<quint16>(24); // extra data size
	es << static_cast<quint64>(0); // uncompressed size
	es << static_cast<quint64>(0); // compressed size
	es << static_cast<quint64>(localOffsets[i]);
	// now the central dir header
	ds << static_cast<quint32>(0x02014b50u); // central magic
	ds << static_cast<quint16>(45); // version made by
	ds << static_cast<quint16>(45); // version needed
	ds << static_cast<quint16>(0); // flags
	ds << static_cast<quint16>(0); // method
	ds << static_cast<quint16>(0); // time 00:00:00
	ds << static_cast<quint16>(0x21); // date 1980-01-01
	ds << static_cast<quint32>(0); // CRC-32
	ds << static_cast<quint32>(0xFFFFFFFFu); // compressed size
	ds << static_cast<quint32>(0xFFFFFFFFu); // uncompressed size
	ds << static_cast<quint16>(5); // name length
	ds << static_cast<quint16>(extra.size()); // extra length
	ds << static_cast<quint16>(0); // comment length
	ds << static_cast<quint16>(0); // disk number
	ds << static_cast<quint16>(0); // internal attrs
	ds << static_cast<quint32>(0); // external attrs
	ds << static_cast<quint32>(0xFFFFFFFFu); // local offset
	ds.writeRawData("file", 4); // name
	ds << static_cast<qint8>('0' + i); // name (contd.)
	ds.writeRawData(extra.buffer(), extra.size());
	}
	qint64 centralEnd = fakeLargeFile.pos();
	// zip64 end
	ds << static_cast<quint32>(0x06064b50); // zip64 end magic
	ds << static_cast<quint64>(44); // size of the zip64 end
	ds << static_cast<quint16>(45); // version made by
	ds << static_cast<quint16>(45); // version needed
	ds << static_cast<quint32>(0); // disk number
	ds << static_cast<quint32>(0); // central dir disk number
	ds << static_cast<quint64>(2); // number of entries on disk
	ds << static_cast<quint64>(2); // total number of entries
	ds << static_cast<quint64>(centralEnd - centralStart); // size
	ds << static_cast<quint64>(centralStart); // offset
	// zip64 locator
	ds << static_cast<quint32>(0x07064b50); // zip64 locator magic
	ds << static_cast<quint32>(0); // disk number
	ds << static_cast<quint64>(centralEnd); // offset
	ds << static_cast<quint32>(1); // number of disks
	// zip32 end
	ds << static_cast<quint32>(0x06054b50); // end magic
	ds << static_cast<quint16>(0); // disk number
	ds << static_cast<quint16>(0); // central dir disk number
	ds << static_cast<quint16>(2); // number of entries
	ds << static_cast<quint32>(0xFFFFFFFFu); // central dir size
	ds << static_cast<quint32>(0xFFFFFFFFu); // central dir offset
	ds << static_cast<quint16>(0); // comment length
	fakeLargeFile.close();
	QuaZip fakeLargeZip("tmp/large.zip");
	QVERIFY(fakeLargeZip.open(QuaZip::mdUnzip));
	QCOMPARE(fakeLargeZip.getFileInfoList().size(), numFiles);
	QCOMPARE(fakeLargeZip.getFileInfoList()[0].uncompressedSize,
	static_cast<quint32>(0));
	fakeLargeZip.close();
	curDir.remove("tmp/large.zip");
	}
	diff --git a/test.diff b/test.diff
	--- a/test.diff
	+++ b/test.diff
	@@ -1,98 +1,77 @@
	---- a/qztest/qztest.cpp 2019-09-12 12:50:50.956633046 +0300
	-+++ b/qztest/qztest.cpp 2019-09-12 13:29:17.661408359 +0300
	+diff -u a/qztest/qztest.cpp b/qztest/qztest.cpp
	+--- a/qztest/qztest.cpp 2023-05-31 17:48:37.376339390 +0300
	++++ b/qztest/qztest.cpp 2019-09-12 15:40:16.889104000 +0300
	@@ -25,10 +25,6 @@
	#include "qztest.h"
	#include "testquazip.h"
	#include "testquazipfile.h"
	-#include "testquachecksum32.h"
	-#include "testjlcompress.h"
	-#include "testquazipdir.h"
	-#include "testquagzipfile.h"
	#include "testquaziodevice.h"
	#include "testquazipnewinfo.h"
	#include "testquazipfileinfo.h"
	@@ -201,26 +197,10 @@
	err = qMax(err, QTest::qExec(&testQuaZipFile, app.arguments()));
	}
	{
	- TestQuaChecksum32 testQuaChecksum32;
	- err = qMax(err, QTest::qExec(&testQuaChecksum32, app.arguments()));
	- }
	- {
	- TestJlCompress testJlCompress;
	- err = qMax(err, QTest::qExec(&testJlCompress, app.arguments()));
	- }
	- {
	- TestQuaZipDir testQuaZipDir;
	- err = qMax(err, QTest::qExec(&testQuaZipDir, app.arguments()));
	- }
	- {
	TestQuaZIODevice testQuaZIODevice;
	err = qMax(err, QTest::qExec(&testQuaZIODevice, app.arguments()));
	}
	{
	- TestQuaGzipFile testQuaGzipFile;
	- err = qMax(err, QTest::qExec(&testQuaGzipFile, app.arguments()));
	- }
	- {
	TestQuaZipNewInfo testQuaZipNewInfo;
	err = qMax(err, QTest::qExec(&testQuaZipNewInfo, app.arguments()));
	}
	---- a/qztest/testquazip.cpp 2019-09-12 12:50:50.964633035 +0300
	-+++ b/qztest/testquazip.cpp 2019-09-11 17:33:09.456429269 +0300
	+diff -u a/qztest/testjlcompress.cpp b/qztest/testjlcompress.cpp
	+--- a/qztest/testjlcompress.cpp 2023-05-31 17:48:37.376339390 +0300
	++++ b/qztest/testjlcompress.cpp 2019-09-12 15:40:16.889104000 +0300
	+@@ -31,7 +31,7 @@
	+
	+ #include <QtTest/QtTest>
	+
	+-#include <quazip/JlCompress.h>
	++#include "JlCompress.h"
	+
	+ #ifdef Q_OS_WIN
	+ #include <windows.h>
	+diff -u a/qztest/testquazip.cpp b/qztest/testquazip.cpp
	+--- a/qztest/testquazip.cpp 2023-05-31 17:48:37.380339356 +0300
	++++ b/qztest/testquazip.cpp 2019-09-12 15:40:16.889104000 +0300
	@@ -40,7 +40,7 @@
	#include <QtTest/QtTest>

	#include <quazip/quazip.h>
	-#include <quazip/JlCompress.h>
	+#include "JlCompress.h"

	void TestQuaZip::getFileList_data()
	{
	---- a/qztest/testquazipfile.cpp 2019-09-12 12:50:50.968633030 +0300
	-+++ b/qztest/testquazipfile.cpp 2019-09-11 17:58:58.330810048 +0300
	+diff -u a/qztest/testquazipfile.cpp b/qztest/testquazipfile.cpp
	+--- a/qztest/testquazipfile.cpp 2023-05-31 17:48:37.380339356 +0300
	++++ b/qztest/testquazipfile.cpp 2021-11-26 15:54:40.415006290 +0300
	@@ -26,7 +26,7 @@

	#include "qztest.h"

	-#include <quazip/JlCompress.h>
	+#include "JlCompress.h"
	#include <quazip/quazipfile.h>
	#include <quazip/quazip.h>

	-@@ -52,9 +52,6 @@
	- QStringList()
	- << QString::fromUtf8("русское имя файла с пробелами.txt"))
	- << QByteArray("IBM866") << QByteArray() << false << -1;
	-- QTest::newRow("password") << "password.zip" << (
	-- QStringList() << "test.txt")
	-- << QByteArray() << QByteArray("PassPass") << false << -1;
	- QTest::newRow("zip64") << "zip64.zip" << (
	- QStringList() << "test64.txt")
	- << QByteArray() << QByteArray() << true << -1;
	---- a/qztest/testjlcompress.cpp 2019-09-12 13:53:25.487271597 +0300
	-+++ b/qztest/testjlcompress.cpp 2019-09-12 12:50:50.960633041 +0300
	-@@ -31,7 +31,7 @@
	-
	- #include <QtTest/QtTest>
	-
	--#include <quazip/JlCompress.h>
	-+#include "JlCompress.h"
	-
	- #ifdef Q_OS_WIN
	- #include <windows.h>
	---- a/qztest/JlCompress.h 2019-09-12 12:50:50.908633109 +0300
	-+++ b/qztest/JlCompress.h 2019-09-12 13:49:44.951605835 +0300
	-@@ -26,9 +26,9 @@
	- see quazip/(un)zip.h files for details. Basically it's the zlib license.
	- */
	-
	--#include "quazip.h"
	--#include "quazipfile.h"
	--#include "quazipfileinfo.h"
	-+#include "quazip/quazip.h"
	-+#include "quazip/quazipfile.h"
	-+#include "quazip/quazipfileinfo.h"
	- #include <QString>
	- #include <QDir>
	- #include <QFileInfo>
	diff --git a/zip.diff b/zip.diff
	--- a/zip.diff
	+++ b/zip.diff
	@@ -1,591 +1,430 @@
	---- a/quazip/zip.c 2019-09-12 14:17:24.629118214 +0300
	-+++ b/quazip/zip.c 2019-09-12 14:19:04.885102347 +0300
	+diff -u a/quazip/unzip.c b/quazip/unzip.c
	+--- a/quazip/unzip.c 2023-05-31 17:48:37.372339423 +0300
	++++ b/quazip/unzip.c 2021-11-26 15:50:18.266174865 +0300
	+@@ -140,10 +140,6 @@
	+ 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*/
	+
	+@@ -1433,9 +1429,6 @@
	+ 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;
	+
	+@@ -1540,9 +1533,6 @@
	+ }
	+
	+ 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;
	+@@ -1557,33 +1547,7 @@
	+
	+ 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))
	++ 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;
	+@@ -1803,49 +1767,6 @@
	+ 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
	+ {
	+ uInt uAvailOutBefore,uAvailOutAfter;
	+@@ -2031,10 +1952,6 @@
	+ 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;
	+diff -u a/quazip/unzip.h b/quazip/unzip.h
	+--- a/quazip/unzip.h 2023-05-31 17:48:37.372339423 +0300
	++++ b/quazip/unzip.h 2019-09-12 15:40:20.781101000 +0300
	+@@ -60,12 +60,6 @@
	+ #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 /
	+diff -u a/quazip/zip.c b/quazip/zip.c
	+--- a/quazip/zip.c 2023-05-31 17:48:37.372339423 +0300
	++++ b/quazip/zip.c 2021-11-26 15:53:25.805832359 +0300
	@@ -140,9 +140,6 @@
	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 */
	-@@ -165,11 +162,6 @@
	- 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 FAR * pcrc_32_tab;
	-- int crypt_header_size;
	--#endif
	- } curfile64_info;
	-
	- typedef struct
	-@@ -193,11 +185,6 @@
	- } zip64_internal;
	-
	-
	--#ifndef NOCRYPT
	--#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
	--#include "minizip_crypt.h"
	--#endif
	--
	- local linkedlist_datablock_internal* allocate_new_datablock()
	- {
	- linkedlist_datablock_internal* ldi;
	-@@ -1086,6 +1073,7 @@
	- const char* password, uLong crcForCrypting,
	- uLong versionMadeBy, uLong flagBase, int zip64)
	- {
	-+ crcForCrypting = crcForCrypting;
	- zip64_internal* zi;
	- uInt size_filename;
	- uInt size_comment;
	-@@ -1093,21 +1081,14 @@
	- int err = ZIP_OK;
	- uLong version_to_extract;
	-
	--# ifdef NOCRYPT
	- if (password != NULL)
	- return ZIP_PARAMERROR;
	--# endif
	-
	+@@ -1101,13 +1098,8 @@
	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;

	-@@ -1231,16 +1212,6 @@
	+@@ -1231,16 +1223,6 @@
	err = Write_LocalFileHeader(zi, filename, size_extrafield_local,
	extrafield_local, version_to_extract);

	-#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;
	-@@ -1248,11 +1219,7 @@
	+@@ -1248,11 +1230,7 @@
	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)
	{
	-@@ -1268,41 +1235,8 @@
	+@@ -1268,19 +1246,6 @@
	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);/
	-- if (crcForCrypting == 0) {
	-- crcForCrypting = (uLong)zi->ci.dosDate << 16; /* ATTANTION! Without this row, you don't unpack your password protected archive in other app. */
	-- }
	-- 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;
	-@@ -1413,32 +1347,14 @@
	-
	- 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)
	+@@ -1425,20 +1390,8 @@
	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.totalUncompressedData += zi->ci.stream.total_in;
	+ zi->ci.stream.total_in = 0;


	zi->ci.pos_in_buffered_data = 0;
	-@@ -1460,89 +1376,51 @@
	+@@ -1460,89 +1413,51 @@

	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;
	+ zi->ci.stream.next_in = (Bytef*)buf;
	+ zi->ci.stream.avail_in = len;

	- while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
	- {
	- if (zi->ci.bstream.avail_out == 0)
	+ 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.bstream.avail_out = (uInt)Z_BUFSIZE;
	- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
	+ 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 != BZ_RUN_OK)
	- break;
	+ if(err != ZIP_OK)
	+ break;

	- if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
	+ if ((zi->ci.method == Z_DEFLATED) && (!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) ;
	+ uInt uAvailOutBefore = zi->ci.stream.avail_out;
	+ err=deflate(&zi->ci.stream, Z_NO_FLUSH);
	+ zi->ci.pos_in_buffered_data += uAvailOutBefore - zi->ci.stream.avail_out;
	}
	- }
	-
	- 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))
	- {
	- uInt uAvailOutBefore = zi->ci.stream.avail_out;
	- err=deflate(&zi->ci.stream, Z_NO_FLUSH);
	- zi->ci.pos_in_buffered_data += uAvailOutBefore - zi->ci.stream.avail_out;
	- }
	- 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(...) */
	- }
	+ 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;
	}
	-@@ -1585,32 +1463,6 @@
	+@@ -1585,32 +1500,6 @@
	zi->ci.pos_in_buffered_data += uAvailOutBefore - zi->ci.stream.avail_out;
	}
	}
	- 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 */
	-@@ -1645,10 +1497,6 @@
	- }
	- 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)
	- {
	---- a/quazip/zip.h 2019-09-12 12:50:50.952633051 +0300
	-+++ b/quazip/zip.h 2019-09-11 17:53:44.063138337 +0300
	+diff -u a/quazip/zip.h b/quazip/zip.h
	+--- a/quazip/zip.h 2023-05-31 17:48:37.376339390 +0300
	++++ b/quazip/zip.h 2019-09-12 15:40:20.777101000 +0300
	@@ -50,8 +50,6 @@
	extern "C" {
	#endif

	-//#define HAVE_BZIP2
	-
	#ifndef _ZLIB_H
	#include "zlib.h"
	#endif
	@@ -60,12 +58,6 @@
	#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 /
	---- a/quazip/unzip.c 2019-09-12 12:50:50.952633051 +0300
	-+++ b/quazip/unzip.c 2019-09-11 18:01:02.330680525 +0300
	-@@ -140,10 +140,6 @@
	- 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*/
	-
	-@@ -191,17 +187,9 @@
	- int isZip64;
	- unsigned flags;
	-
	--# ifndef NOUNCRYPT
	-- unsigned long keys[3]; /* keys defining the pseudo-random sequence */
	-- const z_crc_t FAR * pcrc_32_tab;
	--# endif
	- } unz64_s;
	-
	-
	--#ifndef NOUNCRYPT
	--#include "minizip_crypt.h"
	--#endif
	--
	- /* ===========================================================================
	- Read a byte from a gz_stream; update next_in and avail_in. Return EOF
	- for end of file.
	-@@ -1433,9 +1421,6 @@
	- 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;
	-
	-@@ -1488,12 +1473,8 @@
	- 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;
	-@@ -1540,9 +1521,6 @@
	- }
	-
	- 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;
	-@@ -1557,33 +1535,7 @@
	-
	- 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))
	-+ 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;
	-@@ -1623,29 +1575,6 @@
	- 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;
	- }
	-
	-@@ -1751,18 +1680,6 @@
	- 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;
	-@@ -1803,49 +1720,6 @@
	- 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
	- {
	- uInt uAvailOutBefore,uAvailOutAfter;
	-@@ -2031,10 +1905,6 @@
	- 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;
	---- a/quazip/unzip.h 2019-09-12 12:50:50.952633051 +0300
	-+++ b/quazip/unzip.h 2019-09-11 18:01:04.066678712 +0300
	-@@ -60,12 +60,6 @@
	- #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 /

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 11, 10:31 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 127176

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions