c/minizip-ng
1
0
Fork 0
mirror of https://github.com/zlib-ng/minizip-ng synced 2025-03-28 21:13:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged miniunz into minizip.

Browse Source 
Renamed passthru stream to raw stream.
Removed zlib extra compression parameters, so now all streams have the same basic parameter, which is compression level. And so got rid of mz_zip_compress and mz_zip_crypt structures.
Fixed issues using the disk splitting stream when the disk size was 0.
Changed return value of mz_file_exists to be consistent with all other functions.
Updated test harness and added empty zip test.
This commit is contained in:
Nathan Moinvaziri 2017-10-18 16:51:10 -07:00
parent 68fae9970c
commit a66cc31fac
16 changed files with 756 additions and 943 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
CMakeLists.txt
View File

@ -9,7 +9,7 @@ option(USE_CRYPT "Enables building with PKWARE traditional encryption" ON)
option(USE_AES "Enables building with AES library" ON)
option(USE_BZIP2 "Enables building with BZIP2 library" ON)
option(USE_LZMA "Enables building with LZMA library" ON)
option(BUILD_TEST "Enables building of executables minizip and miniunz. Requires ZLIB!" OFF)
option(BUILD_TEST "Enables building of executables. Requires ZLIB!" OFF)
# Set a consistent MACOSX_RPATH default across all CMake versions.
# When CMake 2.8.12 is required, change this default to 1.
@ -45,25 +45,25 @@ set(PROJECT_NAME libminizip)
set(MINIZIP_SRC
src/mz_os.c
src/mz_compat.c
src/mz_strm.c
src/mz_strm_buf.c
src/mz_strm_mem.c
src/mz_strm_posix.c
src/mz_strm_split.c
src/mz_strm_zlib.c
src/mz_unzip.c
src/mz_zip.c)
set(MINIZIP_PUBLIC_HEADERS
src/mz.h
src/mz_os.h
src/mz_compat.h
src/mz_strm.h
src/mz_strm_buf.h
src/mz_strm_mem.h
src/mz_strm_posix.h
src/mz_strm_split.h
src/mz_strm_zlib.h
src/mz_unzip.h
src/mz_zip.h)
if(WIN32)
@ -379,12 +379,9 @@ install(FILES ${MINIZIP_PUBLIC_HEADERS} DESTINATION "${INSTALL_INC_DIR}")
install(FILES ${MINIZIP_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
if(BUILD_TEST)
add_executable(miniunz "src/miniunz.c")
target_link_libraries(miniunz ${PROJECT_NAME})
add_executable(minizip "src/minizip.c")
target_link_libraries(minizip ${PROJECT_NAME})
install(TARGETS miniunz minizip
install(TARGETS minizip
RUNTIME DESTINATION "bin")
endif()

8
Minizip.podspec
View File

@ -7,17 +7,17 @@ Pod::Spec.new do |s|
Minizip zlib contribution that includes:
* AES encryption
* I/O buffering
* PKWARE disk spanning
It also has the latest bug fixes that having been found all over the internet including the minizip forum and zlib developer's mailing list.
* PKWARE disk splitting
It also has the latest bug fixes that having been found all over the internet.
DESC
s.homepage = 'https://github.com/nmoinvaz/minizip'
s.authors = 'Gilles Vollant', 'Nathan Moinvaziri'
s.authors = 'Nathan Moinvaziri', 'Gilles Vollant'
s.source = { :git => 'https://github.com/nmoinvaz/minizip.git' }
s.libraries = 'z'
s.subspec 'Core' do |sp|
sp.source_files = '{mz_strm,mz_strm_mem,mz_strm_buf,mz_unzip,mz_zip,mz_strm_crypt,mz_strm_posix,mz_strm_zlib}.{c,h}'
sp.source_files = 'src/{mz_os,mz_compat,mz_strm,mz_strm_mem,mz_strm_buf,mz_zip,mz_strm_crypt,mz_strm_posix,mz_strm_zlib}.{c,h}'
end
s.subspec 'AES' do |sp|

14
README.md
View File

@ -20,8 +20,7 @@ cmake --build .
| File(s) | Description | Required |
|:- |:-|:-:|
| miniunz.c | Sample unzip application | No |
| minizip.c | Sample zip application | No |
| minizip.c | Sample application | No |
| mz_compat.\* | Minizip 1.0 compatibility layer | No |
| mz.h | Error codes and flags | Yes |
| mz_os\* | OS specific helper functions | Encryption |
@ -36,8 +35,7 @@ cmake --build .
| mz_strm_posix.\* | File stream using Posix functions | Non-windows systems |
| mz_strm_win32.\* | File stream using Win32 API functions | Windows systems |
| mz_strm_zlib.\* | Deflate stream using zlib | Yes |
| mz_unzip.\* | Unzip functionality | Unzipping |
| mz_zip.\* | Zip functionality | Zipping |
| mz_zip.\* | Zip functionality | Yes |
## Features
@ -58,7 +56,7 @@ mz_stream_mem_create(&mem_stream);
mz_stream_mem_set_buffer(mem_stream, zip_buffer, zip_buffer_size);
mz_stream_open(mem_stream, NULL, MZ_STREAM_MODE_READ);
void *unz_handle = mz_unzip_open(mem_stream);
void *zip_handle = mz_zip_open(mem_stream, MZ_STREAM_MODE_READ);
// do unzip operations
mz_stream_mem_delete(&mem_stream);
@ -74,7 +72,7 @@ mz_stream_mem_set_grow(mem_stream, 1);
mz_stream_mem_set_grow_size(mem_stream, (128 * 1024));
mz_stream_open(mem_stream, NULL, MZ_STREAM_MODE_CREATE);
void *zip_handle = mz_zip_open(0, 0, mem_stream);
void *zip_handle = mz_zip_open(mem_stream, MZ_STREAM_MODE_WRITE);
// do unzip operations
mz_stream_mem_delete(&mem_stream);
@ -94,7 +92,7 @@ mz_stream_buffered_create(&buf_stream);
mz_stream_buffered_open(buf_stream, NULL, MZ_STREAM_MODE_READ);
mz_stream_buffered_set_base(buf_stream, stream);
void *unz_handle = mz_unzip_open(buf_stream);
void *zip_handle = mz_zip_open(buf_stream, MZ_STREAM_MODE_READ);
```
#### Disk Splitting Stream
@ -114,7 +112,7 @@ mz_stream_set_base(split_stream, stream);
mz_stream_open(split_stream, path..
handle = mz_unzip/zip_open(split_stream);
handle = mz_zip_open(split_stream, MZ_STREAM_MODE_WRITE);
```
The central directory is the only data stored in the .zip and doesn't follow disk size restrictions.

474
src/miniunz.c
View File

@ -1,474 +0,0 @@
/* miniunz.c
Version 2.0.1, October 16th, 2017
part of the MiniZip project
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Copyright (C) 2009-2010 Mathias Svensson
Modifications for Zip64 support
http://result42.com
Copyright (C) 2007-2008 Even Rouault
Modifications of Unzip for Zip64
Copyright (C) 1998-2010 Gilles Vollant
http://www.winimage.com/zLibDll/minizip.html
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include "mz.h"
#include "mz_os.h"
#include "mz_strm.h"
#include "mz_strm_split.h"
#include "mz_zip.h"
/***************************************************************************/
void miniunz_banner()
{
printf("Miniunz %s - https://github.com/nmoinvaz/minizip\n", MZ_VERSION);
printf("---------------------------------------------------\n");
}
void miniunz_help()
{
printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \
" -e Extract without path (junk paths)\n" \
" -x Extract with path\n" \
" -v List files\n" \
" -l List files\n" \
" -d Directory to extract into\n" \
" -o Overwrite files without prompting\n" \
" -p Extract crypted file using password\n\n");
}
/***************************************************************************/
typedef struct miniunz_opt_s {
uint8_t extract_without_path;
uint8_t overwrite;
} miniunz_opt;
/***************************************************************************/
int32_t miniunz_list(void *handle)
{
mz_zip_file *file_info = NULL;
uint32_t ratio = 0;
int16_t level = 0;
int16_t err = MZ_OK;
struct tm tmu_date = { 0 };
const char *string_method = NULL;
char crypt = ' ';
err = mz_zip_goto_first_entry(handle);
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
printf("Error %d going to first entry in zip file\n", err);
return err;
}
printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
do
{
err = mz_zip_entry_get_info(handle, &file_info);
if (err != MZ_OK)
{
printf("Error %d getting entry info in zip file\n", err);
break;
}
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 = '*';
switch (file_info->compression_method)
{
case MZ_COMPRESS_METHOD_RAW:
string_method = "Stored";
break;
case MZ_COMPRESS_METHOD_DEFLATE:
level = (int16_t)((file_info->flag & 0x6) / 2);
if (level == 0)
string_method = "Defl:N";
else if (level == 1)
string_method = "Defl:X";
else if ((level == 2) || (level == 3))
string_method = "Defl:F"; // 2: fast , 3: extra fast
else
string_method = "Defl:?";
break;
case MZ_COMPRESS_METHOD_BZIP2:
string_method = "BZip2";
break;
case MZ_COMPRESS_METHOD_LZMA:
string_method = "LZMA";
break;
default:
string_method = "Unknwn";
}
mz_dosdate_to_tm(file_info->dos_date, &tmu_date);
printf(" %7llu %6s%c %7llu %3u%% %2.2u-%2.2u-%2.2u %2.2u:%2.2u %8.8x %s\n",
file_info->uncompressed_size, string_method, crypt, file_info->compressed_size, 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,
file_info->crc, file_info->filename);
err = mz_zip_goto_next_entry(handle);
}
while (err == MZ_OK);
if (err != MZ_END_OF_LIST && err != MZ_OK)
{
printf("Error %d going to next entry in zip file\n", err);
return err;
}
return MZ_OK;
}
int32_t miniunz_extract_currentfile(void *handle, const char *destination, const char *password, miniunz_opt *options)
{
mz_zip_file *file_info = NULL;
uint8_t buf[INT16_MAX];
int32_t read = 0;
int32_t written = 0;
int16_t err = MZ_OK;
int16_t err_close = MZ_OK;
uint8_t skip = 0;
void *stream = NULL;
char *match = NULL;
char *filename = NULL;
char out_path[512];
char directory[512];
err = mz_zip_entry_get_info(handle, &file_info);
if (err != MZ_OK)
{
printf("Error %d getting entry info in zip file\n", err);
return err;
}
match = filename = file_info->filename;
while (*match != 0)
{
if ((*match == '/') || (*match == '\\'))
filename = match + 1;
match += 1;
}
// Construct output path
out_path[0] = 0;
if (destination != NULL)
mz_path_combine(out_path, destination, sizeof(out_path));
if (options->extract_without_path)
mz_path_combine(out_path, filename, sizeof(out_path));
else
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 (options->extract_without_path == 0)
{
printf("Creating directory: %s\n", out_path);
mz_make_dir(out_path);
}
return err;
}
err = mz_zip_entry_read_open(handle, 0, password);
if (err != MZ_OK)
{
printf("Error %d opening entry in zip file\n", err);
return err;
}
// Determine if the file should be overwritten or not and ask the user if needed
if ((err == MZ_OK) && (options->overwrite == 0) && (mz_file_exists(out_path)))
{
char rep = 0;
do
{
char answer[128];
printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ", out_path);
if (scanf("%1s", answer) != 1)
exit(EXIT_FAILURE);
rep = answer[0];
if ((rep >= 'a') && (rep <= 'z'))
rep -= 0x20;
}
while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
if (rep == 'N')
skip = 1;
if (rep == 'A')
options->overwrite = 1;
}
mz_stream_os_create(&stream);
// Create the file on disk so we can unzip to it
if ((skip == 0) && (err == MZ_OK))
{
// Some zips don't contain directory alone before file
if ((mz_stream_os_open(stream, out_path, MZ_STREAM_MODE_CREATE) != MZ_OK) &&
(options->extract_without_path == 0) && (filename != file_info->filename))
{
// Create the directory of the output path
strncpy(directory, out_path, sizeof(directory));
match = directory + strlen(directory) - 1;
while (match > directory)
{
if ((*match == '/') || (*match == '\\'))
{
*match = 0;
break;
}
match -= 1;
}
mz_make_dir(directory);
mz_stream_os_open(stream, out_path, MZ_STREAM_MODE_CREATE);
}
}
// Read from the zip, unzip to buffer, and write to disk
if (mz_stream_os_is_open(stream) == MZ_OK)
{
printf(" Extracting: %s\n", out_path);
while (1)
{
read = mz_zip_entry_read(handle, buf, sizeof(buf));
if (read < 0)
{
err = read;
printf("Error %d reading entry in zip file\n", err);
break;
}
if (read == 0)
break;
written = mz_stream_os_write(stream, buf, read);
if (written != read)
{
err = mz_stream_os_error(stream);
printf("Error %d in writing extracted file\n", err);
break;
}
}
mz_stream_os_close(stream);
// Set the time of the file that has been unzipped
if (err == MZ_OK)
mz_os_set_file_date(out_path, file_info->dos_date);
}
else
{
printf("Error opening %s\n", out_path);
}
mz_stream_os_delete(&stream);
err_close = mz_zip_entry_close(handle);
if (err_close != MZ_OK)
printf("Error %d closing entry in zip file\n", err_close);
return err;
}
int32_t miniunz_extract_all(void *handle, const char *destination, const char *password, miniunz_opt *options)
{
int16_t err = MZ_OK;
err = mz_zip_goto_first_entry(handle);
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
printf("Error %d going to first entry in zip file\n", err);
return 1;
}
while (err == MZ_OK)
{
err = miniunz_extract_currentfile(handle, destination, password, options);
if (err != MZ_OK)
break;
err = mz_zip_goto_next_entry(handle);
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
printf("Error %d going to next entry in zip file\n", err);
return 1;
}
}
return 0;
}
int32_t miniunz_extract_onefile(void *handle, const char *filename, const char *destination, const char *password, miniunz_opt *options)
{
if (mz_zip_locate_entry(handle, filename, NULL) != MZ_OK)
{
printf("File %s not found in the zip file\n", filename);
return 2;
}
if (miniunz_extract_currentfile(handle, destination, password, options) == MZ_OK)
return 0;
return 1;
}
#ifndef NOMAIN
int main(int argc, const char *argv[])
{
void *handle = NULL;
void *stream = NULL;
void *split_stream = NULL;
void *open_stream = NULL;
miniunz_opt options;
int16_t i = 0;
uint8_t do_list = 0;
uint8_t do_extract = 1;
const char *path = NULL;
const char *password = NULL;
const char *destination = NULL;
const char *filename_to_extract = NULL;
int err = 0;
miniunz_banner();
if (argc == 1)
{
miniunz_help();
return 0;
}
memset(&options, 0, sizeof(options));
// Parse command line options
for (i = 1; i < argc; i++)
{
if ((*argv[i]) == '-')
{
const char *p = argv[i] + 1;
while (*p != 0)
{
char c = *(p++);
if ((c == 'l') || (c == 'L'))
do_list = 1;
if ((c == 'v') || (c == 'V'))
do_list = 1;
if ((c == 'x') || (c == 'X'))
do_extract = 1;
if ((c == 'e') || (c == 'E'))
do_extract = options.extract_without_path = 1;
if ((c == 'o') || (c == 'O'))
options.overwrite = 1;
if (((c == 'd') || (c == 'D')) && (i + 1 < argc))
{
destination = argv[i + 1];
i += 1;
}
if (((c == 'p') || (c == 'P')) && (i + 1 < argc))
{
password = argv[i + 1];
i += 1;
}
}
continue;
}
if (path == NULL)
path = argv[i];
else if ((filename_to_extract == NULL) && (destination == NULL))
filename_to_extract = argv[i];
}
if (path == NULL)
{
printf("Error missing path\n");
return 1;
}
mz_stream_os_create(&stream);
mz_stream_split_create(&split_stream);
mz_stream_set_base(split_stream, stream);
err = mz_stream_open(split_stream, path, MZ_STREAM_MODE_READ);
if (err != MZ_OK)
{
printf("Error opening file %s\n", path);
}
else
{
// Open zip file
handle = mz_zip_open(split_stream, MZ_STREAM_MODE_READ);
if (handle == NULL)
{
printf("Error opening zip %s\n", path);
err = 1;
}
else
{
printf("%s opened\n", path);
// Process command line options
if (do_list)
{
err = miniunz_list(handle);
}
else if (do_extract)
{
// Create target directory if it doesn't exist
if (destination != NULL)
mz_make_dir(destination);
if (filename_to_extract == NULL)
err = miniunz_extract_all(handle, destination, password, &options);
else
err = miniunz_extract_onefile(handle, filename_to_extract, destination, password, &options);
}
mz_zip_close(handle, NULL, NULL);
}
mz_stream_os_close(stream);
}
mz_stream_split_delete(&split_stream);
mz_stream_os_delete(&stream);
return err;
}
#endif

