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

Use same brace style as zlib.

Browse Source
This commit is contained in:
Nathan Moinvaziri 2020-06-14 15:19:14 -07:00
parent 3f1d2a4854
commit dc6962b5fa
28 changed files with 1449 additions and 2917 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
minigzip.c
View File

@ -28,15 +28,13 @@ int32_t minigzip_help(void);
/***************************************************************************/
int32_t minigzip_banner(void)
{
int32_t minigzip_banner(void) {
printf("Minigzip %s - https://github.com/nmoinvaz/minizip\n", MZ_VERSION);
printf("---------------------------------------------------\n");
return MZ_OK;
}
int32_t minigzip_help(void)
{
int32_t minigzip_help(void) {
printf("Usage: minigzip [-x] [-d] [-0 to -9] [files]\n\n" \
" -x Extract file\n" \
" -d Destination directory\n" \
@ -48,8 +46,7 @@ int32_t minigzip_help(void)
/***************************************************************************/
int32_t minigzip_copy(const char *path, const char *destination, int16_t operation, int16_t level)
{
int32_t minigzip_copy(const char *path, const char *destination, int16_t operation, int16_t level) {
void *target_stream = NULL;
void *source_stream = NULL;
void *zlib_stream = NULL;
@ -60,20 +57,16 @@ int32_t minigzip_copy(const char *path, const char *destination, int16_t operati
memset(target_path, 0, sizeof(target_path));
if (destination != NULL)
{
if (destination != NULL) {
if (mz_os_file_exists(destination) != MZ_OK)
mz_dir_make(destination);
}
if (operation == MZ_GZIP_COMPRESS)
{
if (operation == MZ_GZIP_COMPRESS) {
mz_path_combine(target_path, path, sizeof(target_path));
strncat(target_path, ".gz", sizeof(target_path) - strlen(target_path) - 1);
printf("Compressing to %s\n", target_path);
}
else if (operation == MZ_GZIP_DECOMPRESS)
{
} else if (operation == MZ_GZIP_DECOMPRESS) {
if (destination != NULL)
mz_path_combine(target_path, destination, sizeof(target_path));
@ -91,22 +84,17 @@ int32_t minigzip_copy(const char *path, const char *destination, int16_t operati
mz_stream_os_create(&source_stream);
err = mz_stream_os_open(source_stream, path, MZ_OPEN_MODE_READ);
if (err == MZ_OK)
{
if (err == MZ_OK) {
mz_stream_os_create(&target_stream);
err = mz_stream_os_open(target_stream, target_path, MZ_OPEN_MODE_CREATE | MZ_OPEN_MODE_WRITE);
if (err == MZ_OK)
{
if (operation == MZ_GZIP_COMPRESS)
{
if (err == MZ_OK) {
if (operation == MZ_GZIP_COMPRESS) {
mz_stream_zlib_set_prop_int64(zlib_stream, MZ_STREAM_PROP_COMPRESS_LEVEL, level);
mz_stream_zlib_open(zlib_stream, target_path, MZ_OPEN_MODE_WRITE);
mz_stream_set_base(zlib_stream, target_stream);
err = mz_stream_copy_to_end(zlib_stream, source_stream);
}
else if (operation == MZ_GZIP_DECOMPRESS)
{
} else if (operation == MZ_GZIP_DECOMPRESS) {
mz_stream_zlib_open(zlib_stream, path, MZ_OPEN_MODE_READ);
mz_stream_set_base(zlib_stream, source_stream);
err = mz_stream_copy_to_end(target_stream, zlib_stream);
@ -118,17 +106,13 @@ int32_t minigzip_copy(const char *path, const char *destination, int16_t operati
printf("Operation completed successfully\n");
mz_stream_zlib_close(zlib_stream);
}
else
{
} else {
printf("Error %d opening target path %s\n", err, target_path);
}
mz_stream_os_close(target_stream);
mz_stream_os_delete(&target_stream);
}
else
{
} else {
printf("Error %d opening source path %s\n", err, path);
}
@ -142,8 +126,7 @@ int32_t minigzip_copy(const char *path, const char *destination, int16_t operati
/***************************************************************************/
#if !defined(MZ_ZIP_NO_MAIN)
int main(int argc, const char *argv[])
{
int main(int argc, const char *argv[]) {
int16_t operation_level = MZ_COMPRESS_LEVEL_DEFAULT;
int32_t path_arg = 0;
int32_t err = 0;
@ -154,50 +137,40 @@ int main(int argc, const char *argv[])
minigzip_banner();
if (argc == 1)
{
if (argc == 1) {
minigzip_help();
return 0;
}
/* Parse command line options */
for (i = 1; i < argc; i += 1)
{
for (i = 1; i < argc; i += 1) {
printf("%s ", argv[i]);
if (argv[i][0] == '-')
{
if (argv[i][0] == '-') {
char c = argv[i][1];
if ((c == 'x') || (c == 'X'))
operation = MZ_GZIP_DECOMPRESS;
else if ((c >= '0') && (c <= '9'))
operation_level = (c - '0');
else if (((c == 'd') || (c == 'D')) && (i + 1 < argc))
{
else if (((c == 'd') || (c == 'D')) && (i + 1 < argc)) {
destination = argv[i + 1];
printf("%s ", argv[i + 1]);
i += 1;
}
else
{
} else {
err = MZ_SUPPORT_ERROR;
}
}
else if (path_arg == 0)
{
} else if (path_arg == 0) {
path_arg = i;
break;
}
}
printf("\n");
if (err == MZ_SUPPORT_ERROR)
{
if (err == MZ_SUPPORT_ERROR) {
printf("Feature not supported\n");
return err;
}
if (path_arg == 0)
{
if (path_arg == 0) {
minigzip_help();
return 0;
}

228
minizip.c
View File

@ -62,15 +62,13 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
/***************************************************************************/
int32_t minizip_banner(void)
{
int32_t minizip_banner(void) {
printf("Minizip %s - https://github.com/nmoinvaz/minizip\n", MZ_VERSION);
printf("---------------------------------------------------\n");
return MZ_OK;
}
int32_t minizip_help(void)
{
int32_t minizip_help(void) {
printf("Usage: minizip [-x][-d dir|-l|-e][-o][-f][-y][-c cp][-a][-0 to -9][-b|-m][-k 512][-p pwd][-s] file.zip [files]\n\n" \
" -x Extract files\n" \
" -l List files\n" \
@ -99,8 +97,7 @@ int32_t minizip_help(void)
/***************************************************************************/
int32_t minizip_list(const char *path)
{
int32_t minizip_list(const char *path) {
mz_zip_file *file_info = NULL;
uint32_t ratio = 0;
int16_t level = 0;
@ -113,8 +110,7 @@ int32_t minizip_list(const char *path)
mz_zip_reader_create(&reader);
err = mz_zip_reader_open_file(reader, path);
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " opening archive %s\n", err, path);
mz_zip_reader_delete(&reader);
return err;
@ -122,8 +118,7 @@ int32_t minizip_list(const char *path)
err = mz_zip_reader_goto_first_entry(reader);
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
if (err != MZ_OK && err != MZ_END_OF_LIST) {
printf("Error %" PRId32 " going to first entry in archive\n", err);
mz_zip_reader_delete(&reader);
return err;
@ -133,12 +128,10 @@ int32_t minizip_list(const char *path)
printf(" ------ -------- ----- ------ ------- ---- ---- ------ ----\n");
/* Enumerate all entries in the archive */
do
{
do {
err = mz_zip_reader_entry_get_info(reader, &file_info);
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " getting entry info in archive\n", err);
break;
}
@ -153,8 +146,7 @@ int32_t minizip_list(const char *path)
else
crypt = ' ';
switch (file_info->compression_method)
{
switch (file_info->compression_method) {
case MZ_COMPRESS_METHOD_STORE:
string_method = "Stored";
break;
@ -184,22 +176,20 @@ int32_t minizip_list(const char *path)
/* 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,
string_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);
file_info->compressed_size, file_info->uncompressed_size, ratio,
string_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);
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
if (err != MZ_OK && err != MZ_END_OF_LIST) {
printf("Error %" PRId32 " going to next entry in archive\n", err);
break;
}
}
while (err == MZ_OK);
} while (err == MZ_OK);
mz_zip_reader_delete(&reader);
@ -211,8 +201,7 @@ int32_t minizip_list(const char *path)
/***************************************************************************/
int32_t minizip_add_entry_cb(void *handle, void *userdata, mz_zip_file *file_info)
{
int32_t minizip_add_entry_cb(void *handle, void *userdata, mz_zip_file *file_info) {
MZ_UNUSED(handle);
MZ_UNUSED(userdata);
@ -221,8 +210,7 @@ int32_t minizip_add_entry_cb(void *handle, void *userdata, mz_zip_file *file_inf
return MZ_OK;
}
int32_t minizip_add_progress_cb(void *handle, void *userdata, mz_zip_file *file_info, int64_t position)
{
int32_t minizip_add_progress_cb(void *handle, void *userdata, mz_zip_file *file_info, int64_t position) {
minizip_opt *options = (minizip_opt *)userdata;
double progress = 0;
uint8_t raw = 0;
@ -243,18 +231,15 @@ int32_t minizip_add_progress_cb(void *handle, void *userdata, mz_zip_file *file_
return MZ_OK;
}
int32_t minizip_add_overwrite_cb(void *handle, void *userdata, const char *path)
{
int32_t minizip_add_overwrite_cb(void *handle, void *userdata, const char *path) {
minizip_opt *options = (minizip_opt *)userdata;
MZ_UNUSED(handle);
if (options->overwrite == 0)
{
if (options->overwrite == 0) {
/* If ask the user what to do because append and overwrite args not set */
char rep = 0;
do
{
do {
char answer[128];
printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ", path);
if (scanf("%1s", answer) != 1)
@ -263,15 +248,11 @@ int32_t minizip_add_overwrite_cb(void *handle, void *userdata, const char *path)
if ((rep >= 'a') && (rep <= 'z'))
rep -= 0x20;
}
while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
} while ((rep != 'Y') && (rep != 'N') && (rep != 'A'));
if (rep == 'A')
{
if (rep == 'A') {
return MZ_EXIST_ERROR;
}
else if (rep == 'N')
{
} else if (rep == 'N') {
return MZ_INTERNAL_ERROR;
}
}
@ -279,8 +260,7 @@ 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;
@ -306,10 +286,8 @@ int32_t minizip_add(const char *path, const char *password, minizip_opt *options
err = mz_zip_writer_open_file(writer, path, options->disk_size, options->append);
if (err == MZ_OK)
{
for (i = 0; i < arg_count; i += 1)
{
if (err == MZ_OK) {
for (i = 0; i < arg_count; i += 1) {
filename_in_zip = args[i];
/* Add file system path to archive */
@ -317,15 +295,12 @@ int32_t minizip_add(const char *path, const char *password, minizip_opt *options
if (err != MZ_OK)
printf("Error %" PRId32 " adding path to archive %s\n", err, filename_in_zip);
}
}
else
{
} else {
printf("Error %" PRId32 " opening archive for writing\n", err);
}
err_close = mz_zip_writer_close(writer);
if (err_close != MZ_OK)
{
if (err_close != MZ_OK) {
printf("Error %" PRId32 " closing archive for writing %s\n", err_close, path);
err = err_close;
}
@ -336,8 +311,7 @@ int32_t minizip_add(const char *path, const char *password, minizip_opt *options
/***************************************************************************/
int32_t minizip_extract_entry_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path)
{
int32_t minizip_extract_entry_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path) {
MZ_UNUSED(handle);
MZ_UNUSED(userdata);
MZ_UNUSED(path);
@ -347,8 +321,7 @@ int32_t minizip_extract_entry_cb(void *handle, void *userdata, mz_zip_file *file
return MZ_OK;
}
int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *file_info, int64_t position)
{
int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *file_info, int64_t position) {
minizip_opt *options = (minizip_opt *)userdata;
double progress = 0;
uint8_t raw = 0;
@ -370,19 +343,16 @@ int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *f
return MZ_OK;
}
int32_t minizip_extract_overwrite_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path)
{
int32_t minizip_extract_overwrite_cb(void *handle, void *userdata, mz_zip_file *file_info, const char *path) {
minizip_opt *options = (minizip_opt *)userdata;
MZ_UNUSED(handle);
MZ_UNUSED(file_info);
/* Verify if we want to overwrite current entry on disk */
if (options->overwrite == 0)
{
if (options->overwrite == 0) {
char rep = 0;
do
{
do {
char answer[128];
printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ", path);
if (scanf("%1s", answer) != 1)
@ -401,8 +371,7 @@ 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;
@ -421,36 +390,26 @@ int32_t minizip_extract(const char *path, const char *pattern, const char *desti
err = mz_zip_reader_open_file(reader, path);
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " opening archive %s\n", err, path);
}
else
{
} else {
/* Save all entries in archive to destination directory */
err = mz_zip_reader_save_all(reader, destination);
if (err == MZ_END_OF_LIST)
{
if (pattern != NULL)
{
if (err == MZ_END_OF_LIST) {
if (pattern != NULL) {
printf("Files matching %s not found in archive\n", pattern);
}
else
{
} else {
printf("No files in archive\n");
err = MZ_OK;
}
}
else if (err != MZ_OK)
{
} else if (err != MZ_OK) {
printf("Error %" PRId32 " saving entries to disk %s\n", err, path);
}
}
err_close = mz_zip_reader_close(reader);
if (err_close != MZ_OK)
{
if (err_close != MZ_OK) {
printf("Error %" PRId32 " closing archive for reading\n", err_close);
err = err_close;
}
@ -461,8 +420,7 @@ int32_t minizip_extract(const char *path, const char *pattern, const char *desti
/***************************************************************************/
int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg_count, const char **args)
{
int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg_count, const char **args) {
mz_zip_file *file_info = NULL;
const char *filename_in_zip = NULL;
const char *target_path_ptr = target_path;
@ -475,8 +433,7 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
char bak_path[256];
char tmp_path[256];
if (target_path == NULL)
{
if (target_path == NULL) {
/* Construct temporary zip name */
strncpy(tmp_path, src_path, sizeof(tmp_path) - 1);
tmp_path[sizeof(tmp_path) - 1] = 0;
@ -489,8 +446,7 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
/* Open original archive we want to erase an entry in */
err = mz_zip_reader_open_file(reader, src_path);
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " opening archive for reading %s\n", err, src_path);
mz_zip_reader_delete(&reader);
return err;
@ -498,8 +454,7 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
/* Open temporary archive */
err = mz_zip_writer_open_file(writer, target_path_ptr, 0, 0);
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " opening archive for writing %s\n", err, target_path_ptr);
mz_zip_reader_delete(&reader);
mz_zip_writer_delete(&writer);
@ -511,37 +466,30 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
if (err != MZ_OK && err != MZ_END_OF_LIST)
printf("Error %" PRId32 " going to first entry in archive\n", err);
while (err == MZ_OK)
{
while (err == MZ_OK) {
err = mz_zip_reader_entry_get_info(reader, &file_info);
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " getting info from archive\n", err);
break;
}
/* Copy all entries from original archive to temporary archive
except the ones we don't want */
for (i = 0, skip = 0; i < arg_count; i += 1)
{
for (i = 0, skip = 0; i < arg_count; i += 1) {
filename_in_zip = args[i];
if (mz_path_compare_wc(file_info->filename, filename_in_zip, 1) == MZ_OK)
skip = 1;
}
if (skip)
{
if (skip) {
printf("Skipping %s\n", file_info->filename);
}
else
{
} else {
printf("Copying %s\n", file_info->filename);
err = mz_zip_writer_copy_from_reader(writer, reader);
}
if (err != MZ_OK)
{
if (err != MZ_OK) {
printf("Error %" PRId32 " copying entry into new zip\n", err);
break;
}
@ -561,10 +509,8 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
mz_zip_writer_close(writer);
mz_zip_writer_delete(&writer);
if (err == MZ_END_OF_LIST)
{
if (target_path == NULL)
{
if (err == MZ_END_OF_LIST) {
if (target_path == NULL) {
/* Swap original archive with temporary archive, backup old archive if possible */
strncpy(bak_path, src_path, sizeof(bak_path) - 1);
bak_path[sizeof(bak_path) - 1] = 0;
@ -589,8 +535,7 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
/***************************************************************************/
#if !defined(MZ_ZIP_NO_MAIN)
int main(int argc, const char *argv[])
{
int main(int argc, const char *argv[]) {
minizip_opt options;
int32_t path_arg = 0;
int32_t err = 0;
@ -605,8 +550,7 @@ int main(int argc, const char *argv[])
minizip_banner();
if (argc == 1)
{
if (argc == 1) {
minizip_help();
return 0;
}
@ -617,11 +561,9 @@ int main(int argc, const char *argv[])
options.compress_level = MZ_COMPRESS_LEVEL_DEFAULT;
/* Parse command line options */
for (i = 1; i < argc; i += 1)
{
for (i = 1; i < argc; i += 1) {
printf("%s ", argv[i]);
if (argv[i][0] == '-')
{
if (argv[i][0] == '-') {
char c = argv[i][1];
if ((c == 'l') || (c == 'L'))
do_list = 1;
@ -643,13 +585,11 @@ int main(int argc, const char *argv[])
options.zip_cd = 1;
else if ((c == 'v') || (c == 'V'))
options.verbose = 1;
else if ((c >= '0') && (c <= '9'))
{
else if ((c >= '0') && (c <= '9')) {
options.compress_level = (c - '0');
if (options.compress_level == 0)
options.compress_method = MZ_COMPRESS_METHOD_STORE;
}
else if ((c == 'b') || (c == 'B'))
} else if ((c == 'b') || (c == 'B'))
#ifdef HAVE_BZIP2
options.compress_method = MZ_COMPRESS_METHOD_BZIP2;
#else
@ -667,8 +607,7 @@ int main(int argc, const char *argv[])
#else
err = MZ_SUPPORT_ERROR;
#endif
else if (((c == 'h') || (c == 'H')) && (i + 1 < argc))
{
else if (((c == 'h') || (c == 'H')) && (i + 1 < argc)) {
#ifdef MZ_ZIP_SIGNING
options.cert_path = argv[i + 1];
printf("%s ", argv[i + 1]);
@ -676,9 +615,7 @@ int main(int argc, const char *argv[])
err = MZ_SUPPORT_ERROR;
#endif
i += 1;
}
else if (((c == 'w') || (c == 'W')) && (i + 1 < argc))
{
} else if (((c == 'w') || (c == 'W')) && (i + 1 < argc)) {
#ifdef MZ_ZIP_SIGNING
options.cert_pwd = argv[i + 1];
printf("%s ", argv[i + 1]);
@ -686,26 +623,18 @@ int main(int argc, const char *argv[])
err = MZ_SUPPORT_ERROR;
#endif
i += 1;
}
else if (((c == 'c') || (c == 'C')) && (i + 1 < argc))
{
} else if (((c == 'c') || (c == 'C')) && (i + 1 < argc)) {
options.encoding = (int32_t)atoi(argv[i + 1]);
i += 1;
}
else if (((c == 'k') || (c == 'K')) && (i + 1 < argc))
{
} else if (((c == 'k') || (c == 'K')) && (i + 1 < argc)) {
options.disk_size = (int64_t)atoi(argv[i + 1]) * 1024;
printf("%s ", argv[i + 1]);
i += 1;
}
else if (((c == 'd') || (c == 'D')) && (i + 1 < argc))
{
} else if (((c == 'd') || (c == 'D')) && (i + 1 < argc)) {
destination = argv[i + 1];
printf("%s ", argv[i + 1]);
i += 1;
}
else if (((c == 'p') || (c == 'P')) && (i + 1 < argc))
{
} else if (((c == 'p') || (c == 'P')) && (i + 1 < argc)) {
#ifndef MZ_ZIP_NO_ENCRYPTION
password = argv[i + 1];
printf("*** ");
@ -714,47 +643,36 @@ int main(int argc, const char *argv[])
#endif
i += 1;
}
}
else if (path_arg == 0)
} else if (path_arg == 0)
path_arg = i;
}
printf("\n");
if (err == MZ_SUPPORT_ERROR)
{
if (err == MZ_SUPPORT_ERROR) {
printf("Feature not supported\n");
return err;
}
if (path_arg == 0)
{
if (path_arg == 0) {
minizip_help();
return 0;
}
path = argv[path_arg];
if (do_list)
{
if (do_list) {
/* List archive contents */
err = minizip_list(path);
}
else if (do_extract)
{
} else if (do_extract) {
if (argc > path_arg + 1)
filename_to_extract = argv[path_arg + 1];
/* Extract archive */
err = minizip_extract(path, filename_to_extract, destination, password, &options);
}
else if (do_erase)
{
} else if (do_erase) {
/* Erase file in archive */
err = minizip_erase(path, NULL, argc - (path_arg + 1), &argv[path_arg + 1]);
}
else
{
} else {
/* Add files to archive */
err = minizip_add(path, password, &options, argc - (path_arg + 1), &argv[path_arg + 1]);
}

329
mz_compat.c
View File

@ -36,11 +36,9 @@ typedef struct mz_compat_s {
/***************************************************************************/
static int32_t zipConvertAppendToStreamMode(int append)
{
static int32_t zipConvertAppendToStreamMode(int append) {
int32_t mode = MZ_OPEN_MODE_WRITE;
switch (append)
{
switch (append) {
case APPEND_STATUS_CREATE:
mode |= MZ_OPEN_MODE_CREATE;
break;
@ -54,52 +52,43 @@ static int32_t zipConvertAppendToStreamMode(int append)
return mode;
}
zipFile zipOpen(const char *path, int append)
{
zipFile zipOpen(const char *path, int append) {
zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
return zipOpen2(path, append, NULL, &pzlib);
}
zipFile zipOpen64(const void *path, int append)
{
zipFile zipOpen64(const void *path, int append) {
zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
return zipOpen2(path, append, NULL, &pzlib);
}
zipFile zipOpen2(const char *path, int append, const char **globalcomment,
zlib_filefunc_def *pzlib_filefunc_def)
{
zlib_filefunc_def *pzlib_filefunc_def) {
return zipOpen2_64(path, append, globalcomment, pzlib_filefunc_def);
}
zipFile zipOpen2_64(const void *path, int append, const char **globalcomment,
zlib_filefunc64_def *pzlib_filefunc_def)
{
zlib_filefunc64_def *pzlib_filefunc_def) {
zipFile zip = NULL;
int32_t mode = zipConvertAppendToStreamMode(append);
void *stream = NULL;
if (pzlib_filefunc_def)
{
if (pzlib_filefunc_def) {
if (mz_stream_create(&stream, (mz_stream_vtbl *)*pzlib_filefunc_def) == NULL)
return NULL;
}
else
{
} else {
if (mz_stream_os_create(&stream) == NULL)
return NULL;
}
if (mz_stream_open(stream, path, mode) != MZ_OK)
{
if (mz_stream_open(stream, path, mode) != MZ_OK) {
mz_stream_delete(&stream);
return NULL;
}
zip = zipOpen_MZ(stream, append, globalcomment);
if (zip == NULL)
{
if (zip == NULL) {
mz_stream_delete(&stream);
return NULL;
}
@ -107,8 +96,7 @@ zipFile zipOpen2_64(const void *path, int append, const char **globalcomment,
return zip;
}
zipFile zipOpen_MZ(void *stream, int append, const char **globalcomment)
{
zipFile zipOpen_MZ(void *stream, int append, const char **globalcomment) {
mz_compat *compat = NULL;
int32_t err = MZ_OK;
int32_t mode = zipConvertAppendToStreamMode(append);
@ -117,8 +105,7 @@ zipFile zipOpen_MZ(void *stream, int append, const char **globalcomment)
mz_zip_create(&handle);
err = mz_zip_open(handle, stream, mode);
if (err != MZ_OK)
{
if (err != MZ_OK) {
mz_zip_delete(&handle);
return NULL;
}
@ -127,29 +114,24 @@ zipFile zipOpen_MZ(void *stream, int append, const char **globalcomment)
mz_zip_get_comment(handle, globalcomment);
compat = (mz_compat *)MZ_ALLOC(sizeof(mz_compat));
if (compat != NULL)
{
if (compat != NULL) {
compat->handle = handle;
compat->stream = stream;
}
else
{
} else {
mz_zip_delete(&handle);
}
return (zipFile)compat;
}
void* zipGetHandle_MZ(zipFile file)
{
void* zipGetHandle_MZ(zipFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return NULL;
return compat->handle;
}
void* zipGetStream_MZ(zipFile file)
{
void* zipGetStream_MZ(zipFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return NULL;
@ -160,8 +142,7 @@ int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t 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)
{
unsigned long crc_for_crypting, unsigned long version_madeby, unsigned long flag_base, int zip64) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file file_info;
@ -177,8 +158,7 @@ int zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo
memset(&file_info, 0, sizeof(file_info));
if (zipfi != NULL)
{
if (zipfi != NULL) {
uint64_t dos_date = 0;
if (zipfi->mz_dos_date != 0)
@ -221,8 +201,7 @@ int zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_filein
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t 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)
{
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);
@ -232,8 +211,7 @@ int zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t 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)
{
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);
@ -243,8 +221,7 @@ int zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
unsigned long crc_for_crypting)
{
unsigned long crc_for_crypting) {
return zipOpenNewFileInZip3_64(file, filename, zipfi, extrafield_local, size_extrafield_local,
extrafield_global, size_extrafield_global, comment, compression_method, level, raw, windowBits,
memLevel, strategy, password, crc_for_crypting, 0);
@ -254,8 +231,7 @@ int zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_filein
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
uint32_t crc_for_crypting, int zip64)
{
uint32_t 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);
@ -264,8 +240,7 @@ int zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_filein
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, uint16_t compression_method, int level,
int raw)
{
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);
@ -274,8 +249,7 @@ int zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo
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, uint16_t compression_method, int level,
int raw, int zip64)
{
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);
@ -283,8 +257,7 @@ int zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_filein
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, uint16_t compression_method, int level)
{
uint16_t size_extrafield_global, const char *comment, uint16_t 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);
}
@ -292,14 +265,12 @@ int zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *
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, uint16_t compression_method, int level,
int zip64)
{
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)
{
int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len) {
mz_compat *compat = (mz_compat *)file;
int32_t written = 0;
if (compat == NULL || len >= INT32_MAX)
@ -310,52 +281,44 @@ int zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len)
return ZIP_OK;
}
int zipCloseFileInZipRaw(zipFile file, unsigned long uncompressed_size, unsigned long crc32)
{
int zipCloseFileInZipRaw(zipFile file, unsigned long uncompressed_size, unsigned long crc32) {
return zipCloseFileInZipRaw64(file, uncompressed_size, crc32);
}
int zipCloseFileInZipRaw64(zipFile file, int64_t uncompressed_size, unsigned long crc32)
{
int zipCloseFileInZipRaw64(zipFile file, int64_t uncompressed_size, unsigned long crc32) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return ZIP_PARAMERROR;
return mz_zip_entry_close_raw(compat->handle, uncompressed_size, crc32);
}
int zipCloseFileInZip(zipFile file)
{
int zipCloseFileInZip(zipFile file) {
return zipCloseFileInZip64(file);
}
int zipCloseFileInZip64(zipFile file)
{
int zipCloseFileInZip64(zipFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return ZIP_PARAMERROR;
return mz_zip_entry_close(compat->handle);
}
int zipClose(zipFile file, const char *global_comment)
{
int zipClose(zipFile file, const char *global_comment) {
return zipClose_64(file, global_comment);
}
int zipClose_64(zipFile file, const char *global_comment)
{
int zipClose_64(zipFile file, const char *global_comment) {
return zipClose2_64(file, global_comment, MZ_VERSION_MADEBY);
}
int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby)
{
int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
if (compat->handle != NULL)
err = zipClose2_MZ(file, global_comment, version_madeby);
if (compat->stream != NULL)
{
if (compat->stream != NULL) {
mz_stream_close(compat->stream);
mz_stream_delete(&compat->stream);
}
@ -366,14 +329,12 @@ int zipClose2_64(zipFile file, const char *global_comment, uint16_t version_made
}
/* Only closes the zip handle, does not close the stream */
int zipClose_MZ(zipFile file, const char *global_comment)
{
int zipClose_MZ(zipFile file, const char *global_comment) {
return zipClose2_MZ(file, global_comment, MZ_VERSION_MADEBY);
}
/* Only closes the zip handle, does not close the stream */
int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_madeby)
{
int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_madeby) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
@ -394,47 +355,38 @@ int zipClose2_MZ(zipFile file, const char *global_comment, uint16_t version_made
/***************************************************************************/
unzFile unzOpen(const char *path)
{
unzFile unzOpen(const char *path) {
return unzOpen64(path);
}
unzFile unzOpen64(const void *path)
{
unzFile unzOpen64(const void *path) {
zlib_filefunc64_def pzlib = mz_stream_os_get_interface();
return unzOpen2(path, &pzlib);
}
unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def)
{
unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def) {
return unzOpen2_64(path, pzlib_filefunc_def);
}
unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def)
{
unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def) {
unzFile unz = NULL;
void *stream = NULL;
if (pzlib_filefunc_def)
{
if (pzlib_filefunc_def) {
if (mz_stream_create(&stream, (mz_stream_vtbl *)*pzlib_filefunc_def) == NULL)
return NULL;
}
else
{
} else {
if (mz_stream_os_create(&stream) == NULL)
return NULL;
}
if (mz_stream_open(stream, path, MZ_OPEN_MODE_READ) != MZ_OK)
{
if (mz_stream_open(stream, path, MZ_OPEN_MODE_READ) != MZ_OK) {
mz_stream_delete(&stream);
return NULL;
}
unz = unzOpen_MZ(stream);
if (unz == NULL)
{
if (unz == NULL) {
mz_stream_close(stream);
mz_stream_delete(&stream);
return NULL;
@ -442,24 +394,21 @@ 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_compat *compat = (mz_compat *)file;
if (compat == NULL)
return NULL;
return compat->handle;
}
void* unzGetStream_MZ(unzFile file)
{
void* unzGetStream_MZ(unzFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return NULL;
return compat->stream;
}
unzFile unzOpen_MZ(void *stream)
{
unzFile unzOpen_MZ(void *stream) {
mz_compat *compat = NULL;
int32_t err = MZ_OK;
void *handle = NULL;
@ -467,30 +416,25 @@ unzFile unzOpen_MZ(void *stream)
mz_zip_create(&handle);
err = mz_zip_open(handle, stream, MZ_OPEN_MODE_READ);
if (err != MZ_OK)
{
if (err != MZ_OK) {
mz_zip_delete(&handle);
return NULL;
}
compat = (mz_compat *)MZ_ALLOC(sizeof(mz_compat));
if (compat != NULL)
{
if (compat != NULL) {
compat->handle = handle;
compat->stream = stream;
mz_zip_goto_first_entry(compat->handle);
}
else
{
} else {
mz_zip_delete(&handle);
}
return (unzFile)compat;
}
int unzClose(unzFile file)
{
int unzClose(unzFile file) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
@ -500,8 +444,7 @@ int unzClose(unzFile file)
if (compat->handle != NULL)
err = unzClose_MZ(file);
if (compat->stream != NULL)
{
if (compat->stream != NULL) {
mz_stream_close(compat->stream);
mz_stream_delete(&compat->stream);
}
@ -512,8 +455,7 @@ int unzClose(unzFile file)
}
/* Only closes the zip handle, does not close the stream */
int unzClose_MZ(unzFile file)
{
int unzClose_MZ(unzFile file) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
@ -526,8 +468,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_compat *compat = (mz_compat *)file;
unz_global_info64 global_info64;
int32_t err = MZ_OK;
@ -537,8 +478,7 @@ int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)
return UNZ_PARAMERROR;
err = unzGetGlobalInfo64(file, &global_info64);
if (err == MZ_OK)
{
if (err == MZ_OK) {
pglobal_info32->number_entry = (uint32_t)global_info64.number_entry;
pglobal_info32->size_comment = global_info64.size_comment;
pglobal_info32->number_disk_with_CD = global_info64.number_disk_with_CD;
@ -546,8 +486,7 @@ int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)
return err;
}
int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
{
int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info) {
mz_compat *compat = (mz_compat *)file;
const char *comment_ptr = NULL;
int32_t err = MZ_OK;
@ -565,8 +504,7 @@ int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
return err;
}
int unzGetGlobalComment(unzFile file, char *comment, unsigned long comment_size)
{
int unzGetGlobalComment(unzFile file, char *comment, unsigned long comment_size) {
mz_compat *compat = (mz_compat *)file;
const char *comment_ptr = NULL;
int32_t err = MZ_OK;
@ -574,16 +512,14 @@ int unzGetGlobalComment(unzFile file, char *comment, unsigned long comment_size)
if (comment == NULL || comment_size == 0)
return UNZ_PARAMERROR;
err = mz_zip_get_comment(compat->handle, &comment_ptr);
if (err == MZ_OK)
{
if (err == MZ_OK) {
strncpy(comment, comment_ptr, comment_size - 1);
comment[comment_size - 1] = 0;
}
return err;
}
int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password)
{
int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
int32_t err = MZ_OK;
@ -600,18 +536,14 @@ int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const ch
err = mz_zip_entry_read_open(compat->handle, (uint8_t)raw, password);
if (err == MZ_OK)
err = mz_zip_entry_get_info(compat->handle, &file_info);
if (err == MZ_OK)
{
if (method != NULL)
{
if (err == MZ_OK) {
if (method != NULL) {
*method = file_info->compression_method;
}
if (level != NULL)
{
if (level != NULL) {
*level = 6;
switch (file_info->flag & 0x06)
{
switch (file_info->flag & 0x06) {
case MZ_ZIP_FLAG_DEFLATE_SUPER_FAST:
*level = 1;
break;
@ -631,23 +563,19 @@ int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const ch
return err;
}
int unzOpenCurrentFile(unzFile file)
{
int unzOpenCurrentFile(unzFile file) {
return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
}
int unzOpenCurrentFilePassword(unzFile file, const char *password)
{
int unzOpenCurrentFilePassword(unzFile file, const char *password) {
return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
}
int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw)
{
int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw) {
return unzOpenCurrentFile3(file, method, level, raw, NULL);
}
int unzReadCurrentFile(unzFile file, void *buf, uint32_t len)
{
int unzReadCurrentFile(unzFile file, void *buf, uint32_t len) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
if (compat == NULL || len >= INT32_MAX)
@ -658,8 +586,7 @@ int unzReadCurrentFile(unzFile file, void *buf, uint32_t len)
return err;
}
int unzCloseCurrentFile(unzFile file)
{
int unzCloseCurrentFile(unzFile file) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
if (compat == NULL)
@ -670,8 +597,7 @@ int unzCloseCurrentFile(unzFile file)
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)
{
unsigned long comment_size) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
uint16_t bytes_to_copy = 0;
@ -682,8 +608,7 @@ int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filenam
err = mz_zip_entry_get_info(compat->handle, &file_info);
if ((err == MZ_OK) && (pfile_info != NULL))
{
if ((err == MZ_OK) && (pfile_info != NULL)) {
pfile_info->version = file_info->version_madeby;
pfile_info->version_needed = file_info->version_needed;
pfile_info->flag = file_info->flag;
@ -704,8 +629,7 @@ int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filenam
pfile_info->compressed_size = (uint32_t)file_info->compressed_size;
pfile_info->uncompressed_size = (uint32_t)file_info->uncompressed_size;
if (filename_size > 0 && filename != NULL && file_info->filename != NULL)
{
if (filename_size > 0 && filename != NULL && file_info->filename != NULL) {
bytes_to_copy = (uint16_t)filename_size;
if (bytes_to_copy > file_info->filename_size)
bytes_to_copy = file_info->filename_size;
@ -713,15 +637,13 @@ int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filenam
if (bytes_to_copy < filename_size)
filename[bytes_to_copy] = 0;
}
if (extrafield_size > 0 && extrafield != NULL)
{
if (extrafield_size > 0 && extrafield != NULL) {
bytes_to_copy = (uint16_t)extrafield_size;
if (bytes_to_copy > file_info->extrafield_size)
bytes_to_copy = file_info->extrafield_size;
memcpy(extrafield, file_info->extrafield, bytes_to_copy);
}
if (comment_size > 0 && comment != NULL && file_info->comment != NULL)
{
if (comment_size > 0 && comment != NULL && file_info->comment != NULL) {
bytes_to_copy = (uint16_t)comment_size;
if (bytes_to_copy > file_info->comment_size)
bytes_to_copy = file_info->comment_size;
@ -735,8 +657,7 @@ int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filenam
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)
{
unsigned long comment_size) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
uint16_t bytes_to_copy = 0;
@ -747,8 +668,7 @@ int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *fi
err = mz_zip_entry_get_info(compat->handle, &file_info);
if ((err == MZ_OK) && (pfile_info != NULL))
{
if ((err == MZ_OK) && (pfile_info != NULL)) {
pfile_info->version = file_info->version_madeby;
pfile_info->version_needed = file_info->version_needed;
pfile_info->flag = file_info->flag;
@ -769,8 +689,7 @@ int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *fi
pfile_info->compressed_size = (uint64_t)file_info->compressed_size;
pfile_info->uncompressed_size = (uint64_t)file_info->uncompressed_size;
if (filename_size > 0 && filename != NULL && file_info->filename != NULL)
{
if (filename_size > 0 && filename != NULL && file_info->filename != NULL) {
bytes_to_copy = (uint16_t)filename_size;
if (bytes_to_copy > file_info->filename_size)
bytes_to_copy = file_info->filename_size;
@ -779,16 +698,14 @@ int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *fi
filename[bytes_to_copy] = 0;
}
if (extrafield_size > 0 && extrafield != NULL)
{
if (extrafield_size > 0 && extrafield != NULL) {
bytes_to_copy = (uint16_t)extrafield_size;
if (bytes_to_copy > file_info->extrafield_size)
bytes_to_copy = file_info->extrafield_size;
memcpy(extrafield, file_info->extrafield, bytes_to_copy);
}
if (comment_size > 0 && comment != NULL && file_info->comment != NULL)
{
if (comment_size > 0 && comment != NULL && file_info->comment != NULL) {
bytes_to_copy = (uint16_t)comment_size;
if (bytes_to_copy > file_info->comment_size)
bytes_to_copy = file_info->comment_size;
@ -800,8 +717,7 @@ int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *fi
return err;
}
int unzGoToFirstFile(unzFile file)
{
int unzGoToFirstFile(unzFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return UNZ_PARAMERROR;
@ -809,8 +725,7 @@ int unzGoToFirstFile(unzFile file)
return mz_zip_goto_first_entry(compat->handle);
}
int unzGoToNextFile(unzFile file)
{
int unzGoToNextFile(unzFile file) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
if (compat == NULL)
@ -821,8 +736,7 @@ int unzGoToNextFile(unzFile file)
return err;
}
int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func)
{
int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
uint64_t preserve_index = 0;
@ -835,18 +749,14 @@ int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filena
preserve_index = compat->entry_index;
err = mz_zip_goto_first_entry(compat->handle);
while (err == MZ_OK)
{
while (err == MZ_OK) {
err = mz_zip_entry_get_info(compat->handle, &file_info);
if (err != MZ_OK)
break;
if ((intptr_t)filename_compare_func > 2)
{
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);
}
@ -863,8 +773,7 @@ int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filena
/***************************************************************************/
int unzGetFilePos(unzFile file, unz_file_pos *file_pos)
{
int unzGetFilePos(unzFile file, unz_file_pos *file_pos) {
unz64_file_pos file_pos64;
int32_t err = 0;
@ -877,8 +786,7 @@ int unzGetFilePos(unzFile file, unz_file_pos *file_pos)
return err;
}
int unzGoToFilePos(unzFile file, unz_file_pos *file_pos)
{
int unzGoToFilePos(unzFile file, unz_file_pos *file_pos) {
mz_compat *compat = (mz_compat *)file;
unz64_file_pos file_pos64;
@ -891,8 +799,7 @@ int unzGoToFilePos(unzFile file, unz_file_pos *file_pos)
return unzGoToFilePos64(file, &file_pos64);
}
int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos)
{
int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos) {
mz_compat *compat = (mz_compat *)file;
int64_t offset = 0;
@ -908,8 +815,7 @@ int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos)
return UNZ_OK;
}
int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos)
{
int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos) {
mz_compat *compat = (mz_compat *)file;
int32_t err = MZ_OK;
@ -922,34 +828,29 @@ int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos)
return err;
}
unsigned long unzGetOffset(unzFile file)
{
unsigned long unzGetOffset(unzFile file) {
return (uint32_t)unzGetOffset64(file);
}
int64_t unzGetOffset64(unzFile file)
{
int64_t unzGetOffset64(unzFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return UNZ_PARAMERROR;
return mz_zip_get_entry(compat->handle);
}
int unzSetOffset(unzFile file, unsigned long pos)
{
int unzSetOffset(unzFile file, unsigned long pos) {
return unzSetOffset64(file, pos);
}
int unzSetOffset64(unzFile file, int64_t pos)
{
int unzSetOffset64(unzFile file, int64_t pos) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return UNZ_PARAMERROR;
return (int)mz_zip_goto_entry(compat->handle, pos);
}
int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len)
{
int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
int32_t err = MZ_OK;
@ -970,31 +871,26 @@ int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len)
return MZ_OK;
}
int64_t unztell(unzFile file)
{
int64_t unztell(unzFile file) {
return unzTell64(file);
}
int32_t unzTell(unzFile file)
{
int32_t unzTell(unzFile file) {
return (int32_t)unzTell64(file);
}
int64_t unzTell64(unzFile file)
{
int64_t unzTell64(unzFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return UNZ_PARAMERROR;
return (int64_t)compat->total_out;
}
int unzSeek(unzFile file, int32_t offset, int origin)
{
int unzSeek(unzFile file, int32_t offset, int origin) {
return unzSeek64(file, offset, origin);
}
int unzSeek64(unzFile file, int64_t offset, int origin)
{
int unzSeek64(unzFile file, int64_t offset, int origin) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
int64_t position = 0;
@ -1029,8 +925,7 @@ int unzSeek64(unzFile file, int64_t offset, int origin)
return err;
}
int unzEndOfFile(unzFile file)
{
int unzEndOfFile(unzFile file) {
mz_compat *compat = (mz_compat *)file;
mz_zip_file *file_info = NULL;
int32_t err = MZ_OK;
@ -1045,8 +940,7 @@ int unzEndOfFile(unzFile file)
return 0;
}
void* unzGetStream(unzFile file)
{
void* unzGetStream(unzFile file) {
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return NULL;
@ -1055,45 +949,38 @@ void* unzGetStream(unzFile file)
/***************************************************************************/
void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
{
void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def) {
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_os_get_interface();
}
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)
{
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def) {
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_os_get_interface();
}
void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
{
void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def) {
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_os_get_interface();
}
void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def)
{
void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def) {
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_os_get_interface();
}
void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def)
{
void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def) {
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_os_get_interface();
}
void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def)
{
void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def) {
/* NOTE: You should no longer pass in widechar string to open function */
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_os_get_interface();
}
void fill_memory_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
{
void fill_memory_filefunc(zlib_filefunc_def *pzlib_filefunc_def) {
if (pzlib_filefunc_def != NULL)
*pzlib_filefunc_def = mz_stream_mem_get_interface();
}

21
mz_compat.h
View File

@ -72,8 +72,7 @@ typedef uint64_t ZPOS64_T;
#define mz_dos_date dos_date
#endif
typedef struct
{
typedef struct {
uint32_t mz_dos_date;
struct tm tmz_date;
uint16_t internal_fa; /* internal file attributes 2 bytes */
@ -192,22 +191,19 @@ typedef void *unzFile;
/***************************************************************************/
typedef struct unz_global_info64_s
{
typedef struct unz_global_info64_s {
uint64_t number_entry; /* total number of entries in the central dir on this disk */
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
uint16_t size_comment; /* size of the global comment of the zipfile */
} unz_global_info64;
typedef struct unz_global_info_s
{
typedef struct unz_global_info_s {
uint32_t number_entry; /* total number of entries in the central dir on this disk */
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */
uint16_t size_comment; /* size of the global comment of the zipfile */
} unz_global_info;
typedef struct unz_file_info64_s
{
typedef struct unz_file_info64_s {
uint16_t version; /* version made by 2 bytes */
uint16_t version_needed; /* version needed to extract 2 bytes */
uint16_t flag; /* general purpose bit flag 2 bytes */
@ -230,8 +226,7 @@ typedef struct unz_file_info64_s
uint16_t size_file_extra_internal;
} unz_file_info64;
typedef struct unz_file_info_s
{
typedef struct unz_file_info_s {
uint16_t version; /* version made by 2 bytes */
uint16_t version_needed; /* version needed to extract 2 bytes */
uint16_t flag; /* general purpose bit flag 2 bytes */
@ -302,8 +297,7 @@ ZEXPORT int unzGetLocalExtrafield(unzFile file, void *buf, unsigned int len)
/***************************************************************************/
/* Raw access to zip file */
typedef struct unz_file_pos_s
{
typedef struct unz_file_pos_s {
uint32_t pos_in_zip_directory; /* offset in zip file directory */
uint32_t num_of_file; /* # of file */
} unz_file_pos;
@ -311,8 +305,7 @@ typedef struct unz_file_pos_s
ZEXPORT int unzGetFilePos(unzFile file, unz_file_pos *file_pos);
ZEXPORT int unzGoToFilePos(unzFile file, unz_file_pos *file_pos);
typedef struct unz64_file_pos_s
{
typedef struct unz64_file_pos_s {
int64_t pos_in_zip_directory; /* offset in zip file directory */
uint64_t num_of_file; /* # of file */
} unz64_file_pos;

15
mz_crypt.c
View File

@ -41,8 +41,7 @@
/***************************************************************************/
uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size)
{
uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size) {
#if defined(HAVE_ZLIB)
return (uint32_t)ZLIB_PREFIX(crc32)((z_crc_t)value, buf, (uInt)size);
#elif defined(HAVE_LZMA)
@ -95,8 +94,7 @@ uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size)
};
value = ~value;
while (size > 0)
{
while (size > 0) {
value = (value >> 8) ^ crc32_table[(value ^ *buf) & 0xFF];
buf += 1;
@ -109,8 +107,7 @@ uint32_t mz_crypt_crc32_update(uint32_t value, const uint8_t *buf, int32_t size)
#ifndef MZ_ZIP_NO_ENCRYPTION
int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *salt,
int32_t salt_length, int32_t iteration_count, uint8_t *key, int32_t key_length)
{
int32_t salt_length, int32_t iteration_count, uint8_t *key, int32_t key_length) {
void *hmac1 = NULL;
void *hmac2 = NULL;
void *hmac3 = NULL;
@ -143,8 +140,7 @@ int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *sa
block_count = 1 + ((uint16_t)key_length - 1) / MZ_HASH_SHA1_SIZE;
for (i = 0; (err == MZ_OK) && (i < block_count); i += 1)
{
for (i = 0; (err == MZ_OK) && (i < block_count); i += 1) {
memset(ux, 0, sizeof(ux));
err = mz_crypt_hmac_copy(hmac2, hmac3);
@ -156,8 +152,7 @@ int32_t mz_crypt_pbkdf2(uint8_t *password, int32_t password_length, uint8_t *sa
uu[2] = (uint8_t)((i + 1) >> 8);
uu[3] = (uint8_t)(i + 1);
for (j = 0, k = 4; j < iteration_count; j += 1)
{
for (j = 0, k = 4; j < iteration_count; j += 1) {
err = mz_crypt_hmac_update(hmac3, uu, k);
if (err == MZ_OK)
err = mz_crypt_hmac_end(hmac3, uu, sizeof(uu));

128
mz_crypt_apple.c
View File

@ -21,8 +21,7 @@
/***************************************************************************/
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
if (SecRandomCopyBytes(kSecRandomDefault, size, buf) != errSecSuccess)
return 0;
return size;
@ -40,16 +39,14 @@ typedef struct mz_crypt_sha_s {
/***************************************************************************/
void mz_crypt_sha_reset(void *handle)
{
void mz_crypt_sha_reset(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->error = 0;
sha->initialized = 0;
}
int32_t mz_crypt_sha_begin(void *handle)
{
int32_t mz_crypt_sha_begin(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha == NULL)
@ -71,8 +68,7 @@ int32_t mz_crypt_sha_begin(void *handle)
return MZ_OK;
}
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha == NULL || buf == NULL || !sha->initialized)
@ -89,21 +85,17 @@ int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
return size;
}
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha == NULL || digest == NULL || !sha->initialized)
return MZ_PARAM_ERROR;
if (sha->algorithm == MZ_HASH_SHA1)
{
if (sha->algorithm == MZ_HASH_SHA1) {
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
sha->error = CC_SHA1_Final(digest, &sha->ctx1);
}
else
{
} else {
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
sha->error = CC_SHA256_Final(digest, &sha->ctx256);
@ -115,19 +107,16 @@ int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
return MZ_OK;
}
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->algorithm = algorithm;
}
void *mz_crypt_sha_create(void **handle)
{
void *mz_crypt_sha_create(void **handle) {
mz_crypt_sha *sha = NULL;
sha = (mz_crypt_sha *)MZ_ALLOC(sizeof(mz_crypt_sha));
if (sha != NULL)
{
if (sha != NULL) {
memset(sha, 0, sizeof(mz_crypt_sha));
sha->algorithm = MZ_HASH_SHA256;
}
@ -137,14 +126,12 @@ void *mz_crypt_sha_create(void **handle)
return sha;
}
void mz_crypt_sha_delete(void **handle)
{
void mz_crypt_sha_delete(void **handle) {
mz_crypt_sha *sha = NULL;
if (handle == NULL)
return;
sha = (mz_crypt_sha *)*handle;
if (sha != NULL)
{
if (sha != NULL) {
mz_crypt_sha_reset(*handle);
MZ_FREE(sha);
}
@ -161,8 +148,7 @@ typedef struct mz_crypt_aes_s {
/***************************************************************************/
void mz_crypt_aes_reset(void *handle)
{
void mz_crypt_aes_reset(void *handle) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (aes->crypt != NULL)
@ -170,8 +156,7 @@ void mz_crypt_aes_reset(void *handle)
aes->crypt = NULL;
}
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
size_t data_moved = 0;
@ -188,8 +173,7 @@ int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
return size;
}
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
size_t data_moved = 0;
@ -206,8 +190,7 @@ int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
return size;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
@ -225,8 +208,7 @@ int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_
return MZ_OK;
}
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
@ -244,14 +226,12 @@ int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_
return MZ_OK;
}
void mz_crypt_aes_set_mode(void *handle, int32_t mode)
{
void mz_crypt_aes_set_mode(void *handle, int32_t mode) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
aes->mode = mode;
}
void *mz_crypt_aes_create(void **handle)
{
void *mz_crypt_aes_create(void **handle) {
mz_crypt_aes *aes = NULL;
aes = (mz_crypt_aes *)MZ_ALLOC(sizeof(mz_crypt_aes));
@ -263,14 +243,12 @@ void *mz_crypt_aes_create(void **handle)
return aes;
}
void mz_crypt_aes_delete(void **handle)
{
void mz_crypt_aes_delete(void **handle) {
mz_crypt_aes *aes = NULL;
if (handle == NULL)
return;
aes = (mz_crypt_aes *)*handle;
if (aes != NULL)
{
if (aes != NULL) {
mz_crypt_aes_reset(*handle);
MZ_FREE(aes);
}
@ -288,21 +266,18 @@ typedef struct mz_crypt_hmac_s {
/***************************************************************************/
static void mz_crypt_hmac_free(void *handle)
{
static void mz_crypt_hmac_free(void *handle) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
memset(&hmac->ctx, 0, sizeof(hmac->ctx));
}
void mz_crypt_hmac_reset(void *handle)
{
void mz_crypt_hmac_reset(void *handle) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
mz_crypt_hmac_free(handle);
hmac->error = 0;
}
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
CCHmacAlgorithm algorithm = 0;
@ -322,8 +297,7 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
return MZ_OK;
}
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac == NULL || buf == NULL)
@ -333,21 +307,17 @@ int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
return MZ_OK;
}
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac == NULL || digest == NULL)
return MZ_PARAM_ERROR;
if (hmac->algorithm == MZ_HASH_SHA1)
{
if (hmac->algorithm == MZ_HASH_SHA1) {
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
CCHmacFinal(&hmac->ctx, digest);
}
else
{
} else {
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
CCHmacFinal(&hmac->ctx, digest);
@ -356,14 +326,12 @@ int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
return MZ_OK;
}
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
hmac->algorithm = algorithm;
}
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
{
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle) {
mz_crypt_hmac *source = (mz_crypt_hmac *)src_handle;
mz_crypt_hmac *target = (mz_crypt_hmac *)target_handle;
@ -374,13 +342,11 @@ int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
return MZ_OK;
}
void *mz_crypt_hmac_create(void **handle)
{
void *mz_crypt_hmac_create(void **handle) {
mz_crypt_hmac *hmac = NULL;
hmac = (mz_crypt_hmac *)MZ_ALLOC(sizeof(mz_crypt_hmac));
if (hmac != NULL)
{
if (hmac != NULL) {
memset(hmac, 0, sizeof(mz_crypt_hmac));
hmac->algorithm = MZ_HASH_SHA256;
}
@ -390,14 +356,12 @@ void *mz_crypt_hmac_create(void **handle)
return hmac;
}
void mz_crypt_hmac_delete(void **handle)
{
void mz_crypt_hmac_delete(void **handle) {
mz_crypt_hmac *hmac = NULL;
if (handle == NULL)
return;
hmac = (mz_crypt_hmac *)*handle;
if (hmac != NULL)
{
if (hmac != NULL) {
mz_crypt_hmac_free(*handle);
MZ_FREE(hmac);
}
@ -408,8 +372,7 @@ void mz_crypt_hmac_delete(void **handle)
#if defined(MZ_ZIP_SIGNING)
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size,
const char *cert_pwd, uint8_t **signature, int32_t *signature_size)
{
const char *cert_pwd, uint8_t **signature, int32_t *signature_size) {
CFStringRef password_ref = NULL;
CFDictionaryRef options_dict = NULL;
CFDictionaryRef identity_trust = NULL;
@ -444,12 +407,10 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
identity = (SecIdentityRef)CFDictionaryGetValue(identity_trust, kSecImportItemIdentity);
if (identity)
trust = (SecTrustRef)CFDictionaryGetValue(identity_trust, kSecImportItemTrust);
if (trust)
{
if (trust) {
status = CMSEncodeContent(identity, NULL, NULL, FALSE, 0, message, message_size, &signature_out);
if (status == errSecSuccess)
{
if (status == errSecSuccess) {
*signature_size = CFDataGetLength(signature_out);
*signature = (uint8_t *)MZ_ALLOC(*signature_size);
@ -473,8 +434,7 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
return err;
}
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size)
{
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size) {
CMSDecoderRef decoder = NULL;
CMSSignerStatus signer_status = 0;
CFDataRef message_out = NULL;
@ -496,24 +456,20 @@ int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *si
if (status == errSecSuccess)
trust_policy = SecPolicyCreateBasicX509();
if (status == errSecSuccess && trust_policy)
{
if (status == errSecSuccess && trust_policy) {
CMSDecoderGetNumSigners(decoder, &signer_count);
if (signer_count > 0)
err = MZ_OK;
for (i = 0; i < signer_count; i += 1)
{
for (i = 0; i < signer_count; i += 1) {
status = CMSDecoderCopySignerStatus(decoder, i, trust_policy, TRUE, &signer_status, NULL, &verify_status);
if (status != errSecSuccess || verify_status != 0 || signer_status != kCMSSignerValid)
{
if (status != errSecSuccess || verify_status != 0 || signer_status != kCMSSignerValid) {
err = MZ_SIGN_ERROR;
break;
}
}
}
if (err == MZ_OK)
{
if (err == MZ_OK) {
status = CMSDecoderCopyContent(decoder, &message_out);
if ((status != errSecSuccess) ||
(CFDataGetLength(message_out) != message_size) ||

119
mz_crypt_brg.c
View File

@ -32,39 +32,33 @@
/***************************************************************************/
#if defined(HAVE_ARC4RANDOM_BUF)
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
if (size < 0)
return 0;
arc4random_buf(buf, (uint32_t)size);
return size;
}
#elif defined(HAVE_ARC4RANDOM)
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
int32_t left = size;
for (; left > 2; left -= 3, buf += 3)
{
for (; left > 2; left -= 3, buf += 3) {
uint32_t val = arc4random();
buf[0] = (val) & 0xFF;
buf[1] = (val >> 8) & 0xFF;
buf[2] = (val >> 16) & 0xFF;
}
for (; left > 0; left--, buf++)
{
for (; left > 0; left--, buf++) {
*buf = arc4random() & 0xFF;
}
return size - left;
}
#elif defined(HAVE_GETRANDOM)
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
int32_t left = size;
int32_t written = 0;
while (left > 0)
{
while (left > 0) {
written = getrandom(buf, left, 0);
if (written < 0)
return MZ_INTERNAL_ERROR;
@ -78,8 +72,7 @@ int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
#if !defined(FORCE_LOWQUALITY_ENTROPY)
#pragma message("Warning: Low quality entropy function used for encryption")
#endif
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
return mz_os_rand(buf, size);
}
#endif
@ -95,14 +88,12 @@ typedef struct mz_crypt_sha_s {
/***************************************************************************/
void mz_crypt_sha_reset(void *handle)
{
void mz_crypt_sha_reset(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->initialized = 0;
}
int32_t mz_crypt_sha_begin(void *handle)
{
int32_t mz_crypt_sha_begin(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha == NULL)
@ -117,8 +108,7 @@ int32_t mz_crypt_sha_begin(void *handle)
return MZ_OK;
}
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha == NULL || buf == NULL || !sha->initialized)
@ -132,21 +122,17 @@ int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
return size;
}
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha == NULL || digest == NULL || !sha->initialized)
return MZ_PARAM_ERROR;
if (sha->algorithm == MZ_HASH_SHA1)
{
if (sha->algorithm == MZ_HASH_SHA1) {
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
sha1_end(digest, &sha->ctx1);
}
else
{
} else {
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
sha256_end(digest, &sha->ctx256);
@ -155,19 +141,16 @@ int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
return MZ_OK;
}
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->algorithm = algorithm;
}
void *mz_crypt_sha_create(void **handle)
{
void *mz_crypt_sha_create(void **handle) {
mz_crypt_sha *sha = NULL;
sha = (mz_crypt_sha *)MZ_ALLOC(sizeof(mz_crypt_sha));
if (sha != NULL)
{
if (sha != NULL) {
memset(sha, 0, sizeof(mz_crypt_sha));
sha->algorithm = MZ_HASH_SHA256;
}
@ -177,14 +160,12 @@ void *mz_crypt_sha_create(void **handle)
return sha;
}
void mz_crypt_sha_delete(void **handle)
{
void mz_crypt_sha_delete(void **handle) {
mz_crypt_sha *sha = NULL;
if (handle == NULL)
return;
sha = (mz_crypt_sha *)*handle;
if (sha != NULL)
{
if (sha != NULL) {
mz_crypt_sha_reset(*handle);
MZ_FREE(sha);
}
@ -202,13 +183,11 @@ typedef struct mz_crypt_aes_s {
/***************************************************************************/
void mz_crypt_aes_reset(void *handle)
{
void mz_crypt_aes_reset(void *handle) {
MZ_UNUSED(handle);
}
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (aes == NULL || buf == NULL)
@ -222,8 +201,7 @@ int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
return size;
}
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (aes == NULL || buf == NULL)
return MZ_PARAM_ERROR;
@ -236,8 +214,7 @@ int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
return size;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
@ -253,8 +230,7 @@ int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_
return MZ_OK;
}
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
@ -270,14 +246,12 @@ int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_
return MZ_OK;
}
void mz_crypt_aes_set_mode(void *handle, int32_t mode)
{
void mz_crypt_aes_set_mode(void *handle, int32_t mode) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
aes->mode = mode;
}
void *mz_crypt_aes_create(void **handle)
{
void *mz_crypt_aes_create(void **handle) {
mz_crypt_aes *aes = NULL;
aes = (mz_crypt_aes *)MZ_ALLOC(sizeof(mz_crypt_aes));
@ -289,8 +263,7 @@ void *mz_crypt_aes_create(void **handle)
return aes;
}
void mz_crypt_aes_delete(void **handle)
{
void mz_crypt_aes_delete(void **handle) {
mz_crypt_aes *aes = NULL;
if (handle == NULL)
return;
@ -311,14 +284,12 @@ typedef struct mz_crypt_hmac_s {
/***************************************************************************/
void mz_crypt_hmac_reset(void *handle)
{
void mz_crypt_hmac_reset(void *handle) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
hmac->error = 0;
}
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac == NULL)
@ -336,8 +307,7 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
return MZ_OK;
}
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac == NULL || buf == NULL)
@ -347,21 +317,17 @@ int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
return MZ_OK;
}
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac == NULL || digest == NULL)
return MZ_PARAM_ERROR;
if (hmac->algorithm == MZ_HASH_SHA1)
{
if (hmac->algorithm == MZ_HASH_SHA1) {
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
hmac_sha_end(digest, digest_size, &hmac->ctx);
}
else
{
} else {
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
hmac_sha_end(digest, digest_size, &hmac->ctx);
@ -370,14 +336,12 @@ int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
return MZ_OK;
}
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
hmac->algorithm = algorithm;
}
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
{
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle) {
mz_crypt_hmac *source = (mz_crypt_hmac *)src_handle;
mz_crypt_hmac *target = (mz_crypt_hmac *)target_handle;
@ -388,13 +352,11 @@ int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
return MZ_OK;
}
void *mz_crypt_hmac_create(void **handle)
{
void *mz_crypt_hmac_create(void **handle) {
mz_crypt_hmac *hmac = NULL;
hmac = (mz_crypt_hmac *)MZ_ALLOC(sizeof(mz_crypt_hmac));
if (hmac != NULL)
{
if (hmac != NULL) {
memset(hmac, 0, sizeof(mz_crypt_hmac));
hmac->algorithm = MZ_HASH_SHA256;
}
@ -404,8 +366,7 @@ void *mz_crypt_hmac_create(void **handle)
return hmac;
}
void mz_crypt_hmac_delete(void **handle)
{
void mz_crypt_hmac_delete(void **handle) {
mz_crypt_hmac *hmac = NULL;
if (handle == NULL)
return;
@ -419,8 +380,7 @@ void mz_crypt_hmac_delete(void **handle)
#if defined(MZ_ZIP_SIGNING)
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size,
const char *cert_pwd, uint8_t **signature, int32_t *signature_size)
{
const char *cert_pwd, uint8_t **signature, int32_t *signature_size) {
MZ_UNUSED(message);
MZ_UNUSED(message_size);
MZ_UNUSED(cert_data);
@ -432,8 +392,7 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
return MZ_SUPPORT_ERROR;
}
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size)
{
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size) {
MZ_UNUSED(message);
MZ_UNUSED(message_size);
MZ_UNUSED(signature);

177
mz_crypt_openssl.c
View File

@ -24,11 +24,9 @@
/***************************************************************************/
static void mz_crypt_init(void)
{
static void mz_crypt_init(void) {
static int32_t openssl_initialized = 0;
if (openssl_initialized == 0)
{
if (openssl_initialized == 0) {
OpenSSL_add_all_algorithms();
ERR_load_BIO_strings();
@ -41,8 +39,7 @@ static void mz_crypt_init(void)
}
}
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
int32_t result = 0;
result = RAND_bytes(buf, size);
@ -65,8 +62,7 @@ typedef struct mz_crypt_sha_s {
/***************************************************************************/
void mz_crypt_sha_reset(void *handle)
{
void mz_crypt_sha_reset(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->error = 0;
@ -75,8 +71,7 @@ void mz_crypt_sha_reset(void *handle)
mz_crypt_init();
}
int32_t mz_crypt_sha_begin(void *handle)
{
int32_t mz_crypt_sha_begin(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
int32_t result = 0;
@ -91,8 +86,7 @@ int32_t mz_crypt_sha_begin(void *handle)
else
result = SHA256_Init(&sha->ctx256);
if (!result)
{
if (!result) {
sha->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -101,8 +95,7 @@ int32_t mz_crypt_sha_begin(void *handle)
return MZ_OK;
}
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
int32_t result = 0;
@ -114,8 +107,7 @@ int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
else
result = SHA256_Update(&sha->ctx256, buf, size);
if (!result)
{
if (!result) {
sha->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -123,29 +115,24 @@ int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
return size;
}
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
int32_t result = 0;
if (sha == NULL || digest == NULL || !sha->initialized)
return MZ_PARAM_ERROR;
if (sha->algorithm == MZ_HASH_SHA1)
{
if (sha->algorithm == MZ_HASH_SHA1) {
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
result = SHA1_Final(digest, &sha->ctx1);
}
else
{
} else {
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
result = SHA256_Final(digest, &sha->ctx256);
}
if (!result)
{
if (!result) {
sha->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -153,19 +140,16 @@ int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
return MZ_OK;
}
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->algorithm = algorithm;
}
void *mz_crypt_sha_create(void **handle)
{
void *mz_crypt_sha_create(void **handle) {
mz_crypt_sha *sha = NULL;
sha = (mz_crypt_sha *)MZ_ALLOC(sizeof(mz_crypt_sha));
if (sha != NULL)
{
if (sha != NULL) {
memset(sha, 0, sizeof(mz_crypt_sha));
sha->algorithm = MZ_HASH_SHA256;
}
@ -175,14 +159,12 @@ void *mz_crypt_sha_create(void **handle)
return sha;
}
void mz_crypt_sha_delete(void **handle)
{
void mz_crypt_sha_delete(void **handle) {
mz_crypt_sha *sha = NULL;
if (handle == NULL)
return;
sha = (mz_crypt_sha *)*handle;
if (sha != NULL)
{
if (sha != NULL) {
mz_crypt_sha_reset(*handle);
MZ_FREE(sha);
}
@ -201,15 +183,13 @@ typedef struct mz_crypt_aes_s {
/***************************************************************************/
void mz_crypt_aes_reset(void *handle)
{
void mz_crypt_aes_reset(void *handle) {
MZ_UNUSED(handle);
mz_crypt_init();
}
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (aes == NULL || buf == NULL)
@ -222,8 +202,7 @@ int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
return size;
}
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (aes == NULL || buf == NULL)
return MZ_PARAM_ERROR;
@ -235,8 +214,7 @@ int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
return size;
}
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
int32_t result = 0;
int32_t key_bits = 0;
@ -249,8 +227,7 @@ int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_
key_bits = key_length * 8;
result = AES_set_encrypt_key(key, key_bits, &aes->key);
if (result)
{
if (result) {
aes->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -258,8 +235,7 @@ int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_
return MZ_OK;
}
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
int32_t result = 0;
int32_t key_bits = 0;
@ -272,8 +248,7 @@ int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_
key_bits = key_length * 8;
result = AES_set_decrypt_key(key, key_bits, &aes->key);
if (result)
{
if (result) {
aes->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -281,14 +256,12 @@ int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_
return MZ_OK;
}
void mz_crypt_aes_set_mode(void *handle, int32_t mode)
{
void mz_crypt_aes_set_mode(void *handle, int32_t mode) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
aes->mode = mode;
}
void *mz_crypt_aes_create(void **handle)
{
void *mz_crypt_aes_create(void **handle) {
mz_crypt_aes *aes = NULL;
aes = (mz_crypt_aes *)MZ_ALLOC(sizeof(mz_crypt_aes));
@ -300,8 +273,7 @@ void *mz_crypt_aes_create(void **handle)
return aes;
}
void mz_crypt_aes_delete(void **handle)
{
void mz_crypt_aes_delete(void **handle) {
mz_crypt_aes *aes = NULL;
if (handle == NULL)
return;
@ -323,18 +295,15 @@ typedef struct mz_crypt_hmac_s {
/***************************************************************************/
#if (OPENSSL_VERSION_NUMBER < 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER)
static HMAC_CTX *HMAC_CTX_new(void)
{
static HMAC_CTX *HMAC_CTX_new(void) {
HMAC_CTX *ctx = OPENSSL_malloc(sizeof(HMAC_CTX));
if (ctx != NULL)
HMAC_CTX_init(ctx);
return ctx;
}
static void HMAC_CTX_free(HMAC_CTX *ctx)
{
if (ctx != NULL)
{
static void HMAC_CTX_free(HMAC_CTX *ctx) {
if (ctx != NULL) {
HMAC_CTX_cleanup(ctx);
OPENSSL_free(ctx);
}
@ -343,8 +312,7 @@ static void HMAC_CTX_free(HMAC_CTX *ctx)
/***************************************************************************/
void mz_crypt_hmac_reset(void *handle)
{
void mz_crypt_hmac_reset(void *handle) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
HMAC_CTX_free(hmac->ctx);
@ -355,8 +323,7 @@ void mz_crypt_hmac_reset(void *handle)
mz_crypt_init();
}
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
int32_t result = 0;
const EVP_MD *evp_md = NULL;
@ -374,8 +341,7 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
evp_md = EVP_sha256();
result = HMAC_Init_ex(hmac->ctx, key, key_length, evp_md, NULL);
if (!result)
{
if (!result) {
hmac->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -383,8 +349,7 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
return MZ_OK;
}
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
int32_t result = 0;
@ -392,8 +357,7 @@ int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
return MZ_PARAM_ERROR;
result = HMAC_Update(hmac->ctx, buf, size);
if (!result)
{
if (!result) {
hmac->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -401,30 +365,25 @@ int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
return MZ_OK;
}
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
int32_t result = 0;
if (hmac == NULL || digest == NULL)
return MZ_PARAM_ERROR;
if (hmac->algorithm == MZ_HASH_SHA1)
{
if (hmac->algorithm == MZ_HASH_SHA1) {
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
result = HMAC_Final(hmac->ctx, digest, (uint32_t *)&digest_size);
}
else
{
} else {
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
result = HMAC_Final(hmac->ctx, digest, (uint32_t *)&digest_size);
}
if (!result)
{
if (!result) {
hmac->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -432,14 +391,12 @@ int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
return MZ_OK;
}
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
hmac->algorithm = algorithm;
}
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
{
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle) {
mz_crypt_hmac *source = (mz_crypt_hmac *)src_handle;
mz_crypt_hmac *target = (mz_crypt_hmac *)target_handle;
int32_t result = 0;
@ -453,8 +410,7 @@ int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
target->ctx = HMAC_CTX_new();
result = HMAC_CTX_copy(target->ctx, source->ctx);
if (!result)
{
if (!result) {
target->error = ERR_get_error();
return MZ_HASH_ERROR;
}
@ -462,13 +418,11 @@ int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
return MZ_OK;
}
void *mz_crypt_hmac_create(void **handle)
{
void *mz_crypt_hmac_create(void **handle) {
mz_crypt_hmac *hmac = NULL;
hmac = (mz_crypt_hmac *)MZ_ALLOC(sizeof(mz_crypt_hmac));
if (hmac != NULL)
{
if (hmac != NULL) {
memset(hmac, 0, sizeof(mz_crypt_hmac));
hmac->algorithm = MZ_HASH_SHA256;
}
@ -478,14 +432,12 @@ void *mz_crypt_hmac_create(void **handle)
return hmac;
}
void mz_crypt_hmac_delete(void **handle)
{
void mz_crypt_hmac_delete(void **handle) {
mz_crypt_hmac *hmac = NULL;
if (handle == NULL)
return;
hmac = (mz_crypt_hmac *)*handle;
if (hmac != NULL)
{
if (hmac != NULL) {
mz_crypt_hmac_reset(*handle);
MZ_FREE(hmac);
}
@ -496,8 +448,7 @@ void mz_crypt_hmac_delete(void **handle)
#if defined(MZ_ZIP_SIGNING)
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size,
const char *cert_pwd, uint8_t **signature, int32_t *signature_size)
{
const char *cert_pwd, uint8_t **signature, int32_t *signature_size) {
PKCS12 *p12 = NULL;
EVP_PKEY *evp_pkey = NULL;
BUF_MEM *buf_mem = NULL;
@ -526,25 +477,20 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
err = MZ_SIGN_ERROR;
if (err == MZ_OK)
result = PKCS12_parse(p12, cert_pwd, &evp_pkey, &cert, &ca_stack);
if (result)
{
if (result) {
cms = CMS_sign(NULL, NULL, ca_stack, NULL, CMS_BINARY | CMS_PARTIAL);
if (cms)
signer_info = CMS_add1_signer(cms, cert, evp_pkey, EVP_sha256(), 0);
if (signer_info == NULL)
{
if (signer_info == NULL) {
err = MZ_SIGN_ERROR;
}
else
{
} else {
message_bio = BIO_new_mem_buf(message, message_size);
signature_bio = BIO_new(BIO_s_mem());
result = CMS_final(cms, message_bio, NULL, CMS_BINARY);
if (result)
result = i2d_CMS_bio(signature_bio, cms);
if (result)
{
if (result) {
BIO_flush(signature_bio);
BIO_get_mem_ptr(signature_bio, &buf_mem);
@ -576,8 +522,7 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
if (p12)
PKCS12_free(p12);
if (err != MZ_OK && *signature != NULL)
{
if (err != MZ_OK && *signature != NULL) {
MZ_FREE(*signature);
*signature = NULL;
*signature_size = 0;
@ -586,8 +531,7 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
return err;
}
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size)
{
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size) {
CMS_ContentInfo *cms = NULL;
STACK_OF(X509) *signers = NULL;
STACK_OF(X509) *intercerts = NULL;
@ -631,30 +575,26 @@ int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *si
message_bio = BIO_new(BIO_s_mem());
cms = d2i_CMS_bio(signature_bio, NULL);
if (cms)
{
if (cms) {
result = CMS_verify(cms, NULL, cert_store, NULL, message_bio, CMS_NO_SIGNER_CERT_VERIFY | CMS_BINARY);
if (result)
signers = CMS_get0_signers(cms);
if (signers)
intercerts = CMS_get1_certs(cms);
if (intercerts)
{
if (intercerts) {
/* Verify signer certificates */
signer_count = sk_X509_num(signers);
if (signer_count > 0)
err = MZ_OK;
for (i = 0; i < signer_count; i++)
{
for (i = 0; i < signer_count; i++) {
store_ctx = X509_STORE_CTX_new();
X509_STORE_CTX_init(store_ctx, cert_store, sk_X509_value(signers, i), intercerts);
result = X509_verify_cert(store_ctx);
if (store_ctx)
X509_STORE_CTX_free(store_ctx);
if (!result)
{
if (!result) {
err = MZ_SIGN_ERROR;
break;
}
@ -663,8 +603,7 @@ int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *si
BIO_get_mem_ptr(message_bio, &buf_mem);
if (err == MZ_OK)
{
if (err == MZ_OK) {
/* Verify the message */
if (((int32_t)buf_mem->length != message_size) ||
(memcmp(buf_mem->data, message, message_size) != 0))

196
mz_crypt_win32.c
View File

@ -20,15 +20,13 @@
/***************************************************************************/
int32_t mz_crypt_rand(uint8_t *buf, int32_t size)
{
int32_t mz_crypt_rand(uint8_t *buf, int32_t size) {
HCRYPTPROV provider;
int32_t result = 0;
result = CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (result)
{
if (result) {
result = CryptGenRandom(provider, size, buf);
CryptReleaseContext(provider, 0);
if (result)
@ -49,8 +47,7 @@ typedef struct mz_crypt_sha_s {
/***************************************************************************/
void mz_crypt_sha_reset(void *handle)
{
void mz_crypt_sha_reset(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
if (sha->hash)
CryptDestroyHash(sha->hash);
@ -61,8 +58,7 @@ void mz_crypt_sha_reset(void *handle)
sha->error = 0;
}
int32_t mz_crypt_sha_begin(void *handle)
{
int32_t mz_crypt_sha_begin(void *handle) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
ALG_ID alg_id = 0;
int32_t result = 0;
@ -78,17 +74,14 @@ int32_t mz_crypt_sha_begin(void *handle)
alg_id = CALG_SHA_256;
result = CryptAcquireContext(&sha->provider, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (!result)
{
if (!result) {
sha->error = GetLastError();
err = MZ_CRYPT_ERROR;
}
if (result)
{
if (result) {
result = CryptCreateHash(sha->provider, alg_id, 0, 0, &sha->hash);
if (!result)
{
if (!result) {
sha->error = GetLastError();
err = MZ_HASH_ERROR;
}
@ -97,24 +90,21 @@ int32_t mz_crypt_sha_begin(void *handle)
return err;
}
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_sha_update(void *handle, const void *buf, int32_t size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
int32_t result = 0;
if (sha == NULL || buf == NULL || sha->hash == 0)
return MZ_PARAM_ERROR;
result = CryptHashData(sha->hash, buf, size, 0);
if (!result)
{
if (!result) {
sha->error = GetLastError();
return MZ_HASH_ERROR;
}
return size;
}
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
int32_t result = 0;
int32_t expected_size = 0;
@ -127,27 +117,23 @@ int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size)
if (!result)
return MZ_HASH_ERROR;
result = CryptGetHashParam(sha->hash, HP_HASHVAL, digest, (DWORD *)&digest_size, 0);
if (!result)
{
if (!result) {
sha->error = GetLastError();
return MZ_HASH_ERROR;
}
return MZ_OK;
}
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_sha_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_sha *sha = (mz_crypt_sha *)handle;
sha->algorithm = algorithm;
}
void *mz_crypt_sha_create(void **handle)
{
void *mz_crypt_sha_create(void **handle) {
mz_crypt_sha *sha = NULL;
sha = (mz_crypt_sha *)MZ_ALLOC(sizeof(mz_crypt_sha));
if (sha != NULL)
{
if (sha != NULL) {
memset(sha, 0, sizeof(mz_crypt_sha));
sha->algorithm = MZ_HASH_SHA256;
}
@ -157,14 +143,12 @@ void *mz_crypt_sha_create(void **handle)
return sha;
}
void mz_crypt_sha_delete(void **handle)
{
void mz_crypt_sha_delete(void **handle) {
mz_crypt_sha *sha = NULL;
if (handle == NULL)
return;
sha = (mz_crypt_sha *)*handle;
if (sha != NULL)
{
if (sha != NULL) {
mz_crypt_sha_reset(*handle);
MZ_FREE(sha);
}
@ -182,8 +166,7 @@ typedef struct mz_crypt_aes_s {
/***************************************************************************/
static void mz_crypt_aes_free(void *handle)
{
static void mz_crypt_aes_free(void *handle) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
if (aes->key)
CryptDestroyKey(aes->key);
@ -193,13 +176,11 @@ static void mz_crypt_aes_free(void *handle)
aes->provider = 0;
}
void mz_crypt_aes_reset(void *handle)
{
void mz_crypt_aes_reset(void *handle) {
mz_crypt_aes_free(handle);
}
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
int32_t result = 0;
@ -208,16 +189,14 @@ int32_t mz_crypt_aes_encrypt(void *handle, uint8_t *buf, int32_t size)
if (size != MZ_AES_BLOCK_SIZE)
return MZ_PARAM_ERROR;
result = CryptEncrypt(aes->key, 0, 0, 0, buf, (DWORD *)&size, size);
if (!result)
{
if (!result) {
aes->error = GetLastError();
return MZ_CRYPT_ERROR;
}
return size;
}
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
{
int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
int32_t result = 0;
if (aes == NULL || buf == NULL)
@ -225,16 +204,14 @@ int32_t mz_crypt_aes_decrypt(void *handle, uint8_t *buf, int32_t size)
if (size != MZ_AES_BLOCK_SIZE)
return MZ_PARAM_ERROR;
result = CryptDecrypt(aes->key, 0, 0, 0, buf, (DWORD *)&size);
if (!result)
{
if (!result) {
aes->error = GetLastError();
return MZ_CRYPT_ERROR;
}
return size;
}
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length)
{
static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_length) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
HCRYPTHASH hash = 0;
ALG_ID alg_id = 0;
@ -265,12 +242,10 @@ 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);
if (result)
{
if (result) {
key_blob_size = sizeof(key_blob_header_s) + key_length;
key_blob = (uint8_t *)MZ_ALLOC(key_blob_size);
if (key_blob)
{
if (key_blob) {
key_blob_s = (key_blob_header_s *)key_blob;
key_blob_s->hdr.bType = PLAINTEXTKEYBLOB;
key_blob_s->hdr.bVersion = CUR_BLOB_VERSION;
@ -283,9 +258,7 @@ static int32_t mz_crypt_aes_set_key(void *handle, const void *key, int32_t key_l
result = CryptImportKey(aes->provider, key_blob, key_blob_size, 0, 0, &aes->key);
MZ_FREE(key_blob);
}
else
{
} else {
err = MZ_MEM_ERROR;
}
}
@ -293,8 +266,7 @@ 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)
{
if (!result && err == MZ_OK) {
aes->error = GetLastError();
err = MZ_CRYPT_ERROR;
}
@ -305,24 +277,20 @@ 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)
{
int32_t mz_crypt_aes_set_encrypt_key(void *handle, const void *key, int32_t key_length) {
return mz_crypt_aes_set_key(handle, key, key_length);
}
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_aes_set_decrypt_key(void *handle, const void *key, int32_t key_length) {
return mz_crypt_aes_set_key(handle, key, key_length);
}
void mz_crypt_aes_set_mode(void *handle, int32_t mode)
{
void mz_crypt_aes_set_mode(void *handle, int32_t mode) {
mz_crypt_aes *aes = (mz_crypt_aes *)handle;
aes->mode = mode;
}
void *mz_crypt_aes_create(void **handle)
{
void *mz_crypt_aes_create(void **handle) {
mz_crypt_aes *aes = NULL;
aes = (mz_crypt_aes *)MZ_ALLOC(sizeof(mz_crypt_aes));
@ -334,14 +302,12 @@ void *mz_crypt_aes_create(void **handle)
return aes;
}
void mz_crypt_aes_delete(void **handle)
{
void mz_crypt_aes_delete(void **handle) {
mz_crypt_aes *aes = NULL;
if (handle == NULL)
return;
aes = (mz_crypt_aes *)*handle;
if (aes != NULL)
{
if (aes != NULL) {
mz_crypt_aes_free(*handle);
MZ_FREE(aes);
}
@ -362,8 +328,7 @@ typedef struct mz_crypt_hmac_s {
/***************************************************************************/
static void mz_crypt_hmac_free(void *handle)
{
static void mz_crypt_hmac_free(void *handle) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac->key)
CryptDestroyKey(hmac->key);
@ -377,13 +342,11 @@ static void mz_crypt_hmac_free(void *handle)
memset(&hmac->info, 0, sizeof(hmac->info));
}
void mz_crypt_hmac_reset(void *handle)
{
void mz_crypt_hmac_reset(void *handle) {
mz_crypt_hmac_free(handle);
}
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
{
int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
ALG_ID alg_id = 0;
typedef struct key_blob_header_s {
@ -412,19 +375,15 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
result = CryptAcquireContext(&hmac->provider, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT | CRYPT_SILENT);
if (!result)
{
if (!result) {
hmac->error = GetLastError();
err = MZ_CRYPT_ERROR;
}
else
{
} else {
key_blob_size = sizeof(key_blob_header_s) + key_length;
key_blob = (uint8_t *)MZ_ALLOC(key_blob_size);
}
if (key_blob)
{
if (key_blob) {
key_blob_s = (key_blob_header_s *)key_blob;
key_blob_s->hdr.bType = PLAINTEXTKEYBLOB;
key_blob_s->hdr.bVersion = CUR_BLOB_VERSION;
@ -441,14 +400,11 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
result = CryptSetHashParam(hmac->hash, HP_HMAC_INFO, (uint8_t *)&hmac->info, 0);
MZ_FREE(key_blob);
}
else if (err == MZ_OK)
{
} else if (err == MZ_OK) {
err = MZ_MEM_ERROR;
}
if (!result)
{
if (!result) {
hmac->error = GetLastError();
err = MZ_CRYPT_ERROR;
}
@ -459,8 +415,7 @@ int32_t mz_crypt_hmac_init(void *handle, const void *key, int32_t key_length)
return err;
}
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
{
int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
int32_t result = 0;
@ -468,16 +423,14 @@ int32_t mz_crypt_hmac_update(void *handle, const void *buf, int32_t size)
return MZ_PARAM_ERROR;
result = CryptHashData(hmac->hash, buf, size, 0);
if (!result)
{
if (!result) {
hmac->error = GetLastError();
return MZ_HASH_ERROR;
}
return MZ_OK;
}
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
{
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
int32_t result = 0;
int32_t expected_size = 0;
@ -490,50 +443,43 @@ int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
if (!result)
return MZ_HASH_ERROR;
result = CryptGetHashParam(hmac->hash, HP_HASHVAL, digest, (DWORD *)&digest_size, 0);
if (!result)
{
if (!result) {
hmac->error = GetLastError();
return MZ_HASH_ERROR;
}
return MZ_OK;
}
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm)
{
void mz_crypt_hmac_set_algorithm(void *handle, uint16_t algorithm) {
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
hmac->algorithm = algorithm;
}
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle)
{
int32_t mz_crypt_hmac_copy(void *src_handle, void *target_handle) {
mz_crypt_hmac *source = (mz_crypt_hmac *)src_handle;
mz_crypt_hmac *target = (mz_crypt_hmac *)target_handle;
int32_t result = 0;
int32_t err = MZ_OK;
if (target->hash)
{
if (target->hash) {
CryptDestroyHash(target->hash);
target->hash = 0;
}
result = CryptDuplicateHash(source->hash, NULL, 0, &target->hash);
if (!result)
{
if (!result) {
target->error = GetLastError();
err = MZ_HASH_ERROR;
}
return err;
}
void *mz_crypt_hmac_create(void **handle)
{
void *mz_crypt_hmac_create(void **handle) {
mz_crypt_hmac *hmac = NULL;
hmac = (mz_crypt_hmac *)MZ_ALLOC(sizeof(mz_crypt_hmac));
if (hmac != NULL)
{
if (hmac != NULL) {
memset(hmac, 0, sizeof(mz_crypt_hmac));
hmac->algorithm = MZ_HASH_SHA256;
}
@ -543,14 +489,12 @@ void *mz_crypt_hmac_create(void **handle)
return hmac;
}
void mz_crypt_hmac_delete(void **handle)
{
void mz_crypt_hmac_delete(void **handle) {
mz_crypt_hmac *hmac = NULL;
if (handle == NULL)
return;
hmac = (mz_crypt_hmac *)*handle;
if (hmac != NULL)
{
if (hmac != NULL) {
mz_crypt_hmac_free(*handle);
MZ_FREE(hmac);
}
@ -561,8 +505,7 @@ void mz_crypt_hmac_delete(void **handle)
#if defined(MZ_ZIP_SIGNING)
int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data, int32_t cert_data_size,
const char *cert_pwd, uint8_t **signature, int32_t *signature_size)
{
const char *cert_pwd, uint8_t **signature, int32_t *signature_size) {
CRYPT_SIGN_MESSAGE_PARA sign_params;
CRYPT_DATA_BLOB cert_data_blob;
PCCERT_CONTEXT cert_context = NULL;
@ -584,8 +527,7 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
cert_data_blob.cbData = cert_data_size;
password_wide = mz_os_unicode_string_create(cert_pwd, MZ_ENCODING_UTF8);
if (password_wide)
{
if (password_wide) {
cert_store = PFXImportCertStore(&cert_data_blob, password_wide, 0);
mz_os_unicode_string_delete(&password_wide);
}
@ -597,15 +539,13 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
if (cert_store == NULL)
return MZ_PARAM_ERROR;
if (err == MZ_OK)
{
if (err == MZ_OK) {
cert_context = CertFindCertificateInStore(cert_store,
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, CERT_FIND_HAS_PRIVATE_KEY, NULL, NULL);
if (cert_context == NULL)
err = MZ_PARAM_ERROR;
}
if (err == MZ_OK)
{
if (err == MZ_OK) {
memset(&sign_params, 0, sizeof(sign_params));
sign_params.cbSize = sizeof(sign_params);
@ -627,16 +567,14 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
if (timestamp_url != NULL)
timestamp_url_wide = mz_os_unicode_string_create(timestamp_url);
if (timestamp_url_wide != NULL)
{
if (timestamp_url_wide != NULL) {
result = CryptRetrieveTimeStamp(timestamp_url_wide,
TIMESTAMP_NO_AUTH_RETRIEVAL | TIMESTAMP_VERIFY_CONTEXT_SIGNATURE, 0, szOID_NIST_sha256,
NULL, message, message_size, &ts_context, NULL, NULL);
mz_os_unicode_string_delete(&timestamp_url_wide);
if ((result) && (ts_context != NULL))
{
if ((result) && (ts_context != NULL)) {
crypt_blob.cbData = ts_context->cbEncoded;
crypt_blob.pbData = ts_context->pbEncoded;
@ -677,8 +615,7 @@ int32_t mz_crypt_sign(uint8_t *message, int32_t message_size, uint8_t *cert_data
return err;
}
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size)
{
int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *signature, int32_t signature_size) {
CRYPT_VERIFY_MESSAGE_PARA verify_params;
CERT_CONTEXT *signer_cert = NULL;
CERT_CHAIN_PARA chain_para;
@ -729,8 +666,7 @@ int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *si
#if 0
crypt_msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING | X509_ASN_ENCODING, 0, 0, 0, NULL, NULL);
if (crypt_msg != NULL)
{
if (crypt_msg != NULL) {
/* Timestamp support */
PCRYPT_ATTRIBUTES unauth_attribs = NULL;
HCRYPTMSG ts_msg = 0;
@ -747,8 +683,7 @@ int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *si
if ((result) && (ts_signature_size > 0))
ts_signature = (uint8_t *)MZ_ALLOC(ts_signature_size);
if ((result) && (ts_signature != NULL))
{
if ((result) && (ts_signature != NULL)) {
result = CryptMsgGetParam(crypt_msg, CMSG_SIGNER_UNAUTH_ATTR_PARAM, 0, ts_signature,
&ts_signature_size);
if (result)
@ -775,15 +710,12 @@ int32_t mz_crypt_sign_verify(uint8_t *message, int32_t message_size, uint8_t *si
if (crypt_context != NULL)
CryptMemFree(crypt_context);
}
else
{
} else {
result = 0;
}
#endif
if ((result) && (decoded != NULL) && (decoded_size == message_size))
{
if ((result) && (decoded != NULL) && (decoded_size == message_size)) {
/* Verify cms message with our stored message */
if (memcmp(decoded, message, message_size) == 0)
err = MZ_OK;

134
mz_os.c
View File

@ -21,8 +21,7 @@
/***************************************************************************/
int32_t mz_path_combine(char *path, const char *join, int32_t max_path)
{
int32_t mz_path_combine(char *path, const char *join, int32_t max_path) {
int32_t path_len = 0;
if (path == NULL || join == NULL || max_path == 0)
@ -30,13 +29,10 @@ int32_t mz_path_combine(char *path, const char *join, int32_t max_path)
path_len = (int32_t)strlen(path);
if (path_len == 0)
{
if (path_len == 0) {
strncpy(path, join, max_path - 1);
path[max_path - 1] = 0;
}
else
{
} else {
mz_path_append_slash(path, max_path, MZ_PATH_SLASH_PLATFORM);
strncat(path, join, max_path - path_len);
}
@ -44,24 +40,20 @@ int32_t mz_path_combine(char *path, const char *join, int32_t max_path)
return MZ_OK;
}
int32_t mz_path_append_slash(char *path, int32_t max_path, char slash)
{
int32_t mz_path_append_slash(char *path, int32_t max_path, char slash) {
int32_t path_len = (int32_t)strlen(path);
if ((path_len + 2) >= max_path)
return MZ_BUF_ERROR;
if (path[path_len - 1] != '\\' && path[path_len - 1] != '/')
{
if (path[path_len - 1] != '\\' && path[path_len - 1] != '/') {
path[path_len] = slash;
path[path_len + 1] = 0;
}
return MZ_OK;
}
int32_t mz_path_remove_slash(char *path)
{
int32_t mz_path_remove_slash(char *path) {
int32_t path_len = (int32_t)strlen(path);
while (path_len > 0)
{
while (path_len > 0) {
if (path[path_len - 1] == '\\' || path[path_len - 1] == '/')
path[path_len - 1] = 0;
else
@ -72,39 +64,32 @@ int32_t mz_path_remove_slash(char *path)
return MZ_OK;
}
int32_t mz_path_has_slash(const char *path)
{
int32_t mz_path_has_slash(const char *path) {
int32_t path_len = (int32_t)strlen(path);
if (path[path_len - 1] != '\\' && path[path_len - 1] != '/')
return MZ_EXIST_ERROR;
return MZ_OK;
}
int32_t mz_path_convert_slashes(char *path, char slash)
{
int32_t mz_path_convert_slashes(char *path, char slash) {
int32_t i = 0;
for (i = 0; i < (int32_t)strlen(path); i += 1)
{
for (i = 0; i < (int32_t)strlen(path); i += 1) {
if (path[i] == '\\' || path[i] == '/')
path[i] = slash;
}
return MZ_OK;
}
int32_t mz_path_compare_wc(const char *path, const char *wildcard, uint8_t ignore_case)
{
while (*path != 0)
{
switch (*wildcard)
{
int32_t mz_path_compare_wc(const char *path, const char *wildcard, uint8_t ignore_case) {
while (*path != 0) {
switch (*wildcard) {
case '*':
if (*(wildcard + 1) == 0)
return MZ_OK;
while (*path != 0)
{
while (*path != 0) {
if (mz_path_compare_wc(path, (wildcard + 1), ignore_case) == MZ_OK)
return MZ_OK;
@ -118,13 +103,10 @@ int32_t mz_path_compare_wc(const char *path, const char *wildcard, uint8_t ignor
if ((*path == '\\' && *wildcard == '/') || (*path == '/' && *wildcard == '\\'))
break;
if (ignore_case)
{
if (ignore_case) {
if (tolower(*path) != tolower(*wildcard))
return MZ_EXIST_ERROR;
}
else
{
} else {
if (*path != *wildcard)
return MZ_EXIST_ERROR;
}
@ -142,8 +124,7 @@ int32_t mz_path_compare_wc(const char *path, const char *wildcard, uint8_t ignor
return MZ_OK;
}
int32_t mz_path_resolve(const char *path, char *output, int32_t max_output)
{
int32_t mz_path_resolve(const char *path, char *output, int32_t max_output) {
const char *source = path;
const char *check = output;
char *target = output;
@ -152,27 +133,22 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output)
if (max_output <= 0)
return MZ_PARAM_ERROR;
while (*source != 0 && max_output > 1)
{
while (*source != 0 && max_output > 1) {
check = source;
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;
}
if ((*check != 0) && (*check == '.'))
{
if ((*check != 0) && (*check == '.')) {
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;
@ -181,8 +157,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)
@ -190,26 +165,21 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output)
continue;
}
/* Go to parent directory .. */
else if (*check == '.')
{
else if (*check == '.') {
check += 1;
if ((*check == 0) || (*check == '\\' || *check == '/'))
{
if ((*check == 0) || (*check == '\\' || *check == '/')) {
source += (check - source);
/* Search backwards for previous slash */
if (target != output)
{
if (target != output) {
target -= 1;
do
{
do {
if ((*target == '\\') || (*target == '/'))
break;
target -= 1;
max_output += 1;
}
while (target > output);
} while (target > output);
}
if ((target == output) && (*source != 0))
@ -239,8 +209,7 @@ int32_t mz_path_resolve(const char *path, char *output, int32_t max_output)
return MZ_OK;
}
int32_t mz_path_remove_filename(char *path)
{
int32_t mz_path_remove_filename(char *path) {
char *path_ptr = NULL;
if (path == NULL)
@ -248,10 +217,8 @@ int32_t mz_path_remove_filename(char *path)
path_ptr = path + strlen(path) - 1;
while (path_ptr > path)
{
if ((*path_ptr == '/') || (*path_ptr == '\\'))
{
while (path_ptr > path) {
if ((*path_ptr == '/') || (*path_ptr == '\\')) {
*path_ptr = 0;
break;
}
@ -265,8 +232,7 @@ int32_t mz_path_remove_filename(char *path)
return MZ_OK;
}
int32_t mz_path_remove_extension(char *path)
{
int32_t mz_path_remove_extension(char *path) {
char *path_ptr = NULL;
if (path == NULL)
@ -274,12 +240,10 @@ int32_t mz_path_remove_extension(char *path)
path_ptr = path + strlen(path) - 1;
while (path_ptr > path)
{
while (path_ptr > path) {
if ((*path_ptr == '/') || (*path_ptr == '\\'))
break;
if (*path_ptr == '.')
{
if (*path_ptr == '.') {
*path_ptr = 0;
break;
}
@ -293,8 +257,7 @@ int32_t mz_path_remove_extension(char *path)
return MZ_OK;
}
int32_t mz_path_get_filename(const char *path, const char **filename)
{
int32_t mz_path_get_filename(const char *path, const char **filename) {
const char *match = NULL;
if (path == NULL || filename == NULL)
@ -302,8 +265,7 @@ int32_t mz_path_get_filename(const char *path, const char **filename)
*filename = NULL;
for (match = path; *match != 0; match += 1)
{
for (match = path; *match != 0; match += 1) {
if ((*match == '\\') || (*match == '/'))
*filename = match + 1;
}
@ -314,8 +276,7 @@ int32_t mz_path_get_filename(const char *path, const char **filename)
return MZ_OK;
}
int32_t mz_dir_make(const char *path)
{
int32_t mz_dir_make(const char *path) {
int32_t err = MZ_OK;
int16_t len = 0;
char *current_dir = NULL;
@ -335,11 +296,9 @@ int32_t mz_dir_make(const char *path)
mz_path_remove_slash(current_dir);
err = mz_os_make_dir(current_dir);
if (err != MZ_OK)
{
if (err != MZ_OK) {
match = current_dir + 1;
while (1)
{
while (1) {
while (*match != 0 && *match != '\\' && *match != '/')
match += 1;
hold = *match;
@ -360,8 +319,7 @@ int32_t mz_dir_make(const char *path)
return err;
}
int32_t mz_file_get_crc(const char *path, uint32_t *result_crc)
{
int32_t mz_file_get_crc(const char *path, uint32_t *result_crc) {
void *stream = NULL;
uint32_t crc32 = 0;
int32_t read = 0;
@ -372,21 +330,17 @@ int32_t mz_file_get_crc(const char *path, uint32_t *result_crc)
err = mz_stream_os_open(stream, path, MZ_OPEN_MODE_READ);
if (err == MZ_OK)
{
do
{
if (err == MZ_OK) {
do {
read = mz_stream_os_read(stream, buf, sizeof(buf));
if (read < 0)
{
if (read < 0) {
err = read;
break;
}
crc32 = mz_crypt_crc32_update(crc32, buf, read);
}
while ((err == MZ_OK) && (read > 0));
} while ((err == MZ_OK) && (read > 0));
mz_stream_os_close(stream);
}

84
mz_os_posix.c
View File

@ -34,8 +34,7 @@
/***************************************************************************/
#if defined(HAVE_ICONV)
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
{
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding) {
iconv_t cd;
const char *from_encoding = NULL;
size_t result = 0;
@ -69,8 +68,7 @@ uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
string_utf8 = (uint8_t *)MZ_ALLOC((int32_t)(string_utf8_size + 1));
string_utf8_ptr = string_utf8;
if (string_utf8)
{
if (string_utf8) {
memset(string_utf8, 0, string_utf8_size + 1);
result = iconv(cd, (char **)&string, &string_length,
@ -79,8 +77,7 @@ uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
iconv_close(cd);
if (result == (size_t)-1)
{
if (result == (size_t)-1) {
MZ_FREE(string_utf8);
string_utf8 = NULL;
}
@ -88,8 +85,7 @@ uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
return string_utf8;
}
#else
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
{
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding) {
size_t string_length = 0;
uint8_t *string_copy = NULL;
@ -102,10 +98,8 @@ uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
}
#endif
void mz_os_utf8_string_delete(uint8_t **string)
{
if (string != NULL)
{
void mz_os_utf8_string_delete(uint8_t **string) {
if (string != NULL) {
MZ_FREE(*string);
*string = NULL;
}
@ -113,14 +107,12 @@ void mz_os_utf8_string_delete(uint8_t **string)
/***************************************************************************/
int32_t mz_os_rand(uint8_t *buf, int32_t size)
{
int32_t mz_os_rand(uint8_t *buf, int32_t size) {
static unsigned calls = 0;
int32_t i = 0;
/* Ensure different random header each time */
if (++calls == 1)
{
if (++calls == 1) {
#define PI_SEED 3141592654UL
srand((unsigned)(time(NULL) ^ PI_SEED));
}
@ -131,24 +123,21 @@ int32_t mz_os_rand(uint8_t *buf, int32_t size)
return size;
}
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) {
if (rename(source_path, target_path) == -1)
return MZ_EXIST_ERROR;
return MZ_OK;
}
int32_t mz_os_unlink(const char *path)
{
int32_t mz_os_unlink(const char *path) {
if (unlink(path) == -1)
return MZ_EXIST_ERROR;
return MZ_OK;
}
int32_t mz_os_file_exists(const char *path)
{
int32_t mz_os_file_exists(const char *path) {
struct stat path_stat;
memset(&path_stat, 0, sizeof(path_stat));
@ -157,13 +146,11 @@ int32_t mz_os_file_exists(const char *path)
return MZ_EXIST_ERROR;
}
int64_t mz_os_get_file_size(const char *path)
{
int64_t mz_os_get_file_size(const char *path) {
struct stat path_stat;
memset(&path_stat, 0, sizeof(path_stat));
if (stat(path, &path_stat) == 0)
{
if (stat(path, &path_stat) == 0) {
/* Stat returns size taken up by directory entry, so return 0 */
if (S_ISDIR(path_stat.st_mode))
return 0;
@ -174,8 +161,7 @@ int64_t mz_os_get_file_size(const char *path)
return 0;
}
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) {
struct stat path_stat;
char *name = NULL;
size_t len = 0;
@ -183,16 +169,14 @@ int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *acc
memset(&path_stat, 0, sizeof(path_stat));
if (strcmp(path, "-") != 0)
{
if (strcmp(path, "-") != 0) {
/* Not all systems allow stat'ing a file with / appended */
len = strlen(path);
name = (char *)malloc(len + 1);
strncpy(name, path, len + 1);
mz_path_remove_slash(name);
if (stat(name, &path_stat) == 0)
{
if (stat(name, &path_stat) == 0) {
if (modified_date != NULL)
*modified_date = path_stat.st_mtime;
if (accessed_date != NULL)
@ -210,8 +194,7 @@ int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *acc
return err;
}
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) {
struct utimbuf ut;
ut.actime = accessed_date;
@ -226,8 +209,7 @@ int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t acces
return MZ_OK;
}
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) {
struct stat path_stat;
int32_t err = MZ_OK;
@ -238,8 +220,7 @@ int32_t mz_os_get_file_attribs(const char *path, uint32_t *attributes)
return err;
}
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) {
int32_t err = MZ_OK;
if (chmod(path, (mode_t)attributes) == -1)
@ -248,8 +229,7 @@ int32_t mz_os_set_file_attribs(const char *path, uint32_t attributes)
return err;
}
int32_t mz_os_make_dir(const char *path)
{
int32_t mz_os_make_dir(const char *path) {
int32_t err = 0;
err = mkdir(path, 0755);
@ -260,20 +240,17 @@ 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 == NULL)
return NULL;
return readdir(dir);
}
int32_t mz_os_close_dir(DIR *dir)
{
int32_t mz_os_close_dir(DIR *dir) {
if (dir == NULL)
return MZ_PARAM_ERROR;
if (closedir(dir) == -1)
@ -281,8 +258,7 @@ int32_t mz_os_close_dir(DIR *dir)
return MZ_OK;
}
int32_t mz_os_is_dir(const char *path)
{
int32_t mz_os_is_dir(const char *path) {
struct stat path_stat;
memset(&path_stat, 0, sizeof(path_stat));
@ -293,8 +269,7 @@ int32_t mz_os_is_dir(const char *path)
return MZ_EXIST_ERROR;
}
int32_t mz_os_is_symlink(const char *path)
{
int32_t mz_os_is_symlink(const char *path) {
struct stat path_stat;
memset(&path_stat, 0, sizeof(path_stat));
@ -305,15 +280,13 @@ int32_t mz_os_is_symlink(const char *path)
return MZ_EXIST_ERROR;
}
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) {
if (symlink(target_path, path) != 0)
return MZ_INTERNAL_ERROR;
return MZ_OK;
}
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) {
size_t length = 0;
length = (size_t)readlink(path, target_path, max_target_path - 1);
@ -324,8 +297,7 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
return MZ_OK;
}
uint64_t mz_os_ms_time(void)
{
uint64_t mz_os_ms_time(void) {
struct timespec ts;
#if defined(__APPLE__)

164
mz_os_win32.c
View File

@ -39,8 +39,7 @@ typedef struct DIR_int_s {
/***************************************************************************/
wchar_t *mz_os_unicode_string_create(const char *string, int32_t encoding)
{
wchar_t *mz_os_unicode_string_create(const char *string, int32_t encoding) {
wchar_t *string_wide = NULL;
uint32_t string_wide_size = 0;
@ -57,29 +56,24 @@ wchar_t *mz_os_unicode_string_create(const char *string, int32_t encoding)
return string_wide;
}
void mz_os_unicode_string_delete(wchar_t **string)
{
if (string != NULL)
{
void mz_os_unicode_string_delete(wchar_t **string) {
if (string != NULL) {
MZ_FREE(*string);
*string = NULL;
}
}
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
{
uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding) {
wchar_t *string_wide = NULL;
uint8_t *string_utf8 = NULL;
uint32_t string_utf8_size = 0;
string_wide = mz_os_unicode_string_create(string, encoding);
if (string_wide)
{
if (string_wide) {
string_utf8_size = WideCharToMultiByte(CP_UTF8, 0, string_wide, -1, NULL, 0, NULL, NULL);
string_utf8 = (uint8_t *)MZ_ALLOC((string_utf8_size + 1) * sizeof(wchar_t));
if (string_utf8)
{
if (string_utf8) {
memset(string_utf8, 0, string_utf8_size + 1);
WideCharToMultiByte(CP_UTF8, 0, string_wide, -1, (char *)string_utf8, string_utf8_size, NULL, NULL);
}
@ -90,16 +84,14 @@ uint8_t *mz_os_utf8_string_create(const char *string, int32_t encoding)
return string_utf8;
}
uint8_t *mz_os_utf8_string_create_from_unicode(const wchar_t *string, int32_t encoding)
{
uint8_t *mz_os_utf8_string_create_from_unicode(const wchar_t *string, int32_t encoding) {
uint8_t *string_utf8 = NULL;
uint32_t string_utf8_size = 0;
string_utf8_size = WideCharToMultiByte(CP_UTF8, 0, string, -1, NULL, 0, NULL, NULL);
string_utf8 = (uint8_t *)MZ_ALLOC((string_utf8_size + 1) * sizeof(wchar_t));
if (string_utf8)
{
if (string_utf8) {
memset(string_utf8, 0, string_utf8_size + 1);
WideCharToMultiByte(CP_UTF8, 0, string, -1, (char *)string_utf8, string_utf8_size, NULL, NULL);
}
@ -107,10 +99,8 @@ uint8_t *mz_os_utf8_string_create_from_unicode(const wchar_t *string, int32_t en
return string_utf8;
}
void mz_os_utf8_string_delete(uint8_t **string)
{
if (string != NULL)
{
void mz_os_utf8_string_delete(uint8_t **string) {
if (string != NULL) {
MZ_FREE(*string);
*string = NULL;
}
@ -118,13 +108,11 @@ void mz_os_utf8_string_delete(uint8_t **string)
/***************************************************************************/
int32_t mz_os_rand(uint8_t *buf, int32_t size)
{
int32_t mz_os_rand(uint8_t *buf, int32_t size) {
unsigned __int64 pentium_tsc[1];
int32_t len = 0;
for (len = 0; len < (int)size; len += 1)
{
for (len = 0; len < (int)size; len += 1) {
if (len % 8 == 0)
QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc);
buf[len] = ((unsigned char*)pentium_tsc)[len % 8];
@ -133,8 +121,7 @@ int32_t mz_os_rand(uint8_t *buf, int32_t size)
return len;
}
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) {
wchar_t *source_path_wide = NULL;
wchar_t *target_path_wide = NULL;
int32_t result = 0;
@ -144,19 +131,15 @@ int32_t mz_os_rename(const char *source_path, const char *target_path)
return MZ_PARAM_ERROR;
source_path_wide = mz_os_unicode_string_create(source_path, MZ_ENCODING_UTF8);
if (source_path_wide == NULL)
{
if (source_path_wide == NULL) {
err = MZ_PARAM_ERROR;
}
else
{
} else {
target_path_wide = mz_os_unicode_string_create(target_path, MZ_ENCODING_UTF8);
if (target_path_wide == NULL)
err = MZ_PARAM_ERROR;
}
if (err == MZ_OK)
{
if (err == MZ_OK) {
result = MoveFileW(source_path_wide, target_path_wide);
if (result == 0)
err = MZ_EXIST_ERROR;
@ -170,8 +153,7 @@ int32_t mz_os_rename(const char *source_path, const char *target_path)
return err;
}
int32_t mz_os_unlink(const char *path)
{
int32_t mz_os_unlink(const char *path) {
wchar_t *path_wide = NULL;
int32_t result = 0;
@ -194,8 +176,7 @@ int32_t mz_os_unlink(const char *path)
return MZ_OK;
}
int32_t mz_os_file_exists(const char *path)
{
int32_t mz_os_file_exists(const char *path) {
wchar_t *path_wide = NULL;
DWORD attribs = 0;
@ -214,8 +195,7 @@ int32_t mz_os_file_exists(const char *path)
return MZ_OK;
}
int64_t mz_os_get_file_size(const char *path)
{
int64_t mz_os_get_file_size(const char *path) {
HANDLE handle = NULL;
LARGE_INTEGER large_size;
wchar_t *path_wide = NULL;
@ -234,8 +214,7 @@ int64_t mz_os_get_file_size(const char *path)
large_size.QuadPart = 0;
if (handle != INVALID_HANDLE_VALUE)
{
if (handle != INVALID_HANDLE_VALUE) {
GetFileSizeEx(handle, &large_size);
CloseHandle(handle);
}
@ -243,24 +222,21 @@ int64_t mz_os_get_file_size(const char *path)
return large_size.QuadPart;
}
static void mz_os_file_to_unix_time(FILETIME file_time, time_t *unix_time)
{
static void mz_os_file_to_unix_time(FILETIME file_time, time_t *unix_time) {
uint64_t quad_file_time = 0;
quad_file_time = file_time.dwLowDateTime;
quad_file_time |= ((uint64_t)file_time.dwHighDateTime << 32);
*unix_time = (time_t)((quad_file_time - 116444736000000000LL) / 10000000);
}
static void mz_os_unix_to_file_time(time_t unix_time, FILETIME *file_time)
{
static void mz_os_unix_to_file_time(time_t unix_time, FILETIME *file_time) {
uint64_t quad_file_time = 0;
quad_file_time = ((uint64_t)unix_time * 10000000) + 116444736000000000LL;
file_time->dwHighDateTime = (quad_file_time >> 32);
file_time->dwLowDateTime = (uint32_t)(quad_file_time);
}
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) {
WIN32_FIND_DATAW ff32;
HANDLE handle = NULL;
wchar_t *path_wide = NULL;
@ -275,8 +251,7 @@ int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *acc
handle = FindFirstFileW(path_wide, &ff32);
MZ_FREE(path_wide);
if (handle != INVALID_HANDLE_VALUE)
{
if (handle != INVALID_HANDLE_VALUE) {
if (modified_date != NULL)
mz_os_file_to_unix_time(ff32.ftLastWriteTime, modified_date);
if (accessed_date != NULL)
@ -291,8 +266,7 @@ int32_t mz_os_get_file_date(const char *path, time_t *modified_date, time_t *acc
return err;
}
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) {
HANDLE handle = NULL;
FILETIME ftm_creation, ftm_accessed, ftm_modified;
wchar_t *path_wide = NULL;
@ -311,8 +285,7 @@ int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t acces
#endif
mz_os_unicode_string_delete(&path_wide);
if (handle != INVALID_HANDLE_VALUE)
{
if (handle != INVALID_HANDLE_VALUE) {
GetFileTime(handle, &ftm_creation, &ftm_accessed, &ftm_modified);
if (modified_date != 0)
@ -331,8 +304,7 @@ int32_t mz_os_set_file_date(const char *path, time_t modified_date, time_t acces
return err;
}
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) {
wchar_t *path_wide = NULL;
int32_t err = MZ_OK;
@ -351,8 +323,7 @@ int32_t mz_os_get_file_attribs(const char *path, uint32_t *attributes)
return err;
}
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) {
wchar_t *path_wide = NULL;
int32_t err = MZ_OK;
@ -369,8 +340,7 @@ int32_t mz_os_set_file_attribs(const char *path, uint32_t attributes)
return err;
}
int32_t mz_os_make_dir(const char *path)
{
int32_t mz_os_make_dir(const char *path) {
wchar_t *path_wide = NULL;
int32_t err = MZ_OK;
@ -385,8 +355,7 @@ int32_t mz_os_make_dir(const char *path)
if (path_wide == NULL)
return MZ_PARAM_ERROR;
if (CreateDirectoryW(path_wide, NULL) == 0)
{
if (CreateDirectoryW(path_wide, NULL) == 0) {
if (GetLastError() != ERROR_ALREADY_EXISTS)
err = MZ_INTERNAL_ERROR;
}
@ -396,8 +365,7 @@ int32_t mz_os_make_dir(const char *path)
return err;
}
DIR *mz_os_open_dir(const char *path)
{
DIR *mz_os_open_dir(const char *path) {
WIN32_FIND_DATAW find_data;
DIR_int *dir_int = NULL;
wchar_t *path_wide = NULL;
@ -435,8 +403,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 == NULL)
@ -449,8 +416,7 @@ struct dirent* mz_os_read_dir(DIR *dir)
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 (FindNextFileW(dir_int->find_handle, &dir_int->find_data) == 0) {
if (GetLastError() != ERROR_NO_MORE_FILES)
return NULL;
@ -460,8 +426,7 @@ struct dirent* mz_os_read_dir(DIR *dir)
return &dir_int->entry;
}
int32_t mz_os_close_dir(DIR *dir)
{
int32_t mz_os_close_dir(DIR *dir) {
DIR_int *dir_int;
if (dir == NULL)
@ -474,8 +439,7 @@ int32_t mz_os_close_dir(DIR *dir)
return MZ_OK;
}
int32_t mz_os_is_dir(const char *path)
{
int32_t mz_os_is_dir(const char *path) {
wchar_t *path_wide = NULL;
uint32_t attribs = 0;
@ -488,8 +452,7 @@ int32_t mz_os_is_dir(const char *path)
attribs = GetFileAttributesW(path_wide);
mz_os_unicode_string_delete(&path_wide);
if (attribs != 0xFFFFFFFF)
{
if (attribs != 0xFFFFFFFF) {
if (attribs & FILE_ATTRIBUTE_DIRECTORY)
return MZ_OK;
}
@ -497,8 +460,7 @@ int32_t mz_os_is_dir(const char *path)
return MZ_EXIST_ERROR;
}
int32_t mz_os_is_symlink(const char *path)
{
int32_t mz_os_is_symlink(const char *path) {
wchar_t *path_wide = NULL;
uint32_t attribs = 0;
@ -511,8 +473,7 @@ int32_t mz_os_is_symlink(const char *path)
attribs = GetFileAttributesW(path_wide);
mz_os_unicode_string_delete(&path_wide);
if (attribs != 0xFFFFFFFF)
{
if (attribs != 0xFFFFFFFF) {
if (attribs & FILE_ATTRIBUTE_REPARSE_POINT)
return MZ_OK;
}
@ -520,8 +481,7 @@ int32_t mz_os_is_symlink(const char *path)
return MZ_EXIST_ERROR;
}
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) {
typedef BOOLEAN (WINAPI *LPCREATESYMBOLICLINKW)(LPCWSTR, LPCWSTR, DWORD);
LPCREATESYMBOLICLINKW create_symbolic_link_w = NULL;
HMODULE kernel32_mod = NULL;
@ -539,20 +499,17 @@ int32_t mz_os_make_symlink(const char *path, const char *target_path)
return MZ_SUPPORT_ERROR;
create_symbolic_link_w = (LPCREATESYMBOLICLINKW)GetProcAddress(kernel32_mod, "CreateSymbolicLinkW");
if (create_symbolic_link_w == NULL)
{
if (create_symbolic_link_w == NULL) {
return MZ_SUPPORT_ERROR;
}
path_wide = mz_os_unicode_string_create(path, MZ_ENCODING_UTF8);
if (path_wide == NULL)
{
if (path_wide == NULL) {
return MZ_PARAM_ERROR;
}
target_path_wide = mz_os_unicode_string_create(target_path, MZ_ENCODING_UTF8);
if (target_path_wide != NULL)
{
if (target_path_wide != NULL) {
if (mz_path_has_slash(target_path) == MZ_OK)
flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
@ -560,9 +517,7 @@ int32_t mz_os_make_symlink(const char *path, const char *target_path)
err = MZ_SYMLINK_ERROR;
mz_os_unicode_string_delete(&target_path_wide);
}
else
{
} else {
err = MZ_PARAM_ERROR;
}
@ -571,8 +526,7 @@ int32_t mz_os_make_symlink(const char *path, const char *target_path)
return err;
}
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) {
typedef struct _REPARSE_DATA_BUFFER {
ULONG ReparseTag;
USHORT ReparseDataLength;
@ -619,25 +573,21 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
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);
if (handle == INVALID_HANDLE_VALUE)
{
if (handle == INVALID_HANDLE_VALUE) {
mz_os_unicode_string_delete(&path_wide);
return MZ_OPEN_ERROR;
}
if (DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0, buffer, sizeof(buffer), &length, NULL) == TRUE)
{
if (DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0, buffer, sizeof(buffer), &length, NULL) == TRUE) {
reparse_data = (REPARSE_DATA_BUFFER *)buffer;
if ((IsReparseTagMicrosoft(reparse_data->ReparseTag)) &&
(reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK))
{
(reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK)) {
target_path_len = max_target_path * sizeof(wchar_t);
if (target_path_len > reparse_data->SymbolicLinkReparseBuffer.PrintNameLength)
target_path_len = reparse_data->SymbolicLinkReparseBuffer.PrintNameLength;
target_path_wide = (wchar_t *)MZ_ALLOC(target_path_len + sizeof(wchar_t));
if (target_path_wide)
{
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);
@ -645,30 +595,23 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
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);
if (target_path_utf8)
{
if (target_path_utf8) {
strncpy(target_path, (const char *)target_path_utf8, max_target_path - 1);
target_path[max_target_path - 1] = 0;
/* Ensure directories have slash at the end so we can recreate them later */
if (mz_os_is_dir((const char *)target_path_utf8) == MZ_OK)
mz_path_append_slash(target_path, max_target_path, MZ_PATH_SLASH_PLATFORM);
mz_os_utf8_string_delete(&target_path_utf8);
}
else
{
} else {
err = MZ_MEM_ERROR;
}
MZ_FREE(target_path_wide);
}
else
{
} else {
err = MZ_MEM_ERROR;
}
}
}
else
{
} else {
err = MZ_INTERNAL_ERROR;
}
@ -677,8 +620,7 @@ int32_t mz_os_read_symlink(const char *path, char *target_path, int32_t max_targ
return err;
}
uint64_t mz_os_ms_time(void)
{
uint64_t mz_os_ms_time(void) {
SYSTEMTIME system_time;
FILETIME file_time;
uint64_t quad_file_time = 0;

186
mz_strm.c
View File

@ -18,24 +18,21 @@
/***************************************************************************/
int32_t mz_stream_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_open(void *stream, const char *path, int32_t mode) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->open == NULL)
return MZ_STREAM_ERROR;
return strm->vtbl->open(strm, path, mode);
}
int32_t mz_stream_is_open(void *stream)
{
int32_t mz_stream_is_open(void *stream) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->is_open == NULL)
return MZ_STREAM_ERROR;
return strm->vtbl->is_open(strm);
}
int32_t mz_stream_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_read(void *stream, void *buf, int32_t size) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->read == NULL)
return MZ_PARAM_ERROR;
@ -44,19 +41,16 @@ int32_t mz_stream_read(void *stream, void *buf, int32_t size)
return strm->vtbl->read(strm, buf, size);
}
static int32_t mz_stream_read_value(void *stream, uint64_t *value, int32_t len)
{
static int32_t mz_stream_read_value(void *stream, uint64_t *value, int32_t len) {
uint8_t buf[8];
int32_t n = 0;
int32_t i = 0;
*value = 0;
if (mz_stream_read(stream, buf, len) == len)
{
if (mz_stream_read(stream, buf, len) == len) {
for (n = 0; n < len; n += 1, i += 8)
*value += ((uint64_t)buf[n]) << i;
}
else if (mz_stream_error(stream))
} else if (mz_stream_error(stream))
return MZ_STREAM_ERROR;
else
return MZ_END_OF_STREAM;
@ -64,8 +58,7 @@ static int32_t mz_stream_read_value(void *stream, uint64_t *value, int32_t len)
return MZ_OK;
}
int32_t mz_stream_read_uint8(void *stream, uint8_t *value)
{
int32_t mz_stream_read_uint8(void *stream, uint8_t *value) {
int32_t err = MZ_OK;
uint64_t value64 = 0;
@ -76,8 +69,7 @@ int32_t mz_stream_read_uint8(void *stream, uint8_t *value)
return err;
}
int32_t mz_stream_read_uint16(void *stream, uint16_t *value)
{
int32_t mz_stream_read_uint16(void *stream, uint16_t *value) {
int32_t err = MZ_OK;
uint64_t value64 = 0;
@ -88,8 +80,7 @@ int32_t mz_stream_read_uint16(void *stream, uint16_t *value)
return err;
}
int32_t mz_stream_read_uint32(void *stream, uint32_t *value)
{
int32_t mz_stream_read_uint32(void *stream, uint32_t *value) {
int32_t err = MZ_OK;
uint64_t value64 = 0;
@ -100,18 +91,15 @@ int32_t mz_stream_read_uint32(void *stream, uint32_t *value)
return err;
}
int32_t mz_stream_read_int64(void *stream, int64_t *value)
{
int32_t mz_stream_read_int64(void *stream, int64_t *value) {
return mz_stream_read_value(stream, (uint64_t *)value, sizeof(uint64_t));
}
int32_t mz_stream_read_uint64(void *stream, uint64_t *value)
{
int32_t mz_stream_read_uint64(void *stream, uint64_t *value) {
return mz_stream_read_value(stream, value, sizeof(uint64_t));
}
int32_t mz_stream_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_write(void *stream, const void *buf, int32_t size) {
mz_stream *strm = (mz_stream *)stream;
if (size == 0)
return size;
@ -122,19 +110,16 @@ int32_t mz_stream_write(void *stream, const void *buf, int32_t size)
return strm->vtbl->write(strm, buf, size);
}
static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len)
{
static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len) {
uint8_t buf[8];
int32_t n = 0;
for (n = 0; n < len; n += 1)
{
for (n = 0; n < len; n += 1) {
buf[n] = (uint8_t)(value & 0xff);
value >>= 8;
}
if (value != 0)
{
if (value != 0) {
/* Data overflow - hack for ZIP64 (X Roche) */
for (n = 0; n < len; n += 1)
buf[n] = 0xff;
@ -146,44 +131,36 @@ static int32_t mz_stream_write_value(void *stream, uint64_t value, int32_t len)
return MZ_OK;
}
int32_t mz_stream_write_uint8(void *stream, uint8_t value)
{
int32_t mz_stream_write_uint8(void *stream, uint8_t value) {
return mz_stream_write_value(stream, value, sizeof(uint8_t));
}
int32_t mz_stream_write_uint16(void *stream, uint16_t value)
{
int32_t mz_stream_write_uint16(void *stream, uint16_t value) {
return mz_stream_write_value(stream, value, sizeof(uint16_t));
}
int32_t mz_stream_write_uint32(void *stream, uint32_t value)
{
int32_t mz_stream_write_uint32(void *stream, uint32_t value) {
return mz_stream_write_value(stream, value, sizeof(uint32_t));
}
int32_t mz_stream_write_int64(void *stream, int64_t value)
{
int32_t mz_stream_write_int64(void *stream, int64_t value) {
return mz_stream_write_value(stream, (uint64_t)value, sizeof(uint64_t));
}
int32_t mz_stream_write_uint64(void *stream, uint64_t value)
{
int32_t mz_stream_write_uint64(void *stream, uint64_t value) {
return mz_stream_write_value(stream, value, sizeof(uint64_t));
}
int32_t mz_stream_copy(void *target, void *source, int32_t len)
{
int32_t mz_stream_copy(void *target, void *source, int32_t len) {
return mz_stream_copy_stream(target, NULL, source, NULL, len);
}
int32_t mz_stream_copy_to_end(void *target, void *source)
{
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)
{
mz_stream_read_cb read_cb, int32_t len) {
uint8_t buf[16384];
int32_t bytes_to_copy = 0;
int32_t read = 0;
@ -194,8 +171,7 @@ int32_t mz_stream_copy_stream(void *target, mz_stream_write_cb write_cb, void *s
if (read_cb == NULL)
read_cb = mz_stream_read;
while (len > 0)
{
while (len > 0) {
bytes_to_copy = len;
if (bytes_to_copy > (int32_t)sizeof(buf))
bytes_to_copy = sizeof(buf);
@ -212,8 +188,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;
@ -224,8 +199,7 @@ int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb,
read_cb = mz_stream_read;
read = read_cb(source, buf, sizeof(buf));
while (read > 0)
{
while (read > 0) {
written = write_cb(target, buf, read);
if (written != read)
return MZ_STREAM_ERROR;
@ -238,8 +212,7 @@ int32_t mz_stream_copy_stream_to_end(void *target, mz_stream_write_cb write_cb,
return MZ_OK;
}
int64_t mz_stream_tell(void *stream)
{
int64_t mz_stream_tell(void *stream) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->tell == NULL)
return MZ_PARAM_ERROR;
@ -248,8 +221,7 @@ int64_t mz_stream_tell(void *stream)
return strm->vtbl->tell(strm);
}
int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->seek == NULL)
return MZ_PARAM_ERROR;
@ -260,8 +232,7 @@ int32_t mz_stream_seek(void *stream, int64_t offset, int32_t origin)
return strm->vtbl->seek(strm, offset, origin);
}
int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position)
{
int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
uint8_t buf[MZ_STREAM_FIND_SIZE];
int32_t buf_pos = 0;
int32_t read_size = sizeof(buf);
@ -282,8 +253,7 @@ 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)
{
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))
read_size = (int32_t)(max_seek - read_pos - buf_pos);
@ -291,8 +261,7 @@ int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_
if ((read <= 0) || (read + buf_pos < find_size))
break;
for (i = 0; i <= read + buf_pos - find_size; i += 1)
{
for (i = 0; i <= read + buf_pos - find_size; i += 1) {
if (memcmp(&buf[i], find, find_size) != 0)
continue;
@ -307,8 +276,7 @@ int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_
return MZ_OK;
}
if (first)
{
if (first) {
read -= find_size;
read_size -= find_size;
buf_pos = find_size;
@ -322,8 +290,7 @@ int32_t mz_stream_find(void *stream, const void *find, int32_t find_size, int64_
return MZ_EXIST_ERROR;
}
int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position)
{
int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size, int64_t max_seek, int64_t *position) {
uint8_t buf[MZ_STREAM_FIND_SIZE];
int32_t buf_pos = 0;
int32_t read_size = MZ_STREAM_FIND_SIZE;
@ -344,8 +311,7 @@ int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size
start_pos = mz_stream_tell(stream);
while (read_pos < max_seek)
{
while (read_pos < max_seek) {
if (read_size > (int32_t)(max_seek - read_pos) && (max_seek - read_pos) < (int64_t)sizeof(buf))
read_size = (int32_t)(max_seek - read_pos);
@ -357,8 +323,7 @@ int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size
if (read + buf_pos < MZ_STREAM_FIND_SIZE)
memmove(buf + MZ_STREAM_FIND_SIZE - (read + buf_pos), buf, read);
for (i = find_size; i <= (read + buf_pos); i += 1)
{
for (i = find_size; i <= (read + buf_pos); i += 1) {
if (memcmp(&buf[MZ_STREAM_FIND_SIZE - i], find, find_size) != 0)
continue;
@ -373,8 +338,7 @@ int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size
return MZ_OK;
}
if (first)
{
if (first) {
read -= find_size;
read_size -= find_size;
buf_pos = find_size;
@ -391,8 +355,7 @@ int32_t mz_stream_find_reverse(void *stream, const void *find, int32_t find_size
return MZ_EXIST_ERROR;
}
int32_t mz_stream_close(void *stream)
{
int32_t mz_stream_close(void *stream) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->close == NULL)
return MZ_PARAM_ERROR;
@ -401,47 +364,41 @@ int32_t mz_stream_close(void *stream)
return strm->vtbl->close(strm);
}
int32_t mz_stream_error(void *stream)
{
int32_t mz_stream_error(void *stream) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->error == NULL)
return MZ_PARAM_ERROR;
return strm->vtbl->error(strm);
}
int32_t mz_stream_set_base(void *stream, void *base)
{
int32_t mz_stream_set_base(void *stream, void *base) {
mz_stream *strm = (mz_stream *)stream;
strm->base = (mz_stream *)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 == NULL || strm->vtbl == NULL)
return NULL;
return (void *)strm->vtbl;
}
int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->get_prop_int64 == NULL)
return MZ_PARAM_ERROR;
return strm->vtbl->get_prop_int64(stream, prop, value);
}
int32_t mz_stream_set_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) {
mz_stream *strm = (mz_stream *)stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->set_prop_int64 == NULL)
return MZ_PARAM_ERROR;
return strm->vtbl->set_prop_int64(stream, prop, value);
}
void *mz_stream_create(void **stream, mz_stream_vtbl *vtbl)
{
void *mz_stream_create(void **stream, mz_stream_vtbl *vtbl) {
if (stream == NULL)
return NULL;
if (vtbl == NULL || vtbl->create == NULL)
@ -449,8 +406,7 @@ void *mz_stream_create(void **stream, mz_stream_vtbl *vtbl)
return vtbl->create(stream);
}
void mz_stream_delete(void **stream)
{
void mz_stream_delete(void **stream) {
mz_stream *strm = NULL;
if (stream == NULL)
return;
@ -471,8 +427,7 @@ typedef struct mz_stream_raw_s {
/***************************************************************************/
int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode) {
MZ_UNUSED(stream);
MZ_UNUSED(path);
MZ_UNUSED(mode);
@ -480,28 +435,24 @@ int32_t mz_stream_raw_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_raw_is_open(void *stream)
{
int32_t mz_stream_raw_is_open(void *stream) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_is_open(raw->stream.base);
}
int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
int32_t bytes_to_read = size;
int32_t read = 0;
if (raw->max_total_in > 0)
{
if (raw->max_total_in > 0) {
if ((int64_t)bytes_to_read > (raw->max_total_in - raw->total_in))
bytes_to_read = (int32_t)(raw->max_total_in - raw->total_in);
}
read = mz_stream_read(raw->stream.base, buf, bytes_to_read);
if (read > 0)
{
if (read > 0) {
raw->total_in += read;
raw->total_out += read;
}
@ -509,15 +460,13 @@ int32_t mz_stream_raw_read(void *stream, void *buf, int32_t size)
return read;
}
int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
int32_t written = 0;
written = mz_stream_write(raw->stream.base, buf, size);
if (written > 0)
{
if (written > 0) {
raw->total_out += written;
raw->total_in += written;
}
@ -525,35 +474,29 @@ int32_t mz_stream_raw_write(void *stream, const void *buf, int32_t size)
return written;
}
int64_t mz_stream_raw_tell(void *stream)
{
int64_t mz_stream_raw_tell(void *stream) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_tell(raw->stream.base);
}
int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_raw_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_seek(raw->stream.base, offset, origin);
}
int32_t mz_stream_raw_close(void *stream)
{
int32_t mz_stream_raw_close(void *stream) {
MZ_UNUSED(stream);
return MZ_OK;
}
int32_t mz_stream_raw_error(void *stream)
{
int32_t mz_stream_raw_error(void *stream) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
return mz_stream_error(raw->stream.base);
}
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = raw->total_in;
return MZ_OK;
@ -564,11 +507,9 @@ int32_t mz_stream_raw_get_prop_int64(void *stream, int32_t prop, int64_t *value)
return MZ_EXIST_ERROR;
}
int32_t mz_stream_raw_set_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) {
mz_stream_raw *raw = (mz_stream_raw *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN_MAX:
raw->max_total_in = value;
return MZ_OK;
@ -595,13 +536,11 @@ static mz_stream_vtbl mz_stream_raw_vtbl = {
/***************************************************************************/
void *mz_stream_raw_create(void **stream)
{
void *mz_stream_raw_create(void **stream) {
mz_stream_raw *raw = NULL;
raw = (mz_stream_raw *)MZ_ALLOC(sizeof(mz_stream_raw));
if (raw != NULL)
{
if (raw != NULL) {
memset(raw, 0, sizeof(mz_stream_raw));
raw->stream.vtbl = &mz_stream_raw_vtbl;
}
@ -611,8 +550,7 @@ void *mz_stream_raw_create(void **stream)
return raw;
}
void mz_stream_raw_delete(void **stream)
{
void mz_stream_raw_delete(void **stream) {
mz_stream_raw *raw = NULL;
if (stream == NULL)
return;

3
mz_strm.h
View File

@ -51,8 +51,7 @@ typedef int32_t (*mz_stream_find_cb) (void *stream, const void *find,
/***************************************************************************/
typedef struct mz_stream_vtbl_s
{
typedef struct mz_stream_vtbl_s {
mz_stream_open_cb open;
mz_stream_is_open_cb is_open;
mz_stream_read_cb read;

172
mz_strm_buf.c
View File

@ -60,8 +60,7 @@ typedef struct mz_stream_buffered_s {
/***************************************************************************/
static int32_t mz_stream_buffered_reset(void *stream)
{
static int32_t mz_stream_buffered_reset(void *stream) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
buffered->readbuf_len = 0;
@ -73,22 +72,19 @@ static int32_t mz_stream_buffered_reset(void *stream)
return MZ_OK;
}
int32_t mz_stream_buffered_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_buffered_open(void *stream, const char *path, int32_t mode) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
mz_stream_buffered_print("Buffered - Open (mode %" PRId32 ")\n", mode);
mz_stream_buffered_reset(buffered);
return mz_stream_open(buffered->stream.base, path, mode);
}
int32_t mz_stream_buffered_is_open(void *stream)
{
int32_t mz_stream_buffered_is_open(void *stream) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
return mz_stream_is_open(buffered->stream.base);
}
static int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
{
static int32_t mz_stream_buffered_flush(void *stream, int32_t *written) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
int32_t total_bytes_written = 0;
int32_t bytes_to_write = buffered->writebuf_len;
@ -97,8 +93,7 @@ static int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
*written = 0;
while (bytes_left_to_write > 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);
@ -122,8 +117,7 @@ static int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
return MZ_OK;
}
int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
int32_t buf_len = 0;
int32_t bytes_to_read = 0;
@ -133,18 +127,14 @@ 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)
{
if (buffered->writebuf_len > 0) {
mz_stream_buffered_print("Buffered - Switch from write to read, not yet supported (pos %" PRId64 ")\n",
buffered->position);
}
while (bytes_left_to_read > 0)
{
if ((buffered->readbuf_len == 0) || (buffered->readbuf_pos == buffered->readbuf_len))
{
if (buffered->readbuf_len == sizeof(buffered->readbuf))
{
while (bytes_left_to_read > 0) {
if ((buffered->readbuf_len == 0) || (buffered->readbuf_pos == buffered->readbuf_len)) {
if (buffered->readbuf_len == sizeof(buffered->readbuf)) {
buffered->readbuf_pos = 0;
buffered->readbuf_len = 0;
}
@ -165,8 +155,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
break;
}
if ((buffered->readbuf_len - buffered->readbuf_pos) > 0)
{
if ((buffered->readbuf_len - buffered->readbuf_pos) > 0) {
bytes_to_copy = buffered->readbuf_len - buffered->readbuf_pos;
if (bytes_to_copy > bytes_left_to_read)
bytes_to_copy = bytes_left_to_read;
@ -187,8 +176,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
return size - bytes_left_to_read;
}
int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
int32_t bytes_to_write = size;
int32_t bytes_left_to_write = size;
@ -201,8 +189,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
mz_stream_buffered_print("Buffered - Write (size %" PRId32 " len %" PRId32 " pos %" PRId64 ")\n",
size, buffered->writebuf_len, buffered->position);
if (buffered->readbuf_len > 0)
{
if (buffered->readbuf_len > 0) {
buffered->position -= buffered->readbuf_len;
buffered->position += buffered->readbuf_pos;
@ -216,8 +203,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
return err;
}
while (bytes_left_to_write > 0)
{
while (bytes_left_to_write > 0) {
bytes_used = buffered->writebuf_len;
if (bytes_used > buffered->writebuf_pos)
bytes_used = buffered->writebuf_pos;
@ -225,8 +211,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
if (bytes_to_copy > bytes_left_to_write)
bytes_to_copy = bytes_left_to_write;
if (bytes_to_copy == 0)
{
if (bytes_to_copy == 0) {
err = mz_stream_buffered_flush(stream, &bytes_flushed);
if (err != MZ_OK)
return err;
@ -253,8 +238,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
return size - bytes_left_to_write;
}
int64_t mz_stream_buffered_tell(void *stream)
{
int64_t mz_stream_buffered_tell(void *stream) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
int64_t position = mz_stream_tell(buffered->stream.base);
@ -270,8 +254,7 @@ int64_t mz_stream_buffered_tell(void *stream)
return position;
}
int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
int32_t bytes_flushed = 0;
int32_t err = MZ_OK;
@ -279,69 +262,60 @@ int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin)
mz_stream_buffered_print("Buffered - Seek (origin %" PRId32 " offset %" PRId64 " pos %" PRId64 ")\n",
origin, offset, buffered->position);
switch (origin)
{
case MZ_SEEK_SET:
switch (origin) {
case MZ_SEEK_SET:
if (buffered->writebuf_len > 0)
{
if ((offset >= buffered->position) && (offset <= buffered->position + buffered->writebuf_len))
{
buffered->writebuf_pos = (int32_t)(offset - buffered->position);
return MZ_OK;
}
}
if ((buffered->readbuf_len > 0) && (offset < buffered->position) &&
(offset >= buffered->position - buffered->readbuf_len))
{
buffered->readbuf_pos = (int32_t)(offset - (buffered->position - buffered->readbuf_len));
if (buffered->writebuf_len > 0) {
if ((offset >= buffered->position) && (offset <= buffered->position + buffered->writebuf_len)) {
buffered->writebuf_pos = (int32_t)(offset - buffered->position);
return MZ_OK;
}
}
err = mz_stream_buffered_flush(stream, &bytes_flushed);
if (err != MZ_OK)
return err;
if ((buffered->readbuf_len > 0) && (offset < buffered->position) &&
(offset >= buffered->position - buffered->readbuf_len)) {
buffered->readbuf_pos = (int32_t)(offset - (buffered->position - buffered->readbuf_len));
return MZ_OK;
}
buffered->position = offset;
break;
err = mz_stream_buffered_flush(stream, &bytes_flushed);
if (err != MZ_OK)
return err;
case MZ_SEEK_CUR:
buffered->position = offset;
break;
if (buffered->readbuf_len > 0)
{
if (offset <= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos))
{
buffered->readbuf_pos += (uint32_t)offset;
return MZ_OK;
}
offset -= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos);
buffered->position += offset;
}
if (buffered->writebuf_len > 0)
{
if (offset <= ((int64_t)buffered->writebuf_len - buffered->writebuf_pos))
{
buffered->writebuf_pos += (uint32_t)offset;
return MZ_OK;
}
/* offset -= (buffered->writebuf_len - buffered->writebuf_pos); */
}
case MZ_SEEK_CUR:
err = mz_stream_buffered_flush(stream, &bytes_flushed);
if (err != MZ_OK)
return err;
break;
case MZ_SEEK_END:
if (buffered->writebuf_len > 0)
{
buffered->writebuf_pos = buffered->writebuf_len;
if (buffered->readbuf_len > 0) {
if (offset <= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos)) {
buffered->readbuf_pos += (uint32_t)offset;
return MZ_OK;
}
break;
offset -= ((int64_t)buffered->readbuf_len - buffered->readbuf_pos);
buffered->position += offset;
}
if (buffered->writebuf_len > 0) {
if (offset <= ((int64_t)buffered->writebuf_len - buffered->writebuf_pos)) {
buffered->writebuf_pos += (uint32_t)offset;
return MZ_OK;
}
/* offset -= (buffered->writebuf_len - buffered->writebuf_pos); */
}
err = mz_stream_buffered_flush(stream, &bytes_flushed);
if (err != MZ_OK)
return err;
break;
case MZ_SEEK_END:
if (buffered->writebuf_len > 0) {
buffered->writebuf_pos = buffered->writebuf_len;
return MZ_OK;
}
break;
}
buffered->readbuf_len = 0;
@ -352,22 +326,19 @@ int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin)
return mz_stream_seek(buffered->stream.base, offset, origin);
}
int32_t mz_stream_buffered_close(void *stream)
{
int32_t mz_stream_buffered_close(void *stream) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
int32_t bytes_flushed = 0;
mz_stream_buffered_flush(stream, &bytes_flushed);
mz_stream_buffered_print("Buffered - Close (flushed %" PRId32 ")\n", bytes_flushed);
if (buffered->readbuf_hits + buffered->readbuf_misses > 0)
{
if (buffered->readbuf_hits + buffered->readbuf_misses > 0) {
mz_stream_buffered_print("Buffered - Read efficiency %.02f%%\n",
(buffered->readbuf_hits / ((float)buffered->readbuf_hits + buffered->readbuf_misses)) * 100);
}
if (buffered->writebuf_hits + buffered->writebuf_misses > 0)
{
if (buffered->writebuf_hits + buffered->writebuf_misses > 0) {
mz_stream_buffered_print("Buffered - Write efficiency %.02f%%\n",
(buffered->writebuf_hits / ((float)buffered->writebuf_hits + buffered->writebuf_misses)) * 100);
}
@ -377,19 +348,16 @@ int32_t mz_stream_buffered_close(void *stream)
return mz_stream_close(buffered->stream.base);
}
int32_t mz_stream_buffered_error(void *stream)
{
int32_t mz_stream_buffered_error(void *stream) {
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
return mz_stream_error(buffered->stream.base);
}
void *mz_stream_buffered_create(void **stream)
{
void *mz_stream_buffered_create(void **stream) {
mz_stream_buffered *buffered = NULL;
buffered = (mz_stream_buffered *)MZ_ALLOC(sizeof(mz_stream_buffered));
if (buffered != NULL)
{
if (buffered != NULL) {
memset(buffered, 0, sizeof(mz_stream_buffered));
buffered->stream.vtbl = &mz_stream_buffered_vtbl;
}
@ -399,8 +367,7 @@ void *mz_stream_buffered_create(void **stream)
return buffered;
}
void mz_stream_buffered_delete(void **stream)
{
void mz_stream_buffered_delete(void **stream) {
mz_stream_buffered *buffered = NULL;
if (stream == NULL)
return;
@ -410,7 +377,6 @@ void mz_stream_buffered_delete(void **stream)
*stream = NULL;
}
void *mz_stream_buffered_get_interface(void)
{
void *mz_stream_buffered_get_interface(void) {
return (void *)&mz_stream_buffered_vtbl;
}

101
mz_strm_bzip.c
View File

@ -52,8 +52,7 @@ typedef struct mz_stream_bzip_s {
/***************************************************************************/
int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
MZ_UNUSED(path);
@ -69,8 +68,7 @@ int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode)
bzip->total_in = 0;
bzip->total_out = 0;
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -79,9 +77,7 @@ int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode)
bzip->error = BZ2_bzCompressInit(&bzip->bzstream, bzip->level, 0, 0);
#endif
}
else if (mode & MZ_OPEN_MODE_READ)
{
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -101,16 +97,14 @@ int32_t mz_stream_bzip_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_bzip_is_open(void *stream)
{
int32_t mz_stream_bzip_is_open(void *stream) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
if (bzip->initialized != 1)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
MZ_UNUSED(stream);
MZ_UNUSED(buf);
@ -137,12 +131,9 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
bzip->bzstream.next_out = (char *)buf;
bzip->bzstream.avail_out = (unsigned int)size;
do
{
if (bzip->bzstream.avail_in == 0)
{
if (bzip->max_total_in > 0)
{
do {
if (bzip->bzstream.avail_in == 0) {
if (bzip->max_total_in > 0) {
if ((int64_t)bytes_to_read > (bzip->max_total_in - bzip->total_in))
bytes_to_read = (int32_t)(bzip->max_total_in - bzip->total_in);
}
@ -175,18 +166,15 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
bzip->total_in += in_bytes;
bzip->total_out += out_bytes;
if (err == BZ_STREAM_END)
{
if (err == BZ_STREAM_END) {
bzip->stream_end = 1;
break;
}
if (err != BZ_OK && err != BZ_RUN_OK)
{
if (err != BZ_OK && err != BZ_RUN_OK) {
bzip->error = err;
break;
}
}
while (bzip->bzstream.avail_out > 0);
} while (bzip->bzstream.avail_out > 0);
if (bzip->error != 0)
return MZ_DATA_ERROR;
@ -196,26 +184,22 @@ int32_t mz_stream_bzip_read(void *stream, void *buf, int32_t size)
}
#ifndef MZ_ZIP_NO_COMPRESSION
static int32_t mz_stream_bzip_flush(void *stream)
{
static int32_t mz_stream_bzip_flush(void *stream) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
if (mz_stream_write(bzip->stream.base, bzip->buffer, bzip->buffer_len) != bzip->buffer_len)
return MZ_WRITE_ERROR;
return MZ_OK;
}
static int32_t mz_stream_bzip_compress(void *stream, int flush)
{
static int32_t mz_stream_bzip_compress(void *stream, int flush) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
uint64_t total_out_before = 0;
uint64_t total_out_after = 0;
uint32_t out_bytes = 0;
int32_t err = BZ_OK;
do
{
if (bzip->bzstream.avail_out == 0)
{
do {
if (bzip->bzstream.avail_out == 0) {
err = mz_stream_bzip_flush(bzip);
if (err != MZ_OK)
return err;
@ -241,20 +225,17 @@ static int32_t mz_stream_bzip_compress(void *stream, int flush)
if (err == BZ_STREAM_END)
break;
if (err < 0)
{
if (err < 0) {
bzip->error = err;
return MZ_DATA_ERROR;
}
}
while ((bzip->bzstream.avail_in > 0) || (flush == BZ_FINISH && err == BZ_FINISH_OK));
} while ((bzip->bzstream.avail_in > 0) || (flush == BZ_FINISH && err == BZ_FINISH_OK));
return MZ_OK;
}
#endif
int32_t mz_stream_bzip_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_bzip_write(void *stream, const void *buf, int32_t size) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
int32_t err = size;
@ -273,15 +254,13 @@ int32_t mz_stream_bzip_write(void *stream, const void *buf, int32_t size)
return err;
}
int64_t mz_stream_bzip_tell(void *stream)
{
int64_t mz_stream_bzip_tell(void *stream) {
MZ_UNUSED(stream);
return MZ_TELL_ERROR;
}
int32_t mz_stream_bzip_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_bzip_seek(void *stream, int64_t offset, int32_t origin) {
MZ_UNUSED(stream);
MZ_UNUSED(offset);
MZ_UNUSED(origin);
@ -289,12 +268,10 @@ int32_t mz_stream_bzip_seek(void *stream, int64_t offset, int32_t origin)
return MZ_SEEK_ERROR;
}
int32_t mz_stream_bzip_close(void *stream)
{
int32_t mz_stream_bzip_close(void *stream) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
if (bzip->mode & MZ_OPEN_MODE_WRITE)
{
if (bzip->mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -303,9 +280,7 @@ int32_t mz_stream_bzip_close(void *stream)
BZ2_bzCompressEnd(&bzip->bzstream);
#endif
}
else if (bzip->mode & MZ_OPEN_MODE_READ)
{
} else if (bzip->mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -320,17 +295,14 @@ int32_t mz_stream_bzip_close(void *stream)
return MZ_OK;
}
int32_t mz_stream_bzip_error(void *stream)
{
int32_t mz_stream_bzip_error(void *stream) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
return bzip->error;
}
int32_t mz_stream_bzip_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_bzip_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = bzip->total_in;
break;
@ -349,11 +321,9 @@ int32_t mz_stream_bzip_get_prop_int64(void *stream, int32_t prop, int64_t *value
return MZ_OK;
}
int32_t mz_stream_bzip_set_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) {
mz_stream_bzip *bzip = (mz_stream_bzip *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_COMPRESS_LEVEL:
if (value < 0)
bzip->level = 6;
@ -367,13 +337,11 @@ int32_t mz_stream_bzip_set_prop_int64(void *stream, int32_t prop, int64_t value)
return MZ_EXIST_ERROR;
}
void *mz_stream_bzip_create(void **stream)
{
void *mz_stream_bzip_create(void **stream) {
mz_stream_bzip *bzip = NULL;
bzip = (mz_stream_bzip *)MZ_ALLOC(sizeof(mz_stream_bzip));
if (bzip != NULL)
{
if (bzip != NULL) {
memset(bzip, 0, sizeof(mz_stream_bzip));
bzip->stream.vtbl = &mz_stream_bzip_vtbl;
bzip->level = 6;
@ -384,8 +352,7 @@ void *mz_stream_bzip_create(void **stream)
return bzip;
}
void mz_stream_bzip_delete(void **stream)
{
void mz_stream_bzip_delete(void **stream) {
mz_stream_bzip *bzip = NULL;
if (stream == NULL)
return;
@ -395,12 +362,10 @@ void mz_stream_bzip_delete(void **stream)
*stream = NULL;
}
void *mz_stream_bzip_get_interface(void)
{
void *mz_stream_bzip_get_interface(void) {
return (void *)&mz_stream_bzip_vtbl;
}
extern void bz_internal_error(int errcode)
{
extern void bz_internal_error(int errcode) {
MZ_UNUSED(errcode);
}

110
mz_strm_libcomp.c
View File

@ -52,8 +52,7 @@ typedef struct mz_stream_libcomp_s {
/***************************************************************************/
int32_t mz_stream_libcomp_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_libcomp_open(void *stream, const char *path, int32_t mode) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
int32_t err = 0;
int16_t operation = 0;
@ -66,16 +65,13 @@ int32_t mz_stream_libcomp_open(void *stream, const char *path, int32_t mode)
libcomp->total_in = 0;
libcomp->total_out = 0;
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
operation = COMPRESSION_STREAM_ENCODE;
#endif
}
else if (mode & MZ_OPEN_MODE_READ)
{
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -86,8 +82,7 @@ int32_t mz_stream_libcomp_open(void *stream, const char *path, int32_t mode)
err = compression_stream_init(&libcomp->cstream, (compression_stream_operation)operation,
(compression_algorithm)libcomp->algorithm);
if (err == COMPRESSION_STATUS_ERROR)
{
if (err == COMPRESSION_STATUS_ERROR) {
libcomp->error = err;
return MZ_OPEN_ERROR;
}
@ -97,16 +92,14 @@ int32_t mz_stream_libcomp_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_libcomp_is_open(void *stream)
{
int32_t mz_stream_libcomp_is_open(void *stream) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
if (libcomp->initialized != 1)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_libcomp_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_libcomp_read(void *stream, void *buf, int32_t size) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
MZ_UNUSED(stream);
MZ_UNUSED(buf);
@ -130,12 +123,9 @@ int32_t mz_stream_libcomp_read(void *stream, void *buf, int32_t size)
libcomp->cstream.dst_ptr = buf;
libcomp->cstream.dst_size = (size_t)size;
do
{
if (libcomp->cstream.src_size == 0)
{
if (libcomp->max_total_in > 0)
{
do {
if (libcomp->cstream.src_size == 0) {
if (libcomp->max_total_in > 0) {
if ((int64_t)bytes_to_read > (libcomp->max_total_in - libcomp->total_in))
bytes_to_read = (int32_t)(libcomp->max_total_in - libcomp->total_in);
}
@ -155,8 +145,7 @@ int32_t mz_stream_libcomp_read(void *stream, void *buf, int32_t size)
total_out_before = libcomp->cstream.dst_size;
err = compression_stream_process(&libcomp->cstream, flags);
if (err == COMPRESSION_STATUS_ERROR)
{
if (err == COMPRESSION_STATUS_ERROR) {
libcomp->error = err;
break;
}
@ -175,13 +164,11 @@ int32_t mz_stream_libcomp_read(void *stream, void *buf, int32_t size)
if (err == COMPRESSION_STATUS_END)
break;
if (err != COMPRESSION_STATUS_OK)
{
if (err != COMPRESSION_STATUS_OK) {
libcomp->error = err;
break;
}
}
while (libcomp->cstream.dst_size > 0);
} while (libcomp->cstream.dst_size > 0);
if (libcomp->error != 0)
return MZ_DATA_ERROR;
@ -190,16 +177,14 @@ int32_t mz_stream_libcomp_read(void *stream, void *buf, int32_t size)
#endif
}
static int32_t mz_stream_libcomp_flush(void *stream)
{
static int32_t mz_stream_libcomp_flush(void *stream) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
if (mz_stream_write(libcomp->stream.base, libcomp->buffer, libcomp->buffer_len) != libcomp->buffer_len)
return MZ_WRITE_ERROR;
return MZ_OK;
}
static int32_t mz_stream_libcomp_deflate(void *stream, int flush)
{
static int32_t mz_stream_libcomp_deflate(void *stream, int flush) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
uint64_t total_out_before = 0;
uint64_t total_out_after = 0;
@ -207,13 +192,10 @@ static int32_t mz_stream_libcomp_deflate(void *stream, int flush)
int32_t err = MZ_OK;
do
{
if (libcomp->cstream.dst_size == 0)
{
do {
if (libcomp->cstream.dst_size == 0) {
err = mz_stream_libcomp_flush(libcomp);
if (err != MZ_OK)
{
if (err != MZ_OK) {
libcomp->error = err;
return err;
}
@ -235,19 +217,16 @@ static int32_t mz_stream_libcomp_deflate(void *stream, int flush)
if (err == COMPRESSION_STATUS_END)
break;
if (err != COMPRESSION_STATUS_OK)
{
if (err != COMPRESSION_STATUS_OK) {
libcomp->error = err;
return MZ_DATA_ERROR;
}
}
while ((libcomp->cstream.src_size > 0) || (flush == COMPRESSION_STREAM_FINALIZE && err == COMPRESSION_STATUS_OK));
} while ((libcomp->cstream.src_size > 0) || (flush == COMPRESSION_STREAM_FINALIZE && err == COMPRESSION_STATUS_OK));
return MZ_OK;
}
int32_t mz_stream_libcomp_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_libcomp_write(void *stream, const void *buf, int32_t size) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
int32_t err = size;
@ -265,15 +244,13 @@ int32_t mz_stream_libcomp_write(void *stream, const void *buf, int32_t size)
return err;
}
int64_t mz_stream_libcomp_tell(void *stream)
{
int64_t mz_stream_libcomp_tell(void *stream) {
MZ_UNUSED(stream);
return MZ_TELL_ERROR;
}
int32_t mz_stream_libcomp_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_libcomp_seek(void *stream, int64_t offset, int32_t origin) {
MZ_UNUSED(stream);
MZ_UNUSED(offset);
MZ_UNUSED(origin);
@ -281,22 +258,18 @@ int32_t mz_stream_libcomp_seek(void *stream, int64_t offset, int32_t origin)
return MZ_SEEK_ERROR;
}
int32_t mz_stream_libcomp_close(void *stream)
{
int32_t mz_stream_libcomp_close(void *stream) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
if (libcomp->mode & MZ_OPEN_MODE_WRITE)
{
if (libcomp->mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
mz_stream_libcomp_deflate(stream, COMPRESSION_STREAM_FINALIZE);
mz_stream_libcomp_flush(stream);
#endif
}
else if (libcomp->mode & MZ_OPEN_MODE_READ)
{
} else if (libcomp->mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#endif
@ -311,17 +284,14 @@ int32_t mz_stream_libcomp_close(void *stream)
return MZ_OK;
}
int32_t mz_stream_libcomp_error(void *stream)
{
int32_t mz_stream_libcomp_error(void *stream) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
return libcomp->error;
}
int32_t mz_stream_libcomp_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_libcomp_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = libcomp->total_in;
break;
@ -340,11 +310,9 @@ int32_t mz_stream_libcomp_get_prop_int64(void *stream, int32_t prop, int64_t *va
return MZ_OK;
}
int32_t mz_stream_libcomp_set_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) {
mz_stream_libcomp *libcomp = (mz_stream_libcomp *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_COMPRESS_ALGORITHM:
libcomp->algorithm = (int16_t)value;
break;
@ -357,13 +325,11 @@ int32_t mz_stream_libcomp_set_prop_int64(void *stream, int32_t prop, int64_t val
return MZ_OK;
}
void *mz_stream_libcomp_create(void **stream)
{
void *mz_stream_libcomp_create(void **stream) {
mz_stream_libcomp *libcomp = NULL;
libcomp = (mz_stream_libcomp *)MZ_ALLOC(sizeof(mz_stream_libcomp));
if (libcomp != NULL)
{
if (libcomp != NULL) {
memset(libcomp, 0, sizeof(mz_stream_libcomp));
libcomp->stream.vtbl = &mz_stream_libcomp_vtbl;
}
@ -373,8 +339,7 @@ void *mz_stream_libcomp_create(void **stream)
return libcomp;
}
void mz_stream_libcomp_delete(void **stream)
{
void mz_stream_libcomp_delete(void **stream) {
mz_stream_libcomp *libcomp = NULL;
if (stream == NULL)
return;
@ -401,13 +366,11 @@ static mz_stream_vtbl mz_stream_zlib_vtbl = {
mz_stream_libcomp_set_prop_int64
};
void *mz_stream_zlib_create(void **stream)
{
void *mz_stream_zlib_create(void **stream) {
mz_stream_libcomp *libcomp = NULL;
void *stream_int = NULL;
mz_stream_libcomp_create(&stream_int);
if (stream_int != NULL)
{
if (stream_int != NULL) {
libcomp = (mz_stream_libcomp *)stream_int;
libcomp->stream.vtbl = &mz_stream_zlib_vtbl;
libcomp->algorithm = COMPRESSION_ZLIB;
@ -417,7 +380,6 @@ void *mz_stream_zlib_create(void **stream)
return stream_int;
}
void *mz_stream_zlib_get_interface(void)
{
void *mz_stream_zlib_get_interface(void) {
return (void *)&mz_stream_zlib_vtbl;
}

95
mz_strm_lzma.c
View File

@ -56,8 +56,7 @@ typedef struct mz_stream_lzma_s {
/***************************************************************************/
int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
lzma_filter filters[LZMA_FILTERS_MAX + 1];
lzma_options_lzma opt_lzma;
@ -75,8 +74,7 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
lzma->total_in = 0;
lzma->total_out = 0;
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
MZ_UNUSED(filters);
MZ_UNUSED(major);
@ -105,9 +103,7 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
lzma->error = lzma_alone_encoder(&lzma->lstream, &opt_lzma);
#endif
}
else if (mode & MZ_OPEN_MODE_READ)
{
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
MZ_UNUSED(filters);
MZ_UNUSED(major);
@ -135,16 +131,14 @@ int32_t mz_stream_lzma_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_lzma_is_open(void *stream)
{
int32_t mz_stream_lzma_is_open(void *stream) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
if (lzma->initialized != 1)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
MZ_UNUSED(stream);
MZ_UNUSED(buf);
@ -168,13 +162,10 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
lzma->lstream.next_out = (uint8_t*)buf;
lzma->lstream.avail_out = (size_t)size;
do
{
if (lzma->lstream.avail_in == 0)
{
do {
if (lzma->lstream.avail_in == 0) {
bytes_to_read = sizeof(lzma->buffer);
if (lzma->max_total_in > 0)
{
if (lzma->max_total_in > 0) {
if ((int64_t)bytes_to_read > (lzma->max_total_in - lzma->total_in))
bytes_to_read = (int32_t)(lzma->max_total_in - lzma->total_in);
}
@ -209,13 +200,11 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
if (err == LZMA_STREAM_END)
break;
if (err != LZMA_OK)
{
if (err != LZMA_OK) {
lzma->error = err;
break;
}
}
while (lzma->lstream.avail_out > 0);
} while (lzma->lstream.avail_out > 0);
if (lzma->error != 0)
return MZ_DATA_ERROR;
@ -225,16 +214,14 @@ int32_t mz_stream_lzma_read(void *stream, void *buf, int32_t size)
}
#ifndef MZ_ZIP_NO_COMPRESSION
static int32_t mz_stream_lzma_flush(void *stream)
{
static int32_t mz_stream_lzma_flush(void *stream) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
if (mz_stream_write(lzma->stream.base, lzma->buffer, lzma->buffer_len) != lzma->buffer_len)
return MZ_WRITE_ERROR;
return MZ_OK;
}
static int32_t mz_stream_lzma_code(void *stream, int32_t flush)
{
static int32_t mz_stream_lzma_code(void *stream, int32_t flush) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
uint64_t total_out_before = 0;
uint64_t total_out_after = 0;
@ -242,10 +229,8 @@ static int32_t mz_stream_lzma_code(void *stream, int32_t flush)
int32_t err = LZMA_OK;
do
{
if (lzma->lstream.avail_out == 0)
{
do {
if (lzma->lstream.avail_out == 0) {
err = mz_stream_lzma_flush(lzma);
if (err != MZ_OK)
return err;
@ -262,23 +247,20 @@ static int32_t mz_stream_lzma_code(void *stream, int32_t flush)
out_bytes = (uint32_t)(total_out_after - total_out_before);
if (err != LZMA_OK && err != LZMA_STREAM_END)
{
if (err != LZMA_OK && err != LZMA_STREAM_END) {
lzma->error = err;
return MZ_DATA_ERROR;
}
lzma->buffer_len += out_bytes;
lzma->total_out += out_bytes;
}
while ((lzma->lstream.avail_in > 0) || (flush == LZMA_FINISH && err == LZMA_OK));
} while ((lzma->lstream.avail_in > 0) || (flush == LZMA_FINISH && err == LZMA_OK));
return MZ_OK;
}
#endif
int32_t mz_stream_lzma_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_lzma_write(void *stream, const void *buf, int32_t size) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
int32_t err = size;
@ -297,15 +279,13 @@ int32_t mz_stream_lzma_write(void *stream, const void *buf, int32_t size)
return err;
}
int64_t mz_stream_lzma_tell(void *stream)
{
int64_t mz_stream_lzma_tell(void *stream) {
MZ_UNUSED(stream);
return MZ_TELL_ERROR;
}
int32_t mz_stream_lzma_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_lzma_seek(void *stream, int64_t offset, int32_t origin) {
MZ_UNUSED(stream);
MZ_UNUSED(offset);
MZ_UNUSED(origin);
@ -313,12 +293,10 @@ int32_t mz_stream_lzma_seek(void *stream, int64_t offset, int32_t origin)
return MZ_SEEK_ERROR;
}
int32_t mz_stream_lzma_close(void *stream)
{
int32_t mz_stream_lzma_close(void *stream) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
if (lzma->mode & MZ_OPEN_MODE_WRITE)
{
if (lzma->mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -327,9 +305,7 @@ int32_t mz_stream_lzma_close(void *stream)
lzma_end(&lzma->lstream);
#endif
}
else if (lzma->mode & MZ_OPEN_MODE_READ)
{
} else if (lzma->mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -344,17 +320,14 @@ int32_t mz_stream_lzma_close(void *stream)
return MZ_OK;
}
int32_t mz_stream_lzma_error(void *stream)
{
int32_t mz_stream_lzma_error(void *stream) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
return lzma->error;
}
int32_t mz_stream_lzma_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_lzma_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = lzma->total_in;
break;
@ -376,11 +349,9 @@ int32_t mz_stream_lzma_get_prop_int64(void *stream, int32_t prop, int64_t *value
return MZ_OK;
}
int32_t mz_stream_lzma_set_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) {
mz_stream_lzma *lzma = (mz_stream_lzma *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_COMPRESS_LEVEL:
if (value >= 9)
lzma->preset = LZMA_PRESET_EXTREME;
@ -401,13 +372,11 @@ int32_t mz_stream_lzma_set_prop_int64(void *stream, int32_t prop, int64_t value)
return MZ_OK;
}
void *mz_stream_lzma_create(void **stream)
{
void *mz_stream_lzma_create(void **stream) {
mz_stream_lzma *lzma = NULL;
lzma = (mz_stream_lzma *)MZ_ALLOC(sizeof(mz_stream_lzma));
if (lzma != NULL)
{
if (lzma != NULL) {
memset(lzma, 0, sizeof(mz_stream_lzma));
lzma->stream.vtbl = &mz_stream_lzma_vtbl;
lzma->preset = LZMA_PRESET_DEFAULT;
@ -419,8 +388,7 @@ void *mz_stream_lzma_create(void **stream)
return lzma;
}
void mz_stream_lzma_delete(void **stream)
{
void mz_stream_lzma_delete(void **stream) {
mz_stream_lzma *lzma = NULL;
if (stream == NULL)
return;
@ -430,7 +398,6 @@ void mz_stream_lzma_delete(void **stream)
*stream = NULL;
}
void *mz_stream_lzma_get_interface(void)
{
void *mz_stream_lzma_get_interface(void) {
return (void *)&mz_stream_lzma_vtbl;
}

108
mz_strm_mem.c
View File

@ -53,8 +53,7 @@ typedef struct mz_stream_mem_s {
/***************************************************************************/
static int32_t mz_stream_mem_set_size(void *stream, int32_t size)
{
static int32_t mz_stream_mem_set_size(void *stream, int32_t size) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
int32_t new_size = size;
uint8_t *new_buf = NULL;
@ -64,8 +63,7 @@ static int32_t mz_stream_mem_set_size(void *stream, int32_t size)
if (new_buf == NULL)
return MZ_BUF_ERROR;
if (mem->buffer)
{
if (mem->buffer) {
memcpy(new_buf, mem->buffer, mem->size);
MZ_FREE(mem->buffer);
}
@ -75,8 +73,7 @@ static int32_t mz_stream_mem_set_size(void *stream, int32_t size)
return MZ_OK;
}
int32_t mz_stream_mem_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_mem_open(void *stream, const char *path, int32_t mode) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
int32_t err = MZ_OK;
@ -94,16 +91,14 @@ int32_t mz_stream_mem_open(void *stream, const char *path, int32_t mode)
return err;
}
int32_t mz_stream_mem_is_open(void *stream)
{
int32_t mz_stream_mem_is_open(void *stream) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
if (mem->buffer == NULL)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_mem_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_mem_read(void *stream, void *buf, int32_t size) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
if (size > mem->size - mem->position)
@ -120,8 +115,7 @@ int32_t mz_stream_mem_read(void *stream, void *buf, int32_t size)
return size;
}
int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
int32_t new_size = 0;
int32_t err = MZ_OK;
@ -129,10 +123,8 @@ int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size)
if (size == 0)
return size;
if (size > mem->size - mem->position)
{
if (mem->mode & MZ_OPEN_MODE_CREATE)
{
if (size > mem->size - mem->position) {
if (mem->mode & MZ_OPEN_MODE_CREATE) {
new_size = mem->size;
if (size < mem->grow_size)
new_size += mem->grow_size;
@ -142,9 +134,7 @@ int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size)
err = mz_stream_mem_set_size(stream, new_size);
if (err != MZ_OK)
return err;
}
else
{
} else {
size = mem->size - mem->position;
}
}
@ -158,44 +148,38 @@ int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size)
return size;
}
int64_t mz_stream_mem_tell(void *stream)
{
int64_t mz_stream_mem_tell(void *stream) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
return mem->position;
}
int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
int64_t new_pos = 0;
int32_t err = MZ_OK;
switch (origin)
{
case MZ_SEEK_CUR:
new_pos = mem->position + offset;
break;
case MZ_SEEK_END:
new_pos = mem->limit + offset;
break;
case MZ_SEEK_SET:
new_pos = offset;
break;
default:
return MZ_SEEK_ERROR;
switch (origin) {
case MZ_SEEK_CUR:
new_pos = mem->position + offset;
break;
case MZ_SEEK_END:
new_pos = mem->limit + offset;
break;
case MZ_SEEK_SET:
new_pos = offset;
break;
default:
return MZ_SEEK_ERROR;
}
if (new_pos > mem->size)
{
if (new_pos > mem->size) {
if ((mem->mode & MZ_OPEN_MODE_CREATE) == 0)
return MZ_SEEK_ERROR;
err = mz_stream_mem_set_size(stream, (int32_t)new_pos);
if (err != MZ_OK)
return err;
}
else if (new_pos < 0)
{
} else if (new_pos < 0) {
return MZ_SEEK_ERROR;
}
@ -203,37 +187,32 @@ int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin)
return MZ_OK;
}
int32_t mz_stream_mem_close(void *stream)
{
int32_t mz_stream_mem_close(void *stream) {
MZ_UNUSED(stream);
/* We never return errors */
return MZ_OK;
}
int32_t mz_stream_mem_error(void *stream)
{
int32_t mz_stream_mem_error(void *stream) {
MZ_UNUSED(stream);
/* We never return errors */
return MZ_OK;
}
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) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
mem->buffer = (uint8_t *)buf;
mem->size = size;
mem->limit = size;
}
int32_t mz_stream_mem_get_buffer(void *stream, const void **buf)
{
int32_t mz_stream_mem_get_buffer(void *stream, const void **buf) {
return mz_stream_mem_get_buffer_at(stream, 0, 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(void *stream, int64_t position, const void **buf) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
if (buf == NULL || position < 0 || mem->size < position || mem->buffer == NULL)
return MZ_SEEK_ERROR;
@ -241,37 +220,31 @@ int32_t mz_stream_mem_get_buffer_at(void *stream, int64_t position, const void *
return MZ_OK;
}
int32_t mz_stream_mem_get_buffer_at_current(void *stream, const void **buf)
{
int32_t mz_stream_mem_get_buffer_at_current(void *stream, const void **buf) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
return mz_stream_mem_get_buffer_at(stream, mem->position, buf);
}
void mz_stream_mem_get_buffer_length(void *stream, int32_t *length)
{
void mz_stream_mem_get_buffer_length(void *stream, int32_t *length) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
*length = mem->limit;
}
void mz_stream_mem_set_buffer_limit(void *stream, int32_t limit)
{
void mz_stream_mem_set_buffer_limit(void *stream, int32_t limit) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
mem->limit = limit;
}
void mz_stream_mem_set_grow_size(void *stream, int32_t grow_size)
{
void mz_stream_mem_set_grow_size(void *stream, int32_t grow_size) {
mz_stream_mem *mem = (mz_stream_mem *)stream;
mem->grow_size = grow_size;
}
void *mz_stream_mem_create(void **stream)
{
void *mz_stream_mem_create(void **stream) {
mz_stream_mem *mem = NULL;
mem = (mz_stream_mem *)MZ_ALLOC(sizeof(mz_stream_mem));
if (mem != NULL)
{
if (mem != NULL) {
memset(mem, 0, sizeof(mz_stream_mem));
mem->stream.vtbl = &mz_stream_mem_vtbl;
mem->grow_size = 4096;
@ -282,14 +255,12 @@ void *mz_stream_mem_create(void **stream)
return mem;
}
void mz_stream_mem_delete(void **stream)
{
void mz_stream_mem_delete(void **stream) {
mz_stream_mem *mem = NULL;
if (stream == NULL)
return;
mem = (mz_stream_mem *)*stream;
if (mem != NULL)
{
if (mem != NULL) {
if ((mem->mode & MZ_OPEN_MODE_CREATE) && (mem->buffer != NULL))
MZ_FREE(mem->buffer);
MZ_FREE(mem);
@ -297,7 +268,6 @@ void mz_stream_mem_delete(void **stream)
*stream = NULL;
}
void *mz_stream_mem_get_interface(void)
{
void *mz_stream_mem_get_interface(void) {
return (void *)&mz_stream_mem_vtbl;
}

85
mz_strm_os_posix.c
View File

@ -66,8 +66,7 @@ static mz_stream_vtbl mz_stream_os_vtbl = {
/***************************************************************************/
typedef struct mz_stream_posix_s
{
typedef struct mz_stream_posix_s {
mz_stream stream;
int32_t error;
FILE *handle;
@ -75,8 +74,7 @@ typedef struct mz_stream_posix_s
/***************************************************************************/
int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode) {
mz_stream_posix *posix = (mz_stream_posix *)stream;
const char *mode_fopen = NULL;
@ -93,8 +91,7 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
return MZ_OPEN_ERROR;
posix->handle = fopen64(path, mode_fopen);
if (posix->handle == NULL)
{
if (posix->handle == NULL) {
posix->error = errno;
return MZ_OPEN_ERROR;
}
@ -105,72 +102,62 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_os_is_open(void *stream)
{
int32_t mz_stream_os_is_open(void *stream) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
if (posix->handle == NULL)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_os_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_os_read(void *stream, void *buf, int32_t size) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
int32_t read = (int32_t)fread(buf, 1, (size_t)size, posix->handle);
if (read < size && ferror(posix->handle))
{
if (read < size && ferror(posix->handle)) {
posix->error = errno;
return MZ_READ_ERROR;
}
return read;
}
int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
int32_t written = (int32_t)fwrite(buf, 1, (size_t)size, posix->handle);
if (written < size && ferror(posix->handle))
{
if (written < size && ferror(posix->handle)) {
posix->error = errno;
return MZ_WRITE_ERROR;
}
return written;
}
int64_t mz_stream_os_tell(void *stream)
{
int64_t mz_stream_os_tell(void *stream) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
int64_t position = ftello64(posix->handle);
if (position == -1)
{
if (position == -1) {
posix->error = errno;
return MZ_TELL_ERROR;
}
return position;
}
int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
int32_t fseek_origin = 0;
switch (origin)
{
case MZ_SEEK_CUR:
fseek_origin = SEEK_CUR;
break;
case MZ_SEEK_END:
fseek_origin = SEEK_END;
break;
case MZ_SEEK_SET:
fseek_origin = SEEK_SET;
break;
default:
return MZ_SEEK_ERROR;
switch (origin) {
case MZ_SEEK_CUR:
fseek_origin = SEEK_CUR;
break;
case MZ_SEEK_END:
fseek_origin = SEEK_END;
break;
case MZ_SEEK_SET:
fseek_origin = SEEK_SET;
break;
default:
return MZ_SEEK_ERROR;
}
if (fseeko64(posix->handle, offset, fseek_origin) != 0)
{
if (fseeko64(posix->handle, offset, fseek_origin) != 0) {
posix->error = errno;
return MZ_SEEK_ERROR;
}
@ -178,36 +165,30 @@ int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
return MZ_OK;
}
int32_t mz_stream_os_close(void *stream)
{
int32_t mz_stream_os_close(void *stream) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
int32_t closed = 0;
if (posix->handle != NULL)
{
if (posix->handle != NULL) {
closed = fclose(posix->handle);
posix->handle = NULL;
}
if (closed != 0)
{
if (closed != 0) {
posix->error = errno;
return MZ_CLOSE_ERROR;
}
return MZ_OK;
}
int32_t mz_stream_os_error(void *stream)
{
int32_t mz_stream_os_error(void *stream) {
mz_stream_posix *posix = (mz_stream_posix*)stream;
return posix->error;
}
void *mz_stream_os_create(void **stream)
{
void *mz_stream_os_create(void **stream) {
mz_stream_posix *posix = NULL;
posix = (mz_stream_posix *)MZ_ALLOC(sizeof(mz_stream_posix));
if (posix != NULL)
{
if (posix != NULL) {
memset(posix, 0, sizeof(mz_stream_posix));
posix->stream.vtbl = &mz_stream_os_vtbl;
}
@ -217,8 +198,7 @@ void *mz_stream_os_create(void **stream)
return posix;
}
void mz_stream_os_delete(void **stream)
{
void mz_stream_os_delete(void **stream) {
mz_stream_posix *posix = NULL;
if (stream == NULL)
return;
@ -228,7 +208,6 @@ void mz_stream_os_delete(void **stream)
*stream = NULL;
}
void *mz_stream_os_get_interface(void)
{
void *mz_stream_os_get_interface(void) {
return (void *)&mz_stream_os_vtbl;
}

97
mz_strm_os_win32.c
View File

@ -57,8 +57,7 @@ static mz_stream_vtbl mz_stream_os_vtbl = {
/***************************************************************************/
typedef struct mz_stream_win32_s
{
typedef struct mz_stream_win32_s {
mz_stream stream;
HANDLE handle;
int32_t error;
@ -74,8 +73,7 @@ typedef struct mz_stream_win32_s
/***************************************************************************/
int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
uint32_t desired_access = 0;
uint32_t creation_disposition = 0;
@ -90,23 +88,16 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
/* Some use cases require write sharing as well */
share_mode |= FILE_SHARE_WRITE;
if ((mode & MZ_OPEN_MODE_READWRITE) == MZ_OPEN_MODE_READ)
{
if ((mode & MZ_OPEN_MODE_READWRITE) == MZ_OPEN_MODE_READ) {
desired_access = GENERIC_READ;
creation_disposition = OPEN_EXISTING;
}
else if (mode & MZ_OPEN_MODE_APPEND)
{
} else if (mode & MZ_OPEN_MODE_APPEND) {
desired_access = GENERIC_WRITE | GENERIC_READ;
creation_disposition = OPEN_EXISTING;
}
else if (mode & MZ_OPEN_MODE_CREATE)
{
} else if (mode & MZ_OPEN_MODE_CREATE) {
desired_access = GENERIC_WRITE | GENERIC_READ;
creation_disposition = CREATE_ALWAYS;
}
else
{
} else {
return MZ_PARAM_ERROR;
}
@ -126,8 +117,7 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
mz_os_unicode_string_delete(&path_wide);
if (mz_stream_os_is_open(stream) != MZ_OK)
{
if (mz_stream_os_is_open(stream) != MZ_OK) {
win32->error = GetLastError();
return MZ_OPEN_ERROR;
}
@ -138,24 +128,21 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_os_is_open(void *stream)
{
int32_t mz_stream_os_is_open(void *stream) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
if (win32->handle == NULL || win32->handle == INVALID_HANDLE_VALUE)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_os_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_os_read(void *stream, void *buf, int32_t size) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
uint32_t read = 0;
if (mz_stream_os_is_open(stream) != MZ_OK)
return MZ_OPEN_ERROR;
if (!ReadFile(win32->handle, buf, size, (DWORD *)&read, NULL))
{
if (!ReadFile(win32->handle, buf, size, (DWORD *)&read, NULL)) {
win32->error = GetLastError();
if (win32->error == ERROR_HANDLE_EOF)
win32->error = 0;
@ -166,16 +153,14 @@ int32_t mz_stream_os_read(void *stream, void *buf, int32_t size)
return read;
}
int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
int32_t written = 0;
if (mz_stream_os_is_open(stream) != MZ_OK)
return MZ_OPEN_ERROR;
if (!WriteFile(win32->handle, buf, size, (DWORD *)&written, NULL))
{
if (!WriteFile(win32->handle, buf, size, (DWORD *)&written, NULL)) {
win32->error = GetLastError();
if (win32->error == ERROR_HANDLE_EOF)
win32->error = 0;
@ -187,8 +172,7 @@ int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size)
}
static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos,
LARGE_INTEGER *new_pos, uint32_t move_method)
{
LARGE_INTEGER *new_pos, uint32_t move_method) {
#ifdef MZ_WINRT_API
return SetFilePointerEx(handle, pos, newPos, dwMoveMethod);
#else
@ -201,8 +185,7 @@ static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos,
if ((pos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
return MZ_SEEK_ERROR;
if (new_pos != NULL)
{
if (new_pos != NULL) {
new_pos->LowPart = pos;
new_pos->HighPart = high_part;
}
@ -211,8 +194,7 @@ static int32_t mz_stream_os_seekinternal(HANDLE handle, LARGE_INTEGER large_pos,
#endif
}
int64_t mz_stream_os_tell(void *stream)
{
int64_t mz_stream_os_tell(void *stream) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
LARGE_INTEGER large_pos;
@ -229,8 +211,7 @@ int64_t mz_stream_os_tell(void *stream)
return large_pos.QuadPart;
}
int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
uint32_t move_method = 0xFFFFFFFF;
int32_t err = MZ_OK;
@ -240,19 +221,18 @@ int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
if (mz_stream_os_is_open(stream) != MZ_OK)
return MZ_OPEN_ERROR;
switch (origin)
{
case MZ_SEEK_CUR:
move_method = FILE_CURRENT;
break;
case MZ_SEEK_END:
move_method = FILE_END;
break;
case MZ_SEEK_SET:
move_method = FILE_BEGIN;
break;
default:
return MZ_SEEK_ERROR;
switch (origin) {
case MZ_SEEK_CUR:
move_method = FILE_CURRENT;
break;
case MZ_SEEK_END:
move_method = FILE_END;
break;
case MZ_SEEK_SET:
move_method = FILE_BEGIN;
break;
default:
return MZ_SEEK_ERROR;
}
mz_stream_os_print("Win32 - Seek - %" PRId64 " (origin %" PRId32 ")\n", offset, origin);
@ -260,8 +240,7 @@ int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
large_pos.QuadPart = offset;
err = mz_stream_os_seekinternal(win32->handle, large_pos, NULL, move_method);
if (err != MZ_OK)
{
if (err != MZ_OK) {
win32->error = GetLastError();
return err;
}
@ -269,8 +248,7 @@ int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
return MZ_OK;
}
int32_t mz_stream_os_close(void *stream)
{
int32_t mz_stream_os_close(void *stream) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
if (win32->handle != NULL)
@ -280,19 +258,16 @@ int32_t mz_stream_os_close(void *stream)
return MZ_OK;
}
int32_t mz_stream_os_error(void *stream)
{
int32_t mz_stream_os_error(void *stream) {
mz_stream_win32 *win32 = (mz_stream_win32 *)stream;
return win32->error;
}
void *mz_stream_os_create(void **stream)
{
void *mz_stream_os_create(void **stream) {
mz_stream_win32 *win32 = NULL;
win32 = (mz_stream_win32 *)MZ_ALLOC(sizeof(mz_stream_win32));
if (win32 != NULL)
{
if (win32 != NULL) {
memset(win32, 0, sizeof(mz_stream_win32));
win32->stream.vtbl = &mz_stream_os_vtbl;
}
@ -302,8 +277,7 @@ void *mz_stream_os_create(void **stream)
return win32;
}
void mz_stream_os_delete(void **stream)
{
void mz_stream_os_delete(void **stream) {
mz_stream_win32 *win32 = NULL;
if (stream == NULL)
return;
@ -313,7 +287,6 @@ void mz_stream_os_delete(void **stream)
*stream = NULL;
}
void *mz_stream_os_get_interface(void)
{
void *mz_stream_os_get_interface(void) {
return (void *)&mz_stream_os_vtbl;
}

85
mz_strm_pkcrypt.c
View File

@ -73,8 +73,7 @@ typedef struct mz_stream_pkcrypt_s {
/***************************************************************************/
static uint8_t mz_stream_pkcrypt_decrypt_byte(void *stream)
{
static uint8_t mz_stream_pkcrypt_decrypt_byte(void *stream) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an */
@ -85,8 +84,7 @@ static uint8_t mz_stream_pkcrypt_decrypt_byte(void *stream)
return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
}
static uint8_t mz_stream_pkcrypt_update_keys(void *stream, uint8_t c)
{
static uint8_t mz_stream_pkcrypt_update_keys(void *stream, uint8_t c) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
uint8_t buf = c;
@ -102,16 +100,14 @@ static uint8_t mz_stream_pkcrypt_update_keys(void *stream, uint8_t c)
return (uint8_t)c;
}
static void mz_stream_pkcrypt_init_keys(void *stream, const char *password)
{
static void mz_stream_pkcrypt_init_keys(void *stream, const char *password) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
pkcrypt->keys[0] = 305419896L;
pkcrypt->keys[1] = 591751049L;
pkcrypt->keys[2] = 878082192L;
while (*password != 0)
{
while (*password != 0) {
mz_stream_pkcrypt_update_keys(stream, (uint8_t)*password);
password += 1;
}
@ -119,8 +115,7 @@ static void mz_stream_pkcrypt_init_keys(void *stream, const char *password)
/***************************************************************************/
int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
uint16_t t = 0;
int16_t i = 0;
@ -143,8 +138,7 @@ int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode)
mz_stream_pkcrypt_init_keys(stream, password);
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
MZ_UNUSED(t);
MZ_UNUSED(i);
@ -166,9 +160,7 @@ int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode)
pkcrypt->total_out += MZ_PKCRYPT_HEADER_SIZE;
#endif
}
else if (mode & MZ_OPEN_MODE_READ)
{
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
MZ_UNUSED(t);
MZ_UNUSED(i);
@ -199,16 +191,14 @@ int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_pkcrypt_is_open(void *stream)
{
int32_t mz_stream_pkcrypt_is_open(void *stream) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
if (pkcrypt->initialized == 0)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
uint8_t *buf_ptr = (uint8_t *)buf;
int32_t bytes_to_read = size;
@ -230,8 +220,7 @@ int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size)
return read;
}
int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
const uint8_t *buf_ptr = (const uint8_t *)buf;
int32_t bytes_to_write = sizeof(pkcrypt->buffer);
@ -243,13 +232,11 @@ int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size)
if (size < 0)
return MZ_PARAM_ERROR;
do
{
do {
if (bytes_to_write > (size - total_written))
bytes_to_write = (size - total_written);
for (i = 0; i < bytes_to_write; i += 1)
{
for (i = 0; i < bytes_to_write; i += 1) {
pkcrypt->buffer[i] = mz_stream_pkcrypt_encode(stream, *buf_ptr, t);
buf_ptr += 1;
}
@ -259,63 +246,53 @@ int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size)
return written;
total_written += written;
}
while (total_written < size && written > 0);
} while (total_written < size && written > 0);
pkcrypt->total_out += total_written;
return total_written;
}
int64_t mz_stream_pkcrypt_tell(void *stream)
{
int64_t mz_stream_pkcrypt_tell(void *stream) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
return mz_stream_tell(pkcrypt->stream.base);
}
int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
return mz_stream_seek(pkcrypt->stream.base, offset, origin);
}
int32_t mz_stream_pkcrypt_close(void *stream)
{
int32_t mz_stream_pkcrypt_close(void *stream) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
pkcrypt->initialized = 0;
return MZ_OK;
}
int32_t mz_stream_pkcrypt_error(void *stream)
{
int32_t mz_stream_pkcrypt_error(void *stream) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
return pkcrypt->error;
}
void mz_stream_pkcrypt_set_password(void *stream, const char *password)
{
void mz_stream_pkcrypt_set_password(void *stream, const char *password) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
pkcrypt->password = password;
}
void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2)
{
void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
pkcrypt->verify1 = verify1;
pkcrypt->verify2 = verify2;
}
void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2)
{
void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
*verify1 = pkcrypt->verify1;
*verify2 = pkcrypt->verify2;
}
int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = pkcrypt->total_in;
break;
@ -337,11 +314,9 @@ int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *va
return MZ_OK;
}
int32_t mz_stream_pkcrypt_set_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) {
mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN_MAX:
pkcrypt->max_total_in = value;
break;
@ -351,13 +326,11 @@ int32_t mz_stream_pkcrypt_set_prop_int64(void *stream, int32_t prop, int64_t val
return MZ_OK;
}
void *mz_stream_pkcrypt_create(void **stream)
{
void *mz_stream_pkcrypt_create(void **stream) {
mz_stream_pkcrypt *pkcrypt = NULL;
pkcrypt = (mz_stream_pkcrypt *)MZ_ALLOC(sizeof(mz_stream_pkcrypt));
if (pkcrypt != NULL)
{
if (pkcrypt != NULL) {
memset(pkcrypt, 0, sizeof(mz_stream_pkcrypt));
pkcrypt->stream.vtbl = &mz_stream_pkcrypt_vtbl;
}
@ -367,8 +340,7 @@ void *mz_stream_pkcrypt_create(void **stream)
return pkcrypt;
}
void mz_stream_pkcrypt_delete(void **stream)
{
void mz_stream_pkcrypt_delete(void **stream) {
mz_stream_pkcrypt *pkcrypt = NULL;
if (stream == NULL)
return;
@ -378,7 +350,6 @@ void mz_stream_pkcrypt_delete(void **stream)
*stream = NULL;
}
void *mz_stream_pkcrypt_get_interface(void)
{
void *mz_stream_pkcrypt_get_interface(void) {
return (void *)&mz_stream_pkcrypt_vtbl;
}

142
mz_strm_split.c
View File

@ -73,8 +73,7 @@ typedef struct mz_stream_split_s {
/***************************************************************************/
static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
{
static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk) {
mz_stream_split *split = (mz_stream_split *)stream;
uint32_t magic = 0;
int64_t position = 0;
@ -84,8 +83,7 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
/* Check if we are reading or writing a disk part or the cd disk */
if (number_disk >= 0)
{
if (number_disk >= 0) {
if ((split->mode & MZ_OPEN_MODE_WRITE) == 0)
disk_part = MZ_OPEN_MODE_READ;
else if (split->disk_size > 0)
@ -93,19 +91,15 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
}
/* Construct disk path */
if (disk_part > 0)
{
for (i = (int32_t)strlen(split->path_disk) - 1; i >= 0; i -= 1)
{
if (disk_part > 0) {
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);
break;
}
}
else
{
} else {
strncpy(split->path_disk, split->path_cd, split->path_disk_size - 1);
split->path_disk[split->path_disk_size - 1] = 0;
}
@ -119,26 +113,20 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
if (err == MZ_OK)
err = mz_stream_open(split->stream.base, split->path_disk, split->mode);
if (err == MZ_OK)
{
if (err == MZ_OK) {
split->total_in_disk = 0;
split->total_out_disk = 0;
split->current_disk = number_disk;
if (split->mode & MZ_OPEN_MODE_WRITE)
{
if ((split->current_disk == 0) && (split->disk_size > 0))
{
if (split->mode & MZ_OPEN_MODE_WRITE) {
if ((split->current_disk == 0) && (split->disk_size > 0)) {
err = mz_stream_write_uint32(split->stream.base, MZ_ZIP_MAGIC_DISKHEADER);
split->total_out_disk += 4;
split->total_out += split->total_out_disk;
}
}
else if (split->mode & MZ_OPEN_MODE_READ)
{
if (split->current_disk == 0)
{
} else if (split->mode & MZ_OPEN_MODE_READ) {
if (split->current_disk == 0) {
err = mz_stream_read_uint32(split->stream.base, &magic);
if (magic != MZ_ZIP_MAGIC_DISKHEADER)
err = MZ_FORMAT_ERROR;
@ -146,8 +134,7 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
}
}
if (err == MZ_OK)
{
if (err == MZ_OK) {
/* Get the size of the current disk we are on */
position = mz_stream_tell(split->stream.base);
mz_stream_seek(split->stream.base, 0, MZ_SEEK_END);
@ -160,8 +147,7 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
return err;
}
static int32_t mz_stream_split_close_disk(void *stream)
{
static int32_t mz_stream_split_close_disk(void *stream) {
mz_stream_split *split = (mz_stream_split *)stream;
if (mz_stream_is_open(split->stream.base) != MZ_OK)
@ -171,24 +157,19 @@ static int32_t mz_stream_split_close_disk(void *stream)
return mz_stream_close(split->stream.base);
}
static int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk)
{
static int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk) {
mz_stream_split *split = (mz_stream_split *)stream;
int32_t err = MZ_OK;
int32_t err_is_open = MZ_OK;
err_is_open = mz_stream_is_open(split->stream.base);
if ((split->disk_size == 0) && (split->mode & MZ_OPEN_MODE_WRITE))
{
if ((split->disk_size == 0) && (split->mode & MZ_OPEN_MODE_WRITE)) {
if (err_is_open != MZ_OK)
err = mz_stream_split_open_disk(stream, number_disk);
}
else if ((number_disk != split->current_disk) || (err_is_open != MZ_OK))
{
} else if ((number_disk != split->current_disk) || (err_is_open != MZ_OK)) {
err = mz_stream_split_close_disk(stream);
if (err == MZ_OK)
{
if (err == MZ_OK) {
err = mz_stream_split_open_disk(stream, number_disk);
if (err == MZ_OK)
split->number_disk = number_disk;
@ -198,8 +179,7 @@ static int32_t mz_stream_split_goto_disk(void *stream, int32_t number_disk)
return err;
}
int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode) {
mz_stream_split *split = (mz_stream_split *)stream;
int32_t number_disk = 0;
@ -219,8 +199,7 @@ int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode)
split->path_disk_size = (uint32_t)strlen(path) + 10;
split->path_disk = (char *)MZ_ALLOC(split->path_disk_size);
if (split->path_disk == NULL)
{
if (split->path_disk == NULL) {
MZ_FREE(split->path_cd);
return MZ_MEM_ERROR;
}
@ -228,13 +207,10 @@ int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode)
strncpy(split->path_disk, path, split->path_disk_size - 1);
split->path_disk[split->path_disk_size - 1] = 0;
if ((mode & MZ_OPEN_MODE_WRITE) && ((mode & MZ_OPEN_MODE_APPEND) == 0))
{
if ((mode & MZ_OPEN_MODE_WRITE) && ((mode & MZ_OPEN_MODE_APPEND) == 0)) {
number_disk = 0;
split->current_disk = -1;
}
else
{
} else {
number_disk = -1;
split->current_disk = 0;
}
@ -242,16 +218,14 @@ int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode)
return mz_stream_split_goto_disk(stream, number_disk);
}
int32_t mz_stream_split_is_open(void *stream)
{
int32_t mz_stream_split_is_open(void *stream) {
mz_stream_split *split = (mz_stream_split *)stream;
if (split->is_open != 1)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_split_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_split_read(void *stream, void *buf, int32_t size) {
mz_stream_split *split = (mz_stream_split *)stream;
int32_t bytes_left = size;
int32_t read = 0;
@ -262,21 +236,18 @@ int32_t mz_stream_split_read(void *stream, void *buf, int32_t size)
if (err != MZ_OK)
return err;
while (bytes_left > 0)
{
while (bytes_left > 0) {
read = mz_stream_read(split->stream.base, buf_ptr, bytes_left);
mz_stream_split_print("Split - Read disk - %" PRId32 "\n", read);
if (read < 0)
return read;
if (read == 0)
{
if (read == 0) {
if (split->current_disk < 0) /* No more disks to goto */
break;
err = mz_stream_split_goto_disk(stream, split->current_disk + 1);
if (err == MZ_EXIST_ERROR)
{
if (err == MZ_EXIST_ERROR) {
split->current_disk = -1;
break;
}
@ -292,8 +263,7 @@ int32_t mz_stream_split_read(void *stream, void *buf, int32_t size)
return size - bytes_left;
}
int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size) {
mz_stream_split *split = (mz_stream_split *)stream;
int64_t position = 0;
int32_t written = 0;
@ -306,15 +276,12 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
position = mz_stream_tell(split->stream.base);
while (bytes_left > 0)
{
while (bytes_left > 0) {
bytes_to_write = bytes_left;
if (split->disk_size > 0)
{
if (split->disk_size > 0) {
if ((split->total_out_disk == split->disk_size && split->total_out > 0) ||
(split->number_disk == -1 && split->number_disk != split->current_disk))
{
(split->number_disk == -1 && split->number_disk != split->current_disk)) {
if (split->number_disk != -1)
number_disk = split->current_disk + 1;
@ -323,8 +290,7 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
return err;
}
if (split->number_disk != -1)
{
if (split->number_disk != -1) {
bytes_avail = (int32_t)(split->disk_size - split->total_out_disk);
if (bytes_to_write > bytes_avail)
bytes_to_write = bytes_avail;
@ -343,8 +309,7 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
split->total_out += written;
split->total_out_disk += written;
if (position == split->current_disk_size)
{
if (position == split->current_disk_size) {
split->current_disk_size += written;
position = split->current_disk_size;
}
@ -353,8 +318,7 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
return size - bytes_left;
}
int64_t mz_stream_split_tell(void *stream)
{
int64_t mz_stream_split_tell(void *stream) {
mz_stream_split *split = (mz_stream_split *)stream;
int32_t err = MZ_OK;
err = mz_stream_split_goto_disk(stream, split->number_disk);
@ -363,8 +327,7 @@ int64_t mz_stream_split_tell(void *stream)
return mz_stream_tell(split->stream.base);
}
int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_split *split = (mz_stream_split *)stream;
int64_t disk_left = 0;
int64_t position = 0;
@ -377,13 +340,11 @@ int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin)
mz_stream_split_print("Split - Seek disk - %" PRId64 " (origin %" PRId32 ")\n", offset, origin);
if ((origin == MZ_SEEK_CUR) && (split->number_disk != -1))
{
if ((origin == MZ_SEEK_CUR) && (split->number_disk != -1)) {
position = mz_stream_tell(split->stream.base);
disk_left = split->current_disk_size - position;
while (offset > disk_left)
{
while (offset > disk_left) {
err = mz_stream_split_goto_disk(stream, split->current_disk + 1);
if (err != MZ_OK)
return err;
@ -396,8 +357,7 @@ int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin)
return mz_stream_seek(split->stream.base, offset, origin);
}
int32_t mz_stream_split_close(void *stream)
{
int32_t mz_stream_split_close(void *stream) {
mz_stream_split *split = (mz_stream_split *)stream;
int32_t err = MZ_OK;
@ -406,17 +366,14 @@ int32_t mz_stream_split_close(void *stream)
return err;
}
int32_t mz_stream_split_error(void *stream)
{
int32_t mz_stream_split_error(void *stream) {
mz_stream_split *split = (mz_stream_split *)stream;
return mz_stream_error(split->stream.base);
}
int32_t mz_stream_split_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_split_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_split *split = (mz_stream_split *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_OUT:
*value = split->total_out;
break;
@ -432,11 +389,9 @@ int32_t mz_stream_split_get_prop_int64(void *stream, int32_t prop, int64_t *valu
return MZ_OK;
}
int32_t mz_stream_split_set_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) {
mz_stream_split *split = (mz_stream_split *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_DISK_NUMBER:
split->number_disk = (int32_t)value;
break;
@ -449,13 +404,11 @@ int32_t mz_stream_split_set_prop_int64(void *stream, int32_t prop, int64_t value
return MZ_OK;
}
void *mz_stream_split_create(void **stream)
{
void *mz_stream_split_create(void **stream) {
mz_stream_split *split = NULL;
split = (mz_stream_split *)MZ_ALLOC(sizeof(mz_stream_split));
if (split != NULL)
{
if (split != NULL) {
memset(split, 0, sizeof(mz_stream_split));
split->stream.vtbl = &mz_stream_split_vtbl;
}
@ -465,14 +418,12 @@ void *mz_stream_split_create(void **stream)
return split;
}
void mz_stream_split_delete(void **stream)
{
void mz_stream_split_delete(void **stream) {
mz_stream_split *split = NULL;
if (stream == NULL)
return;
split = (mz_stream_split *)*stream;
if (split != NULL)
{
if (split != NULL) {
if (split->path_cd)
MZ_FREE(split->path_cd);
if (split->path_disk)
@ -483,7 +434,6 @@ void mz_stream_split_delete(void **stream)
*stream = NULL;
}
void *mz_stream_split_get_interface(void)
{
void *mz_stream_split_get_interface(void) {
return (void *)&mz_stream_split_vtbl;
}

96
mz_strm_wzaes.c
View File

@ -64,8 +64,7 @@ typedef struct mz_stream_wzaes_s {
/***************************************************************************/
int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
uint16_t salt_length = 0;
uint16_t password_length = 0;
@ -96,16 +95,13 @@ int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode)
salt_length = MZ_AES_SALT_LENGTH(wzaes->encryption_mode);
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
mz_crypt_rand(salt_value, salt_length);
#endif
}
else if (mode & MZ_OPEN_MODE_READ)
{
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -136,8 +132,7 @@ int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode)
memcpy(verify, kbuf + (2 * key_length), MZ_AES_PW_VERIFY_SIZE);
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
if (mz_stream_write(wzaes->stream.base, salt_value, salt_length) != salt_length)
return MZ_WRITE_ERROR;
@ -147,9 +142,7 @@ int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode)
return MZ_WRITE_ERROR;
wzaes->total_out += MZ_AES_PW_VERIFY_SIZE;
}
else if (mode & MZ_OPEN_MODE_READ)
{
} else if (mode & MZ_OPEN_MODE_READ) {
wzaes->total_in += salt_length;
if (mz_stream_read(wzaes->stream.base, verify_expected, MZ_AES_PW_VERIFY_SIZE) != MZ_AES_PW_VERIFY_SIZE)
@ -167,25 +160,21 @@ int32_t mz_stream_wzaes_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_wzaes_is_open(void *stream)
{
int32_t mz_stream_wzaes_is_open(void *stream) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
if (wzaes->initialized == 0)
return MZ_OPEN_ERROR;
return MZ_OK;
}
static int32_t mz_stream_wzaes_ctr_encrypt(void *stream, uint8_t *buf, int32_t size)
{
static int32_t mz_stream_wzaes_ctr_encrypt(void *stream, uint8_t *buf, int32_t size) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
uint32_t pos = wzaes->crypt_pos;
uint32_t i = 0;
int32_t err = MZ_OK;
while (i < (uint32_t)size)
{
if (pos == MZ_AES_BLOCK_SIZE)
{
while (i < (uint32_t)size) {
if (pos == MZ_AES_BLOCK_SIZE) {
uint32_t j = 0;
/* Increment encryption nonce */
@ -205,8 +194,7 @@ static int32_t mz_stream_wzaes_ctr_encrypt(void *stream, uint8_t *buf, int32_t s
return err;
}
int32_t mz_stream_wzaes_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_wzaes_read(void *stream, void *buf, int32_t size) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
int64_t max_total_in = 0;
int32_t bytes_to_read = size;
@ -218,8 +206,7 @@ int32_t mz_stream_wzaes_read(void *stream, void *buf, int32_t size)
read = mz_stream_read(wzaes->stream.base, buf, bytes_to_read);
if (read > 0)
{
if (read > 0) {
mz_crypt_hmac_update(wzaes->hmac, (uint8_t *)buf, read);
mz_stream_wzaes_ctr_encrypt(stream, (uint8_t *)buf, read);
@ -229,8 +216,7 @@ int32_t mz_stream_wzaes_read(void *stream, void *buf, int32_t size)
return read;
}
int32_t mz_stream_wzaes_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_wzaes_write(void *stream, const void *buf, int32_t size) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
const uint8_t *buf_ptr = (const uint8_t *)buf;
int32_t bytes_to_write = sizeof(wzaes->buffer);
@ -240,8 +226,7 @@ int32_t mz_stream_wzaes_write(void *stream, const void *buf, int32_t size)
if (size < 0)
return MZ_PARAM_ERROR;
do
{
do {
if (bytes_to_write > (size - total_written))
bytes_to_write = (size - total_written);
@ -256,42 +241,35 @@ int32_t mz_stream_wzaes_write(void *stream, const void *buf, int32_t size)
return written;
total_written += written;
}
while (total_written < size && written > 0);
} while (total_written < size && written > 0);
wzaes->total_out += total_written;
return total_written;
}
int64_t mz_stream_wzaes_tell(void *stream)
{
int64_t mz_stream_wzaes_tell(void *stream) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
return mz_stream_tell(wzaes->stream.base);
}
int32_t mz_stream_wzaes_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_wzaes_seek(void *stream, int64_t offset, int32_t origin) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
return mz_stream_seek(wzaes->stream.base, offset, origin);
}
int32_t mz_stream_wzaes_close(void *stream)
{
int32_t mz_stream_wzaes_close(void *stream) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
uint8_t expected_hash[MZ_AES_AUTHCODE_SIZE];
uint8_t computed_hash[MZ_HASH_SHA1_SIZE];
mz_crypt_hmac_end(wzaes->hmac, computed_hash, sizeof(computed_hash));
if (wzaes->mode & MZ_OPEN_MODE_WRITE)
{
if (wzaes->mode & MZ_OPEN_MODE_WRITE) {
if (mz_stream_write(wzaes->stream.base, computed_hash, MZ_AES_AUTHCODE_SIZE) != MZ_AES_AUTHCODE_SIZE)
return MZ_WRITE_ERROR;
wzaes->total_out += MZ_AES_AUTHCODE_SIZE;
}
else if (wzaes->mode & MZ_OPEN_MODE_READ)
{
} else if (wzaes->mode & MZ_OPEN_MODE_READ) {
if (mz_stream_read(wzaes->stream.base, expected_hash, MZ_AES_AUTHCODE_SIZE) != MZ_AES_AUTHCODE_SIZE)
return MZ_READ_ERROR;
@ -306,29 +284,24 @@ int32_t mz_stream_wzaes_close(void *stream)
return MZ_OK;
}
int32_t mz_stream_wzaes_error(void *stream)
{
int32_t mz_stream_wzaes_error(void *stream) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
return wzaes->error;
}
void mz_stream_wzaes_set_password(void *stream, const char *password)
{
void mz_stream_wzaes_set_password(void *stream, const char *password) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
wzaes->password = password;
}
void mz_stream_wzaes_set_encryption_mode(void *stream, int16_t encryption_mode)
{
void mz_stream_wzaes_set_encryption_mode(void *stream, int16_t encryption_mode) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
wzaes->encryption_mode = encryption_mode;
}
int32_t mz_stream_wzaes_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_wzaes_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = wzaes->total_in;
break;
@ -350,11 +323,9 @@ int32_t mz_stream_wzaes_get_prop_int64(void *stream, int32_t prop, int64_t *valu
return MZ_OK;
}
int32_t mz_stream_wzaes_set_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) {
mz_stream_wzaes *wzaes = (mz_stream_wzaes *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN_MAX:
wzaes->max_total_in = value;
break;
@ -364,13 +335,11 @@ int32_t mz_stream_wzaes_set_prop_int64(void *stream, int32_t prop, int64_t value
return MZ_OK;
}
void *mz_stream_wzaes_create(void **stream)
{
void *mz_stream_wzaes_create(void **stream) {
mz_stream_wzaes *wzaes = NULL;
wzaes = (mz_stream_wzaes *)MZ_ALLOC(sizeof(mz_stream_wzaes));
if (wzaes != NULL)
{
if (wzaes != NULL) {
memset(wzaes, 0, sizeof(mz_stream_wzaes));
wzaes->stream.vtbl = &mz_stream_wzaes_vtbl;
wzaes->encryption_mode = MZ_AES_ENCRYPTION_MODE_256;
@ -384,14 +353,12 @@ void *mz_stream_wzaes_create(void **stream)
return wzaes;
}
void mz_stream_wzaes_delete(void **stream)
{
void mz_stream_wzaes_delete(void **stream) {
mz_stream_wzaes *wzaes = NULL;
if (stream == NULL)
return;
wzaes = (mz_stream_wzaes *)*stream;
if (wzaes != NULL)
{
if (wzaes != NULL) {
mz_crypt_aes_delete(&wzaes->aes);
mz_crypt_hmac_delete(&wzaes->hmac);
MZ_FREE(wzaes);
@ -399,7 +366,6 @@ void mz_stream_wzaes_delete(void **stream)
*stream = NULL;
}
void *mz_stream_wzaes_get_interface(void)
{
void *mz_stream_wzaes_get_interface(void) {
return (void *)&mz_stream_wzaes_vtbl;
}

103
mz_strm_zlib.c
View File

@ -73,8 +73,7 @@ typedef struct mz_stream_zlib_s {
/***************************************************************************/
int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode)
{
int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
MZ_UNUSED(path);
@ -89,8 +88,7 @@ int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode)
zlib->total_in = 0;
zlib->total_out = 0;
if (mode & MZ_OPEN_MODE_WRITE)
{
if (mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -100,9 +98,7 @@ int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode)
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)
{
} else if (mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -121,16 +117,14 @@ int32_t mz_stream_zlib_open(void *stream, const char *path, int32_t mode)
return MZ_OK;
}
int32_t mz_stream_zlib_is_open(void *stream)
{
int32_t mz_stream_zlib_is_open(void *stream) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
if (zlib->initialized != 1)
return MZ_OPEN_ERROR;
return MZ_OK;
}
int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
{
int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
MZ_UNUSED(stream);
MZ_UNUSED(buf);
@ -154,12 +148,9 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
zlib->zstream.next_out = (Bytef*)buf;
zlib->zstream.avail_out = (uInt)size;
do
{
if (zlib->zstream.avail_in == 0)
{
if (zlib->max_total_in > 0)
{
do {
if (zlib->zstream.avail_in == 0) {
if (zlib->max_total_in > 0) {
if ((int64_t)bytes_to_read > (zlib->max_total_in - zlib->total_in))
bytes_to_read = (int32_t)(zlib->max_total_in - zlib->total_in);
}
@ -177,8 +168,7 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
total_out_before = zlib->zstream.total_out;
err = ZLIB_PREFIX(inflate)(&zlib->zstream, Z_SYNC_FLUSH);
if ((err >= Z_OK) && (zlib->zstream.msg != NULL))
{
if ((err >= Z_OK) && (zlib->zstream.msg != NULL)) {
zlib->error = Z_DATA_ERROR;
break;
}
@ -197,16 +187,13 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
if (err == Z_STREAM_END)
break;
if (err != Z_OK)
{
if (err != Z_OK) {
zlib->error = err;
break;
}
}
while (zlib->zstream.avail_out > 0);
} while (zlib->zstream.avail_out > 0);
if (zlib->error != 0)
{
if (zlib->error != 0) {
/* Zlib errors are compatible with MZ */
return zlib->error;
}
@ -216,16 +203,14 @@ int32_t mz_stream_zlib_read(void *stream, void *buf, int32_t size)
}
#ifndef MZ_ZIP_NO_COMPRESSION
static int32_t mz_stream_zlib_flush(void *stream)
{
static int32_t mz_stream_zlib_flush(void *stream) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
if (mz_stream_write(zlib->stream.base, zlib->buffer, zlib->buffer_len) != zlib->buffer_len)
return MZ_WRITE_ERROR;
return MZ_OK;
}
static int32_t mz_stream_zlib_deflate(void *stream, int flush)
{
static int32_t mz_stream_zlib_deflate(void *stream, int flush) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
uint64_t total_out_before = 0;
uint64_t total_out_after = 0;
@ -233,10 +218,8 @@ static int32_t mz_stream_zlib_deflate(void *stream, int flush)
int32_t err = Z_OK;
do
{
if (zlib->zstream.avail_out == 0)
{
do {
if (zlib->zstream.avail_out == 0) {
err = mz_stream_zlib_flush(zlib);
if (err != MZ_OK)
return err;
@ -258,20 +241,17 @@ static int32_t mz_stream_zlib_deflate(void *stream, int flush)
if (err == Z_STREAM_END)
break;
if (err != Z_OK)
{
if (err != Z_OK) {
zlib->error = err;
return MZ_DATA_ERROR;
}
}
while ((zlib->zstream.avail_in > 0) || (flush == Z_FINISH && err == Z_OK));
} while ((zlib->zstream.avail_in > 0) || (flush == Z_FINISH && err == Z_OK));
return MZ_OK;
}
#endif
int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size)
{
int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
int32_t err = size;
@ -290,15 +270,13 @@ int32_t mz_stream_zlib_write(void *stream, const void *buf, int32_t size)
return err;
}
int64_t mz_stream_zlib_tell(void *stream)
{
int64_t mz_stream_zlib_tell(void *stream) {
MZ_UNUSED(stream);
return MZ_TELL_ERROR;
}
int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin)
{
int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin) {
MZ_UNUSED(stream);
MZ_UNUSED(offset);
MZ_UNUSED(origin);
@ -306,13 +284,11 @@ int32_t mz_stream_zlib_seek(void *stream, int64_t offset, int32_t origin)
return MZ_SEEK_ERROR;
}
int32_t mz_stream_zlib_close(void *stream)
{
int32_t mz_stream_zlib_close(void *stream) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
if (zlib->mode & MZ_OPEN_MODE_WRITE)
{
if (zlib->mode & MZ_OPEN_MODE_WRITE) {
#ifdef MZ_ZIP_NO_COMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -321,9 +297,7 @@ int32_t mz_stream_zlib_close(void *stream)
ZLIB_PREFIX(deflateEnd)(&zlib->zstream);
#endif
}
else if (zlib->mode & MZ_OPEN_MODE_READ)
{
} else if (zlib->mode & MZ_OPEN_MODE_READ) {
#ifdef MZ_ZIP_NO_DECOMPRESSION
return MZ_SUPPORT_ERROR;
#else
@ -338,17 +312,14 @@ int32_t mz_stream_zlib_close(void *stream)
return MZ_OK;
}
int32_t mz_stream_zlib_error(void *stream)
{
int32_t mz_stream_zlib_error(void *stream) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
return zlib->error;
}
int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value)
{
int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_TOTAL_IN:
*value = zlib->total_in;
break;
@ -363,18 +334,16 @@ int32_t mz_stream_zlib_get_prop_int64(void *stream, int32_t prop, int64_t *value
break;
case MZ_STREAM_PROP_COMPRESS_WINDOW:
*value = zlib->window_bits;
break;
break;
default:
return MZ_EXIST_ERROR;
}
return MZ_OK;
}
int32_t mz_stream_zlib_set_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) {
mz_stream_zlib *zlib = (mz_stream_zlib *)stream;
switch (prop)
{
switch (prop) {
case MZ_STREAM_PROP_COMPRESS_LEVEL:
zlib->level = (int16_t)value;
break;
@ -390,13 +359,11 @@ int32_t mz_stream_zlib_set_prop_int64(void *stream, int32_t prop, int64_t value)
return MZ_OK;
}
void *mz_stream_zlib_create(void **stream)
{
void *mz_stream_zlib_create(void **stream) {
mz_stream_zlib *zlib = NULL;
zlib = (mz_stream_zlib *)MZ_ALLOC(sizeof(mz_stream_zlib));
if (zlib != NULL)
{
if (zlib != NULL) {
memset(zlib, 0, sizeof(mz_stream_zlib));
zlib->stream.vtbl = &mz_stream_zlib_vtbl;
zlib->level = Z_DEFAULT_COMPRESSION;
@ -408,8 +375,7 @@ void *mz_stream_zlib_create(void **stream)
return zlib;
}
void mz_stream_zlib_delete(void **stream)
{
void mz_stream_zlib_delete(void **stream) {
mz_stream_zlib *zlib = NULL;
if (stream == NULL)
return;
@ -419,7 +385,6 @@ void mz_stream_zlib_delete(void **stream)
*stream = NULL;
}
void *mz_stream_zlib_get_interface(void)
{
void *mz_stream_zlib_get_interface(void) {
return (void *)&mz_stream_zlib_vtbl;
}

806
mz_zip.c
View File

File diff suppressed because it is too large Load Diff

3
mz_zip.h
View File

@ -23,8 +23,7 @@ extern "C" {
/***************************************************************************/
typedef struct mz_zip_file_s
{
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 */

510
mz_zip_rw.c
View File

File diff suppressed because it is too large Load Diff