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

Added back compatibility layer.

Browse Source 
Fixed compiler warnings and errors.
This commit is contained in:
Nathan Moinvaziri 2017-10-08 23:26:17 -07:00
parent 1e3300f758
commit 8db28c9afe
10 changed files with 923 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

615
mz_compat.c Normal file
View File

@ -0,0 +1,615 @@
/* mzstrm.c -- Stream interface
part of the MiniZip project
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Copyright (C) 1998-2010 Gilles Vollant
http://www.winimage.com/zLibDll/minizip.html
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "mz_error.h"
#include "mz_os.h"
#include "mz_strm.h"
#include "mz_strm_zlib.h"
#include "mz_zip.h"
#include "mz_unzip.h"
#include "mz_compat.h"
/***************************************************************************/
typedef struct mz_compat_s {
void *stream;
void *handle;
} mz_compat;
/***************************************************************************/
extern zipFile ZEXPORT zipOpen(const char *path, int append)
{
return zipOpen2(path, append, NULL, mz_stream_os_get_interface());
}
extern zipFile ZEXPORT zipOpen64(const void *path, int append)
{
return zipOpen2(path, append, NULL, mz_stream_os_get_interface());
}
extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment,
zlib_filefunc_def *pzlib_filefunc_def)
{
return zipOpen2_64(path, append, globalcomment, pzlib_filefunc_def);
}
extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment,
zlib_filefunc64_def *pzlib_filefunc_def)
{
mz_compat *compat = NULL;
int32_t mode = MZ_STREAM_MODE_READWRITE;
int32_t open_existing = 0;
int16_t err = MZ_OK;
void *handle = NULL;
void *stream = NULL;
if (mz_stream_create(&stream, (mz_stream_vtbl *)pzlib_filefunc_def) == NULL)
return NULL;
switch (append)
{
case APPEND_STATUS_CREATE:
mode |= MZ_STREAM_MODE_CREATE;
break;
case APPEND_STATUS_CREATEAFTER:
mode |= MZ_STREAM_MODE_CREATE | MZ_STREAM_MODE_APPEND;
break;
case APPEND_STATUS_ADDINZIP:
open_existing = 1;
break;
}
if (mz_stream_open(stream, path, mode) != MZ_OK)
{
mz_stream_delete(&stream);
return NULL;
}
handle = mz_zip_open(open_existing, stream);
if (handle == NULL)
{
mz_stream_delete(&stream);
return NULL;
}
if (globalcomment != NULL)
mz_zip_get_global_comment(handle, globalcomment);
compat = (mz_compat *)malloc(sizeof(mz_compat));
compat->handle = handle;
compat->stream = stream;
return (zipFile)compat;
}
extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64)
{
mz_compat *compat = (mz_compat *)file;
mz_zip_file file_info;
if (compat == NULL)
return MZ_PARAM_ERROR;
if (zipfi != NULL)
{
file_info.dos_date = zipfi->dos_date;
file_info.external_fa = zipfi->external_fa;
file_info.internal_fa = zipfi->internal_fa;
}
file_info.filename = filename;
file_info.extrafield_local = extrafield_local;
file_info.extrafield_local_size = size_extrafield_local;
file_info.extrafield_global = extrafield_global;
file_info.extrafield_global_size = size_extrafield_global;
file_info.version_madeby = version_madeby;
file_info.comment = comment;
file_info.flag = flag_base;
file_info.zip64 = zip64;
mz_zip_compress compress_info;
compress_info.level = level;
compress_info.window_bits = windowBits;
compress_info.mem_level = memLevel;
compress_info.strategy = strategy;
compress_info.method = compression_method;
mz_zip_crypt crypt_info;
#ifdef HAVE_AES
crypt_info.aes = 1;
#endif
crypt_info.password = password;
return mz_zip_entry_open(compat->handle, &file_info, &compress_info, &crypt_info);
}
extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t 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);
}
extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t 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);
}
extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting)
{
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, 0);
}
extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED 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);
}
extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_zip_entry_write(compat->handle, buf, len);
}
extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_zip_entry_close_raw(compat->handle, uncompressed_size, crc32);
}
extern int ZEXPORT zipCloseFileInZip(zipFile file)
{
return zipCloseFileInZipRaw(file, 0, 0);
}
extern int ZEXPORT zipCloseFileInZip64(zipFile file)
{
return zipCloseFileInZipRaw(file, 0, 0);
}
extern int ZEXPORT zipClose(zipFile file, const char *global_comment)
{
return zipClose_64(file, global_comment);
}
extern int ZEXPORT zipClose_64(zipFile file, const char *global_comment)
{
return zipClose2_64(file, global_comment, MZ_VERSION_MADEBY);
}
extern int ZEXPORT zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby)
{
mz_compat *compat = (mz_compat *)file;
int16_t err = MZ_OK;
if (compat == NULL)
return MZ_PARAM_ERROR;
err = mz_zip_close(compat->handle, global_comment, version_madeby);
if (compat->stream != NULL)
mz_stream_delete(&compat->stream);
free(compat);
return err;
}
/***************************************************************************/
extern unzFile ZEXPORT unzOpen(const char *path)
{
return unzOpen64(path);
}
extern unzFile ZEXPORT unzOpen64(const void *path)
{
return unzOpen2(path, mz_stream_os_get_interface());
}
extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def)
{
return unzOpen2_64(path, pzlib_filefunc_def);
}
extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def)
{
mz_compat *compat = NULL;
int32_t mode = MZ_STREAM_MODE_READ;
int32_t open_existing = 0;
int16_t err = MZ_OK;
void *handle = NULL;
void *stream = NULL;
if (mz_stream_create(&stream, (mz_stream_vtbl *)pzlib_filefunc_def) == NULL)
return NULL;
if (mz_stream_open(stream, path, mode) != MZ_OK)
{
mz_stream_delete(&stream);
return NULL;
}
handle = mz_unzip_open(stream);
if (handle == NULL)
{
mz_stream_delete(&stream);
return NULL;
}
compat = (mz_compat *)malloc(sizeof(mz_compat));
compat->handle = handle;
compat->stream = stream;
return (unzFile)compat;
}
extern int ZEXPORT unzClose(unzFile file)
{
mz_compat *compat = (mz_compat *)file;
int16_t err = MZ_OK;
if (compat == NULL)
return MZ_PARAM_ERROR;
err = mz_unzip_close(compat->handle);
if (compat->stream != NULL)
mz_stream_delete(&compat->stream);
free(compat);
return err;
}
extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)
{
mz_compat *compat = (mz_compat *)file;
unz_global_info64 global_info64;
int16_t err = MZ_OK;
if (compat == NULL)
return MZ_PARAM_ERROR;
err = unzGetGlobalInfo64(file, &global_info64);
if (err != UNZ_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;
}
return MZ_OK;
}
extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)
{
mz_compat *compat = (mz_compat *)file;
mz_unzip_global global_info;
int16_t err = MZ_OK;
if (compat == NULL)
return MZ_PARAM_ERROR;
err = mz_unzip_get_global_info(compat->handle, &global_info);
if (err == MZ_OK)
{
pglobal_info->size_comment = global_info.comment_size;
pglobal_info->number_entry = global_info.number_entry;
pglobal_info->number_disk_with_CD = global_info.number_disk_with_CD;
}
return err;
}
extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_unzip_get_global_comment(compat->handle, comment, comment_size);
}
extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
if (method != NULL)
*method = 0;
if (level != NULL)
*level = 0;
return mz_unzip_entry_open(compat->handle, raw, password);
}
extern int ZEXPORT unzOpenCurrentFile(unzFile file)
{
return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
}
extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password)
{
return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
}
extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw)
{
return unzOpenCurrentFile3(file, method, level, raw, NULL);
}
extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_unzip_entry_read(compat->handle, buf, len);
}
extern int ZEXPORT unzCloseCurrentFile(unzFile file)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_unzip_entry_close(compat->handle);
}
extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
{
mz_compat *compat = (mz_compat *)file;
mz_unzip_file *file_info = NULL;
int16_t bytes_to_copy = 0;
int16_t err = MZ_OK;
if (compat == NULL)
return MZ_PARAM_ERROR;
err = mz_unzip_entry_get_info(compat->handle, &file_info);
if ((err == MZ_OK) && (pfile_info != NULL))
{
pfile_info->version = file_info->version;
pfile_info->version_needed = file_info->version_needed;
pfile_info->flag = file_info->flag;
pfile_info->compression_method = file_info->compression_method;
pfile_info->dos_date = file_info->dos_date;
pfile_info->crc = file_info->crc;
pfile_info->size_filename = file_info->filename_size;
pfile_info->size_file_extra = file_info->extrafield_size;
pfile_info->size_file_comment = file_info->comment_size;
pfile_info->disk_num_start = (uint16_t)file_info->disk_num_start;
pfile_info->internal_fa = file_info->internal_fa;
pfile_info->external_fa = file_info->external_fa;
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)
{
bytes_to_copy = filename_size;
if (bytes_to_copy > file_info->filename_size)
bytes_to_copy = file_info->filename_size;
memcpy(filename, file_info->filename, bytes_to_copy);
}
if (extrafield_size > 0 && extrafield != NULL)
{
bytes_to_copy = 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)
{
bytes_to_copy = comment_size;
if (bytes_to_copy > file_info->comment_size)
bytes_to_copy = file_info->comment_size;
memcpy(comment, file_info->comment, bytes_to_copy);
}
}
return err;
}
extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)
{
mz_compat *compat = (mz_compat *)file;
mz_unzip_file *file_info = NULL;
int16_t bytes_to_copy = 0;
int16_t err = MZ_OK;
if (compat == NULL)
return MZ_PARAM_ERROR;
err = mz_unzip_entry_get_info(compat->handle, &file_info);
if ((err == MZ_OK) && (pfile_info != NULL))
{
pfile_info->version = file_info->version;
pfile_info->version_needed = file_info->version_needed;
pfile_info->flag = file_info->flag;
pfile_info->compression_method = file_info->compression_method;
pfile_info->dos_date = file_info->dos_date;
pfile_info->crc = file_info->crc;
pfile_info->size_filename = file_info->filename_size;
pfile_info->size_file_extra = file_info->extrafield_size;
pfile_info->size_file_comment = file_info->comment_size;
pfile_info->disk_num_start = file_info->disk_num_start;
pfile_info->internal_fa = file_info->internal_fa;
pfile_info->external_fa = file_info->external_fa;
pfile_info->compressed_size = file_info->compressed_size;
pfile_info->uncompressed_size = file_info->uncompressed_size;
if (filename_size > 0 && filename != NULL)
{
bytes_to_copy = filename_size;
if (bytes_to_copy > file_info->filename_size)
bytes_to_copy = file_info->filename_size;
memcpy(filename, file_info->filename, bytes_to_copy);
}
if (extrafield_size > 0 && extrafield != NULL)
{
bytes_to_copy = 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)
{
bytes_to_copy = comment_size;
if (bytes_to_copy > file_info->comment_size)
bytes_to_copy = file_info->comment_size;
memcpy(comment, file_info->comment, bytes_to_copy);
}
}
return err;
}
extern int ZEXPORT unzGoToFirstFile(unzFile file)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_unzip_goto_first_entry(compat->handle);
}
extern int ZEXPORT unzGoToNextFile(unzFile file)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_unzip_goto_next_entry(compat->handle);
}
extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func)
{
mz_compat *compat = (mz_compat *)file;
if (compat == NULL)
return MZ_PARAM_ERROR;
return mz_unzip_locate_entry(compat->handle, filename, filename_compare_func);
}
/***************************************************************************/
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)
{
if (pzlib_filefunc_def != NULL)
pzlib_filefunc_def = mz_stream_os_get_interface();
}
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)
{
if (pzlib_filefunc_def != NULL)
pzlib_filefunc_def = mz_stream_os_get_interface();
}
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)
{
// 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();
}
/***************************************************************************/
int get_file_crc(const char *path, void *buf, uint32_t buf_size, uint32_t *result_crc)
{
void *stream = NULL;
void *crc32_stream = NULL;
uint32_t read = 0;
int16_t err = MZ_OK;
mz_stream_os_create(&stream);
err = mz_stream_os_open(stream, path, MZ_STREAM_MODE_READ);
mz_stream_crc32_create(&crc32_stream);
mz_stream_crc32_open(crc32_stream, NULL, MZ_STREAM_MODE_READ);
if (err == MZ_OK)
{
do
{
read = mz_stream_crc32_read(crc32_stream, buf, buf_size);
if ((read < buf_size) && (mz_stream_error(crc32_stream) != MZ_OK))
err = read;
}
while ((err == MZ_OK) && (read > 0));
mz_stream_os_close(stream);
}
mz_stream_crc32_close(crc32_stream);
*result_crc = mz_stream_crc32_get_value(crc32_stream);
mz_stream_crc32_delete(&crc32_stream);
mz_stream_os_delete(&stream);
return err;
}

