diff --git a/compat/crypt.h b/compat/crypt.h index 5eba242..46f2b67 100644 --- a/compat/crypt.h +++ b/compat/crypt.h @@ -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)) diff --git a/compat/ioapi.c b/compat/ioapi.c index aafe8ca..b0571ac 100644 --- a/compat/ioapi.c +++ b/compat/ioapi.c @@ -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}; /***************************************************************************/ diff --git a/compat/ioapi.h b/compat/ioapi.h index b81a12c..79cffc8 100644 --- a/compat/ioapi.h +++ b/compat/ioapi.h @@ -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 \ No newline at end of file +#endif diff --git a/compat/unzip.c b/compat/unzip.c index d02078d..aa025bb 100644 --- a/compat/unzip.c +++ b/compat/unzip.c @@ -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; diff --git a/compat/unzip.h b/compat/unzip.h index 3944e6b..7c24b60 100644 --- a/compat/unzip.h +++ b/compat/unzip.h @@ -19,8 +19,8 @@ extern "C" { #include -#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 */ \ No newline at end of file +#endif /* _unz64_H */ diff --git a/compat/zip.c b/compat/zip.c index 5fa110b..1c78d50 100644 --- a/compat/zip.c +++ b/compat/zip.c @@ -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) { diff --git a/compat/zip.h b/compat/zip.h index 4fce9ca..5c1f125 100644 --- a/compat/zip.h +++ b/compat/zip.h @@ -20,7 +20,7 @@ extern "C" { #include #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 } diff --git a/minizip.c b/minizip.c index fb68861..991ea49 100644 --- a/minizip.c +++ b/minizip.c @@ -18,23 +18,23 @@ #include "mz_zip.h" #include "mz_zip_rw.h" -#include /* printf */ +#include /* 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; diff --git a/mz_crypt.c b/mz_crypt.c index 4c8d659..0b068e0 100644 --- a/mz_crypt.c +++ b/mz_crypt.c @@ -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; diff --git a/mz_crypt.h b/mz_crypt.h index 1837af8..743cc3a 100644 --- a/mz_crypt.h +++ b/mz_crypt.h @@ -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); /***************************************************************************/ diff --git a/mz_crypt_apple.c b/mz_crypt_apple.c index 8485c6a..e3a9c67 100644 --- a/mz_crypt_apple.c +++ b/mz_crypt_apple.c @@ -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; /***************************************************************************/ diff --git a/mz_crypt_openssl.c b/mz_crypt_openssl.c index 1fda9d6..c96181e 100644 --- a/mz_crypt_openssl.c +++ b/mz_crypt_openssl.c @@ -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)); diff --git a/mz_crypt_winvista.c b/mz_crypt_winvista.c index 8eaa4dd..27311fd 100644 --- a/mz_crypt_winvista.c +++ b/mz_crypt_winvista.c @@ -19,11 +19,11 @@ #endif #if _WIN32_WINNT >= _WIN32_WINNT_VISTA -#include +# include /***************************************************************************/ -#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; diff --git a/mz_crypt_winxp.c b/mz_crypt_winxp.c index c9852c8..b96380a 100644 --- a/mz_crypt_winxp.c +++ b/mz_crypt_winxp.c @@ -15,7 +15,7 @@ #include #if _WIN32_WINNT <= _WIN32_WINNT_WINXP -#include +# include /***************************************************************************/ @@ -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(); diff --git a/mz_os.c b/mz_os.c index 57b1722..d8dcbf9 100644 --- a/mz_os.c +++ b/mz_os.c @@ -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; diff --git a/mz_os.h b/mz_os.h index ad6ea4f..4db0550 100644 --- a/mz_os.h +++ b/mz_os.h @@ -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 +# include #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); diff --git a/mz_os_posix.c b/mz_os_posix.c index 6736d09..6cbc434 100644 --- a/mz_os_posix.c +++ b/mz_os_posix.c @@ -15,7 +15,7 @@ #include /* rename */ #include #if defined(HAVE_ICONV) -#include +# include #endif #include #include @@ -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); diff --git a/mz_os_win32.c b/mz_os_win32.c index 808749b..b12d980 100644 --- a/mz_os_win32.c +++ b/mz_os_win32.c @@ -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); diff --git a/mz_strm.c b/mz_strm.c index edcbafa..f93198b 100644 --- a/mz_strm.c +++ b/mz_strm.c @@ -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}; /***************************************************************************/ diff --git a/mz_strm.h b/mz_strm.h index f65baab..5d09b7c 100644 --- a/mz_strm.h +++ b/mz_strm.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_buf.c b/mz_strm_buf.c index 441b6f7..c844459 100644 --- a/mz_strm_buf.c +++ b/mz_strm_buf.c @@ -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); } diff --git a/mz_strm_buf.h b/mz_strm_buf.h index 9850090..61b382f 100644 --- a/mz_strm_buf.h +++ b/mz_strm_buf.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_bzip.c b/mz_strm_bzip.c index ecd2c44..10027c5 100644 --- a/mz_strm_bzip.c +++ b/mz_strm_bzip.c @@ -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); diff --git a/mz_strm_bzip.h b/mz_strm_bzip.h index d8dcef5..06e3646 100644 --- a/mz_strm_bzip.h +++ b/mz_strm_bzip.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_libcomp.c b/mz_strm_libcomp.c index a222f20..436d07f 100644 --- a/mz_strm_libcomp.c +++ b/mz_strm_libcomp.c @@ -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; /***************************************************************************/ diff --git a/mz_strm_libcomp.h b/mz_strm_libcomp.h index f58c764..bd73c5f 100644 --- a/mz_strm_libcomp.h +++ b/mz_strm_libcomp.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_lzma.c b/mz_strm_lzma.c index 5bedb72..b91d32b 100644 --- a/mz_strm_lzma.c +++ b/mz_strm_lzma.c @@ -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; /***************************************************************************/ diff --git a/mz_strm_lzma.h b/mz_strm_lzma.h index 26d9b9e..6a60f7f 100644 --- a/mz_strm_lzma.h +++ b/mz_strm_lzma.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_mem.c b/mz_strm_mem.c index 45881b2..7ef07d5 100644 --- a/mz_strm_mem.c +++ b/mz_strm_mem.c @@ -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; diff --git a/mz_strm_mem.h b/mz_strm_mem.h index ed6f957..1055634 100644 --- a/mz_strm_mem.h +++ b/mz_strm_mem.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_os.h b/mz_strm_os.h index 0ed279f..d6846d8 100644 --- a/mz_strm_os.h +++ b/mz_strm_os.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_os_posix.c b/mz_strm_os_posix.c index b351ebb..f76b878 100644 --- a/mz_strm_os_posix.c +++ b/mz_strm_os_posix.c @@ -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; /***************************************************************************/ diff --git a/mz_strm_os_win32.c b/mz_strm_os_win32.c index c4198cc..d79da7b 100644 --- a/mz_strm_os_win32.c +++ b/mz_strm_os_win32.c @@ -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); diff --git a/mz_strm_pkcrypt.c b/mz_strm_pkcrypt.c index 4116329..04fcb60 100644 --- a/mz_strm_pkcrypt.c +++ b/mz_strm_pkcrypt.c @@ -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; diff --git a/mz_strm_pkcrypt.h b/mz_strm_pkcrypt.h index d9bdbaa..5c4f8d0 100644 --- a/mz_strm_pkcrypt.h +++ b/mz_strm_pkcrypt.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_split.c b/mz_strm_split.c index 9cb6ca2..b960f17 100644 --- a/mz_strm_split.c +++ b/mz_strm_split.c @@ -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 { diff --git a/mz_strm_split.h b/mz_strm_split.h index a5b74ed..2877f25 100644 --- a/mz_strm_split.h +++ b/mz_strm_split.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_wzaes.c b/mz_strm_wzaes.c index f1299c8..a0c9fac 100644 --- a/mz_strm_wzaes.c +++ b/mz_strm_wzaes.c @@ -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; diff --git a/mz_strm_wzaes.h b/mz_strm_wzaes.h index 788166e..ac20655 100644 --- a/mz_strm_wzaes.h +++ b/mz_strm_wzaes.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_zlib.c b/mz_strm_zlib.c index 5734cf7..c6557de 100644 --- a/mz_strm_zlib.c +++ b/mz_strm_zlib.c @@ -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 diff --git a/mz_strm_zlib.h b/mz_strm_zlib.h index bba0991..89f10f2 100644 --- a/mz_strm_zlib.h +++ b/mz_strm_zlib.h @@ -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); /***************************************************************************/ diff --git a/mz_strm_zstd.c b/mz_strm_zstd.c index 1741e2a..18c3b54 100644 --- a/mz_strm_zstd.c +++ b/mz_strm_zstd.c @@ -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; /***************************************************************************/ diff --git a/mz_strm_zstd.h b/mz_strm_zstd.h index 46f7e0f..d1bc66d 100644 --- a/mz_strm_zstd.h +++ b/mz_strm_zstd.h @@ -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); /***************************************************************************/ diff --git a/mz_zip.c b/mz_zip.c index 9cebfc2..139a874 100644 --- a/mz_zip.c +++ b/mz_zip.c @@ -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: diff --git a/mz_zip.h b/mz_zip.h index 5d38f86..6f1ddec 100644 --- a/mz_zip.h +++ b/mz_zip.h @@ -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 */ /***************************************************************************/ diff --git a/mz_zip_rw.c b/mz_zip_rw.c index 3cae9c5..7b7654a 100644 --- a/mz_zip_rw.c +++ b/mz_zip_rw.c @@ -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; diff --git a/mz_zip_rw.h b/mz_zip_rw.h index 71f267e..39bb34a 100644 --- a/mz_zip_rw.h +++ b/mz_zip_rw.h @@ -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 */ /***************************************************************************/