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

Clang-format style changes.

Browse Source
This commit is contained in:
Nathan Moinvaziri 2024-11-01 16:30:39 -07:00
parent 483950d09d
commit 2c51fa719e
47 changed files with 1236 additions and 1392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compat/crypt.h
View File

@ -62,7 +62,6 @@ static int update_keys(unsigned long* pkeys, const z_crc_t* pcrc_32_tab, int c)
return c; return c;
} }
/***************************************************************************/ /***************************************************************************/
/* Initialize the encryption keys and the random header according to the password. */ /* Initialize the encryption keys and the random header according to the password. */
@ -76,8 +75,7 @@ static void init_keys(const char* passwd, unsigned long* pkeys, const z_crc_t* p
} }
} }
#define zdecode(pkeys,pcrc_32_tab,c) \ #define zdecode(pkeys, pcrc_32_tab, c) (update_keys(pkeys, pcrc_32_tab, c ^= decrypt_byte(pkeys, pcrc_32_tab)))
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
#define zencode(pkeys, pcrc_32_tab, c, t) \ #define zencode(pkeys, pcrc_32_tab, c, t) \
(t = decrypt_byte(pkeys, pcrc_32_tab), update_keys(pkeys, pcrc_32_tab, c), (Byte)t ^ (c)) (t = decrypt_byte(pkeys, pcrc_32_tab), update_keys(pkeys, pcrc_32_tab, c), (Byte)t ^ (c))

6
compat/ioapi.c
View File

@ -24,8 +24,7 @@ static int32_t mz_stream_ioapi_error(void *stream);
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_ioapi_vtbl = { static mz_stream_vtbl mz_stream_ioapi_vtbl = {mz_stream_ioapi_open,
mz_stream_ioapi_open,
mz_stream_ioapi_is_open, mz_stream_ioapi_is_open,
mz_stream_ioapi_read, mz_stream_ioapi_read,
mz_stream_ioapi_write, mz_stream_ioapi_write,
@ -36,8 +35,7 @@ static mz_stream_vtbl mz_stream_ioapi_vtbl = {
mz_stream_ioapi_create, mz_stream_ioapi_create,
mz_stream_ioapi_delete, mz_stream_ioapi_delete,
NULL, NULL,
NULL NULL};
};
/***************************************************************************/ /***************************************************************************/

9
compat/ioapi.h
View File

@ -40,8 +40,7 @@ extern "C" {
typedef void *(ZCALLBACK *open_file_func)(void *opaque, const char *filename, int mode); typedef void *(ZCALLBACK *open_file_func)(void *opaque, const char *filename, int mode);
typedef void *(ZCALLBACK *open64_file_func)(void *opaque, const void *filename, int mode); typedef void *(ZCALLBACK *open64_file_func)(void *opaque, const void *filename, int mode);
typedef unsigned long(ZCALLBACK *read_file_func)(void *opaque, void *stream, void *buf, unsigned long size); typedef unsigned long(ZCALLBACK *read_file_func)(void *opaque, void *stream, void *buf, unsigned long size);
typedef unsigned long (ZCALLBACK *write_file_func) (void *opaque, void *stream, const void* buf, typedef unsigned long(ZCALLBACK *write_file_func)(void *opaque, void *stream, const void *buf, unsigned long size);
unsigned long size);
typedef int(ZCALLBACK *close_file_func)(void *opaque, void *stream); typedef int(ZCALLBACK *close_file_func)(void *opaque, void *stream);
typedef int(ZCALLBACK *testerror_file_func)(void *opaque, void *stream); typedef int(ZCALLBACK *testerror_file_func)(void *opaque, void *stream);
typedef long(ZCALLBACK *tell_file_func)(void *opaque, void *stream); typedef long(ZCALLBACK *tell_file_func)(void *opaque, void *stream);
@ -51,8 +50,7 @@ typedef long (ZCALLBACK *seek64_file_func) (void *opaque, void *strea
/***************************************************************************/ /***************************************************************************/
typedef struct zlib_filefunc_def_s typedef struct zlib_filefunc_def_s {
{
open_file_func zopen_file; open_file_func zopen_file;
read_file_func zread_file; read_file_func zread_file;
write_file_func zwrite_file; write_file_func zwrite_file;
@ -63,8 +61,7 @@ typedef struct zlib_filefunc_def_s
void *opaque; void *opaque;
} zlib_filefunc_def; } zlib_filefunc_def;
typedef struct zlib_filefunc64_def_s typedef struct zlib_filefunc64_def_s {
{
open64_file_func zopen64_file; open64_file_func zopen64_file;
read_file_func zread_file; read_file_func zread_file;
write_file_func zwrite_file; write_file_func zwrite_file;

14
compat/unzip.c
View File

@ -330,9 +330,8 @@ static void unzConvertTimeToUnzTime(time_t time, tm_unz *tmu_date) {
tmu_date->tm_year += 1900; tmu_date->tm_year += 1900;
} }
int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, unsigned long filename_size,
unsigned long filename_size, void *extrafield, unsigned long extrafield_size, char *comment, void *extrafield, unsigned long extrafield_size, char *comment, unsigned long comment_size) {
unsigned long comment_size) {
mz_unzip_compat *compat = (mz_unzip_compat *)file; mz_unzip_compat *compat = (mz_unzip_compat *)file;
mz_zip_file *file_info = NULL; mz_zip_file *file_info = NULL;
uint16_t bytes_to_copy = 0; uint16_t bytes_to_copy = 0;
@ -390,8 +389,8 @@ int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filenam
return err; return err;
} }
int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename, int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename, unsigned long filename_size,
unsigned long filename_size, void *extrafield, unsigned long extrafield_size, char *comment, void *extrafield, unsigned long extrafield_size, char *comment,
unsigned long comment_size) { unsigned long comment_size) {
mz_unzip_compat *compat = (mz_unzip_compat *)file; mz_unzip_compat *compat = (mz_unzip_compat *)file;
mz_zip_file *file_info = NULL; mz_zip_file *file_info = NULL;
@ -514,7 +513,7 @@ int unzLocateFile(unzFile file, const char *filename, unzFileNameCase filename_c
} }
#else #else
int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func) { int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func) {
mz_compat* compat = (mz_compat*)file; mz_unzip_compat *compat = (mz_unzip_compat *)file;
mz_zip_file *file_info = NULL; mz_zip_file *file_info = NULL;
uint64_t preserve_index = 0; uint64_t preserve_index = 0;
int32_t err = MZ_OK; int32_t err = MZ_OK;
@ -533,8 +532,7 @@ int unzLocateFile(unzFile file, const char* filename, unzFileNameComparer filena
if ((intptr_t)filename_compare_func > 2) { if ((intptr_t)filename_compare_func > 2) {
result = filename_compare_func(file, filename, file_info->filename); result = filename_compare_func(file, filename, file_info->filename);
} } else {
else {
int32_t case_sensitive = (int32_t)(intptr_t)filename_compare_func; int32_t case_sensitive = (int32_t)(intptr_t)filename_compare_func;
result = mz_path_compare_wc(filename, file_info->filename, !case_sensitive); result = mz_path_compare_wc(filename, file_info->filename, !case_sensitive);
} }

23
compat/unzip.h
View File

@ -28,7 +28,9 @@ extern "C" {
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted /* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */ from (void*) without cast */
typedef struct TagunzFile__ { int unused; } unzFile__; typedef struct TagunzFile__ {
int unused;
} unzFile__;
typedef unzFile__ *unzFile; typedef unzFile__ *unzFile;
#else #else
typedef void *unzFile; typedef void *unzFile;
@ -60,8 +62,7 @@ typedef void *unzFile;
/***************************************************************************/ /***************************************************************************/
/* tm_unz contain date/time info */ /* tm_unz contain date/time info */
typedef struct tm_unz_s typedef struct tm_unz_s {
{
int tm_sec; /* seconds after the minute - [0,59] */ int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */ int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */ int tm_hour; /* hours since midnight - [0,23] */
@ -148,9 +149,8 @@ typedef int unzFileNameCase;
typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2); typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);
#endif #endif
typedef int (*unzIteratorFunction)(unzFile file); typedef int (*unzIteratorFunction)(unzFile file);
typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename, typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename, uint16_t filename_size,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
uint16_t comment_size);
/***************************************************************************/ /***************************************************************************/
/* Reading a zip file */ /* Reading a zip file */
@ -171,12 +171,12 @@ ZEXPORT int unzOpenCurrentFile2(unzFile file, int *method, int *level, int r
ZEXPORT int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password); ZEXPORT int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password);
ZEXPORT int unzReadCurrentFile(unzFile file, void *buf, uint32_t len); ZEXPORT int unzReadCurrentFile(unzFile file, void *buf, uint32_t len);
ZEXPORT int unzCloseCurrentFile(unzFile file); ZEXPORT int unzCloseCurrentFile(unzFile file);
ZEXPORT int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, ZEXPORT int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, unsigned long filename_size,
unsigned long filename_size, void *extrafield, unsigned long extrafield_size, char *comment, void *extrafield, unsigned long extrafield_size, char *comment,
unsigned long comment_size); unsigned long comment_size);
ZEXPORT int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename, ZEXPORT int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename,
unsigned long filename_size, void *extrafield, unsigned long extrafield_size, char *comment, unsigned long filename_size, void *extrafield, unsigned long extrafield_size,
unsigned long comment_size); char *comment, unsigned long comment_size);
ZEXPORT int unzGoToFirstFile(unzFile file); ZEXPORT int unzGoToFirstFile(unzFile file);
ZEXPORT int unzGoToNextFile(unzFile file); ZEXPORT int unzGoToNextFile(unzFile file);
#if !defined(MZ_COMPAT_VERSION) || MZ_COMPAT_VERSION < 110 #if !defined(MZ_COMPAT_VERSION) || MZ_COMPAT_VERSION < 110
@ -212,8 +212,7 @@ ZEXPORT int unzGoToFilePos(unzFile file, unz_file_pos *file_pos);
ZEXPORT int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos); ZEXPORT int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos);
ZEXPORT int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos); ZEXPORT int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos);
ZEXPORT int64_t unzGetOffset64(unzFile file); ZEXPORT int64_t unzGetOffset64(unzFile file);
ZEXPORT unsigned long ZEXPORT unsigned long unzGetOffset(unzFile file);
unzGetOffset(unzFile file);
ZEXPORT int unzSetOffset64(unzFile file, int64_t pos); ZEXPORT int unzSetOffset64(unzFile file, int64_t pos);
ZEXPORT int unzSetOffset(unzFile file, unsigned long pos); ZEXPORT int unzSetOffset(unzFile file, unsigned long pos);
ZEXPORT int32_t unztell(unzFile file); ZEXPORT int32_t unztell(unzFile file);

113
compat/zip.c
View File

