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

42
compat/crypt.h
View File

@ -33,51 +33,49 @@
# endif
#endif
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
#define CRC32(c, b) ((*(pcrc_32_tab + (((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
/***************************************************************************/
/* Return the next byte in the pseudo-random sequence */
static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab) {
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
* unpredictable manner on 16-bit systems; not a problem
* with any known compiler so far, though */
static int decrypt_byte(unsigned long *pkeys, const z_crc_t *pcrc_32_tab) {
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
* unpredictable manner on 16-bit systems; not a problem
* with any known compiler so far, though */
(void)pcrc_32_tab;
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
temp = ((unsigned)(*(pkeys + 2)) & 0xffff) | 2;
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
}
/***************************************************************************/
/* Update the encryption keys with the next byte of plain text */
static int update_keys(unsigned long* pkeys, const z_crc_t* pcrc_32_tab, int c) {
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
static int update_keys(unsigned long *pkeys, const z_crc_t *pcrc_32_tab, int c) {
(*(pkeys + 0)) = CRC32((*(pkeys + 0)), c);
(*(pkeys + 1)) += (*(pkeys + 0)) & 0xff;
(*(pkeys + 1)) = (*(pkeys + 1)) * 134775813L + 1;
{
register int keyshift = (int)((*(pkeys+1)) >> 24);
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
register int keyshift = (int)((*(pkeys + 1)) >> 24);
(*(pkeys + 2)) = CRC32((*(pkeys + 2)), keyshift);
}
return c;
}
/***************************************************************************/
/* Initialize the encryption keys and the random header according to the password. */
static void init_keys(const char* passwd, unsigned long* pkeys, const z_crc_t* pcrc_32_tab) {
*(pkeys+0) = 305419896L;
*(pkeys+1) = 591751049L;
*(pkeys+2) = 878082192L;
static void init_keys(const char *passwd, unsigned long *pkeys, const z_crc_t *pcrc_32_tab) {
*(pkeys + 0) = 305419896L;
*(pkeys + 1) = 591751049L;
*(pkeys + 2) = 878082192L;
while (*passwd != '\0') {
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
update_keys(pkeys, pcrc_32_tab, (int)*passwd);
passwd++;
}
}
#define zdecode(pkeys,pcrc_32_tab,c) \
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
#define zdecode(pkeys, pcrc_32_tab, c) (update_keys(pkeys, pcrc_32_tab, c ^= decrypt_byte(pkeys, pcrc_32_tab)))
#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))
#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))

32
compat/ioapi.c
View File

@ -5,9 +5,9 @@
#include "ioapi.h"
typedef struct mz_stream_ioapi_s {
mz_stream stream;
void *handle;
zlib_filefunc_def filefunc;
mz_stream stream;
void *handle;
zlib_filefunc_def filefunc;
zlib_filefunc64_def filefunc64;
} mz_stream_ioapi;
@ -24,20 +24,18 @@ static int32_t mz_stream_ioapi_error(void *stream);
/***************************************************************************/
static mz_stream_vtbl mz_stream_ioapi_vtbl = {
mz_stream_ioapi_open,
mz_stream_ioapi_is_open,
mz_stream_ioapi_read,
mz_stream_ioapi_write,
mz_stream_ioapi_tell,
mz_stream_ioapi_seek,
mz_stream_ioapi_close,
mz_stream_ioapi_error,
mz_stream_ioapi_create,
mz_stream_ioapi_delete,
NULL,
NULL
};
static mz_stream_vtbl mz_stream_ioapi_vtbl = {mz_stream_ioapi_open,
mz_stream_ioapi_is_open,
mz_stream_ioapi_read,
mz_stream_ioapi_write,
mz_stream_ioapi_tell,
mz_stream_ioapi_seek,
mz_stream_ioapi_close,
mz_stream_ioapi_error,
mz_stream_ioapi_create,
mz_stream_ioapi_delete,
NULL,
NULL};
/***************************************************************************/

77
compat/ioapi.h
View File

@ -11,7 +11,7 @@
typedef uint64_t ZPOS64_T;
#ifndef ZEXPORT
#define ZEXPORT extern
# define ZEXPORT extern
#endif
#ifdef __cplusplus
@ -20,59 +20,56 @@ extern "C" {
/***************************************************************************/
#define ZLIB_FILEFUNC_SEEK_SET (0)
#define ZLIB_FILEFUNC_SEEK_CUR (1)
#define ZLIB_FILEFUNC_SEEK_END (2)
#define ZLIB_FILEFUNC_SEEK_SET (0)
#define ZLIB_FILEFUNC_SEEK_CUR (1)
#define ZLIB_FILEFUNC_SEEK_END (2)
#define ZLIB_FILEFUNC_MODE_READ (1)
#define ZLIB_FILEFUNC_MODE_WRITE (2)
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
#define ZLIB_FILEFUNC_MODE_READ (1)
#define ZLIB_FILEFUNC_MODE_WRITE (2)
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
#define ZLIB_FILEFUNC_MODE_CREATE (8)
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
#define ZLIB_FILEFUNC_MODE_CREATE (8)
#ifndef ZCALLBACK
#define ZCALLBACK
# define ZCALLBACK
#endif
/***************************************************************************/
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 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,
unsigned long size);
typedef int (ZCALLBACK *close_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 ZPOS64_T (ZCALLBACK *tell64_file_func) (void *opaque, void *stream);
typedef long (ZCALLBACK *seek_file_func) (void *opaque, void *stream, unsigned long offset, int origin);
typedef long (ZCALLBACK *seek64_file_func) (void *opaque, void *stream, ZPOS64_T offset, int origin);
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 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, unsigned long size);
typedef int(ZCALLBACK *close_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 ZPOS64_T(ZCALLBACK *tell64_file_func)(void *opaque, void *stream);
typedef long(ZCALLBACK *seek_file_func)(void *opaque, void *stream, unsigned long offset, int origin);
typedef long(ZCALLBACK *seek64_file_func)(void *opaque, void *stream, ZPOS64_T offset, int origin);
/***************************************************************************/
typedef struct zlib_filefunc_def_s
{
open_file_func zopen_file;
read_file_func zread_file;
write_file_func zwrite_file;
tell_file_func ztell_file;
seek_file_func zseek_file;
close_file_func zclose_file;
typedef struct zlib_filefunc_def_s {
open_file_func zopen_file;
read_file_func zread_file;
write_file_func zwrite_file;
tell_file_func ztell_file;
seek_file_func zseek_file;
close_file_func zclose_file;
testerror_file_func zerror_file;
void* opaque;
void *opaque;
} zlib_filefunc_def;
typedef struct zlib_filefunc64_def_s
{
open64_file_func zopen64_file;
read_file_func zread_file;
write_file_func zwrite_file;
tell64_file_func ztell64_file;
seek64_file_func zseek64_file;
close_file_func zclose_file;
typedef struct zlib_filefunc64_def_s {
open64_file_func zopen64_file;
read_file_func zread_file;
write_file_func zwrite_file;
tell64_file_func ztell64_file;
seek64_file_func zseek64_file;
close_file_func zclose_file;
testerror_file_func zerror_file;
void* opaque;
void *opaque;
} zlib_filefunc64_def;
/***************************************************************************/
@ -101,4 +98,4 @@ void mz_stream_ioapi_delete(void **stream);
}
#endif
#endif
#endif

48
compat/unzip.c
View File

@ -23,11 +23,11 @@
/***************************************************************************/
typedef struct mz_unzip_compat_s {
void *stream;
void *handle;
void *stream;
void *handle;
uint64_t entry_index;
int64_t entry_pos;
int64_t total_out;
int64_t entry_pos;
int64_t total_out;
} mz_unzip_compat;
/***************************************************************************/
@ -41,7 +41,7 @@ unzFile unzOpen64(const void *path) {
}
unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def) {
unzFile unz = NULL;
unzFile unz = NULL;
void *stream = NULL;
if (pzlib_filefunc_def) {
@ -114,14 +114,14 @@ unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def) {
return unz;
}
void* unzGetHandle_MZ(unzFile file) {
void *unzGetHandle_MZ(unzFile file) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
if (!compat)
return NULL;
return compat->handle;
}
void* unzGetStream_MZ(unzFile file) {
void *unzGetStream_MZ(unzFile file) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
if (!compat)
return NULL;
@ -190,7 +190,7 @@ int unzClose_MZ(unzFile file) {
return err;
}
int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32) {
int unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info32) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
unz_global_info64 global_info64;
int32_t err = MZ_OK;
@ -330,9 +330,8 @@ static void unzConvertTimeToUnzTime(time_t time, tm_unz *tmu_date) {
tmu_date->tm_year += 1900;
}
int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
unsigned long filename_size, void *extrafield, unsigned long extrafield_size, char *comment,
unsigned long comment_size) {
int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, unsigned long filename_size,
void *extrafield, unsigned long extrafield_size, char *comment, unsigned long comment_size) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
mz_zip_file *file_info = NULL;
uint16_t bytes_to_copy = 0;
@ -390,9 +389,9 @@ int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filenam
return err;
}
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 comment_size) {
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 comment_size) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
mz_zip_file *file_info = NULL;
uint16_t bytes_to_copy = 0;
@ -470,11 +469,11 @@ int unzGoToNextFile(unzFile file) {
}
#if !defined(MZ_COMPAT_VERSION) || MZ_COMPAT_VERSION < 110
#ifdef WIN32
# define UNZ_DEFAULT_IGNORE_CASE 1
#else
# define UNZ_DEFAULT_IGNORE_CASE 0
#endif
# ifdef WIN32
# define UNZ_DEFAULT_IGNORE_CASE 1
# else
# define UNZ_DEFAULT_IGNORE_CASE 0
# endif
int unzLocateFile(unzFile file, const char *filename, unzFileNameCase filename_case) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
@ -513,9 +512,9 @@ int unzLocateFile(unzFile file, const char *filename, unzFileNameCase filename_c
return err;
}
#else
int unzLocateFile(unzFile file, const char* filename, unzFileNameComparer filename_compare_func) {
mz_compat* compat = (mz_compat*)file;
mz_zip_file* file_info = NULL;
int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
mz_zip_file *file_info = NULL;
uint64_t preserve_index = 0;
int32_t err = MZ_OK;
int32_t result = 0;
@ -533,8 +532,7 @@ int unzLocateFile(unzFile file, const char* filename, unzFileNameComparer filena
if ((intptr_t)filename_compare_func > 2) {
result = filename_compare_func(file, filename, file_info->filename);
}
else {
} else {
int32_t case_sensitive = (int32_t)(intptr_t)filename_compare_func;
result = mz_path_compare_wc(filename, file_info->filename, !case_sensitive);
}
@ -727,7 +725,7 @@ int unzeof(unzFile file) {
return 0;
}
void* unzGetStream(unzFile file) {
void *unzGetStream(unzFile file) {
mz_unzip_compat *compat = (mz_unzip_compat *)file;
if (!compat)
return NULL;

201
compat/unzip.h
View File

@ -19,8 +19,8 @@ extern "C" {
#include <stdint.h>
#ifndef _ZLIBIOAPI_H
#include "ioapi.h"
#ifndef _ZLIBIOAPI_H
# include "ioapi.h"
#endif
/***************************************************************************/
@ -28,7 +28,9 @@ extern "C" {
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */
typedef struct TagunzFile__ { int unused; } unzFile__;
typedef struct TagunzFile__ {
int unused;
} unzFile__;
typedef unzFile__ *unzFile;
#else
typedef void *unzFile;
@ -48,62 +50,61 @@ typedef void *unzFile;
/***************************************************************************/
#define UNZ_OK (0)
#define UNZ_END_OF_LIST_OF_FILE (-100)
#define UNZ_ERRNO (Z_ERRNO)
#define UNZ_EOF (0)
#define UNZ_PARAMERROR (-102)
#define UNZ_BADZIPFILE (-103)
#define UNZ_INTERNALERROR (-104)
#define UNZ_CRCERROR (-105)
#define UNZ_BADPASSWORD (-106) /* minizip-ng */
#define UNZ_OK (0)
#define UNZ_END_OF_LIST_OF_FILE (-100)
#define UNZ_ERRNO (Z_ERRNO)
#define UNZ_EOF (0)
#define UNZ_PARAMERROR (-102)
#define UNZ_BADZIPFILE (-103)
#define UNZ_INTERNALERROR (-104)
#define UNZ_CRCERROR (-105)
#define UNZ_BADPASSWORD (-106) /* minizip-ng */
/***************************************************************************/
/* tm_unz contain date/time info */
typedef struct tm_unz_s
{
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years - [1980..2044] */
typedef struct tm_unz_s {
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years - [1980..2044] */
} tm_unz;
/***************************************************************************/
/* Global data about the zip from end of central dir */
typedef struct unz_global_info64_s {
uint64_t number_entry; /* total number of entries in the central dir on this disk */
unsigned long size_comment; /* size of the global comment of the zipfile */
uint64_t number_entry; /* total number of entries in the central dir on this disk */
unsigned long size_comment; /* size of the global comment of the zipfile */
/* minizip-ng fields */
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
} unz_global_info64;
typedef struct unz_global_info_s {
unsigned long number_entry; /* total number of entries in the central dir on this disk */
unsigned long size_comment; /* size of the global comment of the zipfile */
unsigned long number_entry; /* total number of entries in the central dir on this disk */
unsigned long size_comment; /* size of the global comment of the zipfile */
/* minizip-ng fields */
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
} unz_global_info;
/* Information about a file in the zip */
typedef struct unz_file_info64_s {
unsigned long version; /* version made by 2 bytes */
unsigned long version_needed; /* version needed to extract 2 bytes */
unsigned long flag; /* general purpose bit flag 2 bytes */
unsigned long compression_method; /* compression method 2 bytes */
unsigned long mz_dos_date; /* last mod file date in Dos fmt 4 bytes */
unsigned long crc; /* crc-32 4 bytes */
ZPOS64_T compressed_size; /* compressed size 8 bytes */
ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */
unsigned long size_filename; /* filename length 2 bytes */
unsigned long size_file_extra; /* extra field length 2 bytes */
unsigned long size_file_comment; /* file comment length 2 bytes */
unsigned long version; /* version made by 2 bytes */
unsigned long version_needed; /* version needed to extract 2 bytes */
unsigned long flag; /* general purpose bit flag 2 bytes */
unsigned long compression_method; /* compression method 2 bytes */
unsigned long mz_dos_date; /* last mod file date in Dos fmt 4 bytes */
unsigned long crc; /* crc-32 4 bytes */
ZPOS64_T compressed_size; /* compressed size 8 bytes */
ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */
unsigned long size_filename; /* filename length 2 bytes */
unsigned long size_file_extra; /* extra field length 2 bytes */
unsigned long size_file_comment; /* file comment length 2 bytes */
unsigned long disk_num_start; /* disk number start 4 bytes */
unsigned long internal_fa; /* internal file attributes 2 bytes */
unsigned long external_fa; /* external file attributes 4 bytes */
unsigned long disk_num_start; /* disk number start 4 bytes */
unsigned long internal_fa; /* internal file attributes 2 bytes */
unsigned long external_fa; /* external file attributes 4 bytes */
tm_unz tmu_date;
@ -113,21 +114,21 @@ typedef struct unz_file_info64_s {
} unz_file_info64;
typedef struct unz_file_info_s {
unsigned long version; /* version made by 2 bytes */
unsigned long version_needed; /* version needed to extract 2 bytes */
unsigned long flag; /* general purpose bit flag 2 bytes */
unsigned long compression_method; /* compression method 2 bytes */
unsigned long mz_dos_date; /* last mod file date in Dos fmt 4 bytes */
unsigned long crc; /* crc-32 4 bytes */
ZPOS64_T compressed_size; /* compressed size 4 bytes */
ZPOS64_T uncompressed_size; /* uncompressed size 4 bytes */
unsigned long size_filename; /* filename length 2 bytes */
unsigned long size_file_extra; /* extra field length 2 bytes */
unsigned long size_file_comment; /* file comment length 2 bytes */
unsigned long version; /* version made by 2 bytes */
unsigned long version_needed; /* version needed to extract 2 bytes */
unsigned long flag; /* general purpose bit flag 2 bytes */
unsigned long compression_method; /* compression method 2 bytes */
unsigned long mz_dos_date; /* last mod file date in Dos fmt 4 bytes */
unsigned long crc; /* crc-32 4 bytes */
ZPOS64_T compressed_size; /* compressed size 4 bytes */
ZPOS64_T uncompressed_size; /* uncompressed size 4 bytes */
unsigned long size_filename; /* filename length 2 bytes */
unsigned long size_file_extra; /* extra field length 2 bytes */
unsigned long size_file_comment; /* file comment length 2 bytes */
unsigned long disk_num_start; /* disk number start 2 bytes */
unsigned long internal_fa; /* internal file attributes 2 bytes */
unsigned long external_fa; /* external file attributes 4 bytes */
unsigned long disk_num_start; /* disk number start 2 bytes */
unsigned long internal_fa; /* internal file attributes 2 bytes */
unsigned long external_fa; /* external file attributes 4 bytes */
tm_unz tmu_date;
@ -145,12 +146,11 @@ typedef struct unz_file_info_s {
*/
typedef int unzFileNameCase;
#else
typedef int (*unzFileNameComparer)(unzFile file, const char* filename1, const char* filename2);
typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);
#endif
typedef int (*unzIteratorFunction)(unzFile file);
typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment,
uint16_t comment_size);
typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename, uint16_t filename_size,
void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
/***************************************************************************/
/* Reading a zip file */
@ -160,73 +160,72 @@ ZEXPORT unzFile unzOpen(const char *path);
ZEXPORT unzFile unzOpen64(const void *path);
ZEXPORT unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def);
ZEXPORT unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def);
ZEXPORT int unzClose(unzFile file);
ZEXPORT int unzClose(unzFile file);
ZEXPORT int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32);
ZEXPORT int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info);
ZEXPORT int unzGetGlobalComment(unzFile file, char *comment, unsigned long comment_size);
ZEXPORT int unzOpenCurrentFile(unzFile file);
ZEXPORT int unzOpenCurrentFilePassword(unzFile file, const char *password);
ZEXPORT int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);
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 unzCloseCurrentFile(unzFile file);
ZEXPORT int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
unsigned long filename_size, void *extrafield, unsigned long extrafield_size, char *comment,
unsigned long comment_size);
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 comment_size);
ZEXPORT int unzGoToFirstFile(unzFile file);
ZEXPORT int unzGoToNextFile(unzFile file);
ZEXPORT int unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info32);
ZEXPORT int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info);
ZEXPORT int unzGetGlobalComment(unzFile file, char *comment, unsigned long comment_size);
ZEXPORT int unzOpenCurrentFile(unzFile file);
ZEXPORT int unzOpenCurrentFilePassword(unzFile file, const char *password);
ZEXPORT int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);
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 unzCloseCurrentFile(unzFile file);
ZEXPORT int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, unsigned long filename_size,
void *extrafield, unsigned long extrafield_size, char *comment,
unsigned long comment_size);
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 comment_size);
ZEXPORT int unzGoToFirstFile(unzFile file);
ZEXPORT int unzGoToNextFile(unzFile file);
#if !defined(MZ_COMPAT_VERSION) || MZ_COMPAT_VERSION < 110
ZEXPORT int unzLocateFile(unzFile file, const char *filename, unzFileNameCase filename_case);
ZEXPORT int unzLocateFile(unzFile file, const char *filename, unzFileNameCase filename_case);
#else
ZEXPORT int unzLocateFile(unzFile file, const char* filename, unzFileNameComparer filename_compare_func);
ZEXPORT int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);
#endif
/* unzStringFileNameCompare is too new */
ZEXPORT int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len);
ZEXPORT int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len);
/* Compatibility layer with older minizip-ng (mz_unzip.h). */
unzFile unzOpen_MZ(void *stream);
ZEXPORT int unzClose_MZ(unzFile file);
ZEXPORT void* unzGetHandle_MZ(unzFile file);
ZEXPORT void* unzGetStream_MZ(unzFile file);
unzFile unzOpen_MZ(void *stream);
ZEXPORT int unzClose_MZ(unzFile file);
ZEXPORT void *unzGetHandle_MZ(unzFile file);
ZEXPORT void *unzGetStream_MZ(unzFile file);
/***************************************************************************/
/* Raw access to zip file */
typedef struct unz_file_pos_s {
uint32_t pos_in_zip_directory; /* offset in zip file directory */
uint32_t num_of_file; /* # of file */
uint32_t pos_in_zip_directory; /* offset in zip file directory */
uint32_t num_of_file; /* # of file */
} unz_file_pos;
typedef struct unz64_file_pos_s {
int64_t pos_in_zip_directory; /* offset in zip file directory */
uint64_t num_of_file; /* # of file */
int64_t pos_in_zip_directory; /* offset in zip file directory */
uint64_t num_of_file; /* # of file */
} unz64_file_pos;
/* Compatibility layer with the original minizip library (unzip.h). */
ZEXPORT int unzGetFilePos(unzFile file, unz_file_pos *file_pos);
ZEXPORT int unzGoToFilePos(unzFile file, unz_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 unzGetFilePos(unzFile file, unz_file_pos *file_pos);
ZEXPORT int unzGoToFilePos(unzFile file, unz_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 int64_t unzGetOffset64(unzFile file);
ZEXPORT unsigned long
unzGetOffset(unzFile file);
ZEXPORT int unzSetOffset64(unzFile file, int64_t pos);
ZEXPORT int unzSetOffset(unzFile file, unsigned long pos);
ZEXPORT unsigned long unzGetOffset(unzFile file);
ZEXPORT int unzSetOffset64(unzFile file, int64_t pos);
ZEXPORT int unzSetOffset(unzFile file, unsigned long pos);
ZEXPORT int32_t unztell(unzFile file);
ZEXPORT uint64_t unztell64(unzFile file);
ZEXPORT int unzeof(unzFile file);
ZEXPORT int unzeof(unzFile file);
/* Compatibility layer with older minizip-ng (mz_unzip.h). */
ZEXPORT int32_t unzTell(unzFile file);
ZEXPORT uint64_t unzTell64(unzFile file);
ZEXPORT int unzSeek(unzFile file, int32_t offset, int origin);
ZEXPORT int unzSeek64(unzFile file, int64_t offset, int origin);
ZEXPORT int unzEndOfFile(unzFile file);
ZEXPORT void* unzGetStream(unzFile file);
ZEXPORT int unzSeek(unzFile file, int32_t offset, int origin);
ZEXPORT int unzSeek64(unzFile file, int64_t offset, int origin);
ZEXPORT int unzEndOfFile(unzFile file);
ZEXPORT void *unzGetStream(unzFile file);
/***************************************************************************/
@ -234,4 +233,4 @@ ZEXPORT void* unzGetStream(unzFile file);
}
#endif
#endif /* _unz64_H */
#endif /* _unz64_H */

149
compat/zip.c
View File

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

176
compat/zip.h
View File

@ -20,7 +20,7 @@ extern "C" {
#include <stdint.h>
#ifndef _ZLIBIOAPI_H
#include "ioapi.h"
# include "ioapi.h"
#endif
/***************************************************************************/
@ -28,7 +28,9 @@ extern "C" {
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */
typedef struct TagzipFile__ { int unused; } zipFile__;
typedef struct TagzipFile__ {
int unused;
} zipFile__;
typedef zipFile__ *zipFile;
#else
typedef void *zipFile;
@ -46,12 +48,12 @@ typedef void *zipFile;
#define Z_BZIP2ED (12)
#endif
#define ZIP_OK (0)
#define ZIP_EOF (0)
#define ZIP_ERRNO (Z_ERRNO)
#define ZIP_PARAMERROR (-102)
#define ZIP_BADZIPFILE (-103)
#define ZIP_INTERNALERROR (-104)
#define ZIP_OK (0)
#define ZIP_EOF (0)
#define ZIP_ERRNO (Z_ERRNO)
#define ZIP_PARAMERROR (-102)
#define ZIP_BADZIPFILE (-103)
#define ZIP_INTERNALERROR (-104)
/***************************************************************************/
/* default memLevel */
@ -59,42 +61,41 @@ typedef void *zipFile;
# if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8
# else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
# endif
#endif
/***************************************************************************/
/* tm_zip contain date/time info */
typedef struct tm_zip_s
{
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years - [1980..2044] */
typedef struct tm_zip_s {
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years - [1980..2044] */
} tm_zip;
/***************************************************************************/
#if !defined(MZ_COMPAT_VERSION) || MZ_COMPAT_VERSION <= 110
#define mz_dos_date dosDate
# define mz_dos_date dosDate
#else
#define mz_dos_date dos_date
# define mz_dos_date dos_date
#endif
typedef struct {
tm_zip tmz_date; /* date in understandable format */
unsigned long mz_dos_date; /* if dos_date == 0, tmz_date is used */
unsigned long internal_fa; /* internal file attributes 2 bytes */
unsigned long external_fa; /* external file attributes 4 bytes */
tm_zip tmz_date; /* date in understandable format */
unsigned long mz_dos_date; /* if dos_date == 0, tmz_date is used */
unsigned long internal_fa; /* internal file attributes 2 bytes */
unsigned long external_fa; /* external file attributes 4 bytes */
} zip_fileinfo;
typedef const char* zipcharpc;
typedef const char *zipcharpc;
#define APPEND_STATUS_CREATE (0)
#define APPEND_STATUS_CREATEAFTER (1)
#define APPEND_STATUS_ADDINZIP (2)
#define APPEND_STATUS_CREATE (0)
#define APPEND_STATUS_CREATEAFTER (1)
#define APPEND_STATUS_ADDINZIP (2)
/***************************************************************************/
/* Writing a zip file */
@ -103,73 +104,76 @@ typedef const char* zipcharpc;
ZEXPORT zipFile zipOpen(const char *path, int append);
ZEXPORT zipFile zipOpen64(const void *path, int append);
ZEXPORT zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment,
zlib_filefunc_def *pzlib_filefunc_def);
ZEXPORT zipFile zipOpen2(const char *path, int append, zipcharpc *globalcomment, zlib_filefunc_def *pzlib_filefunc_def);
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 */
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,
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,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int zip64);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int zip64);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
unsigned long crc_for_crypting);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
unsigned long crc_for_crypting, int zip64);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, 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,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
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);
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 zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, unsigned long crc32);
ZEXPORT int zipCloseFileInZip(zipFile file);
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, 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,
const void *extrafield_local, uint16_t size_extrafield_local,
const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int zip64);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int raw);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int raw, int zip64);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int raw, int windowBits, int memLevel, int strategy,
const char *password, unsigned long crc_for_crypting);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int raw, int windowBits, int memLevel,
int strategy, const char *password, unsigned long crc_for_crypting, int zip64);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int raw, int windowBits, int memLevel, int strategy,
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,
const void *extrafield_local, uint16_t size_extrafield_local,
const void *extrafield_global, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, 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);
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 zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, unsigned long crc32);
ZEXPORT int zipCloseFileInZip(zipFile file);
/* zipAlreadyThere is too new */
ZEXPORT int zipClose(zipFile file, const char *global_comment);
ZEXPORT int zipClose(zipFile file, const char *global_comment);
/* zipRemoveExtraInfoBlock is not supported */
/* Compatibility layer with older minizip-ng (mz_zip.h). */
ZEXPORT zipFile zipOpen_MZ(void *stream, int append, zipcharpc *globalcomment);
ZEXPORT void* zipGetHandle_MZ(zipFile);
ZEXPORT void* zipGetStream_MZ(zipFile file);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
int zip64);
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,
uint16_t size_extrafield_global, const char *comment, int compression_method, int level,
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);
ZEXPORT int zipCloseFileInZip64(zipFile file);
ZEXPORT int zipClose_64(zipFile file, const char *global_comment);
ZEXPORT int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby);
int zipClose_MZ(zipFile file, const char *global_comment);
int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_madeby);
ZEXPORT void *zipGetHandle_MZ(zipFile);
ZEXPORT void *zipGetStream_MZ(zipFile file);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, int zip64);
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, uint16_t size_extrafield_global, const char *comment,
int compression_method, int level, 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);
ZEXPORT int zipCloseFileInZip64(zipFile file);
ZEXPORT int zipClose_64(zipFile file, const char *global_comment);
ZEXPORT int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby);
int zipClose_MZ(zipFile file, const char *global_comment);
int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_madeby);
#ifdef __cplusplus
}

