Version 2.3.0.

Add back auto detection of zip64. #258
Simplification & fixed formatting. #258
2018-05-03 17:59:04 -07:00 · 2018-05-03 17:57:20 -07:00 · 2018-05-03 17:24:32 -07:00 · 2018-05-03 09:35:37 -07:00 · 2018-05-02 20:09:48 -07:00 · 2018-05-02 20:09:25 -07:00
46 changed files with 1131 additions and 1411 deletions
@@ -1,5 +0,0 @@
-# Xcode
-xcuserdata/
-
-# JetBrains
-.idea/
@@ -23,4 +23,4 @@ before_script:
 script:
    - make
    - cd ../test
-    - python test.py --exe_dir=../build
+    - travis_wait 30 python test.py --exe_dir=../build
@@ -19,15 +19,18 @@ if(NOT DEFINED CMAKE_MACOSX_RPATH)
    set(CMAKE_MACOSX_RPATH 0)
 endif()

-set(INSTALL_BIN_DIR "bin" CACHE PATH "Installation directory for executables")
-set(INSTALL_LIB_DIR "lib" CACHE PATH "Installation directory for libraries")
-set(INSTALL_INC_DIR "include" CACHE PATH "Installation directory for headers")
-set(INSTALL_MAN_DIR "share/man" CACHE PATH "Installation directory for manual pages")
-set(INSTALL_PKGCONFIG_DIR "share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
-
 project("minizip")

-set(VERSION "2.2.4")
+include(GNUInstallDirs)
+
+set(INSTALL_BIN_DIR ${CMAKE_INSTALL_BINDIR} CACHE PATH "Installation directory for executables")
+set(INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE PATH "Installation directory for libraries")
+set(INSTALL_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "Installation directory for headers")
+set(INSTALL_MAN_DIR ${CMAKE_INSTALL_MANDIR} CACHE PATH "Installation directory for manual pages")
+set(INSTALL_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE PATH "Installation directory for pkgconfig (.pc) files")
+set(INSTALL_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/minizip CACHE PATH "Installation directory for cmake files.")
+
+set(VERSION "2.3.0")

 # Set cmake debug postfix to d
 set(CMAKE_DEBUG_POSTFIX "d")
@@ -39,6 +42,7 @@ if(USE_ZLIB)
    if(ZLIB_FOUND)
        include_directories(${ZLIB_INCLUDE_DIRS})
    endif()
+    add_definitions(-DHAVE_ZLIB)
 endif()

 set(MINIZIP_PC ${CMAKE_CURRENT_BINARY_DIR}/minizip.pc)
@@ -47,31 +51,31 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/minizip.pc.cmakein ${MINIZIP_PC} @ONL
 set(PROJECT_NAME libminizip)

 set(MINIZIP_SRC
-    src/mz_os.c
-    src/mz_compat.c
-    src/mz_strm.c
-    src/mz_strm_buf.c
-    src/mz_strm_mem.c
-    src/mz_strm_posix.c
-    src/mz_strm_split.c
-    src/mz_strm_zlib.c
-    src/mz_zip.c)
+    mz_os.c
+    mz_compat.c
+    mz_strm.c
+    mz_strm_buf.c
+    mz_strm_mem.c
+    mz_strm_posix.c
+    mz_strm_split.c
+    mz_strm_zlib.c
+    mz_zip.c)

 set(MINIZIP_PUBLIC_HEADERS
-    src/mz.h
-    src/mz_os.h
-    src/mz_compat.h
-    src/mz_strm.h
-    src/mz_strm_buf.h
-    src/mz_strm_mem.h
-    src/mz_strm_posix.h
-    src/mz_strm_split.h
-    src/mz_strm_zlib.h
-    src/mz_zip.h)
+    mz.h
+    mz_os.h
+    mz_compat.h
+    mz_strm.h
+    mz_strm_buf.h
+    mz_strm_mem.h
+    mz_strm_posix.h
+    mz_strm_split.h
+    mz_strm_zlib.h
+    mz_zip.h)

 if(WIN32)
-    list(APPEND MINIZIP_SRC "src/mz_os_win32.c" "src/mz_strm_win32.c")
-    list(APPEND MINIZIP_PUBLIC_HEADERS "src/mz_os_win32.h" "src/mz_strm_win32.h")
+    list(APPEND MINIZIP_SRC "mz_os_win32.c" "mz_strm_win32.c")
+    list(APPEND MINIZIP_PUBLIC_HEADERS "mz_os_win32.h" "mz_strm_win32.h")

    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
 endif()
@@ -81,49 +85,61 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
 endif()

 if(UNIX)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -O3")
+    add_compile_options(-O3)

-    list(APPEND MINIZIP_SRC "src/mz_os_posix.c")
-    list(APPEND MINIZIP_PUBLIC_HEADERS "src/mz_os_posix.h")
+    list(APPEND MINIZIP_SRC "mz_os_posix.c")
+    list(APPEND MINIZIP_PUBLIC_HEADERS "mz_os_posix.h")

-    add_definitions(-D__USE_FILE_OFFSET64)
-    add_definitions(-D__USE_LARGEFILE64)
-    add_definitions(-D_LARGEFILE64_SOURCE)
-    add_definitions(-D_FILE_OFFSET_BIT=64)
+    set(define_lfs_macros TRUE)

-    find_package(PkgConfig REQUIRED)
+    if(ANDROID)
+        string(REGEX REPLACE "android-([0-9+])" "\\1"
+            android_api "${ANDROID_PLATFORM}")
+        if(${android_api} LESS 24)
+            set(define_lfs_macros FALSE)
+        endif()
+    endif()

-    pkg_check_modules(LIBBSD libbsd)
+    if(define_lfs_macros)
+        add_definitions(-D__USE_FILE_OFFSET64)
+        add_definitions(-D__USE_LARGEFILE64)
+        add_definitions(-D_LARGEFILE64_SOURCE)
+        add_definitions(-D_FILE_OFFSET_BITS=64)
+    endif()

-    include_directories(${LIBBSD_INCLUDE_DIRS})
-    link_directories(${LIBBSD_LIBRARY_DIRS})
+    if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+        find_package(PkgConfig REQUIRED)
+
+        pkg_check_modules(LIBBSD libbsd REQUIRED)
+
+        include_directories(${LIBBSD_INCLUDE_DIRS})
+        link_directories(${LIBBSD_LIBRARY_DIRS})
+    endif()
 endif()

 if(USE_CRYPT)
    add_definitions(-DHAVE_CRYPT)

-    list(APPEND MINIZIP_SRC "src/mz_strm_crypt.c")
-    list(APPEND MINIZIP_PUBLIC_HEADERS "src/mz_strm_crypt.h")
+    list(APPEND MINIZIP_SRC "mz_strm_crypt.c")
+    list(APPEND MINIZIP_PUBLIC_HEADERS "mz_strm_crypt.h")
 endif()

 if(USE_AES)
    add_definitions(-DHAVE_AES)