@ -51,8 +51,7 @@ zipFile zipOpen64(const void *path, int append) {
return zipOpen2(path, append, NULL, NULL); return zipOpen2(path, append, NULL, NULL);
} }
zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment, zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment, zlib_filefunc_def *pzlib_filefunc_def) {
zlib_filefunc_def *pzlib_filefunc_def) {
zipFile zip = NULL; zipFile zip = NULL;
int32_t mode = zipConvertAppendToStreamMode(append); int32_t mode = zipConvertAppendToStreamMode(append);
void *stream = NULL; void *stream = NULL;
@ -91,8 +90,7 @@ zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment,
return zip; return zip;
} }
zipFile zipOpen2_64(const void *path, int append, zipcharpc *globalcomment, zipFile zipOpen2_64(const void *path, int append, zipcharpc *globalcomment, zlib_filefunc64_def *pzlib_filefunc_def) {
zlib_filefunc64_def *pzlib_filefunc_def) {
zipFile zip = NULL; zipFile zip = NULL;
int32_t mode = zipConvertAppendToStreamMode(append); int32_t mode = zipConvertAppendToStreamMode(append);
void *stream = NULL; void *stream = NULL;
@ -185,11 +183,11 @@ static time_t zipConvertZipDateToTime(tm_zip tmz_date) {
return mz_zip_tm_to_time_t(&tm_date); return mz_zip_tm_to_time_t(&tm_date);
} }
int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const char *comment, int compression_method, int level, int raw, int windowBits, int memLevel,
int raw, int windowBits, int memLevel, int strategy, const char *password, int strategy, const char *password, unsigned long crc_for_crypting,
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base, int zip64) { unsigned long version_madeby, unsigned long flag_base, int zip64) {
mz_zip_compat *compat = (mz_zip_compat *)file; mz_zip_compat *compat = (mz_zip_compat *)file;
mz_zip_file file_info; mz_zip_file file_info;
@ -247,85 +245,84 @@ int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo
return mz_zip_entry_write_open(compat->handle, &file_info, (int16_t)level, (uint8_t)raw, password); return mz_zip_entry_write_open(compat->handle, &file_info, (int16_t)level, (uint8_t)raw, password);
} }
int zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password, int raw, int windowBits, int memLevel, int strategy, const char *password,
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base, int zip64) { unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base,
return zipOpenNewFileInZip5(file, filename, zipfi, extrafield_local, size_extrafield_local, int zip64) {
extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, return zipOpenNewFileInZip5(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
memLevel, strategy, password, crc_for_crypting, version_madeby, flag_base, zip64); size_extrafield_global, comment, compression_method, level, raw, windowBits, memLevel,
strategy, password, crc_for_crypting, version_madeby, flag_base, zip64);
} }
int zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const char *comment, int compression_method, int level, int raw, int windowBits, int memLevel,
int raw, int windowBits, int memLevel, int strategy, const char *password, int strategy, const char *password, unsigned long crc_for_crypting,
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base) { unsigned long version_madeby, unsigned long flag_base) {
return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, size_extrafield_global, comment, compression_method, level, raw, windowBits,
memLevel, strategy, password, crc_for_crypting, version_madeby, flag_base, 0); memLevel, strategy, password, crc_for_crypting, version_madeby, flag_base, 0);
} }
int zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const char *comment, int compression_method, int level, int raw, int windowBits, int memLevel,
int raw, int windowBits, int memLevel, int strategy, const char *password, int strategy, const char *password, unsigned long crc_for_crypting) {
unsigned long crc_for_crypting) { return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local, 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, 0); memLevel, strategy, password, crc_for_crypting, 0);
} }
int zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password, int raw, int windowBits, int memLevel, int strategy, const char *password,
unsigned long crc_for_crypting, int zip64) { unsigned long crc_for_crypting, int zip64) {
return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits, size_extrafield_global, comment, compression_method, level, raw, windowBits,
memLevel, strategy, password, crc_for_crypting, MZ_VERSION_MADEBY, 0, zip64); memLevel, strategy, password, crc_for_crypting, MZ_VERSION_MADEBY, 0, zip64);
} }
int zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const char *comment, int compression_method, int level, int raw) {
int raw) { return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local, size_extrafield_global, comment, compression_method, level, raw, 0, 0, 0, NULL, 0,
extrafield_global, size_extrafield_global, comment, compression_method, level, raw, 0);
0, 0, 0, NULL, 0, 0);
} }
int zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int zip64) { int raw, int zip64) {
return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local, return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
extrafield_global, size_extrafield_global, comment, compression_method, level, raw, 0, size_extrafield_global, comment, compression_method, level, raw, 0, 0, 0, NULL, 0,
0, 0, NULL, 0, zip64); zip64);
} }
int zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level) { const char *comment, int compression_method, int level) {
return zipOpenNewFileInZip_64(file, filename, zipfi, extrafield_local, size_extrafield_local, return zipOpenNewFileInZip_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
extrafield_global, size_extrafield_global, comment, compression_method, level, 0); size_extrafield_global, comment, compression_method, level, 0);
} }
int zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int zip64) { int zip64) {
return zipOpenNewFileInZip2_64(file, filename, zipfi, extrafield_local, size_extrafield_local, return zipOpenNewFileInZip2_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
extrafield_global, size_extrafield_global, comment, compression_method, level, 0, zip64); size_extrafield_global, comment, compression_method, level, 0, zip64);
} }
int zipOpenNewFileInZip_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, int zipOpenNewFileInZip_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, const void *extrafield_local,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int zip64) { int zip64) {
return zipOpenNewFileInZip2_64(file, filename, zipfi, extrafield_local, size_extrafield_local, return zipOpenNewFileInZip2_64(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global,
extrafield_global, size_extrafield_global, comment, compression_method, level, 0, zip64); size_extrafield_global, comment, compression_method, level, 0, zip64);
} }
int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len) { int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len) {

82
compat/zip.h
View File

@ -28,7 +28,9 @@ extern "C" {
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) #if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted /* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */ from (void*) without cast */
typedef struct TagzipFile__ { int unused; } zipFile__; typedef struct TagzipFile__ {
int unused;
} zipFile__;
typedef zipFile__ *zipFile; typedef zipFile__ *zipFile;
#else #else
typedef void *zipFile; typedef void *zipFile;
@ -65,8 +67,7 @@ typedef void *zipFile;
/***************************************************************************/ /***************************************************************************/
/* tm_zip contain date/time info */ /* tm_zip contain date/time info */
typedef struct tm_zip_s typedef struct tm_zip_s {
{
int tm_sec; /* seconds after the minute - [0,59] */ int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */ int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */ int tm_hour; /* hours since midnight - [0,23] */
@ -103,47 +104,49 @@ typedef const char* zipcharpc;
ZEXPORT zipFile zipOpen(const char *path, int append); ZEXPORT zipFile zipOpen(const char *path, int append);
ZEXPORT zipFile zipOpen64(const void *path, int append); ZEXPORT zipFile zipOpen64(const void *path, int append);
ZEXPORT zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment, ZEXPORT zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment, zlib_filefunc_def *pzlib_filefunc_def);
zlib_filefunc_def *pzlib_filefunc_def);
ZEXPORT zipFile zipOpen2_64(const void *path, int append, zipcharpc *globalcomment, ZEXPORT zipFile zipOpen2_64(const void *path, int append, zipcharpc *globalcomment,
zlib_filefunc64_def *pzlib_filefunc_def); zlib_filefunc64_def *pzlib_filefunc_def);
/* zipOpen3 is not supported */ /* zipOpen3 is not supported */
ZEXPORT int zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level); const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level);
ZEXPORT int zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int zip64); int compression_method, int level, int zip64);
ZEXPORT int zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw); int compression_method, int level, int raw);
ZEXPORT int zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw, int zip64); int compression_method, int level, int raw, int zip64);
ZEXPORT int zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw, int windowBits, int memLevel, int strategy, const char *password, int compression_method, int level, int raw, int windowBits, int memLevel, int strategy,
unsigned long crc_for_crypting); const char *password, unsigned long crc_for_crypting);
ZEXPORT int zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw, int windowBits, int memLevel, int strategy, const char *password, int compression_method, int level, int raw, int windowBits, int memLevel,
unsigned long crc_for_crypting, int zip64); int strategy, const char *password, unsigned long crc_for_crypting, int zip64);
ZEXPORT int zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw, int windowBits, int memLevel, int strategy, const char *password, int compression_method, int level, int raw, int windowBits, int memLevel, int strategy,
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base); const char *password, unsigned long crc_for_crypting, unsigned long version_madeby,
unsigned long flag_base);
ZEXPORT int zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw, int windowBits, int memLevel, int strategy, const char *password, int compression_method, int level, int raw, int windowBits, int memLevel,
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base, int zip64); int strategy, const char *password, unsigned long crc_for_crypting,
unsigned long version_madeby, unsigned long flag_base, int zip64);
ZEXPORT int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len); ZEXPORT int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len);
ZEXPORT int zipCloseFileInZipRaw(zipFile file, unsigned long uncompressed_size, unsigned long crc32); ZEXPORT int zipCloseFileInZipRaw(zipFile file, unsigned long uncompressed_size, unsigned long crc32);
ZEXPORT int zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, unsigned long crc32); ZEXPORT int zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, unsigned long crc32);
@ -157,14 +160,15 @@ ZEXPORT zipFile zipOpen_MZ(void *stream, int append, zipcharpc *globalcomment);
ZEXPORT void *zipGetHandle_MZ(zipFile); ZEXPORT void *zipGetHandle_MZ(zipFile);
ZEXPORT void *zipGetStream_MZ(zipFile file); ZEXPORT void *zipGetStream_MZ(zipFile file);
ZEXPORT int zipOpenNewFileInZip_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int zip64); int compression_method, int level, int zip64);
ZEXPORT int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi, ZEXPORT int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, const void *extrafield_local, uint16_t size_extrafield_local,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level, const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int raw, int windowBits, int memLevel, int strategy, const char *password, int compression_method, int level, int raw, int windowBits, int memLevel, int strategy,
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base, int zip64); const char *password, unsigned long crc_for_crypting, unsigned long version_madeby,
unsigned long flag_base, int zip64);
ZEXPORT int zipCloseFileInZip64(zipFile file); ZEXPORT int zipCloseFileInZip64(zipFile file);
ZEXPORT int zipClose_64(zipFile file, const char *global_comment); ZEXPORT int zipClose_64(zipFile file, const char *global_comment);
ZEXPORT int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby); ZEXPORT int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby);

28
minizip.c
View File

@ -52,7 +52,8 @@ int32_t minizip_add(const char *path, const char *password, minizip_opt *options
int32_t minizip_extract_entry_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path); int32_t minizip_extract_entry_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *file_info, int64_t position); int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *file_info, int64_t position);
int32_t minizip_extract_overwrite_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path); int32_t minizip_extract_overwrite_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
int32_t minizip_extract(const char *path, const char *pattern, const char *destination, const char *password, minizip_opt *options); int32_t minizip_extract(const char *path, const char *pattern, const char *destination, const char *password,
minizip_opt *options);
int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg_count, const char **args); int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg_count, const char **args);
@ -148,14 +149,11 @@ int32_t minizip_list(const char *path) {
mz_zip_time_t_to_tm(file_info->modified_date, &tmu_date); mz_zip_time_t_to_tm(file_info->modified_date, &tmu_date);
/* Print entry information */ /* Print entry information */
printf("%12" PRId64 " %12" PRId64 " %3" PRIu32 "%% %6s%c %8" PRIx32 " %2.2" PRIu32 \ printf("%12" PRId64 " %12" PRId64 " %3" PRIu32 "%% %6s%c %8" PRIx32 " %2.2" PRIu32 "-%2.2" PRIu32
"-%2.2" PRIu32 "-%2.2" PRIu32 " %2.2" PRIu32 ":%2.2" PRIu32 " %8.8" PRIx32 " %s\n", "-%2.2" PRIu32 " %2.2" PRIu32 ":%2.2" PRIu32 " %8.8" PRIx32 " %s\n",
file_info->compressed_size, file_info->uncompressed_size, ratio, file_info->compressed_size, file_info->uncompressed_size, ratio, method, crypt, file_info->external_fa,
method, crypt, file_info->external_fa, (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_mon + 1, (uint32_t)tmu_date.tm_mday, (uint32_t)tmu_date.tm_hour, (uint32_t)tmu_date.tm_min, file_info->crc, file_info->filename);
(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_reader_goto_next_entry(reader); err = mz_zip_reader_goto_next_entry(reader);
@ -199,9 +197,10 @@ int32_t minizip_add_progress_cb(void *handle, void *userdata, mz_zip_file *file_
progress = ((double)position / file_info->uncompressed_size) * 100; progress = ((double)position / file_info->uncompressed_size) * 100;
/* Print the progress of the current compress operation */ /* Print the progress of the current compress operation */
if (options->verbose) if (options->verbose) {
printf("%s - %" PRId64 " / %" PRId64 " (%.02f%%)\n", file_info->filename, position, printf("%s - %" PRId64 " / %" PRId64 " (%.02f%%)\n", file_info->filename, position,
file_info->uncompressed_size, progress); file_info->uncompressed_size, progress);
}
return MZ_OK; return MZ_OK;
} }
@ -234,7 +233,8 @@ int32_t minizip_add_overwrite_cb(void *handle, void *userdata, const char *path)
return MZ_OK; return MZ_OK;
} }
int32_t minizip_add(const char *path, const char *password, minizip_opt *options, int32_t arg_count, const char **args) { int32_t minizip_add(const char *path, const char *password, minizip_opt *options, int32_t arg_count,
const char **args) {
void *writer = NULL; void *writer = NULL;
int32_t err = MZ_OK; int32_t err = MZ_OK;
int32_t err_close = MZ_OK; int32_t err_close = MZ_OK;
@ -312,9 +312,10 @@ int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *f
progress = ((double)position / file_info->uncompressed_size) * 100; progress = ((double)position / file_info->uncompressed_size) * 100;
/* Print the progress of the current extraction */ /* Print the progress of the current extraction */
if (options->verbose) if (options->verbose) {
printf("%s - %" PRId64 " / %" PRId64 " (%.02f%%)\n", file_info->filename, position, printf("%s - %" PRId64 " / %" PRId64 " (%.02f%%)\n", file_info->filename, position,
file_info->uncompressed_size, progress); file_info->uncompressed_size, progress);
}
return MZ_OK; return MZ_OK;
} }
@ -347,7 +348,8 @@ int32_t minizip_extract_overwrite_cb(void *handle, void *userdata, mz_zip_file *
return MZ_OK; return MZ_OK;
} }
int32_t minizip_extract(const char *path, const char *pattern, const char *destination, const char *password, minizip_opt *options) { int32_t minizip_extract(const char *path, const char *pattern, const char *destination, const char *password,
minizip_opt *options) {
void *reader = NULL; void *reader = NULL;
int32_t err = MZ_OK; int32_t err = MZ_OK;
int32_t err_close = MZ_OK; int32_t err_close = MZ_OK;

77
mz_crypt.c
View File

@ -45,50 +45,35 @@ uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size)
return (uint32_t)lzma_crc32(buf, (size_t)size, (uint32_t)value); return (uint32_t)lzma_crc32(buf, (size_t)size, (uint32_t)value);
#else #else
static uint32_t crc32_table[256] = { static uint32_t crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
value = ~value; value = ~value;
while (size > 0) { while (size > 0) {
@ -103,8 +88,8 @@ uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size)
} }
#if defined(HAVE_WZAES) #if defined(HAVE_WZAES)
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt, int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt, int32_t salt_length,
int32_t salt_length, uint32_t iteration_count, uint8_t *key, uint16_t key_length) { uint32_t iteration_count, uint8_t *key, uint16_t key_length) {
void *hmac1 = NULL; void *hmac1 = NULL;
void *hmac2 = NULL; void *hmac2 = NULL;
void *hmac3 = NULL; void *hmac3 = NULL;

12
mz_crypt.h
View File

@ -19,8 +19,8 @@ extern "C" {
uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size); uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size);
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt, int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt, int32_t salt_length,
int32_t salt_length, uint32_t iteration_count, uint8_t *key, uint16_t key_length); uint32_t iteration_count, uint8_t *key, uint16_t key_length);
/***************************************************************************/ /***************************************************************************/
@ -39,10 +39,10 @@ int32_t mz_crypt_aes_encrypt(void *handle, const void *aad, int32_t aad_size, u
int32_t mz_crypt_aes_encrypt_final(void *handle, uint8_t *buf, int32_t size, uint8_t *tag, int32_t tag_size); int32_t mz_crypt_aes_encrypt_final(void *handle, uint8_t *buf, int32_t size, uint8_t *tag, int32_t tag_size);
int32_t mz_crypt_aes_decrypt(void *handle, const void *aad, int32_t aad_size, uint8_t *buf, int32_t size); int32_t mz_crypt_aes_decrypt(void *handle, const void *aad, int32_t aad_size, uint8_t *buf, int32_t size);
int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, const uint8_t *tag, int32_t tag_size); int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, const uint8_t *tag, int32_t tag_size);
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length); int32_t iv_length);
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length); int32_t iv_length);
void mz_crypt_aes_set_mode(void *handle, int32_t mode); void mz_crypt_aes_set_mode(void *handle, int32_t mode);
void *mz_crypt_aes_create(void); void *mz_crypt_aes_create(void);
void mz_crypt_aes_delete(void **handle); void mz_crypt_aes_delete(void **handle);