58
minizip.c
View File

@ -18,23 +18,23 @@
#include "mz_zip.h"
#include "mz_zip_rw.h"
#include <stdio.h> /* printf */
#include <stdio.h> /* printf */
/***************************************************************************/
typedef struct minizip_opt_s {
uint8_t include_path;
int16_t compress_level;
uint8_t compress_method;
uint8_t overwrite;
uint8_t append;
int64_t disk_size;
uint8_t follow_links;
uint8_t store_links;
uint8_t zip_cd;
int32_t encoding;
uint8_t verbose;
uint8_t aes;
uint8_t include_path;
int16_t compress_level;
uint8_t compress_method;
uint8_t overwrite;
uint8_t append;
int64_t disk_size;
uint8_t follow_links;
uint8_t store_links;
uint8_t zip_cd;
int32_t encoding;
uint8_t verbose;
uint8_t aes;
} minizip_opt;
/***************************************************************************/
@ -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_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(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);
@ -148,14 +149,11 @@ int32_t minizip_list(const char *path) {
mz_zip_time_t_to_tm(file_info->modified_date, &tmu_date);
/* Print entry information */
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 " %8.8" PRIx32 " %s\n",
file_info->compressed_size, file_info->uncompressed_size, ratio,
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_hour, (uint32_t)tmu_date.tm_min,
file_info->crc, file_info->filename);
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 " %8.8" PRIx32 " %s\n",
file_info->compressed_size, file_info->uncompressed_size, ratio, 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_hour, (uint32_t)tmu_date.tm_min, file_info->crc, file_info->filename);
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;
/* Print the progress of the current compress operation */
if (options->verbose)
if (options->verbose) {
printf("%s - %" PRId64 " / %" PRId64 " (%.02f%%)\n", file_info->filename, position,
file_info->uncompressed_size, progress);
file_info->uncompressed_size, progress);
}
return MZ_OK;
}
@ -234,7 +233,8 @@ int32_t minizip_add_overwrite_cb(void *handle, void *userdata, const char *path)
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;
int32_t err = 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;
/* Print the progress of the current extraction */
if (options->verbose)
if (options->verbose) {
printf("%s - %" PRId64 " / %" PRId64 " (%.02f%%)\n", file_info->filename, position,
file_info->uncompressed_size, progress);
file_info->uncompressed_size, progress);
}
return MZ_OK;
}
@ -347,7 +348,8 @@ int32_t minizip_extract_overwrite_cb(void *handle, void *userdata, mz_zip_file *
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;
int32_t err = MZ_OK;
int32_t err_close = MZ_OK;

79
mz_crypt.c
View File

@ -34,7 +34,7 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size) {
#if defined(HAVE_ZLIB)
/* Define z_crc_t in zlib 1.2.5 and less or if using zlib-ng */
/* Define z_crc_t in zlib 1.2.5 and less or if using zlib-ng */
# if (ZLIB_VERNUM < 0x1270)
typedef unsigned long z_crc_t;
# else
@ -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);
#else
static uint32_t crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
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
};
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
0x41047a60, 0xdf60efc3, 0xa867df55, 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;
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)
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt,
int32_t salt_length, uint32_t iteration_count, uint8_t *key, uint16_t key_length) {
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt, int32_t salt_length,
uint32_t iteration_count, uint8_t *key, uint16_t key_length) {
void *hmac1 = NULL;
void *hmac2 = NULL;
void *hmac3 = NULL;

60
mz_crypt.h
View File

@ -19,42 +19,42 @@ extern "C" {
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 salt_length, uint32_t iteration_count, uint8_t *key, uint16_t key_length);
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt, int32_t salt_length,
uint32_t iteration_count, uint8_t *key, uint16_t key_length);
/***************************************************************************/
int32_t mz_crypt_rand(uint8_t *buf, int32_t size);
int32_t mz_crypt_rand(uint8_t *buf, int32_t size);
void mz_crypt_sha_reset(void *handle);
int32_t mz_crypt_sha_begin(void *handle);
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size);
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size);
int32_t mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm);
void* mz_crypt_sha_create(void);
void mz_crypt_sha_delete(void **handle);
void mz_crypt_sha_reset(void *handle);
int32_t mz_crypt_sha_begin(void *handle);
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size);
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size);
int32_t mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm);
void *mz_crypt_sha_create(void);
void mz_crypt_sha_delete(void **handle);
void mz_crypt_aes_reset(void *handle);
int32_t mz_crypt_aes_encrypt(void *handle, const void *aad, int32_t aad_size, uint8_t *buf, int32_t 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_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,
const void *iv, int32_t iv_length);
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length);
void mz_crypt_aes_set_mode(void *handle, int32_t mode);
void* mz_crypt_aes_create(void);
void mz_crypt_aes_delete(void **handle);
void mz_crypt_aes_reset(void *handle);
int32_t mz_crypt_aes_encrypt(void *handle, const void *aad, int32_t aad_size, uint8_t *buf, int32_t 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_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, const void *iv,
int32_t iv_length);
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length);
void mz_crypt_aes_set_mode(void *handle, int32_t mode);
void *mz_crypt_aes_create(void);
void mz_crypt_aes_delete(void **handle);
void mz_crypt_hmac_reset(void *handle);
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length);
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size);
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size);
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle);
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm);
void* mz_crypt_hmac_create(void);
void mz_crypt_hmac_delete(void **handle);
void mz_crypt_hmac_reset(void *handle);
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length);
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size);
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size);
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle);
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm);
void *mz_crypt_hmac_create(void);
void mz_crypt_hmac_delete(void **handle);
/***************************************************************************/

42
mz_crypt_apple.c
View File

