Version 2.3.0.

whitespace fixes

CMakeLists.txt

@@ -30,7 +30,7 @@ set(INSTALL_MAN_DIR ${CMAKE_INSTALL_MANDIR} CACHE PATH "Installation directory f
 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.2.9")
+set(VERSION "2.3.0")
 
 # Set cmake debug postfix to d
 set(CMAKE_DEBUG_POSTFIX "d")

Minizip.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name     = 'Minizip'
-  s.version  = '2.2.9'
+  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

README.md

@@ -1,4 +1,4 @@
-# Minizip 2.2.9
+# Minizip 2.3.0
 
 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.
 
@@ -54,7 +54,7 @@ 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 [AES](https://github.com/BrianGladman/aes) and [SHA](https://github.com/BrianGladman/sha) libraries

minizip.c

@@ -1,5 +1,5 @@
 /* minizip.c
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -47,7 +47,7 @@ void minizip_help()
            "  -o  Overwrite existing files\n" \
            "  -a  Append to existing zip file\n" \
            "  -u  Buffered reading and writing\n" \
-           "  -j  Exclude path of files\n" \
+           "  -i  Include full path of files\n" \
            "  -0  Store only\n" \
            "  -1  Compress faster\n" \
            "  -9  Compress better\n" \
@@ -68,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;
@@ -79,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);
 
@@ -128,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);
@@ -139,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)
@@ -187,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);
 
@@ -218,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;
     }
@@ -235,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 = ' ';
 
@@ -248,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)
     {
@@ -261,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 = '*';
@@ -271,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);
@@ -296,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,
@@ -329,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;
@@ -355,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;
     }
 
@@ -399,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;
     }
@@ -407,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));
@@ -460,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
@@ -483,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);
 
@@ -580,8 +603,8 @@ int main(int argc, char *argv[])
                     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');
@@ -694,7 +717,7 @@ int main(int argc, char *argv[])
     {
         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);
@@ -737,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);
         }

mz.h

@@ -1,5 +1,5 @@
 /* mz.h -- Errors codes, zip flags and magic
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -19,7 +19,7 @@ extern "C" {
 /***************************************************************************/
 
 // MZ_VERSION
-#define MZ_VERSION                      ("2.2.9")
+#define MZ_VERSION                      ("2.3.0")
 
 // MZ_ERROR
 #define MZ_OK                           (0)
@@ -71,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

mz_compat.c

@@ -1,5 +1,5 @@
 /* mz_compat.c -- Backwards compatible interface for older versions
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -50,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;
@@ -59,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)
     {
@@ -92,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;
 
@@ -100,26 +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 = { 0 };
+    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;
@@ -129,6 +146,10 @@ 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
     if (password)
         file_info.aes_version = MZ_AES_VERSION;
@@ -142,45 +163,45 @@ extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, cons
 
 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);
 }
 
@@ -188,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);
 }
 
@@ -226,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);
@@ -240,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;
 }
@@ -270,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);
@@ -287,7 +323,7 @@ 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;
 
@@ -301,7 +337,7 @@ 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);
 
@@ -311,7 +347,7 @@ extern int ZEXPORT unzClose(unzFile file)
         mz_stream_delete(&compat->stream);
     }
 
-    free(compat);
+    MZ_FREE(compat);
 
     return err;
 }
@@ -324,7 +360,7 @@ extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info3
 
     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 == MZ_OK)
@@ -344,7 +380,7 @@ extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_i
 
     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);
@@ -362,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);
@@ -373,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)
@@ -400,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);
 }
 
@@ -408,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);
 }
 
@@ -421,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))
@@ -430,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;
@@ -478,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);
 
@@ -488,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;
@@ -537,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);
 }
 
@@ -545,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);
 }
 
@@ -553,10 +594,45 @@ 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)
@@ -595,4 +671,3 @@ void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def)
     if (pzlib_filefunc_def != NULL)
         *pzlib_filefunc_def = mz_stream_os_get_interface();
 }
-

mz_compat.h

@@ -1,5 +1,5 @@
 /* mz_compat.h -- Backwards compatible interface for older versions
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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);

mz_os.c

@@ -1,5 +1,5 @@
 /* mz_os.c -- System functions
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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;
-}
+}

mz_os.h

@@ -1,5 +1,5 @@
 /* mz_os.h -- System functions
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_os_posix.c

@@ -1,5 +1,5 @@
 /* mz_os_posix.c -- System functions for posix
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -69,7 +69,6 @@ int32_t mz_posix_get_file_date(const char *path, time_t *modified_date, time_t *
     size_t len = 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;

mz_os_posix.h

@@ -1,5 +1,5 @@
 /* mz_os_posix.h -- System functions for posix
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -23,9 +23,9 @@ extern "C" {
 /***************************************************************************/
 
 #if defined(__APPLE__)
-#define MZ_VERSION_MADEBY_HOST_SYSTEM (19)
+#define MZ_VERSION_MADEBY_HOST_SYSTEM   (MZ_HOST_SYSTEM_OSX_DARWIN)
 #elif defined(unix)
-#define MZ_VERSION_MADEBY_HOST_SYSTEM (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
 
 /***************************************************************************/
 

mz_os_win32.c

@@ -1,5 +1,5 @@
 /* mz_os_win32.c -- System functions for Windows
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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;
     }
 }
@@ -159,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)
     {
@@ -213,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;
@@ -249,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;
 
@@ -269,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)
@@ -279,7 +307,7 @@ struct dirent* mz_win32_read_dir(DIR *dir)
 
         dir_int->end = 1;
     }
- 
+
     return &dir_int->entry;
 }
 
@@ -293,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;
 }
 
@@ -313,4 +341,4 @@ int32_t mz_win32_is_dir(const char *path)
     }
 
     return MZ_EXIST_ERROR;
-}
+}

mz_os_win32.h

@@ -1,5 +1,5 @@
 /* mz_os_win32.h -- System functions for Windows
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -20,7 +20,7 @@ extern "C" {
 
 /***************************************************************************/
 
-#define MZ_VERSION_MADEBY_HOST_SYSTEM (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
 
 /***************************************************************************/
 

mz_strm.c

@@ -1,5 +1,5 @@
 /* mz_strm.c -- Stream interface
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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;
 }

mz_strm.h

@@ -1,5 +1,5 @@
 /* mz_strm.h -- Stream interface
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_aes.c

@@ -1,5 +1,5 @@
 /* mz_strm_aes.c -- Stream for WinZip AES encryption
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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;
@@ -299,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:
@@ -319,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));
@@ -339,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;
 }
 

mz_strm_aes.h

@@ -1,5 +1,5 @@
 /* mz_strm_aes.h -- Stream for WinZIP AES encryption
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_buf.c

@@ -1,5 +1,5 @@
 /* mz_strm_buf.c -- Stream for buffering reads/writes
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    This version of ioapi is designed to buffer IO.
@@ -31,7 +31,7 @@
 
 /***************************************************************************/
 
-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
 };
 
 /***************************************************************************/
@@ -89,7 +91,7 @@ static 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)
@@ -97,7 +99,7 @@ static int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
 
         buffered->writebuf_misses += 1;
 