20
mz_crypt_apple.c
View File

@ -62,9 +62,7 @@ typedef struct mz_crypt_sha_s {
/***************************************************************************/ /***************************************************************************/
static const uint8_t mz_crypt_sha_digest_size[] = { static const uint8_t mz_crypt_sha_digest_size[] = {
MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE, MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE, MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE};
MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE
};
/***************************************************************************/ /***************************************************************************/
@ -347,8 +345,8 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
#endif #endif
} }
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length, CCOperation op) { int32_t iv_length, CCOperation op) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle; mz_crypt_aes *aes = (mz_crypt_aes *)handle;
CCMode mode; CCMode mode;
@ -367,8 +365,8 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
mz_crypt_aes_reset(handle); mz_crypt_aes_reset(handle);
aes->error = CCCryptorCreateWithMode(op, mode, kCCAlgorithmAES, ccNoPadding, iv, key, key_length, aes->error = CCCryptorCreateWithMode(op, mode, kCCAlgorithmAES, ccNoPadding, iv, key, key_length, NULL, 0, 0, 0,
NULL, 0, 0, 0, &aes->crypt); &aes->crypt);
if (aes->error != kCCSuccess) if (aes->error != kCCSuccess)
return MZ_HASH_ERROR; return MZ_HASH_ERROR;
@ -385,13 +383,13 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
return MZ_OK; return MZ_OK;
} }
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, kCCEncrypt); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, kCCEncrypt);
} }
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, kCCDecrypt); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, kCCDecrypt);
} }

16
mz_crypt_openssl.c
View File

@ -72,9 +72,7 @@ typedef struct mz_crypt_sha_s {
/***************************************************************************/ /***************************************************************************/
static const uint8_t mz_crypt_sha_digest_size[] = { static const uint8_t mz_crypt_sha_digest_size[] = {
MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE, MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE, MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE};
MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE
};
/***************************************************************************/ /***************************************************************************/
@ -382,8 +380,8 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
return size; return size;
} }
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length, int32_t encrypt) { int32_t iv_length, int32_t encrypt) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle; mz_crypt_aes *aes = (mz_crypt_aes *)handle;
const EVP_CIPHER *type = NULL; const EVP_CIPHER *type = NULL;
@ -430,8 +428,8 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
return MZ_OK; return MZ_OK;
} }
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle; mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (!aes || !key || !key_length) if (!aes || !key || !key_length)
@ -446,8 +444,8 @@ int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, 1); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, 1);
} }
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle; mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (!aes || !key || !key_length) if (!aes || !key || !key_length)

48
mz_crypt_winvista.c
View File