462
src/minizip.c
View File

@ -38,35 +38,43 @@ void minizip_banner()
void minizip_help()
{
printf("Usage : minizip [-o] [-a] [-0 to -9] [-b|-m] [-s] [-j] [-p password] [-k 512] file.zip [files_to_add]\n\n");
printf(" -o Overwrite existing file.zip\n");
printf(" -a Append to existing file.zip\n");
printf(" -0 Store only\n");
printf(" -1 Compress faster\n");
printf(" -9 Compress better\n");
printf("Usage : minizip [-x -d dir|-l] [-o] [-a] [-j] [-0 to -9] [-b|-m] [-k 512] [-p pwd] [-s] file.zip [files]\n\n" \
" -x Extract files\n" \
" -l List files\n" \
" -d Destination directory\n" \
" -o Overwrite existing files\n" \
" -a Append to existing zip file\n" \
" -j Exclude path of files\n" \
" -0 Store only\n" \
" -1 Compress faster\n" \
" -9 Compress better\n" \
" -k Disk size in KB\n" \
" -p Encryption password\n");
#ifdef HAVE_AES
printf(" -s AES encryption\n");
#endif
#ifdef HAVE_BZIP2
printf(" -b BZIP2 compression\n");
#endif
#ifdef HAVE_LZMA
printf(" -m LZMA compression\n");
#endif
#ifdef HAVE_AES
printf(" -s AES encryption\n");
#endif
printf(" -p Encryption password\n");
printf(" -k Disk size in KB\n");
printf(" -j Exclude path and store only the file name\n\n");
printf("\n");
}
/***************************************************************************/
typedef struct minizip_opt_s {
uint8_t exclude_path;
int16_t compress_level;
int16_t compress_method;
int16_t aes;
uint8_t overwrite;
} minizip_opt;
/***************************************************************************/
int32_t minizip_add_file(void *handle, const char *path, minizip_opt *options, mz_zip_compress *compress_info, mz_zip_crypt *crypt_info)
int32_t minizip_add_file(void *handle, const char *path, const char *password, minizip_opt *options)
{
mz_zip_file file_info = { 0 };
int32_t read = 0;
@ -105,6 +113,8 @@ int32_t minizip_add_file(void *handle, const char *path, minizip_opt *options, m
// Get information about the file on disk so we can store it in zip
printf("Adding: %s\n", filenameinzip);
file_info.aes_version = options->aes;
file_info.compression_method = options->compress_method;
file_info.filename = filenameinzip;
if (mz_file_get_size(path) >= UINT32_MAX)
@ -113,7 +123,7 @@ int32_t minizip_add_file(void *handle, const char *path, minizip_opt *options, m
mz_os_get_file_date(path, &file_info.dos_date);
// Add to zip
err = mz_zip_entry_write_open(handle, &file_info, compress_info, crypt_info);
err = mz_zip_entry_write_open(handle, &file_info, options->compress_level, password);
if (err != MZ_OK)
{
printf("Error in opening %s in zip file (%d)\n", filenameinzip, err);
@ -160,12 +170,15 @@ int32_t minizip_add_file(void *handle, const char *path, minizip_opt *options, m
err_close = mz_zip_entry_close(handle);
if (err_close != MZ_OK)
{
printf("Error in closing %s in the zip file (%d)\n", filenameinzip, err_close);
err = err_close;
}
return err;
}
int32_t minizip_add(void *handle, const char *path, minizip_opt *options, mz_zip_compress *compress_info, mz_zip_crypt *crypt_info, uint8_t recursive)
int32_t minizip_add(void *handle, const char *path, const char *password, minizip_opt *options, uint8_t recursive)
{
DIR *dir = NULL;
struct dirent *entry = NULL;
@ -174,7 +187,7 @@ int32_t minizip_add(void *handle, const char *path, minizip_opt *options, mz_zip
if (mz_os_is_dir(path) != MZ_OK)
return minizip_add_file(handle, path, options, compress_info, crypt_info);
return minizip_add_file(handle, path, password, options);
dir = mz_os_open_dir(path);
@ -196,7 +209,7 @@ int32_t minizip_add(void *handle, const char *path, minizip_opt *options, mz_zip
if (!recursive && mz_os_is_dir(full_path))
continue;
err = minizip_add(handle, full_path, options, compress_info, crypt_info, recursive);
err = minizip_add(handle, full_path, password, options, recursive);
if (err != MZ_OK)
return err;
}
@ -205,23 +218,317 @@ int32_t minizip_add(void *handle, const char *path, minizip_opt *options, mz_zip
return MZ_OK;
}
/***************************************************************************/
int32_t minizip_list(void *handle)
{
mz_zip_file *file_info = NULL;
uint32_t ratio = 0;
int16_t level = 0;
int16_t err = MZ_OK;
struct tm tmu_date = { 0 };
const char *string_method = NULL;
char crypt = ' ';
err = mz_zip_goto_first_entry(handle);
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
printf("Error %d going to first entry in zip file\n", err);
}
else
{
printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
}
while (err == MZ_OK)
{
err = mz_zip_entry_get_info(handle, &file_info);
if (err != MZ_OK)
{
printf("Error %d getting entry info in zip file\n", err);
break;
}
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 = '*';
switch (file_info->compression_method)
{
case MZ_COMPRESS_METHOD_RAW:
string_method = "Stored";
break;
case MZ_COMPRESS_METHOD_DEFLATE:
level = (int16_t)((file_info->flag & 0x6) / 2);
if (level == 0)
string_method = "Defl:N";
else if (level == 1)
string_method = "Defl:X";
else if ((level == 2) || (level == 3))
string_method = "Defl:F"; // 2: fast , 3: extra fast
else
string_method = "Defl:?";
break;
case MZ_COMPRESS_METHOD_BZIP2:
string_method = "BZip2";
break;
case MZ_COMPRESS_METHOD_LZMA:
string_method = "LZMA";
break;
default:
string_method = "Unknwn";
}
mz_dosdate_to_tm(file_info->dos_date, &tmu_date);
printf(" %7llu %6s%c %7llu %3u%% %2.2u-%2.2u-%2.2u %2.2u:%2.2u %8.8x %s\n",
file_info->uncompressed_size, string_method, crypt, file_info->compressed_size, 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,
file_info->crc, file_info->filename);
err = mz_zip_goto_next_entry(handle);
}
if (err == MZ_END_OF_LIST)
return MZ_OK;
if (err != MZ_OK)
printf("Error %d going to next entry in zip file\n", err);
return err;
}
/***************************************************************************/
int32_t minizip_extract_currentfile(void *handle, const char *destination, const char *password, minizip_opt *options)
{
mz_zip_file *file_info = NULL;
uint8_t buf[INT16_MAX];
int32_t read = 0;
int32_t written = 0;
int16_t err = MZ_OK;
int16_t err_close = MZ_OK;
uint8_t skip = 0;
void *stream = NULL;
char *match = NULL;
char *filename = NULL;
char out_path[512];
char directory[512];
err = mz_zip_entry_get_info(handle, &file_info);
if (err != MZ_OK)
{
printf("Error %d getting entry info in zip file\n", err);
return err;
}
match = filename = (char *)file_info->filename;
while (*match != 0)
{
if ((*match == '/') || (*match == '\\'))
filename = match + 1;
match += 1;
}
// 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));
else
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 (options->exclude_path == 0)
{
printf("Creating directory: %s\n", out_path);
mz_make_dir(out_path);
}
return err;
}
err = mz_zip_entry_read_open(handle, 0, password);
if (err != MZ_OK)
{
printf("Error %d opening entry in zip file\n", err);
return err;
}
// Determine if the file should be overwritten or not and ask the user if needed
if ((err == MZ_OK) && (options->overwrite == 0) && (mz_file_exists(out_path) == MZ_OK))
{
char rep = 0;
do
{
char answer[128];
printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ", out_path);
if (scanf("%1s", answer) != 1)
exit(EXIT_FAILURE);
rep = answer[0];
if ((rep >= 'a') && (rep <= 'z'))
rep -= 0x20;
}
while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
if (rep == 'N')
skip = 1;
if (rep == 'A')
options->overwrite = 1;
}
mz_stream_os_create(&stream);
// Create the file on disk so we can unzip to it
if ((skip == 0) && (err == MZ_OK))
{
// Some zips don't contain directory alone before file
if ((mz_stream_os_open(stream, out_path, MZ_STREAM_MODE_CREATE) != MZ_OK) &&
(options->exclude_path == 0) && (filename != file_info->filename))
{
// Create the directory of the output path
strncpy(directory, out_path, sizeof(directory));
match = directory + strlen(directory) - 1;
while (match > directory)
{
if ((*match == '/') || (*match == '\\'))
{
*match = 0;
break;
}
match -= 1;
}
mz_make_dir(directory);
mz_stream_os_open(stream, out_path, MZ_STREAM_MODE_CREATE);
}
}
// Read from the zip, unzip to buffer, and write to disk
if (mz_stream_os_is_open(stream) == MZ_OK)
{
printf(" Extracting: %s\n", out_path);
while (1)
{
read = mz_zip_entry_read(handle, buf, sizeof(buf));
if (read < 0)
{
err = read;
printf("Error %d reading entry in zip file\n", err);
break;
}
if (read == 0)
break;
written = mz_stream_os_write(stream, buf, read);
if (written != read)
{
err = mz_stream_os_error(stream);
printf("Error %d in writing extracted file\n", err);
break;
}
}
mz_stream_os_close(stream);
// Set the time of the file that has been unzipped
if (err == MZ_OK)
mz_os_set_file_date(out_path, file_info->dos_date);
}
else
{
printf("Error opening %s\n", out_path);
}
mz_stream_os_delete(&stream);
err_close = mz_zip_entry_close(handle);
if (err_close != MZ_OK)
{
printf("Error %d closing entry in zip file\n", err_close);
err = err_close;
}
return err;
}
int32_t minizip_extract_all(void *handle, const char *destination, const char *password, minizip_opt *options)
{
int16_t err = MZ_OK;
err = mz_zip_goto_first_entry(handle);
if (err == MZ_END_OF_LIST)
return MZ_OK;
if (err != MZ_OK)
printf("Error %d going to first entry in zip file\n", err);
while (err == MZ_OK)
{
err = minizip_extract_currentfile(handle, destination, password, options);
if (err != MZ_OK)
break;
err = mz_zip_goto_next_entry(handle);
if (err == MZ_END_OF_LIST)
return MZ_OK;
if (err != MZ_OK)
printf("Error %d going to next entry in zip file\n", err);
}
return err;
}
int32_t minizip_extract_onefile(void *handle, const char *filename, const char *destination, const char *password, minizip_opt *options)
{
int16_t err = mz_zip_locate_entry(handle, filename, NULL);
if (err != MZ_OK)
{
printf("File %s not found in the zip file\n", filename);
return err;
}
return minizip_extract_currentfile(handle, destination, password, options);
}
/***************************************************************************/
#ifndef NOMAIN
int main(int argc, char *argv[])
{
void *handle = NULL;
void *file_stream = NULL;
void *split_stream = NULL;
void *open_stream = NULL;
char *path = NULL;
char *password = NULL;
char *destination = NULL;
char *filename_to_extract = NULL;
minizip_opt options;
mz_zip_compress compress_info;
mz_zip_crypt crypt_info;
int64_t disk_size = 0;
int32_t path_arg = 0;
uint8_t opt_append = 0;
uint8_t opt_open_existing = 0;
uint8_t opt_exclude_path = 0;
uint8_t do_list = 0;
uint8_t do_extract = 0;
int16_t mode = 0;
uint8_t append = 0;
int16_t err_close = 0;
int16_t err = 0;
int16_t i = 0;
@ -234,11 +541,9 @@ int main(int argc, char *argv[])
}
memset(&options, 0, sizeof(options));
memset(&compress_info, 0, sizeof(compress_info));
memset(&crypt_info, 0, sizeof(crypt_info));
compress_info.method = MZ_COMPRESS_METHOD_DEFLATE;
compress_info.level = MZ_COMPRESS_LEVEL_DEFAULT;
options.compress_method = MZ_COMPRESS_METHOD_DEFLATE;
options.compress_level = MZ_COMPRESS_LEVEL_DEFAULT;
// Parse command line options
for (i = 1; i < argc; i++)
@ -250,38 +555,48 @@ int main(int argc, char *argv[])
while ((*p) != '\0')
{
char c = *(p++);
if ((c == 'o') || (c == 'O'))
opt_append = 1;
if ((c == 'l') || (c == 'L'))
do_list = 1;
if ((c == 'x') || (c == 'X'))
do_extract = 1;
if ((c == 'a') || (c == 'A'))
opt_open_existing = 1;
if ((c >= '0') && (c <= '9'))
{
compress_info.level = (c - '0');
if (compress_info.level == 0)
compress_info.method = MZ_COMPRESS_METHOD_RAW;
}
append = 1;
if ((c == 'o') || (c == 'O'))
options.overwrite = 1;
if ((c == 'j') || (c == 'J'))
options.exclude_path = 1;
if ((c >= '0') && (c <= '9'))
{
options.compress_level = (c - '0');
if (options.compress_level == 0)
options.compress_method = MZ_COMPRESS_METHOD_RAW;
}
#ifdef HAVE_BZIP2
if ((c == 'b') || (c == 'B'))
compress_info.method = MZ_COMPRESS_METHOD_BZIP2;
options.compress_method = MZ_COMPRESS_METHOD_BZIP2;
#endif
#ifdef HAVE_LZMA
if ((c == 'm') || (c == 'M'))
compress_info.method = MZ_COMPRESS_METHOD_LZMA;
options.compress_method = MZ_COMPRESS_METHOD_LZMA;
#endif
#ifdef HAVE_AES
if ((c == 's') || (c == 'S'))
crypt_info.aes = 1;
options.aes = 1;
#endif
if (((c == 'k') || (c == 'k')) && (i + 1 < argc))
{
disk_size = atoi(argv[i + 1]) * 1024;
i += 1;
}
if (((c == 'd') || (c == 'D')) && (i + 1 < argc))
{
destination = argv[i + 1];
i += 1;
}
if (((c == 'p') || (c == 'P')) && (i + 1 < argc))
{
crypt_info.password = argv[i + 1];
password = argv[i + 1];
i += 1;
}
}
@ -301,17 +616,21 @@ int main(int argc, char *argv[])
path = argv[path_arg];
if (opt_open_existing)
mode = MZ_STREAM_MODE_READ;
if ((do_list == 0) && (do_extract == 0))
{
mode |= MZ_STREAM_MODE_WRITE;
if (mz_file_exists(path) != MZ_OK)
{
// If the file doesn't exist, we don't append file
if (mz_file_exists(path) != MZ_OK)
opt_append = 0;
if (append)
mode |= MZ_STREAM_MODE_APPEND;
}
else if (opt_append == 0)
else if (options.overwrite == 0)
{
// If ask the user what to do because append and overwrite args not set
if (mz_file_exists(path) != MZ_OK)
{
char rep = 0;
do
{
@ -328,7 +647,7 @@ int main(int argc, char *argv[])
if (rep == 'A')
{
opt_open_existing = 1;
mode |= MZ_STREAM_MODE_APPEND;
}
else if (rep == 'N')
{
@ -336,30 +655,18 @@ int main(int argc, char *argv[])
return 0;
}
}
if ((mode & MZ_STREAM_MODE_APPEND) == 0)
mode |= MZ_STREAM_MODE_CREATE;
}
mz_stream_os_create(&file_stream);
mode = MZ_STREAM_MODE_READWRITE;
if (opt_append)
mode |= MZ_STREAM_MODE_APPEND;
else
mode |= MZ_STREAM_MODE_CREATE;
if (disk_size > 0)
{
mz_stream_split_create(&split_stream);
mz_stream_set_base(split_stream, file_stream);
mz_stream_split_set_prop_int64(split_stream, MZ_STREAM_PROP_DISK_SIZE, disk_size);
open_stream = split_stream;
}
else
{
open_stream = file_stream;
}
err = mz_stream_open(open_stream, path, mode);
err = mz_stream_open(split_stream, path, mode);
if (err != MZ_OK)
{
@ -367,33 +674,52 @@ int main(int argc, char *argv[])
}
else
{
handle = mz_zip_open(open_stream, mode);
handle = mz_zip_open(split_stream, mode);
if (handle == NULL)
{
printf("Error opening zip %s\n", path);
err = MZ_FORMAT_ERROR;
}
if (do_list)
{
err = minizip_list(handle);
}
else if (do_extract)
{
// Create target directory if it doesn't exist
if (destination != NULL)
mz_make_dir(destination);
if (argc > path_arg + 1)
filename_to_extract = argv[path_arg + 1];
if (filename_to_extract == NULL)
err = minizip_extract_all(handle, destination, password, &options);
else
err = minizip_extract_onefile(handle, filename_to_extract, destination, password, &options);
}
else
{
printf("Creating %s\n", path);
// 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], &options, &compress_info, &crypt_info, 1);
err = minizip_add(handle, argv[i], password, &options, 1);
err_close = mz_zip_close(handle, NULL, MZ_VERSION_MADEBY);
if (err_close != MZ_OK)
{
printf("Error in closing %s (%d)\n", path, err_close);
err = err_close;
}
}
mz_stream_os_close(file_stream);
}
if (split_stream != NULL)
mz_stream_split_delete(&split_stream);
mz_stream_os_delete(&file_stream);
return err;

16
src/mz_compat.c
View File

@ -120,6 +120,7 @@ extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, cons
file_info.internal_fa = zipfi->internal_fa;
}
file_info.compression_method = compression_method;
file_info.filename = (char *)filename;
//file_info.extrafield_local = extrafield_local;
//file_info.extrafield_local_size = size_extrafield_local;
@ -129,22 +130,11 @@ extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, cons
file_info.comment = (char *)comment;
file_info.flag = flag_base;
file_info.zip_64 = zip64;
mz_zip_compress compress_info;
compress_info.level = level;
compress_info.window_bits = windowBits;
compress_info.mem_level = memLevel;
compress_info.strategy = strategy;
compress_info.method = compression_method;
mz_zip_crypt crypt_info;
#ifdef HAVE_AES
crypt_info.aes = 1;
file_info.aes_version = 1;
#endif
crypt_info.password = password;
return mz_zip_entry_write_open(compat->handle, &file_info, &compress_info, &crypt_info);
return mz_zip_entry_write_open(compat->handle, &file_info, level, password);
}
extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,

10
src/mz_os.c
View File

@ -24,20 +24,18 @@
int32_t mz_file_exists(const char *path)
{
int16_t err = MZ_OK;
void *stream = NULL;
int opened = 0;
mz_stream_os_create(&stream);
if (mz_stream_os_open(stream, path, MZ_STREAM_MODE_READ) == MZ_OK)
{
err = mz_stream_os_open(stream, path, MZ_STREAM_MODE_READ);
if (err == MZ_OK)
mz_stream_os_close(stream);
opened = 1;
}
mz_stream_os_delete(&stream);
return opened;
return err;
}
int64_t mz_file_get_size(const char *path)

120
src/mz_strm.c
View File

@ -286,123 +286,3 @@ void mz_stream_delete(void **stream)
strm->vtbl->delete(stream);
*stream = NULL;
}
/***************************************************************************/
typedef struct mz_stream_passthru_s {
mz_stream stream;
int64_t total_in;
int64_t total_out;
} mz_stream_passthru;
/***************************************************************************/
int32_t mz_stream_passthru_open(void *stream, const char *path, int32_t mode)
{
return MZ_OK;
}
int32_t mz_stream_passthru_is_open(void *stream)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
return mz_stream_is_open(passthru->stream.base);
}
int32_t mz_stream_passthru_read(void *stream, void *buf, int32_t size)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
int32_t read = mz_stream_read(passthru->stream.base, buf, size);
if (read > 0)
passthru->total_in += read;
return read;
}
int32_t mz_stream_passthru_write(void *stream, const void *buf, int32_t size)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
int32_t written = mz_stream_write(passthru->stream.base, buf, size);
if (written > 0)
passthru->total_out += written;
return written;
}
int64_t mz_stream_passthru_tell(void *stream)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
return mz_stream_tell(passthru->stream.base);
}
int32_t mz_stream_passthru_seek(void *stream, int64_t offset, int32_t origin)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
return mz_stream_seek(passthru->stream.base, offset, origin);
}
int32_t mz_stream_passthru_close(void *stream)
{
return MZ_OK;
}
int32_t mz_stream_passthru_error(void *stream)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
return mz_stream_error(passthru->stream.base);
}
int32_t mz_stream_passthru_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
return mz_stream_get_prop_int64(passthru->stream.base, prop, value);
}
int32_t mz_stream_passthru_set_prop_int64(void *stream, int32_t prop, int64_t value)
{
mz_stream_passthru *passthru = (mz_stream_passthru *)stream;
return mz_stream_set_prop_int64(passthru->stream.base, prop, value);
}
/***************************************************************************/
mz_stream_vtbl mz_stream_passthru_vtbl = {
mz_stream_passthru_open,
mz_stream_passthru_is_open,
mz_stream_passthru_read,
mz_stream_passthru_write,
mz_stream_passthru_tell,
mz_stream_passthru_seek,
mz_stream_passthru_close,
mz_stream_passthru_error,
mz_stream_passthru_create,
mz_stream_passthru_delete,
mz_stream_passthru_get_prop_int64,
mz_stream_passthru_set_prop_int64
};
/***************************************************************************/
void *mz_stream_passthru_create(void **stream)
{
mz_stream_passthru *passthru = NULL;
passthru = (mz_stream_passthru *)malloc(sizeof(mz_stream_passthru));
if (passthru != NULL)
{
memset(passthru, 0, sizeof(mz_stream_passthru));
passthru->stream.vtbl = &mz_stream_passthru_vtbl;
}
if (stream != NULL)
*stream = passthru;
return passthru;
}
void mz_stream_passthru_delete(void **stream)
{
mz_stream_passthru *passthru = NULL;
if (stream == NULL)
return;
passthru = (mz_stream_passthru *)*stream;
if (passthru != NULL)
free(passthru);
*stream = NULL;
}