293
mz_compat.h Normal file
View File

@ -0,0 +1,293 @@
/* mz_compat.h -- Backwards compatible interface for older versions of MiniZip
part of the MiniZip project
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Copyright (C) 1998-2010 Gilles Vollant
http://www.winimage.com/zLibDll/minizip.html
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/
#ifndef _MZ_COMPAT_H
#define _MZ_COMPAT_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "zlib.h"
/***************************************************************************/
#ifdef __GNUC__
# define ZIP_UNUSED __attribute__((__unused__))
#else
# define ZIP_UNUSED
#endif
#ifndef DEF_MEM_LEVEL
# if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8
# else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
# endif
#endif
#if defined(USE_FILE32API)
# define fopen64 fopen
# define ftello64 ftell
# define fseeko64 fseek
#else
# if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \
defined(__OpenBSD__) || defined(__APPLE__) || defined(__ANDROID__)
# define fopen64 fopen
# define ftello64 ftello
# define fseeko64 fseeko
# endif
# ifdef _MSC_VER
# define fopen64 fopen
# if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
# define ftello64 _ftelli64
# define fseeko64 _fseeki64
# else /* old MSC */
# define ftello64 ftell
# define fseeko64 fseek
# endif
# endif
#endif
/***************************************************************************/
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */
typedef struct TagzipFile__ { int unused; } zip_file__;
typedef zip_file__ *zipFile;
#else
typedef voidp zipFile;
#endif
/***************************************************************************/
typedef void *zlib_filefunc_def;
typedef void *zlib_filefunc64_def;
/***************************************************************************/
typedef struct
{
uint32_t dos_date;
uint16_t internal_fa; // internal file attributes 2 bytes
uint32_t external_fa; // external file attributes 4 bytes
} zip_fileinfo;
/***************************************************************************/
#define ZIP_OK (0)
#define ZIP_EOF (0)
#define ZIP_ERRNO (Z_ERRNO)
#define ZIP_PARAMERROR (-102)
#define ZIP_BADZIPFILE (-103)
#define ZIP_INTERNALERROR (-104)
#define Z_BZIP2ED (12)
#define APPEND_STATUS_CREATE (1)
#define APPEND_STATUS_CREATEAFTER (2)
#define APPEND_STATUS_ADDINZIP (3)
/***************************************************************************/
extern zipFile ZEXPORT zipOpen(const char *path, int append);
extern zipFile ZEXPORT zipOpen64(const void *path, int append);
extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment,
zlib_filefunc_def *pzlib_filefunc_def);
extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment,
zlib_filefunc64_def *pzlib_filefunc_def);
extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting);
extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, int zip64);
extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base);
extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64);
extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi,
const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global,
uint16_t size_extrafield_global, const char *comment, uint16_t compression_method, int level,
int raw, int windowBits, int memLevel, int strategy, const char *password,
ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64);
extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len);
extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32);
extern int ZEXPORT zipCloseFileInZip(zipFile file);
extern int ZEXPORT zipCloseFileInZip64(zipFile file);
extern int ZEXPORT zipClose(zipFile file, const char *global_comment);
extern int ZEXPORT zipClose_64(zipFile file, const char *global_comment);
extern int ZEXPORT zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby);
/***************************************************************************/
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */
typedef struct TagunzFile__ { int unused; } unz_file__;
typedef unz_file__ *unzFile;
#else
typedef voidp unzFile;
#endif
/***************************************************************************/
#define UNZ_OK (0)
#define UNZ_END_OF_LIST_OF_FILE (-100)
#define UNZ_ERRNO (Z_ERRNO)
#define UNZ_EOF (0)
#define UNZ_PARAMERROR (-102)
#define UNZ_BADZIPFILE (-103)
#define UNZ_INTERNALERROR (-104)
#define UNZ_CRCERROR (-105)
#define UNZ_BADPASSWORD (-106)
/***************************************************************************/
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
{
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
{
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
uint16_t compression_method; // compression method 2 bytes
uint32_t dos_date; // last mod file date in Dos fmt 4 bytes
uint32_t crc; // crc-32 4 bytes
uint64_t compressed_size; // compressed size 8 bytes
uint64_t uncompressed_size; // uncompressed size 8 bytes
uint16_t size_filename; // filename length 2 bytes
uint16_t size_file_extra; // extra field length 2 bytes
uint16_t size_file_comment; // file comment length 2 bytes
uint32_t disk_num_start; // disk number start 4 bytes
uint16_t internal_fa; // internal file attributes 2 bytes
uint32_t external_fa; // external file attributes 4 bytes
uint64_t disk_offset;
uint16_t size_file_extra_internal;
} unz_file_info64;
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
uint16_t compression_method; // compression method 2 bytes
uint32_t dos_date; // last mod file date in Dos fmt 4 bytes
uint32_t crc; // crc-32 4 bytes
uint32_t compressed_size; // compressed size 4 bytes
uint32_t uncompressed_size; // uncompressed size 4 bytes
uint16_t size_filename; // filename length 2 bytes
uint16_t size_file_extra; // extra field length 2 bytes
uint16_t size_file_comment; // file comment length 2 bytes
uint16_t disk_num_start; // disk number start 2 bytes
uint16_t internal_fa; // internal file attributes 2 bytes
uint32_t external_fa; // external file attributes 4 bytes
uint64_t disk_offset;
} unz_file_info;
/***************************************************************************/
typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);
typedef int (*unzIteratorFunction)(unzFile file);
typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
/***************************************************************************/
extern unzFile ZEXPORT unzOpen(const char *path);
extern unzFile ZEXPORT unzOpen64(const void *path);
extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def);
extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def);
extern int ZEXPORT unzClose(unzFile file);
extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32);
extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info);
extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size);
extern int ZEXPORT unzOpenCurrentFile(unzFile file);
extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password);
extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);
extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password);
extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len);
extern int ZEXPORT unzCloseCurrentFile(unzFile file);
extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
extern int ZEXPORT unzGoToFirstFile(unzFile file);
extern int ZEXPORT unzGoToNextFile(unzFile file);
extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);
/***************************************************************************/
void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def);
void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def);
void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def);
void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def);
void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def);
/***************************************************************************/
#define check_file_exists mz_os_file_exists
#define dosdate_to_tm mz_dosdate_to_tm
#define change_file_date mz_os_set_file_date
#define get_file_date mz_os_get_file_date
#define is_large_file(x) (mz_os_file_get_size(x) > UINT32_MAX)
#define makedir mz_os_make_dir
#define MKDIR mz_os_make_dir
#define CHDIR mz_os_change_dir
int get_file_crc(const char *path, void *buf, uint32_t buf_size, uint32_t *result_crc);
/***************************************************************************/
#ifdef __cplusplus
}
#endif
#endif