-        mz_stream_buffered_print(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;
@@ -124,7 +126,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
     mz_stream_buffered_print(stream, "read [size %ld pos %lld]\n", size, buffered->position);
 
     if (buffered->writebuf_len > 0)
-        mz_stream_buffered_print(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)
@@ -146,7 +148,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
             buffered->readbuf_len += bytes_read;
             buffered->position += bytes_read;
 
-            mz_stream_buffered_print(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)
@@ -167,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(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);
         }
     }
@@ -185,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(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)
@@ -221,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(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;
@@ -274,7 +276,7 @@ int32_t mz_stream_buffered_seek(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));
@@ -341,11 +343,11 @@ int32_t mz_stream_buffered_close(void *stream)
     mz_stream_buffered_print(stream, "close\n");
 
     if (buffered->readbuf_hits + buffered->readbuf_misses > 0)
-        mz_stream_buffered_print(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(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);
@@ -361,7 +363,7 @@ 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));
@@ -380,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;
 }
 

mz_strm_buf.h

@@ -1,5 +1,5 @@
 /* mz_strm_buf.h -- Stream for buffering reads/writes
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    This version of ioapi is designed to buffer IO.

mz_strm_bzip.c

@@ -1,5 +1,5 @@
 /* mz_strm_bzip.c -- Stream for bzip inflate/deflate
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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;
@@ -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);
@@ -222,12 +223,12 @@ static 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);
@@ -265,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;
 }
 
@@ -342,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));
@@ -362,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;
 }
 
@@ -373,4 +380,5 @@ void *mz_stream_bzip_get_interface(void)
 
 extern void bz_internal_error(int errcode)
 {
+    MZ_UNUSED(errcode);
 }

mz_strm_bzip.h

@@ -1,5 +1,5 @@
 /* mz_strm_bzip.h -- Stream for bzip inflate/deflate
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_crypt.c

@@ -1,5 +1,5 @@
 /* mz_strm_crypt.c -- Code for traditional PKWARE encryption
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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
 };
 
 /***************************************************************************/
@@ -151,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);
 
@@ -213,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;
@@ -296,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));
@@ -315,7 +316,7 @@ void mz_stream_crypt_delete(void **stream)
         return;
     crypt = (mz_stream_crypt *)*stream;
     if (crypt != NULL)
-        free(crypt);
+        MZ_FREE(crypt);
     *stream = NULL;
 }
 

mz_strm_crypt.h