@ -104,8 +104,8 @@ int32_t mz_crypt_sha_begin(void *handle) {
status = BCryptOpenAlgorithmProvider(&sha->provider, alg_id, NULL, 0); status = BCryptOpenAlgorithmProvider(&sha->provider, alg_id, NULL, 0);
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
status = BCryptGetProperty(sha->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size, status =
&result_size, 0); BCryptGetProperty(sha->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size, &result_size, 0);
} }
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
sha->buffer = malloc(buffer_size); sha->buffer = malloc(buffer_size);
@ -257,8 +257,7 @@ int32_t mz_crypt_aes_encrypt(void *handle, const void *aad, int32_t aad_size, ui
aes->auth_info->cbAuthData = aad_size; aes->auth_info->cbAuthData = aad_size;
} }
status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
&output_size, 0);
if (aad && aes->auth_info) { if (aad && aes->auth_info) {
aes->auth_info->pbAuthData = NULL; aes->auth_info->pbAuthData = NULL;
@ -285,8 +284,7 @@ int32_t mz_crypt_aes_encrypt_final(void *handle, uint8_t *buf, int32_t size, uin
aes->auth_info->dwFlags &= ~BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG; aes->auth_info->dwFlags &= ~BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG;
status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
&output_size, 0);
if (!NT_SUCCESS(status)) { if (!NT_SUCCESS(status)) {
aes->error = status; aes->error = status;
@ -313,8 +311,7 @@ int32_t mz_crypt_aes_decrypt(void *handle, const void *aad, int32_t aad_size, ui
aes->auth_info->cbAuthData = aad_size; aes->auth_info->cbAuthData = aad_size;
} }
status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
&output_size, 0);
if (aad && aes->auth_info) { if (aad && aes->auth_info) {
aes->auth_info->pbAuthData = NULL; aes->auth_info->pbAuthData = NULL;
@ -341,8 +338,7 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
aes->auth_info->dwFlags &= ~BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG; aes->auth_info->dwFlags &= ~BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG;
status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
&output_size, 0);
if (!NT_SUCCESS(status)) { if (!NT_SUCCESS(status)) {
aes->error = status; aes->error = status;
@ -352,8 +348,8 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
return size; return size;
} }
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle; mz_crypt_aes *aes = (mz_crypt_aes *)handle;
BCRYPT_KEY_DATA_BLOB_HEADER *key_blob = NULL; BCRYPT_KEY_DATA_BLOB_HEADER *key_blob = NULL;
int32_t key_blob_size = 0; int32_t key_blob_size = 0;
@ -399,8 +395,8 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
ULONG result_size; ULONG result_size;
status = BCryptGetProperty(aes->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&key_size, status = BCryptGetProperty(aes->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&key_size, sizeof(key_size),
sizeof(key_size), &result_size, 0); &result_size, 0);
} }
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
@ -416,8 +412,8 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
memcpy((uint8_t *)key_blob + sizeof(*key_blob), key, key_length); memcpy((uint8_t *)key_blob + sizeof(*key_blob), key, key_length);
status = BCryptImportKey(aes->provider, NULL, BCRYPT_KEY_DATA_BLOB, &aes->key, aes->key_buffer, status = BCryptImportKey(aes->provider, NULL, BCRYPT_KEY_DATA_BLOB, &aes->key, aes->key_buffer, key_size,
key_size, (PUCHAR)key_blob, key_blob_size, 0); (PUCHAR)key_blob, key_blob_size, 0);
SecureZeroMemory(key_blob, key_blob_size); SecureZeroMemory(key_blob, key_blob_size);
free(key_blob); free(key_blob);
} }
@ -436,8 +432,8 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
BCRYPT_AUTH_TAG_LENGTHS_STRUCT tag_lengths; BCRYPT_AUTH_TAG_LENGTHS_STRUCT tag_lengths;
status = BCryptGetProperty(aes->provider, BCRYPT_AUTH_TAG_LENGTH, (PUCHAR)&tag_lengths, status = BCryptGetProperty(aes->provider, BCRYPT_AUTH_TAG_LENGTH, (PUCHAR)&tag_lengths, sizeof(tag_lengths),
sizeof(tag_lengths), &result_size, 0); &result_size, 0);
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
aes->tag_size = tag_lengths.dwMaxLength; aes->tag_size = tag_lengths.dwMaxLength;
@ -453,8 +449,8 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
ULONG block_length; ULONG block_length;
status = BCryptGetProperty(aes->provider, BCRYPT_BLOCK_LENGTH, (PUCHAR)&block_length, status = BCryptGetProperty(aes->provider, BCRYPT_BLOCK_LENGTH, (PUCHAR)&block_length, sizeof(block_length),
sizeof(block_length), &result_size, 0); &result_size, 0);
if (NT_SUCCESS(status) && iv) { if (NT_SUCCESS(status) && iv) {
if (aes->iv_length > block_length) if (aes->iv_length > block_length)
@ -479,13 +475,13 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
return err; return err;
} }
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length);
} }
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length);
} }
@ -561,8 +557,8 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
status = BCryptOpenAlgorithmProvider(&hmac->provider, alg_id, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG); status = BCryptOpenAlgorithmProvider(&hmac->provider, alg_id, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG);
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
status = BCryptGetProperty(hmac->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size, status =
&result_size, 0); BCryptGetProperty(hmac->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size, &result_size, 0);
} }
if (NT_SUCCESS(status)) { if (NT_SUCCESS(status)) {
hmac->buffer = malloc(buffer_size); hmac->buffer = malloc(buffer_size);

17
mz_crypt_winxp.c
View File

@ -253,8 +253,8 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
return MZ_SUPPORT_ERROR; return MZ_SUPPORT_ERROR;
} }
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle; mz_crypt_aes *aes = (mz_crypt_aes *)handle;
HCRYPTHASH hash = 0; HCRYPTHASH hash = 0;
ALG_ID alg_id = 0; ALG_ID alg_id = 0;
@ -321,7 +321,6 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
if (result && err == MZ_OK) if (result && err == MZ_OK)
result = CryptSetKeyParam(aes->key, KP_MODE, (const uint8_t *)&mode, 0); result = CryptSetKeyParam(aes->key, KP_MODE, (const uint8_t *)&mode, 0);
if (!result && err == MZ_OK) { if (!result && err == MZ_OK) {
aes->error = GetLastError(); aes->error = GetLastError();
err = MZ_CRYPT_ERROR; err = MZ_CRYPT_ERROR;
@ -345,13 +344,13 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
return err; return err;
} }
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length);
} }
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
const void *iv, int32_t iv_length) { int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length); return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length);
} }
@ -439,8 +438,8 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
hmac->info.HashAlgid = alg_id; hmac->info.HashAlgid = alg_id;
result = CryptAcquireContext(&hmac->provider, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, result =
CRYPT_VERIFYCONTEXT | CRYPT_SILENT); CryptAcquireContext(&hmac->provider, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (!result) { if (!result) {
hmac->error = GetLastError(); hmac->error = GetLastError();

18
mz_os.c
View File

@ -136,12 +136,12 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
while (*source != 0 && max_output > 1) { while (*source != 0 && max_output > 1) {
check = source; check = source;
if ((*check == '\\') || (*check == '/')) if (*check == '\\' || *check == '/')
check += 1; check += 1;
if ((source == path) || (target == output) || (check != source)) { if (source == path || target == output || check != source) {
/* Skip double paths */ /* Skip double paths */
if ((*check == '\\') || (*check == '/')) { if (*check == '\\' || *check == '/') {
source += 1; source += 1;
continue; continue;
} }
@ -149,7 +149,7 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
check += 1; check += 1;
/* Remove . if at end of string and not at the beginning */ /* Remove . if at end of string and not at the beginning */
if ((*check == 0) && (source != path && target != output)) { if (*check == 0 && source != path && target != output) {
/* Copy last slash */ /* Copy last slash */
*target = *source; *target = *source;
target += 1; target += 1;
@ -158,7 +158,7 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
continue; continue;
} }
/* Remove . if not at end of string */ /* Remove . if not at end of string */
else if ((*check == '\\') || (*check == '/')) { else if (*check == '\\' || *check == '/') {
source += (check - source); source += (check - source);
/* Skip slash if at beginning of string */ /* Skip slash if at beginning of string */
if (target == output && *source != 0) if (target == output && *source != 0)
@ -168,14 +168,14 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
/* Go to parent directory .. */ /* Go to parent directory .. */
else if (*check == '.') { else if (*check == '.') {
check += 1; check += 1;
if ((*check == 0) || (*check == '\\' || *check == '/')) { if (*check == 0 || (*check == '\\' || *check == '/')) {
source += (check - source); source += (check - source);
/* Search backwards for previous slash or the start of the output string */ /* Search backwards for previous slash or the start of the output string */
if (target != output) { if (target != output) {
target -= 1; target -= 1;
do { do {
if ((target == output) ||(*target == '\\') || (*target == '/')) if (target == output || *target == '\\' || *target == '/')
break; break;
target -= 1; target -= 1;
@ -183,9 +183,9 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
} while (target > output); } while (target > output);
} }
if ((target == output) && (*source != 0)) if ((target == output) && *source != 0)
source += 1; source += 1;
if ((*target == '\\' || *target == '/') && (*source == 0)) if ((*target == '\\' || *target == '/') && *source == 0)
target += 1; target += 1;
*target = 0; *target = 0;

6
mz_os.h
View File

@ -37,8 +37,7 @@ extern "C" {
# define MZ_VERSION_MADEBY_ZIP_VERSION (45) # define MZ_VERSION_MADEBY_ZIP_VERSION (45)
#endif #endif
#define MZ_VERSION_MADEBY ((MZ_VERSION_MADEBY_HOST_SYSTEM << 8) | \ #define MZ_VERSION_MADEBY ((MZ_VERSION_MADEBY_HOST_SYSTEM << 8) | (MZ_VERSION_MADEBY_ZIP_VERSION))
(MZ_VERSION_MADEBY_ZIP_VERSION))
#define MZ_PATH_SLASH_UNIX ('/') #define MZ_PATH_SLASH_UNIX ('/')
#define MZ_PATH_SLASH_WINDOWS ('\\') #define MZ_PATH_SLASH_WINDOWS ('\\')
@ -145,8 +144,7 @@ int32_t mz_os_make_dir(const char *path);
DIR *mz_os_open_dir(const char *path); DIR *mz_os_open_dir(const char *path);
/* Opens a directory for listing */ /* Opens a directory for listing */
struct struct dirent *mz_os_read_dir(DIR *dir);
dirent* mz_os_read_dir(DIR *dir);
/* Reads a directory listing entry */ /* Reads a directory listing entry */
int32_t mz_os_close_dir(DIR *dir); int32_t mz_os_close_dir(DIR *dir);

3
mz_os_posix.c
View File

@ -75,8 +75,7 @@ char *mz_os_utf8_string_create(const char *string, int32_t encoding) {
string_utf8_ptr = string_utf8; string_utf8_ptr = string_utf8;
if (string_utf8) { if (string_utf8) {
result = iconv(cd, (char **)&string, &string_length, result = iconv(cd, (char **)&string, &string_length, (char **)&string_utf8_ptr, &string_utf8_size);
(char **)&string_utf8_ptr, &string_utf8_size);
} }
iconv_close(cd); iconv_close(cd);

7
mz_os_win32.c
View File

@ -411,8 +411,8 @@ struct dirent* mz_os_read_dir(DIR *dir) {
if (dir_int->end) if (dir_int->end)
return NULL; 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,
dir_int->entry.d_name, sizeof(dir_int->entry.d_name), NULL, NULL); sizeof(dir_int->entry.d_name), NULL, NULL);
if (FindNextFileW(dir_int->find_handle, &dir_int->find_data) == 0) { if (FindNextFileW(dir_int->find_handle, &dir_int->find_data) == 0) {
if (GetLastError() != ERROR_NO_MORE_FILES) if (GetLastError() != ERROR_NO_MORE_FILES)
@ -593,8 +593,7 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
if (DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0, buffer, sizeof(buffer), &length, NULL) == TRUE) { if (DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0, buffer, sizeof(buffer), &length, NULL) == TRUE) {
reparse_data = (REPARSE_DATA_BUFFER *)buffer; reparse_data = (REPARSE_DATA_BUFFER *)buffer;
if ((IsReparseTagMicrosoft(reparse_data->ReparseTag)) && if ((IsReparseTagMicrosoft(reparse_data->ReparseTag)) && (reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK)) {
(reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK)) {
target_path_len = max_target_path * sizeof(wchar_t); target_path_len = max_target_path * sizeof(wchar_t);
if (target_path_len > reparse_data->SymbolicLinkReparseBuffer.PrintNameLength) if (target_path_len > reparse_data->SymbolicLinkReparseBuffer.PrintNameLength)
target_path_len = reparse_data->SymbolicLinkReparseBuffer.PrintNameLength; target_path_len = reparse_data->SymbolicLinkReparseBuffer.PrintNameLength;

24
mz_strm.c
View File

@ -158,8 +158,8 @@ int32_t mz_stream_copy_to_end(void *target, void *source) {
return mz_stream_copy_stream_to_end(target, NULL, source, NULL); return mz_stream_copy_stream_to_end(target, NULL, source, NULL);
} }
int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb,
mz_stream_read_cb read_cb, int32_t len) { int32_t len) {
uint8_t buf[16384]; uint8_t buf[16384];
int32_t bytes_to_copy = 0; int32_t bytes_to_copy = 0;
int32_t read = 0; int32_t read = 0;
@ -253,8 +253,10 @@ int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_
start_pos = mz_stream_tell(stream); start_pos = mz_stream_tell(stream);
while (read_pos < max_seek) { while (read_pos < max_seek) {
if (read_size > (int32_t)(max_seek - read_pos - buf_pos) && (max_seek - read_pos - buf_pos) < (int64_t)sizeof(buf)) if (read_size > (int32_t)(max_seek - read_pos - buf_pos) &&
(max_seek - read_pos - buf_pos) < (int64_t)sizeof(buf)) {
read_size = (int32_t)(max_seek - read_pos - buf_pos); read_size = (int32_t)(max_seek - read_pos - buf_pos);
}
read = mz_stream_read(stream, buf + buf_pos, read_size); read = mz_stream_read(stream, buf + buf_pos, read_size);
if ((read <= 0) || (read + buf_pos < find_size)) if ((read <= 0) || (read + buf_pos < find_size))
@ -517,19 +519,9 @@ int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value)
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_raw_vtbl = { static mz_stream_vtbl mz_stream_raw_vtbl = {
mz_stream_raw_open, mz_stream_raw_open, mz_stream_raw_is_open, mz_stream_raw_read, mz_stream_raw_write,
mz_stream_raw_is_open, mz_stream_raw_tell, mz_stream_raw_seek, mz_stream_raw_close, mz_stream_raw_error,
mz_stream_raw_read, mz_stream_raw_create, mz_stream_raw_delete, mz_stream_raw_get_prop_int64, mz_stream_raw_set_prop_int64};
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
};
/***************************************************************************/ /***************************************************************************/

10
mz_strm.h
View File

@ -45,8 +45,8 @@ typedef void (*mz_stream_destroy_cb) (void **stream);
typedef int32_t (*mz_stream_get_prop_int64_cb)(void *stream, int32_t prop, int64_t *value); typedef int32_t (*mz_stream_get_prop_int64_cb)(void *stream, int32_t prop, int64_t *value);
typedef int32_t (*mz_stream_set_prop_int64_cb)(void *stream, int32_t prop, int64_t value); typedef int32_t (*mz_stream_set_prop_int64_cb)(void *stream, int32_t prop, int64_t value);
typedef int32_t (*mz_stream_find_cb) (void *stream, const void *find, int32_t find_size, typedef int32_t (*mz_stream_find_cb)(void *stream, const void *find, int32_t find_size, int64_t max_seek,
int64_t max_seek, int64_t *position); int64_t *position);
/***************************************************************************/ /***************************************************************************/
@ -89,8 +89,10 @@ int32_t mz_stream_write_int64(void *stream, int64_t value);
int32_t mz_stream_write_uint64(void *stream, uint64_t value); int32_t mz_stream_write_uint64(void *stream, uint64_t value);
int32_t mz_stream_copy(void *target, void *source, int32_t len); int32_t mz_stream_copy(void *target, void *source, int32_t len);
int32_t mz_stream_copy_to_end(void *target, void *source); int32_t mz_stream_copy_to_end(void *target, void *source);
int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb, int32_t len); int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb,
int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb); int32_t len);
int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source,
mz_stream_read_cb read_cb);
int64_t mz_stream_tell(void *stream); int64_t mz_stream_tell(void *stream);
int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin); int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin);
int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position); int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position);

50
mz_strm_buf.c
View File

@ -16,8 +16,7 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_buffered_vtbl = { static mz_stream_vtbl mz_stream_buffered_vtbl = {mz_stream_buffered_open,
mz_stream_buffered_open,
mz_stream_buffered_is_open, mz_stream_buffered_is_open,
mz_stream_buffered_read, mz_stream_buffered_read,
mz_stream_buffered_write, mz_stream_buffered_write,
@ -28,8 +27,7 @@ static mz_stream_vtbl mz_stream_buffered_vtbl = {
mz_stream_buffered_create, mz_stream_buffered_create,
mz_stream_buffered_delete, mz_stream_buffered_delete,
NULL, NULL,
NULL NULL};
};
/***************************************************************************/ /***************************************************************************/
@ -93,16 +91,16 @@ static int32_t mz_stream_buffered_flush(void *stream, int32_t *written) {
*written = 0; *written = 0;
while (bytes_left_to_write > 0) { while (bytes_left_to_write > 0) {
bytes_written = mz_stream_write(buffered->stream.base, bytes_written = mz_stream_write(
buffered->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write); buffered->stream.base, buffered->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);
if (bytes_written != bytes_left_to_write) if (bytes_written != bytes_left_to_write)
return MZ_WRITE_ERROR; return MZ_WRITE_ERROR;
buffered->writebuf_misses += 1; buffered->writebuf_misses += 1;
mz_stream_buffered_print("Buffered - Write flush (%" PRId32 ":%" PRId32 " len %" PRId32 ")\n", mz_stream_buffered_print("Buffered - Write flush (%" PRId32 ":%" PRId32 " len %" PRId32 ")\n", bytes_to_write,
bytes_to_write, bytes_left_to_write, buffered->writebuf_len); bytes_left_to_write, buffered->writebuf_len);
total_bytes_written += bytes_written; total_bytes_written += bytes_written;
bytes_left_to_write -= bytes_written; bytes_left_to_write -= bytes_written;
@ -128,7 +126,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size) {
mz_stream_buffered_print("Buffered - Read (size %" PRId32 " pos %" PRId64 ")\n", size, buffered->position); mz_stream_buffered_print("Buffered - Read (size %" PRId32 " pos %" PRId64 ")\n", size, buffered->position);
if (buffered->writebuf_len > 0) { if (buffered->writebuf_len > 0) {
int64_t position = buffered->position + buffered->writebuf_pos int64_t position = buffered->position + buffered->writebuf_pos;
mz_stream_buffered_print("Buffered - Switch from write to read, flushing (pos %" PRId64 ")\n", position); mz_stream_buffered_print("Buffered - Switch from write to read, flushing (pos %" PRId64 ")\n", position);
@ -144,7 +142,8 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size) {
} }
bytes_to_read = (int32_t)sizeof(buffered->readbuf) - (buffered->readbuf_len - buffered->readbuf_pos); bytes_to_read = (int32_t)sizeof(buffered->readbuf) - (buffered->readbuf_len - buffered->readbuf_pos);
bytes_read = mz_stream_read(buffered->stream.base, buffered->readbuf + buffered->readbuf_pos, bytes_to_read); bytes_read =
mz_stream_read(buffered->stream.base, buffered->readbuf + buffered->readbuf_pos, bytes_to_read);
if (bytes_read < 0) if (bytes_read < 0)
return bytes_read; return bytes_read;
@ -152,7 +151,8 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size) {
buffered->readbuf_len += bytes_read; buffered->readbuf_len += bytes_read;
buffered->position += bytes_read; buffered->position += bytes_read;
mz_stream_buffered_print("Buffered - Filled (read %" PRId32 "/%" PRId32 " buf %" PRId32 ":%" PRId32 " pos %" PRId64 ")\n", mz_stream_buffered_print(
"Buffered - Filled (read %" PRId32 "/%" PRId32 " buf %" PRId32 ":%" PRId32 " pos %" PRId64 ")\n",
bytes_read, bytes_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position); bytes_read, bytes_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
if (bytes_read == 0) if (bytes_read == 0)
@ -172,8 +172,10 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size) {
buffered->readbuf_hits += 1; buffered->readbuf_hits += 1;
buffered->readbuf_pos += bytes_to_copy; buffered->readbuf_pos += bytes_to_copy;
mz_stream_buffered_print("Buffered - Emptied (copied %" PRId32 " remaining %" PRId32 " buf %" PRId32 ":%" PRId32 " pos %" PRId64 ")\n", mz_stream_buffered_print("Buffered - Emptied (copied %" PRId32 " remaining %" PRId32 " buf %" PRId32
bytes_to_copy, bytes_left_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position); ":%" PRId32 " pos %" PRId64 ")\n",
bytes_to_copy, bytes_left_to_read, buffered->readbuf_pos, buffered->readbuf_len,
buffered->position);
} }
} }
@ -189,9 +191,8 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size) {
int32_t bytes_flushed = 0; int32_t bytes_flushed = 0;
int32_t err = MZ_OK; int32_t err = MZ_OK;
mz_stream_buffered_print("Buffered - Write (size %" PRId32 " len %" PRId32 " pos %" PRId64 ")\n", size,
mz_stream_buffered_print("Buffered - Write (size %" PRId32 " len %" PRId32 " pos %" PRId64 ")\n", buffered->writebuf_len, buffered->position);
size, buffered->writebuf_len, buffered->position);
if (buffered->readbuf_len > 0) { if (buffered->readbuf_len > 0) {
buffered->position -= buffered->readbuf_len; buffered->position -= buffered->readbuf_len;
@ -225,10 +226,11 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size) {
continue; continue;
} }
memcpy(buffered->writebuf + buffered->writebuf_pos, memcpy(buffered->writebuf + buffered->writebuf_pos, (const char *)buf + (bytes_to_write - bytes_left_to_write),
(const char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy); bytes_to_copy);
mz_stream_buffered_print("Buffered - Write copy (remaining %" PRId32 " write %" PRId32 ":%" PRId32 " len %" PRId32 ")\n", mz_stream_buffered_print("Buffered - Write copy (remaining %" PRId32 " write %" PRId32 ":%" PRId32
" len %" PRId32 ")\n",
bytes_to_copy, bytes_to_write, bytes_left_to_write, buffered->writebuf_len); bytes_to_copy, bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
bytes_left_to_write -= bytes_to_copy; bytes_left_to_write -= bytes_to_copy;
@ -263,8 +265,8 @@ int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin) {
int32_t bytes_flushed = 0; int32_t bytes_flushed = 0;
int32_t err = MZ_OK; int32_t err = MZ_OK;
mz_stream_buffered_print("Buffered - Seek (origin %" PRId32 " offset %" PRId64 " pos %" PRId64 ")\n", mz_stream_buffered_print("Buffered - Seek (origin %" PRId32 " offset %" PRId64 " pos %" PRId64 ")\n", origin,
origin, offset, buffered->position); offset, buffered->position);
switch (origin) { switch (origin) {
case MZ_SEEK_SET: case MZ_SEEK_SET:
@ -337,12 +339,14 @@ int32_t mz_stream_buffered_close(void *stream) {
mz_stream_buffered_print("Buffered - Close (flushed %" PRId32 ")\n", bytes_flushed); mz_stream_buffered_print("Buffered - Close (flushed %" PRId32 ")\n", bytes_flushed);
if (buffered->readbuf_hits + buffered->readbuf_misses > 0) { if (buffered->readbuf_hits + buffered->readbuf_misses > 0) {
mz_stream_buffered_print("Buffered - Read efficiency %.02f%%\n", mz_stream_buffered_print(
"Buffered - Read efficiency %.02f%%\n",
(buffered->readbuf_hits / ((float)buffered->readbuf_hits + buffered->readbuf_misses)) * 100); (buffered->readbuf_hits / ((float)buffered->readbuf_hits + buffered->readbuf_misses)) * 100);
} }
if (buffered->writebuf_hits + buffered->writebuf_misses > 0) { if (buffered->writebuf_hits + buffered->writebuf_misses > 0) {
mz_stream_buffered_print("Buffered - Write efficiency %.02f%%\n", mz_stream_buffered_print(
"Buffered - Write efficiency %.02f%%\n",
(buffered->writebuf_hits / ((float)buffered->writebuf_hits + buffered->writebuf_misses)) * 100); (buffered->writebuf_hits / ((float)buffered->writebuf_hits + buffered->writebuf_misses)) * 100);
} }

28
mz_strm_bzip.c
View File

@ -17,19 +17,9 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_bzip_vtbl = { static mz_stream_vtbl mz_stream_bzip_vtbl = {
mz_stream_bzip_open, mz_stream_bzip_open, mz_stream_bzip_is_open, mz_stream_bzip_read, mz_stream_bzip_write,
mz_stream_bzip_is_open, mz_stream_bzip_tell, mz_stream_bzip_seek, mz_stream_bzip_close, mz_stream_bzip_error,
mz_stream_bzip_read, mz_stream_bzip_create, mz_stream_bzip_delete, mz_stream_bzip_get_prop_int64, mz_stream_bzip_set_prop_int64};
mz_stream_bzip_write,
mz_stream_bzip_tell,
mz_stream_bzip_seek,
mz_stream_bzip_close,
mz_stream_bzip_error,
mz_stream_bzip_create,
mz_stream_bzip_delete,
mz_stream_bzip_get_prop_int64,
mz_stream_bzip_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/
@ -144,14 +134,12 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size) {
} }
total_in_before = bzip->bzstream.avail_in; 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);
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
err = BZ2_bzDecompress(&bzip->bzstream); err = BZ2_bzDecompress(&bzip->bzstream);
total_in_after = bzip->bzstream.avail_in; 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);
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
in_bytes = (int32_t)(total_in_before - total_in_after); in_bytes = (int32_t)(total_in_before - total_in_after);
out_bytes = (int32_t)(total_out_after - total_out_before); out_bytes = (int32_t)(total_out_after - total_out_before);
@ -205,13 +193,11 @@ static int32_t mz_stream_bzip_compress(void *stream, int flush) {
bzip->buffer_len = 0; 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);
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
err = BZ2_bzCompress(&bzip->bzstream, flush); 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);
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
out_bytes = (uint32_t)(total_out_after - total_out_before); out_bytes = (uint32_t)(total_out_after - total_out_before);

20
mz_strm_libcomp.c
View File

@ -17,26 +17,16 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_libcomp_vtbl = { static mz_stream_vtbl mz_stream_libcomp_vtbl = {
mz_stream_libcomp_open, mz_stream_libcomp_open, mz_stream_libcomp_is_open, mz_stream_libcomp_read,
mz_stream_libcomp_is_open, mz_stream_libcomp_write, mz_stream_libcomp_tell, mz_stream_libcomp_seek,
mz_stream_libcomp_read, mz_stream_libcomp_close, mz_stream_libcomp_error, mz_stream_libcomp_create,
mz_stream_libcomp_write, mz_stream_libcomp_delete, mz_stream_libcomp_get_prop_int64, mz_stream_libcomp_set_prop_int64};
mz_stream_libcomp_tell,
mz_stream_libcomp_seek,
mz_stream_libcomp_close,
mz_stream_libcomp_error,
mz_stream_libcomp_create,
mz_stream_libcomp_delete,
mz_stream_libcomp_get_prop_int64,
mz_stream_libcomp_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/
typedef struct mz_stream_libcomp_s { typedef struct mz_stream_libcomp_s {
mz_stream stream; mz_stream stream;
compression_stream compression_stream cstream;
cstream;
uint8_t buffer[INT16_MAX]; uint8_t buffer[INT16_MAX];
int32_t buffer_len; int32_t buffer_len;
int64_t total_in; int64_t total_in;

16
mz_strm_lzma.c
View File

@ -23,19 +23,9 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_lzma_vtbl = { static mz_stream_vtbl mz_stream_lzma_vtbl = {
mz_stream_lzma_open, mz_stream_lzma_open, mz_stream_lzma_is_open, mz_stream_lzma_read, mz_stream_lzma_write,
mz_stream_lzma_is_open, mz_stream_lzma_tell, mz_stream_lzma_seek, mz_stream_lzma_close, mz_stream_lzma_error,
mz_stream_lzma_read, mz_stream_lzma_create, mz_stream_lzma_delete, mz_stream_lzma_get_prop_int64, mz_stream_lzma_set_prop_int64};
mz_stream_lzma_write,
mz_stream_lzma_tell,
mz_stream_lzma_seek,
mz_stream_lzma_close,
mz_stream_lzma_error,
mz_stream_lzma_create,
mz_stream_lzma_delete,
mz_stream_lzma_get_prop_int64,
mz_stream_lzma_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/

6
mz_strm_mem.c
View File

@ -22,8 +22,7 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_mem_vtbl = { static mz_stream_vtbl mz_stream_mem_vtbl = {mz_stream_mem_open,
mz_stream_mem_open,
mz_stream_mem_is_open, mz_stream_mem_is_open,
mz_stream_mem_read, mz_stream_mem_read,
mz_stream_mem_write, mz_stream_mem_write,
@ -34,8 +33,7 @@ static mz_stream_vtbl mz_stream_mem_vtbl = {
mz_stream_mem_create, mz_stream_mem_create,
mz_stream_mem_delete, mz_stream_mem_delete,
NULL, NULL,
NULL NULL};
};
/***************************************************************************/ /***************************************************************************/

6
mz_strm_os_posix.c
View File

@ -41,8 +41,7 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_os_vtbl = { static mz_stream_vtbl mz_stream_os_vtbl = {mz_stream_os_open,
mz_stream_os_open,
mz_stream_os_is_open, mz_stream_os_is_open,
mz_stream_os_read, mz_stream_os_read,
mz_stream_os_write, mz_stream_os_write,
@ -53,8 +52,7 @@ static mz_stream_vtbl mz_stream_os_vtbl = {
mz_stream_os_create, mz_stream_os_create,
mz_stream_os_delete, mz_stream_os_delete,
NULL, NULL,
NULL NULL};
};
/***************************************************************************/ /***************************************************************************/

18
mz_strm_os_win32.c
View File

@ -27,7 +27,7 @@
#endif #endif
#ifndef INVALID_SET_FILE_POINTER #ifndef INVALID_SET_FILE_POINTER
# define INVALID_SET_FILE_POINTER (DWORD)-1 # define INVALID_SET_FILE_POINTER (DWORD)(-1)
#endif #endif
#ifndef _WIN32_WINNT_WIN8 #ifndef _WIN32_WINNT_WIN8
@ -36,8 +36,7 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_os_vtbl = { static mz_stream_vtbl mz_stream_os_vtbl = {mz_stream_os_open,
mz_stream_os_open,
mz_stream_os_is_open, mz_stream_os_is_open,
mz_stream_os_read, mz_stream_os_read,
mz_stream_os_write, mz_stream_os_write,
@ -48,8 +47,7 @@ static mz_stream_vtbl mz_stream_os_vtbl = {
mz_stream_os_create, mz_stream_os_create,
mz_stream_os_delete, mz_stream_os_delete,
NULL, NULL,
NULL NULL};
};
/***************************************************************************/ /***************************************************************************/
@ -103,11 +101,9 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode) {
return MZ_PARAM_ERROR; return MZ_PARAM_ERROR;
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8 #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
win32->handle = CreateFile2(path_wide, desired_access, share_mode, win32->handle = CreateFile2(path_wide, desired_access, share_mode, creation_disposition, NULL);
creation_disposition, NULL);
#else #else
win32->handle = CreateFileW(path_wide, desired_access, share_mode, NULL, win32->handle = CreateFileW(path_wide, desired_access, share_mode, NULL, creation_disposition, flags_attribs, NULL);
creation_disposition, flags_attribs, NULL);
#endif #endif
mz_os_unicode_string_delete(&path_wide); mz_os_unicode_string_delete(&path_wide);
@ -166,8 +162,8 @@ int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size) {
return written; return written;
} }
static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos, static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos, LARGE_INTEGER *new_pos,
LARGE_INTEGER *new_pos, uint32_t move_method) { uint32_t move_method) {
#if _WIN32_WINNT >= _WIN32_WINNT_WINXP #if _WIN32_WINNT >= _WIN32_WINNT_WINXP
BOOL success = FALSE; BOOL success = FALSE;
success = SetFilePointerEx(handle, large_pos, new_pos, move_method); success = SetFilePointerEx(handle, large_pos, new_pos, move_method);

23
mz_strm_pkcrypt.c
View File

@ -29,19 +29,10 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_pkcrypt_vtbl = { static mz_stream_vtbl mz_stream_pkcrypt_vtbl = {
mz_stream_pkcrypt_open, mz_stream_pkcrypt_open, mz_stream_pkcrypt_is_open, mz_stream_pkcrypt_read,
mz_stream_pkcrypt_is_open, mz_stream_pkcrypt_write, mz_stream_pkcrypt_tell, mz_stream_pkcrypt_seek,
mz_stream_pkcrypt_read, mz_stream_pkcrypt_close, mz_stream_pkcrypt_error, mz_stream_pkcrypt_create,
mz_stream_pkcrypt_write, mz_stream_pkcrypt_delete, mz_stream_pkcrypt_get_prop_int64, mz_stream_pkcrypt_set_prop_int64};
mz_stream_pkcrypt_tell,
mz_stream_pkcrypt_seek,
mz_stream_pkcrypt_close,
mz_stream_pkcrypt_error,
mz_stream_pkcrypt_create,
mz_stream_pkcrypt_delete,
mz_stream_pkcrypt_get_prop_int64,
mz_stream_pkcrypt_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/
@ -63,12 +54,10 @@ typedef struct mz_stream_pkcrypt_s {
/***************************************************************************/ /***************************************************************************/
#define mz_stream_pkcrypt_decode(strm, c) \ #define mz_stream_pkcrypt_decode(strm, c) \
(mz_stream_pkcrypt_update_keys(strm, \ (mz_stream_pkcrypt_update_keys(strm, c ^= mz_stream_pkcrypt_decrypt_byte(strm)))
c ^= mz_stream_pkcrypt_decrypt_byte(strm)))
#define mz_stream_pkcrypt_encode(strm, c, t) \ #define mz_stream_pkcrypt_encode(strm, c, t) \
(t = mz_stream_pkcrypt_decrypt_byte(strm), \ (t = mz_stream_pkcrypt_decrypt_byte(strm), mz_stream_pkcrypt_update_keys(strm, (uint8_t)c), (uint8_t)(t ^ (c)))
mz_stream_pkcrypt_update_keys(strm, (uint8_t)c), (uint8_t)(t^(c)))
/***************************************************************************/ /***************************************************************************/

19
mz_strm_split.c
View File

@ -27,19 +27,9 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_split_vtbl = { static mz_stream_vtbl mz_stream_split_vtbl = {
mz_stream_split_open, mz_stream_split_open, mz_stream_split_is_open, mz_stream_split_read, mz_stream_split_write,
mz_stream_split_is_open, mz_stream_split_tell, mz_stream_split_seek, mz_stream_split_close, mz_stream_split_error,
mz_stream_split_read, mz_stream_split_create, mz_stream_split_delete, mz_stream_split_get_prop_int64, mz_stream_split_set_prop_int64};
mz_stream_split_write,
mz_stream_split_tell,
mz_stream_split_seek,
mz_stream_split_close,
mz_stream_split_error,
mz_stream_split_create,
mz_stream_split_delete,
mz_stream_split_get_prop_int64,
mz_stream_split_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/
@ -92,8 +82,7 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk) {
for (i = (int32_t)strlen(split->path_disk) - 1; i >= 0; i -= 1) { for (i = (int32_t)strlen(split->path_disk) - 1; i >= 0; i -= 1) {
if (split->path_disk[i] != '.') if (split->path_disk[i] != '.')
continue; continue;
snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i, snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i, ".z%02" PRId32, number_disk + 1);
".z%02" PRId32, number_disk + 1);
break; break;
} }
} else { } else {

20
mz_strm_wzaes.c
View File

@ -27,19 +27,9 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_wzaes_vtbl = { static mz_stream_vtbl mz_stream_wzaes_vtbl = {
mz_stream_wzaes_open, mz_stream_wzaes_open, mz_stream_wzaes_is_open, mz_stream_wzaes_read, mz_stream_wzaes_write,
mz_stream_wzaes_is_open, mz_stream_wzaes_tell, mz_stream_wzaes_seek, mz_stream_wzaes_close, mz_stream_wzaes_error,
mz_stream_wzaes_read, mz_stream_wzaes_create, mz_stream_wzaes_delete, mz_stream_wzaes_get_prop_int64, mz_stream_wzaes_set_prop_int64};
mz_stream_wzaes_write,
mz_stream_wzaes_tell,
mz_stream_wzaes_seek,
mz_stream_wzaes_close,
mz_stream_wzaes_error,
mz_stream_wzaes_create,
mz_stream_wzaes_delete,
mz_stream_wzaes_get_prop_int64,
mz_stream_wzaes_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/
@ -103,8 +93,8 @@ int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode) {
} }
/* Derive the encryption and authentication keys and the password verifier */ /* Derive the encryption and authentication keys and the password verifier */
mz_crypt_pbkdf2((uint8_t *)password, password_length, salt_value, salt_length, mz_crypt_pbkdf2((uint8_t *)password, password_length, salt_value, salt_length, MZ_AES_KEYING_ITERATIONS, kbuf,
MZ_AES_KEYING_ITERATIONS, kbuf, 2 * key_length + MZ_AES_PW_VERIFY_SIZE); 2 * key_length + MZ_AES_PW_VERIFY_SIZE);
/* Initialize the buffer pos */ /* Initialize the buffer pos */
wzaes->crypt_pos = MZ_AES_BLOCK_SIZE; wzaes->crypt_pos = MZ_AES_BLOCK_SIZE;

20
mz_strm_zlib.c
View File

@ -39,19 +39,9 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_zlib_vtbl = { static mz_stream_vtbl mz_stream_zlib_vtbl = {
mz_stream_zlib_open, mz_stream_zlib_open, mz_stream_zlib_is_open, mz_stream_zlib_read, mz_stream_zlib_write,
mz_stream_zlib_is_open, mz_stream_zlib_tell, mz_stream_zlib_seek, mz_stream_zlib_close, mz_stream_zlib_error,
mz_stream_zlib_read, mz_stream_zlib_create, mz_stream_zlib_delete, mz_stream_zlib_get_prop_int64, mz_stream_zlib_set_prop_int64};
mz_stream_zlib_write,
mz_stream_zlib_tell,
mz_stream_zlib_seek,
mz_stream_zlib_close,
mz_stream_zlib_error,
mz_stream_zlib_create,
mz_stream_zlib_delete,
mz_stream_zlib_get_prop_int64,
mz_stream_zlib_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/
@ -94,8 +84,8 @@ int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode) {
zlib->zstream.next_out = zlib->buffer; zlib->zstream.next_out = zlib->buffer;
zlib->zstream.avail_out = sizeof(zlib->buffer); zlib->zstream.avail_out = sizeof(zlib->buffer);
zlib->error = ZLIB_PREFIX(deflateInit2)(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED, zlib->error = ZLIB_PREFIX(deflateInit2)(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED, zlib->window_bits,
zlib->window_bits, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
#endif #endif
} else if (mode & MZ_OPEN_MODE_READ) { } else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION #ifdef MZ_ZIP_NO_DECOMPRESSION

16
mz_strm_zstd.c
View File

@ -19,19 +19,9 @@
/***************************************************************************/ /***************************************************************************/
static mz_stream_vtbl mz_stream_zstd_vtbl = { static mz_stream_vtbl mz_stream_zstd_vtbl = {
mz_stream_zstd_open, mz_stream_zstd_open, mz_stream_zstd_is_open, mz_stream_zstd_read, mz_stream_zstd_write,
mz_stream_zstd_is_open, mz_stream_zstd_tell, mz_stream_zstd_seek, mz_stream_zstd_close, mz_stream_zstd_error,
mz_stream_zstd_read, mz_stream_zstd_create, mz_stream_zstd_delete, mz_stream_zstd_get_prop_int64, mz_stream_zstd_set_prop_int64};
mz_stream_zstd_write,
mz_stream_zstd_tell,
mz_stream_zstd_seek,
mz_stream_zstd_close,
mz_stream_zstd_error,
mz_stream_zstd_create,
mz_stream_zstd_delete,
mz_stream_zstd_get_prop_int64,
mz_stream_zstd_set_prop_int64
};
/***************************************************************************/ /***************************************************************************/

139
mz_zip.c
View File

@ -464,8 +464,7 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
file_info->linkname = ""; file_info->linkname = "";
if (err == MZ_OK) { if (err == MZ_OK) {
mz_zip_print("Zip - Entry - Read header - %s (local %" PRId8 ")\n", mz_zip_print("Zip - Entry - Read header - %s (local %" PRId8 ")\n", file_info->filename, local);
file_info->filename, local);
mz_zip_print("Zip - Entry - Read header compress (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n", mz_zip_print("Zip - Entry - Read header compress (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n",
file_info->uncompressed_size, file_info->compressed_size, file_info->crc); file_info->uncompressed_size, file_info->compressed_size, file_info->crc);
if (!local) { if (!local) {
@ -479,7 +478,8 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
return err; return err;
} }
static int32_t mz_zip_entry_read_descriptor(void *stream, uint8_t zip64, uint32_t *crc32, int64_t *compressed_size, int64_t *uncompressed_size) { static int32_t mz_zip_entry_read_descriptor(void *stream, uint8_t zip64, uint32_t *crc32, int64_t *compressed_size,
int64_t *uncompressed_size) {
uint32_t value32 = 0; uint32_t value32 = 0;
int64_t value64 = 0; int64_t value64 = 0;
int32_t err = MZ_OK; int32_t err = MZ_OK;
@ -564,13 +564,11 @@ static int32_t mz_zip_entry_needs_zip64(mz_zip_file *file_info, uint8_t local, u
max_uncompressed_size -= MZ_ZIP_UNCOMPR_SIZE64_CUSHION; max_uncompressed_size -= MZ_ZIP_UNCOMPR_SIZE64_CUSHION;
} }
needs_zip64 = (file_info->uncompressed_size >= max_uncompressed_size) || needs_zip64 = (file_info->uncompressed_size >= max_uncompressed_size) || (file_info->compressed_size >= UINT32_MAX);
(file_info->compressed_size >= UINT32_MAX);
if (!local) { if (!local) {
/* Disk offset and number only used in central directory header */ /* Disk offset and number only used in central directory header */
needs_zip64 |= (file_info->disk_offset >= UINT32_MAX) || needs_zip64 |= (file_info->disk_offset >= UINT32_MAX) || (file_info->disk_number >= UINT16_MAX);
(file_info->disk_number >= UINT16_MAX);
} }
if (file_info->zip64 == MZ_ZIP64_AUTO) { if (file_info->zip64 == MZ_ZIP64_AUTO) {
@ -646,8 +644,7 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
file_extra_stream = mz_stream_mem_create(); file_extra_stream = mz_stream_mem_create();
if (!file_extra_stream) if (!file_extra_stream)
return MZ_MEM_ERROR; return MZ_MEM_ERROR;
mz_stream_mem_set_buffer(file_extra_stream, (void *)file_info->extrafield, mz_stream_mem_set_buffer(file_extra_stream, (void *)file_info->extrafield, file_info->extrafield_size);
file_info->extrafield_size);
do { do {
err_mem = mz_stream_read_uint16(file_extra_stream, &field_type); err_mem = mz_stream_read_uint16(file_extra_stream, &field_type);
@ -682,9 +679,8 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
MZ_UNUSED(skip_aes); MZ_UNUSED(skip_aes);
#endif #endif
/* NTFS timestamps */ /* NTFS timestamps */
if ((file_info->modified_date != 0) && if ((file_info->modified_date != 0) && (file_info->accessed_date != 0) && (file_info->creation_date != 0) &&
(file_info->accessed_date != 0) && (!mask)) {
(file_info->creation_date != 0) && (!mask)) {
field_length_ntfs = 8 + 8 + 8 + 4 + 2 + 2; field_length_ntfs = 8 + 8 + 8 + 4 + 2 + 2;
extrafield_size += 4 + field_length_ntfs; extrafield_size += 4 + field_length_ntfs;
} }
@ -747,8 +743,8 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
err = mz_zip_entry_write_crc_sizes(stream, zip64, mask, file_info); err = mz_zip_entry_write_crc_sizes(stream, zip64, mask, file_info);
if (mask) { if (mask) {
snprintf(masked_name, sizeof(masked_name), "%" PRIx32 "_%" PRIx64, snprintf(masked_name, sizeof(masked_name), "%" PRIx32 "_%" PRIx64, file_info->disk_number,
file_info->disk_number, file_info->disk_offset); file_info->disk_offset);
filename = masked_name; filename = masked_name;
} else { } else {
filename = file_info->filename; filename = file_info->filename;
@ -799,8 +795,7 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
while ((err == MZ_OK) && (backslash = strchr(next, '\\'))) { while ((err == MZ_OK) && (backslash = strchr(next, '\\'))) {
int32_t part_length = (int32_t)(backslash - next); int32_t part_length = (int32_t)(backslash - next);
if (mz_stream_write(stream, next, part_length) != part_length || if (mz_stream_write(stream, next, part_length) != part_length || mz_stream_write(stream, "/", 1) != 1)
mz_stream_write(stream, "/", 1) != 1)
err = MZ_WRITE_ERROR; err = MZ_WRITE_ERROR;
left -= part_length + 1; left -= part_length + 1;
@ -922,7 +917,8 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
return err; return err;
} }
static int32_t mz_zip_entry_write_descriptor(void *stream, uint8_t zip64, uint32_t crc32, int64_t compressed_size, int64_t uncompressed_size) { static int32_t mz_zip_entry_write_descriptor(void *stream, uint8_t zip64, uint32_t crc32, int64_t compressed_size,
int64_t uncompressed_size) {
int32_t err = MZ_OK; int32_t err = MZ_OK;
err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_DATADESCRIPTOR); err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_DATADESCRIPTOR);
@ -1280,8 +1276,8 @@ static int32_t mz_zip_recover_cd(void *handle) {
mz_stream_mem_open(local_file_info_stream, NULL, MZ_OPEN_MODE_CREATE); mz_stream_mem_open(local_file_info_stream, NULL, MZ_OPEN_MODE_CREATE);
if (err == MZ_OK) { if (err == MZ_OK) {
err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic), err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic), INT64_MAX,
INT64_MAX, &next_header_pos); &next_header_pos);
} }
while (err == MZ_OK && !eof) { while (err == MZ_OK && !eof) {
@ -1308,8 +1304,8 @@ static int32_t mz_zip_recover_cd(void *handle) {
for (;;) { for (;;) {
/* Search for the next local header */ /* Search for the next local header */
err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic), err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic), INT64_MAX,
INT64_MAX, &next_header_pos); &next_header_pos);
if (err == MZ_EXIST_ERROR) { if (err == MZ_EXIST_ERROR) {
mz_stream_seek(zip->stream, compressed_pos, MZ_SEEK_SET); mz_stream_seek(zip->stream, compressed_pos, MZ_SEEK_SET);
@ -1388,8 +1384,8 @@ static int32_t mz_zip_recover_cd(void *handle) {
mz_stream_mem_delete(&local_file_info_stream); mz_stream_mem_delete(&local_file_info_stream);
mz_zip_print("Zip - Recover - Complete (cddisk %" PRId32 " entries %" PRId64 ")\n", mz_zip_print("Zip - Recover - Complete (cddisk %" PRId32 " entries %" PRId64 ")\n", disk_number_with_cd,
disk_number_with_cd, number_entry); number_entry);
if (number_entry == 0) if (number_entry == 0)
return err; return err;
@ -1784,19 +1780,21 @@ static int32_t mz_zip_entry_open_int(void *handle, uint8_t raw, int16_t compress
else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_DEFLATE || else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_DEFLATE ||
zip->file_info.compression_method == MZ_COMPRESS_METHOD_XZ) { zip->file_info.compression_method == MZ_COMPRESS_METHOD_XZ) {
zip->compress_stream = mz_stream_libcomp_create(); zip->compress_stream = mz_stream_libcomp_create();
if (zip->compress_stream) if (zip->compress_stream) {
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_METHOD, mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_METHOD,
zip->file_info.compression_method); zip->file_info.compression_method);
} }
}
#endif #endif
#ifdef HAVE_LZMA #ifdef HAVE_LZMA
else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_LZMA || else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_LZMA ||
zip->file_info.compression_method == MZ_COMPRESS_METHOD_XZ) { zip->file_info.compression_method == MZ_COMPRESS_METHOD_XZ) {
zip->compress_stream = mz_stream_lzma_create(); zip->compress_stream = mz_stream_lzma_create();
if (zip->compress_stream) if (zip->compress_stream) {
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_METHOD, mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_COMPRESS_METHOD,
zip->file_info.compression_method); zip->file_info.compression_method);
} }
}
#endif #endif
#ifdef HAVE_ZSTD #ifdef HAVE_ZSTD
else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_ZSTD) else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_ZSTD)
@ -1816,8 +1814,7 @@ static int32_t mz_zip_entry_open_int(void *handle, uint8_t raw, int16_t compress
int32_t set_end_of_stream = 0; int32_t set_end_of_stream = 0;
#ifndef HAVE_LIBCOMP #ifndef HAVE_LIBCOMP
if (zip->entry_raw || if (zip->entry_raw || zip->file_info.compression_method == MZ_COMPRESS_METHOD_STORE ||
zip->file_info.compression_method == MZ_COMPRESS_METHOD_STORE ||
zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED) zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)
#endif #endif
{ {
@ -1843,8 +1840,10 @@ static int32_t mz_zip_entry_open_int(void *handle, uint8_t raw, int16_t compress
} }
if (set_end_of_stream) { if (set_end_of_stream) {
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX, zip->file_info.compressed_size); mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX,
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_OUT_MAX, zip->file_info.uncompressed_size); zip->file_info.compressed_size);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_OUT_MAX,
zip->file_info.uncompressed_size);
} }
} }
@ -1913,7 +1912,8 @@ int32_t mz_zip_entry_read_open(void *handle, uint8_t raw, const char *password)
return err; return err;
} }
int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info, int16_t compress_level, uint8_t raw, const char *password) { int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info, int16_t compress_level, uint8_t raw,
const char *password) {
mz_zip *zip = (mz_zip *)handle; mz_zip *zip = (mz_zip *)handle;
int64_t filename_pos = -1; int64_t filename_pos = -1;
int64_t extrafield_pos = 0; int64_t extrafield_pos = 0;
@ -1938,8 +1938,8 @@ int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info, int1
memcpy(&zip->file_info, file_info, sizeof(mz_zip_file)); memcpy(&zip->file_info, file_info, sizeof(mz_zip_file));
mz_zip_print("Zip - Entry - Write open - %s (level %" PRId16 " raw %" PRId8 ")\n", mz_zip_print("Zip - Entry - Write open - %s (level %" PRId16 " raw %" PRId8 ")\n", zip->file_info.filename,
zip->file_info.filename, compress_level, raw); compress_level, raw);
mz_stream_seek(zip->file_info_stream, 0, MZ_SEEK_SET); mz_stream_seek(zip->file_info_stream, 0, MZ_SEEK_SET);
mz_stream_write(zip->file_info_stream, file_info, sizeof(mz_zip_file)); mz_stream_write(zip->file_info_stream, file_info, sizeof(mz_zip_file));
@ -2064,12 +2064,10 @@ int32_t mz_zip_entry_write(void *handle, const void *buf, int32_t len) {
zip->entry_crc32 = mz_crypt_crc32_update(zip->entry_crc32, buf, written); zip->entry_crc32 = mz_crypt_crc32_update(zip->entry_crc32, buf, written);
mz_zip_print("Zip - Entry - Write - %" PRId32 " (max %" PRId32 ")\n", written, len); mz_zip_print("Zip - Entry - Write - %" PRId32 " (max %" PRId32 ")\n", written, len);
return written; return written;
} }
int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size, int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size, int64_t *uncompressed_size) {
int64_t *uncompressed_size) {
mz_zip *zip = (mz_zip *)handle; mz_zip *zip = (mz_zip *)handle;
int64_t total_in = 0; int64_t total_in = 0;
int32_t err = MZ_OK; int32_t err = MZ_OK;
@ -2092,26 +2090,26 @@ int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compress
mz_stream_get_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN, &total_in); mz_stream_get_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN, &total_in);
if ((zip->file_info.flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR) && if ((zip->file_info.flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR) &&
((zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO) == 0) && ((zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO) == 0) && (crc32 || compressed_size || uncompressed_size)) {
(crc32 || compressed_size || uncompressed_size)) {
/* Check to see if data descriptor is zip64 bit format or not */ /* Check to see if data descriptor is zip64 bit format or not */
if (mz_zip_extrafield_contains(zip->local_file_info.extrafield, if (mz_zip_extrafield_contains(zip->local_file_info.extrafield, zip->local_file_info.extrafield_size,
zip->local_file_info.extrafield_size, MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK) MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK) {
zip64 = 1; zip64 = 1;
}
err = mz_zip_entry_seek_local_header(handle); err = mz_zip_entry_seek_local_header(handle);
/* Seek to end of compressed stream since we might have over-read during compression */ /* Seek to end of compressed stream since we might have over-read during compression */
if (err == MZ_OK) if (err == MZ_OK) {
err = mz_stream_seek(zip->stream, MZ_ZIP_SIZE_LD_ITEM + err = mz_stream_seek(zip->stream,
(int64_t)zip->local_file_info.filename_size + MZ_ZIP_SIZE_LD_ITEM + (int64_t)zip->local_file_info.filename_size +
(int64_t)zip->local_file_info.extrafield_size + (int64_t)zip->local_file_info.extrafield_size + total_in,
total_in, MZ_SEEK_CUR); MZ_SEEK_CUR);
}
/* Read data descriptor */ /* Read data descriptor */
if (err == MZ_OK) if (err == MZ_OK)
err = mz_zip_entry_read_descriptor(zip->stream, zip64, err = mz_zip_entry_read_descriptor(zip->stream, zip64, crc32, compressed_size, uncompressed_size);
crc32, compressed_size, uncompressed_size);
} }
/* If entire entry was not read verification will fail */ /* If entire entry was not read verification will fail */
@ -2135,8 +2133,7 @@ int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compress
return err; return err;
} }
int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size, int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size, int64_t uncompressed_size) {
int64_t uncompressed_size) {
mz_zip *zip = (mz_zip *)handle; mz_zip *zip = (mz_zip *)handle;
int64_t end_disk_number = 0; int64_t end_disk_number = 0;
int32_t err = MZ_OK; int32_t err = MZ_OK;
@ -2150,8 +2147,8 @@ int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compresse
if (!zip->entry_raw) if (!zip->entry_raw)
crc32 = zip->entry_crc32; crc32 = zip->entry_crc32;
mz_zip_print("Zip - Entry - Write Close (crc 0x%08" PRIx32 " cs %" PRId64 " ucs %" PRId64 ")\n", mz_zip_print("Zip - Entry - Write Close (crc 0x%08" PRIx32 " cs %" PRId64 " ucs %" PRId64 ")\n", crc32,
crc32, compressed_size, uncompressed_size); compressed_size, uncompressed_size);
/* If sizes are not set, then read them from the compression stream */ /* If sizes are not set, then read them from the compression stream */
if (compressed_size < 0) if (compressed_size < 0)
@ -2173,17 +2170,15 @@ int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compresse
if local extrafield was saved with zip64 extrafield */ if local extrafield was saved with zip64 extrafield */
if (zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO) if (zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO)
err = mz_zip_entry_write_descriptor(zip->stream, err = mz_zip_entry_write_descriptor(zip->stream, zip64, 0, compressed_size, 0);
zip64, 0, compressed_size, 0);
else else
err = mz_zip_entry_write_descriptor(zip->stream, err = mz_zip_entry_write_descriptor(zip->stream, zip64, crc32, compressed_size, uncompressed_size);
zip64, crc32, compressed_size, uncompressed_size);
} }
/* Write file info to central directory */ /* Write file info to central directory */
mz_zip_print("Zip - Entry - Write cd (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n", mz_zip_print("Zip - Entry - Write cd (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n", uncompressed_size,
uncompressed_size, compressed_size, crc32); compressed_size, crc32);
zip->file_info.crc = crc32; zip->file_info.crc = crc32;
zip->file_info.compressed_size = compressed_size; zip->file_info.compressed_size = compressed_size;
@ -2250,12 +2245,11 @@ int32_t mz_zip_entry_seek_local_header(void *handle) {
mz_stream_set_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, disk_number); mz_stream_set_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, disk_number);
mz_zip_print("Zip - Entry - Seek local (disk %" PRId32 " offset %" PRId64 ")\n", mz_zip_print("Zip - Entry - Seek local (disk %" PRId32 " offset %" PRId64 ")\n", disk_number,
disk_number, zip->file_info.disk_offset); zip->file_info.disk_offset);
/* Guard against seek overflows */ /* Guard against seek overflows */
if ((zip->disk_offset_shift > 0) && if ((zip->disk_offset_shift > 0) && (zip->file_info.disk_offset > (INT64_MAX - zip->disk_offset_shift)))
(zip->file_info.disk_offset > (INT64_MAX - zip->disk_offset_shift)))
return MZ_FORMAT_ERROR; return MZ_FORMAT_ERROR;
return mz_stream_seek(zip->stream, zip->file_info.disk_offset + zip->disk_offset_shift, MZ_SEEK_SET); return mz_stream_seek(zip->stream, zip->file_info.disk_offset + zip->disk_offset_shift, MZ_SEEK_SET);
@ -2522,14 +2516,17 @@ int32_t mz_zip_attrib_convert(uint8_t src_sys, uint32_t src_attrib, uint8_t targ
*target_attrib = src_attrib; *target_attrib = src_attrib;
return MZ_OK; return MZ_OK;
} }
if ((target_sys == MZ_HOST_SYSTEM_UNIX) || (target_sys == MZ_HOST_SYSTEM_OSX_DARWIN) || (target_sys == MZ_HOST_SYSTEM_RISCOS)) if ((target_sys == MZ_HOST_SYSTEM_UNIX) || (target_sys == MZ_HOST_SYSTEM_OSX_DARWIN) ||
(target_sys == MZ_HOST_SYSTEM_RISCOS))
return mz_zip_attrib_win32_to_posix(src_attrib, target_attrib); return mz_zip_attrib_win32_to_posix(src_attrib, target_attrib);
} else if ((src_sys == MZ_HOST_SYSTEM_UNIX) || (src_sys == MZ_HOST_SYSTEM_OSX_DARWIN) || (src_sys == MZ_HOST_SYSTEM_RISCOS)) { } else if ((src_sys == MZ_HOST_SYSTEM_UNIX) || (src_sys == MZ_HOST_SYSTEM_OSX_DARWIN) ||
(src_sys == MZ_HOST_SYSTEM_RISCOS)) {
/* If high bytes are set, it contains unix specific attributes */ /* If high bytes are set, it contains unix specific attributes */
if ((src_attrib >> 16) != 0) if ((src_attrib >> 16) != 0)
src_attrib >>= 16; src_attrib >>= 16;
if ((target_sys == MZ_HOST_SYSTEM_UNIX) || (target_sys == MZ_HOST_SYSTEM_OSX_DARWIN) || (target_sys == MZ_HOST_SYSTEM_RISCOS)) { if ((target_sys == MZ_HOST_SYSTEM_UNIX) || (target_sys == MZ_HOST_SYSTEM_OSX_DARWIN) ||
(target_sys == MZ_HOST_SYSTEM_RISCOS)) {
*target_attrib = src_attrib; *target_attrib = src_attrib;
return MZ_OK; return MZ_OK;
} }
@ -2615,8 +2612,8 @@ int32_t mz_zip_extrafield_find(void *stream, uint16_t type, int32_t max_seek, ui
return MZ_EXIST_ERROR; return MZ_EXIST_ERROR;
} }
int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size, int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size, uint16_t type,
uint16_t type, uint16_t *length) { uint16_t *length) {
void *file_extra_stream = NULL; void *file_extra_stream = NULL;
int32_t err = MZ_OK; int32_t err = MZ_OK;
@ -2656,10 +2653,8 @@ int32_t mz_zip_extrafield_write(void *stream, uint16_t type, uint16_t length) {
static int32_t mz_zip_invalid_date(const struct tm *ptm) { static int32_t mz_zip_invalid_date(const struct tm *ptm) {
#define datevalue_in_range(min, max, value) ((min) <= (value) && (value) <= (max)) #define datevalue_in_range(min, max, value) ((min) <= (value) && (value) <= (max))
return (!datevalue_in_range(0, 127 + 80, ptm->tm_year) || /* 1980-based year, allow 80 extra */ 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(0, 11, ptm->tm_mon) || !datevalue_in_range(1, 31, ptm->tm_mday) ||
!datevalue_in_range(1, 31, ptm->tm_mday) || !datevalue_in_range(0, 23, ptm->tm_hour) || !datevalue_in_range(0, 59, ptm->tm_min) ||
!datevalue_in_range(0, 23, ptm->tm_hour) ||
!datevalue_in_range(0, 59, ptm->tm_min) ||
!datevalue_in_range(0, 59, ptm->tm_sec)); !datevalue_in_range(0, 59, ptm->tm_sec));
#undef datevalue_in_range #undef datevalue_in_range
} }
@ -2758,8 +2753,7 @@ int32_t mz_zip_unix_to_ntfs_time(time_t unix_time, uint64_t *ntfs_time) {
int32_t mz_zip_path_compare(const char *path1, const char *path2, uint8_t ignore_case) { int32_t mz_zip_path_compare(const char *path1, const char *path2, uint8_t ignore_case) {
do { do {
if ((*path1 == '\\' && *path2 == '/') || if ((*path1 == '\\' && *path2 == '/') || (*path2 == '\\' && *path1 == '/')) {
(*path2 == '\\' && *path1 == '/')) {
/* Ignore comparison of path slashes */ /* Ignore comparison of path slashes */
} else if (ignore_case) { } else if (ignore_case) {
if (tolower(*path1) != tolower(*path2)) if (tolower(*path1) != tolower(*path2))
@ -2780,8 +2774,7 @@ int32_t mz_zip_path_compare(const char *path1, const char *path2, uint8_t ignore
/***************************************************************************/ /***************************************************************************/
const char* mz_zip_get_compression_method_string(int32_t compression_method) const char *mz_zip_get_compression_method_string(int32_t compression_method) {
{
const char *method = "?"; const char *method = "?";
switch (compression_method) { switch (compression_method) {
case MZ_COMPRESS_METHOD_STORE: case MZ_COMPRESS_METHOD_STORE:

22
mz_zip.h
View File

@ -40,17 +40,14 @@ typedef struct mz_zip_file_s {
int64_t disk_offset; /* relative offset of local header */ int64_t disk_offset; /* relative offset of local header */
uint16_t internal_fa; /* internal file attributes */ uint16_t internal_fa; /* internal file attributes */
uint32_t external_fa; /* external file attributes */ uint32_t external_fa; /* external file attributes */
const char *filename; /* filename utf8 null-terminated string */ const char *filename; /* filename utf8 null-terminated string */
const uint8_t *extrafield; /* extrafield data */ const uint8_t *extrafield; /* extrafield data */
const char *comment; /* comment utf8 null-terminated string */ const char *comment; /* comment utf8 null-terminated string */
const char *linkname; /* sym-link filename utf8 null-terminated string */ const char *linkname; /* sym-link filename utf8 null-terminated string */
uint16_t zip64; /* zip64 extension mode */ uint16_t zip64; /* zip64 extension mode */
uint16_t aes_version; /* winzip aes extension if not 0 */ uint16_t aes_version; /* winzip aes extension if not 0 */
uint8_t aes_strength; /* winzip aes encryption strength */ uint8_t aes_strength; /* winzip aes encryption strength */
uint16_t pk_verify; /* pkware encryption verifier */ uint16_t pk_verify; /* pkware encryption verifier */
} mz_zip_file, mz_zip_entry; } mz_zip_file, mz_zip_entry;
/***************************************************************************/ /***************************************************************************/
@ -121,19 +118,17 @@ int32_t mz_zip_entry_read_open(void *handle, uint8_t raw, const char *password);
int32_t mz_zip_entry_read(void *handle, void *buf, int32_t len); int32_t mz_zip_entry_read(void *handle, void *buf, int32_t len);
/* Read bytes from the current file in the zip file */ /* Read bytes from the current file in the zip file */
int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size, int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size, int64_t *uncompressed_size);
int64_t *uncompressed_size);
/* Close the current file for reading and get data descriptor values */ /* Close the current file for reading and get data descriptor values */
int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info, int32_t mz_zip_entry_write_open(void *handle, const mz_zip_file *file_info, int16_t compress_level, uint8_t raw,
int16_t compress_level, uint8_t raw, const char *password); const char *password);
/* Open for writing the current file in the zip file */ /* Open for writing the current file in the zip file */
int32_t mz_zip_entry_write(void *handle, const void *buf, int32_t len); int32_t mz_zip_entry_write(void *handle, const void *buf, int32_t len);
/* Write bytes from the current file in the zip file */ /* Write bytes from the current file in the zip file */
int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size, int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size, int64_t uncompressed_size);
int64_t uncompressed_size);
/* Close the current file for writing and set data descriptor values */ /* Close the current file for writing and set data descriptor values */
int32_t mz_zip_entry_seek_local_header(void *handle); int32_t mz_zip_entry_seek_local_header(void *handle);
@ -194,8 +189,7 @@ int32_t mz_zip_attrib_is_dir(uint32_t attrib, int32_t version_madeby);
int32_t mz_zip_attrib_is_symlink(uint32_t attrib, int32_t version_madeby); int32_t mz_zip_attrib_is_symlink(uint32_t attrib, int32_t version_madeby);
/* Checks to see if the attribute is a symbolic link based on platform */ /* Checks to see if the attribute is a symbolic link based on platform */
int32_t mz_zip_attrib_convert(uint8_t src_sys, uint32_t src_attrib, uint8_t target_sys, int32_t mz_zip_attrib_convert(uint8_t src_sys, uint32_t src_attrib, uint8_t target_sys, uint32_t *target_attrib);
uint32_t *target_attrib);
/* Converts file attributes from one host system to another */ /* Converts file attributes from one host system to another */
int32_t mz_zip_attrib_posix_to_win32(uint32_t posix_attrib, uint32_t *win32_attrib); int32_t mz_zip_attrib_posix_to_win32(uint32_t posix_attrib, uint32_t *win32_attrib);
@ -209,8 +203,7 @@ int32_t mz_zip_attrib_win32_to_posix(uint32_t win32_attrib, uint32_t *posix_attr
int32_t mz_zip_extrafield_find(void *stream, uint16_t type, int32_t max_seek, uint16_t *length); int32_t mz_zip_extrafield_find(void *stream, uint16_t type, int32_t max_seek, uint16_t *length);
/* Seeks to extra field by its type and returns its length */ /* Seeks to extra field by its type and returns its length */
int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size, int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size, uint16_t type, uint16_t *length);
uint16_t type, uint16_t *length);
/* Gets whether an extrafield exists and its size */ /* Gets whether an extrafield exists and its size */
int32_t mz_zip_extrafield_read(void *stream, uint16_t *type, uint16_t *length); int32_t mz_zip_extrafield_read(void *stream, uint16_t *type, uint16_t *length);
@ -252,8 +245,7 @@ int32_t mz_zip_path_compare(const char *path1, const char *path2, uint8_t ignor
/***************************************************************************/ /***************************************************************************/
const const char *mz_zip_get_compression_method_string(int32_t compression_method);
char* mz_zip_get_compression_method_string(int32_t compression_method);
/* Gets a string representing the compression method */ /* Gets a string representing the compression method */
/***************************************************************************/ /***************************************************************************/

56
mz_zip_rw.c
View File

@ -43,18 +43,14 @@ typedef struct mz_zip_reader_s {
uint8_t pattern_ignore_case; uint8_t pattern_ignore_case;
const char *password; const char *password;
void *overwrite_userdata; void *overwrite_userdata;
mz_zip_reader_overwrite_cb mz_zip_reader_overwrite_cb overwrite_cb;
overwrite_cb;
void *password_userdata; void *password_userdata;
mz_zip_reader_password_cb mz_zip_reader_password_cb password_cb;
password_cb;
void *progress_userdata; void *progress_userdata;
mz_zip_reader_progress_cb mz_zip_reader_progress_cb progress_cb;
progress_cb;
uint32_t progress_cb_interval_ms; uint32_t progress_cb_interval_ms;
void *entry_userdata; void *entry_userdata;
mz_zip_reader_entry_cb mz_zip_reader_entry_cb entry_cb;
entry_cb;
uint8_t raw; uint8_t raw;
uint8_t buffer[UINT16_MAX]; uint8_t buffer[UINT16_MAX];
int32_t encoding; int32_t encoding;
@ -282,9 +278,10 @@ int32_t mz_zip_reader_unzip_cd(void *handle) {
mz_stream_mem_open(cd_mem_stream, NULL, MZ_OPEN_MODE_CREATE); mz_stream_mem_open(cd_mem_stream, NULL, MZ_OPEN_MODE_CREATE);
err = mz_stream_seek(cd_mem_stream, 0, MZ_SEEK_SET); err = mz_stream_seek(cd_mem_stream, 0, MZ_SEEK_SET);
if (err == MZ_OK) if (err == MZ_OK) {
err = mz_stream_copy_stream(cd_mem_stream, NULL, handle, mz_zip_reader_entry_read, err = mz_stream_copy_stream(cd_mem_stream, NULL, handle, mz_zip_reader_entry_read,
(int32_t)cd_info->uncompressed_size); (int32_t)cd_info->uncompressed_size);
}
if (err == MZ_OK) { if (err == MZ_OK) {
reader->cd_zipped = 1; reader->cd_zipped = 1;
@ -394,8 +391,7 @@ int32_t mz_zip_reader_entry_open(void *handle) {
/* Check if we need a password and ask for it if we need to */ /* Check if we need a password and ask for it if we need to */
if (!password && reader->password_cb && (reader->file_info->flag & MZ_ZIP_FLAG_ENCRYPTED)) { if (!password && reader->password_cb && (reader->file_info->flag & MZ_ZIP_FLAG_ENCRYPTED)) {
reader->password_cb(handle, reader->password_userdata, reader->file_info, reader->password_cb(handle, reader->password_userdata, reader->file_info, password_buf, sizeof(password_buf));
password_buf, sizeof(password_buf));
password = password_buf; password = password_buf;
} }
@ -673,8 +669,7 @@ int32_t mz_zip_reader_entry_save_file(void *handle, const char *path) {
mz_path_remove_filename(directory); mz_path_remove_filename(directory);
/* If it is a directory entry then create a directory instead of writing file */ /* If it is a directory entry then create a directory instead of writing file */
if ((mz_zip_entry_is_dir(reader->zip_handle) == MZ_OK) && if ((mz_zip_entry_is_dir(reader->zip_handle) == MZ_OK) && (mz_zip_entry_is_symlink(reader->zip_handle) != MZ_OK)) {
(mz_zip_entry_is_symlink(reader->zip_handle) != MZ_OK)) {
err = mz_dir_make(directory); err = mz_dir_make(directory);
goto save_cleanup; goto save_cleanup;
} }
@ -689,8 +684,7 @@ int32_t mz_zip_reader_entry_save_file(void *handle, const char *path) {
} }
/* If symbolic link then properly construct destination path and link path */ /* If symbolic link then properly construct destination path and link path */
if ((mz_zip_entry_is_symlink(reader->zip_handle) == MZ_OK) && if ((mz_zip_entry_is_symlink(reader->zip_handle) == MZ_OK) && (mz_path_has_slash(pathwfs) == MZ_OK)) {
(mz_path_has_slash(pathwfs) == MZ_OK)) {
mz_path_remove_slash(pathwfs); mz_path_remove_slash(pathwfs);
mz_path_remove_filename(directory); mz_path_remove_filename(directory);
} }
@ -754,8 +748,8 @@ int32_t mz_zip_reader_entry_save_file(void *handle, const char *path) {
if (err == MZ_OK) { if (err == MZ_OK) {
/* Set the time of the file that has been created */ /* Set the time of the file that has been created */
mz_os_set_file_date(pathwfs, reader->file_info->modified_date, mz_os_set_file_date(pathwfs, reader->file_info->modified_date, reader->file_info->accessed_date,
reader->file_info->accessed_date, reader->file_info->creation_date); reader->file_info->creation_date);
} }
if (err == MZ_OK) { if (err == MZ_OK) {
@ -1033,18 +1027,14 @@ typedef struct mz_zip_writer_s {
void *file_extra_stream; void *file_extra_stream;
mz_zip_file file_info; mz_zip_file file_info;
void *overwrite_userdata; void *overwrite_userdata;
mz_zip_writer_overwrite_cb mz_zip_writer_overwrite_cb overwrite_cb;
overwrite_cb;
void *password_userdata; void *password_userdata;
mz_zip_writer_password_cb mz_zip_writer_password_cb password_cb;
password_cb;
void *progress_userdata; void *progress_userdata;
mz_zip_writer_progress_cb mz_zip_writer_progress_cb progress_cb;
progress_cb;
uint32_t progress_cb_interval_ms; uint32_t progress_cb_interval_ms;
void *entry_userdata; void *entry_userdata;
mz_zip_writer_entry_cb mz_zip_writer_entry_cb entry_cb;
entry_cb;
const char *password; const char *password;
const char *comment; const char *comment;
uint16_t compress_method; uint16_t compress_method;
@ -1103,8 +1093,7 @@ int32_t mz_zip_writer_zip_cd(void *handle) {
err = mz_zip_writer_entry_open(handle, &cd_file); err = mz_zip_writer_entry_open(handle, &cd_file);
if (err == MZ_OK) { if (err == MZ_OK) {
mz_stream_copy_stream(handle, mz_zip_writer_entry_write, cd_mem_stream, mz_stream_copy_stream(handle, mz_zip_writer_entry_write, cd_mem_stream, NULL, (int32_t)cd_mem_length);
NULL, (int32_t)cd_mem_length);
mz_stream_seek(cd_mem_stream, 0, MZ_SEEK_SET); mz_stream_seek(cd_mem_stream, 0, MZ_SEEK_SET);
mz_stream_mem_set_buffer_limit(cd_mem_stream, 0); mz_stream_mem_set_buffer_limit(cd_mem_stream, 0);
@ -1321,8 +1310,7 @@ int32_t mz_zip_writer_entry_open(void *handle, mz_zip_file *file_info) {
/* Check if we need a password and ask for it if we need to */ /* Check if we need a password and ask for it if we need to */
if (!password && writer->password_cb && (writer->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)) { if (!password && writer->password_cb && (writer->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)) {
writer->password_cb(handle, writer->password_userdata, &writer->file_info, writer->password_cb(handle, writer->password_userdata, &writer->file_info, password_buf, sizeof(password_buf));
password_buf, sizeof(password_buf));
password = password_buf; password = password_buf;
} }
@ -1397,9 +1385,10 @@ int32_t mz_zip_writer_entry_close(void *handle) {
err = MZ_WRITE_ERROR; err = MZ_WRITE_ERROR;
} }
if ((writer->file_info.extrafield) && (writer->file_info.extrafield_size > 0)) if (writer->file_info.extrafield && writer->file_info.extrafield_size > 0) {
mz_stream_mem_write(writer->file_extra_stream, writer->file_info.extrafield, mz_stream_mem_write(writer->file_extra_stream, writer->file_info.extrafield,
writer->file_info.extrafield_size); writer->file_info.extrafield_size);
}
/* Update extra field for central directory after adding extra fields */ /* Update extra field for central directory after adding extra fields */
mz_stream_mem_get_buffer(writer->file_extra_stream, (const void **)&extrafield); mz_stream_mem_get_buffer(writer->file_extra_stream, (const void **)&extrafield);
@ -1599,8 +1588,7 @@ int32_t mz_zip_writer_add_file(void *handle, const char *path, const char *filen
if (writer->aes) if (writer->aes)
file_info.aes_version = MZ_AES_VERSION; file_info.aes_version = MZ_AES_VERSION;
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);
&file_info.creation_date);
mz_os_get_file_attribs(path, &src_attrib); mz_os_get_file_attribs(path, &src_attrib);
src_sys = MZ_HOST_SYSTEM(file_info.version_madeby); src_sys = MZ_HOST_SYSTEM(file_info.version_madeby);
@ -1636,8 +1624,8 @@ int32_t mz_zip_writer_add_file(void *handle, const char *path, const char *filen
return err; return err;
} }
int32_t mz_zip_writer_add_path(void *handle, const char *path, const char *root_path, int32_t mz_zip_writer_add_path(void *handle, const char *path, const char *root_path, uint8_t include_path,
uint8_t include_path, uint8_t recursive) { uint8_t recursive) {
mz_zip_writer *writer = (mz_zip_writer *)handle; mz_zip_writer *writer = (mz_zip_writer *)handle;
DIR *dir = NULL; DIR *dir = NULL;
struct dirent *entry = NULL; struct dirent *entry = NULL;

6
mz_zip_rw.h
View File

@ -18,7 +18,8 @@ extern "C" {
/***************************************************************************/ /***************************************************************************/
typedef int32_t (*mz_zip_reader_overwrite_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path); typedef int32_t (*mz_zip_reader_overwrite_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
typedef int32_t (*mz_zip_reader_password_cb)(void *handle, void *userdata, mz_zip_file *file_info, char *password, int32_t max_password); typedef int32_t (*mz_zip_reader_password_cb)(void *handle, void *userdata, mz_zip_file *file_info, char *password,
int32_t max_password);
typedef int32_t (*mz_zip_reader_progress_cb)(void *handle, void *userdata, mz_zip_file *file_info, int64_t position); typedef int32_t (*mz_zip_reader_progress_cb)(void *handle, void *userdata, mz_zip_file *file_info, int64_t position);
typedef int32_t (*mz_zip_reader_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path); typedef int32_t (*mz_zip_reader_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
@ -152,7 +153,8 @@ void mz_zip_reader_delete(void **handle);
/***************************************************************************/ /***************************************************************************/
typedef int32_t (*mz_zip_writer_overwrite_cb)(void *handle, void *userdata, const char *path); typedef int32_t (*mz_zip_writer_overwrite_cb)(void *handle, void *userdata, const char *path);
typedef int32_t (*mz_zip_writer_password_cb)(void *handle, void *userdata, mz_zip_file *file_info, char *password, int32_t max_password); typedef int32_t (*mz_zip_writer_password_cb)(void *handle, void *userdata, mz_zip_file *file_info, char *password,
int32_t max_password);
typedef int32_t (*mz_zip_writer_progress_cb)(void *handle, void *userdata, mz_zip_file *file_info, int64_t position); typedef int32_t (*mz_zip_writer_progress_cb)(void *handle, void *userdata, mz_zip_file *file_info, int64_t position);
typedef int32_t (*mz_zip_writer_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info); typedef int32_t (*mz_zip_writer_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info);