Added support for only using either compression or decompression with continued support for raw mode.

Renamed MZ_USE_WINRT_API to MZ_WINRT_API.

CMakeLists.txt

@@ -10,6 +10,8 @@ option(USE_BZIP2 "Enables BZIP2 compression" ON)
 option(USE_LZMA "Enables LZMA compression" ON)
 option(USE_PKCRYPT "Enables PKWARE traditional encryption" ON)
 option(USE_AES "Enables AES encryption" ON)
+option(COMPRESS_ONLY "Only support compression" OFF)
+option(DECOMPRESS_ONLY "Only support decompression" OFF)
 option(BUILD_TEST "Builds minizip test executable" OFF)
 
 # Set a consistent MACOSX_RPATH default across all CMake versions.
@@ -71,6 +73,13 @@ set(MINIZIP_PUBLIC_HEADERS
     mz_strm_split.h
     mz_zip.h)
 
+if(COMPRESS_ONLY)
+    add_definitions(-DMZ_ZIP_COMPRESS_ONLY)
+endif()
+if(DECOMPRESS_ONLY)
+    add_definitions(-DMZ_ZIP_DECOMPRESS_ONLY)
+endif()
+
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 if(WIN32)
@@ -81,7 +90,7 @@ if(WIN32)
 endif()
 
 if("${CMAKE_SYSTEM_NAME}" STREQUAL "WindowsStore")
-    add_definitions(-DMZ_USE_WINRT_API)
+    add_definitions(-DMZ_WINRT_API)
 endif()
 
 if(UNIX)

README.md

@@ -29,7 +29,8 @@ cmake --build .
 | USE_BZIP2 | Enables BZIP2 compression | ON |
 | USE_LZMA | Enables LZMA compression | ON |
 | USE_PKCRYPT | Enables PKWARE traditional encryption | ON |
-| USE_AES | Enables AES encryption | ON |
+| COMPRESS_ONLY | Only support compression | OFF |
+| DECOMPRESS_ONLY | Only support decompression | OFF |
 | BUILD_TEST | Builds minizip test executable | OFF |
 
 ## Zlib Installation (Windows)
@@ -192,7 +193,7 @@ void *zip_handle = mz_zip_open(split_stream, MZ_OPEN_MODE_WRITE);
 
 ### Windows RT
 
-+ Requires ``#define MZ_USE_WINRT_API``
++ Requires ``#define MZ_WINRT_API``
 
 ## Limitations
 

mz.h

