QuasarApp/zip
4
0
Fork 0
mirror of https://github.com/QuasarApp/zip.git synced 2025-05-08 18:09:33 +00:00
Code Issues Projects Releases Wiki Activity

formatting

Browse Source
This commit is contained in:
Kuba Podgórski 2017-02-14 20:05:54 +01:00
parent 49656d5c10
commit 8cac9e042f
2 changed files with 117 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -1,5 +1,5 @@
project(zip)
cmake_minimum_required(VERSION 2.8) cmake_minimum_required(VERSION 2.8)
project(zip)
set(SRC src/miniz.h src/zip.h src/zip.c) set(SRC src/miniz.h src/zip.h src/zip.c)

117
src/zip.c
View File

@ -7,16 +7,19 @@
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE. OTHER DEALINGS IN THE SOFTWARE.
*/ */
#include <sys/stat.h>
#include <errno.h>
#include "miniz.h"
#include "zip.h" #include "zip.h"
#include "miniz.h"
#include <errno.h>
#include <sys/stat.h>
#if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__ #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
/* Win32, OS/2, DOS */ /* Win32, OS/2, DOS */
#define HAS_DEVICE(P) ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) && (P)[1] == ':') #define HAS_DEVICE(P) \
#define FILESYSTEM_PREFIX_LEN(P) (HAS_DEVICE (P) ? 2 : 0) ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) && \
(P)[1] == ':')
#define FILESYSTEM_PREFIX_LEN(P) (HAS_DEVICE(P) ? 2 : 0)
#define ISSLASH(C) ((C) == '/' || (C) == '\\') #define ISSLASH(C) ((C) == '/' || (C) == '\\')
#endif #endif
@ -28,12 +31,18 @@
#define ISSLASH(C) ((C) == '/') #define ISSLASH(C) ((C) == '/')
#endif #endif
#define cleanup(ptr) do { if (ptr) { free((void *)ptr); ptr = NULL; } } while (0) #define cleanup(ptr) \
do { \
if (ptr) { \
free((void *)ptr); \
ptr = NULL; \
} \
} while (0)
#define strclone(ptr) ((ptr) ? strdup(ptr) : NULL) #define strclone(ptr) ((ptr) ? strdup(ptr) : NULL)
static char *basename(const char *name) { static char *basename(const char *name) {
char const *p; char const *p;
char const *base = name += FILESYSTEM_PREFIX_LEN (name); char const *base = name += FILESYSTEM_PREFIX_LEN(name);
int all_slashes = 1; int all_slashes = 1;
for (p = name; *p; p++) { for (p = name; *p; p++) {
@ -44,8 +53,7 @@ static char *basename(const char *name) {
} }
/* If NAME is all slashes, arrange to return `/'. */ /* If NAME is all slashes, arrange to return `/'. */
if (*base == '\0' && ISSLASH(*name) && all_slashes) if (*base == '\0' && ISSLASH(*name) && all_slashes) --base;
--base;
return (char *)base; return (char *)base;
} }
@ -53,7 +61,7 @@ static char *basename(const char *name) {
static int mkpath(const char *path) { static int mkpath(const char *path) {
const int mode = 0755; const int mode = 0755;
char const *p; char const *p;
char npath[MAX_PATH + 1] = { 0 }; char npath[MAX_PATH + 1] = {0};
int len = 0; int len = 0;
for (p = path; *p && len < MAX_PATH; p++) { for (p = path; *p && len < MAX_PATH; p++) {
@ -107,7 +115,9 @@ struct zip_t *zip_open(const char *zipname, int level, int append) {
if (append && MZ_FILE_STAT(zipname, &fstat) == 0) { if (append && MZ_FILE_STAT(zipname, &fstat) == 0) {
// Append to an existing archive. // Append to an existing archive.
if (!mz_zip_reader_init_file(&(zip->archive), zipname, level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) { if (!mz_zip_reader_init_file(
&(zip->archive), zipname,
level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
cleanup(zip); cleanup(zip);
return NULL; return NULL;
} }
@ -132,7 +142,8 @@ struct zip_t *zip_open(const char *zipname, int level, int append) {
void zip_close(struct zip_t *zip) { void zip_close(struct zip_t *zip) {
if (zip) { if (zip) {
// Always finalize, even if adding failed for some reason, so we have a valid central directory. // Always finalize, even if adding failed for some reason, so we have a
// valid central directory.
mz_zip_writer_finalize_archive(&(zip->archive)); mz_zip_writer_finalize_archive(&(zip->archive));
mz_zip_writer_end(&(zip->archive)); mz_zip_writer_end(&(zip->archive));
@ -165,11 +176,13 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
zip->entry.uncomp_crc32 = MZ_CRC32_INIT; zip->entry.uncomp_crc32 = MZ_CRC32_INIT;
zip->entry.offset = zip->archive.m_archive_size; zip->entry.offset = zip->archive.m_archive_size;
zip->entry.header_offset = zip->archive.m_archive_size; zip->entry.header_offset = zip->archive.m_archive_size;
memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8)); memset(zip->entry.header, 0,
MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8));
zip->entry.method = 0; zip->entry.method = 0;
pzip = &(zip->archive); pzip = &(zip->archive);
num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pzip); num_alignment_padding_bytes =
mz_zip_writer_compute_padding_needed_for_file_alignment(pzip);
if (!pzip->m_pState || (pzip->m_zip_mode != MZ_ZIP_MODE_WRITING)) { if (!pzip->m_pState || (pzip->m_zip_mode != MZ_ZIP_MODE_WRITING)) {
// Wrong zip mode // Wrong zip mode
@ -180,20 +193,30 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
return -1; return -1;
} }
// no zip64 support yet // no zip64 support yet
if ((pzip->m_total_files == 0xFFFF) || ((pzip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + entrylen) > 0xFFFFFFFF)) { if ((pzip->m_total_files == 0xFFFF) ||
((pzip->m_archive_size + num_alignment_padding_bytes +
MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
entrylen) > 0xFFFFFFFF)) {
// No zip64 support yet // No zip64 support yet
return -1; return -1;
} }
if (!mz_zip_writer_write_zeros(pzip, zip->entry.offset, num_alignment_padding_bytes + sizeof(zip->entry.header))) { if (!mz_zip_writer_write_zeros(
pzip, zip->entry.offset,
num_alignment_padding_bytes + sizeof(zip->entry.header))) {
// Cannot memset zip entry header // Cannot memset zip entry header
return -1; return -1;
} }
zip->entry.header_offset += num_alignment_padding_bytes; zip->entry.header_offset += num_alignment_padding_bytes;
if (pzip->m_file_offset_alignment) { MZ_ASSERT((zip->entry.header_offset & (pzip->m_file_offset_alignment - 1)) == 0); } if (pzip->m_file_offset_alignment) {
zip->entry.offset += num_alignment_padding_bytes + sizeof(zip->entry.header); MZ_ASSERT((zip->entry.header_offset &
(pzip->m_file_offset_alignment - 1)) == 0);
}
zip->entry.offset +=
num_alignment_padding_bytes + sizeof(zip->entry.header);
if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, zip->entry.name, entrylen) != entrylen) { if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, zip->entry.name,
entrylen) != entrylen) {
// Cannot write data to zip entry // Cannot write data to zip entry
return -1; return -1;
} }
@ -205,7 +228,11 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
zip->entry.state.m_cur_archive_file_ofs = zip->entry.offset; zip->entry.state.m_cur_archive_file_ofs = zip->entry.offset;
zip->entry.state.m_comp_size = 0; zip->entry.state.m_comp_size = 0;
if (tdefl_init(&(zip->entry.comp), mz_zip_writer_add_put_buf_callback, &(zip->entry.state), tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) { if (tdefl_init(&(zip->entry.comp), mz_zip_writer_add_put_buf_callback,
&(zip->entry.state),
tdefl_create_comp_flags_from_zip_params(
level, -15, MZ_DEFAULT_STRATEGY)) !=
TDEFL_STATUS_OKAY) {
// Cannot initialize the zip compressor // Cannot initialize the zip compressor
return -1; return -1;
} }
@ -245,29 +272,41 @@ int zip_entry_close(struct zip_t *zip) {
entrylen = (mz_uint16)strlen(zip->entry.name); entrylen = (mz_uint16)strlen(zip->entry.name);
t = time(NULL); t = time(NULL);
tm = localtime(&t); tm = localtime(&t);
dos_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1)); dos_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) +
dos_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday); ((tm->tm_sec) >> 1));
dos_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) +
((tm->tm_mon + 1) << 5) + tm->tm_mday);
// no zip64 support yet // no zip64 support yet
if ((zip->entry.comp_size > 0xFFFFFFFF) || (zip->entry.offset > 0xFFFFFFFF)) { if ((zip->entry.comp_size > 0xFFFFFFFF) ||
(zip->entry.offset > 0xFFFFFFFF)) {
// No zip64 support, yet // No zip64 support, yet
cleanup(zip->entry.name); cleanup(zip->entry.name);
return -1; return -1;
} }
if (!mz_zip_writer_create_local_dir_header(pzip, zip->entry.header, entrylen, 0, zip->entry.uncomp_size, zip->entry.comp_size, zip->entry.uncomp_crc32, zip->entry.method, 0, dos_time, dos_date)) { if (!mz_zip_writer_create_local_dir_header(
pzip, zip->entry.header, entrylen, 0, zip->entry.uncomp_size,
zip->entry.comp_size, zip->entry.uncomp_crc32, zip->entry.method, 0,
dos_time, dos_date)) {
// Cannot create zip entry header // Cannot create zip entry header
cleanup(zip->entry.name); cleanup(zip->entry.name);
return -1; return -1;
} }
if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset, zip->entry.header, sizeof(zip->entry.header)) != sizeof(zip->entry.header)) { if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset,
zip->entry.header, sizeof(zip->entry.header)) !=
sizeof(zip->entry.header)) {
// Cannot write zip entry header // Cannot write zip entry header
cleanup(zip->entry.name); cleanup(zip->entry.name);
return -1; return -1;
} }
if (!mz_zip_writer_add_to_central_dir(pzip, zip->entry.name, entrylen, NULL, 0, "", 0, zip->entry.uncomp_size, zip->entry.comp_size, zip->entry.uncomp_crc32, zip->entry.method, 0, dos_time, dos_date, zip->entry.header_offset, 0)) { if (!mz_zip_writer_add_to_central_dir(
pzip, zip->entry.name, entrylen, NULL, 0, "", 0,
zip->entry.uncomp_size, zip->entry.comp_size,
zip->entry.uncomp_crc32, zip->entry.method, 0, dos_time, dos_date,
zip->entry.header_offset, 0)) {
// Cannot write to zip central dir // Cannot write to zip central dir
cleanup(zip->entry.name); cleanup(zip->entry.name);
return -1; return -1;
@ -293,18 +332,21 @@ int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
pzip = &(zip->archive); pzip = &(zip->archive);
if (buf && bufsize > 0) { if (buf && bufsize > 0) {
zip->entry.uncomp_size += bufsize; zip->entry.uncomp_size += bufsize;
zip->entry.uncomp_crc32 = (mz_uint32)mz_crc32(zip->entry.uncomp_crc32, (const mz_uint8 *)buf, bufsize); zip->entry.uncomp_crc32 = (mz_uint32)mz_crc32(
zip->entry.uncomp_crc32, (const mz_uint8 *)buf, bufsize);
level = zip->level & 0xF; level = zip->level & 0xF;
if (!level) { if (!level) {
if ((pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, buf, bufsize) != bufsize)) { if ((pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, buf,
bufsize) != bufsize)) {
// Cannot write buffer // Cannot write buffer
return -1; return -1;
} }
zip->entry.offset += bufsize; zip->entry.offset += bufsize;
zip->entry.comp_size += bufsize; zip->entry.comp_size += bufsize;
} else { } else {
status = tdefl_compress_buffer(&(zip->entry.comp), buf, bufsize, TDEFL_NO_FLUSH); status = tdefl_compress_buffer(&(zip->entry.comp), buf, bufsize,
TDEFL_NO_FLUSH);
if (status != TDEFL_STATUS_DONE && status != TDEFL_STATUS_OKAY) { if (status != TDEFL_STATUS_DONE && status != TDEFL_STATUS_OKAY) {
// Cannot compress buffer // Cannot compress buffer
return -1; return -1;
@ -319,7 +361,7 @@ int zip_entry_fwrite(struct zip_t *zip, const char *filename) {
int status = 0; int status = 0;
size_t n = 0; size_t n = 0;
FILE *stream = NULL; FILE *stream = NULL;
mz_uint8 buf[MZ_ZIP_MAX_IO_BUF_SIZE] = { 0 }; mz_uint8 buf[MZ_ZIP_MAX_IO_BUF_SIZE] = {0};
if (!zip) { if (!zip) {
// zip_t handler is not initialized // zip_t handler is not initialized
@ -332,7 +374,8 @@ int zip_entry_fwrite(struct zip_t *zip, const char *filename) {
return -1; return -1;
} }
while((n = fread(buf, sizeof(mz_uint8), MZ_ZIP_MAX_IO_BUF_SIZE, stream)) > 0) { while ((n = fread(buf, sizeof(mz_uint8), MZ_ZIP_MAX_IO_BUF_SIZE, stream)) >
0) {
if (zip_entry_write(zip, buf, n) < 0) { if (zip_entry_write(zip, buf, n) < 0) {
status = -1; status = -1;
break; break;
@ -371,7 +414,8 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
break; break;
} }
if (!mz_zip_writer_add_file(&zip_archive, basename(name), name, "", 0, ZIP_DEFAULT_COMPRESSION_LEVEL)) { if (!mz_zip_writer_add_file(&zip_archive, basename(name), name, "", 0,
ZIP_DEFAULT_COMPRESSION_LEVEL)) {
// Cannot add file to zip_archive // Cannot add file to zip_archive
status = -1; status = -1;
break; break;
@ -383,10 +427,11 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
return status; return status;
} }
int zip_extract(const char *zipname, const char *dir, int (* on_extract)(const char *filename, void *arg), void *arg) { int zip_extract(const char *zipname, const char *dir,
int (*on_extract)(const char *filename, void *arg), void *arg) {
int status = 0; int status = 0;
mz_uint i, n; mz_uint i, n;
char path[MAX_PATH + 1] = { 0 }; char path[MAX_PATH + 1] = {0};
mz_zip_archive zip_archive; mz_zip_archive zip_archive;
mz_zip_archive_file_stat info; mz_zip_archive_file_stat info;
size_t dirlen = 0; size_t dirlen = 0;
@ -414,7 +459,7 @@ int zip_extract(const char *zipname, const char *dir, int (* on_extract)(const c
} }
strcpy(path, dir); strcpy(path, dir);
if (!ISSLASH(path[dirlen -1])) { if (!ISSLASH(path[dirlen - 1])) {
#if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__ #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
path[dirlen] = '\\'; path[dirlen] = '\\';
#else #else
@ -459,6 +504,6 @@ int zip_extract(const char *zipname, const char *dir, int (* on_extract)(const c
status = -1; status = -1;
} }
finally: finally:
return status; return status;
} }