-    list(APPEND MINIZIP_SRC "src/mz_strm_aes.c")
-    list(APPEND MINIZIP_PUBLIC_HEADERS "src/mz_strm_aes.h")
+    list(APPEND MINIZIP_SRC "mz_strm_aes.c")
+    list(APPEND MINIZIP_PUBLIC_HEADERS "mz_strm_aes.h")

    set(AES_SRC
        lib/aes/aescrypt.c
        lib/aes/aeskey.c
        lib/aes/aestab.c
-        lib/aes/aes_ni.c
        lib/aes/hmac.c
        lib/aes/pwd2key.c
        lib/aes/sha1.c)

    set(AES_PUBLIC_HEADERS
        lib/aes/aes.h
-        lib/aes/aes_ni.h
        lib/aes/aesopt.h
        lib/aes/aestab.h
        lib/aes/brg_endian.h
@@ -139,13 +155,22 @@ endif()

 if(USE_ZLIB)
    add_definitions(-DHAVE_ZLIB)
+
+    include(CheckFunctionExists)
+    set(CMAKE_REQUIRED_LIBRARIES ZLIB::ZLIB)
+    CHECK_FUNCTION_EXISTS(z_get_crc_table
+        NEEDS_Z_PREFIX)
+
+    if(NEEDS_Z_PREFIX)
+        add_definitions(-DZ_PREFIX)
+    endif()
 endif()
 if(USE_BZIP2)
    add_definitions(-DHAVE_BZIP2)
    add_definitions(-DBZ_NO_STDIO)

-    list(APPEND MINIZIP_SRC "src/mz_strm_bzip.c")
-    list(APPEND MINIZIP_PUBLIC_HEADERS "src/mz_strm_bzip.h")
+    list(APPEND MINIZIP_SRC "mz_strm_bzip.c")
+    list(APPEND MINIZIP_PUBLIC_HEADERS "mz_strm_bzip.h")

    set(BZIP2_SRC
        lib/bzip2/blocksort.c
@@ -170,8 +195,8 @@ if(USE_LZMA)
    add_definitions(-DHAVE_CONFIG_H)
    add_definitions(-DLZMA_API_STATIC)

-    list(APPEND MINIZIP_SRC "src/mz_strm_lzma.c")
-    list(APPEND MINIZIP_PUBLIC_HEADERS "src/mz_strm_lzma.h")
+    list(APPEND MINIZIP_SRC "mz_strm_lzma.c")
+    list(APPEND MINIZIP_PUBLIC_HEADERS "mz_strm_lzma.h")

    set(LZMA_CHECK_SRC
        lib/liblzma/check/check.c
@@ -273,8 +298,19 @@ if(USE_LZMA)
    source_group("LZMA\\RangeCoder" FILES ${LZMA_RANGECODER_SRC} ${LZMA_RANGECODER_HEADERS})
 endif()

+# Enable x86 optimizations if supported
 if(CMAKE_C_COMPILER MATCHES ".*clang")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse3 -msse4.1 -maes")
+    include(CheckCCompilerFlag)
+    macro(enable_option_if_supported option variable)
+        check_c_compiler_flag("-Werror=unused-command-line-argument ${option}" ${variable})
+        if(${variable})
+            add_compile_options(${option})
+        endif()
+    endmacro()
+
+    enable_option_if_supported(-msse3 check_opt_sse3)
+    enable_option_if_supported(-msse4.1 check_opt_sse41)
+    enable_option_if_supported(-maes check_opt_aes)
 endif()

 # Create minizip library
@@ -286,7 +322,12 @@ add_library(${PROJECT_NAME}
                ${BZIP2_SRC} ${BZIP2_PUBLIC_HEADERS}
                ${LZMA_SRC} ${LZMA_PUBLIC_HEADERS})

-set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C PREFIX "")
+if (MINGW AND BUILD_SHARED_LIBS)
+  set_target_properties(${PROJECT_NAME} PROPERTIES ARCHIVE_OUTPUT_NAME "minizip")
+endif ()
+
+set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C PREFIX ""
+                      POSITION_INDEPENDENT_CODE 1)
 if(USE_ZLIB)
    target_link_libraries(${PROJECT_NAME} ZLIB::ZLIB)
 endif()
@@ -306,14 +347,14 @@ install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}
        LIBRARY DESTINATION "${INSTALL_LIB_DIR}")

 install(EXPORT ${PROJECT_NAME}
-        DESTINATION "cmake"
+        DESTINATION "${INSTALL_CMAKE_DIR}"
        NAMESPACE "MINIZIP::")

 install(FILES ${MINIZIP_PUBLIC_HEADERS} DESTINATION "${INSTALL_INC_DIR}")
 install(FILES ${MINIZIP_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")

 if(BUILD_TEST)
-    add_executable(minizip "src/minizip.c")
+    add_executable(minizip "minizip.c")
    target_link_libraries(minizip ${PROJECT_NAME})

    install(TARGETS minizip
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
  s.name     = 'Minizip'
-  s.version  = '2.2.4'
+  s.version  = '2.3.0'
  s.license  = 'zlib'
  s.summary  = 'Minizip contrib in zlib with the latest bug fixes and advanced features'
  s.description = <<-DESC
@@ -17,7 +17,7 @@ DESC
  s.libraries = 'z'

  s.subspec 'Core' do |sp|
-    sp.source_files = 'src/{mz_os,mz_compat,mz_strm,mz_strm_mem,mz_strm_buf,mz_zip,mz_strm_crypt,mz_strm_posix,mz_strm_zlib}.{c,h}'
+    sp.source_files = '{mz_os,mz_compat,mz_strm,mz_strm_mem,mz_strm_buf,mz_zip,mz_strm_crypt,mz_strm_posix,mz_strm_zlib}.{c,h}'
  end

  s.subspec 'AES' do |sp|
@@ -1,6 +1,6 @@
-# Minizip 2.2.4
+# Minizip 2.3.0

-This library is a refactoring of the minizip contribution found in the zlib distribution that is supported on Windows, macOS, and Linux. The motivation for this work has been the inclusion of advanced features, improvements in code maintainability and readability, and the reduction of duplicate code. It is based on the original work of [Gilles Vollant](http://www.winimage.com/zLibDll/minizip.html) that has been contributed to by many people over the years.
+This library is a refactoring of the minizip contribution found in the zlib distribution and is supported on Windows, macOS, and Linux. The motivation for this work has been the inclusion of advanced features, improvements in code maintainability and readability, and the reduction of duplicate code. It is based on the original work of [Gilles Vollant](http://www.winimage.com/zLibDll/minizip.html) that has been contributed to by many people over the years.

 Dev: ![Dev Branch Status](https://travis-ci.org/nmoinvaz/minizip.svg?branch=dev)
 Master: ![Master Branch Status](https://travis-ci.org/nmoinvaz/minizip.svg?branch=master)
@@ -30,12 +30,12 @@ cmake --build .
 | mz_strm_buf.\* | Buffered stream | No |
 | mz_strm_bzip.\* | BZIP2 stream using libbzip2 | No |
 | mz_strm_crypt.\* | PKWARE traditional encryption stream | No |
-| mz_strm_lzma.\* | LZMA stream using liblzma | No |
+| mz_strm_lzma.\* | LZMA stream using liblzma | zlib or liblzma |
 | mz_strm_mem.\* | Memory stream | Yes |
 | mz_strm_split.\* | Disk splitting stream | No |
 | mz_strm_posix.\* | File stream using Posix functions | Non-windows systems |
 | mz_strm_win32.\* | File stream using Win32 API functions | Windows systems |
-| mz_strm_zlib.\* | Deflate stream using zlib | Yes |
+| mz_strm_zlib.\* | Deflate stream using zlib | zlib or liblzma |
 | mz_zip.\* | Zip functionality | Yes |

 ## Features
@@ -54,10 +54,10 @@ cmake --build .

 ### Encryption

-#### [WinZIP AES Encryption](http://www.winzip.com/aes_info.htm)
+#### [WinZIP AES Encryption](https://www.winzip.com/aes_info.htm)

 + Requires ``cmake . -DUSE_AES=ON`` or ``#define HAVE_AES``
-+ Requires [Brian Gladman's](https://github.com/BrianGladman/aes) AES library
+ Requires Brian Gladman's [AES](https://github.com/BrianGladman/aes) and [SHA](https://github.com/BrianGladman/sha) libraries

 When zipping with a password it will always use AES 256-bit encryption.
 When unzipping it will use AES decryption only if necessary.
@@ -81,7 +81,7 @@ This library has been refactored around streams.

 #### Memory Streaming

-To unzip from a zip file in memory create a memory stream and pass it to the unzip open functions.
+To unzip from a zip file in memory pass the memory stream to the open function.
 ```
 uint8_t *zip_buffer = NULL;
 int32_t zip_buffer_size = 0;
@@ -98,7 +98,7 @@ void *zip_handle = mz_zip_open(mem_stream, MZ_OPEN_MODE_READ);
 mz_stream_mem_delete(&mem_stream);
 ```

-To create a zip file in memory first create a growable memory stream and pass it to the zip open functions.
+To create a zip file in memory first create a growable memory stream and pass it to the open function.

 ```
 void *mem_stream = NULL;
@@ -135,7 +135,7 @@ void *zip_handle = mz_zip_open(buf_stream, MZ_OPEN_MODE_READ);

 #### Disk Splitting Stream

-To create an archive with multiple disks use the disk splitting stream and for zipping supply a disk size value in bytes.
+To create an archive with multiple disks use the disk splitting stream and supply a disk size value in bytes.

 ```
 void *stream = NULL;
@@ -150,13 +150,9 @@ mz_stream_set_base(split_stream, stream);

 mz_stream_open(split_stream, path..

-handle = mz_zip_open(split_stream, MZ_OPEN_MODE_WRITE);
+void *zip_handle = mz_zip_open(split_stream, MZ_OPEN_MODE_WRITE);
 ```

-The central directory is the only data stored in the .zip and doesn't follow disk size restrictions.
-
-When unzipping it will automatically determine when in needs to cross disk boundaries.
-
 ### Windows RT

 + Requires ``#define MZ_USE_WINRT_API``
@@ -166,3 +162,4 @@ When unzipping it will automatically determine when in needs to cross disk bound
 + Archives are required to have a central directory.
 + Central directory header values should be correct and it is necessary for the compressed size to be accurate for AES encryption.
 + Central directory encryption is not supported due to licensing restrictions mentioned by PKWARE in their zip appnote.
+ Central directory is the only data stored on the last disk of a split-disk archive and doesn't follow disk size restrictions.
@@ -1,687 +0,0 @@
-/*
-Copyright (c) 1998-2013, Brian Gladman, Worcester, UK. All rights reserved.
-
-The redistribution and use of this software (with or without changes)
-is allowed without the payment of fees or royalties provided that:
-
-  source code distributions include the above copyright notice, this
-  list of conditions and the following disclaimer;
-
-  binary distributions include the above copyright notice, this list
-  of conditions and the following disclaimer in their documentation.
-
-This software is provided 'as is' with no explicit or implied warranties
-in respect of its operation, including, but not limited to, correctness
-and fitness for purpose.
---------------------------------------------------------------------------
-Issue Date: 09/09/2014
-*/
-
-#include "aes_ni.h"
-
-#if defined( USE_INTEL_AES_IF_PRESENT )
-
-#if defined(_MSC_VER)
-
-#include <intrin.h>
-#pragma intrinsic(__cpuid)
-#define INLINE  __inline
-
-INLINE int has_aes_ni(void)
-{
-	static int test = -1;
-	if(test < 0)
-	{
-        int cpu_info[4];
-        __cpuid(cpu_info, 1);
-		test = cpu_info[2] & 0x02000000;
-	}
-	return test;
-}
-
-#elif defined( __GNUC__ )
-
-#include <cpuid.h>
-
-#if !defined(__clang__)
-#pragma GCC target ("ssse3")
-#pragma GCC target ("sse4.1")
-#pragma GCC target ("aes")
-#endif
-
-#include <x86intrin.h>
-#define INLINE  static __inline
-
-INLINE int has_aes_ni()
-{
-    static int test = -1;
-    if(test < 0)
-    {
-        unsigned int a, b, c, d;
-        if(!__get_cpuid(1, &a, &b, &c, &d))
-            test = 0;
-        else
-            test = (c & 0x2000000);
-    }
-    return test;
-}
-
-#else
-#error AES New Instructions require Microsoft, Intel, GNU C, or CLANG
-#endif
-
-INLINE __m128i aes_128_assist(__m128i t1, __m128i t2)
-{
-	__m128i t3;
-	t2 = _mm_shuffle_epi32(t2, 0xff);
-	t3 = _mm_slli_si128(t1, 0x4);
-	t1 = _mm_xor_si128(t1, t3);
-	t3 = _mm_slli_si128(t3, 0x4);
-	t1 = _mm_xor_si128(t1, t3);
-	t3 = _mm_slli_si128(t3, 0x4);
-	t1 = _mm_xor_si128(t1, t3);
-	t1 = _mm_xor_si128(t1, t2);
-	return t1;
-}
-
-AES_RETURN aes_ni(encrypt_key128)(const unsigned char *key, aes_encrypt_ctx cx[1])
-{
-	__m128i t1, t2;
-	__m128i *ks = (__m128i*)cx->ks;
-
-	if(!has_aes_ni())
-	{
-		return aes_xi(encrypt_key128)(key, cx);
-	}
-
-	t1 = _mm_loadu_si128((__m128i*)key);
-
-	ks[0] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x1);
-	t1 = aes_128_assist(t1, t2);
-	ks[1] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x2);
-	t1 = aes_128_assist(t1, t2);
-	ks[2] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x4);
-	t1 = aes_128_assist(t1, t2);
-	ks[3] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x8);
-	t1 = aes_128_assist(t1, t2);
-	ks[4] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x10);
-	t1 = aes_128_assist(t1, t2);
-	ks[5] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x20);
-	t1 = aes_128_assist(t1, t2);
-	ks[6] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x40);
-	t1 = aes_128_assist(t1, t2);
-	ks[7] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x80);
-	t1 = aes_128_assist(t1, t2);
-	ks[8] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x1b);
-	t1 = aes_128_assist(t1, t2);
-	ks[9] = t1;
-
-	t2 = _mm_aeskeygenassist_si128(t1, 0x36);
-	t1 = aes_128_assist(t1, t2);
-	ks[10] = t1;
-
-	cx->inf.l = 0;
-	cx->inf.b[0] = 10 * 16;
-	return EXIT_SUCCESS;
-}
-
-INLINE void aes_192_assist(__m128i* t1, __m128i * t2, __m128i * t3)
-{
-	__m128i t4;
-	*t2 = _mm_shuffle_epi32(*t2, 0x55);
-	t4 = _mm_slli_si128(*t1, 0x4);
-	*t1 = _mm_xor_si128(*t1, t4);
-	t4 = _mm_slli_si128(t4, 0x4);
-	*t1 = _mm_xor_si128(*t1, t4);
-	t4 = _mm_slli_si128(t4, 0x4);
-	*t1 = _mm_xor_si128(*t1, t4);
-	*t1 = _mm_xor_si128(*t1, *t2);
-	*t2 = _mm_shuffle_epi32(*t1, 0xff);
-	t4 = _mm_slli_si128(*t3, 0x4);
-	*t3 = _mm_xor_si128(*t3, t4);
-	*t3 = _mm_xor_si128(*t3, *t2);
-}
-
-AES_RETURN aes_ni(encrypt_key192)(const unsigned char *key, aes_encrypt_ctx cx[1])
-{
-	__m128i t1, t2, t3;
-	__m128i *ks = (__m128i*)cx->ks;
-
-	if(!has_aes_ni())
-	{
-		return aes_xi(encrypt_key192)(key, cx);
-	}
-
-	t1 = _mm_loadu_si128((__m128i*)key);
-	t3 = _mm_loadu_si128((__m128i*)(key + 16));
-
-	ks[0] = t1;
-	ks[1] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x1);
-	aes_192_assist(&t1, &t2, &t3);
-
-	ks[1] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(ks[1]), _mm_castsi128_pd(t1), 0));
-	ks[2] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(t1), _mm_castsi128_pd(t3), 1));
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x2);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[3] = t1;
-	ks[4] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x4);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[4] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(ks[4]), _mm_castsi128_pd(t1), 0));
-	ks[5] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(t1), _mm_castsi128_pd(t3), 1));
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x8);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[6] = t1;
-	ks[7] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x10);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[7] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(ks[7]), _mm_castsi128_pd(t1), 0));
-	ks[8] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(t1), _mm_castsi128_pd(t3), 1));
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x20);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[9] = t1;
-	ks[10] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x40);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[10] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(ks[10]), _mm_castsi128_pd(t1), 0));
-	ks[11] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(t1), _mm_castsi128_pd(t3), 1));
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x80);
-	aes_192_assist(&t1, &t2, &t3);
-	ks[12] = t1;
-
-	cx->inf.l = 0;
-	cx->inf.b[0] = 12 * 16;
-	return EXIT_SUCCESS;
-}
-
-INLINE void aes_256_assist1(__m128i* t1, __m128i * t2)
-{
-	__m128i t4;
-	*t2 = _mm_shuffle_epi32(*t2, 0xff);
-	t4 = _mm_slli_si128(*t1, 0x4);
-	*t1 = _mm_xor_si128(*t1, t4);
-	t4 = _mm_slli_si128(t4, 0x4);
-	*t1 = _mm_xor_si128(*t1, t4);
-	t4 = _mm_slli_si128(t4, 0x4);
-	*t1 = _mm_xor_si128(*t1, t4);
-	*t1 = _mm_xor_si128(*t1, *t2);
-}
-
-INLINE void aes_256_assist2(__m128i* t1, __m128i * t3)
-{
-	__m128i t2, t4;
-	t4 = _mm_aeskeygenassist_si128(*t1, 0x0);
-	t2 = _mm_shuffle_epi32(t4, 0xaa);
-	t4 = _mm_slli_si128(*t3, 0x4);
-	*t3 = _mm_xor_si128(*t3, t4);
-	t4 = _mm_slli_si128(t4, 0x4);
-	*t3 = _mm_xor_si128(*t3, t4);
-	t4 = _mm_slli_si128(t4, 0x4);
-	*t3 = _mm_xor_si128(*t3, t4);
-	*t3 = _mm_xor_si128(*t3, t2);
-}
-
-AES_RETURN aes_ni(encrypt_key256)(const unsigned char *key, aes_encrypt_ctx cx[1])
-{
-	__m128i t1, t2, t3;
-	__m128i *ks = (__m128i*)cx->ks;
-
-	if(!has_aes_ni())
-	{
-		return aes_xi(encrypt_key256)(key, cx);
-	}
-
-	t1 = _mm_loadu_si128((__m128i*)key);
-	t3 = _mm_loadu_si128((__m128i*)(key + 16));
-
-	ks[0] = t1;
-	ks[1] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x01);
-	aes_256_assist1(&t1, &t2);
-	ks[2] = t1;
-	aes_256_assist2(&t1, &t3);
-	ks[3] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x02);
-	aes_256_assist1(&t1, &t2);
-	ks[4] = t1;
-	aes_256_assist2(&t1, &t3);
-	ks[5] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x04);
-	aes_256_assist1(&t1, &t2);
-	ks[6] = t1;
-	aes_256_assist2(&t1, &t3);
-	ks[7] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x08);
-	aes_256_assist1(&t1, &t2);
-	ks[8] = t1;
-	aes_256_assist2(&t1, &t3);
-	ks[9] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x10);
-	aes_256_assist1(&t1, &t2);
-	ks[10] = t1;
-	aes_256_assist2(&t1, &t3);
-	ks[11] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x20);
-	aes_256_assist1(&t1, &t2);
-	ks[12] = t1;
-	aes_256_assist2(&t1, &t3);
-	ks[13] = t3;
-
-	t2 = _mm_aeskeygenassist_si128(t3, 0x40);
-	aes_256_assist1(&t1, &t2);
-	ks[14] = t1;
-
-	cx->inf.l = 0;
-	cx->inf.b[0] = 14 * 16;
-	return EXIT_SUCCESS;
-}
-
-INLINE void enc_to_dec(aes_decrypt_ctx cx[1])
-{
-	__m128i *ks = (__m128i*)cx->ks;
-	int j;
-
-	for( j = 1 ; j < (cx->inf.b[0] >> 4) ; ++j )
-		ks[j] = _mm_aesimc_si128(ks[j]);
-}
-
-AES_RETURN aes_ni(decrypt_key128)(const unsigned char *key, aes_decrypt_ctx cx[1])
-{
-	if(!has_aes_ni())
-	{
-		return aes_xi(decrypt_key128)(key, cx);
-	}
-
-	if(aes_ni(encrypt_key128)(key, (aes_encrypt_ctx*)cx) == EXIT_SUCCESS)
-	{
-		enc_to_dec(cx);
-		return EXIT_SUCCESS;
-	}
-	else
-		return EXIT_FAILURE;
-
-}
-
-AES_RETURN aes_ni(decrypt_key192)(const unsigned char *key, aes_decrypt_ctx cx[1])
-{
-	if(!has_aes_ni())
-	{
-		return aes_xi(decrypt_key192)(key, cx);
-	}
-
-	if(aes_ni(encrypt_key192)(key, (aes_encrypt_ctx*)cx) == EXIT_SUCCESS)
-	{
-		enc_to_dec(cx);
-		return EXIT_SUCCESS;
-	}
-	else
-		return EXIT_FAILURE;
-}
-
-AES_RETURN aes_ni(decrypt_key256)(const unsigned char *key, aes_decrypt_ctx cx[1])
-{
-	if(!has_aes_ni())
-	{
-		return aes_xi(decrypt_key256)(key, cx);
-	}
-
-	if(aes_ni(encrypt_key256)(key, (aes_encrypt_ctx*)cx) == EXIT_SUCCESS)
-	{
-		enc_to_dec(cx);
-		return EXIT_SUCCESS;
-	}
-	else
-		return EXIT_FAILURE;
-}
-
-AES_RETURN aes_ni(encrypt)(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1])
-{
-	__m128i *key = (__m128i*)cx->ks, t;
-
-	if(cx->inf.b[0] != 10 * 16 && cx->inf.b[0] != 12 * 16 && cx->inf.b[0] != 14 * 16)
-		return EXIT_FAILURE;
-
-	if(!has_aes_ni())
-	{
-		return aes_xi(encrypt)(in, out, cx);
-	}
-
-	t = _mm_xor_si128(_mm_loadu_si128((__m128i*)in), *(__m128i*)key);
-
-	switch(cx->inf.b[0])
-	{
-	case 14 * 16:
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-	case 12 * 16:
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-	case 10 * 16:
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenc_si128(t, *(__m128i*)++key);
-		t = _mm_aesenclast_si128(t, *(__m128i*)++key);
-	}
-
-	_mm_storeu_si128(&((__m128i*)out)[0], t);
-	return EXIT_SUCCESS;
-}
-
-AES_RETURN aes_ni(decrypt)(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1])
-{
-	__m128i *key = (__m128i*)cx->ks + (cx->inf.b[0] >> 4), t;
-
-	if(cx->inf.b[0] != 10 * 16 && cx->inf.b[0] != 12 * 16 && cx->inf.b[0] != 14 * 16)
-		return EXIT_FAILURE;
-
-	if(!has_aes_ni())
-	{
-		return aes_xi(decrypt)(in, out, cx);
-	}
-
-	t = _mm_xor_si128(_mm_loadu_si128((__m128i*)in), *(__m128i*)key);
-
-	switch(cx->inf.b[0])
-	{
-	case 14 * 16:
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-	case 12 * 16:
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-	case 10 * 16:
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdec_si128(t, *(__m128i*)--key);
-		t = _mm_aesdeclast_si128(t, *(__m128i*)--key);
-	}
-
-	_mm_storeu_si128((__m128i*)out, t);
-	return EXIT_SUCCESS;
-}
-
-#ifdef ADD_AESNI_MODE_CALLS
-#ifdef USE_AES_CONTEXT
-
-AES_RETURN aes_CBC_encrypt(const unsigned char *in,
-	unsigned char *out,
-	unsigned char ivec[16],
-	unsigned long length,
-    const aes_encrypt_ctx cx[1])
-{
-	__m128i feedback, data, *key = (__m128i*)cx->ks;
-	int number_of_rounds = cx->inf.b[0] >> 4, j;
-    unsigned long i;
-    
-    if(number_of_rounds != 10 && number_of_rounds != 12 && number_of_rounds != 14)
-        return EXIT_FAILURE;
-
-    if(!has_aes_ni())
-    {
-        return aes_cbc_encrypt(in, out, length, ivec, cx);
-    }
-
-    if(length % 16)
-		length = length / 16 + 1;
-	else length /= 16;
-	feedback = _mm_loadu_si128((__m128i*)ivec);
-	for(i = 0; i < length; i++)
-	{
-		data = _mm_loadu_si128(&((__m128i*)in)[i]);
-		feedback = _mm_xor_si128(data, feedback);
-		feedback = _mm_xor_si128(feedback, ((__m128i*)key)[0]);
-		for(j = 1; j <number_of_rounds; j++)
-			feedback = _mm_aesenc_si128(feedback, ((__m128i*)key)[j]);
-		feedback = _mm_aesenclast_si128(feedback, ((__m128i*)key)[j]);
-		_mm_storeu_si128(&((__m128i*)out)[i], feedback);
-	}
-    return EXIT_SUCCESS;
-}
-
-AES_RETURN aes_CBC_decrypt(const unsigned char *in,
-    unsigned char *out,
-    unsigned char ivec[16],
-    unsigned long length,
-    const aes_decrypt_ctx cx[1])
-{
-    __m128i data, feedback, last_in, *key = (__m128i*)cx->ks;
-    int number_of_rounds = cx->inf.b[0] >> 4, j;
-    unsigned long i;
-
-    if(number_of_rounds != 10 && number_of_rounds != 12 && number_of_rounds != 14)
-        return EXIT_FAILURE;
-
-    if(!has_aes_ni())
-    {
-        return aes_cbc_decrypt(in, out, length, ivec, cx);
-    }
-
-    if(length % 16)
-        length = length / 16 + 1;
-    else length /= 16;
-    feedback = _mm_loadu_si128((__m128i*)ivec);
-    for(i = 0; i < length; i++)
-    {
-        last_in = _mm_loadu_si128(&((__m128i*)in)[i]);
-        data = _mm_xor_si128(last_in, ((__m128i*)key)[number_of_rounds]);
-        for(j = number_of_rounds - 1; j > 0; j--)
-        {
-            data = _mm_aesdec_si128(data, ((__m128i*)key)[j]);
-        }
-        data = _mm_aesdeclast_si128(data, ((__m128i*)key)[0]);
-        data = _mm_xor_si128(data, feedback);
-        _mm_storeu_si128(&((__m128i*)out)[i], data);
-        feedback = last_in;
-    }
-    return EXIT_SUCCESS;
-}
-
-static void ctr_inc(unsigned char *ctr_blk)
-{
-    uint32_t c;
-
-    c = *(uint32_t*)(ctr_blk + 8);
-    c++;
-    *(uint32_t*)(ctr_blk + 8) = c;
-
-    if(!c)
-        *(uint32_t*)(ctr_blk + 12) = *(uint32_t*)(ctr_blk + 12) + 1;
-}
-
-AES_RETURN AES_CTR_encrypt(const unsigned char *in,
-    unsigned char *out,
-    const unsigned char ivec[8],
-    const unsigned char nonce[4],
-    unsigned long length,
-    const aes_encrypt_ctx cx[1])
-{
-    __m128i ctr_block = { 0 }, *key = (__m128i*)cx->ks, tmp, ONE, BSWAP_EPI64;
-    int number_of_rounds = cx->inf.b[0] >> 4, j;
-    unsigned long i;
-
-    if(number_of_rounds != 10 && number_of_rounds != 12 && number_of_rounds != 14)
-        return EXIT_FAILURE;
-
-    if(!has_aes_ni())
-    {
-        unsigned char ctr_blk[16];
-        *(uint64_t*)ctr_blk = *(uint64_t*)ivec;
-        *(uint32_t*)(ctr_blk + 8) = *(uint32_t*)nonce;
-        return aes_ctr_crypt(in, out, length, (unsigned char*)ctr_blk, ctr_inc, cx);
-    }
-
-    if(length % 16)
-        length = length / 16 + 1;
-    else length /= 16;
-    ONE = _mm_set_epi32(0, 1, 0, 0);
-    BSWAP_EPI64 = _mm_setr_epi8(7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
-#ifdef _MSC_VER
-    ctr_block = _mm_insert_epi64(ctr_block, *(long long*)ivec, 1);
-#else
-    ctr_block = _mm_set_epi64(*(__m64*)ivec, *(__m64*)&ctr_block);
-#endif
-    ctr_block = _mm_insert_epi32(ctr_block, *(long*)nonce, 1);
-    ctr_block = _mm_srli_si128(ctr_block, 4);
-    ctr_block = _mm_shuffle_epi8(ctr_block, BSWAP_EPI64);
-    ctr_block = _mm_add_epi64(ctr_block, ONE);
-    for(i = 0; i < length; i++)
-    {
-        tmp = _mm_shuffle_epi8(ctr_block, BSWAP_EPI64);
-        ctr_block = _mm_add_epi64(ctr_block, ONE);
-        tmp = _mm_xor_si128(tmp, ((__m128i*)key)[0]);
-        for(j = 1; j <number_of_rounds; j++)
-        {
-            tmp = _mm_aesenc_si128(tmp, ((__m128i*)key)[j]);
-        };
-        tmp = _mm_aesenclast_si128(tmp, ((__m128i*)key)[j]);
-        tmp = _mm_xor_si128(tmp, _mm_loadu_si128(&((__m128i*)in)[i]));
-        _mm_storeu_si128(&((__m128i*)out)[i], tmp);
-    }
-    return EXIT_SUCCESS;
-}
-
-#else
-
-void aes_CBC_encrypt(const unsigned char *in,
-    unsigned char *out,
-    unsigned char ivec[16],
-    unsigned long length,
-    unsigned char *key,
-    int number_of_rounds)
-{
-    __m128i feedback, data;
-    unsigned long i;
-    int j;
-    if(length % 16)
-        length = length / 16 + 1;
-    else length /= 16;
-    feedback = _mm_loadu_si128((__m128i*)ivec);
-    for(i = 0; i < length; i++)
-    {
-        data = _mm_loadu_si128(&((__m128i*)in)[i]);
-        feedback = _mm_xor_si128(data, feedback);
-        feedback = _mm_xor_si128(feedback, ((__m128i*)key)[0]);
-        for(j = 1; j <number_of_rounds; j++)
-            feedback = _mm_aesenc_si128(feedback, ((__m128i*)key)[j]);
-        feedback = _mm_aesenclast_si128(feedback, ((__m128i*)key)[j]);
-        _mm_storeu_si128(&((__m128i*)out)[i], feedback);
-    }
-}
-
-void aes_CBC_decrypt(const unsigned char *in,
-	unsigned char *out,
-	unsigned char ivec[16],
-	unsigned long length,
-	unsigned char *key,
-	int number_of_rounds)
-{
-	__m128i data, feedback, last_in;
-	unsigned long i;
-	int j;
-	if(length % 16)
-		length = length / 16 + 1;
-	else length /= 16;
-	feedback = _mm_loadu_si128((__m128i*)ivec);
-	for(i = 0; i < length; i++)
-	{
-		last_in = _mm_loadu_si128(&((__m128i*)in)[i]);
-		data = _mm_xor_si128(last_in, ((__m128i*)key)[0]);
-		for(j = 1; j <number_of_rounds; j++)
-		{
-			data = _mm_aesdec_si128(data, ((__m128i*)key)[j]);
-		}
-		data = _mm_aesdeclast_si128(data, ((__m128i*)key)[j]);
-		data = _mm_xor_si128(data, feedback);
-		_mm_storeu_si128(&((__m128i*)out)[i], data);
-		feedback = last_in;
-	}
-}
-
-void AES_CTR_encrypt(const unsigned char *in,
-	unsigned char *out,
-	const unsigned char ivec[8],
-	const unsigned char nonce[4],
-	unsigned long length,
-	const unsigned char *key,
-	int number_of_rounds)
-{
-	__m128i ctr_block = { 0 }, tmp, ONE, BSWAP_EPI64;
-	unsigned long i;
-	int j;
-	if(length % 16)
-		length = length / 16 + 1;
-	else length /= 16;
-	ONE = _mm_set_epi32(0, 1, 0, 0);
-	BSWAP_EPI64 = _mm_setr_epi8(7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
-#ifdef _MSC_VER
-	ctr_block = _mm_insert_epi64(ctr_block, *(long long*)ivec, 1);
-#else
-	ctr_block = _mm_set_epi64(*(__m64*)ivec, *(__m64*)&ctr_block);
-#endif
-	ctr_block = _mm_insert_epi32(ctr_block, *(long*)nonce, 1);
-	ctr_block = _mm_srli_si128(ctr_block, 4);
-	ctr_block = _mm_shuffle_epi8(ctr_block, BSWAP_EPI64);
-	ctr_block = _mm_add_epi64(ctr_block, ONE);
-	for(i = 0; i < length; i++)
-	{
-		tmp = _mm_shuffle_epi8(ctr_block, BSWAP_EPI64);
-		ctr_block = _mm_add_epi64(ctr_block, ONE);
-		tmp = _mm_xor_si128(tmp, ((__m128i*)key)[0]);
-		for(j = 1; j <number_of_rounds; j++)
-		{
-			tmp = _mm_aesenc_si128(tmp, ((__m128i*)key)[j]);
-		};
-		tmp = _mm_aesenclast_si128(tmp, ((__m128i*)key)[j]);
-		tmp = _mm_xor_si128(tmp, _mm_loadu_si128(&((__m128i*)in)[i]));
-		_mm_storeu_si128(&((__m128i*)out)[i], tmp);
-	}
-}
-#endif
-#endif
-
-#endif
@@ -1,59 +0,0 @@
-/*
-Copyright (c) 1998-2013, Brian Gladman, Worcester, UK. All rights reserved.
-
-The redistribution and use of this software (with or without changes)
-is allowed without the payment of fees or royalties provided that:
-
-  source code distributions include the above copyright notice, this
-  list of conditions and the following disclaimer;
-
-  binary distributions include the above copyright notice, this list
-  of conditions and the following disclaimer in their documentation.
-
-This software is provided 'as is' with no explicit or implied warranties
-in respect of its operation, including, but not limited to, correctness
-and fitness for purpose.
---------------------------------------------------------------------------
-Issue Date: 13/11/2013
-*/
-
-#ifndef AES_NI_H
-#define AES_NI_H
-
-#define USE_AES_CONTEXT
-
-#include "aesopt.h"
-
-#if defined( USE_INTEL_AES_IF_PRESENT )
-
-/* map names in C code to make them internal ('name' -> 'aes_name_i') */
-#define aes_xi(x) aes_ ## x ## _i
-
-/* map names here to provide the external API ('name' -> 'aes_name') */
-#define aes_ni(x) aes_ ## x
-
-AES_RETURN aes_ni(encrypt_key128)(const unsigned char *key, aes_encrypt_ctx cx[1]);
-AES_RETURN aes_ni(encrypt_key192)(const unsigned char *key, aes_encrypt_ctx cx[1]);
-AES_RETURN aes_ni(encrypt_key256)(const unsigned char *key, aes_encrypt_ctx cx[1]);
-
-AES_RETURN aes_ni(decrypt_key128)(const unsigned char *key, aes_decrypt_ctx cx[1]);
-AES_RETURN aes_ni(decrypt_key192)(const unsigned char *key, aes_decrypt_ctx cx[1]);
-AES_RETURN aes_ni(decrypt_key256)(const unsigned char *key, aes_decrypt_ctx cx[1]);
-
-AES_RETURN aes_ni(encrypt)(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1]);
-AES_RETURN aes_ni(decrypt)(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1]);
-
-AES_RETURN aes_xi(encrypt_key128)(const unsigned char *key, aes_encrypt_ctx cx[1]);
-AES_RETURN aes_xi(encrypt_key192)(const unsigned char *key, aes_encrypt_ctx cx[1]);
-AES_RETURN aes_xi(encrypt_key256)(const unsigned char *key, aes_encrypt_ctx cx[1]);
-
-AES_RETURN aes_xi(decrypt_key128)(const unsigned char *key, aes_decrypt_ctx cx[1]);
-AES_RETURN aes_xi(decrypt_key192)(const unsigned char *key, aes_decrypt_ctx cx[1]);
-AES_RETURN aes_xi(decrypt_key256)(const unsigned char *key, aes_decrypt_ctx cx[1]);
-
-AES_RETURN aes_xi(encrypt)(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1]);
-AES_RETURN aes_xi(decrypt)(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1]);
-
-#endif
-
-#endif
@@ -188,7 +188,7 @@ Issue Date: 20/12/2007
 	built
 */

-#if 1 && defined( INTEL_AES_POSSIBLE ) && !defined( USE_INTEL_AES_IF_PRESENT )
+#if 0 && defined( INTEL_AES_POSSIBLE ) && !defined( USE_INTEL_AES_IF_PRESENT )
 #  define USE_INTEL_AES_IF_PRESENT
 #endif

@@ -23,6 +23,7 @@ a password and a salt value.

 #include <string.h>
 #include "hmac.h"
+#include "pwd2key.h"

 #if defined(__cplusplus)
 extern "C"
@@ -1,8 +1,8 @@
 /* minizip.c
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2009-2010 Mathias Svensson
     Modifications for Zip64 support
@@ -26,6 +26,7 @@
 #include "mz.h"
 #include "mz_os.h"
 #include "mz_strm.h"
+#include "mz_strm_buf.h"
 #include "mz_strm_split.h"
 #include "mz_zip.h"

@@ -45,7 +46,8 @@ void minizip_help()
           "  -d  Destination directory\n" \
           "  -o  Overwrite existing files\n" \
           "  -a  Append to existing zip file\n" \
-           "  -j  Exclude path of files\n" \
+           "  -u  Buffered reading and writing\n" \
+           "  -i  Include full path of files\n" \
           "  -0  Store only\n" \
           "  -1  Compress faster\n" \
           "  -9  Compress better\n" \
@@ -66,7 +68,7 @@ void minizip_help()
 /***************************************************************************/

 typedef struct minizip_opt_s {
-    uint8_t exclude_path;
+    uint8_t include_path;
    int16_t compress_level;
    int16_t compress_method;
    uint8_t overwrite;
@@ -77,42 +79,27 @@ typedef struct minizip_opt_s {

 /***************************************************************************/

-int32_t minizip_add_file(void *handle, const char *path, const char *password, minizip_opt *options)
+int32_t minizip_add_path(void *handle, const char *path, const char *filenameinzip, const char *password, int16_t is_dir, minizip_opt *options)
 {
-    mz_zip_file file_info = { 0 };
+    mz_zip_file file_info;
    int32_t read = 0;
    int32_t written = 0;
    int32_t err = MZ_OK;
    int32_t err_close = MZ_OK;
    void *stream = NULL;
-    const char *filenameinzip = NULL;
    char buf[INT16_MAX];


-    // Construct the filename that our file will be stored in the zip as.
-    // The path name saved, should not include a leading slash.
-    // If it did, windows/xp and dynazip couldn't read the zip file. 
+    memset(&file_info, 0, sizeof(file_info));

-    filenameinzip = path;
+    // The path name saved, should not include a leading slash.
+    // If it did, windows/xp and dynazip couldn't read the zip file.
+
+    if (filenameinzip == NULL)
+        filenameinzip = path;
    while (filenameinzip[0] == '\\' || filenameinzip[0] == '/')
        filenameinzip += 1;

-    // Should the file be stored with any path info at all?
-    if (options->exclude_path)
-    {
-        const char *match = NULL;
-        const char *last_slash = NULL;
-
-        for (match = filenameinzip; *match; match += 1)
-        {
-            if (*match == '\\' || *match == '/')
-                last_slash = match;
-        }
-
-        if (last_slash != NULL)
-            filenameinzip = last_slash + 1; // base filename follows last slash
-    }
-    
    // Get information about the file on disk so we can store it in zip
    printf("Adding: %s\n", filenameinzip);

@@ -126,8 +113,9 @@ int32_t minizip_add_file(void *handle, const char *path, const char *password, m
        file_info.aes_version = MZ_AES_VERSION;
 #endif

-    mz_os_get_file_date(path, &file_info.modified_date, &file_info.accessed_date, 
+    mz_os_get_file_date(path, &file_info.modified_date, &file_info.accessed_date,
        &file_info.creation_date);
+    mz_os_get_file_attribs(path, &file_info.external_fa);

    // Add to zip
    err = mz_zip_entry_write_open(handle, &file_info, options->compress_level, password);
@@ -137,43 +125,45 @@ int32_t minizip_add_file(void *handle, const char *path, const char *password, m
        return err;
    }

-    mz_stream_os_create(&stream);
-
-    err = mz_stream_os_open(stream, path, MZ_OPEN_MODE_READ);
-
-    if (err == MZ_OK)
+    if (!is_dir)
    {
-        // Read contents of file and write it to zip
-        do
+        mz_stream_os_create(&stream);
+
+        err = mz_stream_os_open(stream, path, MZ_OPEN_MODE_READ);
+
+        if (err == MZ_OK)
        {
-            read = mz_stream_os_read(stream, buf, sizeof(buf));
-            if (read < 0)
+            // Read contents of file and write it to zip
+            do
            {
-                err = mz_stream_os_error(stream);
-                printf("Error %d in reading %s\n", err, filenameinzip);
-                break;
-            }
-            if (read == 0)
-                break;
+                read = mz_stream_os_read(stream, buf, sizeof(buf));
+                if (read < 0)
+                {
+                    err = mz_stream_os_error(stream);
+                    printf("Error %d in reading %s\n", err, filenameinzip);
+                    break;
+                }
+                if (read == 0)
+                    break;

-            written = mz_zip_entry_write(handle, buf, read);
-            if (written != read)
-            {
-                err = mz_stream_os_error(stream);
-                printf("Error in writing %s in the zip file (%d)\n", filenameinzip, err);
-                break;
-            }
+                written = mz_zip_entry_write(handle, buf, read);
+                if (written != read)
+                {
+                    err = mz_stream_os_error(stream);
+                    printf("Error in writing %s in the zip file (%d)\n", filenameinzip, err);
+                    break;
+                }
+            } while (err == MZ_OK);
+
+            mz_stream_os_close(stream);
+        }
+        else
+        {
+            printf("Error in opening %s for reading\n", path);
        }
-        while (err == MZ_OK);

-        mz_stream_os_close(stream);
+        mz_stream_os_delete(&stream);
    }
-    else
-    {
-        printf("Error in opening %s for reading\n", path);
-    }
-
-    mz_stream_os_delete(&stream);

    err_close = mz_zip_entry_close(handle);
    if (err_close != MZ_OK)
@@ -185,16 +175,51 @@ int32_t minizip_add_file(void *handle, const char *path, const char *password, m
    return err;
 }

-int32_t minizip_add(void *handle, const char *path, const char *password, minizip_opt *options, uint8_t recursive)
+int32_t minizip_add(void *handle, const char *path, const char *root_path, const char *password, minizip_opt *options, uint8_t recursive)
 {
    DIR *dir = NULL;
    struct dirent *entry = NULL;
-    int32_t err = 0;
+    int32_t err =  MZ_OK;
+    int16_t is_dir = 0;
    char full_path[320];
+    const char *filenameinzip = path;


-    if (mz_os_is_dir(path) != MZ_OK)
-        return minizip_add_file(handle, path, password, options);
+    if (mz_os_is_dir(path) == MZ_OK)
+        is_dir = 1;
+
+    // Construct the filename that our file will be stored in the zip as
+    if (root_path == NULL)
+        root_path = path;
+
+    // Should the file be stored with any path info at all?
+    if (!options->include_path)
+    {
+        if (!is_dir && root_path == path)
+        {
+            const char *match = NULL;
+            const char *last_slash = NULL;
+
+            for (match = filenameinzip; *match; match += 1)
+            {
+                if (*match == '\\' || *match == '/')
+                    last_slash = match;
+            }
+
+            if (last_slash != NULL)
+                filenameinzip = last_slash + 1; // base filename follows last slash
+        }
+        else
+        {
+            filenameinzip += strlen(root_path);
+        }
+    }
+
+    if (*filenameinzip != 0)
+        err = minizip_add_path(handle, path, filenameinzip, password, is_dir, options);
+
+    if (!is_dir)
+        return err;

    dir = mz_os_open_dir(path);

@@ -216,7 +241,7 @@ int32_t minizip_add(void *handle, const char *path, const char *password, minizi
        if (!recursive && mz_os_is_dir(full_path))
            continue;

-        err = minizip_add(handle, full_path, password, options, recursive);
+        err = minizip_add(handle, full_path, root_path, password, options, recursive);
        if (err != MZ_OK)
            return err;
    }
@@ -233,7 +258,7 @@ int32_t minizip_list(void *handle)
    uint32_t ratio = 0;
    int16_t level = 0;
    int32_t err = MZ_OK;
-    struct tm tmu_date = { 0 };
+    struct tm tmu_date;
    const char *string_method = NULL;
    char crypt = ' ';

@@ -246,8 +271,8 @@ int32_t minizip_list(void *handle)
        return err;
    }

-    printf("  Length  Method     Size Ratio   Date    Time   CRC-32     Name\n");
-    printf("  ------  ------     ---- -----   ----    ----   ------     ----\n");
+    printf("  Length  Method     Size  Attribs Ratio   Date    Time   CRC-32     Name\n");
+    printf("  ------  ------     ----  ------- -----   ----    ----   ------     ----\n");

    while (err == MZ_OK)
    {
@@ -259,9 +284,10 @@ int32_t minizip_list(void *handle)
            break;
        }

+        ratio = 0;
        if (file_info->uncompressed_size > 0)
            ratio = (uint32_t)((file_info->compressed_size * 100) / file_info->uncompressed_size);
-        
+
        // Display a '*' if the file is encrypted
        if (file_info->flag & MZ_ZIP_FLAG_ENCRYPTED)
            crypt = '*';
@@ -269,7 +295,7 @@ int32_t minizip_list(void *handle)
        switch (file_info->compression_method)
        {
        case MZ_COMPRESS_METHOD_RAW:
-            string_method = "Stored"; 
+            string_method = "Stored";
            break;
        case MZ_COMPRESS_METHOD_DEFLATE:
            level = (int16_t)((file_info->flag & 0x6) / 2);
@@ -294,9 +320,10 @@ int32_t minizip_list(void *handle)

        mz_zip_time_t_to_tm(file_info->modified_date, &tmu_date);

-        printf(" %7"PRIu64"  %6s%c %7"PRIu64" %3"PRIu32"%%  %2.2"PRIu32"-%2.2"PRIu32\
+        printf(" %7"PRIu64"  %6s%c %7"PRIu64" %8"PRIx32" %3"PRIu32"%%  %2.2"PRIu32"-%2.2"PRIu32\
               "-%2.2"PRIu32"  %2.2"PRIu32":%2.2"PRIu32"  %8.8"PRIx32"   %s\n",
-                file_info->uncompressed_size, string_method, crypt, file_info->compressed_size, ratio, 
+                file_info->uncompressed_size, string_method, crypt,
+                file_info->compressed_size, file_info->external_fa, ratio,
                (uint32_t)tmu_date.tm_mon + 1, (uint32_t)tmu_date.tm_mday,
                (uint32_t)tmu_date.tm_year % 100,
                (uint32_t)tmu_date.tm_hour, (uint32_t)tmu_date.tm_min,
@@ -327,7 +354,6 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const
    int32_t written = 0;
    int32_t err = MZ_OK;
    int32_t err_close = MZ_OK;
-    uint8_t skip = 0;
    void *stream = NULL;
    char *match = NULL;
    char *filename = NULL;
@@ -353,22 +379,22 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const

    // Construct output path
    out_path[0] = 0;
-    if (destination != NULL)
-        mz_path_combine(out_path, destination, sizeof(out_path));
-    if (options->exclude_path)
-        mz_path_combine(out_path, filename, sizeof(out_path));
+    if ((*file_info->filename == '/') || (file_info->filename[1] == ':'))
+    {
+        strncpy(out_path, file_info->filename, sizeof(out_path));
+    }
    else
+    {
+        if (destination != NULL)
+            mz_path_combine(out_path, destination, sizeof(out_path));
        mz_path_combine(out_path, file_info->filename, sizeof(out_path));
+    }

    // If zip entry is a directory then create it on disk
-    if (*filename == 0)
+    if (mz_zip_attrib_is_dir(file_info->external_fa, file_info->version_madeby) == MZ_OK)
    {
-        if (options->exclude_path == 0)
-        {
-            printf("Creating directory: %s\n", out_path);
-            mz_make_dir(out_path);
-        }
-
+        printf("Creating directory: %s\n", out_path);
+        mz_make_dir(out_path);
        return err;
    }

@@ -397,7 +423,7 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const
        while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));

        if (rep == 'N')
-            skip = 1;
+            return err;
        if (rep == 'A')
            options->overwrite = 1;
    }
@@ -405,11 +431,11 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const
    mz_stream_os_create(&stream);

    // Create the file on disk so we can unzip to it
-    if ((skip == 0) && (err == MZ_OK))
+    if (err == MZ_OK)
    {
        // Some zips don't contain directory alone before file
        if ((mz_stream_os_open(stream, out_path, MZ_OPEN_MODE_CREATE) != MZ_OK) &&
-            (options->exclude_path == 0) && (filename != file_info->filename))
+            (filename != file_info->filename))
        {
            // Create the directory of the output path
            strncpy(directory, out_path, sizeof(directory));
@@ -458,7 +484,7 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const

        // Set the time of the file that has been unzipped
        if (err == MZ_OK)
-            mz_os_set_file_date(out_path, file_info->modified_date, file_info->accessed_date, 
+            mz_os_set_file_date(out_path, file_info->modified_date, file_info->accessed_date,
                file_info->creation_date);
    }
    else
@@ -481,7 +507,6 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const
 int32_t minizip_extract_all(void *handle, const char *destination, const char *password, minizip_opt *options)
 {
    int32_t err = MZ_OK;
-    

    err = mz_zip_goto_first_entry(handle);

@@ -529,6 +554,7 @@ int main(int argc, char *argv[])
    void *handle = NULL;
    void *file_stream = NULL;
    void *split_stream = NULL;
+    void *buf_stream = NULL;
    char *path = NULL;
    char *password = NULL;
    char *destination = NULL;
@@ -538,6 +564,7 @@ int main(int argc, char *argv[])
    int32_t path_arg = 0;
    uint8_t do_list = 0;
    uint8_t do_extract = 0;
+    uint8_t buffered = 0;
    int16_t mode = 0;
    uint8_t append = 0;
    int32_t err_close = 0;
@@ -572,10 +599,12 @@ int main(int argc, char *argv[])
                    do_extract = 1;
                if ((c == 'a') || (c == 'A'))
                    append = 1;
+                if ((c == 'u') || (c == 'U'))
+                    buffered = 1;
                if ((c == 'o') || (c == 'O'))
                    options.overwrite = 1;
-                if ((c == 'j') || (c == 'J'))
-                    options.exclude_path = 1;
+                if ((c == 'i') || (c == 'I'))
+                    options.include_path = 1;
                if ((c >= '0') && (c <= '9'))
                {
                    options.compress_level = (c - '0');
@@ -595,7 +624,7 @@ int main(int argc, char *argv[])
                if ((c == 's') || (c == 'S'))
                    options.aes = 1;
 #endif
-                if (((c == 'k') || (c == 'k')) && (i + 1 < argc))
+                if (((c == 'k') || (c == 'K')) && (i + 1 < argc))
                {
                    disk_size = atoi(argv[i + 1]) * 1024;
                    i += 1;
@@ -676,9 +705,19 @@ int main(int argc, char *argv[])
    }

    mz_stream_os_create(&file_stream);
-
+    mz_stream_buffered_create(&buf_stream);
    mz_stream_split_create(&split_stream);
-    mz_stream_set_base(split_stream, file_stream);
+
+    if (buffered)
+    {
+        mz_stream_set_base(buf_stream, file_stream);
+        mz_stream_set_base(split_stream, buf_stream);
+    }
+    else
+    {
+        mz_stream_set_base(split_stream, file_stream);
+    }
+
    mz_stream_split_set_prop_int64(split_stream, MZ_STREAM_PROP_DISK_SIZE, disk_size);

    err = mz_stream_open(split_stream, path, mode);
@@ -721,7 +760,7 @@ int main(int argc, char *argv[])

            // Go through command line args looking for files to add to zip
            for (i = path_arg + 1; (i < argc) && (err == MZ_OK); i += 1)
-                err = minizip_add(handle, argv[i], password, &options, 1);
+                err = minizip_add(handle, argv[i], NULL, password, &options, 1);

            mz_zip_set_version_madeby(handle, MZ_VERSION_MADEBY);
        }
@@ -734,10 +773,11 @@ int main(int argc, char *argv[])
            err = err_close;
        }

-        mz_stream_os_close(file_stream);
+        mz_stream_close(split_stream);
    }

    mz_stream_split_delete(&split_stream);
+    mz_stream_buffered_delete(&buf_stream);
    mz_stream_os_delete(&file_stream);

    return err;
@@ -8,6 +8,6 @@ Name: minizip
 Description: Minizip zip file manipulation library
 Version: @VERSION@

-Requires:
-Libs: -L${libdir} -L${sharedlibdir} -lz -lminizip
+Requires: zlib
+Libs: -L${libdir} -L${sharedlibdir} -lminizip
 Cflags: -I${includedir}
@@ -1,8 +1,8 @@
 /* mz.h -- Errors codes, zip flags and magic
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -19,7 +19,7 @@ extern "C" {
 /***************************************************************************/

 // MZ_VERSION
-#define MZ_VERSION                      ("2.2.4")
+#define MZ_VERSION                      ("2.3.0")

 // MZ_ERROR
 #define MZ_OK                           (0)
@@ -34,6 +34,7 @@ extern "C" {
 #define MZ_CRC_ERROR                    (-105)
 #define MZ_CRYPT_ERROR                  (-106)
 #define MZ_EXIST_ERROR                  (-107)
+#define MZ_PASSWORD_ERROR               (-108)

 // MZ_OPEN
 #define MZ_OPEN_MODE_READ               (0x01)
@@ -70,12 +71,33 @@ extern "C" {
                                         MZ_ZIP_FLAG_DEFLATE_MAX)
 #define MZ_ZIP_FLAG_DATA_DESCRIPTOR     (1 << 3)

+// MZ_ZIP64
+#define MZ_ZIP64_AUTO                   (0)
+#define MZ_ZIP64_FORCE                  (1)
+#define MZ_ZIP64_DISABLE                (2)
+
+// MZ_HOST_SYSTEM
+#define MZ_HOST_SYSTEM_MSDOS            (0)
+#define MZ_HOST_SYSTEM_UNIX             (3)
+#define MZ_HOST_SYSTEM_WINDOWS_NTFS     (10)
+#define MZ_HOST_SYSTEM_OSX_DARWIN       (19)
+
 // MZ_AES
 #define MZ_AES_VERSION                  (1)
 #define MZ_AES_ENCRYPTION_MODE_128      (0x01)
 #define MZ_AES_ENCRYPTION_MODE_192      (0x02)
 #define MZ_AES_ENCRYPTION_MODE_256      (0x03)

+// MZ_UTILITY
+#define MZ_UNUSED(SYMBOL)               ((void)SYMBOL)
+
+#ifndef MZ_CUSTOM_ALLOC
+#define MZ_ALLOC(SIZE)                  (malloc(SIZE))
+#endif
+#ifndef MZ_CUSTOM_FREE
+#define MZ_FREE(PTR)                    (free(PTR))
+#endif
+
 /***************************************************************************/

 #ifdef __cplusplus
@@ -1,8 +1,8 @@
 /* mz_compat.c -- Backwards compatible interface for older versions
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2010 Gilles Vollant
     http://www.winimage.com/zLibDll/minizip.html
@@ -34,12 +34,14 @@ typedef struct mz_compat_s {

 extern zipFile ZEXPORT zipOpen(const char *path, int append)
 {
-    return zipOpen2(path, append, NULL, mz_stream_os_get_interface());
+    zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
+    return zipOpen2(path, append, NULL, &pzlib);
 }

 extern zipFile ZEXPORT zipOpen64(const void *path, int append)
 {
-    return zipOpen2(path, append, NULL, mz_stream_os_get_interface());
+    zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
+    return zipOpen2(path, append, NULL, &pzlib);
 }

 extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment,
@@ -48,7 +50,7 @@ extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globa
    return zipOpen2_64(path, append, globalcomment, pzlib_filefunc_def);
 }

-extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment, 
+extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment,
    zlib_filefunc64_def *pzlib_filefunc_def)
 {
    mz_compat *compat = NULL;
@@ -57,8 +59,16 @@ extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **gl
    void *handle = NULL;
    void *stream = NULL;

-    if (mz_stream_create(&stream, (mz_stream_vtbl *)pzlib_filefunc_def) == NULL)
-        return NULL;
+    if (pzlib_filefunc_def)
+    {
+        if (mz_stream_create(&stream, (mz_stream_vtbl *)*pzlib_filefunc_def) == NULL)
+            return NULL;
+    }
+    else
+    {
+        if (mz_stream_os_create(&stream) == NULL)
+            return NULL;
+    }

    switch (append)
    {
@@ -90,7 +100,7 @@ extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **gl
    if (globalcomment != NULL)
        mz_zip_get_comment(handle, globalcomment);

-    compat = (mz_compat *)malloc(sizeof(mz_compat));
+    compat = (mz_compat *)MZ_ALLOC(sizeof(mz_compat));
    compat->handle = handle;
    compat->stream = stream;

@@ -98,24 +108,35 @@ extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **gl
 }

 extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi,
-    const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
-    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level, 
-    int raw, int windowBits, int memLevel, int strategy, const char *password, 
+    ZIP_UNUSED const void *extrafield_local, ZIP_UNUSED uint16_t size_extrafield_local, const void *extrafield_global,
+    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
+    int raw, ZIP_UNUSED int windowBits, ZIP_UNUSED int memLevel, ZIP_UNUSED int strategy, const char *password,
    ZIP_UNUSED uint32_t crc_for_crypting,  uint16_t version_madeby, uint16_t flag_base, int zip64)
 {
    mz_compat *compat = (mz_compat *)file;
    mz_zip_file file_info;
+    uint64_t dos_date = 0;

    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return ZIP_PARAMERROR;
+
+    memset(&file_info, 0, sizeof(file_info));

    if (zipfi != NULL)
    {
-        file_info.modified_date = mz_zip_dosdate_to_time_t(zipfi->dos_date);
+        if (zipfi->dosDate != 0)
+            dos_date = zipfi->dosDate;
+        else
+            dos_date = mz_zip_tm_to_dosdate(&zipfi->tmz_date);
+
+        file_info.modified_date = mz_zip_dosdate_to_time_t(dos_date);
        file_info.external_fa = zipfi->external_fa;
        file_info.internal_fa = zipfi->internal_fa;
    }

+    if (filename == NULL)
+        filename = "-";
+
    file_info.compression_method = compression_method;
    file_info.filename = (char *)filename;
    //file_info.extrafield_local = extrafield_local;
@@ -125,54 +146,62 @@ extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, cons
    file_info.version_madeby = version_madeby;
    file_info.comment = (char *)comment;
    file_info.flag = flag_base;
+    if (zip64)
+        file_info.zip64 = MZ_ZIP64_FORCE;
+    else
+        file_info.zip64 = MZ_ZIP64_DISABLE;
 #ifdef HAVE_AES
-    file_info.aes_version = MZ_AES_VERSION;
+    if (password)
+        file_info.aes_version = MZ_AES_VERSION;
 #endif

+    if (raw)
+        level = 0;
+
    return mz_zip_entry_write_open(compat->handle, &file_info, (int16_t)level, password);
 }

 extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
    const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
-    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level, 
-    int raw, int windowBits, int memLevel,   int strategy, const char *password, 
-    ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64)
+    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
+    int raw, int windowBits, int memLevel,   int strategy, const char *password,
+    uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64)
 {
-    return zipOpenNewFileInZip5(file, filename, zipfi, extrafield_local, size_extrafield_local, 
-        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, 
+    return zipOpenNewFileInZip5(file, filename, zipfi, extrafield_local, size_extrafield_local,
+        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits,
        memLevel, strategy, password, crc_for_crypting, version_madeby, flag_base, zip64);
 }

 extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi,
    const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
-    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level, 
-    int raw, int windowBits, int memLevel, int strategy, const char *password, 
-    ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base)
+    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
+    int raw, int windowBits, int memLevel, int strategy, const char *password,
+    uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base)
 {
    return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,
-        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, 
+        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits,
        memLevel, strategy, password, crc_for_crypting, version_madeby, flag_base, 0);
 }

 extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi,
    const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
-    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level, 
-    int raw, int windowBits, int memLevel, int strategy, const char *password, 
-    ZIP_UNUSED uint32_t crc_for_crypting)
+    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
+    int raw, int windowBits, int memLevel, int strategy, const char *password,
+    uint32_t crc_for_crypting)
 {
    return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,
-        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, 
+        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits,
        memLevel, strategy, password, crc_for_crypting, MZ_VERSION_MADEBY, 0, 0);
 }

 extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
    const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
-    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level, 
-    int raw, int windowBits, int memLevel, int strategy, const char *password, 
-    ZIP_UNUSED uint32_t crc_for_crypting, int zip64)
+    uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
+    int raw, int windowBits, int memLevel, int strategy, const char *password,
+    uint32_t crc_for_crypting, int zip64)
 {
    return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,
-        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, 
+        extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits,
        memLevel, strategy, password, crc_for_crypting, MZ_VERSION_MADEBY, 0, zip64);
 }

@@ -180,15 +209,22 @@ extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, uint32_t l
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
-    return mz_zip_entry_write(compat->handle, buf, len);
+        return ZIP_PARAMERROR;
+    if (mz_zip_entry_write(compat->handle, buf, len) != len)
+        return ZIP_ERRNO;
+    return ZIP_OK;
 }

 extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32)
+{
+    return zipCloseFileInZipRaw64(file, uncompressed_size, crc32);
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, uint32_t crc32)
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return ZIP_PARAMERROR;
    return mz_zip_entry_close_raw(compat->handle, uncompressed_size, crc32);
 }

@@ -218,7 +254,7 @@ extern int ZEXPORT zipClose2_64(zipFile file, const char *global_comment, uint16
    int32_t err = MZ_OK;

    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return ZIP_PARAMERROR;

    if (global_comment != NULL)
        mz_zip_set_comment(compat->handle, global_comment);
@@ -232,7 +268,7 @@ extern int ZEXPORT zipClose2_64(zipFile file, const char *global_comment, uint16
        mz_stream_delete(&compat->stream);
    }

-    free(compat);
+    MZ_FREE(compat);

    return err;
 }
@@ -246,7 +282,8 @@ extern unzFile ZEXPORT unzOpen(const char *path)

 extern unzFile ZEXPORT unzOpen64(const void *path)
 {
-    return unzOpen2(path, mz_stream_os_get_interface());
+    zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
+    return unzOpen2(path, &pzlib);
 }

 extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def)
@@ -261,9 +298,17 @@ extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_
    void *handle = NULL;
    void *stream = NULL;

-    if (mz_stream_create(&stream, (mz_stream_vtbl *)pzlib_filefunc_def) == NULL)
-        return NULL;
-    
+    if (pzlib_filefunc_def)
+    {
+        if (mz_stream_create(&stream, (mz_stream_vtbl *)*pzlib_filefunc_def) == NULL)
+            return NULL;
+    }
+    else
+    {
+        if (mz_stream_os_create(&stream) == NULL)
+            return NULL;
+    }
+
    if (mz_stream_open(stream, path, mode) != MZ_OK)
    {
        mz_stream_delete(&stream);
@@ -278,10 +323,11 @@ extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_
        return NULL;
    }

-    compat = (mz_compat *)malloc(sizeof(mz_compat));
+    compat = (mz_compat *)MZ_ALLOC(sizeof(mz_compat));
    compat->handle = handle;
    compat->stream = stream;

+    mz_zip_goto_first_entry(compat->handle);
    return (unzFile)compat;
 }

@@ -291,14 +337,17 @@ extern int ZEXPORT unzClose(unzFile file)
    int32_t err = MZ_OK;

    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;

    err = mz_zip_close(compat->handle);

    if (compat->stream != NULL)
+    {
+        mz_stream_close(compat->stream);
        mz_stream_delete(&compat->stream);
+    }

-    free(compat);
+    MZ_FREE(compat);

    return err;
 }
@@ -309,17 +358,18 @@ extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info3
    unz_global_info64 global_info64;
    int32_t err = MZ_OK;

+    memset(pglobal_info32, 0, sizeof(unz_global_info));
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;

    err = unzGetGlobalInfo64(file, &global_info64);
-    if (err != UNZ_OK)
+    if (err == MZ_OK)
    {
        pglobal_info32->number_entry = (uint32_t)global_info64.number_entry;
        pglobal_info32->size_comment = global_info64.size_comment;
        pglobal_info32->number_disk_with_CD = global_info64.number_disk_with_CD;
    }
-    return MZ_OK;
+    return err;
 }

 extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
@@ -328,12 +378,16 @@ extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_i
    const char *comment_ptr = NULL;
    int32_t err = MZ_OK;

+    memset(pglobal_info, 0, sizeof(unz_global_info64));
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    err = mz_zip_get_comment(compat->handle, &comment_ptr);
    if (err == MZ_OK)
        pglobal_info->size_comment = (uint16_t)strlen(comment_ptr);
-    mz_zip_get_number_entry(compat->handle, (int64_t *)&pglobal_info->number_entry);
+    if ((err == MZ_OK) || (err == MZ_EXIST_ERROR))
+        err = mz_zip_get_number_entry(compat->handle, (int64_t *)&pglobal_info->number_entry);
+    if (err == MZ_OK)
+        err = mz_zip_get_disk_number_with_cd(compat->handle, &pglobal_info->number_disk_with_CD);
    return err;
 }

@@ -344,7 +398,7 @@ extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t com
    int32_t err = MZ_OK;

    if (comment == NULL || comment_size == 0)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    err = mz_zip_get_comment(compat->handle, &comment_ptr);
    if (err == MZ_OK)
        strncpy(comment, comment_ptr, comment_size);
@@ -355,7 +409,7 @@ extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, in
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    if (method != NULL)
        *method = 0;
    if (level != NULL)
@@ -382,7 +436,7 @@ extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len)
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    return mz_zip_entry_read(compat->handle, buf, len);
 }

@@ -390,7 +444,7 @@ extern int ZEXPORT unzCloseCurrentFile(unzFile file)
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    return mz_zip_entry_close(compat->handle);
 }

@@ -403,7 +457,8 @@ extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info
    int32_t err = MZ_OK;

    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
+
    err = mz_zip_entry_get_info(compat->handle, &file_info);

    if ((err == MZ_OK) && (pfile_info != NULL))
@@ -412,7 +467,9 @@ extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info
        pfile_info->version_needed = file_info->version_needed;
        pfile_info->flag = file_info->flag;
        pfile_info->compression_method = file_info->compression_method;
-        pfile_info->dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
+        pfile_info->dosDate = mz_zip_time_t_to_dos_date(file_info->modified_date);
+        mz_zip_time_t_to_tm(file_info->modified_date, &pfile_info->tmu_date);
+        pfile_info->tmu_date.tm_year += 1900;
        pfile_info->crc = file_info->crc;

        pfile_info->size_filename = file_info->filename_size;
@@ -460,7 +517,7 @@ extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile
    int32_t err = MZ_OK;

    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;

    err = mz_zip_entry_get_info(compat->handle, &file_info);

@@ -470,7 +527,9 @@ extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile
        pfile_info->version_needed = file_info->version_needed;
        pfile_info->flag = file_info->flag;
        pfile_info->compression_method = file_info->compression_method;
-        pfile_info->dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
+        pfile_info->dosDate = mz_zip_time_t_to_dos_date(file_info->modified_date);
+        mz_zip_time_t_to_tm(file_info->modified_date, &pfile_info->tmu_date);
+        pfile_info->tmu_date.tm_year += 1900;
        pfile_info->crc = file_info->crc;

        pfile_info->size_filename = file_info->filename_size;
@@ -490,7 +549,10 @@ extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile
            if (bytes_to_copy > file_info->filename_size)
                bytes_to_copy = file_info->filename_size;
            memcpy(filename, file_info->filename, bytes_to_copy);
+            if (file_info->filename_size < filename_size)
+                filename[file_info->filename_size] = 0;
        }
+
        if (extrafield_size > 0 && extrafield != NULL)
        {
            bytes_to_copy = extrafield_size;
@@ -498,12 +560,15 @@ extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile
                bytes_to_copy = file_info->extrafield_size;
            memcpy(extrafield, file_info->extrafield, bytes_to_copy);
        }
+
        if (comment_size > 0 && comment != NULL)
        {
            bytes_to_copy = comment_size;
            if (bytes_to_copy > file_info->comment_size)
                bytes_to_copy = file_info->comment_size;
            memcpy(comment, file_info->comment, bytes_to_copy);
+            if (file_info->comment_size < comment_size)
+                comment[file_info->comment_size] = 0;
        }
    }
    return err;
@@ -513,7 +578,7 @@ extern int ZEXPORT unzGoToFirstFile(unzFile file)
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    return mz_zip_goto_first_entry(compat->handle);
 }

@@ -521,7 +586,7 @@ extern int ZEXPORT unzGoToNextFile(unzFile file)
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    return mz_zip_goto_next_entry(compat->handle);
 }

@@ -529,46 +594,80 @@ extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileName
 {
    mz_compat *compat = (mz_compat *)file;
    if (compat == NULL)
-        return MZ_PARAM_ERROR;
+        return UNZ_PARAMERROR;
    return mz_zip_locate_entry(compat->handle, filename, filename_compare_func);
 }

+extern int32_t ZEXPORT unzGetOffset(unzFile file)
+{
+    return (int32_t)unzGetOffset64(file);
+}
+
+extern int64_t ZEXPORT unzGetOffset64(unzFile file)
+{
+    mz_compat *compat = (mz_compat *)file;
+    if (compat == NULL)
+        return UNZ_PARAMERROR;
+    return mz_zip_get_entry(compat->handle);
+}
+
+extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos)
+{
+    return unzSetOffset64(file, pos);
+}
+
+extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos)
+{
+    mz_compat *compat = (mz_compat *)file;
+    if (compat == NULL)
+        return UNZ_PARAMERROR;
+    return (int)mz_zip_goto_entry(compat->handle, pos);
+}
+
+extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, unsigned len)  // TODO
+{
+    MZ_UNUSED(file);
+    MZ_UNUSED(buf);
+    MZ_UNUSED(len);
+
+    return 0;
+}
+
 /***************************************************************************/

 void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
 {
    if (pzlib_filefunc_def != NULL)
-        pzlib_filefunc_def = mz_stream_os_get_interface();
+        *pzlib_filefunc_def = mz_stream_os_get_interface();
 }

 void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)
 {
    if (pzlib_filefunc_def != NULL)
-        pzlib_filefunc_def = mz_stream_os_get_interface();
+        *pzlib_filefunc_def = mz_stream_os_get_interface();
 }

 void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
 {
    if (pzlib_filefunc_def != NULL)
-        pzlib_filefunc_def = mz_stream_os_get_interface();
+        *pzlib_filefunc_def = mz_stream_os_get_interface();
 }

 void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def)
 {
    if (pzlib_filefunc_def != NULL)
-        pzlib_filefunc_def = mz_stream_os_get_interface();
+        *pzlib_filefunc_def = mz_stream_os_get_interface();
 }

 void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def)
 {
    if (pzlib_filefunc_def != NULL)
-        pzlib_filefunc_def = mz_stream_os_get_interface();
+        *pzlib_filefunc_def = mz_stream_os_get_interface();
 }

 void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def)
 {
    // NOTE: You should no longer pass in widechar string to open function
    if (pzlib_filefunc_def != NULL)
-        pzlib_filefunc_def = mz_stream_os_get_interface();
+        *pzlib_filefunc_def = mz_stream_os_get_interface();
 }
-
@@ -1,8 +1,8 @@
 /* mz_compat.h -- Backwards compatible interface for older versions
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2010 Gilles Vollant
     http://www.winimage.com/zLibDll/minizip.html
@@ -79,11 +79,17 @@ typedef void *zlib_filefunc_def;
 typedef void *zlib_filefunc64_def;
 typedef const char *zipcharpc;

+typedef struct tm tm_unz;
+typedef struct tm tm_zip;
+
+typedef uint64_t ZPOS64_T;
+
 /***************************************************************************/

 typedef struct
 {
-    uint32_t    dos_date;
+    uint32_t    dosDate;
+    struct tm   tmz_date;
    uint16_t    internal_fa;        // internal file attributes        2 bytes
    uint32_t    external_fa;        // external file attributes        4 bytes
 } zip_fileinfo;
@@ -109,7 +115,7 @@ extern zipFile ZEXPORT zipOpen(const char *path, int append);
 extern zipFile ZEXPORT zipOpen64(const void *path, int append);
 extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment,
    zlib_filefunc_def *pzlib_filefunc_def);
-extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment, 
+extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment,
    zlib_filefunc64_def *pzlib_filefunc_def);

 extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi,
@@ -141,6 +147,7 @@ extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, cons
 extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len);

 extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32);
+extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, uint32_t crc32);
 extern int ZEXPORT zipCloseFileInZip(zipFile file);
 extern int ZEXPORT zipCloseFileInZip64(zipFile file);

@@ -175,35 +182,36 @@ typedef voidp unzFile;

 typedef struct unz_global_info64_s
 {
-    uint64_t number_entry;          // total number of entries in the central dir on this disk 
+    uint64_t number_entry;          // total number of entries in the central dir on this disk
    uint32_t number_disk_with_CD;   // number the the disk with central dir, used for spanning ZIP
-    uint16_t size_comment;          // size of the global comment of the zipfile 
+    uint16_t size_comment;          // size of the global comment of the zipfile
 } unz_global_info64;

 typedef struct unz_global_info_s
 {
-    uint32_t number_entry;          // total number of entries in the central dir on this disk 
+    uint32_t number_entry;          // total number of entries in the central dir on this disk
    uint32_t number_disk_with_CD;   // number the the disk with central dir, used for spanning ZIP
-    uint16_t size_comment;          // size of the global comment of the zipfile 
+    uint16_t size_comment;          // size of the global comment of the zipfile
 } unz_global_info;

 typedef struct unz_file_info64_s
 {
-    uint16_t version;               // version made by                 2 bytes 
-    uint16_t version_needed;        // version needed to extract       2 bytes 
-    uint16_t flag;                  // general purpose bit flag        2 bytes 
-    uint16_t compression_method;    // compression method              2 bytes 
-    uint32_t dos_date;              // last mod file date in Dos fmt   4 bytes 
-    uint32_t crc;                   // crc-32                          4 bytes 
-    uint64_t compressed_size;       // compressed size                 8 bytes 
-    uint64_t uncompressed_size;     // uncompressed size               8 bytes 
-    uint16_t size_filename;         // filename length                 2 bytes 
-    uint16_t size_file_extra;       // extra field length              2 bytes 
-    uint16_t size_file_comment;     // file comment length             2 bytes 
+    uint16_t version;               // version made by                 2 bytes
+    uint16_t version_needed;        // version needed to extract       2 bytes
+    uint16_t flag;                  // general purpose bit flag        2 bytes
+    uint16_t compression_method;    // compression method              2 bytes
+    uint32_t dosDate;               // last mod file date in Dos fmt   4 bytes
+    struct tm tmu_date;
+    uint32_t crc;                   // crc-32                          4 bytes
+    uint64_t compressed_size;       // compressed size                 8 bytes
+    uint64_t uncompressed_size;     // uncompressed size               8 bytes
+    uint16_t size_filename;         // filename length                 2 bytes
+    uint16_t size_file_extra;       // extra field length              2 bytes
+    uint16_t size_file_comment;     // file comment length             2 bytes

-    uint32_t disk_num_start;        // disk number start               4 bytes 
-    uint16_t internal_fa;           // internal file attributes        2 bytes 
-    uint32_t external_fa;           // external file attributes        4 bytes 
+    uint32_t disk_num_start;        // disk number start               4 bytes
+    uint16_t internal_fa;           // internal file attributes        2 bytes
+    uint32_t external_fa;           // external file attributes        4 bytes

    uint64_t disk_offset;

@@ -212,20 +220,21 @@ typedef struct unz_file_info64_s

 typedef struct unz_file_info_s
 {
-    uint16_t version;               // version made by                 2 bytes 
-    uint16_t version_needed;        // version needed to extract       2 bytes 
-    uint16_t flag;                  // general purpose bit flag        2 bytes 
-    uint16_t compression_method;    // compression method              2 bytes 
-    uint32_t dos_date;              // last mod file date in Dos fmt   4 bytes 
-    uint32_t crc;                   // crc-32                          4 bytes 
-    uint32_t compressed_size;       // compressed size                 4 bytes 
-    uint32_t uncompressed_size;     // uncompressed size               4 bytes 
-    uint16_t size_filename;         // filename length                 2 bytes 
-    uint16_t size_file_extra;       // extra field length              2 bytes 
-    uint16_t size_file_comment;     // file comment length             2 bytes 
+    uint16_t version;               // version made by                 2 bytes
+    uint16_t version_needed;        // version needed to extract       2 bytes
+    uint16_t flag;                  // general purpose bit flag        2 bytes
+    uint16_t compression_method;    // compression method              2 bytes
+    uint32_t dosDate;               // last mod file date in Dos fmt   4 bytes
+    struct tm tmu_date;
+    uint32_t crc;                   // crc-32                          4 bytes
+    uint32_t compressed_size;       // compressed size                 4 bytes
+    uint32_t uncompressed_size;     // uncompressed size               4 bytes
+    uint16_t size_filename;         // filename length                 2 bytes
+    uint16_t size_file_extra;       // extra field length              2 bytes
+    uint16_t size_file_comment;     // file comment length             2 bytes

-    uint16_t disk_num_start;        // disk number start               2 bytes 
-    uint16_t internal_fa;           // internal file attributes        2 bytes 
+    uint16_t disk_num_start;        // disk number start               2 bytes
+    uint16_t internal_fa;           // internal file attributes        2 bytes
    uint32_t external_fa;           // external file attributes        4 bytes

    uint64_t disk_offset;
@@ -264,6 +273,12 @@ extern int ZEXPORT unzGoToFirstFile(unzFile file);
 extern int ZEXPORT unzGoToNextFile(unzFile file);
 extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);

+extern int64_t ZEXPORT unzGetOffset64(unzFile file);
+extern int32_t ZEXPORT unzGetOffset(unzFile file);
+extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos);
+extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos);
+extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, unsigned len);
+
 /***************************************************************************/

 void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
@@ -1,8 +1,8 @@
 /* mz_os.c -- System functions
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2010 Gilles Vollant
     http://www.winimage.com/zLibDll/minizip.html
@@ -40,7 +40,7 @@ int32_t mz_make_dir(const char *path)
    if (len <= 0)
        return 0;

-    current_dir = (char *)malloc(len + 1);
+    current_dir = (char *)MZ_ALLOC(len + 1);
    if (current_dir == NULL)
        return MZ_MEM_ERROR;

@@ -71,7 +71,7 @@ int32_t mz_make_dir(const char *path)
        }
    }

-    free(current_dir);
+    MZ_FREE(current_dir);
    return err;
 }

@@ -149,4 +149,4 @@ int32_t mz_get_file_crc(const char *path, uint32_t *result_crc)
    mz_stream_os_delete(&stream);

    return err;
-}
+}
@@ -1,8 +1,8 @@
 /* mz_os.h -- System functions
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2010 Gilles Vollant
     http://www.winimage.com/zLibDll/minizip.html
@@ -32,6 +32,21 @@ extern "C" {

 /***************************************************************************/

+#ifdef HAVE_LZMA
+#define MZ_VERSION_MADEBY_ZIP_VERSION (63)
+#elif HAVE_AES
+#define MZ_VERSION_MADEBY_ZIP_VERSION (51)
+#elif HAVE_BZIP2
+#define MZ_VERSION_MADEBY_ZIP_VERSION (46)
+#else
+#define MZ_VERSION_MADEBY_ZIP_VERSION (45)
+#endif
+
+#define MZ_VERSION_MADEBY             ((MZ_VERSION_MADEBY_HOST_SYSTEM << 8) | \
+                                       (MZ_VERSION_MADEBY_ZIP_VERSION))
+
+/***************************************************************************/
+
 int32_t mz_make_dir(const char *path);
 // Creates a directory recursively

@@ -1,8 +1,8 @@
 /* mz_os_posix.c -- System functions for posix
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -21,8 +21,10 @@
 #  include <unistd.h>
 #  include <utime.h>
 #endif
-#if defined unix
+#if defined __linux__
 #  include <bsd/stdlib.h>
+#else
+#  include <stdlib.h>
 #endif

 #include "mz.h"
@@ -63,13 +65,10 @@ int64_t mz_posix_get_file_size(const char *path)
 int32_t mz_posix_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date)
 {
    struct stat stat_info;
-    struct tm *filedate = NULL;
    char *name = NULL;
    size_t len = 0;
-    time_t tm_t = 0;
    int32_t err = MZ_INTERNAL_ERROR;

-
    memset(&stat_info, 0, sizeof(stat_info));

    if (strcmp(path, "-") != 0)
@@ -108,6 +107,7 @@ int32_t mz_posix_set_file_date(const char *path, time_t modified_date, time_t ac
    ut.actime = accessed_date;
    ut.modtime = modified_date;
    // Creation date not supported
+    (void)creation_date;

    if (utime(path, &ut) != 0)
        return MZ_INTERNAL_ERROR;
@@ -115,6 +115,28 @@ int32_t mz_posix_set_file_date(const char *path, time_t modified_date, time_t ac
    return MZ_OK;
 }

+int32_t mz_posix_get_file_attribs(const char *path, int32_t *attributes)
+{
+    struct stat stat_info;
+    int32_t err = MZ_OK;
+
+    memset(&stat_info, 0, sizeof(stat_info));
+    if (stat(path, &stat_info) == -1)
+        err = MZ_INTERNAL_ERROR;
+    *attributes = stat_info.st_mode;
+    return err;
+}
+
+int32_t mz_posix_set_file_attribs(const char *path, int32_t attributes)
+{
+    int32_t err = MZ_OK;
+
+    if (chmod(path, attributes) == -1)
+        err = MZ_INTERNAL_ERROR;
+
+    return err;
+}
+
 int32_t mz_posix_make_dir(const char *path)
 {
    int32_t err = 0;
@@ -1,8 +1,8 @@
 /* mz_os_posix.h -- System functions for posix
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -23,9 +23,9 @@ extern "C" {
 /***************************************************************************/

 #if defined(__APPLE__)
-#define MZ_VERSION_MADEBY (19)
+#define MZ_VERSION_MADEBY_HOST_SYSTEM   (MZ_HOST_SYSTEM_OSX_DARWIN)
 #elif defined(unix)
-#define MZ_VERSION_MADEBY (3)
+#define MZ_VERSION_MADEBY_HOST_SYSTEM   (MZ_HOST_SYSTEM_UNIX)
 #endif

 /***************************************************************************/
@@ -35,25 +35,29 @@ int32_t mz_posix_file_exists(const char *path);
 int64_t mz_posix_get_file_size(const char *path);
 int32_t mz_posix_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
 int32_t mz_posix_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
+int32_t mz_posix_get_file_attribs(const char *path, int32_t *attributes);
+int32_t mz_posix_set_file_attribs(const char *path, int32_t attributes);
 int32_t mz_posix_make_dir(const char *path);
 DIR*    mz_posix_open_dir(const char *path);
-struct 
+struct
 dirent* mz_posix_read_dir(DIR *dir);
 int32_t mz_posix_close_dir(DIR *dir);
 int32_t mz_posix_is_dir(const char *path);

 /***************************************************************************/

-#define mz_os_rand           mz_posix_rand
-#define mz_os_file_exists    mz_posix_file_exists
-#define mz_os_get_file_size  mz_posix_get_file_size
-#define mz_os_get_file_date  mz_posix_get_file_date
-#define mz_os_set_file_date  mz_posix_set_file_date
-#define mz_os_make_dir       mz_posix_make_dir
-#define mz_os_open_dir       mz_posix_open_dir
-#define mz_os_read_dir       mz_posix_read_dir
-#define mz_os_close_dir      mz_posix_close_dir
-#define mz_os_is_dir         mz_posix_is_dir
+#define mz_os_rand              mz_posix_rand
+#define mz_os_file_exists       mz_posix_file_exists
+#define mz_os_get_file_size     mz_posix_get_file_size
+#define mz_os_get_file_date     mz_posix_get_file_date
+#define mz_os_set_file_date     mz_posix_set_file_date
+#define mz_os_get_file_attribs  mz_posix_get_file_attribs
+#define mz_os_set_file_attribs  mz_posix_set_file_attribs
+#define mz_os_make_dir          mz_posix_make_dir
+#define mz_os_open_dir          mz_posix_open_dir
+#define mz_os_read_dir          mz_posix_read_dir
+#define mz_os_close_dir         mz_posix_close_dir
+#define mz_os_is_dir            mz_posix_is_dir

 /***************************************************************************/

@@ -1,8 +1,8 @@
 /* mz_os_win32.c -- System functions for Windows
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -75,7 +75,7 @@ wchar_t *mz_win32_unicode_path_create(const char *path)
    uint32_t path_wide_size = 0;

    path_wide_size = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
-    path_wide = (wchar_t *)malloc((path_wide_size + 1) * sizeof(wchar_t));
+    path_wide = (wchar_t *)MZ_ALLOC((path_wide_size + 1) * sizeof(wchar_t));
    memset(path_wide, 0, sizeof(wchar_t) * (path_wide_size + 1));

    MultiByteToWideChar(CP_UTF8, 0, path, -1, path_wide, path_wide_size);
@@ -87,7 +87,7 @@ void mz_win32_unicode_path_delete(wchar_t **path)
 {
    if (path != NULL)
    {
-        free(*path);
+        MZ_FREE(*path);
        *path = NULL;
    }
 }
@@ -113,7 +113,6 @@ int64_t mz_win32_get_file_size(const char *path)
    HANDLE handle = NULL;
    LARGE_INTEGER large_size;
    wchar_t *path_wide = NULL;
-    int32_t err = MZ_OK;


    path_wide = mz_win32_unicode_path_create(path);
@@ -160,7 +159,7 @@ int32_t mz_win32_get_file_date(const char *path, time_t *modified_date, time_t *

    path_wide = mz_win32_unicode_path_create(path);
    handle = FindFirstFileW(path_wide, &ff32);
-    free(path_wide);
+    MZ_FREE(path_wide);

    if (handle != INVALID_HANDLE_VALUE)
    {
@@ -214,6 +213,34 @@ int32_t mz_win32_set_file_date(const char *path, time_t modified_date, time_t ac
    return err;
 }

+int32_t mz_win32_get_file_attribs(const char *path, int32_t *attributes)
+{
+    wchar_t *path_wide = NULL;
+    int32_t err = MZ_OK;
+
+    path_wide = mz_win32_unicode_path_create(path);
+    *attributes = GetFileAttributesW(path_wide);
+    MZ_FREE(path_wide);
+
+    if (*attributes == INVALID_FILE_ATTRIBUTES)
+        err = MZ_INTERNAL_ERROR;
+
+    return err;
+}
+
+int32_t mz_win32_set_file_attribs(const char *path, int32_t attributes)
+{
+    wchar_t *path_wide = NULL;
+    int32_t err = MZ_OK;
+
+    path_wide = mz_win32_unicode_path_create(path);
+    if (SetFileAttributesW(path_wide, attributes) == 0)
+        err = MZ_INTERNAL_ERROR;
+    MZ_FREE(path_wide);
+
+    return err;
+}
+
 int32_t mz_win32_make_dir(const char *path)
 {
    wchar_t *path_wide = NULL;
@@ -250,7 +277,7 @@ DIR *mz_win32_open_dir(const char *path)
    if (handle == INVALID_HANDLE_VALUE)
        return NULL;

-    dir_int = (DIR_int *)malloc(sizeof(DIR_int));
+    dir_int = (DIR_int *)MZ_ALLOC(sizeof(DIR_int));
    dir_int->find_handle = handle;
    dir_int->end = 0;

@@ -270,9 +297,9 @@ struct dirent* mz_win32_read_dir(DIR *dir)
    if (dir_int->end)
        return NULL;

-    WideCharToMultiByte(CP_UTF8, 0, dir_int->find_data.cFileName, -1, 
+    WideCharToMultiByte(CP_UTF8, 0, dir_int->find_data.cFileName, -1,
        dir_int->entry.d_name, sizeof(dir_int->entry.d_name), NULL, NULL);
-    
+
    if (FindNextFileW(dir_int->find_handle, &dir_int->find_data) == 0)
    {
        if (GetLastError() != ERROR_NO_MORE_FILES)
@@ -280,7 +307,7 @@ struct dirent* mz_win32_read_dir(DIR *dir)

        dir_int->end = 1;
    }
- 
+
    return &dir_int->entry;
 }

@@ -294,7 +321,7 @@ int32_t mz_win32_close_dir(DIR *dir)
    dir_int = (DIR_int *)dir;
    if (dir_int->find_handle != INVALID_HANDLE_VALUE)
        FindClose(dir_int->find_handle);
-    free(dir_int);
+    MZ_FREE(dir_int);
    return MZ_OK;
 }

@@ -314,4 +341,4 @@ int32_t mz_win32_is_dir(const char *path)
    }

    return MZ_EXIST_ERROR;
-}
+}
@@ -1,8 +1,8 @@
 /* mz_os_win32.h -- System functions for Windows
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -20,7 +20,7 @@ extern "C" {

 /***************************************************************************/

-#define MZ_VERSION_MADEBY (10)
+#define MZ_VERSION_MADEBY_HOST_SYSTEM   (MZ_HOST_SYSTEM_WINDOWS_NTFS)

 /***************************************************************************/

@@ -36,25 +36,29 @@ int32_t mz_win32_file_exists(const char *path);
 int64_t mz_win32_get_file_size(const char *path);
 int32_t mz_win32_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
 int32_t mz_win32_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
+int32_t mz_win32_get_file_attribs(const char *path, int32_t *attributes);
+int32_t mz_win32_set_file_attribs(const char *path, int32_t attributes);
 int32_t mz_win32_make_dir(const char *path);
 DIR*    mz_win32_open_dir(const char *path);
-struct 
+struct
 dirent* mz_win32_read_dir(DIR *dir);
 int32_t mz_win32_close_dir(DIR *dir);
 int32_t mz_win32_is_dir(const char *path);

 /***************************************************************************/

-#define mz_os_rand           mz_win32_rand
-#define mz_os_file_exists    mz_win32_file_exists
-#define mz_os_get_file_size  mz_win32_get_file_size
-#define mz_os_get_file_date  mz_win32_get_file_date
-#define mz_os_set_file_date  mz_win32_set_file_date
-#define mz_os_make_dir       mz_win32_make_dir
-#define mz_os_open_dir       mz_win32_open_dir
-#define mz_os_read_dir       mz_win32_read_dir
-#define mz_os_close_dir      mz_win32_close_dir
-#define mz_os_is_dir         mz_win32_is_dir
+#define mz_os_rand              mz_win32_rand
+#define mz_os_file_exists       mz_win32_file_exists
+#define mz_os_get_file_size     mz_win32_get_file_size
+#define mz_os_get_file_date     mz_win32_get_file_date
+#define mz_os_set_file_date     mz_win32_set_file_date
+#define mz_os_get_file_attribs  mz_win32_get_file_attribs
+#define mz_os_set_file_attribs  mz_win32_set_file_attribs
+#define mz_os_make_dir          mz_win32_make_dir
+#define mz_os_open_dir          mz_win32_open_dir
+#define mz_os_read_dir          mz_win32_read_dir
+#define mz_os_close_dir         mz_win32_close_dir
+#define mz_os_is_dir            mz_win32_is_dir

 /***************************************************************************/

@@ -1,8 +1,8 @@
 /* mz_strm.c -- Stream interface
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -270,7 +270,7 @@ void mz_stream_delete(void **stream)

 /***************************************************************************/

-mz_stream_vtbl mz_stream_crc32_vtbl = {
+static mz_stream_vtbl mz_stream_crc32_vtbl = {
    mz_stream_crc32_open,
    mz_stream_crc32_is_open,
    mz_stream_crc32_read,
@@ -281,7 +281,8 @@ mz_stream_vtbl mz_stream_crc32_vtbl = {
    mz_stream_crc32_error,
    mz_stream_crc32_create,
    mz_stream_crc32_delete,
-    mz_stream_crc32_get_prop_int64
+    mz_stream_crc32_get_prop_int64,
+    NULL
 };

 /***************************************************************************/
@@ -301,6 +302,10 @@ typedef struct mz_stream_crc32_s {
 int32_t mz_stream_crc32_open(void *stream, const char *path, int32_t mode)
 {
    mz_stream_crc32 *crc32 = (mz_stream_crc32 *)stream;
+
+    MZ_UNUSED(path);
+    MZ_UNUSED(mode);
+
    crc32->initialized = 1;
    crc32->value = 0;
    return MZ_OK;
@@ -393,7 +398,7 @@ void *mz_stream_crc32_create(void **stream)
 {
    mz_stream_crc32 *crc32 = NULL;

-    crc32 = (mz_stream_crc32 *)malloc(sizeof(mz_stream_crc32));
+    crc32 = (mz_stream_crc32 *)MZ_ALLOC(sizeof(mz_stream_crc32));
    if (crc32 != NULL)
    {
        memset(crc32, 0, sizeof(mz_stream_crc32));
@@ -412,7 +417,7 @@ void mz_stream_crc32_delete(void **stream)
        return;
    crc32 = (mz_stream_crc32 *)*stream;
    if (crc32 != NULL)
-        free(crc32);
+        MZ_FREE(crc32);
    *stream = NULL;
 }

@@ -434,6 +439,10 @@ typedef struct mz_stream_raw_s {

 int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode)
 {
+    MZ_UNUSED(stream);
+    MZ_UNUSED(path);
+    MZ_UNUSED(mode);
+
    return MZ_OK;
 }

@@ -486,6 +495,8 @@ int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin)

 int32_t mz_stream_raw_close(void *stream)
 {
+    MZ_UNUSED(stream);
+
    return MZ_OK;
 }

@@ -524,7 +535,7 @@ int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value)

 /***************************************************************************/

-mz_stream_vtbl mz_stream_raw_vtbl = {
+static mz_stream_vtbl mz_stream_raw_vtbl = {
    mz_stream_raw_open,
    mz_stream_raw_is_open,
    mz_stream_raw_read,
@@ -545,7 +556,7 @@ void *mz_stream_raw_create(void **stream)
 {
    mz_stream_raw *raw = NULL;

-    raw = (mz_stream_raw *)malloc(sizeof(mz_stream_raw));
+    raw = (mz_stream_raw *)MZ_ALLOC(sizeof(mz_stream_raw));
    if (raw != NULL)
    {
        memset(raw, 0, sizeof(mz_stream_raw));
@@ -564,6 +575,6 @@ void mz_stream_raw_delete(void **stream)
        return;
    raw = (mz_stream_raw *)*stream;
    if (raw != NULL)
-        free(raw);
+        MZ_FREE(raw);
    *stream = NULL;
 }
@@ -1,8 +1,8 @@
 /* mz_strm.h -- Stream interface
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -122,6 +122,18 @@ void*   mz_stream_crc32_get_interface(void);

 /***************************************************************************/

+int32_t mz_stream_raw_open(void *stream, const char *filename, int32_t mode);
+int32_t mz_stream_raw_is_open(void *stream);
+int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size);
+int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size);
+int64_t mz_stream_raw_tell(void *stream);
+int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin);
+int32_t mz_stream_raw_close(void *stream);
+int32_t mz_stream_raw_error(void *stream);
+
+int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value);
+int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value);
+
 void*   mz_stream_raw_create(void **stream);
 void    mz_stream_raw_delete(void **stream);

@@ -1,8 +1,8 @@
 /* mz_strm_aes.c -- Stream for WinZip AES encryption
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2010 Brian Gladman, Worcester, UK

@@ -38,7 +38,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_aes_vtbl = {
+static mz_stream_vtbl mz_stream_aes_vtbl = {
    mz_stream_aes_open,
    mz_stream_aes_is_open,
    mz_stream_aes_read,
@@ -49,7 +49,8 @@ mz_stream_vtbl mz_stream_aes_vtbl = {
    mz_stream_aes_error,
    mz_stream_aes_create,
    mz_stream_aes_delete,
-    mz_stream_aes_get_prop_int64
+    mz_stream_aes_get_prop_int64,
+    NULL
 };

 /***************************************************************************/
@@ -66,7 +67,7 @@ typedef struct mz_stream_aes_s {
    const char      *password;
    aes_encrypt_ctx encr_ctx[1];
    hmac_ctx        auth_ctx[1];
-    uint8_t         nonce[AES_BLOCK_SIZE]; 
+    uint8_t         nonce[AES_BLOCK_SIZE];
    uint8_t         encr_bfr[AES_BLOCK_SIZE];
    uint32_t        encr_pos;
 } mz_stream_aes;
@@ -84,7 +85,6 @@ int32_t mz_stream_aes_open(void *stream, const char *path, int32_t mode)
    const char *password = path;
    int32_t password_length = 0;
    int32_t key_length = 0;
-    int32_t err = MZ_OK;

    aes->total_in = 0;
    aes->total_out = 0;
@@ -117,12 +117,12 @@ int32_t mz_stream_aes_open(void *stream, const char *path, int32_t mode)

    key_length = MZ_AES_KEY_LENGTH(aes->encryption_mode);
    // Derive the encryption and authentication keys and the password verifier
-    derive_key(password, password_length, salt_value, salt_length,
+    derive_key((const uint8_t *)password, password_length, salt_value, salt_length,
        MZ_AES_KEYING_ITERATIONS, kbuf, 2 * key_length + MZ_AES_PW_VERIFY_SIZE);

    // Initialize the encryption nonce and buffer pos
    aes->encr_pos = AES_BLOCK_SIZE;
-    memset(aes->nonce, 0, AES_BLOCK_SIZE * sizeof(unsigned char));
+    memset(aes->nonce, 0, AES_BLOCK_SIZE * sizeof(uint8_t));

    // Initialize for encryption using key 1
    aes_encrypt_key(kbuf, key_length, aes->encr_ctx);
@@ -155,7 +155,7 @@ int32_t mz_stream_aes_open(void *stream, const char *path, int32_t mode)
        aes->total_in += MZ_AES_PW_VERIFY_SIZE;

        if (memcmp(verify_expected, verify, MZ_AES_PW_VERIFY_SIZE) != 0)
-            return MZ_STREAM_ERROR;
+            return MZ_PASSWORD_ERROR;
    }

    aes->mode = mode;
@@ -172,7 +172,7 @@ int32_t mz_stream_aes_is_open(void *stream)
    return MZ_OK;
 }

-int32_t mz_stream_aes_encrypt_data(void *stream, uint8_t *buf, int32_t size)
+static int32_t mz_stream_aes_encrypt_data(void *stream, uint8_t *buf, int32_t size)
 {
    mz_stream_aes *aes = (mz_stream_aes *)stream;
    uint32_t pos = aes->encr_pos;
@@ -300,10 +300,10 @@ int32_t mz_stream_aes_get_prop_int64(void *stream, int32_t prop, int64_t *value)
    mz_stream_aes *aes = (mz_stream_aes *)stream;
    switch (prop)
    {
-    case MZ_STREAM_PROP_TOTAL_IN: 
+    case MZ_STREAM_PROP_TOTAL_IN:
        *value = aes->total_in;
        return MZ_OK;
-    case MZ_STREAM_PROP_TOTAL_OUT: 
+    case MZ_STREAM_PROP_TOTAL_OUT:
        *value = aes->total_out;
        return MZ_OK;
    case MZ_STREAM_PROP_HEADER_SIZE:
@@ -320,7 +320,7 @@ void *mz_stream_aes_create(void **stream)
 {
    mz_stream_aes *aes = NULL;

-    aes = (mz_stream_aes *)malloc(sizeof(mz_stream_aes));
+    aes = (mz_stream_aes *)MZ_ALLOC(sizeof(mz_stream_aes));
    if (aes != NULL)
    {
        memset(aes, 0, sizeof(mz_stream_aes));
@@ -340,7 +340,7 @@ void mz_stream_aes_delete(void **stream)
        return;
    aes = (mz_stream_aes *)*stream;
    if (aes != NULL)
-        free(aes);
+        MZ_FREE(aes);
    *stream = NULL;
 }

@@ -1,8 +1,8 @@
 /* mz_strm_aes.h -- Stream for WinZIP AES encryption
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -1,10 +1,10 @@
 /* mz_strm_buf.c -- Stream for buffering reads/writes
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

   This version of ioapi is designed to buffer IO.

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -24,14 +24,14 @@
 /***************************************************************************/

 #if 0
-#  define mz_stream_buffered_print(o,s,f,...) printf(o,s,f,__VA_ARGS__);
+#  define mz_stream_buffered_print(s,f,...) printf(f,__VA_ARGS__);
 #else
-#  define mz_stream_buffered_print(o,s,f,...)
+#  define mz_stream_buffered_print(s,f,...)
 #endif

 /***************************************************************************/

-mz_stream_vtbl mz_stream_buffered_vtbl = {
+static mz_stream_vtbl mz_stream_buffered_vtbl = {
    mz_stream_buffered_open,
    mz_stream_buffered_is_open,
    mz_stream_buffered_read,
@@ -41,7 +41,9 @@ mz_stream_vtbl mz_stream_buffered_vtbl = {
    mz_stream_buffered_close,
    mz_stream_buffered_error,
    mz_stream_buffered_create,
-    mz_stream_buffered_delete
+    mz_stream_buffered_delete,
+    NULL,
+    NULL
 };

 /***************************************************************************/
@@ -66,17 +68,18 @@ typedef struct mz_stream_buffered_s {

 int32_t mz_stream_buffered_open(void *stream, const char *path, int32_t mode)
 {
-    //mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
-    //mz_stream_buffered_print(opaque, buffered, "open [mode %d]\n", mode);
-    return mz_stream_open(stream, path, mode);
+    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
+    mz_stream_buffered_print(buffered, "open [mode %d]\n", mode);
+    return mz_stream_open(buffered->stream.base, path, mode);
 }

 int32_t mz_stream_buffered_is_open(void *stream)
 {
-    return mz_stream_is_open(stream);
+    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
+    return mz_stream_is_open(buffered->stream.base);
 }

-int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
+static int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
 {
    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
    int32_t total_bytes_written = 0;
@@ -88,7 +91,7 @@ int32_t mz_stream_buffered_flush(void *stream, int32_t *written)

    while (bytes_left_to_write > 0)
    {
-        bytes_written = mz_stream_write(buffered->stream.base, 
+        bytes_written = mz_stream_write(buffered->stream.base,
            buffered->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);

        if (bytes_written != bytes_left_to_write)
@@ -96,7 +99,7 @@ int32_t mz_stream_buffered_flush(void *stream, int32_t *written)

        buffered->writebuf_misses += 1;

-        mz_stream_buffered_print(opaque, stream, "write flush [%d:%d len %d]\n", 
+        mz_stream_buffered_print(stream, "write flush [%d:%d len %d]\n",
            bytes_to_write, bytes_left_to_write, buffered->writebuf_len);

        total_bytes_written += bytes_written;
@@ -120,10 +123,10 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
    int32_t bytes_left_to_read = size;
    int32_t bytes_read = 0;

-    mz_stream_buffered_print(opaque, stream, "read [size %ld pos %lld]\n", size, buffered->position);
+    mz_stream_buffered_print(stream, "read [size %ld pos %lld]\n", size, buffered->position);

    if (buffered->writebuf_len > 0)
-        mz_stream_buffered_print(opaque, stream, "switch from write to read, not yet supported [%lld]\n", 
+        mz_stream_buffered_print(stream, "switch from write to read, not yet supported [%lld]\n",
            buffered->position);

    while (bytes_left_to_read > 0)
@@ -137,15 +140,15 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
            }

            bytes_to_read = sizeof(buffered->readbuf) - (buffered->readbuf_len - buffered->readbuf_pos);
-
-            if (mz_stream_read(buffered->stream.base, buffered->readbuf + buffered->readbuf_pos, bytes_to_read) != bytes_to_read)
-                return 0;
+            bytes_read = mz_stream_read(buffered->stream.base, buffered->readbuf + buffered->readbuf_pos, bytes_to_read);
+            if (bytes_read < 0)
+                return bytes_read;

            buffered->readbuf_misses += 1;
            buffered->readbuf_len += bytes_read;
            buffered->position += bytes_read;

-            mz_stream_buffered_print(opaque, stream, "filled [read %d/%d buf %d:%d pos %lld]\n", 
+            mz_stream_buffered_print(stream, "filled [read %d/%d buf %d:%d pos %lld]\n",
                bytes_read, bytes_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);

            if (bytes_read == 0)
@@ -166,7 +169,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
            buffered->readbuf_hits += 1;
            buffered->readbuf_pos += bytes_to_copy;

-            mz_stream_buffered_print(opaque, stream, "emptied [copied %d remaining %d buf %d:%d pos %lld]\n", 
+            mz_stream_buffered_print(stream, "emptied [copied %d remaining %d buf %d:%d pos %lld]\n",
                bytes_to_copy, bytes_left_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
        }
    }
@@ -184,7 +187,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
    int32_t bytes_flushed = 0;


-    mz_stream_buffered_print(opaque, stream, "write [size %ld len %d pos %lld]\n", 
+    mz_stream_buffered_print(stream, "write [size %ld len %d pos %lld]\n",
        size, buffered->writebuf_len, buffered->position);

    if (buffered->readbuf_len > 0)
@@ -195,7 +198,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
        buffered->readbuf_len = 0;
        buffered->readbuf_pos = 0;

-        mz_stream_buffered_print(opaque, stream, "switch from read to write [%lld]\n", buffered->position);
+        mz_stream_buffered_print(stream, "switch from read to write [%lld]\n", buffered->position);

        if (mz_stream_seek(buffered->stream.base, buffered->position, MZ_SEEK_SET) != MZ_OK)
            return MZ_STREAM_ERROR;
@@ -220,9 +223,9 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
            continue;
        }

-        memcpy(buffered->writebuf + buffered->writebuf_pos, (char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);
+        memcpy(buffered->writebuf + buffered->writebuf_pos, (const char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);

-        mz_stream_buffered_print(opaque, stream, "write copy [remaining %d write %d:%d len %d]\n", 
+        mz_stream_buffered_print(stream, "write copy [remaining %d write %d:%d len %d]\n",
            bytes_to_copy, bytes_to_write, bytes_left_to_write, buffered->writebuf_len);

        bytes_left_to_write -= bytes_to_copy;
@@ -236,12 +239,14 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
    return size - bytes_left_to_write;
 }

-int64_t mz_stream_buffered_tellinternal(void *stream, uint64_t position)
+int64_t mz_stream_buffered_tell(void *stream)
 {
    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
+    int64_t position = mz_stream_tell(buffered->stream.base);
+
    buffered->position = position;

-    mz_stream_buffered_print(opaque, stream, "tell [pos %llu readpos %d writepos %d err %d]\n", 
+    mz_stream_buffered_print(stream, "tell [pos %llu readpos %d writepos %d err %d]\n",
        buffered->position, buffered->readbuf_pos, buffered->writebuf_pos, errno);

    if (buffered->readbuf_len > 0)
@@ -251,19 +256,12 @@ int64_t mz_stream_buffered_tellinternal(void *stream, uint64_t position)
    return position;
 }

-int64_t mz_stream_buffered_tell(void *stream)
-{
-    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
-    int64_t position = mz_stream_tell(buffered->stream.base);
-    return mz_stream_buffered_tellinternal(stream, position);
-}
-
-int mz_stream_buffered_seekinternal(void *stream, int64_t offset, int32_t origin)
+int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin)
 {
    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
    int32_t bytes_flushed = 0;

-    mz_stream_buffered_print(opaque, stream, "seek [origin %d offset %llu pos %lld]\n", origin, offset, buffered->position);
+    mz_stream_buffered_print(stream, "seek [origin %d offset %llu pos %lld]\n", origin, offset, buffered->position);

    switch (origin)
    {
@@ -278,7 +276,7 @@ int mz_stream_buffered_seekinternal(void *stream, int64_t offset, int32_t origin
                }
            }

-            if ((buffered->readbuf_len > 0) && (offset < buffered->position) && 
+            if ((buffered->readbuf_len > 0) && (offset < buffered->position) &&
                (offset >= buffered->position - buffered->readbuf_len))
            {
                buffered->readbuf_pos = (uint32_t)(offset - (buffered->position - buffered->readbuf_len));
@@ -332,14 +330,7 @@ int mz_stream_buffered_seekinternal(void *stream, int64_t offset, int32_t origin
    buffered->readbuf_pos = 0;
    buffered->writebuf_len = 0;
    buffered->writebuf_pos = 0;
-    return MZ_STREAM_ERROR;
-}

-int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin)
-{
-    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
-    if (mz_stream_buffered_seekinternal(stream, offset, origin) != MZ_OK)
-        return MZ_STREAM_ERROR;
    return mz_stream_seek(buffered->stream.base, offset, origin);
 }

@@ -349,30 +340,30 @@ int32_t mz_stream_buffered_close(void *stream)
    int32_t bytes_flushed = 0;

    mz_stream_buffered_flush(stream, &bytes_flushed);
-    mz_stream_buffered_print(opaque, stream, "close\n");
+    mz_stream_buffered_print(stream, "close\n");

    if (buffered->readbuf_hits + buffered->readbuf_misses > 0)
-        mz_stream_buffered_print(opaque, stream, "read efficency %.02f%%\n", 
+        mz_stream_buffered_print(stream, "read efficency %.02f%%\n",
            (buffered->readbuf_hits / ((float)buffered->readbuf_hits + buffered->readbuf_misses)) * 100);

    if (buffered->writebuf_hits + buffered->writebuf_misses > 0)
-        mz_stream_buffered_print(opaque, stream, "write efficency %.02f%%\n", 
+        mz_stream_buffered_print(stream, "write efficency %.02f%%\n",
            (buffered->writebuf_hits / ((float)buffered->writebuf_hits + buffered->writebuf_misses)) * 100);

-    return mz_stream_close(&buffered->stream.base);
+    return mz_stream_close(buffered->stream.base);
 }

 int32_t mz_stream_buffered_error(void *stream)
 {
    mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
-    return mz_stream_error(&buffered->stream.base);
+    return mz_stream_error(buffered->stream.base);
 }

 void *mz_stream_buffered_create(void **stream)
 {
    mz_stream_buffered *buffered = NULL;

-    buffered = (mz_stream_buffered *)malloc(sizeof(mz_stream_buffered));
+    buffered = (mz_stream_buffered *)MZ_ALLOC(sizeof(mz_stream_buffered));
    if (buffered != NULL)
    {
        memset(buffered, 0, sizeof(mz_stream_buffered));
@@ -391,7 +382,7 @@ void mz_stream_buffered_delete(void **stream)
        return;
    buffered = (mz_stream_buffered *)*stream;
    if (buffered != NULL)
-        free(buffered);
+        MZ_FREE(buffered);
    *stream = NULL;
 }

@@ -1,10 +1,10 @@
 /* mz_strm_buf.h -- Stream for buffering reads/writes
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

   This version of ioapi is designed to buffer IO.

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -1,8 +1,8 @@
 /* mz_strm_bzip.c -- Stream for bzip inflate/deflate
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as bzip.
@@ -23,7 +23,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_bzip_vtbl = {
+static mz_stream_vtbl mz_stream_bzip_vtbl = {
    mz_stream_bzip_open,
    mz_stream_bzip_is_open,
    mz_stream_bzip_read,
@@ -61,6 +61,7 @@ int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode)
 {
    mz_stream_bzip *bzip = (mz_stream_bzip *)stream;

+    MZ_UNUSED(path);

    bzip->bzstream.bzalloc = 0;
    bzip->bzstream.bzfree = 0;
@@ -125,7 +126,7 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
        return 0;

    bzip->bzstream.next_out = (char *)buf;
-    bzip->bzstream.avail_out = (uint16_t)size;
+    bzip->bzstream.avail_out = (unsigned int)size;

    do
    {
@@ -136,7 +137,7 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
            {
                if ((bzip->max_total_in - bzip->total_in) < sizeof(bzip->buffer))
                    bytes_to_read = (int32_t)(bzip->max_total_in - bzip->total_in);
-            }    
+            }

            read = mz_stream_read(bzip->stream.base, bzip->buffer, bytes_to_read);

@@ -153,13 +154,13 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
        }

        total_in_before = bzip->bzstream.avail_in;
-        total_out_before = bzip->bzstream.total_out_lo32 + 
+        total_out_before = bzip->bzstream.total_out_lo32 +
                (((uint64_t)bzip->bzstream.total_out_hi32) << 32);

        err = BZ2_bzDecompress(&bzip->bzstream);

        total_in_after = bzip->bzstream.avail_in;
-        total_out_after = bzip->bzstream.total_out_lo32 + 
+        total_out_after = bzip->bzstream.total_out_lo32 +
                (((uint64_t)bzip->bzstream.total_out_hi32) << 32);

        in_bytes = (uint32_t)(total_in_before - total_in_after);
@@ -190,7 +191,7 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
    return total_out;
 }

-int32_t mz_stream_bzip_flush(void *stream)
+static int32_t mz_stream_bzip_flush(void *stream)
 {
    mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
    if (mz_stream_write(bzip->stream.base, bzip->buffer, bzip->buffer_len) != bzip->buffer_len)
@@ -198,7 +199,7 @@ int32_t mz_stream_bzip_flush(void *stream)
    return MZ_OK;
 }

-int32_t mz_stream_bzip_compress(void *stream, int flush)
+static int32_t mz_stream_bzip_compress(void *stream, int flush)
 {
    mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
    uint64_t total_out_before = 0;
@@ -222,24 +223,26 @@ int32_t mz_stream_bzip_compress(void *stream, int flush)
            bzip->buffer_len = 0;
        }

-        total_out_before = bzip->bzstream.total_out_lo32 + 
+        total_out_before = bzip->bzstream.total_out_lo32 +
                (((uint64_t)bzip->bzstream.total_out_hi32) << 32);

        err = BZ2_bzCompress(&bzip->bzstream, flush);

-        total_out_after = bzip->bzstream.total_out_lo32 + 
+        total_out_after = bzip->bzstream.total_out_lo32 +
                (((uint64_t)bzip->bzstream.total_out_hi32) << 32);

        out_bytes = (uint32_t)(total_out_after - total_out_before);

+        bzip->buffer_len += out_bytes;
+        bzip->total_out += out_bytes;
+
+        if (err == BZ_STREAM_END)
+            break;
        if (err < 0)
        {
            bzip->error = err;
            return MZ_STREAM_ERROR;
        }
-
-        bzip->buffer_len += out_bytes;
-        bzip->total_out += out_bytes;
    }
    while ((bzip->bzstream.avail_in > 0) || (flush == BZ_FINISH && err == BZ_FINISH_OK));

@@ -252,7 +255,7 @@ int32_t mz_stream_bzip_write(void *stream, const void *buf, int32_t size)


    bzip->bzstream.next_in = (char *)buf;
-    bzip->bzstream.avail_in = size;
+    bzip->bzstream.avail_in = (unsigned int)size;

    mz_stream_bzip_compress(stream, BZ_RUN);

@@ -263,11 +266,17 @@ int32_t mz_stream_bzip_write(void *stream, const void *buf, int32_t size)

 int64_t mz_stream_bzip_tell(void *stream)
 {
+    MZ_UNUSED(stream);
+
    return MZ_STREAM_ERROR;
 }

 int32_t mz_stream_bzip_seek(void *stream, int64_t offset, int32_t origin)
 {
+    MZ_UNUSED(stream);
+    MZ_UNUSED(offset);
+    MZ_UNUSED(origin);
+
    return MZ_STREAM_ERROR;
 }

@@ -340,7 +349,7 @@ void *mz_stream_bzip_create(void **stream)
 {
    mz_stream_bzip *bzip = NULL;

-    bzip = (mz_stream_bzip *)malloc(sizeof(mz_stream_bzip));
+    bzip = (mz_stream_bzip *)MZ_ALLOC(sizeof(mz_stream_bzip));
    if (bzip != NULL)
    {
        memset(bzip, 0, sizeof(mz_stream_bzip));
@@ -360,7 +369,7 @@ void mz_stream_bzip_delete(void **stream)
        return;
    bzip = (mz_stream_bzip *)*stream;
    if (bzip != NULL)
-        free(bzip);
+        MZ_FREE(bzip);
    *stream = NULL;
 }

@@ -371,4 +380,5 @@ void *mz_stream_bzip_get_interface(void)

 extern void bz_internal_error(int errcode)
 {
+    MZ_UNUSED(errcode);
 }
@@ -1,8 +1,8 @@
 /* mz_strm_bzip.h -- Stream for bzip inflate/deflate
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -37,6 +37,8 @@ void    mz_stream_bzip_delete(void **stream);

 void*   mz_stream_bzip_get_interface(void);

+void    bz_internal_error(int errcode);
+
 /***************************************************************************/

 #ifdef __cplusplus
@@ -1,8 +1,8 @@
 /* mz_strm_crypt.c -- Code for traditional PKWARE encryption
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2005 Gilles Vollant
     Modifications for Info-ZIP crypting
@@ -40,7 +40,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_crypt_vtbl = {
+static mz_stream_vtbl mz_stream_crypt_vtbl = {
    mz_stream_crypt_open,
    mz_stream_crypt_is_open,
    mz_stream_crypt_read,
@@ -51,7 +51,8 @@ mz_stream_vtbl mz_stream_crypt_vtbl = {
    mz_stream_crypt_error,
    mz_stream_crypt_create,
    mz_stream_crypt_delete,
-    mz_stream_crypt_get_prop_int64
+    mz_stream_crypt_get_prop_int64,
+    NULL
 };

 /***************************************************************************/
@@ -64,7 +65,7 @@ typedef struct mz_stream_crypt_s {
    int64_t         total_in;
    int64_t         total_out;
    uint32_t        keys[3];          // keys defining the pseudo-random sequence
-    const z_crc_t   *crc_32_tab;
+    const uint32_t  *crc_32_tab;
    uint8_t         verify1;
    uint8_t         verify2;
    const char      *password;
@@ -80,7 +81,7 @@ typedef struct mz_stream_crypt_s {

 /***************************************************************************/

-uint8_t mz_stream_crypt_decrypt_byte(uint32_t *keys)
+static uint8_t mz_stream_crypt_decrypt_byte(uint32_t *keys)
 {
    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
                     * unpredictable manner on 16-bit systems; not a problem
@@ -90,7 +91,7 @@ uint8_t mz_stream_crypt_decrypt_byte(uint32_t *keys)
    return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
 }

-uint8_t mz_stream_crypt_update_keys(uint32_t *keys, const z_crc_t *crc_32_tab, int32_t c)
+static uint8_t mz_stream_crypt_update_keys(uint32_t *keys, const uint32_t *crc_32_tab, int32_t c)
 {
    #define CRC32(c, b) ((*(crc_32_tab+(((uint32_t)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))

@@ -104,7 +105,7 @@ uint8_t mz_stream_crypt_update_keys(uint32_t *keys, const z_crc_t *crc_32_tab, i
    return (uint8_t)c;
 }

-void mz_stream_crypt_init_keys(const char *password, uint32_t *keys, const z_crc_t *crc_32_tab)
+static void mz_stream_crypt_init_keys(const char *password, uint32_t *keys, const uint32_t *crc_32_tab)
 {
    *(keys+0) = 305419896L;
    *(keys+1) = 591751049L;
@@ -124,6 +125,8 @@ int32_t mz_stream_crypt_open(void *stream, const char *path, int32_t mode)
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    uint16_t t = 0;
    int16_t i = 0;
+    uint8_t verify1 = 0;
+    uint8_t verify2 = 0;
    uint8_t header[RAND_HEAD_LEN];
    const char *password = path;

@@ -149,11 +152,11 @@ int32_t mz_stream_crypt_open(void *stream, const char *path, int32_t mode)
    {
        // First generate RAND_HEAD_LEN - 2 random bytes.
        mz_os_rand(header, RAND_HEAD_LEN - 2);
-        
+
        // Encrypt random header (last two bytes is high word of crc)
        for (i = 0; i < RAND_HEAD_LEN - 2; i++)
            header[i] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, header[i], t);
-        
+
        header[i++] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, crypt->verify1, t);
        header[i++] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, crypt->verify2, t);

@@ -170,8 +173,12 @@ int32_t mz_stream_crypt_open(void *stream, const char *path, int32_t mode)
        for (i = 0; i < RAND_HEAD_LEN - 2; i++)
            header[i] = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i]);

-        crypt->verify1 = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i++]);
-        crypt->verify2 = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i++]);
+        verify1 = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i++]);
+        verify2 = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i++]);
+
+        // Older versions used 2 byte check, newer versions use 1 byte check.
+        if ((verify2 != 0) && (verify2 != crypt->verify2))
+            return MZ_PASSWORD_ERROR;

        crypt->total_in += RAND_HEAD_LEN;
    }
@@ -207,7 +214,7 @@ int32_t mz_stream_crypt_read(void *stream, void *buf, int32_t size)
 int32_t mz_stream_crypt_write(void *stream, const void *buf, int32_t size)
 {
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
-    uint8_t *buf_ptr = (uint8_t *)buf;
+    const uint8_t *buf_ptr = (const uint8_t *)buf;
    uint32_t written = 0;
    uint16_t t = 0;
    int32_t i = 0;
@@ -290,7 +297,7 @@ void *mz_stream_crypt_create(void **stream)
 {
    mz_stream_crypt *crypt = NULL;

-    crypt = (mz_stream_crypt *)malloc(sizeof(mz_stream_crypt));
+    crypt = (mz_stream_crypt *)MZ_ALLOC(sizeof(mz_stream_crypt));
    if (crypt != NULL)
    {
        memset(crypt, 0, sizeof(mz_stream_crypt));
@@ -309,11 +316,11 @@ void mz_stream_crypt_delete(void **stream)
        return;
    crypt = (mz_stream_crypt *)*stream;
    if (crypt != NULL)
-        free(crypt);
+        MZ_FREE(crypt);
    *stream = NULL;
 }

 void *mz_stream_crypt_get_interface(void)
 {
    return (void *)&mz_stream_crypt_vtbl;
-}
+}
@@ -1,8 +1,8 @@
 /* mz_strm_crypt.h -- Code for traditional PKWARE encryption
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 1998-2005 Gilles Vollant
     Modifications for Info-ZIP crypting
@@ -1,8 +1,8 @@
 /* mz_strm_lzma.c -- Stream for lzma inflate/deflate
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as lzma.
@@ -28,7 +28,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_lzma_vtbl = {
+static mz_stream_vtbl mz_stream_lzma_vtbl = {
    mz_stream_lzma_open,
    mz_stream_lzma_is_open,
    mz_stream_lzma_read,
@@ -55,6 +55,7 @@ typedef struct mz_stream_lzma_s {
    int64_t     total_in;
    int64_t     total_out;
    int64_t     max_total_in;
+    int64_t     max_total_out;
    int8_t      initialized;
    uint32_t    preset;
 } mz_stream_lzma;
@@ -65,11 +66,15 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
 {
    mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
    lzma_filter filters[LZMA_FILTERS_MAX + 1];
-    lzma_options_lzma opt_lzma = { 0 };
+    lzma_options_lzma opt_lzma;
    uint32_t size = 0;
    uint8_t major = 0;
    uint8_t minor = 0;

+    MZ_UNUSED(path);
+
+    memset(&opt_lzma, 0, sizeof(opt_lzma));
+
    lzma->lstream.total_in = 0;
    lzma->lstream.total_out = 0;

@@ -91,7 +96,7 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
        filters[1].id = LZMA_VLI_UNKNOWN;

        lzma_properties_size(&size, (lzma_filter *)&filters);
-        
+
        mz_stream_write_uint8(lzma->stream.base, LZMA_VERSION_MAJOR);
        mz_stream_write_uint8(lzma->stream.base, LZMA_VERSION_MINOR);
        mz_stream_write_uint16(lzma->stream.base, (uint16_t)size);
@@ -113,7 +118,7 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)

        lzma->error = lzma_alone_decoder(&lzma->lstream, UINT64_MAX);
    }
-    
+
    if (lzma->error != LZMA_OK)
        return MZ_STREAM_ERROR;

@@ -147,7 +152,7 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)


    lzma->lstream.next_out = (uint8_t*)buf;
-    lzma->lstream.avail_out = (uint16_t)size;
+    lzma->lstream.avail_out = (size_t)size;

    do
    {
@@ -159,7 +164,7 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
                if ((lzma->max_total_in - lzma->total_in) < sizeof(lzma->buffer))
                    bytes_to_read = (int32_t)(lzma->max_total_in - lzma->total_in);
            }
-            
+
            read = mz_stream_read(lzma->stream.base, lzma->buffer, bytes_to_read);

            if (read < 0)
@@ -181,7 +186,9 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)

        total_in_after = lzma->lstream.avail_in;
        total_out_after = lzma->lstream.total_out;
-        
+        if ((lzma->max_total_out != -1) && (int64_t)total_out_after > lzma->max_total_out)
+            total_out_after = lzma->max_total_out;
+
        in_bytes = (uint32_t)(total_in_before - total_in_after);
        out_bytes = (uint32_t)(total_out_after - total_out_before);

@@ -207,7 +214,7 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
    return total_out;
 }

-int32_t mz_stream_lzma_flush(void *stream)
+static int32_t mz_stream_lzma_flush(void *stream)
 {
    mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
    if (mz_stream_write(lzma->stream.base, lzma->buffer, lzma->buffer_len) != lzma->buffer_len)
@@ -215,7 +222,7 @@ int32_t mz_stream_lzma_flush(void *stream)
    return MZ_OK;
 }

-int32_t mz_stream_lzma_code(void *stream, int32_t flush)
+static int32_t mz_stream_lzma_code(void *stream, int32_t flush)
 {
    mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
    uint64_t total_out_before = 0;
@@ -266,7 +273,7 @@ int32_t mz_stream_lzma_write(void *stream, const void *buf, int32_t size)


    lzma->lstream.next_in = (uint8_t*)buf;
-    lzma->lstream.avail_in = size;
+    lzma->lstream.avail_in = (size_t)size;

    mz_stream_lzma_code(stream, LZMA_RUN);

@@ -277,11 +284,17 @@ int32_t mz_stream_lzma_write(void *stream, const void *buf, int32_t size)

 int64_t mz_stream_lzma_tell(void *stream)
 {
+    MZ_UNUSED(stream);
+
    return MZ_STREAM_ERROR;
 }

 int32_t mz_stream_lzma_seek(void *stream, int64_t offset, int32_t origin)
 {
+    MZ_UNUSED(stream);
+    MZ_UNUSED(offset);
+    MZ_UNUSED(origin);
+
    return MZ_STREAM_ERROR;
 }

@@ -346,6 +359,11 @@ int32_t mz_stream_lzma_set_prop_int64(void *stream, int32_t prop, int64_t value)
    case MZ_STREAM_PROP_TOTAL_IN_MAX:
        lzma->max_total_in = value;
        return MZ_OK;
+    case MZ_STREAM_PROP_TOTAL_OUT_MAX:
+        if (value < -1)
+            return MZ_PARAM_ERROR;
+        lzma->max_total_out = value;
+        return MZ_OK;
    }
    return MZ_EXIST_ERROR;
 }
@@ -354,12 +372,13 @@ void *mz_stream_lzma_create(void **stream)
 {
    mz_stream_lzma *lzma = NULL;

-    lzma = (mz_stream_lzma *)malloc(sizeof(mz_stream_lzma));
+    lzma = (mz_stream_lzma *)MZ_ALLOC(sizeof(mz_stream_lzma));
    if (lzma != NULL)
    {
        memset(lzma, 0, sizeof(mz_stream_lzma));
        lzma->stream.vtbl = &mz_stream_lzma_vtbl;
        lzma->preset = LZMA_PRESET_DEFAULT;
+        lzma->max_total_out = -1;
    }
    if (stream != NULL)
        *stream = lzma;
@@ -374,7 +393,7 @@ void mz_stream_lzma_delete(void **stream)
        return;
    lzma = (mz_stream_lzma *)*stream;
    if (lzma != NULL)
-        free(lzma);
+        MZ_FREE(lzma);
    *stream = NULL;
 }

@@ -383,7 +402,7 @@ void *mz_stream_lzma_get_interface(void)
    return (void *)&mz_stream_lzma_vtbl;
 }

-int32_t mz_stream_lzma_crc32(int32_t value, const void *buf, int32_t size)
+static int32_t mz_stream_lzma_crc32(int32_t value, const void *buf, int32_t size)
 {
    return lzma_crc32(buf, size, value);
 }
@@ -391,4 +410,4 @@ int32_t mz_stream_lzma_crc32(int32_t value, const void *buf, int32_t size)
 void *mz_stream_lzma_get_crc32_update(void)
 {
    return (void *)mz_stream_lzma_crc32;
-}
+}
@@ -1,8 +1,8 @@
 /* mz_strm_lzma.h -- Stream for lzma inflate/deflate
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as lzma.
@@ -1,13 +1,13 @@
 /* mz_strm_mem.c -- Stream for memory access
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

   This interface is designed to access memory rather than files.
-   We do use a region of memory to put data in to and take it out of. 
+   We do use a region of memory to put data in to and take it out of.

   Based on Unzip ioapi.c version 0.22, May 19th, 2003

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2003 Justin Fletcher
   Copyright (C) 1998-2003 Gilles Vollant
@@ -28,7 +28,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_mem_vtbl = {
+static mz_stream_vtbl mz_stream_mem_vtbl = {
    mz_stream_mem_open,
    mz_stream_mem_is_open,
    mz_stream_mem_read,
@@ -38,7 +38,9 @@ mz_stream_vtbl mz_stream_mem_vtbl = {
    mz_stream_mem_close,
    mz_stream_mem_error,
    mz_stream_mem_create,
-    mz_stream_mem_delete
+    mz_stream_mem_delete,
+    NULL,
+    NULL
 };

 /***************************************************************************/
@@ -46,7 +48,7 @@ mz_stream_vtbl mz_stream_mem_vtbl = {
 typedef struct mz_stream_mem_s {
    mz_stream   stream;
    int32_t     mode;
-    char        *buffer;    // Memory buffer pointer 
+    char        *buffer;    // Memory buffer pointer
    int32_t     size;       // Size of the memory buffer
    int32_t     limit;      // Furthest we've written
    int32_t     position;   // Current position in the memory
@@ -62,11 +64,11 @@ static void mz_stream_mem_set_size(void *stream, int32_t size)
    char *new_buf = NULL;


-    new_buf = (char *)malloc(new_size);
+    new_buf = (char *)MZ_ALLOC(new_size);
    if (mem->buffer)
    {
        memcpy(new_buf, mem->buffer, mem->size);
-        free(mem->buffer);
+        MZ_FREE(mem->buffer);
    }

    mem->buffer = new_buf;
@@ -77,6 +79,7 @@ int32_t mz_stream_mem_open(void *stream, const char *path, int32_t mode)
 {
    mz_stream_mem *mem = (mz_stream_mem *)stream;

+    MZ_UNUSED(path);

    mem->mode = mode;
    mem->limit = 0;
@@ -189,12 +192,16 @@ int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin)

 int32_t mz_stream_mem_close(void *stream)
 {
+    MZ_UNUSED(stream);
+
    // We never return errors
    return MZ_OK;
 }

 int32_t mz_stream_mem_error(void *stream)
 {
+    MZ_UNUSED(stream);
+
    // We never return errors
    return MZ_OK;
 }
@@ -231,7 +238,7 @@ void *mz_stream_mem_create(void **stream)
 {
    mz_stream_mem *mem = NULL;

-    mem = (mz_stream_mem *)malloc(sizeof(mz_stream_mem));
+    mem = (mz_stream_mem *)MZ_ALLOC(sizeof(mz_stream_mem));
    if (mem != NULL)
    {
        memset(mem, 0, sizeof(mz_stream_mem));
@@ -253,8 +260,8 @@ void mz_stream_mem_delete(void **stream)
    if (mem != NULL)
    {
        if ((mem->mode & MZ_OPEN_MODE_CREATE) && (mem->buffer != NULL))
-            free(mem->buffer);
-        free(mem);
+            MZ_FREE(mem->buffer);
+        MZ_FREE(mem);
    }
    *stream = NULL;
 }
@@ -262,4 +269,4 @@ void mz_stream_mem_delete(void **stream)
 void *mz_stream_mem_get_interface(void)
 {
    return (void *)&mz_stream_mem_vtbl;
-}
+}
@@ -1,8 +1,8 @@
 /* mz_strm_mem.h -- Stream for memory access
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip
   Copyright (C) 2003 Justin Fletcher
   Copyright (C) 1998-2003 Gilles Vollant
@@ -1,8 +1,8 @@
 /* mz_strm_posix.c -- Stream for filesystem access for posix/linux
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Modifications for Zip64 support
     Copyright (C) 2009-2010 Mathias Svensson
@@ -50,7 +50,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_posix_vtbl = {
+static mz_stream_vtbl mz_stream_posix_vtbl = {
    mz_stream_posix_open,
    mz_stream_posix_is_open,
    mz_stream_posix_read,
@@ -60,7 +60,9 @@ mz_stream_vtbl mz_stream_posix_vtbl = {
    mz_stream_posix_close,
    mz_stream_posix_error,
    mz_stream_posix_create,
-    mz_stream_posix_delete
+    mz_stream_posix_delete,
+    NULL,
+    NULL
 };

 /***************************************************************************/
@@ -85,7 +87,7 @@ int32_t mz_stream_posix_open(void *stream, const char *path, int32_t mode)
    if ((mode & MZ_OPEN_MODE_READWRITE) == MZ_OPEN_MODE_READ)
        mode_fopen = "rb";
    else if (mode & MZ_OPEN_MODE_APPEND)
-        mode_fopen = "ab";
+        mode_fopen = "r+b";
    else if (mode & MZ_OPEN_MODE_CREATE)
        mode_fopen = "wb";
    else
@@ -113,9 +115,9 @@ int32_t mz_stream_posix_read(void *stream, void *buf, int32_t size)
 {
    mz_stream_posix *posix = (mz_stream_posix*)stream;
    int32_t read = (int32_t)fread(buf, 1, (size_t)size, posix->handle);
-    if (read < 0)
+    if (read < size && ferror(posix->handle))
    {
-        posix->error = ferror(posix->handle);
+        posix->error = errno;
        return MZ_STREAM_ERROR;
    }
    return read;
@@ -125,9 +127,9 @@ int32_t mz_stream_posix_write(void *stream, const void *buf, int32_t size)
 {
    mz_stream_posix *posix = (mz_stream_posix*)stream;
    int32_t written = (int32_t)fwrite(buf, 1, (size_t)size, posix->handle);
-    if (written < 0)
+    if (written < size && ferror(posix->handle))
    {
-        posix->error = ferror(posix->handle);
+        posix->error = errno;
        return MZ_STREAM_ERROR;
    }
    return written;
@@ -139,7 +141,7 @@ int64_t mz_stream_posix_tell(void *stream)
    int64_t position = ftello64(posix->handle);
    if (position == -1)
    {
-        posix->error = ferror(posix->handle);
+        posix->error = errno;
        return MZ_STREAM_ERROR;
    }
    return position;
@@ -167,7 +169,7 @@ int32_t mz_stream_posix_seek(void *stream, int64_t offset, int32_t origin)

    if (fseeko64(posix->handle, offset, fseek_origin) != 0)
    {
-        posix->error = ferror(posix->handle);
+        posix->error = errno;
        return MZ_STREAM_ERROR;
    }

@@ -177,8 +179,12 @@ int32_t mz_stream_posix_seek(void *stream, int64_t offset, int32_t origin)
 int32_t mz_stream_posix_close(void *stream)
 {
    mz_stream_posix *posix = (mz_stream_posix*)stream;
-    int32_t closed = fclose(posix->handle);
-    posix->handle = NULL;
+    int32_t closed = 0;
+    if (posix->handle != NULL)
+    {
+        closed = fclose(posix->handle);
+        posix->handle = NULL;
+    }
    if (closed != 0)
    {
        posix->error = errno;
@@ -197,9 +203,12 @@ void *mz_stream_posix_create(void **stream)
 {
    mz_stream_posix *posix = NULL;

-    posix = (mz_stream_posix *)malloc(sizeof(mz_stream_posix));
+    posix = (mz_stream_posix *)MZ_ALLOC(sizeof(mz_stream_posix));
    if (posix != NULL)
+    {
+        memset(posix, 0, sizeof(mz_stream_posix));
        posix->stream.vtbl = &mz_stream_posix_vtbl;
+    }
    if (stream != NULL)
        *stream = posix;

@@ -213,7 +222,7 @@ void mz_stream_posix_delete(void **stream)
        return;
    posix = (mz_stream_posix *)*stream;
    if (posix != NULL)
-        free(posix);
+        MZ_FREE(posix);
    *stream = NULL;
 }

@@ -1,8 +1,8 @@
 /* mz_strm_posix.h -- Stream for filesystem access for posix/linux
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2009-2010 Mathias Svensson
     Modifications for Zip64 support
@@ -1,8 +1,8 @@
 /* mz_strm_split.c -- Stream for split files
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -23,9 +23,13 @@

 #define MZ_ZIP_MAGIC_DISKHEADER         (0x08074b50)

+#if defined(_MSC_VER) && _MSC_VER < 1900
+#  define snprintf _snprintf
+#endif
+
 /***************************************************************************/

-mz_stream_vtbl mz_stream_split_vtbl = {
+static mz_stream_vtbl mz_stream_split_vtbl = {
    mz_stream_split_open,
    mz_stream_split_is_open,
    mz_stream_split_read,
@@ -62,14 +66,13 @@ typedef struct mz_stream_split_s {

 /***************************************************************************/

-int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
+static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
 {
    mz_stream_split *split = (mz_stream_split *)stream;
    uint32_t magic = 0;
    int32_t i = 0;
    int32_t err = MZ_OK;
    int16_t disk_part = 0;
-    int16_t read_disk_part = 0;


    // Check if we are reading or writing a disk part or the cd disk
@@ -136,7 +139,7 @@ int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
    return err;
 }

-int32_t mz_stream_split_close_disk(void *stream)
+static int32_t mz_stream_split_close_disk(void *stream)
 {
    mz_stream_split *split = (mz_stream_split *)stream;

@@ -146,7 +149,7 @@ int32_t mz_stream_split_close_disk(void *stream)
    return mz_stream_close(split->stream.base);
 }

-int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk)
+static int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk)
 {
    mz_stream_split *split = (mz_stream_split *)stream;
    int32_t err = MZ_OK;
@@ -178,11 +181,11 @@ int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode)
    split->mode = mode;

    split->path_cd_size = strlen(path) + 1;
-    split->path_cd = (char *)malloc(split->path_cd_size);
+    split->path_cd = (char *)MZ_ALLOC(split->path_cd_size);
    strncpy(split->path_cd, path, split->path_cd_size);

    split->path_disk_size = strlen(path) + 10;
-    split->path_disk = (char *)malloc(split->path_disk_size);
+    split->path_disk = (char *)MZ_ALLOC(split->path_disk_size);
    strncpy(split->path_disk, path, split->path_disk_size);

    if (mode & MZ_OPEN_MODE_WRITE)
@@ -278,11 +281,11 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
                    bytes_to_write = bytes_avail;
            }
        }
-        
+
        written = mz_stream_write(split->stream.base, buf_ptr, bytes_to_write);
        if (written != bytes_to_write)
            return MZ_STREAM_ERROR;
-        
+
        bytes_left -= written;
        buf_ptr += written;
        split->total_out += written;
@@ -365,7 +368,7 @@ void *mz_stream_split_create(void **stream)
 {
    mz_stream_split *split = NULL;

-    split = (mz_stream_split *)malloc(sizeof(mz_stream_split));
+    split = (mz_stream_split *)MZ_ALLOC(sizeof(mz_stream_split));
    if (split != NULL)
    {
        memset(split, 0, sizeof(mz_stream_split));
@@ -386,11 +389,11 @@ void mz_stream_split_delete(void **stream)
    if (split != NULL)
    {
        if (split->path_cd)
-            free(split->path_cd);
+            MZ_FREE(split->path_cd);
        if (split->path_disk)
-            free(split->path_disk);
+            MZ_FREE(split->path_disk);

-        free(split);
+        MZ_FREE(split);
    }
    *stream = NULL;
 }
@@ -1,8 +1,8 @@
 /* mz_strm_split.h -- Stream for split files
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -1,8 +1,8 @@
 /* mz_strm_win32.c -- Stream for filesystem access for windows
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2009-2010 Mathias Svensson
     Modifications for Zip64 support
@@ -40,7 +40,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_win32_vtbl = {
+static mz_stream_vtbl mz_stream_win32_vtbl = {
    mz_stream_win32_open,
    mz_stream_win32_is_open,
    mz_stream_win32_read,
@@ -50,7 +50,9 @@ mz_stream_vtbl mz_stream_win32_vtbl = {
    mz_stream_win32_close,
    mz_stream_win32_error,
    mz_stream_win32_create,
-    mz_stream_win32_delete
+    mz_stream_win32_delete,
+    NULL,
+    NULL
 };

 /***************************************************************************/
@@ -82,7 +84,6 @@ int32_t mz_stream_win32_open(void *stream, const char *path, int32_t mode)
    {
        desired_access = GENERIC_READ;
        creation_disposition = OPEN_EXISTING;
-        share_mode &= FILE_SHARE_WRITE;
    }
    else if (mode & MZ_OPEN_MODE_APPEND)
    {
@@ -100,7 +101,7 @@ int32_t mz_stream_win32_open(void *stream, const char *path, int32_t mode)
    }

    path_wide_size = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
-    path_wide = (wchar_t *)malloc((path_wide_size + 1) * sizeof(wchar_t));
+    path_wide = (wchar_t *)MZ_ALLOC((path_wide_size + 1) * sizeof(wchar_t));
    memset(path_wide, 0, sizeof(wchar_t) * (path_wide_size + 1));

    MultiByteToWideChar(CP_UTF8, 0, path, -1, path_wide, path_wide_size);
@@ -111,7 +112,7 @@ int32_t mz_stream_win32_open(void *stream, const char *path, int32_t mode)
    win32->handle = CreateFileW(path_wide, desired_access, share_mode, NULL, creation_disposition, flags_attribs, NULL);
 #endif

-    free(path_wide);
+    MZ_FREE(path_wide);

    if (mz_stream_win32_is_open(stream) != MZ_OK)
    {
@@ -122,7 +123,7 @@ int32_t mz_stream_win32_open(void *stream, const char *path, int32_t mode)
    if (mode & MZ_OPEN_MODE_APPEND)
        return mz_stream_win32_seek(stream, 0, MZ_SEEK_END);

-    return MZ_OK; 
+    return MZ_OK;
 }

 int32_t mz_stream_win32_is_open(void *stream)
@@ -262,7 +263,7 @@ void *mz_stream_win32_create(void **stream)
 {
    mz_stream_win32 *win32 = NULL;

-    win32 = (mz_stream_win32 *)malloc(sizeof(mz_stream_win32));
+    win32 = (mz_stream_win32 *)MZ_ALLOC(sizeof(mz_stream_win32));
    if (win32 != NULL)
    {
        memset(win32, 0, sizeof(mz_stream_win32));
@@ -281,11 +282,11 @@ void mz_stream_win32_delete(void **stream)
        return;
    win32 = (mz_stream_win32 *)*stream;
    if (win32 != NULL)
-        free(win32);
+        MZ_FREE(win32);
    *stream = NULL;
 }

 void *mz_stream_win32_get_interface(void)
 {
    return (void *)&mz_stream_win32_vtbl;
-}
+}
@@ -1,8 +1,8 @@
 /* mz_sstrm_win32.h -- Stream for filesystem access for windows
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2009-2010 Mathias Svensson
     Modifications for Zip64 support
@@ -1,8 +1,8 @@
 /* mz_strm_zlib.c -- Stream for zlib inflate/deflate
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -33,7 +33,7 @@

 /***************************************************************************/

-mz_stream_vtbl mz_stream_zlib_vtbl = {
+static mz_stream_vtbl mz_stream_zlib_vtbl = {
    mz_stream_zlib_open,
    mz_stream_zlib_is_open,
    mz_stream_zlib_read,
@@ -70,6 +70,7 @@ int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode)
 {
    mz_stream_zlib *zlib = (mz_stream_zlib *)stream;

+    MZ_UNUSED(path);

    zlib->zstream.data_type = Z_BINARY;
    zlib->zstream.zalloc = Z_NULL;
@@ -128,8 +129,8 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
    int32_t err = Z_OK;


-    zlib->zstream.next_out = (uint8_t*)buf;
-    zlib->zstream.avail_out = (uint16_t)size;
+    zlib->zstream.next_out = (Bytef*)buf;
+    zlib->zstream.avail_out = (uInt)size;

    do
    {
@@ -180,7 +181,7 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)

        if (err == Z_STREAM_END)
            break;
- 
+
        if (err != Z_OK)
        {
            zlib->error = err;
@@ -195,7 +196,7 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
    return total_out;
 }

-int32_t mz_stream_zlib_flush(void *stream)
+static int32_t mz_stream_zlib_flush(void *stream)
 {
    mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
    if (mz_stream_write(zlib->stream.base, zlib->buffer, zlib->buffer_len) != zlib->buffer_len)
@@ -203,7 +204,7 @@ int32_t mz_stream_zlib_flush(void *stream)
    return MZ_OK;
 }

-int32_t mz_stream_zlib_deflate(void *stream, int flush)
+static int32_t mz_stream_zlib_deflate(void *stream, int flush)
 {
    mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
    uint64_t total_out_before = 0;
@@ -234,16 +235,18 @@ int32_t mz_stream_zlib_deflate(void *stream, int flush)

        out_bytes = (uint32_t)(total_out_after - total_out_before);

-        if (err != Z_OK && err != Z_STREAM_END)
+        zlib->buffer_len += out_bytes;
+        zlib->total_out += out_bytes;
+
+        if (err == Z_STREAM_END)
+            break;
+        if (err != Z_OK)
        {
            zlib->error = err;
            return MZ_STREAM_ERROR;
        }
-
-        zlib->buffer_len += out_bytes;
-        zlib->total_out += out_bytes;
    }
-    while (zlib->zstream.avail_in > 0);
+    while ((zlib->zstream.avail_in > 0) || (flush == Z_FINISH && err == Z_OK));

    return MZ_OK;
 }
@@ -253,8 +256,8 @@ int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size)
    mz_stream_zlib *zlib = (mz_stream_zlib *)stream;


-    zlib->zstream.next_in = (uint8_t*)buf;
-    zlib->zstream.avail_in = size;
+    zlib->zstream.next_in = (Bytef*)buf;
+    zlib->zstream.avail_in = (uInt)size;

    mz_stream_zlib_deflate(stream, Z_NO_FLUSH);

@@ -265,11 +268,17 @@ int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size)

 int64_t mz_stream_zlib_tell(void *stream)
 {
+    MZ_UNUSED(stream);
+
    return MZ_STREAM_ERROR;
 }

 int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin)
 {
+    MZ_UNUSED(stream);
+    MZ_UNUSED(offset);
+    MZ_UNUSED(origin);
+
    return MZ_STREAM_ERROR;
 }

@@ -340,7 +349,7 @@ void *mz_stream_zlib_create(void **stream)
 {
    mz_stream_zlib *zlib = NULL;

-    zlib = (mz_stream_zlib *)malloc(sizeof(mz_stream_zlib));
+    zlib = (mz_stream_zlib *)MZ_ALLOC(sizeof(mz_stream_zlib));
    if (zlib != NULL)
    {
        memset(zlib, 0, sizeof(mz_stream_zlib));
@@ -360,7 +369,7 @@ void mz_stream_zlib_delete(void **stream)
        return;
    zlib = (mz_stream_zlib *)*stream;
    if (zlib != NULL)
-        free(zlib);
+        MZ_FREE(zlib);
    *stream = NULL;
 }

@@ -369,7 +378,12 @@ void *mz_stream_zlib_get_interface(void)
    return (void *)&mz_stream_zlib_vtbl;
 }

+static int32_t mz_stream_zlib_crc32(int32_t value, const void *buf, int32_t size)
+{
+    return crc32(value, buf, size);
+}
+
 void *mz_stream_zlib_get_crc32_update(void)
 {
-    return (void *)crc32;
-}
+    return (void *)mz_stream_zlib_crc32;
+}
@@ -1,8 +1,8 @@
 /* mz_strm_zlib.h -- Stream for zlib inflate/deflate
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
      https://github.com/nmoinvaz/minizip

   This program is distributed under the terms of the same license as zlib.
@@ -1,9 +1,8 @@
 /* zip.c -- Zip manipulation
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2010-2017 Nathan Moinvaziri
-     Modifications for AES, PKWARE disk spanning
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2009-2010 Mathias Svensson
     Modifications for Zip64 support
@@ -21,6 +20,7 @@
 #include <string.h>
 #include <time.h>
 #include <errno.h>
+#include <limits.h>

 #include "mz.h"
 #include "mz_strm.h"
@@ -85,7 +85,7 @@ typedef struct mz_zip_s
    uint64_t cd_offset;             // offset of start of central directory
    uint64_t cd_size;               // size of the central directory

-    uint16_t entry_scanned; 
+    uint16_t entry_scanned;
    uint16_t entry_opened;          // 1 if a file in the zip is currently writ.
    uint64_t entry_read;

@@ -312,7 +312,7 @@ static int32_t mz_zip_read_cd(void *handle)

    if ((err == MZ_OK) && (comment_size > 0))
    {
-        zip->comment = (char *)malloc(comment_size + 1);
+        zip->comment = (char *)MZ_ALLOC(comment_size + 1);
        if (zip->comment)
        {
            if (mz_stream_read(zip->stream, zip->comment, comment_size) != comment_size)
@@ -336,7 +336,7 @@ static int32_t mz_zip_write_cd(void *handle)

    if (zip == NULL)
        return MZ_PARAM_ERROR;
-    
+
    if (mz_stream_get_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, &disk_number) == MZ_OK)
        zip->disk_number_with_cd = (uint32_t)disk_number;
    if (mz_stream_get_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_SIZE, &disk_size) == MZ_OK && disk_size > 0)
@@ -347,11 +347,11 @@ static int32_t mz_zip_write_cd(void *handle)
    mz_stream_seek(zip->cd_mem_stream, 0, MZ_SEEK_END);
    zip->cd_size = (uint32_t)mz_stream_tell(zip->cd_mem_stream);
    mz_stream_seek(zip->cd_mem_stream, 0, MZ_SEEK_SET);
-    
+
    err = mz_stream_copy(zip->stream, zip->cd_mem_stream, (int32_t)zip->cd_size);

    // Write the ZIP64 central directory header
-    if (zip->cd_offset >= UINT32_MAX || zip->number_entry > UINT32_MAX)
+    if (zip->cd_offset >= UINT32_MAX || zip->number_entry > UINT16_MAX)
    {
        zip64_eocd_pos_inzip = mz_stream_tell(zip->stream);

@@ -395,12 +395,12 @@ static int32_t mz_zip_write_cd(void *handle)
            err = mz_stream_write_uint64(zip->stream, zip64_eocd_pos_inzip);
        // Number of the disk with the start of the central directory
        if (err == MZ_OK)
-            err = mz_stream_write_uint32(zip->stream, zip->disk_number_with_cd);
+            err = mz_stream_write_uint32(zip->stream, zip->disk_number_with_cd + 1);
    }

    // Write the central directory header

-    // Signature 
+    // Signature
    if (err == MZ_OK)
        err = mz_stream_write_uint32(zip->stream, MZ_ZIP_MAGIC_ENDHEADER);
    // Number of this disk
@@ -456,16 +456,15 @@ extern void* mz_zip_open(void *stream, int32_t mode)
    int32_t err = MZ_OK;


-    zip = (mz_zip *)malloc(sizeof(mz_zip));
+    zip = (mz_zip *)MZ_ALLOC(sizeof(mz_zip));
    if (zip == NULL)
        return NULL;

    memset(zip, 0, sizeof(mz_zip));

    zip->stream = stream;
-    zip->open_mode = mode;

-    if (zip->open_mode & MZ_OPEN_MODE_WRITE)
+    if (mode & MZ_OPEN_MODE_WRITE)
    {
        mz_stream_mem_create(&zip->cd_mem_stream);
        mz_stream_mem_open(zip->cd_mem_stream, NULL, MZ_OPEN_MODE_CREATE);
@@ -477,7 +476,7 @@ extern void* mz_zip_open(void *stream, int32_t mode)
        zip->cd_stream = stream;
    }

-    if ((zip->open_mode & MZ_OPEN_MODE_READ) || (mode & MZ_OPEN_MODE_APPEND))
+    if ((mode & MZ_OPEN_MODE_READ) || (mode & MZ_OPEN_MODE_APPEND))
    {
        err = mz_zip_read_cd(zip);

@@ -514,23 +513,12 @@ extern void* mz_zip_open(void *stream, int32_t mode)

    if (err != MZ_OK)
    {
-        if (zip->file_info_stream != NULL)
-            mz_stream_mem_delete(&zip->file_info_stream);
-        if (zip->local_file_info_stream != NULL)
-            mz_stream_mem_delete(&zip->local_file_info_stream);
-        if (zip->cd_mem_stream != NULL)
-        {
-            mz_stream_close(zip->cd_mem_stream);
-            mz_stream_delete(&zip->cd_mem_stream);
-        }
-
-        if (zip->comment)
-            free(zip->comment);
-
-        free(zip);
+        mz_zip_close(zip);
        return NULL;
    }

+    zip->open_mode = mode;
+
    return zip;
 }

@@ -558,15 +546,21 @@ extern int32_t mz_zip_close(void *handle)
        mz_stream_delete(&zip->cd_mem_stream);
    }

-    mz_stream_mem_close(zip->file_info_stream);
-    mz_stream_mem_delete(&zip->file_info_stream);
-    mz_stream_mem_close(zip->local_file_info_stream);
-    mz_stream_mem_delete(&zip->local_file_info_stream);
+    if (zip->file_info_stream != NULL)
+    {
+        mz_stream_mem_close(zip->file_info_stream);
+        mz_stream_mem_delete(&zip->file_info_stream);
+    }
+    if (zip->local_file_info_stream != NULL)
+    {
+        mz_stream_mem_close(zip->local_file_info_stream);
+        mz_stream_mem_delete(&zip->local_file_info_stream);
+    }

    if (zip->comment)
-        free(zip->comment);
+        MZ_FREE(zip->comment);

-    free(zip);
+    MZ_FREE(zip);

    return err;
 }
@@ -589,9 +583,9 @@ extern int32_t mz_zip_set_comment(void *handle, const char *comment)
    if (zip == NULL || comment == NULL)
        return MZ_PARAM_ERROR;
    if (zip->comment != NULL)
-        free(zip->comment);
+        MZ_FREE(zip->comment);
    comment_size = (uint16_t)(strlen(comment) + 1);
-    zip->comment = (char *)malloc(comment_size);
+    zip->comment = (char *)MZ_ALLOC(comment_size);
    strncpy(zip->comment, comment, comment_size);
    return MZ_OK;
 }
@@ -614,27 +608,6 @@ extern int32_t mz_zip_set_version_madeby(void *handle, uint16_t version_madeby)
    return MZ_OK;
 }

-static int16_t mz_zip_entry_get_version_needed(int16_t zip64, mz_zip_file *file_info)
-{
-    int16_t version_needed = 20;
-
-    if (file_info == NULL)
-        return MZ_PARAM_ERROR;
-    if (file_info->version_needed > 0)
-        version_needed = file_info->version_needed;
-    if (zip64)
-        version_needed = 45;
-#ifdef HAVE_AES
-    if ((file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version))
-        version_needed = 51;
-#endif
-#ifdef HAVE_LZMA
-    if (file_info->compression_method == MZ_COMPRESS_METHOD_LZMA)
-        version_needed = 63;
-#endif
-    return version_needed;
-}
-
 // Get info about the current file in the zip file
 static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file *file_info, void *file_info_stream)
 {
@@ -668,7 +641,7 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
        err = MZ_FORMAT_ERROR;
    else if ((!local) && (magic != MZ_ZIP_MAGIC_CENTRALHEADER))
        err = MZ_FORMAT_ERROR;
-    
+
    // Read header fields
    if (err == MZ_OK)
    {
@@ -761,7 +734,7 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
                if ((err == MZ_OK) && (file_info->disk_offset == UINT32_MAX))
                    err = mz_stream_read_uint64(file_info_stream, &value64);
                file_info->disk_offset = value64;
-                if ((err == MZ_OK) && (file_info->disk_number == UINT32_MAX))
+                if ((err == MZ_OK) && (file_info->disk_number == UINT16_MAX))
                    err = mz_stream_read_uint32(file_info_stream, &file_info->disk_number);
            }
            // NTFS extra field
@@ -776,17 +749,17 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
                    if (err == MZ_OK)
                        err = mz_stream_read_uint16(file_info_stream, &ntfs_attrib_size);

-                    if (ntfs_attrib_id == 0x01 && ntfs_attrib_size >= 8)
+                    if ((ntfs_attrib_id == 0x01) && (ntfs_attrib_size == 24))
                    {
                        err = mz_stream_read_uint64(file_info_stream, &ntfs_time);
                        mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->modified_date);

-                        if ((err == MZ_OK) && (ntfs_attrib_size >= 16))
+                        if (err == MZ_OK)
                        {
                            err = mz_stream_read_uint64(file_info_stream, &ntfs_time);
                            mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->accessed_date);
                        }
-                        if ((err == MZ_OK) && (ntfs_attrib_size >= 24))
+                        if (err == MZ_OK)
                        {
                            err = mz_stream_read_uint64(file_info_stream, &ntfs_time);
                            mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->creation_date);
@@ -851,7 +824,6 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file

 static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_file *file_info)
 {
-    struct tm *local_time = NULL;
    uint64_t ntfs_time = 0;
    uint32_t reserved = 0;
    uint32_t dos_date = 0;
@@ -859,13 +831,16 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
    uint16_t extrafield_zip64_size = 0;
    uint16_t extrafield_ntfs_size = 0;
    uint16_t filename_size = 0;
+    uint16_t filename_length = 0;
    uint16_t comment_size = 0;
+    uint16_t version_needed = 0;
    uint8_t zip64 = 0;
    int32_t err = MZ_OK;

    if (file_info == NULL)
        return MZ_PARAM_ERROR;

+    // Calculate extra field sizes
    extrafield_size = file_info->extrafield_size;

    if (file_info->uncompressed_size >= UINT32_MAX)
@@ -875,8 +850,19 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
    if (file_info->disk_offset >= UINT32_MAX)
        extrafield_zip64_size += 8;

-    // Use 64-bit data descriptor if we don't know uncompressed size ahead of time
-    zip64 = (local && file_info->uncompressed_size == 0) || (extrafield_zip64_size > 0);
+    if (file_info->zip64 == MZ_ZIP64_AUTO)
+    {
+        // If uncompressed size is unknown, assume zip64 for 64-bit data descriptors
+        zip64 = (local && file_info->uncompressed_size == 0) || (extrafield_zip64_size > 0);
+    }
+    else if (file_info->zip64 == MZ_ZIP64_FORCE)
+        zip64 = 1;
+    else if (file_info->zip64 == MZ_ZIP64_DISABLE)
+    {
+        // Zip64 extension is required to zip file
+        if (extrafield_zip64_size > 0)
+            return MZ_PARAM_ERROR;
+    }

    if (zip64)
    {
@@ -888,23 +874,15 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
        extrafield_size += 4 + 7;
 #endif
    // NTFS timestamps
-    if (file_info->modified_date != 0)
-        extrafield_ntfs_size += 8;
-    if (file_info->accessed_date != 0)
-        extrafield_ntfs_size += 8;
-    if (file_info->creation_date != 0)
-        extrafield_ntfs_size += 8;
-
-    if (extrafield_ntfs_size > 4)
+    if ((file_info->modified_date != 0) &&
+        (file_info->accessed_date != 0) &&
+        (file_info->creation_date != 0))
    {
-        extrafield_ntfs_size += 4 + 4;
-
+        extrafield_ntfs_size += 8 + 8 + 8 + 4 + 2 + 2;
        extrafield_size += 4;
        extrafield_size += extrafield_ntfs_size;
    }

-    file_info->version_needed = mz_zip_entry_get_version_needed(zip64, file_info);
-
    if (local)
        err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_LOCALHEADER);
    else
@@ -914,8 +892,26 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
            err = mz_stream_write_uint16(stream, file_info->version_madeby);
    }

+    // Calculate version needed to extract
    if (err == MZ_OK)
-        err = mz_stream_write_uint16(stream, file_info->version_needed);
+    {
+        version_needed = file_info->version_needed;
+        if (version_needed == 0)
+        {
+            version_needed = 20;
+            if (zip64)
+                version_needed = 45;
+#ifdef HAVE_AES
+            if ((file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version))
+                version_needed = 51;
+#endif
+#ifdef HAVE_LZMA
+            if (file_info->compression_method == MZ_COMPRESS_METHOD_LZMA)
+                version_needed = 63;
+#endif
+        }
+        err = mz_stream_write_uint16(stream, version_needed);
+    }
    if (err == MZ_OK)
        err = mz_stream_write_uint16(stream, file_info->flag);
    if (err == MZ_OK)
@@ -951,9 +947,20 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
            err = mz_stream_write_uint32(stream, (uint32_t)file_info->uncompressed_size);
    }

-    filename_size = (uint16_t)strlen(file_info->filename);
+    filename_length = (uint16_t)strlen(file_info->filename);
    if (err == MZ_OK)
+    {
+        filename_size = filename_length;
+        if (mz_zip_attrib_is_dir(file_info->external_fa, file_info->version_madeby) == MZ_OK)
+        {
+            if ((file_info->filename[filename_length - 1] == '/') || 
+                (file_info->filename[filename_length - 1] == '\\'))
+                filename_length -= 1;
+            else
+                filename_size += 1;
+        }
        err = mz_stream_write_uint16(stream, filename_size);
+    }
    if (err == MZ_OK)
        err = mz_stream_write_uint16(stream, extrafield_size);

@@ -980,8 +987,14 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil

    if (err == MZ_OK)
    {
-        if (mz_stream_write(stream, file_info->filename, filename_size) != filename_size)
+        if (mz_stream_write(stream, file_info->filename, filename_length) != filename_length)
            err = MZ_STREAM_ERROR;
+        if (err == MZ_OK)
+        {
+            // Ensure that directories have a slash appended to them for compatibility
+            if (mz_zip_attrib_is_dir(file_info->external_fa, file_info->version_madeby) == MZ_OK)
+                err = mz_stream_write_uint8(stream, '/');
+        }
    }
    if (err == MZ_OK)
    {
@@ -1013,17 +1026,17 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
            err = mz_stream_write_uint16(stream, 0x01);
        if (err == MZ_OK)
            err = mz_stream_write_uint16(stream, extrafield_ntfs_size - 8);
-        if ((err == MZ_OK) && (file_info->modified_date != 0))
+        if (err == MZ_OK)
        {
            mz_zip_unix_to_ntfs_time(file_info->modified_date, &ntfs_time);
            err = mz_stream_write_uint64(stream, ntfs_time);
        }
-        if ((err == MZ_OK) && (file_info->accessed_date != 0))
+        if (err == MZ_OK)
        {
            mz_zip_unix_to_ntfs_time(file_info->accessed_date, &ntfs_time);
            err = mz_stream_write_uint64(stream, ntfs_time);
        }
-        if ((err == MZ_OK) && (file_info->creation_date != 0))
+        if (err == MZ_OK)
        {
            mz_zip_unix_to_ntfs_time(file_info->creation_date, &ntfs_time);
            err = mz_stream_write_uint64(stream, ntfs_time);
@@ -1086,10 +1099,10 @@ static int32_t mz_zip_entry_open_int(void *handle, int16_t compression_method, i
        return MZ_PARAM_ERROR;
    }

-    if ((zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (password == NULL))
+    if ((zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (password == NULL) && (zip->compression_method != MZ_COMPRESS_METHOD_RAW))
        return MZ_PARAM_ERROR;

-    if ((err == MZ_OK) && (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED))
+    if ((err == MZ_OK) && (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (zip->compression_method != MZ_COMPRESS_METHOD_RAW))
    {
 #ifdef HAVE_AES
        if (zip->file_info.aes_version)
@@ -1102,17 +1115,26 @@ static int32_t mz_zip_entry_open_int(void *handle, int16_t compression_method, i
 #endif
        {
 #ifdef HAVE_CRYPT
-            uint32_t dos_date = 0;
            uint8_t verify1 = 0;
            uint8_t verify2 = 0;

            // Info-ZIP modification to ZipCrypto format:
            // If bit 3 of the general purpose bit flag is set, it uses high byte of 16-bit File Time.

-            dos_date = mz_zip_time_t_to_dos_date(zip->file_info.modified_date);
+            if (zip->file_info.flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR)
+            {
+                uint32_t dos_date = 0;

-            verify1 = (uint8_t)((dos_date >> 16) & 0xff);
-            verify2 = (uint8_t)((dos_date >> 8) & 0xff);
+                dos_date = mz_zip_time_t_to_dos_date(zip->file_info.modified_date);
+
+                verify1 = (uint8_t)((dos_date >> 16) & 0xff);
+                verify2 = (uint8_t)((dos_date >> 8) & 0xff);
+            }
+            else
+            {
+                verify1 = (uint8_t)((zip->file_info.crc >> 16) & 0xff);
+                verify2 = (uint8_t)((zip->file_info.crc >> 24) & 0xff);
+            }

            mz_stream_crypt_create(&zip->crypt_stream);
            mz_stream_crypt_set_password(zip->crypt_stream, password);
@@ -1157,7 +1179,7 @@ static int32_t mz_zip_entry_open_int(void *handle, int16_t compression_method, i
        }
        else
        {
-            if (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED || zip->compression_method == MZ_COMPRESS_METHOD_RAW)
+            if (zip->compression_method == MZ_COMPRESS_METHOD_RAW || zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)
            {
                max_total_in = zip->file_info.compressed_size;
                if (mz_stream_get_prop_int64(zip->crypt_stream, MZ_STREAM_PROP_FOOTER_SIZE, &footer_size) == MZ_OK)
@@ -1166,6 +1188,11 @@ static int32_t mz_zip_entry_open_int(void *handle, int16_t compression_method, i
                    max_total_in -= total_in;
                mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX, max_total_in);
            }
+            if (zip->compression_method == MZ_COMPRESS_METHOD_LZMA && (zip->file_info.flag & MZ_ZIP_FLAG_LZMA_EOS_MARKER) == 0)
+            {
+                mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX, zip->file_info.compressed_size);
+                mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_OUT_MAX, zip->file_info.uncompressed_size);
+            }
        }

        mz_stream_set_base(zip->compress_stream, zip->crypt_stream);
@@ -1214,7 +1241,7 @@ extern int32_t mz_zip_entry_read_open(void *handle, int16_t raw, const char *pas
        return MZ_PARAM_ERROR;
    if (zip->entry_scanned == 0)
        return MZ_PARAM_ERROR;
-    if ((zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (password == NULL))
+    if ((zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (password == NULL) && (!raw))
        return MZ_PARAM_ERROR;

    if (zip->file_info.disk_number == zip->disk_number_with_cd)
@@ -1236,8 +1263,7 @@ extern int32_t mz_zip_entry_read_open(void *handle, int16_t raw, const char *pas
    return err;
 }

-extern int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info,
-    int16_t compress_level, const char *password)
+extern int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info, int16_t compress_level, const char *password)
 {
    mz_zip *zip = (mz_zip *)handle;
    int64_t disk_number = 0;
@@ -1262,8 +1288,6 @@ extern int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_inf
    memcpy(&zip->file_info, file_info, sizeof(mz_zip_file));

    compression_method = zip->file_info.compression_method;
-    if (compress_level == 0)
-        compression_method = MZ_COMPRESS_METHOD_RAW;

    if (compression_method == MZ_COMPRESS_METHOD_DEFLATE)
    {
@@ -1286,8 +1310,8 @@ extern int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_inf
    else
        zip->file_info.flag &= ~MZ_ZIP_FLAG_ENCRYPTED;

-    if (mz_stream_get_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, &disk_number) == MZ_OK)
-        zip->file_info.disk_number = (uint32_t)disk_number;
+    mz_stream_get_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, &disk_number);
+    zip->file_info.disk_number = (uint32_t)disk_number;

    zip->file_info.disk_offset = mz_stream_tell(zip->stream);
    zip->file_info.crc = 0;
@@ -1298,6 +1322,9 @@ extern int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_inf
        zip->file_info.aes_encryption_mode = MZ_AES_ENCRYPTION_MODE_256;
 #endif

+    if ((compress_level == 0) || (mz_zip_attrib_is_dir(zip->file_info.external_fa, zip->file_info.version_madeby) == MZ_OK))
+        compression_method = MZ_COMPRESS_METHOD_RAW;
+
    if (err == MZ_OK)
        err = mz_zip_entry_write_header(zip->stream, 1, &zip->file_info);
    if (err == MZ_OK)
@@ -1313,9 +1340,9 @@ extern int32_t mz_zip_entry_read(void *handle, void *buf, uint32_t len)

    if (zip == NULL || zip->entry_opened == 0)
        return MZ_PARAM_ERROR;
-    if (len > UINT16_MAX) // Zlib limitation
+    if (UINT_MAX == UINT16_MAX && len > UINT16_MAX) // Zlib limitation
        return MZ_PARAM_ERROR;
-    if (len == 0)
+    if (len == 0 || zip->file_info.uncompressed_size == 0)
        return 0;
    read = mz_stream_read(zip->crc32_stream, buf, len);
    if (read > 0)
@@ -1404,16 +1431,16 @@ extern int32_t mz_zip_entry_close_raw(void *handle, uint64_t uncompressed_size,
            if (err == MZ_OK)
            {
                if (zip->file_info.uncompressed_size <= UINT32_MAX)
-                    err = mz_stream_write_uint64(zip->stream, compressed_size);
-                else
                    err = mz_stream_write_uint32(zip->stream, (uint32_t)compressed_size);
+                else
+                    err = mz_stream_write_uint64(zip->stream, compressed_size);
            }
            if (err == MZ_OK)
            {
                if (zip->file_info.uncompressed_size <= UINT32_MAX)
-                    err = mz_stream_write_uint64(zip->stream, uncompressed_size);
-                else
                    err = mz_stream_write_uint32(zip->stream, (uint32_t)uncompressed_size);
+                else
+                    err = mz_stream_write_uint64(zip->stream, uncompressed_size);
            }
        }

@@ -1448,7 +1475,7 @@ static int32_t mz_zip_goto_next_entry_int(void *handle)
    zip->entry_scanned = 0;

    mz_stream_set_prop_int64(zip->cd_stream, MZ_STREAM_PROP_DISK_NUMBER, -1);
-    
+
    err = mz_stream_seek(zip->cd_stream, zip->cd_current_pos, MZ_SEEK_SET);
    if (err == MZ_OK)
        err = mz_zip_entry_read_header(zip->cd_stream, 0, &zip->file_info, zip->file_info_stream);
@@ -1466,6 +1493,40 @@ extern int32_t mz_zip_get_number_entry(void *handle, int64_t *number_entry)
    return MZ_OK;
 }

+extern int32_t mz_zip_get_disk_number_with_cd(void *handle, uint32_t *disk_number_with_cd)
+{
+    mz_zip *zip = (mz_zip *)handle;
+    if (zip == NULL || disk_number_with_cd == NULL)
+        return MZ_PARAM_ERROR;
+    *disk_number_with_cd = zip->disk_number_with_cd;
+    return MZ_OK;
+}
+
+extern int64_t mz_zip_get_entry(void *handle)
+{
+    mz_zip *zip = (mz_zip *)handle;
+
+    if (zip == NULL)
+        return MZ_PARAM_ERROR;
+
+    return zip->cd_current_pos;
+}
+
+extern int32_t mz_zip_goto_entry(void *handle, uint64_t cd_pos)
+{
+    mz_zip *zip = (mz_zip *)handle;
+
+    if (zip == NULL)
+        return MZ_PARAM_ERROR;
+
+    if (cd_pos < zip->cd_start_pos || cd_pos > zip->cd_start_pos + zip->cd_size)
+        return MZ_PARAM_ERROR;
+
+    zip->cd_current_pos = cd_pos;
+
+    return mz_zip_goto_next_entry_int(handle);
+}
+
 extern int32_t mz_zip_goto_first_entry(void *handle)
 {
    mz_zip *zip = (mz_zip *)handle;
@@ -1519,10 +1580,30 @@ extern int32_t mz_zip_locate_entry(void *handle, const char *filename, mz_filena

 /***************************************************************************/

+int32_t mz_zip_attrib_is_dir(int32_t attributes, int32_t version_madeby)
+{
+    int32_t host_system = (uint8_t)(version_madeby >> 8);
+
+    if (host_system == MZ_HOST_SYSTEM_MSDOS || host_system == MZ_HOST_SYSTEM_WINDOWS_NTFS)
+    {
+        if ((attributes & 0x10) == 0x10) // FILE_ATTRIBUTE_DIRECTORY
+            return MZ_OK;
+    }
+    else if (host_system == MZ_HOST_SYSTEM_UNIX || host_system == MZ_HOST_SYSTEM_OSX_DARWIN)
+    {
+        if ((attributes & 00170000) == 0040000) // S_ISDIR
+            return MZ_OK;
+    }
+
+    return MZ_EXIST_ERROR;
+}
+
+/***************************************************************************/
+
 static int32_t mz_zip_invalid_date(const struct tm *ptm)
 {
 #define datevalue_in_range(min, max, value) ((min) <= (value) && (value) <= (max))
-    return (!datevalue_in_range(0, 207, ptm->tm_year) ||
+    return (!datevalue_in_range(0, 127 + 80, ptm->tm_year) ||  // 1980-based year, allow 80 extra
            !datevalue_in_range(0, 11, ptm->tm_mon) ||
            !datevalue_in_range(1, 31, ptm->tm_mday) ||
            !datevalue_in_range(0, 23, ptm->tm_hour) ||
@@ -1572,9 +1653,13 @@ int32_t mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm)
    struct tm *ltm = NULL;
    if (ptm == NULL)
        return MZ_PARAM_ERROR;
-    ltm = localtime(&unix_time);
+    ltm = localtime(&unix_time);  // Returns a 1900-based year
    if (ltm == NULL)
+    {
+        // Invalid date stored, so don't return it
+        memset(ptm, 0, sizeof(struct tm));
        return MZ_INTERNAL_ERROR;
+    }
    memcpy(ptm, ltm, sizeof(struct tm));
    return MZ_OK;
 }
@@ -1588,8 +1673,7 @@ uint32_t mz_zip_time_t_to_dos_date(time_t unix_time)

 uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm)
 {
-    struct tm fixed_tm = { 0 };
-    uint32_t dos_date = 0;
+    struct tm fixed_tm;

    // Years supported:

@@ -1601,12 +1685,12 @@ uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm)
    memcpy(&fixed_tm, ptm, sizeof(struct tm));
    if (fixed_tm.tm_year >= 1980) // range [1980, 2107]
        fixed_tm.tm_year -= 1980;
-    else if (fixed_tm.tm_year >= 80) // range [80, 99]
+    else if (fixed_tm.tm_year >= 80) // range [80, 207]
        fixed_tm.tm_year -= 80;
    else // range [00, 79]
        fixed_tm.tm_year += 20;

-    if (mz_zip_invalid_date(ptm))
+    if (mz_zip_invalid_date(&fixed_tm))
        return 0;

    return (uint32_t)(((fixed_tm.tm_mday) + (32 * (fixed_tm.tm_mon + 1)) + (512 * fixed_tm.tm_year)) << 16) |
@@ -1,8 +1,8 @@
 /* mz_zip.h -- Zip manipulation
-   Version 2.2.4, November 15th, 2017
+   Version 2.3.0, May 3rd, 2018
   part of the MiniZip project

-   Copyright (C) 2012-2017 Nathan Moinvaziri
+   Copyright (C) 2010-2018 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2009-2010 Mathias Svensson
     Modifications for Zip64 support
@@ -30,9 +30,9 @@ extern "C" {

 typedef struct mz_zip_file_s
 {
-    uint16_t version_madeby;            // version made by 
+    uint16_t version_madeby;            // version made by
    uint16_t version_needed;            // version needed to extract
-    uint16_t flag;                      // general purpose bit flag 
+    uint16_t flag;                      // general purpose bit flag
    uint16_t compression_method;        // compression method
    time_t   modified_date;             // last modified date in unix time
    time_t   accessed_date;             // last accessed date in unix time
@@ -47,6 +47,7 @@ typedef struct mz_zip_file_s
    uint64_t disk_offset;               // relative offset of local header
    uint16_t internal_fa;               // internal file attributes
    uint32_t external_fa;               // external file attributes
+    uint16_t zip64;                     // zip64 extension mode

    char     *filename;                 // filename string
    uint8_t  *extrafield;               // extrafield data
@@ -108,19 +109,31 @@ extern int32_t mz_zip_entry_close(void *handle);
 extern int32_t mz_zip_get_number_entry(void *handle, int64_t *number_entry);
 // Get the total number of entries

+extern int32_t mz_zip_get_disk_number_with_cd(void *handle, uint32_t *disk_number_with_cd);
+// Get the the disk number containing the central directory record
+
+extern int64_t mz_zip_get_entry(void *handle);
+// Return offset of the current entry in the zip file
+
+extern int32_t mz_zip_goto_entry(void *handle, uint64_t cd_pos);
+// Go to specified entry in the zip file
+
 extern int32_t mz_zip_goto_first_entry(void *handle);
-// Go to the first entry in the zip file 
+// Go to the first entry in the zip file

 extern int32_t mz_zip_goto_next_entry(void *handle);
 // Go to the next entry in the zip file or MZ_END_OF_LIST if reaching the end

 typedef int32_t (*mz_filename_compare_cb)(void *handle, const char *filename1, const char *filename2);
-extern int32_t mz_zip_locate_entry(void *handle, const char *filename, 
+extern int32_t mz_zip_locate_entry(void *handle, const char *filename,
    mz_filename_compare_cb filename_compare_cb);
 // Locate the file with the specified name in the zip file or MZ_END_LIST if not found

 /***************************************************************************/

+int32_t  mz_zip_attrib_is_dir(int32_t attributes, int32_t version_madeby);
+// Checks to see if the attribute is a directory based on platform
+
 int32_t  mz_zip_dosdate_to_tm(uint64_t dos_date, struct tm *ptm);
 // Convert dos date/time format to struct tm

@@ -128,7 +141,7 @@ time_t   mz_zip_dosdate_to_time_t(uint64_t dos_date);
 // Convert dos date/time format to time_t

 int32_t  mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm);
-// Convert time_t to time struct 
+// Convert time_t to time struct

 uint32_t mz_zip_time_t_to_dos_date(time_t unix_time);
 // Convert time_t to dos date/time format
@@ -151,7 +151,7 @@ void test_compress(char *method, mz_stream_create_cb create_compress)

        mz_stream_delete(&deflate_stream);

-        printf("%s compressed from %d to %d\n", filename, (uint32_t)total_in, (uint32_t)total_out);
+        printf("%s compressed from %u to %u\n", filename, (uint32_t)total_in, (uint32_t)total_out);

        mz_stream_os_close(out_stream);
    }
@@ -175,7 +175,7 @@ void test_compress(char *method, mz_stream_create_cb create_compress)

        mz_stream_os_close(in_stream);

-        printf("%s uncompressed from %d to %d\n", filename, (uint32_t)total_in, (uint32_t)total_out);
+        printf("%s uncompressed from %u to %u\n", filename, (uint32_t)total_in, (uint32_t)total_out);
    }

    mz_stream_os_delete(&in_stream);
@@ -199,3 +199,4 @@ sfx_zip_test()
 compression_method_tests()
 encryption_tests()
 compression_method_tests('Disk Span', '-k 1024', '')
+compression_method_tests('Buffered', '-u', '-u')