6
src/mz_strm.h
View File

@ -40,9 +40,6 @@ extern "C" {
#define MZ_STREAM_PROP_DISK_SIZE (7)
#define MZ_STREAM_PROP_DISK_NUMBER (8)
#define MZ_STREAM_PROP_COMPRESS_LEVEL (9)
#define MZ_STREAM_PROP_COMPRESS_STRATEGY (10)
#define MZ_STREAM_PROP_COMPRESS_MEM_LEVEL (11)
#define MZ_STREAM_PROP_COMPRESS_WINDOW_BITS (12)
/***************************************************************************/
@ -111,9 +108,6 @@ int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_create(void **stream, mz_stream_vtbl *vtbl);
void mz_stream_delete(void **stream);
void* mz_stream_passthru_create(void **stream);
void mz_stream_passthru_delete(void **stream);
/***************************************************************************/
#ifdef __cplusplus

21
src/mz_strm_split.c
View File

@ -68,7 +68,8 @@ int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
int32_t i = 0;
int16_t err = MZ_OK;
if (number_disk >= 0)
if ((((split->disk_size > 0) && (split->mode & MZ_STREAM_MODE_WRITE)) ||
((split->mode & MZ_STREAM_MODE_WRITE) == 0)) && (number_disk >= 0))
{
for (i = strlen(split->path_disk) - 1; i >= 0; i -= 1)
{
@ -93,7 +94,7 @@ int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
if (split->mode & MZ_STREAM_MODE_WRITE)
{
if (split->current_disk == 0)
if ((split->current_disk == 0) && (split->disk_size > 0))
{
err = mz_stream_write_uint32(split->stream.base, MZ_ZIP_MAGIC_DISKHEADER);
split->total_out_disk += 4;
@ -132,7 +133,12 @@ int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk)
mz_stream_split *split = (mz_stream_split *)stream;
int16_t err = MZ_OK;
if (number_disk != split->current_disk)
if ((split->disk_size == 0) && (split->mode & MZ_STREAM_MODE_WRITE))
{
if (mz_stream_is_open(split->stream.base) != MZ_OK)
err = mz_stream_split_open_disk(stream, number_disk);
}
else if (number_disk != split->current_disk)
{
err = mz_stream_split_close_disk(stream);
if (err == MZ_OK)
@ -231,8 +237,11 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
int16_t err = MZ_OK;
uint8_t *buf_ptr = (uint8_t *)buf;
while (bytes_left > 0)
{
bytes_to_write = bytes_left;
if (split->disk_size > 0)
{
if ((split->total_out_disk == split->disk_size && split->total_out > 0) ||
(split->number_disk == -1 && split->number_disk != split->current_disk))
@ -245,14 +254,13 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
return err;
}
bytes_to_write = bytes_left;
if (split->number_disk != -1)
{
bytes_avail = (int32_t)(split->disk_size - split->total_out_disk);
if (bytes_to_write > bytes_avail)
bytes_to_write = bytes_avail;
}
}
written = mz_stream_write(split->stream.base, buf_ptr, bytes_to_write);
if (written != bytes_to_write)
@ -345,7 +353,6 @@ void *mz_stream_split_create(void **stream)
{
memset(split, 0, sizeof(mz_stream_split));
split->stream.vtbl = &mz_stream_split_vtbl;
split->disk_size = 64 * 1024;
}
if (stream != NULL)
*stream = split;

147
src/mz_strm_zlib.c
View File

@ -512,3 +512,150 @@ void *mz_stream_crc32_get_interface(void)
{
return (void *)&mz_stream_crc32_vtbl;
}
/***************************************************************************/
typedef struct mz_stream_raw_s {
mz_stream stream;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
} mz_stream_raw;
/***************************************************************************/
int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode)
{
return MZ_OK;
}
int32_t mz_stream_raw_is_open(void *stream)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_is_open(raw->stream.base);
}
int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
int32_t bytes_to_read = size;
int32_t read = 0;
if (raw->max_total_in > 0)
{
if ((raw->max_total_in - raw->total_in) < size)
bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
}
read = mz_stream_read(raw->stream.base, buf, bytes_to_read);
if (read > 0)
raw->total_in += read;
return read;
}
int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
int32_t written = mz_stream_write(raw->stream.base, buf, size);
if (written > 0)
raw->total_out += written;
return written;
}
int64_t mz_stream_raw_tell(void *stream)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_tell(raw->stream.base);
}
int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_seek(raw->stream.base, offset, origin);
}
int32_t mz_stream_raw_close(void *stream)
{
return MZ_OK;
}
int32_t mz_stream_raw_error(void *stream)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_error(raw->stream.base);
}
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
switch (prop)
{
case MZ_STREAM_PROP_TOTAL_IN:
*value = raw->total_in;
return MZ_OK;
case MZ_STREAM_PROP_TOTAL_OUT:
*value = raw->total_out;
return MZ_OK;
}
return MZ_EXIST_ERROR;
}
int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value)
{
mz_stream_raw *raw = (mz_stream_raw *)stream;
switch (prop)
{
case MZ_STREAM_PROP_TOTAL_IN_MAX:
raw->max_total_in = value;
return MZ_OK;
}
return MZ_EXIST_ERROR;
}
/***************************************************************************/
mz_stream_vtbl mz_stream_raw_vtbl = {
mz_stream_raw_open,
mz_stream_raw_is_open,
mz_stream_raw_read,
mz_stream_raw_write,
mz_stream_raw_tell,
mz_stream_raw_seek,
mz_stream_raw_close,
mz_stream_raw_error,
mz_stream_raw_create,
mz_stream_raw_delete,
mz_stream_raw_get_prop_int64,
mz_stream_raw_set_prop_int64
};
/***************************************************************************/
void *mz_stream_raw_create(void **stream)
{
mz_stream_raw *raw = NULL;
raw = (mz_stream_raw *)malloc(sizeof(mz_stream_raw));
if (raw != NULL)
{
memset(raw, 0, sizeof(mz_stream_raw));
raw->stream.vtbl = &mz_stream_raw_vtbl;
}
if (stream != NULL)
*stream = raw;
return raw;
}
void mz_stream_raw_delete(void **stream)
{
mz_stream_raw *raw = NULL;
if (stream == NULL)
return;
raw = (mz_stream_raw *)*stream;
if (raw != NULL)
free(raw);
*stream = NULL;
}