13
mz_strm.c
View File

@ -4,11 +4,6 @@
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Modifications for Zip64 support
Copyright (C) 2009-2010 Mathias Svensson
http://result42.com
Copyright (C) 1998-2010 Gilles Vollant
http://www.winimage.com/zLibDll/minizip.html
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
@ -272,15 +267,13 @@ int64_t mz_stream_get_total_out(void *stream)
return strm->vtbl->get_total_out(stream);
}
void *mz_stream_create(void **stream)
void *mz_stream_create(void **stream, mz_stream_vtbl *vtbl)
{
mz_stream *strm = NULL;
if (stream == NULL)
return NULL;
strm = (mz_stream *)*stream;
if (strm == NULL || strm->vtbl == NULL || strm->vtbl->create == NULL)
if (vtbl == NULL || vtbl->create == NULL)
return NULL;
return strm->vtbl->create(stream);
return vtbl->create(stream);
}
void mz_stream_delete(void **stream)

17
mz_strm.h
View File

@ -4,11 +4,6 @@
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Copyright (C) 2009-2010 Mathias Svensson
Modifications for Zip64 support
http://result42.com
Copyright (C) 1998-2010 Gilles Vollant
http://www.winimage.com/zLibDll/minizip.html
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
@ -50,18 +45,9 @@ typedef int64_t (*mz_stream_tell_cb) (void *stream);
typedef int32_t (*mz_stream_seek_cb) (void *stream, int64_t offset, int32_t origin);
typedef int32_t (*mz_stream_close_cb) (void *stream);
typedef int32_t (*mz_stream_error_cb) (void *stream);
typedef int64_t (*mz_stream_set_property_ptr) (void *stream, int32_t property, void *value);
typedef int64_t (*mz_stream_get_property_ptr) (void *stream, int32_t property, void **value);
typedef int64_t (*mz_stream_get_property_int64)(void *stream, int32_t property, int64_t *value);
typedef void* (*mz_stream_create_cb) (void **stream);
typedef void (*mz_stream_delete_cb) (void **stream);
typedef int64_t (*mz_stream_set_base_cb) (void *stream);
typedef int64_t (*mz_stream_get_total_in_cb) (void *stream);
typedef int64_t (*mz_stream_get_total_out_cb) (void *stream);
@ -79,6 +65,7 @@ typedef struct mz_stream_vtbl_s
mz_stream_error_cb error;
mz_stream_create_cb create;
mz_stream_delete_cb delete;
mz_stream_get_total_in_cb get_total_in;
mz_stream_get_total_out_cb get_total_out;
} mz_stream_vtbl;
@ -112,7 +99,7 @@ int32_t mz_stream_set_base(void *stream, void *base);
int64_t mz_stream_get_total_in(void *stream);
int64_t mz_stream_get_total_out(void *stream);
void* mz_stream_create(void **stream);
void* mz_stream_create(void **stream, mz_stream_vtbl *vtbl);
void mz_stream_delete(void **stream);
void* mz_stream_passthru_create(void **stream);