@@ -1,5 +1,5 @@
 /* mz_strm_crypt.h -- Code for traditional PKWARE encryption
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_lzma.c

@@ -1,5 +1,5 @@
 /* mz_strm_lzma.c -- Stream for lzma inflate/deflate
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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,
@@ -66,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;
 
@@ -92,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);
@@ -114,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;
 
@@ -160,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)
@@ -182,9 +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 && total_out_after > lzma->max_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);
 
@@ -280,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;
 }
 
@@ -362,7 +372,7 @@ 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));
@@ -383,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;
 }
 

mz_strm_lzma.h

@@ -1,5 +1,5 @@
 /* mz_strm_lzma.h -- Stream for lzma inflate/deflate
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_mem.c

@@ -1,9 +1,9 @@
 /* mz_strm_mem.c -- Stream for memory access
-   Version 2.2.9, April 18th, 2018
+   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
 
@@ -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;
-}
+}

mz_strm_mem.h

@@ -1,5 +1,5 @@
 /* mz_strm_mem.h -- Stream for memory access
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_posix.c

@@ -1,5 +1,5 @@
 /* mz_strm_posix.c -- Stream for filesystem access for posix/linux
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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
 };
 
 /***************************************************************************/
@@ -201,7 +203,7 @@ 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));
@@ -209,7 +211,7 @@ void *mz_stream_posix_create(void **stream)
     }
     if (stream != NULL)
         *stream = posix;
- 
+
     return posix;
 }
 
@@ -220,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;
 }
 

mz_strm_posix.h

@@ -1,5 +1,5 @@
 /* mz_strm_posix.h -- Stream for filesystem access for posix/linux
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_split.c

@@ -1,5 +1,5 @@
 /* mz_strm_split.c -- Stream for split files
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -29,7 +29,7 @@
 
 /***************************************************************************/
 
-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,
@@ -181,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)
@@ -281,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;
@@ -368,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));
@@ -389,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;
 }

mz_strm_split.h

@@ -1,5 +1,5 @@
 /* mz_strm_split.h -- Stream for split files
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_win32.c

@@ -1,5 +1,5 @@
 /* mz_strm_win32.c -- Stream for filesystem access for windows
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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
 };
 
 /***************************************************************************/
@@ -99,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);
@@ -110,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)
     {
@@ -121,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)
@@ -261,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));
@@ -280,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;
-}
+}

mz_strm_win32.h

@@ -1,5 +1,5 @@
 /* mz_sstrm_win32.h -- Stream for filesystem access for windows
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_strm_zlib.c

@@ -1,5 +1,5 @@
 /* mz_strm_zlib.c -- Stream for zlib inflate/deflate
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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;
@@ -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;
@@ -267,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;
 }
 
@@ -342,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));
@@ -362,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;
 }
 

mz_strm_zlib.h

@@ -1,5 +1,5 @@
 /* mz_strm_zlib.h -- Stream for zlib inflate/deflate
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri

mz_zip.c

@@ -1,5 +1,5 @@
 /* zip.c -- Zip manipulation
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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,7 +347,7 @@ 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
@@ -400,7 +400,7 @@ static int32_t mz_zip_write_cd(void *handle)
 
     // 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,7 +456,7 @@ 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;
 
@@ -558,9 +558,9 @@ extern int32_t mz_zip_close(void *handle)
     }
 
     if (zip->comment)
-        free(zip->comment);
+        MZ_FREE(zip->comment);
 
-    free(zip);
+    MZ_FREE(zip);
 
     return err;
 }
@@ -583,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;
 }
@@ -608,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)
 {
@@ -662,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)
     {
@@ -852,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)
@@ -868,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)
     {
@@ -890,8 +883,6 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
         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
@@ -901,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)
@@ -938,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);
 
@@ -967,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)
     {
@@ -1073,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)
@@ -1215,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)
@@ -1237,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;
@@ -1263,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)
     {
@@ -1299,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)
@@ -1449,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);
@@ -1467,7 +1493,7 @@ 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, int32_t *disk_number_with_cd)
+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)
@@ -1476,6 +1502,31 @@ extern int32_t mz_zip_get_disk_number_with_cd(void *handle, int32_t *disk_number
     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;
@@ -1529,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) ||
@@ -1582,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;
 }
@@ -1598,7 +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 };
+    struct tm fixed_tm;
 
     // Years supported:
 
@@ -1610,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) |

mz_zip.h

@@ -1,5 +1,5 @@
 /* mz_zip.h -- Zip manipulation
-   Version 2.2.9, April 18th, 2018
+   Version 2.3.0, May 3rd, 2018
    part of the MiniZip project
 
    Copyright (C) 2010-2018 Nathan Moinvaziri
@@ -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,22 +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, int32_t *disk_number_with_cd);
+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
 
@@ -131,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