5
src/mz_strm_zlib.h
View File

@ -59,6 +59,11 @@ void* mz_stream_crc32_get_interface(void);
/***************************************************************************/
void* mz_stream_raw_create(void **stream);
void mz_stream_raw_delete(void **stream);
/***************************************************************************/
#ifdef __cplusplus
}
#endif

167
src/mz_zip.c
View File

@ -62,7 +62,6 @@ typedef struct mz_zip_s
mz_zip_global global_info;
mz_zip_file file_info;
mz_zip_file local_file_info;
mz_zip_compress compress_info;
void *stream; // main stream
void *cd_stream; // memory stream for central directory
@ -70,13 +69,9 @@ typedef struct mz_zip_s
void *crc32_stream; // crc32 stream
void *crypt_stream; // encryption stream
void *file_info_stream; // memory stream for storing file info
void *local_file_info_stream; // memory stream for storing file info
int32_t open_mode;
uint32_t number_disk; // number of the current disk, used for spanning ZIP
uint32_t number_disk_with_CD; // number the the disk with central dir, used for spanning ZIP
uint64_t disk_offset; // byte before the zip file, (>0 for sfx)
uint64_t cd_current_pos; // pos of the current file in the central dir
@ -196,7 +191,7 @@ static int32_t mz_zip_search_zip64_cd(void *stream, const uint64_t end_central_o
return err;
}
int mz_zip_read_cd(void *handle)
static int mz_zip_read_cd(void *handle)
{
mz_zip *zip = NULL;
uint64_t number_entry_cd = 0;
@ -225,7 +220,6 @@ int mz_zip_read_cd(void *handle)
// Number of this disk
if (err == MZ_OK)
err = mz_stream_read_uint16(zip->stream, &value16);
zip->number_disk = value16;
// Number of the disk with the start of the central directory
if (err == MZ_OK)
err = mz_stream_read_uint16(zip->stream, &value16);
@ -275,7 +269,7 @@ int mz_zip_read_cd(void *handle)
err = mz_stream_read_uint16(zip->stream, &value16);
// Number of this disk
if (err == MZ_OK)
err = mz_stream_read_uint32(zip->stream, &zip->number_disk);
err = mz_stream_read_uint32(zip->stream, &value32);
// Number of the disk with the start of the central directory
if (err == MZ_OK)
err = mz_stream_read_uint32(zip->stream, &zip->global_info.number_disk_with_cd);
@ -330,7 +324,7 @@ int mz_zip_read_cd(void *handle)
return err;
}
int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_madeby)
static int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_madeby)
{
mz_zip *zip = NULL;
uint16_t comment_size = 0;
@ -338,6 +332,7 @@ int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_m
uint64_t pos = 0;
uint64_t cd_pos = 0;
int64_t disk_number = 0;
int64_t disk_size = 0;
int16_t err = MZ_OK;
@ -349,7 +344,9 @@ int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_m
global_comment = zip->global_info.comment;
if (mz_stream_get_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, &disk_number) == MZ_OK)
zip->number_disk_with_CD = (uint32_t)disk_number + 1;
zip->global_info.number_disk_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)
zip->global_info.number_disk_with_cd += 1;
mz_stream_set_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, -1);
zip->cd_pos = mz_stream_tell(zip->stream);
@ -380,10 +377,10 @@ int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_m
err = mz_stream_write_uint16(zip->stream, (uint16_t)45);
// Number of this disk
if (err == MZ_OK)
err = mz_stream_write_uint32(zip->stream, zip->number_disk_with_CD);
err = mz_stream_write_uint32(zip->stream, zip->global_info.number_disk_with_cd);
// Number of the disk with the start of the central directory
if (err == MZ_OK)
err = mz_stream_write_uint32(zip->stream, zip->number_disk_with_CD);
err = mz_stream_write_uint32(zip->stream, zip->global_info.number_disk_with_cd);
// Total number of entries in the central dir on this disk
if (err == MZ_OK)
err = mz_stream_write_uint64(zip->stream, zip->global_info.number_entry);
@ -403,7 +400,7 @@ int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_m
err = mz_stream_write_uint32(zip->stream, MZ_ZIP_MAGIC_ENDLOCHEADER64);
// Number of the disk with the start of the central directory
if (err == MZ_OK)
err = mz_stream_write_uint32(zip->stream, zip->number_disk_with_CD);
err = mz_stream_write_uint32(zip->stream, zip->global_info.number_disk_with_cd);
// Relative offset to the end of zip64 central directory
if (err == MZ_OK)
{
@ -412,7 +409,7 @@ int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_m
}
// Number of the disk with the start of the central directory
if (err == MZ_OK)
err = mz_stream_write_uint32(zip->stream, zip->number_disk_with_CD + 1);
err = mz_stream_write_uint32(zip->stream, zip->global_info.number_disk_with_cd);
}
// Write the central directory header
@ -422,10 +419,10 @@ int mz_zip_write_cd(void *handle, const char *global_comment, uint16_t version_m
err = mz_stream_write_uint32(zip->stream, MZ_ZIP_MAGIC_ENDHEADER);
// Number of this disk
if (err == MZ_OK)
err = mz_stream_write_uint16(zip->stream, (uint16_t)zip->number_disk_with_CD);
err = mz_stream_write_uint16(zip->stream, (uint16_t)zip->global_info.number_disk_with_cd);
// Number of the disk with the start of the central directory
if (err == MZ_OK)
err = mz_stream_write_uint16(zip->stream, (uint16_t)zip->number_disk_with_CD);
err = mz_stream_write_uint16(zip->stream, (uint16_t)zip->global_info.number_disk_with_cd);
// Total number of entries in the central dir on this disk
if (err == MZ_OK)
{
@ -515,21 +512,10 @@ extern void* ZEXPORT mz_zip_open(void *stream, int32_t mode)
err = mz_stream_mem_open(zip->file_info_stream, NULL, MZ_STREAM_MODE_CREATE);
}
if (err == MZ_OK)
{
mz_stream_mem_create(&zip->local_file_info_stream);
mz_stream_mem_set_grow(zip->local_file_info_stream, 1);
mz_stream_mem_set_grow_size(zip->local_file_info_stream, 4096);
err = mz_stream_mem_open(zip->local_file_info_stream, NULL, MZ_STREAM_MODE_CREATE);
}
if (err != MZ_OK)
{
if (zip->file_info_stream != NULL)
mz_stream_mem_delete(&zip->file_info_stream);
if (zip->local_file_info_stream != NULL)
mz_stream_mem_delete(&zip->local_file_info_stream);
mz_stream_close(zip->cd_stream);
mz_stream_delete(&zip->cd_stream);
@ -567,9 +553,6 @@ extern int ZEXPORT mz_zip_close(void *handle, const char *global_comment, uint16
mz_stream_mem_close(zip->file_info_stream);
mz_stream_mem_delete(&zip->file_info_stream);
mz_stream_mem_close(zip->local_file_info_stream);
mz_stream_mem_delete(&zip->local_file_info_stream);
if (zip->global_info.comment)
free(zip->global_info.comment);
@ -581,7 +564,6 @@ extern int ZEXPORT mz_zip_close(void *handle, const char *global_comment, uint16
extern int ZEXPORT mz_zip_get_global_info(void *handle, mz_zip_global **global_info)
{
mz_zip *zip = NULL;
if (handle == NULL || global_info == NULL)
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
@ -681,7 +663,7 @@ static int mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file *fi
}
}
if (err == MZ_OK)
if ((err == MZ_OK) && (!local))
err = mz_stream_seek(file_info_stream, 0, MZ_STREAM_SEEK_SET);
if ((err == MZ_OK) && (file_info->filename_size > 0))
@ -813,9 +795,7 @@ static int mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_file *f
file_info->version_needed = mz_zip_entry_get_version_needed(file_info);
if (local)
{
err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_LOCALHEADER);
}
else
{
err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_CENTRALHEADER);
@ -930,13 +910,12 @@ static int mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_file *f
{
if (mz_stream_write(stream, file_info->comment, file_info->comment_size) != MZ_OK)
err = MZ_STREAM_ERROR;
free(file_info->comment);
}
return err;
}
static int mz_zip_entry_open_int(void *handle, const char *password)
static int mz_zip_entry_open_int(void *handle, int16_t compress_level, const char *password)
{
mz_zip *zip = NULL;
uint64_t extrafield_local_offset = 0;
@ -951,25 +930,25 @@ static int mz_zip_entry_open_int(void *handle, const char *password)
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
if ((zip->file_info.compression_method != MZ_COMPRESS_METHOD_RAW) &&
(zip->file_info.compression_method != MZ_COMPRESS_METHOD_DEFLATE))
switch (zip->file_info.compression_method)
{
case MZ_COMPRESS_METHOD_RAW:
case MZ_COMPRESS_METHOD_DEFLATE:
#ifdef HAVE_BZIP2
if (zip->file_info.compression_method != MZ_COMPRESS_METHOD_BZIP2)
return MZ_INTERNAL_ERROR;
#elif HAVE_LZMA
if (unzip->file_info.compression_method != MZ_METHOD_LZMA)
return MZ_INTERNAL_ERROR;
#else
return MZ_INTERNAL_ERROR;
case MZ_COMPRESS_METHOD_BZIP2:
#endif
#if HAVE_LZMA
case MZ_COMPRESS_METHOD_LZMA:
#endif
err = MZ_OK;
break;
default:
return MZ_PARAM_ERROR;
}
if ((zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (password == NULL))
return MZ_PARAM_ERROR;
max_total_in = zip->file_info.compressed_size;
if ((err == Z_OK) && (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED))
{
#ifdef HAVE_AES
@ -978,9 +957,6 @@ static int mz_zip_entry_open_int(void *handle, const char *password)
mz_stream_aes_create(&zip->crypt_stream);
mz_stream_aes_set_password(zip->crypt_stream, password);
mz_stream_aes_set_encryption_mode(zip->crypt_stream, zip->file_info.aes_encryption_mode);
if (mz_stream_get_prop_int64(zip->crypt_stream, MZ_STREAM_PROP_FOOTER_SIZE, &footer_size) == MZ_OK)
max_total_in -= footer_size;
}
else
#endif
@ -1005,31 +981,18 @@ static int mz_zip_entry_open_int(void *handle, const char *password)
if (err == MZ_OK)
{
if (zip->crypt_stream == NULL)
{
mz_stream_passthru_create(&zip->crypt_stream);
mz_stream_set_base(zip->crypt_stream, zip->stream);
}
else
{
mz_stream_raw_create(&zip->crypt_stream);
mz_stream_set_base(zip->crypt_stream, zip->stream);
err = mz_stream_open(zip->crypt_stream, NULL, zip->open_mode);
}
if (mz_stream_get_prop_int64(zip->crypt_stream, MZ_STREAM_PROP_TOTAL_IN, &total_in) == MZ_OK)
max_total_in -= total_in;
}
if (err == MZ_OK)
{
if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_RAW)
{
mz_stream_passthru_create(&zip->compress_stream);
mz_stream_set_base(zip->compress_stream, zip->crypt_stream);
}
else
{
if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_DEFLATE)
mz_stream_raw_create(&zip->compress_stream);
else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_DEFLATE)
mz_stream_zlib_create(&zip->compress_stream);
#ifdef HAVE_BZIP2
else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_BZIP2)
@ -1041,29 +1004,31 @@ static int mz_zip_entry_open_int(void *handle, const char *password)
#endif
else
err = MZ_PARAM_ERROR;
}
if (err == MZ_OK)
{
if (zip->open_mode & MZ_STREAM_MODE_WRITE)
{
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_LEVEL, zip->compress_info.level);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_WINDOW_BITS, zip->compress_info.window_bits);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_MEM_LEVEL, zip->compress_info.mem_level);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_STRATEGY, zip->compress_info.strategy);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_LEVEL, compress_level);
}
else
{
if (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)
if (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED || zip->file_info.compression_method == MZ_COMPRESS_METHOD_RAW)
{
max_total_in = zip->file_info.compressed_size;
if (mz_stream_get_prop_int64(zip->crypt_stream, MZ_STREAM_PROP_FOOTER_SIZE, &footer_size) == MZ_OK)
max_total_in -= footer_size;
if (mz_stream_get_prop_int64(zip->crypt_stream, MZ_STREAM_PROP_TOTAL_IN, &total_in) == MZ_OK)
max_total_in -= total_in;
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX, max_total_in);
}
}
mz_stream_set_base(zip->compress_stream, zip->crypt_stream);
err = mz_stream_open(zip->compress_stream, NULL, zip->open_mode);
}
}
}
if (err == Z_OK)
{
mz_stream_crc32_create(&zip->crc32_stream);
@ -1100,6 +1065,8 @@ extern int ZEXPORT mz_zip_entry_read_open(void *handle, int raw, const char *pas
zip = (mz_zip *)handle;
if ((zip->open_mode & MZ_STREAM_MODE_READ) == 0)
return MZ_PARAM_ERROR;
if (zip->entry_scanned == 0)
return MZ_PARAM_ERROR;
if ((zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) && (password == NULL))
@ -1112,15 +1079,15 @@ extern int ZEXPORT mz_zip_entry_read_open(void *handle, int raw, const char *pas
err = mz_stream_seek(zip->stream, zip->disk_offset + zip->file_info.disk_offset, MZ_STREAM_SEEK_SET);
if (err == MZ_OK)
err = mz_zip_entry_read_header(zip->stream, 1, &zip->local_file_info, zip->local_file_info_stream);
err = mz_zip_entry_read_header(zip->stream, 1, &zip->local_file_info, zip->file_info_stream);
if (err == MZ_OK)
err = mz_zip_entry_open_int(handle, password);
err = mz_zip_entry_open_int(handle, 0, password);
return err;
}
extern int ZEXPORT mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info,
const mz_zip_compress *compress_info, const mz_zip_crypt *crypt_info)
int16_t compress_level, const char *password)
{
mz_zip *zip = NULL;
int64_t disk_number = 0;
@ -1134,13 +1101,11 @@ extern int ZEXPORT mz_zip_entry_write_open(void *handle, const mz_zip_file *file
return MZ_PARAM_ERROR;
if (file_info == NULL || file_info->filename == NULL)
return MZ_PARAM_ERROR;
if (compress_info == NULL)
return MZ_PARAM_ERROR;
if (crypt_info == NULL)
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
if ((zip->open_mode & MZ_STREAM_MODE_WRITE) == 0)
return MZ_PARAM_ERROR;
if (zip->entry_opened == 1)
{
err = mz_zip_entry_close(handle);
@ -1149,20 +1114,19 @@ extern int ZEXPORT mz_zip_entry_write_open(void *handle, const mz_zip_file *file
}
memcpy(&zip->file_info, file_info, sizeof(mz_zip_file));
memcpy(&zip->compress_info, compress_info, sizeof(mz_zip_compress));
zip->file_info.flag |= MZ_ZIP_FLAG_DATA_DESCRIPTOR;
#ifdef HAVE_LZMA
zip->file_info.flag |= MZ_ZIP_FLAG_LZMA_EOS_MARKER;
#endif
if ((zip->compress_info.level == 8) || (zip->compress_info.level == 9))
if ((compress_level == 8) || (compress_level == 9))
zip->file_info.flag |= MZ_ZIP_FLAG_DEFLATE_MAX;
if (zip->compress_info.level == 2)
if (compress_level == 2)
zip->file_info.flag |= MZ_ZIP_FLAG_DEFLATE_FAST;
if (zip->compress_info.level == 1)
if (compress_level == 1)
zip->file_info.flag |= MZ_ZIP_FLAG_DEFLATE_SUPER_FAST;
if (crypt_info->password != NULL)
if (password != NULL)
zip->file_info.flag |= MZ_ZIP_FLAG_ENCRYPTED;
else
zip->file_info.flag &= ~MZ_ZIP_FLAG_ENCRYPTED;
@ -1171,11 +1135,11 @@ extern int ZEXPORT mz_zip_entry_write_open(void *handle, const mz_zip_file *file
zip->file_info.disk_num_start = (uint32_t)disk_number;
zip->file_info.disk_offset = mz_stream_tell(zip->stream);
zip->file_info.crc = 0;
zip->file_info.compressed_size = 0;
zip->file_info.uncompressed_size = 0;
zip->file_info.compression_method = compress_info->method;
#ifdef HAVE_AES
if (crypt_info->aes)
if (file_info->aes_version)
{
zip->file_info.aes_version = MZ_AES_VERSION;
zip->file_info.aes_encryption_mode = MZ_AES_ENCRYPTIONMODE;
@ -1185,7 +1149,7 @@ extern int ZEXPORT mz_zip_entry_write_open(void *handle, const mz_zip_file *file
if (err == MZ_OK)
err = mz_zip_entry_write_header(zip->stream, 1, &zip->file_info);
if (err == MZ_OK)
err = mz_zip_entry_open_int(handle, crypt_info->password);
err = mz_zip_entry_open_int(handle, compress_level, password);
return err;
}
@ -1199,7 +1163,6 @@ extern int ZEXPORT mz_zip_entry_read(void *handle, void *buf, uint32_t len)
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
if (zip->entry_opened == 0)
return MZ_PARAM_ERROR;
@ -1209,10 +1172,8 @@ extern int ZEXPORT mz_zip_entry_read(void *handle, void *buf, uint32_t len)
return MZ_PARAM_ERROR;
read = mz_stream_read(zip->crc32_stream, buf, len);
if (read > 0)
zip->entry_read += read;
return read;
}
@ -1224,10 +1185,8 @@ extern int ZEXPORT mz_zip_entry_write(void *handle, const void *buf, uint32_t le
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
if (zip->entry_opened == 0)
return MZ_PARAM_ERROR;
return mz_stream_write(zip->crc32_stream, buf, len);
}
@ -1251,6 +1210,7 @@ extern int ZEXPORT mz_zip_entry_close_raw(void *handle, uint64_t uncompressed_si
return MZ_PARAM_ERROR;
mz_stream_close(zip->compress_stream);
if (crc32 == 0)
crc32 = mz_stream_crc32_get_value(zip->crc32_stream);
if ((zip->open_mode & MZ_STREAM_MODE_WRITE) == 0)
@ -1267,22 +1227,16 @@ extern int ZEXPORT mz_zip_entry_close_raw(void *handle, uint64_t uncompressed_si
}
}
}
else
{
if ((zip->compress_info.method != MZ_COMPRESS_METHOD_RAW) || (uncompressed_size == 0))
{
mz_stream_get_prop_int64(zip->crc32_stream, MZ_STREAM_PROP_TOTAL_OUT, (int64_t *)&uncompressed_size);
mz_stream_get_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_OUT, (int64_t *)&compressed_size);
}
}
if ((zip->file_info.compression_method != MZ_COMPRESS_METHOD_RAW) || (uncompressed_size == 0))
mz_stream_get_prop_int64(zip->crc32_stream, MZ_STREAM_PROP_TOTAL_OUT, (int64_t *)&uncompressed_size);
if (zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)
{
mz_stream_set_base(zip->crypt_stream, zip->stream);
err = mz_stream_close(zip->crypt_stream);
if ((zip->compress_info.method != MZ_COMPRESS_METHOD_RAW) || (uncompressed_size == 0))
mz_stream_get_prop_int64(zip->crypt_stream, MZ_STREAM_PROP_TOTAL_OUT, (int64_t *)&compressed_size);
}
@ -1342,10 +1296,8 @@ extern int ZEXPORT mz_zip_entry_get_info(void *handle, mz_zip_file **file_info)
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
if (zip->entry_scanned == 0)
return MZ_PARAM_ERROR;
*file_info = &zip->file_info;
return MZ_OK;
}
@ -1358,10 +1310,8 @@ extern int ZEXPORT mz_zip_entry_get_local_info(void *handle, mz_zip_file **local
return MZ_PARAM_ERROR;
zip = (mz_zip *)handle;
if (zip->entry_scanned == 0 || zip->entry_opened == 0)
return MZ_PARAM_ERROR;
*local_file_info = &zip->local_file_info;
return MZ_OK;
}
@ -1426,7 +1376,6 @@ extern int ZEXPORT mz_zip_locate_entry(void *handle, const char *filename, mz_fi
zip = (mz_zip *)handle;
err = mz_zip_goto_first_entry(handle);
while (err == MZ_OK)
{
if (filename_compare_cb != NULL)

45
src/mz_zip.h
View File

@ -57,9 +57,9 @@ typedef struct mz_zip_file_s
uint64_t disk_offset; // relative offset of local header 8 bytes
char *filename; // filename string
uint8_t *extrafield; // extrafield data
char *comment; // comment string
const char *filename; // filename string
const uint8_t *extrafield; // extrafield data
const char *comment; // comment string
uint8_t zip_64; // zip 64 extensions if 1
@ -69,23 +69,6 @@ typedef struct mz_zip_file_s
#endif
} mz_zip_file;
typedef struct mz_zip_compress_s
{
uint16_t method; // compression method
int level; // compression level
int window_bits; // deflate window bits
int mem_level; // deflate memory level
int strategy; // deflate strategy
} mz_zip_compress;
typedef struct mz_zip_crypt_s
{
const char *password; // encryption password
#if defined(HAVE_AES)
uint8_t aes; // winzip aes encryption if 1
#endif
} mz_zip_crypt;
/***************************************************************************/
extern void* ZEXPORT mz_zip_open(void *stream, int32_t mode);
@ -98,18 +81,8 @@ extern void* ZEXPORT mz_zip_open(void *stream, int32_t mode);
extern int ZEXPORT mz_zip_get_global_info(void *handle, mz_zip_global **global_info);
// Gets the global zip file info
extern int ZEXPORT mz_zip_entry_get_info(void *handle, mz_zip_file **file_info);
// Get info about the current file
//
// NOTE: The file info is only valid while the current entry is open
extern int ZEXPORT mz_zip_entry_get_local_info(void *handle, mz_zip_file **local_file_info);
// Get local info about the current file
//
// NOTE: The local file info is only valid while the current entry is being read
extern int ZEXPORT mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info,
const mz_zip_compress *compress_info, const mz_zip_crypt *crypt_info);
int16_t compress_level, const char *password);
// Open a file in the zip for writing
extern int ZEXPORT mz_zip_entry_write(void *handle, const void *buf, uint32_t len);
@ -124,6 +97,16 @@ extern int ZEXPORT mz_zip_entry_read(void *handle, void *buf, uint32_t len);
extern int ZEXPORT mz_zip_entry_close(void *handle);
// Close the current file in the zip file
extern int ZEXPORT mz_zip_entry_get_info(void *handle, mz_zip_file **file_info);
// Get info about the current file
//
// NOTE: The file info is only valid while the current entry is open
extern int ZEXPORT mz_zip_entry_get_local_info(void *handle, mz_zip_file **local_file_info);
// Get local info about the current file
//
// NOTE: The local file info is only valid while the current entry is being read
extern int ZEXPORT mz_zip_entry_close_raw(void *handle, uint64_t uncompressed_size, uint32_t crc32);
// Close the current file in the zip file where raw is compressed data