3
mz_strm_posix.h
View File

@ -53,6 +53,9 @@ void* mz_stream_posix_get_interface(void);
#define mz_stream_os_create mz_stream_posix_create
#define mz_stream_os_delete mz_stream_posix_delete
#define mz_stream_os_get_interface \
mz_stream_posix_get_interface
#endif
/***************************************************************************/

2
mz_strm_win32.c
View File

@ -57,7 +57,7 @@ mz_stream_vtbl mz_stream_win32_vtbl = {
typedef struct mz_stream_win32_s
{
mz_stream vtbl;
mz_stream stream;
HANDLE handle;
int32_t error;
} mz_stream_win32;

3
mz_strm_win32.h
View File

@ -54,6 +54,9 @@ void* mz_stream_win32_get_interface(void);
#define mz_stream_os_create mz_stream_win32_create
#define mz_stream_os_delete mz_stream_win32_delete
#define mz_stream_os_get_interface \
mz_stream_win32_get_interface
#define mz_os_rand mz_win32_rand
#define mz_os_get_file_date mz_win32_get_file_date
#define mz_os_set_file_date mz_win32_set_file_date

2
mz_unzip.c
View File

@ -115,7 +115,7 @@ static uint64_t mz_unzip_search_cd(void *stream)
uint64_t read_pos = 0;
uint32_t i = 0;
if (mz_stream_seek(stream, 0, MZ_STREAM_SEEK_END) != 0)
if (mz_stream_seek(stream, 0, MZ_STREAM_SEEK_END) != MZ_OK)
return 0;
file_size = mz_stream_tell(stream);

4
mz_zip.c
View File

@ -79,7 +79,6 @@ typedef struct mz_zip_s
uint64_t add_position_when_writting_offset;
uint64_t number_entry;
uint16_t entry_opened; // 1 if a file in the zip is currently writ.
uint64_t disk_size; // size of each disk
uint32_t number_disk; // number of the current disk, used for spanning ZIP
uint32_t number_disk_with_CD; // number the the disk with central dir, used for spanning ZIP
#ifndef NO_ADDFILEINEXISTINGZIP
@ -180,7 +179,7 @@ static uint64_t mz_zip_search_zip64_cd(void *stream, const uint64_t endcentralof
return offset;
}
extern void* ZEXPORT mz_zip_open(uint8_t open_existing, uint64_t disk_size, void *stream)
extern void* ZEXPORT mz_zip_open(uint8_t open_existing, void *stream)
{
mz_zip *zip = NULL;
#ifndef NO_ADDFILEINEXISTINGZIP
@ -206,7 +205,6 @@ extern void* ZEXPORT mz_zip_open(uint8_t open_existing, uint64_t disk_size, void
memset(zip, 0, sizeof(mz_zip));
zip->stream = stream;
zip->disk_size = disk_size;
mz_stream_mem_create(&zip->cd_stream);
mz_stream_mem_set_grow(zip->cd_stream, 1);

2
mz_zip.h
View File

@ -78,7 +78,7 @@ typedef struct mz_zip_crypt_s
/***************************************************************************/
extern void* ZEXPORT mz_zip_open(uint8_t open_existing, uint64_t disk_size, void *stream);
extern void* ZEXPORT mz_zip_open(uint8_t open_existing, void *stream);
// Create a zip file
//
// NOTE: There is no delete function into a zip file. If you want delete file in a zip file,