@@ -35,6 +35,7 @@ extern "C" {
 #define MZ_CRYPT_ERROR                  (-106)
 #define MZ_EXIST_ERROR                  (-107)
 #define MZ_PASSWORD_ERROR               (-108)
+#define MZ_SUPPORT_ERROR                (-109)
 
 // MZ_OPEN
 #define MZ_OPEN_MODE_READ               (0x01)

mz_os_win32.c

@@ -26,9 +26,9 @@
 
 /***************************************************************************/
 
-#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(MZ_USE_WINRT_API)))
+#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(MZ_WINRT_API)))
 #  if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#    define MZ_USE_WINRT_API 1
+#    define MZ_WINRT_API 1
 #  endif
 #endif
 
@@ -118,7 +118,7 @@ int64_t mz_win32_get_file_size(const char *path)
 
 
     path_wide = mz_win32_unicode_path_create(path);
-#ifdef MZ_USE_WINRT_API
+#ifdef MZ_WINRT_API
     handle = CreateFile2W(path_wide, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 #else
     handle = CreateFileW(path_wide, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
@@ -188,7 +188,7 @@ int32_t mz_win32_set_file_date(const char *path, time_t modified_date, time_t ac
 
 
     path_wide = mz_win32_unicode_path_create(path);
-#ifdef MZ_USE_WINRT_API
+#ifdef MZ_WINRT_API
     handle = CreateFile2W(path_wide, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
 #else
     handle = CreateFileW(path_wide, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

mz_strm_bzip.c

@@ -76,17 +76,25 @@ int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode)
 
     if (mode & MZ_OPEN_MODE_WRITE)
     {
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         bzip->bzstream.next_out = (char *)bzip->buffer;
         bzip->bzstream.avail_out = sizeof(bzip->buffer);
 
         bzip->error = BZ2_bzCompressInit(&bzip->bzstream, bzip->level, 0, 0);
+#endif
     }
     else if (mode & MZ_OPEN_MODE_READ)
     {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         bzip->bzstream.next_in = (char *)bzip->buffer;
         bzip->bzstream.avail_in = 0;
 
         bzip->error = BZ2_bzDecompressInit(&bzip->bzstream, 0, 0);
+#endif
     }
 
     if (bzip->error != BZ_OK)
@@ -108,6 +116,9 @@ int32_t mz_stream_bzip_is_open(void *stream)
 
 int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
 {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+    return MZ_SUPPORT_ERROR;
+#else
     mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
     uint64_t total_in_before = 0;
     uint64_t total_out_before = 0;
@@ -189,6 +200,7 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
         return bzip->error;
 
     return total_out;
+#endif
 }
 
 static int32_t mz_stream_bzip_flush(void *stream)
@@ -252,16 +264,20 @@ static int32_t mz_stream_bzip_compress(void *stream, int flush)
 int32_t mz_stream_bzip_write(void *stream, const void *buf, int32_t size)
 {
     mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
+    int32_t err = size;
 
-
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+    MZ_UNUSED(bzip);
+    err = MZ_SUPPORT_ERROR;
+#else
     bzip->bzstream.next_in = (char *)(intptr_t)buf;
     bzip->bzstream.avail_in = (unsigned int)size;
 
     mz_stream_bzip_compress(stream, BZ_RUN);
 
     bzip->total_in += size;
-
+#endif
-    return size;
+    return err;
 }
 
 int64_t mz_stream_bzip_tell(void *stream)
@@ -286,14 +302,22 @@ int32_t mz_stream_bzip_close(void *stream)
 
     if (bzip->mode & MZ_OPEN_MODE_WRITE)
     {
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         mz_stream_bzip_compress(stream, BZ_FINISH);
         mz_stream_bzip_flush(stream);
 
         BZ2_bzCompressEnd(&bzip->bzstream);
+#endif
     }
     else if (bzip->mode & MZ_OPEN_MODE_READ)
     {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         BZ2_bzDecompressEnd(&bzip->bzstream);
+#endif
     }
 
     bzip->initialized = 0;

mz_strm_lzma.c

@@ -83,6 +83,10 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
 
     if (mode & MZ_OPEN_MODE_WRITE)
     {
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+        MZ_UNUSED(filters);
+        return MZ_SUPPORT_ERROR;
+#else
         lzma->lstream.next_out = lzma->buffer;
         lzma->lstream.avail_out = sizeof(lzma->buffer);
 
@@ -104,9 +108,13 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
         lzma->total_out += MZ_LZMA_HEADER_SIZE;
 
         lzma->error = lzma_alone_encoder(&lzma->lstream, &opt_lzma);
+#endif
     }
     else if (mode & MZ_OPEN_MODE_READ)
     {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         lzma->lstream.next_in = lzma->buffer;
         lzma->lstream.avail_in = 0;
 
@@ -117,6 +125,7 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
         lzma->total_in += MZ_LZMA_HEADER_SIZE;
 
         lzma->error = lzma_alone_decoder(&lzma->lstream, UINT64_MAX);
+#endif
     }
 
     if (lzma->error != LZMA_OK)
@@ -137,6 +146,9 @@ int32_t mz_stream_lzma_is_open(void *stream)
 
 int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
 {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+    return MZ_SUPPORT_ERROR;
+#else
     mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
     uint64_t total_in_before = 0;
     uint64_t total_out_before = 0;
@@ -212,6 +224,7 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
         return lzma->error;
 
     return total_out;
+#endif
 }
 
 static int32_t mz_stream_lzma_flush(void *stream)
@@ -270,16 +283,20 @@ static int32_t mz_stream_lzma_code(void *stream, int32_t flush)
 int32_t mz_stream_lzma_write(void *stream, const void *buf, int32_t size)
 {
     mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
+    int32_t err = size;
 
-
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+    MZ_UNUSED(lzma);
+    err = MZ_SUPPORT_ERROR;
+#else
     lzma->lstream.next_in = (uint8_t*)(intptr_t)buf;
     lzma->lstream.avail_in = (size_t)size;
 
     mz_stream_lzma_code(stream, LZMA_RUN);
 
     lzma->total_in += size;
-
+#endif
-    return size;
+    return err;
 }
 
 int64_t mz_stream_lzma_tell(void *stream)
@@ -304,14 +321,22 @@ int32_t mz_stream_lzma_close(void *stream)
 
     if (lzma->mode & MZ_OPEN_MODE_WRITE)
     {
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         mz_stream_lzma_code(stream, LZMA_FINISH);
         mz_stream_lzma_flush(stream);
 
         lzma_end(&lzma->lstream);
+#endif
     }
     else if (lzma->mode & MZ_OPEN_MODE_READ)
     {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         lzma_end(&lzma->lstream);
+#endif
     }
 
     lzma->initialized = 0;

mz_strm_win32.c

@@ -32,9 +32,9 @@
 #  define INVALID_SET_FILE_POINTER ((DWORD)-1)
 #endif
 
-#if defined(WINAPI_FAMILY_ONE_PARTITION) && !defined(MZ_USE_WINRT_API)
+#if defined(WINAPI_FAMILY_ONE_PARTITION) && !defined(MZ_WINRT_API)
 #  if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
-#    define MZ_USE_WINRT_API 1
+#    define MZ_WINRT_API 1
 #  endif
 #endif
 
@@ -106,7 +106,7 @@ int32_t mz_stream_win32_open(void *stream, const char *path, int32_t mode)
 
     MultiByteToWideChar(CP_UTF8, 0, path, -1, path_wide, path_wide_size);
 
-#ifdef MZ_USE_WINRT_API
+#ifdef MZ_WINRT_API
     win32->handle = CreateFile2W(path_wide, desired_access, share_mode, creation_disposition, NULL);
 #else
     win32->handle = CreateFileW(path_wide, desired_access, share_mode, NULL, creation_disposition, flags_attribs, NULL);
@@ -172,7 +172,7 @@ int32_t mz_stream_win32_write(void *stream, const void *buf, int32_t size)
 
 static int32_t mz_stream_win32_seekinternal(HANDLE handle, LARGE_INTEGER large_pos, LARGE_INTEGER *new_pos, uint32_t move_method)
 {
-#ifdef MZ_USE_WINRT_API
+#ifdef MZ_WINRT_API
     return SetFilePointerEx(handle, pos, newPos, dwMoveMethod);
 #else
     LONG high_part = large_pos.HighPart;

mz_strm_zlib.c

@@ -84,17 +84,25 @@ int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode)
 
     if (mode & MZ_OPEN_MODE_WRITE)
     {
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         zlib->zstream.next_out = zlib->buffer;
         zlib->zstream.avail_out = sizeof(zlib->buffer);
 
         zlib->error = deflateInit2(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+#endif
     }
     else if (mode & MZ_OPEN_MODE_READ)
     {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         zlib->zstream.next_in = zlib->buffer;
         zlib->zstream.avail_in = 0;
 
         zlib->error = inflateInit2(&zlib->zstream, -MAX_WBITS);
+#endif
     }
 
     if (zlib->error != Z_OK)
@@ -115,6 +123,9 @@ int32_t mz_stream_zlib_is_open(void *stream)
 
 int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
 {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+    return MZ_SUPPORT_ERROR;
+#else
     mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
     uint64_t total_in_before = 0;
     uint64_t total_in_after = 0;
@@ -194,6 +205,7 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
         return zlib->error;
 
     return total_out;
+#endif
 }
 
 static int32_t mz_stream_zlib_flush(void *stream)
@@ -254,16 +266,20 @@ static int32_t mz_stream_zlib_deflate(void *stream, int flush)
 int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size)
 {
     mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
+    int32_t err = size;
 
-
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+    MZ_UNUSED(zlib);
+    err = MZ_SUPPORT_ERROR;
+#else
     zlib->zstream.next_in = (Bytef*)(intptr_t)buf;
     zlib->zstream.avail_in = (uInt)size;
 
     mz_stream_zlib_deflate(stream, Z_NO_FLUSH);
 
     zlib->total_in += size;
-
+#endif
-    return size;
+    return err;
 }
 
 int64_t mz_stream_zlib_tell(void *stream)
@@ -289,14 +305,22 @@ int32_t mz_stream_zlib_close(void *stream)
 
     if (zlib->mode & MZ_OPEN_MODE_WRITE)
     {
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         mz_stream_zlib_deflate(stream, Z_FINISH);
         mz_stream_zlib_flush(stream);
 
         deflateEnd(&zlib->zstream);
+#endif
     }
     else if (zlib->mode & MZ_OPEN_MODE_READ)
     {
+#ifdef MZ_ZIP_COMPRESS_ONLY
+        return MZ_SUPPORT_ERROR;
+#else
         inflateEnd(&zlib->zstream);
+#endif
     }
 
     zlib->initialized = 0;

mz_zip.c

@@ -1260,6 +1260,10 @@ extern int32_t mz_zip_entry_read_open(void *handle, int16_t raw, const char *pas
     if (raw)
         compression_method = MZ_COMPRESS_METHOD_RAW;
 
+#ifdef MZ_ZIP_COMPRESS_ONLY
+    if (compression_method != MZ_COMPRESS_METHOD_RAW)
+        err = MZ_SUPPORT_ERROR;
+#endif 
     if (err == MZ_OK)
         err = mz_zip_entry_open_int(handle, compression_method, 0, password);
 
@@ -1328,6 +1332,10 @@ extern int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_inf
     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;
 
+#ifdef MZ_ZIP_DECOMPRESS_ONLY
+    if (compression_method != MZ_COMPRESS_METHOD_RAW)
+        err = MZ_SUPPORT_ERROR;
+#endif
     if (err == MZ_OK)
         err = mz_zip_entry_write_header(zip->stream, 1, &zip->file_info);
     if (err == MZ_OK)
@@ -1356,9 +1364,12 @@ extern int32_t mz_zip_entry_read(void *handle, void *buf, uint32_t len)
 extern int32_t mz_zip_entry_write(void *handle, const void *buf, uint32_t len)
 {
     mz_zip *zip = (mz_zip *)handle;
+    int32_t written = 0;
+
     if (zip == NULL || zip->entry_opened == 0)
         return MZ_PARAM_ERROR;
-    return mz_stream_write(zip->crc32_stream, buf, len);
+    written = mz_stream_write(zip->crc32_stream, buf, len);
+    return written;
 }
 
 extern int32_t mz_zip_entry_get_info(void *handle, mz_zip_file **file_info)