BIN
test/empty.zip Normal file
View File

Binary file not shown.

99
test/test.py
View File

@ -53,7 +53,7 @@ def erase_files(search_pattern):
def erase_dir(path):
if not os.path.exists(path):
return
print 'Erasing dir {0}'.format(path)
print('Erasing dir {0}'.format(path))
# shutil.rmtree doesn't work well and sometimes can't delete
for root, dirs, files in os.walk(path, topdown=False):
for name in files:
@ -107,7 +107,31 @@ def create_random_file(path, size):
size -= len(buf)
i += 1
def zip_unzip_test(zip_file, dest_dir, zip_args, unzip_args, files):
def zip(zip_file, zip_args, files):
cmd = '{0} {1} {2} {3}'.format(get_exec('minizip'), zip_args, zip_file, ' '.join(files))
print cmd
err = os.system(cmd)
if (err != 0):
print('Zip returned error code {0}'.format(err))
sys.exit(err)
def list(zip_file):
cmd = '{0} -l {1}'.format(get_exec('minizip'), zip_file)
print cmd
err = os.system(cmd)
if (err != 0):
print('List returned error code {0}'.format(err))
sys.exit(err)
def unzip(zip_file, dest_dir, unzip_args = ''):
cmd = '{0} -x {1} -d {2} {3}'.format(get_exec('minizip'), unzip_args, dest_dir, zip_file)
print cmd
err = os.system(cmd)
if (err != 0):
print('Unzip returned error code {0}'.format(err))
sys.exit(err)
def zip_list_unzip(zip_file, dest_dir, zip_args, unzip_args, files):
# Single test run
original_infos = {}
for (i, path) in enumerate(files):
@ -117,25 +141,9 @@ def zip_unzip_test(zip_file, dest_dir, zip_args, unzip_args, files):
erase_files(zip_file[0:-2] + "*")
erase_dir(dest_dir)
cmd = '{0} {1} {2} {3}'.format(get_exec('minizip'), zip_args, zip_file, ' '.join(files))
print cmd
err = os.system(cmd)
if (err != 0):
print('Zip returned error code {0}'.format(err))
sys.exit(err)
cmd = '{0} -l {1}'.format(get_exec('miniunz'), zip_file)
print cmd
err = os.system(cmd)
if (err != 0):
print('List returned error code {0}'.format(err))
sys.exit(err)
cmd = '{0} -x {1} {2} -d {3}'.format(get_exec('miniunz'), zip_file, unzip_args, dest_dir)
print cmd
err = os.system(cmd)
if (err != 0):
print('Unzip returned error code {0}'.format(err))
sys.exit(err)
zip(zip_file, zip_args, files)
list(zip_file)
unzip(zip_file, dest_dir, unzip_args)
new_infos = {}
for (i, path) in enumerate(files):
@ -148,34 +156,39 @@ def zip_unzip_test(zip_file, dest_dir, zip_args, unzip_args, files):
print('New: ')
print(new_infos)
def test_level_0(method, zip_arg = '', unzip_arg = ''):
# File tests
print 'Testing {0} on Single File'.format(method)
zip_unzip_test('test.zip', 'out', zip_arg, unzip_arg, ['test.c'])
print 'Testing {0} on Two Files'.format(method)
zip_unzip_test('test.zip', 'out', zip_arg, unzip_arg, ['test.c', 'test.h'])
print 'Testing {0} Directory'.format(method)
zip_unzip_test('test.zip', 'out', zip_arg, unzip_arg, ['repo'])
print 'Testing {0} 1MB file'.format(method)
def file_tests(method, zip_arg = '', unzip_arg = ''):
print('Testing {0} on Single File'.format(method))
zip_list_unzip('test.zip', 'out', zip_arg, unzip_arg, ['test.c'])
print('Testing {0} on Two Files'.format(method))
zip_list_unzip('test.zip', 'out', zip_arg, unzip_arg, ['test.c', 'test.h'])
print('Testing {0} Directory'.format(method))
zip_list_unzip('test.zip', 'out', zip_arg, unzip_arg, ['repo'])
print('Testing {0} 1MB file'.format(method))
create_random_file('1MB.dat', 1 * 1024 * 1024)
zip_unzip_test('test.zip', 'out', zip_arg, unzip_arg, ['1MB.dat'])
print 'Testing {0} 50MB file'.format(method)
zip_list_unzip('test.zip', 'out', zip_arg, unzip_arg, ['1MB.dat'])
print('Testing {0} 50MB file'.format(method))
create_random_file('50MB.dat', 50 * 1024 * 1024)
zip_unzip_test('test.zip', 'out', zip_arg, unzip_arg, ['50MB.dat'])
zip_list_unzip('test.zip', 'out', zip_arg, unzip_arg, ['50MB.dat'])
def test_level_1(method = '', zip_arg = '', unzip_arg = ''):
# Compression method tests
def compression_method_tests(method = '', zip_arg = '', unzip_arg = ''):
method = method + ' ' if method != '' else ''
test_level_0(method + 'Deflate', zip_arg, unzip_arg)
test_level_0(method + 'Raw', '-0 ' + zip_arg, unzip_arg)
test_level_0(method + 'BZIP2', '-b ' + zip_arg, unzip_arg)
test_level_0(method + 'LZMA', '-l ' + zip_arg, unzip_arg)
file_tests(method + 'Deflate', zip_arg, unzip_arg)
file_tests(method + 'Raw', '-0 ' + zip_arg, unzip_arg)
file_tests(method + 'BZIP2', '-b ' + zip_arg, unzip_arg)
file_tests(method + 'LZMA', '-m ' + zip_arg, unzip_arg)
def encryption_tests():
compression_method_tests('Crypt', '-p 1234567890', '-p 1234567890')
compression_method_tests('AES', '-s -p 1234567890', '-p 1234567890')
def empty_zip_test():
unzip('empty.zip', 'out')
if not os.path.exists('repo'):
os.system('git clone https://github.com/nmoinvaz/minizip repo')
# Run tests
test_level_1()
test_level_1('Disk Span', '-k 1024', '')
test_level_1('Crypt', '-p 1234567890', '-p 1234567890')
test_level_1('AES', '-s -p 1234567890', '-p 1234567890')
empty_zip_test()
compression_method_tests()
encryption_tests()
compression_method_tests('Disk Span', '-k 1024', '')