@ -21,7 +21,7 @@
/***************************************************************************/
#ifndef MZ_TARGET_APPSTORE
#define MZ_TARGET_APPSTORE 1
# define MZ_TARGET_APPSTORE 1
#endif
/* Avoid use of private API for App Store as Apple does not allow it. Zip format doesn't need GCM. */
@ -50,21 +50,19 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
typedef struct mz_crypt_sha_s {
union {
CC_SHA1_CTX ctx1;
CC_SHA1_CTX ctx1;
CC_SHA256_CTX ctx256;
CC_SHA512_CTX ctx512;
};
int32_t error;
int32_t initialized;
uint16_t algorithm;
int32_t error;
int32_t initialized;
uint16_t algorithm;
} mz_crypt_sha;
/***************************************************************************/
static const uint8_t mz_crypt_sha_digest_size[] = {
MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE,
MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE
};
MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE, MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE};
/***************************************************************************/
@ -205,8 +203,8 @@ void mz_crypt_sha_delete(void **handle) {
typedef struct mz_crypt_aes_s {
CCCryptorRef crypt;
int32_t mode;
int32_t error;
int32_t mode;
int32_t error;
} mz_crypt_aes;
/***************************************************************************/
@ -347,8 +345,8 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
#endif
}
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length, CCOperation op) {
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length, CCOperation op) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
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);
aes->error = CCCryptorCreateWithMode(op, mode, kCCAlgorithmAES, ccNoPadding, iv, key, key_length,
NULL, 0, 0, 0, &aes->crypt);
aes->error = CCCryptorCreateWithMode(op, mode, kCCAlgorithmAES, ccNoPadding, iv, key, key_length, NULL, 0, 0, 0,
&aes->crypt);
if (aes->error != kCCSuccess)
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;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
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,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length, kCCDecrypt);
}
@ -420,10 +418,10 @@ void mz_crypt_aes_delete(void **handle) {
/***************************************************************************/
typedef struct mz_crypt_hmac_s {
CCHmacContext ctx;
int32_t initialized;
int32_t error;
uint16_t algorithm;
CCHmacContext ctx;
int32_t initialized;
int32_t error;
uint16_t algorithm;
} mz_crypt_hmac;
/***************************************************************************/

44
mz_crypt_openssl.c
View File

@ -59,22 +59,20 @@ typedef struct mz_crypt_sha_s {
union {
SHA512_CTX ctx512;
SHA256_CTX ctx256;
SHA_CTX ctx1;
SHA_CTX ctx1;
};
#else
EVP_MD_CTX *ctx;
EVP_MD_CTX *ctx;
#endif
int32_t initialized;
unsigned long error;
uint16_t algorithm;
int32_t initialized;
unsigned long error;
uint16_t algorithm;
} mz_crypt_sha;
/***************************************************************************/
static const uint8_t mz_crypt_sha_digest_size[] = {
MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE,
MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE
};
MZ_HASH_SHA1_SIZE, 0, MZ_HASH_SHA224_SIZE, MZ_HASH_SHA256_SIZE, MZ_HASH_SHA384_SIZE, MZ_HASH_SHA512_SIZE};
/***************************************************************************/
@ -269,8 +267,8 @@ void mz_crypt_sha_delete(void **handle) {
/***************************************************************************/
typedef struct mz_crypt_aes_s {
int32_t mode;
unsigned long error;
int32_t mode;
unsigned long error;
EVP_CIPHER_CTX *ctx;
} mz_crypt_aes;
@ -382,8 +380,8 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
return size;
}
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length, int32_t encrypt) {
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length, int32_t encrypt) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
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;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
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);
}
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (!aes || !key || !key_length)
@ -488,19 +486,19 @@ void mz_crypt_aes_delete(void **handle) {
typedef struct mz_crypt_hmac_s {
#if OPENSSL_VERSION_NUMBER < 0x30000000L
HMAC_CTX *ctx;
HMAC_CTX *ctx;
#else
EVP_MAC *mac;
EVP_MAC_CTX *ctx;
EVP_MAC *mac;
EVP_MAC_CTX *ctx;
#endif
int32_t initialized;
unsigned long error;
uint16_t algorithm;
int32_t initialized;
unsigned long error;
uint16_t algorithm;
} mz_crypt_hmac;
/***************************************************************************/
#if (OPENSSL_VERSION_NUMBER < 0x10100000L) || \
#if (OPENSSL_VERSION_NUMBER < 0x10100000L) || \
(defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER < 0x2070000fL))
static HMAC_CTX *HMAC_CTX_new(void) {
HMAC_CTX *ctx = OPENSSL_malloc(sizeof(HMAC_CTX));

104
mz_crypt_winvista.c
View File

@ -19,11 +19,11 @@
#endif
#if _WIN32_WINNT >= _WIN32_WINNT_VISTA
#include <bcrypt.h>
# include <bcrypt.h>
/***************************************************************************/
#define NT_SUCCESS(status) ((status) >= 0)
# define NT_SUCCESS(status) ((status) >= 0)
/***************************************************************************/
@ -47,13 +47,13 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
typedef struct mz_crypt_sha_s {
union {
struct {
BCRYPT_ALG_HANDLE provider;
BCRYPT_ALG_HANDLE provider;
BCRYPT_HASH_HANDLE hash;
uint8_t *buffer;
uint8_t *buffer;
};
};
int32_t error;
uint16_t algorithm;
int32_t error;
uint16_t algorithm;
} mz_crypt_sha;
/***************************************************************************/
@ -104,8 +104,8 @@ int32_t mz_crypt_sha_begin(void *handle) {
status = BCryptOpenAlgorithmProvider(&sha->provider, alg_id, NULL, 0);
if (NT_SUCCESS(status)) {
status = BCryptGetProperty(sha->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size,
&result_size, 0);
status =
BCryptGetProperty(sha->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size, &result_size, 0);
}
if (NT_SUCCESS(status)) {
sha->buffer = malloc(buffer_size);
@ -134,7 +134,7 @@ int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
if (sha->hash == 0)
return MZ_PARAM_ERROR;
status = BCryptHashData(sha->hash, (uint8_t*)buf, size, 0);
status = BCryptHashData(sha->hash, (uint8_t *)buf, size, 0);
if (!NT_SUCCESS(status)) {
sha->error = status;
return MZ_HASH_ERROR;
@ -199,22 +199,22 @@ void mz_crypt_sha_delete(void **handle) {
/***************************************************************************/
#define MZ_AES_MAX_TAG_SIZE (16)
#define MZ_AES_MAX_NONCE_SIZE (12)
# define MZ_AES_MAX_TAG_SIZE (16)
# define MZ_AES_MAX_NONCE_SIZE (12)
typedef struct mz_crypt_aes_s {
BCRYPT_ALG_HANDLE provider;
BCRYPT_KEY_HANDLE key;
uint8_t *key_buffer;
int32_t mode;
int32_t error;
uint8_t *iv;
uint32_t iv_length;
uint8_t nonce[MZ_AES_MAX_NONCE_SIZE];
uint32_t nonce_length;
uint8_t mac[MZ_AES_MAX_TAG_SIZE];
uint8_t tag[MZ_AES_MAX_TAG_SIZE];
uint32_t tag_size;
uint8_t *key_buffer;
int32_t mode;
int32_t error;
uint8_t *iv;
uint32_t iv_length;
uint8_t nonce[MZ_AES_MAX_NONCE_SIZE];
uint32_t nonce_length;
uint8_t mac[MZ_AES_MAX_TAG_SIZE];
uint8_t tag[MZ_AES_MAX_TAG_SIZE];
uint32_t tag_size;
BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *auth_info;
} mz_crypt_aes;
@ -253,12 +253,11 @@ int32_t mz_crypt_aes_encrypt(void *handle, const void *aad, int32_t aad_size, ui
return MZ_PARAM_ERROR;
if (aad && aes->auth_info && !(aes->auth_info->dwFlags & BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG)) {
aes->auth_info->pbAuthData = (uint8_t*)aad;
aes->auth_info->pbAuthData = (uint8_t *)aad;
aes->auth_info->cbAuthData = aad_size;
}
status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size,
&output_size, 0);
status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
if (aad && aes->auth_info) {
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;
status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size,
&output_size, 0);
status = BCryptEncrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
if (!NT_SUCCESS(status)) {
aes->error = status;
@ -309,12 +307,11 @@ int32_t mz_crypt_aes_decrypt(void *handle, const void *aad, int32_t aad_size, ui
return MZ_PARAM_ERROR;
if (aad && aes->auth_info && !(aes->auth_info->dwFlags & BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG)) {
aes->auth_info->pbAuthData = (uint8_t*)aad;
aes->auth_info->pbAuthData = (uint8_t *)aad;
aes->auth_info->cbAuthData = aad_size;
}
status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size,
&output_size, 0);
status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
if (aad && aes->auth_info) {
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;
status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size,
&output_size, 0);
status = BCryptDecrypt(aes->key, buf, size, aes->auth_info, aes->iv, aes->iv_length, buf, size, &output_size, 0);
if (!NT_SUCCESS(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;
}
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
BCRYPT_KEY_DATA_BLOB_HEADER *key_blob = NULL;
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)) {
ULONG result_size;
status = BCryptGetProperty(aes->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&key_size,
sizeof(key_size), &result_size, 0);
status = BCryptGetProperty(aes->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&key_size, sizeof(key_size),
&result_size, 0);
}
if (NT_SUCCESS(status)) {
@ -414,10 +410,10 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
key_blob->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
key_blob->cbKeyData = key_length;
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,
key_size, (PUCHAR)key_blob, key_blob_size, 0);
status = BCryptImportKey(aes->provider, NULL, BCRYPT_KEY_DATA_BLOB, &aes->key, aes->key_buffer, key_size,
(PUCHAR)key_blob, key_blob_size, 0);
SecureZeroMemory(key_blob, key_blob_size);
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)) {
BCRYPT_AUTH_TAG_LENGTHS_STRUCT tag_lengths;
status = BCryptGetProperty(aes->provider, BCRYPT_AUTH_TAG_LENGTH, (PUCHAR)&tag_lengths,
sizeof(tag_lengths), &result_size, 0);
status = BCryptGetProperty(aes->provider, BCRYPT_AUTH_TAG_LENGTH, (PUCHAR)&tag_lengths, sizeof(tag_lengths),
&result_size, 0);
if (NT_SUCCESS(status)) {
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)) {
ULONG block_length;
status = BCryptGetProperty(aes->provider, BCRYPT_BLOCK_LENGTH, (PUCHAR)&block_length,
sizeof(block_length), &result_size, 0);
status = BCryptGetProperty(aes->provider, BCRYPT_BLOCK_LENGTH, (PUCHAR)&block_length, sizeof(block_length),
&result_size, 0);
if (NT_SUCCESS(status) && iv) {
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;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t 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,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length);
}
@ -514,12 +510,12 @@ void mz_crypt_aes_delete(void **handle) {
/***************************************************************************/
typedef struct mz_crypt_hmac_s {
BCRYPT_ALG_HANDLE provider;
BCRYPT_KEY_HANDLE key;
BCRYPT_ALG_HANDLE provider;
BCRYPT_KEY_HANDLE key;
BCRYPT_HASH_HANDLE hash;
uint8_t *buffer;
int32_t error;
uint16_t algorithm;
uint8_t *buffer;
int32_t error;
uint16_t algorithm;
} mz_crypt_hmac;
/***************************************************************************/
@ -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);
if (NT_SUCCESS(status)) {
status = BCryptGetProperty(hmac->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size,
&result_size, 0);
status =
BCryptGetProperty(hmac->provider, BCRYPT_OBJECT_LENGTH, (PUCHAR)&buffer_size, result_size, &result_size, 0);
}
if (NT_SUCCESS(status)) {
hmac->buffer = malloc(buffer_size);
@ -590,7 +586,7 @@ int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size) {
if (!hmac || !buf || !hmac->hash)
return MZ_PARAM_ERROR;
status = BCryptHashData(hmac->hash, (uint8_t*)buf, size, 0);
status = BCryptHashData(hmac->hash, (uint8_t *)buf, size, 0);
if (!NT_SUCCESS(status)) {
hmac->error = status;
return MZ_HASH_ERROR;

61
mz_crypt_winxp.c
View File

@ -15,7 +15,7 @@
#include <windows.h>
#if _WIN32_WINNT <= _WIN32_WINNT_WINXP
#include <wincrypt.h>
# include <wincrypt.h>
/***************************************************************************/
@ -39,12 +39,12 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
typedef struct mz_crypt_sha_s {
union {
struct {
HCRYPTPROV provider;
HCRYPTHASH hash;
HCRYPTPROV provider;
HCRYPTHASH hash;
};
};
int32_t error;
uint16_t algorithm;
int32_t error;
uint16_t algorithm;
} mz_crypt_sha;
/***************************************************************************/
@ -81,7 +81,7 @@ int32_t mz_crypt_sha_begin(void *handle) {
case MZ_HASH_SHA1:
alg_id = CALG_SHA1;
break;
#if NTDDI_VERSION > NTDDI_WINXPSP2
# if NTDDI_VERSION > NTDDI_WINXPSP2
case MZ_HASH_SHA256:
alg_id = CALG_SHA_256;
break;
@ -91,12 +91,12 @@ int32_t mz_crypt_sha_begin(void *handle) {
case MZ_HASH_SHA512:
alg_id = CALG_SHA_512;
break;
#else
# else
case MZ_HASH_SHA256:
case MZ_HASH_SHA384:
case MZ_HASH_SHA512:
return MZ_SUPPORT_ERROR;
#endif
# endif
default:
return MZ_PARAM_ERROR;
}
@ -197,9 +197,9 @@ void mz_crypt_sha_delete(void **handle) {
typedef struct mz_crypt_aes_s {
HCRYPTPROV provider;
HCRYPTKEY key;
int32_t mode;
int32_t error;
HCRYPTKEY key;
int32_t mode;
int32_t error;
} mz_crypt_aes;
/***************************************************************************/
@ -253,14 +253,14 @@ int32_t mz_crypt_aes_decrypt_final(void *handle, uint8_t *buf, int32_t size, con
return MZ_SUPPORT_ERROR;
}
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
HCRYPTHASH hash = 0;
ALG_ID alg_id = 0;
typedef struct key_blob_header_s {
BLOBHEADER hdr;
uint32_t key_length;
uint32_t key_length;
} key_blob_header_s;
key_blob_header_s *key_blob_s = NULL;
uint32_t mode;
@ -295,7 +295,7 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
return MZ_PARAM_ERROR;
result = CryptAcquireContext(&aes->provider, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (result) {
key_blob_size = sizeof(key_blob_header_s) + key_length;
key_blob = (uint8_t *)malloc(key_blob_size);
@ -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)
result = CryptSetKeyParam(aes->key, KP_MODE, (const uint8_t *)&mode, 0);
if (!result && err == MZ_OK) {
aes->error = GetLastError();
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;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t 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,
const void *iv, int32_t iv_length) {
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length, const void *iv,
int32_t iv_length) {
return mz_crypt_aes_set_key(handle, key, key_length, iv, iv_length);
}
@ -382,11 +381,11 @@ void mz_crypt_aes_delete(void **handle) {
typedef struct mz_crypt_hmac_s {
HCRYPTPROV provider;
HCRYPTHASH hash;
HCRYPTKEY key;
HMAC_INFO info;
int32_t mode;
int32_t error;
uint16_t algorithm;
HCRYPTKEY key;
HMAC_INFO info;
int32_t mode;
int32_t error;
uint16_t algorithm;
} mz_crypt_hmac;
/***************************************************************************/
@ -414,7 +413,7 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
ALG_ID alg_id = 0;
typedef struct key_blob_header_s {
BLOBHEADER hdr;
uint32_t key_length;
uint32_t key_length;
} key_blob_header_s;
key_blob_header_s *key_blob_s = NULL;
uint8_t *key_blob = NULL;
@ -431,16 +430,16 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
if (hmac->algorithm == MZ_HASH_SHA1)
alg_id = CALG_SHA1;
else
#ifdef CALG_SHA_256
# ifdef CALG_SHA_256
alg_id = CALG_SHA_256;
#else
# else
return MZ_SUPPORT_ERROR;
#endif
# endif
hmac->info.HashAlgid = alg_id;
result = CryptAcquireContext(&hmac->provider, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
result =
CryptAcquireContext(&hmac->provider, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (!result) {
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) {
check = source;
if ((*check == '\\') || (*check == '/'))
if (*check == '\\' || *check == '/')
check += 1;
if ((source == path) || (target == output) || (check != source)) {
if (source == path || target == output || check != source) {
/* Skip double paths */
if ((*check == '\\') || (*check == '/')) {
if (*check == '\\' || *check == '/') {
source += 1;
continue;
}
@ -149,7 +149,7 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
check += 1;
/* 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 */
*target = *source;
target += 1;
@ -158,7 +158,7 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
continue;
}
/* Remove . if not at end of string */
else if ((*check == '\\') || (*check == '/')) {
else if (*check == '\\' || *check == '/') {
source += (check - source);
/* Skip slash if at beginning of string */
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 .. */
else if (*check == '.') {
check += 1;
if ((*check == 0) || (*check == '\\' || *check == '/')) {
if (*check == 0 || (*check == '\\' || *check == '/')) {
source += (check - source);
/* Search backwards for previous slash or the start of the output string */
if (target != output) {
target -= 1;
do {
if ((target == output) ||(*target == '\\') || (*target == '/'))
if (target == output || *target == '\\' || *target == '/')
break;
target -= 1;
@ -183,9 +183,9 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
} while (target > output);
}
if ((target == output) && (*source != 0))
if ((target == output) && *source != 0)
source += 1;
if ((*target == '\\' || *target == '/') && (*source == 0))
if ((*target == '\\' || *target == '/') && *source == 0)
target += 1;
*target = 0;

56
mz_os.h
View File

@ -37,15 +37,14 @@ extern "C" {
# define MZ_VERSION_MADEBY_ZIP_VERSION (45)
#endif
#define MZ_VERSION_MADEBY ((MZ_VERSION_MADEBY_HOST_SYSTEM << 8) | \
(MZ_VERSION_MADEBY_ZIP_VERSION))
#define MZ_VERSION_MADEBY ((MZ_VERSION_MADEBY_HOST_SYSTEM << 8) | (MZ_VERSION_MADEBY_ZIP_VERSION))
#define MZ_PATH_SLASH_UNIX ('/')
#define MZ_PATH_SLASH_WINDOWS ('\\')
#define MZ_PATH_SLASH_UNIX ('/')
#define MZ_PATH_SLASH_WINDOWS ('\\')
#if defined(_WIN32)
# define MZ_PATH_SLASH_PLATFORM (MZ_PATH_SLASH_WINDOWS)
# define MZ_PATH_SLASH_PLATFORM (MZ_PATH_SLASH_WINDOWS)
#else
# define MZ_PATH_SLASH_PLATFORM (MZ_PATH_SLASH_UNIX)
# define MZ_PATH_SLASH_PLATFORM (MZ_PATH_SLASH_UNIX)
#endif
/***************************************************************************/
@ -54,9 +53,9 @@ extern "C" {
struct dirent {
char d_name[256];
};
typedef void* DIR;
typedef void *DIR;
#else
#include <dirent.h>
# include <dirent.h>
#endif
/***************************************************************************/
@ -104,64 +103,63 @@ int32_t mz_file_get_crc(const char *path, uint32_t *result_crc);
wchar_t *mz_os_unicode_string_create(const char *string, int32_t encoding);
/* Create unicode string from a utf8 string */
void mz_os_unicode_string_delete(wchar_t **string);
void mz_os_unicode_string_delete(wchar_t **string);
/* Delete a unicode string that was created */
char *mz_os_utf8_string_create(const char *string, int32_t encoding);
char *mz_os_utf8_string_create(const char *string, int32_t encoding);
/* Create a utf8 string from a string with another encoding */
void mz_os_utf8_string_delete(char **string);
void mz_os_utf8_string_delete(char **string);
/* Delete a utf8 string that was created */
int32_t mz_os_rand(uint8_t *buf, int32_t size);
int32_t mz_os_rand(uint8_t *buf, int32_t size);
/* Random number generator (not cryptographically secure) */
int32_t mz_os_rename(const char *source_path, const char *target_path);
int32_t mz_os_rename(const char *source_path, const char *target_path);
/* Rename a file */
int32_t mz_os_unlink(const char *path);
int32_t mz_os_unlink(const char *path);
/* Delete an existing file */
int32_t mz_os_file_exists(const char *path);
int32_t mz_os_file_exists(const char *path);
/* Check to see if a file exists */
int64_t mz_os_get_file_size(const char *path);
int64_t mz_os_get_file_size(const char *path);
/* Gets the length of a file */
int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
/* Gets a file's modified, access, and creation dates if supported */
int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
/* Sets a file's modified, access, and creation dates if supported */
int32_t mz_os_get_file_attribs(const char *path, uint32_t *attributes);
int32_t mz_os_get_file_attribs(const char *path, uint32_t *attributes);
/* Gets a file's attributes */
int32_t mz_os_set_file_attribs(const char *path, uint32_t attributes);
int32_t mz_os_set_file_attribs(const char *path, uint32_t attributes);
/* Sets a file's attributes */
int32_t mz_os_make_dir(const char *path);
int32_t mz_os_make_dir(const char *path);
/* Recursively creates a directory */
DIR* mz_os_open_dir(const char *path);
DIR *mz_os_open_dir(const char *path);
/* Opens a directory for listing */
struct
dirent* mz_os_read_dir(DIR *dir);
struct dirent *mz_os_read_dir(DIR *dir);
/* Reads a directory listing entry */
int32_t mz_os_close_dir(DIR *dir);
int32_t mz_os_close_dir(DIR *dir);
/* Closes a directory that has been opened for listing */
int32_t mz_os_is_dir(const char *path);
int32_t mz_os_is_dir(const char *path);
/* Checks to see if path is a directory */
int32_t mz_os_is_symlink(const char *path);
int32_t mz_os_is_symlink(const char *path);
/* Checks to see if path is a symbolic link */
int32_t mz_os_make_symlink(const char *path, const char *target_path);
int32_t mz_os_make_symlink(const char *path, const char *target_path);
/* Creates a symbolic link pointing to a target */
int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_target_path);
int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_target_path);
/* Gets the target path for a symbolic link */
uint64_t mz_os_ms_time(void);

11
mz_os_posix.c
View File

@ -15,7 +15,7 @@
#include <stdio.h> /* rename */
#include <errno.h>
#if defined(HAVE_ICONV)
#include <iconv.h>
# include <iconv.h>
#endif
#include <string.h>
#include <sys/types.h>
@ -75,8 +75,7 @@ char *mz_os_utf8_string_create(const char *string, int32_t encoding) {
string_utf8_ptr = string_utf8;
if (string_utf8) {
result = iconv(cd, (char **)&string, &string_length,
(char **)&string_utf8_ptr, &string_utf8_size);
result = iconv(cd, (char **)&string, &string_length, (char **)&string_utf8_ptr, &string_utf8_size);
}
iconv_close(cd);
@ -147,7 +146,7 @@ int32_t mz_os_rand(uint8_t *buf, int32_t size) {
/* Ensure different random header each time */
if (++calls == 1) {
#define PI_SEED 3141592654UL
# define PI_SEED 3141592654UL
srand((unsigned)(time(NULL) ^ PI_SEED));
}
@ -272,11 +271,11 @@ int32_t mz_os_make_dir(const char *path) {
return MZ_OK;
}
DIR* mz_os_open_dir(const char *path) {
DIR *mz_os_open_dir(const char *path) {
return opendir(path);
}
struct dirent* mz_os_read_dir(DIR *dir) {
struct dirent *mz_os_read_dir(DIR *dir) {
if (!dir)
return NULL;
return readdir(dir);

33
mz_os_win32.c
View File

@ -28,10 +28,10 @@
/***************************************************************************/
typedef struct DIR_int_s {
void *find_handle;
void *find_handle;
WIN32_FIND_DATAW find_data;
struct dirent entry;
uint8_t end;
struct dirent entry;
uint8_t end;
} DIR_int;
/***************************************************************************/
@ -401,7 +401,7 @@ DIR *mz_os_open_dir(const char *path) {
return (DIR *)dir_int;
}
struct dirent* mz_os_read_dir(DIR *dir) {
struct dirent *mz_os_read_dir(DIR *dir) {
DIR_int *dir_int;
if (!dir)
@ -411,8 +411,8 @@ struct dirent* mz_os_read_dir(DIR *dir) {
if (dir_int->end)
return NULL;
WideCharToMultiByte(CP_UTF8, 0, dir_int->find_data.cFileName, -1,
dir_int->entry.d_name, sizeof(dir_int->entry.d_name), NULL, NULL);
WideCharToMultiByte(CP_UTF8, 0, dir_int->find_data.cFileName, -1, dir_int->entry.d_name,
sizeof(dir_int->entry.d_name), NULL, NULL);
if (FindNextFileW(dir_int->find_handle, &dir_int->find_data) == 0) {
if (GetLastError() != ERROR_NO_MORE_FILES)
@ -480,7 +480,7 @@ int32_t mz_os_is_symlink(const char *path) {
}
int32_t mz_os_make_symlink(const char *path, const char *target_path) {
typedef BOOLEAN (WINAPI *LPCREATESYMBOLICLINKW)(LPCWSTR, LPCWSTR, DWORD);
typedef BOOLEAN(WINAPI * LPCREATESYMBOLICLINKW)(LPCWSTR, LPCWSTR, DWORD);
MEMORY_BASIC_INFORMATION mbi;
LPCREATESYMBOLICLINKW create_symbolic_link_w = NULL;
HMODULE kernel32_mod = NULL;
@ -530,7 +530,7 @@ int32_t mz_os_make_symlink(const char *path, const char *target_path) {
int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_target_path) {
typedef struct _REPARSE_DATA_BUFFER {
ULONG ReparseTag;
ULONG ReparseTag;
USHORT ReparseDataLength;
USHORT Reserved;
union {
@ -539,18 +539,18 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
USHORT SubstituteNameLength;
USHORT PrintNameOffset;
USHORT PrintNameLength;
ULONG Flags;
WCHAR PathBuffer[1];
ULONG Flags;
WCHAR PathBuffer[1];
} SymbolicLinkReparseBuffer;
struct {
USHORT SubstituteNameOffset;
USHORT SubstituteNameLength;
USHORT PrintNameOffset;
USHORT PrintNameLength;
WCHAR PathBuffer[1];
WCHAR PathBuffer[1];
} MountPointReparseBuffer;
struct {
UCHAR DataBuffer[1];
UCHAR DataBuffer[1];
} GenericReparseBuffer;
};
} REPARSE_DATA_BUFFER;
@ -563,7 +563,7 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
int32_t target_path_len = 0;
int32_t target_path_idx = 0;
int32_t err = MZ_OK;
char *target_path_utf8 = NULL;
char *target_path_utf8 = NULL;
if (!path)
return MZ_PARAM_ERROR;
@ -583,7 +583,7 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
handle = CreateFile2(path_wide, FILE_READ_EA, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING, &extended_params);
#else
handle = CreateFileW(path_wide, FILE_READ_EA, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
#endif
if (handle == INVALID_HANDLE_VALUE) {
@ -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) {
reparse_data = (REPARSE_DATA_BUFFER *)buffer;
if ((IsReparseTagMicrosoft(reparse_data->ReparseTag)) &&
(reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK)) {
if ((IsReparseTagMicrosoft(reparse_data->ReparseTag)) && (reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK)) {
target_path_len = max_target_path * sizeof(wchar_t);
if (target_path_len > reparse_data->SymbolicLinkReparseBuffer.PrintNameLength)
target_path_len = reparse_data->SymbolicLinkReparseBuffer.PrintNameLength;
@ -603,7 +602,7 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
if (target_path_wide) {
target_path_idx = reparse_data->SymbolicLinkReparseBuffer.PrintNameOffset / sizeof(wchar_t);
memcpy(target_path_wide, &reparse_data->SymbolicLinkReparseBuffer.PathBuffer[target_path_idx],
target_path_len);
target_path_len);
target_path_wide[target_path_len / sizeof(wchar_t)] = 0;
target_path_utf8 = mz_os_utf8_string_create_from_unicode(target_path_wide, MZ_ENCODING_UTF8);

36
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);
}
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 len) {
uint8_t buf[16384];
int32_t bytes_to_copy = 0;
int32_t read = 0;
@ -187,7 +187,7 @@ int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *s
}
int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb, void *source,
mz_stream_read_cb read_cb) {
mz_stream_read_cb read_cb) {
uint8_t buf[16384];
int32_t read = 0;
int32_t written = 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);
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 = mz_stream_read(stream, buf + buf_pos, read_size);
if ((read <= 0) || (read + buf_pos < find_size))
@ -376,7 +378,7 @@ int32_t mz_stream_set_base(void *stream, void *base) {
return MZ_OK;
}
void* mz_stream_get_interface(void *stream) {
void *mz_stream_get_interface(void *stream) {
mz_stream *strm = (mz_stream *)stream;
if (!strm || !strm->vtbl)
return NULL;
@ -416,10 +418,10 @@ void mz_stream_delete(void **stream) {
/***************************************************************************/
typedef struct mz_stream_raw_s {
mz_stream stream;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
mz_stream stream;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
} mz_stream_raw;
/***************************************************************************/
@ -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 = {
mz_stream_raw_open,
mz_stream_raw_is_open,
mz_stream_raw_read,
mz_stream_raw_write,
mz_stream_raw_tell,
mz_stream_raw_seek,
mz_stream_raw_close,
mz_stream_raw_error,
mz_stream_raw_create,
mz_stream_raw_delete,
mz_stream_raw_get_prop_int64,
mz_stream_raw_set_prop_int64
};
mz_stream_raw_open, mz_stream_raw_is_open, mz_stream_raw_read, mz_stream_raw_write,
mz_stream_raw_tell, mz_stream_raw_seek, mz_stream_raw_close, mz_stream_raw_error,
mz_stream_raw_create, mz_stream_raw_delete, mz_stream_raw_get_prop_int64, mz_stream_raw_set_prop_int64};
/***************************************************************************/

90
mz_strm.h
View File

@ -17,58 +17,58 @@ extern "C" {
/***************************************************************************/
#define MZ_STREAM_PROP_TOTAL_IN (1)
#define MZ_STREAM_PROP_TOTAL_IN_MAX (2)
#define MZ_STREAM_PROP_TOTAL_OUT (3)
#define MZ_STREAM_PROP_TOTAL_OUT_MAX (4)
#define MZ_STREAM_PROP_HEADER_SIZE (5)
#define MZ_STREAM_PROP_FOOTER_SIZE (6)
#define MZ_STREAM_PROP_DISK_SIZE (7)
#define MZ_STREAM_PROP_DISK_NUMBER (8)
#define MZ_STREAM_PROP_COMPRESS_LEVEL (9)
#define MZ_STREAM_PROP_COMPRESS_METHOD (10)
#define MZ_STREAM_PROP_COMPRESS_WINDOW (11)
#define MZ_STREAM_PROP_TOTAL_IN (1)
#define MZ_STREAM_PROP_TOTAL_IN_MAX (2)
#define MZ_STREAM_PROP_TOTAL_OUT (3)
#define MZ_STREAM_PROP_TOTAL_OUT_MAX (4)
#define MZ_STREAM_PROP_HEADER_SIZE (5)
#define MZ_STREAM_PROP_FOOTER_SIZE (6)
#define MZ_STREAM_PROP_DISK_SIZE (7)
#define MZ_STREAM_PROP_DISK_NUMBER (8)
#define MZ_STREAM_PROP_COMPRESS_LEVEL (9)
#define MZ_STREAM_PROP_COMPRESS_METHOD (10)
#define MZ_STREAM_PROP_COMPRESS_WINDOW (11)
/***************************************************************************/
typedef int32_t (*mz_stream_open_cb) (void *stream, const char *path, int32_t mode);
typedef int32_t (*mz_stream_is_open_cb) (void *stream);
typedef int32_t (*mz_stream_read_cb) (void *stream, void *buf, int32_t size);
typedef int32_t (*mz_stream_write_cb) (void *stream, const void *buf, int32_t size);
typedef int64_t (*mz_stream_tell_cb) (void *stream);
typedef int32_t (*mz_stream_seek_cb) (void *stream, int64_t offset, int32_t origin);
typedef int32_t (*mz_stream_close_cb) (void *stream);
typedef int32_t (*mz_stream_error_cb) (void *stream);
typedef void* (*mz_stream_create_cb) (void);
typedef void (*mz_stream_destroy_cb) (void **stream);
typedef int32_t (*mz_stream_open_cb)(void *stream, const char *path, int32_t mode);
typedef int32_t (*mz_stream_is_open_cb)(void *stream);
typedef int32_t (*mz_stream_read_cb)(void *stream, void *buf, int32_t size);
typedef int32_t (*mz_stream_write_cb)(void *stream, const void *buf, int32_t size);
typedef int64_t (*mz_stream_tell_cb)(void *stream);
typedef int32_t (*mz_stream_seek_cb)(void *stream, int64_t offset, int32_t origin);
typedef int32_t (*mz_stream_close_cb)(void *stream);
typedef int32_t (*mz_stream_error_cb)(void *stream);
typedef void *(*mz_stream_create_cb)(void);
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_set_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_find_cb) (void *stream, const void *find, int32_t find_size,
int64_t max_seek, int64_t *position);
typedef int32_t (*mz_stream_find_cb)(void *stream, const void *find, int32_t find_size, int64_t max_seek,
int64_t *position);
/***************************************************************************/
typedef struct mz_stream_vtbl_s {
mz_stream_open_cb open;
mz_stream_is_open_cb is_open;
mz_stream_read_cb read;
mz_stream_write_cb write;
mz_stream_tell_cb tell;
mz_stream_seek_cb seek;
mz_stream_close_cb close;
mz_stream_error_cb error;
mz_stream_create_cb create;
mz_stream_destroy_cb destroy;
mz_stream_open_cb open;
mz_stream_is_open_cb is_open;
mz_stream_read_cb read;
mz_stream_write_cb write;
mz_stream_tell_cb tell;
mz_stream_seek_cb seek;
mz_stream_close_cb close;
mz_stream_error_cb error;
mz_stream_create_cb create;
mz_stream_destroy_cb destroy;
mz_stream_get_prop_int64_cb get_prop_int64;
mz_stream_set_prop_int64_cb set_prop_int64;
} mz_stream_vtbl;
typedef struct mz_stream_s {
mz_stream_vtbl *vtbl;
struct mz_stream_s *base;
mz_stream_vtbl *vtbl;
struct mz_stream_s *base;
} mz_stream;
/***************************************************************************/
@ -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_copy(void *target, void *source, int32_t len);
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_to_end(void *target, mz_stream_write_cb write_cb, void *source, mz_stream_read_cb read_cb);
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_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);
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);
@ -99,12 +101,12 @@ int32_t mz_stream_close(void *stream);
int32_t mz_stream_error(void *stream);
int32_t mz_stream_set_base(void *stream, void *base);
void* mz_stream_get_interface(void *stream);
void *mz_stream_get_interface(void *stream);
int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_create(mz_stream_vtbl *vtbl);
void mz_stream_delete(void **stream);
void *mz_stream_create(mz_stream_vtbl *vtbl);
void mz_stream_delete(void **stream);
/***************************************************************************/
@ -120,8 +122,8 @@ int32_t mz_stream_raw_error(void *stream);
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_raw_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_raw_create(void);
void mz_stream_raw_delete(void **stream);
void *mz_stream_raw_create(void);
void mz_stream_raw_delete(void **stream);
/***************************************************************************/

100
mz_strm_buf.c
View File

@ -16,37 +16,35 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_buffered_vtbl = {
mz_stream_buffered_open,
mz_stream_buffered_is_open,
mz_stream_buffered_read,
mz_stream_buffered_write,
mz_stream_buffered_tell,
mz_stream_buffered_seek,
mz_stream_buffered_close,
mz_stream_buffered_error,
mz_stream_buffered_create,
mz_stream_buffered_delete,
NULL,
NULL
};
static mz_stream_vtbl mz_stream_buffered_vtbl = {mz_stream_buffered_open,
mz_stream_buffered_is_open,
mz_stream_buffered_read,
mz_stream_buffered_write,
mz_stream_buffered_tell,
mz_stream_buffered_seek,
mz_stream_buffered_close,
mz_stream_buffered_error,
mz_stream_buffered_create,
mz_stream_buffered_delete,
NULL,
NULL};
/***************************************************************************/
typedef struct mz_stream_buffered_s {
mz_stream stream;
int32_t error;
char readbuf[INT16_MAX];
int32_t readbuf_len;
int32_t readbuf_pos;
int32_t readbuf_hits;
int32_t readbuf_misses;
char writebuf[INT16_MAX];
int32_t writebuf_len;
int32_t writebuf_pos;
int32_t writebuf_hits;
int32_t writebuf_misses;
int64_t position;
int32_t error;
char readbuf[INT16_MAX];
int32_t readbuf_len;
int32_t readbuf_pos;
int32_t readbuf_hits;
int32_t readbuf_misses;
char writebuf[INT16_MAX];
int32_t writebuf_len;
int32_t writebuf_pos;
int32_t writebuf_hits;
int32_t writebuf_misses;
int64_t position;
} mz_stream_buffered;
/***************************************************************************/
@ -54,7 +52,7 @@ typedef struct mz_stream_buffered_s {
#if 0
# define mz_stream_buffered_print printf
#else
# define mz_stream_buffered_print(fmt,...)
# define mz_stream_buffered_print(fmt, ...)
#endif
/***************************************************************************/
@ -93,16 +91,16 @@ static int32_t mz_stream_buffered_flush(void *stream, int32_t *written) {
*written = 0;
while (bytes_left_to_write > 0) {
bytes_written = mz_stream_write(buffered->stream.base,
buffered->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);
bytes_written = mz_stream_write(
buffered->stream.base, buffered->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write);
if (bytes_written != bytes_left_to_write)
return MZ_WRITE_ERROR;
buffered->writebuf_misses += 1;
mz_stream_buffered_print("Buffered - Write flush (%" PRId32 ":%" PRId32 " len %" PRId32 ")\n",
bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
mz_stream_buffered_print("Buffered - Write flush (%" PRId32 ":%" PRId32 " len %" PRId32 ")\n", bytes_to_write,
bytes_left_to_write, buffered->writebuf_len);
total_bytes_written += 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);
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);
@ -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_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)
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->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);
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_pos += bytes_to_copy;
mz_stream_buffered_print("Buffered - Emptied (copied %" PRId32 " remaining %" PRId32 " buf %" PRId32 ":%" PRId32 " pos %" PRId64 ")\n",
bytes_to_copy, bytes_left_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
mz_stream_buffered_print("Buffered - Emptied (copied %" PRId32 " remaining %" PRId32 " buf %" PRId32
":%" 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 err = MZ_OK;
mz_stream_buffered_print("Buffered - Write (size %" PRId32 " len %" PRId32 " pos %" PRId64 ")\n",
size, buffered->writebuf_len, buffered->position);
mz_stream_buffered_print("Buffered - Write (size %" PRId32 " len %" PRId32 " pos %" PRId64 ")\n", size,
buffered->writebuf_len, buffered->position);
if (buffered->readbuf_len > 0) {
buffered->position -= buffered->readbuf_len;
@ -225,11 +226,12 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size) {
continue;
}
memcpy(buffered->writebuf + buffered->writebuf_pos,
(const char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);
memcpy(buffered->writebuf + buffered->writebuf_pos, (const char *)buf + (bytes_to_write - bytes_left_to_write),
bytes_to_copy);
mz_stream_buffered_print("Buffered - Write copy (remaining %" PRId32 " write %" PRId32 ":%" PRId32 " len %" PRId32 ")\n",
bytes_to_copy, bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
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_left_to_write -= bytes_to_copy;
@ -249,7 +251,7 @@ int64_t mz_stream_buffered_tell(void *stream) {
buffered->position = position;
mz_stream_buffered_print("Buffered - Tell (pos %" PRId64 " readpos %" PRId32 " writepos %" PRId32 ")\n",
buffered->position, buffered->readbuf_pos, buffered->writebuf_pos);
buffered->position, buffered->readbuf_pos, buffered->writebuf_pos);
if (buffered->readbuf_len > 0)
position -= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos);
@ -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 err = MZ_OK;
mz_stream_buffered_print("Buffered - Seek (origin %" PRId32 " offset %" PRId64 " pos %" PRId64 ")\n",
origin, offset, buffered->position);
mz_stream_buffered_print("Buffered - Seek (origin %" PRId32 " offset %" PRId64 " pos %" PRId64 ")\n", origin,
offset, buffered->position);
switch (origin) {
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);
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);
}
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);
}

6
mz_strm_buf.h
View File

@ -28,10 +28,10 @@ int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin);
int32_t mz_stream_buffered_close(void *stream);
int32_t mz_stream_buffered_error(void *stream);
void* mz_stream_buffered_create(void);
void mz_stream_buffered_delete(void **stream);
void *mz_stream_buffered_create(void);
void mz_stream_buffered_delete(void **stream);
void* mz_stream_buffered_get_interface(void);
void *mz_stream_buffered_get_interface(void);
/***************************************************************************/

52
mz_strm_bzip.c
View File

@ -17,35 +17,25 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_bzip_vtbl = {
mz_stream_bzip_open,
mz_stream_bzip_is_open,
mz_stream_bzip_read,
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
};
mz_stream_bzip_open, mz_stream_bzip_is_open, mz_stream_bzip_read, 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};
/***************************************************************************/
typedef struct mz_stream_bzip_s {
mz_stream stream;
bz_stream bzstream;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int16_t stream_end;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int8_t initialized;
int16_t level;
mz_stream stream;
bz_stream bzstream;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int16_t stream_end;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int8_t initialized;
int16_t level;
} mz_stream_bzip;
/***************************************************************************/
@ -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_out_before = bzip->bzstream.total_out_lo32 +
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
total_out_before = bzip->bzstream.total_out_lo32 + (((uint64_t)bzip->bzstream.total_out_hi32) << 32);
err = BZ2_bzDecompress(&bzip->bzstream);
total_in_after = bzip->bzstream.avail_in;
total_out_after = bzip->bzstream.total_out_lo32 +
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
total_out_after = bzip->bzstream.total_out_lo32 + (((uint64_t)bzip->bzstream.total_out_hi32) << 32);
in_bytes = (int32_t)(total_in_before - total_in_after);
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;
}
total_out_before = bzip->bzstream.total_out_lo32 +
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
total_out_before = bzip->bzstream.total_out_lo32 + (((uint64_t)bzip->bzstream.total_out_hi32) << 32);
err = BZ2_bzCompress(&bzip->bzstream, flush);
total_out_after = bzip->bzstream.total_out_lo32 +
(((uint64_t)bzip->bzstream.total_out_hi32) << 32);
total_out_after = bzip->bzstream.total_out_lo32 + (((uint64_t)bzip->bzstream.total_out_hi32) << 32);
out_bytes = (uint32_t)(total_out_after - total_out_before);

8
mz_strm_bzip.h
View File

@ -29,12 +29,12 @@ int32_t mz_stream_bzip_error(void *stream);
int32_t mz_stream_bzip_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_bzip_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_bzip_create(void);
void mz_stream_bzip_delete(void **stream);
void *mz_stream_bzip_create(void);
void mz_stream_bzip_delete(void **stream);
void* mz_stream_bzip_get_interface(void);
void *mz_stream_bzip_get_interface(void);
void bz_internal_error(int errcode);
void bz_internal_error(int errcode);
/***************************************************************************/

40
mz_strm_libcomp.c
View File

@ -17,35 +17,25 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_libcomp_vtbl = {
mz_stream_libcomp_open,
mz_stream_libcomp_is_open,
mz_stream_libcomp_read,
mz_stream_libcomp_write,
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
};
mz_stream_libcomp_open, mz_stream_libcomp_is_open, mz_stream_libcomp_read,
mz_stream_libcomp_write, 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 {
mz_stream stream;
compression_stream
cstream;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int8_t initialized;
int32_t mode;
int32_t error;
int16_t method;
mz_stream stream;
compression_stream cstream;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int8_t initialized;
int32_t mode;
int32_t error;
int16_t method;
} mz_stream_libcomp;
/***************************************************************************/

6
mz_strm_libcomp.h
View File

@ -31,10 +31,10 @@ int32_t mz_stream_libcomp_error(void *stream);
int32_t mz_stream_libcomp_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_libcomp_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_libcomp_create(void);
void mz_stream_libcomp_delete(void **stream);
void *mz_stream_libcomp_create(void);
void mz_stream_libcomp_delete(void **stream);
void* mz_stream_libcomp_get_interface(void);
void *mz_stream_libcomp_get_interface(void);
/***************************************************************************/

44
mz_strm_lzma.c
View File

@ -23,38 +23,28 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_lzma_vtbl = {
mz_stream_lzma_open,
mz_stream_lzma_is_open,
mz_stream_lzma_read,
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
};
mz_stream_lzma_open, mz_stream_lzma_is_open, mz_stream_lzma_read, 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};
/***************************************************************************/
typedef struct mz_stream_lzma_s {
mz_stream stream;
mz_stream stream;
lzma_stream lstream;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int64_t max_total_out;
int8_t initialized;
int8_t header;
int32_t header_size;
uint32_t preset;
int16_t method;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int64_t max_total_out;
int8_t initialized;
int8_t header;
int32_t header_size;
uint32_t preset;
int16_t method;
} mz_stream_lzma;
/***************************************************************************/

6
mz_strm_lzma.h
View File

@ -29,10 +29,10 @@ int32_t mz_stream_lzma_error(void *stream);
int32_t mz_stream_lzma_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_lzma_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_lzma_create(void);
void mz_stream_lzma_delete(void **stream);
void *mz_stream_lzma_create(void);
void mz_stream_lzma_delete(void **stream);
void* mz_stream_lzma_get_interface(void);
void *mz_stream_lzma_get_interface(void);
/***************************************************************************/

42
mz_strm_mem.c
View File

@ -22,31 +22,29 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_mem_vtbl = {
mz_stream_mem_open,
mz_stream_mem_is_open,
mz_stream_mem_read,
mz_stream_mem_write,
mz_stream_mem_tell,
mz_stream_mem_seek,
mz_stream_mem_close,
mz_stream_mem_error,
mz_stream_mem_create,
mz_stream_mem_delete,
NULL,
NULL
};
static mz_stream_vtbl mz_stream_mem_vtbl = {mz_stream_mem_open,
mz_stream_mem_is_open,
mz_stream_mem_read,
mz_stream_mem_write,
mz_stream_mem_tell,
mz_stream_mem_seek,
mz_stream_mem_close,
mz_stream_mem_error,
mz_stream_mem_create,
mz_stream_mem_delete,
NULL,
NULL};
/***************************************************************************/
typedef struct mz_stream_mem_s {
mz_stream stream;
int32_t mode;
uint8_t *buffer; /* Memory buffer pointer */
int32_t size; /* Size of the memory buffer */
int32_t limit; /* Furthest we've written */
int32_t position; /* Current position in the memory */
int32_t grow_size; /* Size to grow when full */
mz_stream stream;
int32_t mode;
uint8_t *buffer; /* Memory buffer pointer */
int32_t size; /* Size of the memory buffer */
int32_t limit; /* Furthest we've written */
int32_t position; /* Current position in the memory */
int32_t grow_size; /* Size to grow when full */
} mz_stream_mem;
/***************************************************************************/
@ -211,7 +209,7 @@ int32_t mz_stream_mem_get_buffer(void *stream, const void **buf) {
int32_t mz_stream_mem_get_buffer_at(void *stream, int64_t position, const void **buf) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
if (!buf || position < 0 || !mem->buffer|| mem->size < position)
if (!buf || position < 0 || !mem->buffer || mem->size < position)
return MZ_SEEK_ERROR;
*buf = mem->buffer + position;
return MZ_OK;

14
mz_strm_mem.h
View File

@ -26,18 +26,18 @@ int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin);
int32_t mz_stream_mem_close(void *stream);
int32_t mz_stream_mem_error(void *stream);
void mz_stream_mem_set_buffer(void *stream, void *buf, int32_t size);
void mz_stream_mem_set_buffer(void *stream, void *buf, int32_t size);
int32_t mz_stream_mem_get_buffer(void *stream, const void **buf);
int32_t mz_stream_mem_get_buffer_at(void *stream, int64_t position, const void **buf);
int32_t mz_stream_mem_get_buffer_at_current(void *stream, const void **buf);
void mz_stream_mem_get_buffer_length(void *stream, int32_t *length);
void mz_stream_mem_set_buffer_limit(void *stream, int32_t limit);
void mz_stream_mem_set_grow_size(void *stream, int32_t grow_size);
void mz_stream_mem_get_buffer_length(void *stream, int32_t *length);
void mz_stream_mem_set_buffer_limit(void *stream, int32_t limit);
void mz_stream_mem_set_grow_size(void *stream, int32_t grow_size);
void* mz_stream_mem_create(void);
void mz_stream_mem_delete(void **stream);
void *mz_stream_mem_create(void);
void mz_stream_mem_delete(void **stream);
void* mz_stream_mem_get_interface(void);
void *mz_stream_mem_get_interface(void);
/***************************************************************************/

6
mz_strm_os.h
View File

@ -26,10 +26,10 @@ int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin);
int32_t mz_stream_os_close(void *stream);
int32_t mz_stream_os_error(void *stream);
void* mz_stream_os_create(void);
void mz_stream_os_delete(void **stream);
void *mz_stream_os_create(void);
void mz_stream_os_delete(void **stream);
void* mz_stream_os_get_interface(void);
void *mz_stream_os_get_interface(void);
/***************************************************************************/

32
mz_strm_os_posix.c
View File

@ -41,27 +41,25 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_os_vtbl = {
mz_stream_os_open,
mz_stream_os_is_open,
mz_stream_os_read,
mz_stream_os_write,
mz_stream_os_tell,
mz_stream_os_seek,
mz_stream_os_close,
mz_stream_os_error,
mz_stream_os_create,
mz_stream_os_delete,
NULL,
NULL
};
static mz_stream_vtbl mz_stream_os_vtbl = {mz_stream_os_open,
mz_stream_os_is_open,
mz_stream_os_read,
mz_stream_os_write,
mz_stream_os_tell,
mz_stream_os_seek,
mz_stream_os_close,
mz_stream_os_error,
mz_stream_os_create,
mz_stream_os_delete,
NULL,
NULL};
/***************************************************************************/
typedef struct mz_stream_posix_s {
mz_stream stream;
int32_t error;
FILE *handle;
mz_stream stream;
int32_t error;
FILE *handle;
} mz_stream_posix;
/***************************************************************************/

44
mz_strm_os_win32.c
View File

@ -27,7 +27,7 @@
#endif
#ifndef INVALID_SET_FILE_POINTER
# define INVALID_SET_FILE_POINTER (DWORD)-1
# define INVALID_SET_FILE_POINTER (DWORD)(-1)
#endif
#ifndef _WIN32_WINNT_WIN8
@ -36,27 +36,25 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_os_vtbl = {
mz_stream_os_open,
mz_stream_os_is_open,
mz_stream_os_read,
mz_stream_os_write,
mz_stream_os_tell,
mz_stream_os_seek,
mz_stream_os_close,
mz_stream_os_error,
mz_stream_os_create,
mz_stream_os_delete,
NULL,
NULL
};
static mz_stream_vtbl mz_stream_os_vtbl = {mz_stream_os_open,
mz_stream_os_is_open,
mz_stream_os_read,
mz_stream_os_write,
mz_stream_os_tell,
mz_stream_os_seek,
mz_stream_os_close,
mz_stream_os_error,
mz_stream_os_create,
mz_stream_os_delete,
NULL,
NULL};
/***************************************************************************/
typedef struct mz_stream_win32_s {
mz_stream stream;
HANDLE handle;
int32_t error;
mz_stream stream;
HANDLE handle;
int32_t error;
} mz_stream_win32;
/***************************************************************************/
@ -103,11 +101,9 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode) {
return MZ_PARAM_ERROR;
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
win32->handle = CreateFile2(path_wide, desired_access, share_mode,
creation_disposition, NULL);
win32->handle = CreateFile2(path_wide, desired_access, share_mode, creation_disposition, NULL);
#else
win32->handle = CreateFileW(path_wide, desired_access, share_mode, NULL,
creation_disposition, flags_attribs, NULL);
win32->handle = CreateFileW(path_wide, desired_access, share_mode, NULL, creation_disposition, flags_attribs, NULL);
#endif
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;
}
static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos,
LARGE_INTEGER *new_pos, uint32_t move_method) {
static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos, LARGE_INTEGER *new_pos,
uint32_t move_method) {
#if _WIN32_WINNT >= _WIN32_WINNT_WINXP
BOOL success = FALSE;
success = SetFilePointerEx(handle, large_pos, new_pos, move_method);

53
mz_strm_pkcrypt.c
View File

@ -29,46 +29,35 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_pkcrypt_vtbl = {
mz_stream_pkcrypt_open,
mz_stream_pkcrypt_is_open,
mz_stream_pkcrypt_read,
mz_stream_pkcrypt_write,
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
};
mz_stream_pkcrypt_open, mz_stream_pkcrypt_is_open, mz_stream_pkcrypt_read,
mz_stream_pkcrypt_write, 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};
/***************************************************************************/
typedef struct mz_stream_pkcrypt_s {
mz_stream stream;
int32_t error;
int16_t initialized;
uint8_t buffer[UINT16_MAX];
int64_t total_in;
int64_t max_total_in;
int64_t total_out;
uint32_t keys[3]; /* keys defining the pseudo-random sequence */
uint8_t verify1;
uint8_t verify2;
uint16_t verify_version;
const char *password;
mz_stream stream;
int32_t error;
int16_t initialized;
uint8_t buffer[UINT16_MAX];
int64_t total_in;
int64_t max_total_in;
int64_t total_out;
uint32_t keys[3]; /* keys defining the pseudo-random sequence */
uint8_t verify1;
uint8_t verify2;
uint16_t verify_version;
const char *password;
} mz_stream_pkcrypt;
/***************************************************************************/
#define mz_stream_pkcrypt_decode(strm, c) \
(mz_stream_pkcrypt_update_keys(strm, \
c ^= mz_stream_pkcrypt_decrypt_byte(strm)))
#define mz_stream_pkcrypt_decode(strm, c) \
(mz_stream_pkcrypt_update_keys(strm, c ^= mz_stream_pkcrypt_decrypt_byte(strm)))
#define mz_stream_pkcrypt_encode(strm, c, t) \
(t = mz_stream_pkcrypt_decrypt_byte(strm), \
mz_stream_pkcrypt_update_keys(strm, (uint8_t)c), (uint8_t)(t^(c)))
#define mz_stream_pkcrypt_encode(strm, c, t) \
(t = mz_stream_pkcrypt_decrypt_byte(strm), mz_stream_pkcrypt_update_keys(strm, (uint8_t)c), (uint8_t)(t ^ (c)))
/***************************************************************************/
@ -162,7 +151,7 @@ int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode) {
verify1 = mz_stream_pkcrypt_decode(stream, header[i++]);
verify2 = mz_stream_pkcrypt_decode(stream, header[i++]);
/* PKZIP 2.0 and higher use 1 byte check, older versions used 2 byte check.
/* PKZIP 2.0 and higher use 1 byte check, older versions used 2 byte check.
See app note section 6.1.6. */
if (verify2 != pkcrypt->verify2)
return MZ_PASSWORD_ERROR;

12
mz_strm_pkcrypt.h
View File

@ -26,16 +26,16 @@ int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin);
int32_t mz_stream_pkcrypt_close(void *stream);
int32_t mz_stream_pkcrypt_error(void *stream);
void mz_stream_pkcrypt_set_password(void *stream, const char *password);
void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2, uint16_t version);
void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2, uint16_t *version);
void mz_stream_pkcrypt_set_password(void *stream, const char *password);
void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2, uint16_t version);
void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2, uint16_t *version);
int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_pkcrypt_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_pkcrypt_create(void);
void mz_stream_pkcrypt_delete(void **stream);
void *mz_stream_pkcrypt_create(void);
void mz_stream_pkcrypt_delete(void **stream);
void* mz_stream_pkcrypt_get_interface(void);
void *mz_stream_pkcrypt_get_interface(void);
/***************************************************************************/

49
mz_strm_split.c
View File

@ -27,38 +27,28 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_split_vtbl = {
mz_stream_split_open,
mz_stream_split_is_open,
mz_stream_split_read,
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
};
mz_stream_split_open, mz_stream_split_is_open, mz_stream_split_read, 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};
/***************************************************************************/
typedef struct mz_stream_split_s {
mz_stream stream;
int32_t is_open;
int64_t disk_size;
int64_t total_in;
int64_t total_in_disk;
int64_t total_out;
int64_t total_out_disk;
int32_t mode;
char *path_cd;
char *path_disk;
uint32_t path_disk_size;
int32_t number_disk;
int32_t current_disk;
int64_t current_disk_size;
int32_t reached_end;
mz_stream stream;
int32_t is_open;
int64_t disk_size;
int64_t total_in;
int64_t total_in_disk;
int64_t total_out;
int64_t total_out_disk;
int32_t mode;
char *path_cd;
char *path_disk;
uint32_t path_disk_size;
int32_t number_disk;
int32_t current_disk;
int64_t current_disk_size;
int32_t reached_end;
} mz_stream_split;
/***************************************************************************/
@ -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) {
if (split->path_disk[i] != '.')
continue;
snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i,
".z%02" PRId32, number_disk + 1);
snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i, ".z%02" PRId32, number_disk + 1);
break;
}
} else {

6
mz_strm_split.h
View File

@ -29,10 +29,10 @@ int32_t mz_stream_split_error(void *stream);
int32_t mz_stream_split_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_split_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_split_create(void);
void mz_stream_split_delete(void **stream);
void *mz_stream_split_create(void);
void mz_stream_split_delete(void **stream);
void* mz_stream_split_get_interface(void);
void *mz_stream_split_get_interface(void);
/***************************************************************************/

50
mz_strm_wzaes.c
View File

@ -27,38 +27,28 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_wzaes_vtbl = {
mz_stream_wzaes_open,
mz_stream_wzaes_is_open,
mz_stream_wzaes_read,
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
};
mz_stream_wzaes_open, mz_stream_wzaes_is_open, mz_stream_wzaes_read, 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};
/***************************************************************************/
typedef struct mz_stream_wzaes_s {
mz_stream stream;
int32_t mode;
int32_t error;
int16_t initialized;
uint8_t buffer[UINT16_MAX];
int64_t total_in;
int64_t max_total_in;
int64_t total_out;
uint8_t strength;
const char *password;
void *aes;
uint32_t crypt_pos;
uint8_t crypt_block[MZ_AES_BLOCK_SIZE];
void *hmac;
uint8_t nonce[MZ_AES_BLOCK_SIZE];
mz_stream stream;
int32_t mode;
int32_t error;
int16_t initialized;
uint8_t buffer[UINT16_MAX];
int64_t total_in;
int64_t max_total_in;
int64_t total_out;
uint8_t strength;
const char *password;
void *aes;
uint32_t crypt_pos;
uint8_t crypt_block[MZ_AES_BLOCK_SIZE];
void *hmac;
uint8_t nonce[MZ_AES_BLOCK_SIZE];
} mz_stream_wzaes;
/***************************************************************************/
@ -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 */
mz_crypt_pbkdf2((uint8_t *)password, password_length, salt_value, salt_length,
MZ_AES_KEYING_ITERATIONS, kbuf, 2 * key_length + MZ_AES_PW_VERIFY_SIZE);
mz_crypt_pbkdf2((uint8_t *)password, password_length, salt_value, salt_length, MZ_AES_KEYING_ITERATIONS, kbuf,
2 * key_length + MZ_AES_PW_VERIFY_SIZE);
/* Initialize the buffer pos */
wzaes->crypt_pos = MZ_AES_BLOCK_SIZE;

10
mz_strm_wzaes.h
View File

@ -26,16 +26,16 @@ int32_t mz_stream_wzaes_seek(void *stream, int64_t offset, int32_t origin);
int32_t mz_stream_wzaes_close(void *stream);
int32_t mz_stream_wzaes_error(void *stream);
void mz_stream_wzaes_set_password(void *stream, const char *password);
void mz_stream_wzaes_set_strength(void *stream, uint8_t strength);
void mz_stream_wzaes_set_password(void *stream, const char *password);
void mz_stream_wzaes_set_strength(void *stream, uint8_t strength);
int32_t mz_stream_wzaes_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_wzaes_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_wzaes_create(void);
void mz_stream_wzaes_delete(void **stream);
void *mz_stream_wzaes_create(void);
void mz_stream_wzaes_delete(void **stream);
void* mz_stream_wzaes_get_interface(void);
void *mz_stream_wzaes_get_interface(void);
/***************************************************************************/

50
mz_strm_zlib.c
View File

@ -21,53 +21,43 @@
/***************************************************************************/
#if !defined(ZLIB_COMPAT)
# define ZLIB_PREFIX(x) zng_ ## x
typedef zng_stream zlib_stream;
# define ZLIB_PREFIX(x) zng_##x
typedef zng_stream zlib_stream;
#else
# define ZLIB_PREFIX(x) x
typedef z_stream zlib_stream;
typedef z_stream zlib_stream;
#endif
#if !defined(DEF_MEM_LEVEL)
# if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8
# else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
# endif
#endif
/***************************************************************************/
static mz_stream_vtbl mz_stream_zlib_vtbl = {
mz_stream_zlib_open,
mz_stream_zlib_is_open,
mz_stream_zlib_read,
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
};
mz_stream_zlib_open, mz_stream_zlib_is_open, mz_stream_zlib_read, 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};
/***************************************************************************/
typedef struct mz_stream_zlib_s {
mz_stream stream;
mz_stream stream;
zlib_stream zstream;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int8_t initialized;
int16_t level;
int32_t window_bits;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int8_t initialized;
int16_t level;
int32_t window_bits;
int32_t mode;
int32_t error;
} mz_stream_zlib;
/***************************************************************************/
@ -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.avail_out = sizeof(zlib->buffer);
zlib->error = ZLIB_PREFIX(deflateInit2)(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED,
zlib->window_bits, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
zlib->error = ZLIB_PREFIX(deflateInit2)(&zlib->zstream, (int8_t)zlib->level, Z_DEFLATED, zlib->window_bits,
DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
#endif
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION

6
mz_strm_zlib.h
View File

@ -29,10 +29,10 @@ int32_t mz_stream_zlib_error(void *stream);
int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_zlib_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_zlib_create(void);
void mz_stream_zlib_delete(void **stream);
void *mz_stream_zlib_create(void);
void mz_stream_zlib_delete(void **stream);
void* mz_stream_zlib_get_interface(void);
void *mz_stream_zlib_get_interface(void);
/***************************************************************************/

46
mz_strm_zstd.c
View File

@ -19,38 +19,28 @@
/***************************************************************************/
static mz_stream_vtbl mz_stream_zstd_vtbl = {
mz_stream_zstd_open,
mz_stream_zstd_is_open,
mz_stream_zstd_read,
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
};
mz_stream_zstd_open, mz_stream_zstd_is_open, mz_stream_zstd_read, 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};
/***************************************************************************/
typedef struct mz_stream_zstd_s {
mz_stream stream;
ZSTD_CStream *zcstream;
ZSTD_DStream *zdstream;
ZSTD_outBuffer out;
ZSTD_inBuffer in;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int64_t max_total_out;
int8_t initialized;
int32_t preset;
mz_stream stream;
ZSTD_CStream *zcstream;
ZSTD_DStream *zdstream;
ZSTD_outBuffer out;
ZSTD_inBuffer in;
int32_t mode;
int32_t error;
uint8_t buffer[INT16_MAX];
int32_t buffer_len;
int64_t total_in;
int64_t total_out;
int64_t max_total_in;
int64_t max_total_out;
int8_t initialized;
int32_t preset;
} mz_stream_zstd;
/***************************************************************************/

6
mz_strm_zstd.h
View File

@ -30,10 +30,10 @@ int32_t mz_stream_zstd_error(void *stream);
int32_t mz_stream_zstd_get_prop_int64(void *stream, int32_t prop, int64_t *value);
int32_t mz_stream_zstd_set_prop_int64(void *stream, int32_t prop, int64_t value);
void* mz_stream_zstd_create(void);
void mz_stream_zstd_delete(void **stream);
void *mz_stream_zstd_create(void);
void mz_stream_zstd_delete(void **stream);
void* mz_stream_zstd_get_interface(void);
void *mz_stream_zstd_get_interface(void);
/***************************************************************************/

193
mz_zip.c
View File

@ -464,22 +464,22 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
file_info->linkname = "";
if (err == MZ_OK) {
mz_zip_print("Zip - Entry - Read header - %s (local %" PRId8 ")\n",
file_info->filename, local);
mz_zip_print("Zip - Entry - Read header - %s (local %" PRId8 ")\n", file_info->filename, local);
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) {
mz_zip_print("Zip - Entry - Read header disk (disk %" PRIu32 " offset %" PRId64 ")\n",
file_info->disk_number, file_info->disk_offset);
file_info->disk_number, file_info->disk_offset);
}
mz_zip_print("Zip - Entry - Read header variable (fnl %" PRId32 " efs %" PRId32 " cms %" PRId32 ")\n",
file_info->filename_size, file_info->extrafield_size, file_info->comment_size);
file_info->filename_size, file_info->extrafield_size, file_info->comment_size);
}
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;
int64_t value64 = 0;
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;
}
needs_zip64 = (file_info->uncompressed_size >= max_uncompressed_size) ||
(file_info->compressed_size >= UINT32_MAX);
needs_zip64 = (file_info->uncompressed_size >= max_uncompressed_size) || (file_info->compressed_size >= UINT32_MAX);
if (!local) {
/* Disk offset and number only used in central directory header */
needs_zip64 |= (file_info->disk_offset >= UINT32_MAX) ||
(file_info->disk_number >= UINT16_MAX);
needs_zip64 |= (file_info->disk_offset >= UINT32_MAX) || (file_info->disk_number >= UINT16_MAX);
}
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();
if (!file_extra_stream)
return MZ_MEM_ERROR;
mz_stream_mem_set_buffer(file_extra_stream, (void *)file_info->extrafield,
file_info->extrafield_size);
mz_stream_mem_set_buffer(file_extra_stream, (void *)file_info->extrafield, file_info->extrafield_size);
do {
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);
#endif
/* NTFS timestamps */
if ((file_info->modified_date != 0) &&
(file_info->accessed_date != 0) &&
(file_info->creation_date != 0) && (!mask)) {
if ((file_info->modified_date != 0) && (file_info->accessed_date != 0) && (file_info->creation_date != 0) &&
(!mask)) {
field_length_ntfs = 8 + 8 + 8 + 4 + 2 + 2;
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);
if (mask) {
snprintf(masked_name, sizeof(masked_name), "%" PRIx32 "_%" PRIx64,
file_info->disk_number, file_info->disk_offset);
snprintf(masked_name, sizeof(masked_name), "%" PRIx32 "_%" PRIx64, file_info->disk_number,
file_info->disk_offset);
filename = masked_name;
} else {
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, '\\'))) {
int32_t part_length = (int32_t)(backslash - next);
if (mz_stream_write(stream, next, part_length) != part_length ||
mz_stream_write(stream, "/", 1) != 1)
if (mz_stream_write(stream, next, part_length) != part_length || mz_stream_write(stream, "/", 1) != 1)
err = MZ_WRITE_ERROR;
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;
}
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;
err = mz_stream_write_uint32(stream, MZ_ZIP_MAGIC_DATADESCRIPTOR);
@ -1063,7 +1059,7 @@ static int32_t mz_zip_read_cd(void *handle) {
if (err == MZ_OK) {
mz_zip_print("Zip - Read cd (disk %" PRId32 " entries %" PRId64 " offset %" PRId64 " size %" PRId64 ")\n",
zip->disk_number_with_cd, zip->number_entry, zip->cd_offset, zip->cd_size);
zip->disk_number_with_cd, zip->number_entry, zip->cd_offset, zip->cd_size);
/* Verify central directory signature exists at offset */
err = mz_stream_seek(zip->stream, zip->cd_offset, MZ_SEEK_SET);
@ -1130,7 +1126,7 @@ static int32_t mz_zip_write_cd(void *handle) {
err = mz_stream_copy(zip->stream, zip->cd_mem_stream, (int32_t)zip->cd_size);
mz_zip_print("Zip - Write cd (disk %" PRId32 " entries %" PRId64 " offset %" PRId64 " size %" PRId64 ")\n",
zip->disk_number_with_cd, zip->number_entry, zip->cd_offset, zip->cd_size);
zip->disk_number_with_cd, zip->number_entry, zip->cd_offset, zip->cd_size);
if (zip->cd_size == 0 && zip->number_entry > 0) {
/* Zip does not contain central directory, open with recovery option */
@ -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);
if (err == MZ_OK) {
err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic),
INT64_MAX, &next_header_pos);
err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic), INT64_MAX,
&next_header_pos);
}
while (err == MZ_OK && !eof) {
@ -1308,15 +1304,15 @@ static int32_t mz_zip_recover_cd(void *handle) {
for (;;) {
/* Search for the next local header */
err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic),
INT64_MAX, &next_header_pos);
err = mz_stream_find(zip->stream, (const void *)local_header_magic, sizeof(local_header_magic), INT64_MAX,
&next_header_pos);
if (err == MZ_EXIST_ERROR) {
mz_stream_seek(zip->stream, compressed_pos, MZ_SEEK_SET);
/* Search for central dir if no local header found */
err = mz_stream_find(zip->stream, (const void *)central_header_magic, sizeof(central_header_magic),
INT64_MAX, &next_header_pos);
INT64_MAX, &next_header_pos);
if (err == MZ_EXIST_ERROR) {
/* Get end of stream if no central header found */
@ -1375,8 +1371,8 @@ static int32_t mz_zip_recover_cd(void *handle) {
}
mz_zip_print("Zip - Recover - Entry %s (csize %" PRId64 " usize %" PRId64 " flags 0x%" PRIx16 ")\n",
local_file_info.filename, local_file_info.compressed_size, local_file_info.uncompressed_size,
local_file_info.flag);
local_file_info.filename, local_file_info.compressed_size, local_file_info.uncompressed_size,
local_file_info.flag);
/* Rewrite central dir with local headers and offsets */
err = mz_zip_entry_write_header(cd_mem_stream, 0, &local_file_info);
@ -1388,8 +1384,8 @@ static int32_t mz_zip_recover_cd(void *handle) {
mz_stream_mem_delete(&local_file_info_stream);
mz_zip_print("Zip - Recover - Complete (cddisk %" PRId32 " entries %" PRId64 ")\n",
disk_number_with_cd, number_entry);
mz_zip_print("Zip - Recover - Complete (cddisk %" PRId32 " entries %" PRId64 ")\n", disk_number_with_cd,
number_entry);
if (number_entry == 0)
return err;
@ -1784,18 +1780,20 @@ 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 ||
zip->file_info.compression_method == MZ_COMPRESS_METHOD_XZ) {
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,
zip->file_info.compression_method);
zip->file_info.compression_method);
}
}
#endif
#ifdef HAVE_LZMA
else if (zip->file_info.compression_method == MZ_COMPRESS_METHOD_LZMA ||
zip->file_info.compression_method == MZ_COMPRESS_METHOD_XZ) {
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,
zip->file_info.compression_method);
zip->file_info.compression_method);
}
}
#endif
#ifdef HAVE_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;
#ifndef HAVE_LIBCOMP
if (zip->entry_raw ||
zip->file_info.compression_method == MZ_COMPRESS_METHOD_STORE ||
if (zip->entry_raw || zip->file_info.compression_method == MZ_COMPRESS_METHOD_STORE ||
zip->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)
#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) {
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX, zip->file_info.compressed_size);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_OUT_MAX, zip->file_info.uncompressed_size);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_IN_MAX,
zip->file_info.compressed_size);
mz_stream_set_prop_int64(zip->compress_stream, MZ_STREAM_PROP_TOTAL_OUT_MAX,
zip->file_info.uncompressed_size);
}
}
@ -1913,7 +1912,8 @@ int32_t mz_zip_entry_read_open(void *handle, uint8_t raw, const char *password)
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;
int64_t filename_pos = -1;
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));
mz_zip_print("Zip - Entry - Write open - %s (level %" PRId16 " raw %" PRId8 ")\n",
zip->file_info.filename, compress_level, raw);
mz_zip_print("Zip - Entry - Write open - %s (level %" PRId16 " raw %" PRId8 ")\n", zip->file_info.filename,
compress_level, raw);
mz_stream_seek(zip->file_info_stream, 0, MZ_SEEK_SET);
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);
mz_zip_print("Zip - Entry - Write - %" PRId32 " (max %" PRId32 ")\n", written, len);
return written;
}
int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size,
int64_t *uncompressed_size) {
int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size, int64_t *uncompressed_size) {
mz_zip *zip = (mz_zip *)handle;
int64_t total_in = 0;
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);
if ((zip->file_info.flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR) &&
((zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO) == 0) &&
(crc32 || compressed_size || uncompressed_size)) {
((zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO) == 0) && (crc32 || compressed_size || uncompressed_size)) {
/* Check to see if data descriptor is zip64 bit format or not */
if (mz_zip_extrafield_contains(zip->local_file_info.extrafield,
zip->local_file_info.extrafield_size, MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK)
if (mz_zip_extrafield_contains(zip->local_file_info.extrafield, zip->local_file_info.extrafield_size,
MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK) {
zip64 = 1;
}
err = mz_zip_entry_seek_local_header(handle);
/* Seek to end of compressed stream since we might have over-read during compression */
if (err == MZ_OK)
err = mz_stream_seek(zip->stream, MZ_ZIP_SIZE_LD_ITEM +
(int64_t)zip->local_file_info.filename_size +
(int64_t)zip->local_file_info.extrafield_size +
total_in, MZ_SEEK_CUR);
if (err == MZ_OK) {
err = mz_stream_seek(zip->stream,
MZ_ZIP_SIZE_LD_ITEM + (int64_t)zip->local_file_info.filename_size +
(int64_t)zip->local_file_info.extrafield_size + total_in,
MZ_SEEK_CUR);
}
/* Read data descriptor */
if (err == MZ_OK)
err = mz_zip_entry_read_descriptor(zip->stream, zip64,
crc32, compressed_size, uncompressed_size);
err = mz_zip_entry_read_descriptor(zip->stream, zip64, crc32, compressed_size, uncompressed_size);
}
/* If entire entry was not read verification will fail */
@ -2123,7 +2121,7 @@ int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compress
{
if (zip->entry_crc32 != zip->file_info.crc) {
mz_zip_print("Zip - Entry - Crc failed (actual 0x%08" PRIx32 " expected 0x%08" PRIx32 ")\n",
zip->entry_crc32, zip->file_info.crc);
zip->entry_crc32, zip->file_info.crc);
err = MZ_CRC_ERROR;
}
@ -2135,8 +2133,7 @@ int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compress
return err;
}
int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size,
int64_t uncompressed_size) {
int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size, int64_t uncompressed_size) {
mz_zip *zip = (mz_zip *)handle;
int64_t end_disk_number = 0;
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)
crc32 = zip->entry_crc32;
mz_zip_print("Zip - Entry - Write Close (crc 0x%08" PRIx32 " cs %" PRId64 " ucs %" PRId64 ")\n",
crc32, compressed_size, uncompressed_size);
mz_zip_print("Zip - Entry - Write Close (crc 0x%08" PRIx32 " cs %" PRId64 " ucs %" PRId64 ")\n", crc32,
compressed_size, uncompressed_size);
/* If sizes are not set, then read them from the compression stream */
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 (zip->file_info.flag & MZ_ZIP_FLAG_MASK_LOCAL_INFO)
err = mz_zip_entry_write_descriptor(zip->stream,
zip64, 0, compressed_size, 0);
err = mz_zip_entry_write_descriptor(zip->stream, zip64, 0, compressed_size, 0);
else
err = mz_zip_entry_write_descriptor(zip->stream,
zip64, crc32, compressed_size, uncompressed_size);
err = mz_zip_entry_write_descriptor(zip->stream, zip64, crc32, compressed_size, uncompressed_size);
}
/* Write file info to central directory */
mz_zip_print("Zip - Entry - Write cd (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n",
uncompressed_size, compressed_size, crc32);
mz_zip_print("Zip - Entry - Write cd (ucs %" PRId64 " cs %" PRId64 " crc 0x%08" PRIx32 ")\n", uncompressed_size,
compressed_size, crc32);
zip->file_info.crc = crc32;
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_zip_print("Zip - Entry - Seek local (disk %" PRId32 " offset %" PRId64 ")\n",
disk_number, zip->file_info.disk_offset);
mz_zip_print("Zip - Entry - Seek local (disk %" PRId32 " offset %" PRId64 ")\n", disk_number,
zip->file_info.disk_offset);
/* Guard against seek overflows */
if ((zip->disk_offset_shift > 0) &&
(zip->file_info.disk_offset > (INT64_MAX - zip->disk_offset_shift)))
if ((zip->disk_offset_shift > 0) && (zip->file_info.disk_offset > (INT64_MAX - zip->disk_offset_shift)))
return MZ_FORMAT_ERROR;
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;
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);
} 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 ((src_attrib >> 16) != 0)
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;
return MZ_OK;
}
@ -2548,16 +2545,16 @@ int32_t mz_zip_attrib_posix_to_win32(uint32_t posix_attrib, uint32_t *win32_attr
/* S_IWUSR | S_IWGRP | S_IWOTH | S_IXUSR | S_IXGRP | S_IXOTH */
if ((posix_attrib & 0000333) == 0 && (posix_attrib & 0000444) != 0)
*win32_attrib |= 0x01; /* FILE_ATTRIBUTE_READONLY */
*win32_attrib |= 0x01; /* FILE_ATTRIBUTE_READONLY */
/* S_IFLNK */
if ((posix_attrib & 0170000) == 0120000)
*win32_attrib |= 0x400; /* FILE_ATTRIBUTE_REPARSE_POINT */
*win32_attrib |= 0x400; /* FILE_ATTRIBUTE_REPARSE_POINT */
/* S_IFDIR */
else if ((posix_attrib & 0170000) == 0040000)
*win32_attrib |= 0x10; /* FILE_ATTRIBUTE_DIRECTORY */
*win32_attrib |= 0x10; /* FILE_ATTRIBUTE_DIRECTORY */
/* S_IFREG */
else
*win32_attrib |= 0x80; /* FILE_ATTRIBUTE_NORMAL */
*win32_attrib |= 0x80; /* FILE_ATTRIBUTE_NORMAL */
return MZ_OK;
}
@ -2566,18 +2563,18 @@ int32_t mz_zip_attrib_win32_to_posix(uint32_t win32_attrib, uint32_t *posix_attr
if (!posix_attrib)
return MZ_PARAM_ERROR;
*posix_attrib = 0000444; /* S_IRUSR | S_IRGRP | S_IROTH */
*posix_attrib = 0000444; /* S_IRUSR | S_IRGRP | S_IROTH */
/* FILE_ATTRIBUTE_READONLY */
if ((win32_attrib & 0x01) == 0)
*posix_attrib |= 0000222; /* S_IWUSR | S_IWGRP | S_IWOTH */
*posix_attrib |= 0000222; /* S_IWUSR | S_IWGRP | S_IWOTH */
/* FILE_ATTRIBUTE_REPARSE_POINT */
if ((win32_attrib & 0x400) == 0x400)
*posix_attrib |= 0120000; /* S_IFLNK */
*posix_attrib |= 0120000; /* S_IFLNK */
/* FILE_ATTRIBUTE_DIRECTORY */
else if ((win32_attrib & 0x10) == 0x10)
*posix_attrib |= 0040111; /* S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH */
*posix_attrib |= 0040111; /* S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH */
else
*posix_attrib |= 0100000; /* S_IFREG */
*posix_attrib |= 0100000; /* S_IFREG */
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;
}
int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size,
uint16_t type, uint16_t *length) {
int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size, uint16_t type,
uint16_t *length) {
void *file_extra_stream = NULL;
int32_t err = MZ_OK;
@ -2655,11 +2652,9 @@ 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) {
#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 */
!datevalue_in_range(0, 11, ptm->tm_mon) ||
!datevalue_in_range(1, 31, ptm->tm_mday) ||
!datevalue_in_range(0, 23, ptm->tm_hour) ||
!datevalue_in_range(0, 59, ptm->tm_min) ||
return (!datevalue_in_range(0, 127 + 80, ptm->tm_year) || /* 1980-based year, allow 80 extra */
!datevalue_in_range(0, 11, ptm->tm_mon) || !datevalue_in_range(1, 31, ptm->tm_mday) ||
!datevalue_in_range(0, 23, ptm->tm_hour) || !datevalue_in_range(0, 59, ptm->tm_min) ||
!datevalue_in_range(0, 59, ptm->tm_sec));
#undef datevalue_in_range
}
@ -2667,12 +2662,12 @@ static int32_t mz_zip_invalid_date(const struct tm *ptm) {
static void mz_zip_dosdate_to_raw_tm(uint64_t dos_date, struct tm *ptm) {
uint64_t date = (uint64_t)(dos_date >> 16);
ptm->tm_mday = (uint16_t)(date & 0x1f);
ptm->tm_mon = (uint16_t)(((date & 0x1E0) / 0x20) - 1);
ptm->tm_year = (uint16_t)(((date & 0x0FE00) / 0x0200) + 80);
ptm->tm_hour = (uint16_t)((dos_date & 0xF800) / 0x800);
ptm->tm_min = (uint16_t)((dos_date & 0x7E0) / 0x20);
ptm->tm_sec = (uint16_t)(2 * (dos_date & 0x1f));
ptm->tm_mday = (uint16_t)(date & 0x1f);
ptm->tm_mon = (uint16_t)(((date & 0x1E0) / 0x20) - 1);
ptm->tm_year = (uint16_t)(((date & 0x0FE00) / 0x0200) + 80);
ptm->tm_hour = (uint16_t)((dos_date & 0xF800) / 0x800);
ptm->tm_min = (uint16_t)((dos_date & 0x7E0) / 0x20);
ptm->tm_sec = (uint16_t)(2 * (dos_date & 0x1f));
ptm->tm_isdst = -1;
}
@ -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) {
do {
if ((*path1 == '\\' && *path2 == '/') ||
(*path2 == '\\' && *path1 == '/')) {
if ((*path1 == '\\' && *path2 == '/') || (*path2 == '\\' && *path1 == '/')) {
/* Ignore comparison of path slashes */
} else if (ignore_case) {
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 = "?";
switch (compression_method) {
case MZ_COMPRESS_METHOD_STORE:

90
mz_zip.h
View File

@ -23,34 +23,31 @@ extern "C" {
/***************************************************************************/
typedef struct mz_zip_file_s {
uint16_t version_madeby; /* version made by */
uint16_t version_needed; /* version needed to extract */
uint16_t flag; /* general purpose bit flag */
uint16_t compression_method; /* compression method */
time_t modified_date; /* last modified date in unix time */
time_t accessed_date; /* last accessed date in unix time */
time_t creation_date; /* creation date in unix time */
uint32_t crc; /* crc-32 */
int64_t compressed_size; /* compressed size */
int64_t uncompressed_size; /* uncompressed size */
uint16_t filename_size; /* filename length */
uint16_t extrafield_size; /* extra field length */
uint16_t comment_size; /* file comment length */
uint32_t disk_number; /* disk number start */
int64_t disk_offset; /* relative offset of local header */
uint16_t internal_fa; /* internal file attributes */
uint32_t external_fa; /* external file attributes */
const char *filename; /* filename utf8 null-terminated string */
const uint8_t *extrafield; /* extrafield data */
const char *comment; /* comment utf8 null-terminated string */
const char *linkname; /* sym-link filename utf8 null-terminated string */
uint16_t zip64; /* zip64 extension mode */
uint16_t aes_version; /* winzip aes extension if not 0 */
uint8_t aes_strength; /* winzip aes encryption strength */
uint16_t pk_verify; /* pkware encryption verifier */
uint16_t version_madeby; /* version made by */
uint16_t version_needed; /* version needed to extract */
uint16_t flag; /* general purpose bit flag */
uint16_t compression_method; /* compression method */
time_t modified_date; /* last modified date in unix time */
time_t accessed_date; /* last accessed date in unix time */
time_t creation_date; /* creation date in unix time */
uint32_t crc; /* crc-32 */
int64_t compressed_size; /* compressed size */
int64_t uncompressed_size; /* uncompressed size */
uint16_t filename_size; /* filename length */
uint16_t extrafield_size; /* extra field length */
uint16_t comment_size; /* file comment length */
uint32_t disk_number; /* disk number start */
int64_t disk_offset; /* relative offset of local header */
uint16_t internal_fa; /* internal file attributes */
uint32_t external_fa; /* external file attributes */
const char *filename; /* filename utf8 null-terminated string */
const uint8_t *extrafield; /* extrafield data */
const char *comment; /* comment utf8 null-terminated string */
const char *linkname; /* sym-link filename utf8 null-terminated string */
uint16_t zip64; /* zip64 extension mode */
uint16_t aes_version; /* winzip aes extension if not 0 */
uint8_t aes_strength; /* winzip aes encryption strength */
uint16_t pk_verify; /* pkware encryption verifier */
} mz_zip_file, mz_zip_entry;
/***************************************************************************/
@ -59,10 +56,10 @@ typedef int32_t (*mz_zip_locate_entry_cb)(void *handle, void *userdata, mz_zip_f
/***************************************************************************/
void * mz_zip_create(void);
void *mz_zip_create(void);
/* Create zip instance for opening */
void mz_zip_delete(void **handle);
void mz_zip_delete(void **handle);
/* Delete zip object */
int32_t mz_zip_open(void *handle, void *stream, int32_t mode);
@ -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);
/* 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,
int64_t *uncompressed_size);
int32_t mz_zip_entry_read_close(void *handle, uint32_t *crc32, int64_t *compressed_size, int64_t *uncompressed_size);
/* 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,
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);
/* Open for writing the current file in the zip file */
int32_t mz_zip_entry_write(void *handle, const void *buf, int32_t len);
/* 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,
int64_t uncompressed_size);
int32_t mz_zip_entry_write_close(void *handle, uint32_t crc32, int64_t compressed_size, int64_t uncompressed_size);
/* Close the current file for writing and set data descriptor values */
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);
/* 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,
uint32_t *target_attrib);
int32_t mz_zip_attrib_convert(uint8_t src_sys, uint32_t src_attrib, uint8_t target_sys, uint32_t *target_attrib);
/* 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);
@ -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);
/* 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,
uint16_t type, uint16_t *length);
int32_t mz_zip_extrafield_contains(const uint8_t *extrafield, int32_t extrafield_size, uint16_t type, uint16_t *length);
/* Gets whether an extrafield exists and its size */
int32_t mz_zip_extrafield_read(void *stream, uint16_t *type, uint16_t *length);
@ -221,16 +214,16 @@ int32_t mz_zip_extrafield_write(void *stream, uint16_t type, uint16_t length);
/***************************************************************************/
int32_t mz_zip_dosdate_to_tm(uint64_t dos_date, struct tm *ptm);
int32_t mz_zip_dosdate_to_tm(uint64_t dos_date, struct tm *ptm);
/* Convert dos date/time format to struct tm */
time_t mz_zip_dosdate_to_time_t(uint64_t dos_date);
time_t mz_zip_dosdate_to_time_t(uint64_t dos_date);
/* Convert dos date/time format to time_t */
time_t mz_zip_tm_to_time_t(struct tm *ptm);
time_t mz_zip_tm_to_time_t(struct tm *ptm);
/* Convert time struct to time_t */
int32_t mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm);
int32_t mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm);
/* Convert time_t to time struct */
uint32_t mz_zip_time_t_to_dos_date(time_t unix_time);
@ -239,21 +232,20 @@ uint32_t mz_zip_time_t_to_dos_date(time_t unix_time);
uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm);
/* Convert struct tm to dos date/time format */
int32_t mz_zip_ntfs_to_unix_time(uint64_t ntfs_time, time_t *unix_time);
int32_t mz_zip_ntfs_to_unix_time(uint64_t ntfs_time, time_t *unix_time);
/* Convert ntfs time to unix time */
int32_t mz_zip_unix_to_ntfs_time(time_t unix_time, uint64_t *ntfs_time);
int32_t mz_zip_unix_to_ntfs_time(time_t unix_time, uint64_t *ntfs_time);
/* Convert unix time to 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);
/* Compare two paths without regard to slashes */
/***************************************************************************/
const
char* mz_zip_get_compression_method_string(int32_t compression_method);
const char *mz_zip_get_compression_method_string(int32_t compression_method);
/* Gets a string representing the compression method */
/***************************************************************************/

178
mz_zip_rw.c
View File

@ -30,39 +30,35 @@
/***************************************************************************/
typedef struct mz_zip_reader_s {
void *zip_handle;
void *file_stream;
void *buffered_stream;
void *split_stream;
void *mem_stream;
void *hash;
uint16_t hash_algorithm;
uint16_t hash_digest_size;
void *zip_handle;
void *file_stream;
void *buffered_stream;
void *split_stream;
void *mem_stream;
void *hash;
uint16_t hash_algorithm;
uint16_t hash_digest_size;
mz_zip_file *file_info;
const char *pattern;
uint8_t pattern_ignore_case;
const char *password;
void *overwrite_userdata;
mz_zip_reader_overwrite_cb
overwrite_cb;
void *password_userdata;
mz_zip_reader_password_cb
password_cb;
void *progress_userdata;
mz_zip_reader_progress_cb
progress_cb;
uint32_t progress_cb_interval_ms;
void *entry_userdata;
mz_zip_reader_entry_cb
entry_cb;
uint8_t raw;
uint8_t buffer[UINT16_MAX];
int32_t encoding;
uint8_t sign_required;
uint8_t cd_verified;
uint8_t cd_zipped;
uint8_t entry_verified;
uint8_t recover;
const char *pattern;
uint8_t pattern_ignore_case;
const char *password;
void *overwrite_userdata;
mz_zip_reader_overwrite_cb overwrite_cb;
void *password_userdata;
mz_zip_reader_password_cb password_cb;
void *progress_userdata;
mz_zip_reader_progress_cb progress_cb;
uint32_t progress_cb_interval_ms;
void *entry_userdata;
mz_zip_reader_entry_cb entry_cb;
uint8_t raw;
uint8_t buffer[UINT16_MAX];
int32_t encoding;
uint8_t sign_required;
uint8_t cd_verified;
uint8_t cd_zipped;
uint8_t entry_verified;
uint8_t recover;
} mz_zip_reader;
/***************************************************************************/
@ -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);
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,
(int32_t)cd_info->uncompressed_size);
(int32_t)cd_info->uncompressed_size);
}
if (err == MZ_OK) {
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 */
if (!password && reader->password_cb && (reader->file_info->flag & MZ_ZIP_FLAG_ENCRYPTED)) {
reader->password_cb(handle, reader->password_userdata, reader->file_info,
password_buf, sizeof(password_buf));
reader->password_cb(handle, reader->password_userdata, reader->file_info, password_buf, sizeof(password_buf));
password = password_buf;
}
@ -480,7 +476,7 @@ int32_t mz_zip_reader_entry_get_hash(void *handle, uint16_t algorithm, uint8_t *
return MZ_MEM_ERROR;
mz_stream_mem_set_buffer(file_extra_stream, (void *)reader->file_info->extrafield,
reader->file_info->extrafield_size);
reader->file_info->extrafield_size);
do {
err = mz_zip_extrafield_find(file_extra_stream, MZ_ZIP_EXTENSION_HASH, INT32_MAX, NULL);
@ -521,7 +517,7 @@ int32_t mz_zip_reader_entry_get_first_hash(void *handle, uint16_t *algorithm, ui
return MZ_MEM_ERROR;
mz_stream_mem_set_buffer(file_extra_stream, (void *)reader->file_info->extrafield,
reader->file_info->extrafield_size);
reader->file_info->extrafield_size);
err = mz_zip_extrafield_find(file_extra_stream, MZ_ZIP_EXTENSION_HASH, INT32_MAX, NULL);
if (err == MZ_OK)
@ -673,8 +669,7 @@ int32_t mz_zip_reader_entry_save_file(void *handle, const char *path) {
mz_path_remove_filename(directory);
/* 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) &&
(mz_zip_entry_is_symlink(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)) {
err = mz_dir_make(directory);
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 ((mz_zip_entry_is_symlink(reader->zip_handle) == MZ_OK) &&
(mz_path_has_slash(pathwfs) == MZ_OK)) {
if ((mz_zip_entry_is_symlink(reader->zip_handle) == MZ_OK) && (mz_path_has_slash(pathwfs) == MZ_OK)) {
mz_path_remove_slash(pathwfs);
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) {
/* Set the time of the file that has been created */
mz_os_set_file_date(pathwfs, reader->file_info->modified_date,
reader->file_info->accessed_date, reader->file_info->creation_date);
mz_os_set_file_date(pathwfs, reader->file_info->modified_date, reader->file_info->accessed_date,
reader->file_info->creation_date);
}
if (err == MZ_OK) {
@ -824,7 +818,7 @@ int32_t mz_zip_reader_save_all(void *handle, const char *destination_dir) {
char *path = NULL;
char *utf8_name = NULL;
char *resolved_name = NULL;
char* new_alloc = NULL;
char *new_alloc = NULL;
err = mz_zip_reader_goto_first_entry(handle);
@ -854,7 +848,7 @@ int32_t mz_zip_reader_save_all(void *handle, const char *destination_dir) {
}
utf8_name = new_alloc;
new_alloc = (char *)realloc(resolved_name, resolved_name_size);
if ( !new_alloc) {
if (!new_alloc) {
err = MZ_MEM_ERROR;
goto save_all_cleanup;
}
@ -1023,38 +1017,34 @@ void mz_zip_reader_delete(void **handle) {
/***************************************************************************/
typedef struct mz_zip_writer_s {
void *zip_handle;
void *file_stream;
void *buffered_stream;
void *split_stream;
void *hash;
uint16_t hash_algorithm;
void *mem_stream;
void *file_extra_stream;
void *zip_handle;
void *file_stream;
void *buffered_stream;
void *split_stream;
void *hash;
uint16_t hash_algorithm;
void *mem_stream;
void *file_extra_stream;
mz_zip_file file_info;
void *overwrite_userdata;
mz_zip_writer_overwrite_cb
overwrite_cb;
void *password_userdata;
mz_zip_writer_password_cb
password_cb;
void *progress_userdata;
mz_zip_writer_progress_cb
progress_cb;
uint32_t progress_cb_interval_ms;
void *entry_userdata;
mz_zip_writer_entry_cb
entry_cb;
const char *password;
const char *comment;
uint16_t compress_method;
int16_t compress_level;
uint8_t follow_links;
uint8_t store_links;
uint8_t zip_cd;
uint8_t aes;
uint8_t raw;
uint8_t buffer[UINT16_MAX];
void *overwrite_userdata;
mz_zip_writer_overwrite_cb overwrite_cb;
void *password_userdata;
mz_zip_writer_password_cb password_cb;
void *progress_userdata;
mz_zip_writer_progress_cb progress_cb;
uint32_t progress_cb_interval_ms;
void *entry_userdata;
mz_zip_writer_entry_cb entry_cb;
const char *password;
const char *comment;
uint16_t compress_method;
int16_t compress_level;
uint8_t follow_links;
uint8_t store_links;
uint8_t zip_cd;
uint8_t aes;
uint8_t raw;
uint8_t buffer[UINT16_MAX];
} mz_zip_writer;
/***************************************************************************/
@ -1103,8 +1093,7 @@ int32_t mz_zip_writer_zip_cd(void *handle) {
err = mz_zip_writer_entry_open(handle, &cd_file);
if (err == MZ_OK) {
mz_stream_copy_stream(handle, mz_zip_writer_entry_write, cd_mem_stream,
NULL, (int32_t)cd_mem_length);
mz_stream_copy_stream(handle, mz_zip_writer_entry_write, cd_mem_stream, NULL, (int32_t)cd_mem_length);
mz_stream_seek(cd_mem_stream, 0, MZ_SEEK_SET);
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 */
if (!password && writer->password_cb && (writer->file_info.flag & MZ_ZIP_FLAG_ENCRYPTED)) {
writer->password_cb(handle, writer->password_userdata, &writer->file_info,
password_buf, sizeof(password_buf));
writer->password_cb(handle, writer->password_userdata, &writer->file_info, password_buf, sizeof(password_buf));
password = password_buf;
}
@ -1365,14 +1353,14 @@ int32_t mz_zip_writer_entry_close(void *handle) {
uint16_t hash_digest_size = 0;
switch (writer->hash_algorithm) {
case MZ_HASH_SHA1:
hash_digest_size = MZ_HASH_SHA1_SIZE;
break;
case MZ_HASH_SHA256:
hash_digest_size = MZ_HASH_SHA256_SIZE;
break;
default:
return MZ_PARAM_ERROR;
case MZ_HASH_SHA1:
hash_digest_size = MZ_HASH_SHA1_SIZE;
break;
case MZ_HASH_SHA256:
hash_digest_size = MZ_HASH_SHA256_SIZE;
break;
default:
return MZ_PARAM_ERROR;
}
mz_crypt_sha_end(writer->hash, hash_digest, hash_digest_size);
@ -1397,9 +1385,10 @@ int32_t mz_zip_writer_entry_close(void *handle) {
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,
writer->file_info.extrafield_size);
writer->file_info.extrafield_size);
}
/* Update extra field for central directory after adding extra fields */
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)
file_info.aes_version = MZ_AES_VERSION;
mz_os_get_file_date(path, &file_info.modified_date, &file_info.accessed_date,
&file_info.creation_date);
mz_os_get_file_date(path, &file_info.modified_date, &file_info.accessed_date, &file_info.creation_date);
mz_os_get_file_attribs(path, &src_attrib);
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;
}
int32_t mz_zip_writer_add_path(void *handle, const char *path, const char *root_path,
uint8_t include_path, uint8_t recursive) {
int32_t mz_zip_writer_add_path(void *handle, const char *path, const char *root_path, uint8_t include_path,
uint8_t recursive) {
mz_zip_writer *writer = (mz_zip_writer *)handle;
DIR *dir = NULL;
struct dirent *entry = NULL;

62
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_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_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info, const char *path);
@ -101,13 +102,13 @@ int32_t mz_zip_reader_save_all(void *handle, const char *destination_dir);
/***************************************************************************/
void mz_zip_reader_set_pattern(void *handle, const char *pattern, uint8_t ignore_case);
void mz_zip_reader_set_pattern(void *handle, const char *pattern, uint8_t ignore_case);
/* Sets the match pattern for entries in the zip file, if null all entries are matched */
void mz_zip_reader_set_password(void *handle, const char *password);
void mz_zip_reader_set_password(void *handle, const char *password);
/* Sets the password required for extraction */
void mz_zip_reader_set_raw(void *handle, uint8_t raw);
void mz_zip_reader_set_raw(void *handle, uint8_t raw);
/* Sets whether or not it should save the entry raw */
int32_t mz_zip_reader_get_raw(void *handle, uint8_t *raw);
@ -122,37 +123,38 @@ int32_t mz_zip_reader_get_comment(void *handle, const char **comment);
int32_t mz_zip_reader_set_recover(void *handle, uint8_t recover);
/* Sets the ability to recover the central dir by reading local file headers */
void mz_zip_reader_set_encoding(void *handle, int32_t encoding);
void mz_zip_reader_set_encoding(void *handle, int32_t encoding);
/* Sets whether or not it should support a special character encoding in zip file names. */
void mz_zip_reader_set_overwrite_cb(void *handle, void *userdata, mz_zip_reader_overwrite_cb cb);
void mz_zip_reader_set_overwrite_cb(void *handle, void *userdata, mz_zip_reader_overwrite_cb cb);
/* Callback for what to do when a file is being overwritten */
void mz_zip_reader_set_password_cb(void *handle, void *userdata, mz_zip_reader_password_cb cb);
void mz_zip_reader_set_password_cb(void *handle, void *userdata, mz_zip_reader_password_cb cb);
/* Callback for when a password is required and hasn't been set */
void mz_zip_reader_set_progress_cb(void *handle, void *userdata, mz_zip_reader_progress_cb cb);
void mz_zip_reader_set_progress_cb(void *handle, void *userdata, mz_zip_reader_progress_cb cb);
/* Callback for extraction progress */
void mz_zip_reader_set_progress_interval(void *handle, uint32_t milliseconds);
void mz_zip_reader_set_progress_interval(void *handle, uint32_t milliseconds);
/* Let at least milliseconds pass between calls to progress callback */
void mz_zip_reader_set_entry_cb(void *handle, void *userdata, mz_zip_reader_entry_cb cb);
void mz_zip_reader_set_entry_cb(void *handle, void *userdata, mz_zip_reader_entry_cb cb);
/* Callback for zip file entries */
int32_t mz_zip_reader_get_zip_handle(void *handle, void **zip_handle);
/* Gets the underlying zip instance handle */
void* mz_zip_reader_create(void);
void *mz_zip_reader_create(void);
/* Create new instance of zip reader */
void mz_zip_reader_delete(void **handle);
void mz_zip_reader_delete(void **handle);
/* Delete instance of zip reader */
/***************************************************************************/
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_entry_cb)(void *handle, void *userdata, mz_zip_file *file_info);
@ -202,7 +204,7 @@ int32_t mz_zip_writer_add_file(void *handle, const char *path, const char *filen
/* Adds an entry to the zip from a file */
int32_t mz_zip_writer_add_path(void *handle, const char *path, const char *root_path, uint8_t include_path,
uint8_t recursive);
uint8_t recursive);
/* Enumerates a directory or pattern and adds entries to the zip */
int32_t mz_zip_writer_copy_from_reader(void *handle, void *reader);
@ -210,61 +212,61 @@ int32_t mz_zip_writer_copy_from_reader(void *handle, void *reader);
/***************************************************************************/
void mz_zip_writer_set_password(void *handle, const char *password);
void mz_zip_writer_set_password(void *handle, const char *password);
/* Password to use for encrypting files in the zip */
void mz_zip_writer_set_comment(void *handle, const char *comment);
void mz_zip_writer_set_comment(void *handle, const char *comment);
/* Comment to use for the archive */
void mz_zip_writer_set_raw(void *handle, uint8_t raw);
void mz_zip_writer_set_raw(void *handle, uint8_t raw);
/* Sets whether or not we should write the entry raw */
int32_t mz_zip_writer_get_raw(void *handle, uint8_t *raw);
/* Gets whether or not we should write the entry raw */
void mz_zip_writer_set_aes(void *handle, uint8_t aes);
void mz_zip_writer_set_aes(void *handle, uint8_t aes);
/* Use aes encryption when adding files in zip */
void mz_zip_writer_set_compress_method(void *handle, uint16_t compress_method);
void mz_zip_writer_set_compress_method(void *handle, uint16_t compress_method);
/* Sets the compression method when adding files in zip */
void mz_zip_writer_set_compress_level(void *handle, int16_t compress_level);
void mz_zip_writer_set_compress_level(void *handle, int16_t compress_level);
/* Sets the compression level when adding files in zip */
void mz_zip_writer_set_follow_links(void *handle, uint8_t follow_links);
void mz_zip_writer_set_follow_links(void *handle, uint8_t follow_links);
/* Follow symbolic links when traversing directories and files to add */
void mz_zip_writer_set_store_links(void *handle, uint8_t store_links);
void mz_zip_writer_set_store_links(void *handle, uint8_t store_links);
/* Store symbolic links in zip file */
void mz_zip_writer_set_zip_cd(void *handle, uint8_t zip_cd);
void mz_zip_writer_set_zip_cd(void *handle, uint8_t zip_cd);
/* Sets whether or not central directory should be zipped */
int32_t mz_zip_writer_set_certificate(void *handle, const char *cert_path, const char *cert_pwd);
/* Sets the certificate and timestamp url to use for signing when adding files in zip */
void mz_zip_writer_set_overwrite_cb(void *handle, void *userdata, mz_zip_writer_overwrite_cb cb);
void mz_zip_writer_set_overwrite_cb(void *handle, void *userdata, mz_zip_writer_overwrite_cb cb);
/* Callback for what to do when zip file already exists */
void mz_zip_writer_set_password_cb(void *handle, void *userdata, mz_zip_writer_password_cb cb);
void mz_zip_writer_set_password_cb(void *handle, void *userdata, mz_zip_writer_password_cb cb);
/* Callback for ask if a password is required for adding */
void mz_zip_writer_set_progress_cb(void *handle, void *userdata, mz_zip_writer_progress_cb cb);
void mz_zip_writer_set_progress_cb(void *handle, void *userdata, mz_zip_writer_progress_cb cb);
/* Callback for compression progress */
void mz_zip_writer_set_progress_interval(void *handle, uint32_t milliseconds);
void mz_zip_writer_set_progress_interval(void *handle, uint32_t milliseconds);
/* Let at least milliseconds pass between calls to progress callback */
void mz_zip_writer_set_entry_cb(void *handle, void *userdata, mz_zip_writer_entry_cb cb);
void mz_zip_writer_set_entry_cb(void *handle, void *userdata, mz_zip_writer_entry_cb cb);
/* Callback for zip file entries */
int32_t mz_zip_writer_get_zip_handle(void *handle, void **zip_handle);
/* Gets the underlying zip handle */
void* mz_zip_writer_create(void);
void *mz_zip_writer_create(void);
/* Create new instance of zip writer */
void mz_zip_writer_delete(void **handle);
void mz_zip_writer_delete(void **handle);
/* Delete instance of zip writer */
/***************************************************************************/