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 support for NTFS timestamps. #140

Browse Source 
Fixed reading cd while in write mode can cause cd to be prematurely written.
This commit is contained in:
Nathan Moinvaziri 2017-10-22 14:32:37 -07:00
parent a994e3f8c0
commit 9eab88e771
11 changed files with 366 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
README.md
View File

@ -40,6 +40,41 @@ cmake --build .
## Features
### Compression Methods
#### BZIP2
+ Requires ``cmake . -DUSE_BZIP2=ON`` or ``#define HAVE_BZIP2``
+ Requires [BZIP2](http://www.bzip.org/) library
#### LZMA
+ Requires ``cmake . -DUSE_LZMA=ON`` or ``#define HAVE_LZMA``
+ Requires [liblzma](https://tukaani.org/xz/) library
### Encryption
#### [WinZIP AES Encryption](http://www.winzip.com/aes_info.htm)
+ Requires ``cmake . -DUSE_AES=ON`` or ``#define HAVE_AES``
+ Requires [Brian Gladman's](https://github.com/BrianGladman/aes) AES library
When zipping with a password it will always use AES 256-bit encryption.
When unzipping it will use AES decryption only if necessary.
#### Disabling All Encryption
To disable encryption use the following cmake commands:
```
cmake . -DUSE_AES=OFF
cmake . -DUSE_CRYPT=OFF
```
### NTFS Timestamps
Support has been added for UTC modified, access, and creation dates.
### Streams
This library has been refactored around streams.
@ -119,37 +154,6 @@ The central directory is the only data stored in the .zip and doesn't follow dis
When unzipping it will automatically determine when in needs to cross disk boundaries.
### Compression Methods
#### BZIP2
+ Requires ``cmake . -DUSE_BZIP2=ON`` or ``#define HAVE_BZIP2``
+ Requires [BZIP2](http://www.bzip.org/) library
#### LZMA
+ Requires ``cmake . -DUSE_LZMA=ON`` or ``#define HAVE_LZMA``
+ Requires [liblzma](https://tukaani.org/xz/) library
### Encryption
#### [WinZIP AES Encryption](http://www.winzip.com/aes_info.htm)
+ Requires ``cmake . -DUSE_AES=ON`` or ``#define HAVE_AES``
+ Requires [Brian Gladman's](https://github.com/BrianGladman/aes) AES library
When zipping with a password it will always use AES 256-bit encryption.
When unzipping it will use AES decryption only if necessary.
#### Disabling All Encryption
To disable encryption use the following cmake commands:
```
cmake . -DUSE_AES=OFF
cmake . -DUSE_CRYPT=OFF
```
### Windows RT
+ Requires ``#define MZ_USING_WINRT_API``

12
src/minizip.c
View File

@ -117,7 +117,7 @@ int32_t minizip_add_file(void *handle, const char *path, const char *password, m
file_info.version_madeby = MZ_VERSION_MADEBY;
file_info.compression_method = options->compress_method;
file_info.filename = (const char *)filenameinzip;
file_info.filename = (char *)filenameinzip;
file_info.uncompressed_size = mz_file_get_size(path);
#ifdef HAVE_AES
@ -125,7 +125,8 @@ int32_t minizip_add_file(void *handle, const char *path, const char *password, m
file_info.aes_version = MZ_AES_VERSION;
#endif
mz_os_get_file_date(path, &file_info.dos_date);
mz_os_get_file_date(path, &file_info.modified_date, &file_info.accessed_date,
&file_info.creation_date);
// Add to zip
err = mz_zip_entry_write_open(handle, &file_info, options->compress_level, password);
@ -291,7 +292,7 @@ int32_t minizip_list(void *handle)
string_method = "Unknwn";
}
mz_dosdate_to_tm(file_info->dos_date, &tmu_date);
mz_zip_time_t_to_tm(file_info->modified_date, &tmu_date);
printf(" %7llu %6s%c %7llu %3u%% %2.2u-%2.2u-%2.2u %2.2u:%2.2u %8.8x %s\n",
file_info->uncompressed_size, string_method, crypt, file_info->compressed_size, ratio,
@ -338,7 +339,7 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const
return err;
}
match = filename = (char *)file_info->filename;
match = filename = file_info->filename;
while (*match != 0)
{
if ((*match == '/') || (*match == '\\'))
@ -453,7 +454,8 @@ int32_t minizip_extract_currentfile(void *handle, const char *destination, const
// Set the time of the file that has been unzipped
if (err == MZ_OK)
mz_os_set_file_date(out_path, file_info->dos_date);
mz_os_set_file_date(out_path, file_info->modified_date, file_info->accessed_date,
file_info->creation_date);
}
else
{

6
src/mz_compat.c
View File

@ -110,7 +110,7 @@ extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, cons
if (zipfi != NULL)
{
file_info.dos_date = zipfi->dos_date;
file_info.modified_date = mz_zip_dosdate_to_time_t(zipfi->dos_date);
file_info.external_fa = zipfi->external_fa;
file_info.internal_fa = zipfi->internal_fa;
}
@ -408,7 +408,7 @@ extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info
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->dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
pfile_info->crc = file_info->crc;
pfile_info->size_filename = file_info->filename_size;
@ -466,7 +466,7 @@ extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile
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->dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
pfile_info->crc = file_info->crc;
pfile_info->size_filename = file_info->filename_size;

75
src/mz_os.c
View File

@ -13,8 +13,6 @@
#include <stdint.h>
#include <string.h>
#include <time.h>
#include "mz.h"
#include "mz_strm.h"
@ -42,7 +40,7 @@ int64_t mz_file_get_size(const char *path)
{
void *stream = NULL;
int64_t size = 0;
mz_stream_os_create(&stream);
if (mz_stream_os_open(stream, path, MZ_STREAM_MODE_READ) == MZ_OK)
@ -107,77 +105,6 @@ int32_t mz_make_dir(const char *path)
/***************************************************************************/
int32_t mz_invalid_date(const struct tm *ptm)
{
#define datevalue_in_range(min, max, value) ((min) <= (value) && (value) <= (max))
return (!datevalue_in_range(0, 207, ptm->tm_year) ||
!datevalue_in_range(0, 11, ptm->tm_mon) ||
!datevalue_in_range(1, 31, ptm->tm_mday) ||
!datevalue_in_range(0, 23, ptm->tm_hour) ||
!datevalue_in_range(0, 59, ptm->tm_min) ||
!datevalue_in_range(0, 59, ptm->tm_sec));
#undef datevalue_in_range
}
// Conversion without validation
void mz_dosdate_to_raw_tm(uint64_t dos_date, struct tm *ptm)
{
uint64_t date = (uint64_t)(dos_date >> 16);
ptm->tm_mday = (uint16_t)(date & 0x1f);
ptm->tm_mon = (uint16_t)(((date & 0x1E0) / 0x20) - 1);
ptm->tm_year = (uint16_t)(((date & 0x0FE00) / 0x0200) + 80);
ptm->tm_hour = (uint16_t)((dos_date & 0xF800) / 0x800);
ptm->tm_min = (uint16_t)((dos_date & 0x7E0) / 0x20);
ptm->tm_sec = (uint16_t)(2 * (dos_date & 0x1f));
ptm->tm_isdst = -1;
}
int32_t mz_dosdate_to_tm(uint64_t dos_date, struct tm *ptm)
{
mz_dosdate_to_raw_tm(dos_date, ptm);
if (mz_invalid_date(ptm))
{
// Invalid date stored, so don't return it
memset(ptm, 0, sizeof(struct tm));
return -1;
}
return 0;
}
time_t mz_dosdate_to_time_t(uint64_t dos_date)
{
struct tm ptm;
mz_dosdate_to_raw_tm(dos_date, &ptm);
return mktime(&ptm);
}
uint32_t mz_tm_to_dosdate(const struct tm *ptm)
{
struct tm fixed_tm = { 0 };
// Years supported:
// [00, 79] (assumed to be between 2000 and 2079)
// [80, 207] (assumed to be between 1980 and 2107, typical output of old
// software that does 'year-1900' to get a double digit year)
// [1980, 2107] (due to the date format limitations, only years between 1980 and 2107 can be stored.)
memcpy(&fixed_tm, ptm, sizeof(struct tm));
if (fixed_tm.tm_year >= 1980) // range [1980, 2107]
fixed_tm.tm_year -= 1980;
else if (fixed_tm.tm_year >= 80) // range [80, 99]
fixed_tm.tm_year -= 80;
else // range [00, 79]
fixed_tm.tm_year += 20;
if (mz_invalid_date(ptm))
return 0;
return (uint32_t)(((fixed_tm.tm_mday) + (32 * (fixed_tm.tm_mon + 1)) + (512 * fixed_tm.tm_year)) << 16) |
((fixed_tm.tm_sec / 2) + (32 * fixed_tm.tm_min) + (2048 * (uint32_t)fixed_tm.tm_hour));
}
int32_t mz_path_combine(char *path, const char *join, int32_t max_path)
{
int32_t path_len = 0;

9
src/mz_os.h
View File

@ -40,15 +40,6 @@ int64_t mz_file_get_size(const char *path);
int32_t mz_make_dir(const char *path);
// Creates a directory recursively
int32_t mz_dosdate_to_tm(uint64_t dos_date, struct tm *ptm);
// Convert dos date/time format to struct tm
time_t mz_dosdate_to_time_t(uint64_t dos_date);
// Convert dos date/time format to time_t
uint32_t mz_tm_to_dosdate(const struct tm *ptm);
// Convert struct tm to dos date/time format
int32_t mz_path_combine(char *path, const char *join, int32_t max_path);
// Combines two paths

31
src/mz_os_posix.c
View File

@ -35,45 +35,54 @@ int32_t mz_posix_rand(uint8_t *buf, int32_t size)
return size;
}
int32_t mz_posix_get_file_date(const char *path, uint32_t *dos_date)
int32_t mz_posix_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date)
{
struct stat stat_info;
struct tm *filedate = NULL;
char *name = NULL;
size_t len = 0;
time_t tm_t = 0;
int32_t err = MZ_INTERNAL_ERROR;
memset(&stat_info, 0, sizeof(stat_info));
if (strcmp(path, "-") != 0)
{
size_t len = strlen(path);
char *name = (char *)malloc(len + 1);
// Not all systems allow stat'ing a file with / appended
len = strlen(path);
name = (char *)malloc(len + 1);
strncpy(name, path, len + 1);
name[len] = 0;
if (name[len - 1] == '/')
name[len - 1] = 0;
/* Not all systems allow stat'ing a file with / appended */
if (stat(name, &stat_info) == 0)
{
tm_t = stat_info.st_mtime;
if (modified_date != NULL)
*modified_date = stat_info.st_mtime;
if (accessed_date != NULL)
*accessed_date = stat_info.st_atime;
// Creation date not supported
if (creation_date != NULL)
*creation_date = 0;
err = MZ_OK;
}
free(name);
}
filedate = localtime(&tm_t);
*dos_date = mz_tm_to_dosdate(filedate);
return err;
}
int32_t mz_posix_set_file_date(const char *path, uint32_t dos_date)
int32_t mz_posix_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date)
{
struct utimbuf ut;
ut.actime = mz_dosdate_to_time_t(dos_date);
ut.modtime = mz_dosdate_to_time_t(dos_date);
ut.actime = accessed_date;
ut.modtime = modified_date;
// Creation date not supported
if (utime(path, &ut) != 0)
return MZ_INTERNAL_ERROR;

4
src/mz_os_posix.h
View File

@ -30,8 +30,8 @@ extern "C" {
/***************************************************************************/
int32_t mz_posix_rand(uint8_t *buf, int32_t size);
int32_t mz_posix_get_file_date(const char *path, uint32_t *dos_date);
int32_t mz_posix_set_file_date(const char *path, uint32_t dos_date);
int32_t mz_posix_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
int32_t mz_posix_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
int32_t mz_posix_make_dir(const char *path);
DIR* mz_posix_open_dir(const char *path);
struct

47
src/mz_os_win32.c
View File

@ -69,11 +69,26 @@ int32_t mz_win32_rand(uint8_t *buf, int32_t size)
return len;
}
int32_t mz_win32_get_file_date(const char *path, uint32_t *dos_date)
static void mz_win32_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_win32_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_win32_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date)
{
FILETIME ftm_local;
HANDLE handle = NULL;
WIN32_FIND_DATAW ff32;
HANDLE handle = NULL;
wchar_t *path_wide = NULL;
uint32_t path_wide_size = 0;
int32_t err = MZ_INTERNAL_ERROR;
@ -90,8 +105,13 @@ int32_t mz_win32_get_file_date(const char *path, uint32_t *dos_date)
if (handle != INVALID_HANDLE_VALUE)
{
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime), &ftm_local);
FileTimeToDosDateTime(&ftm_local, ((LPWORD)dos_date) + 1, ((LPWORD)dos_date) + 0);
if (modified_date != NULL)
mz_win32_file_to_unix_time(ff32.ftLastWriteTime, modified_date);
if (accessed_date != NULL)
mz_win32_file_to_unix_time(ff32.ftLastAccessTime, accessed_date);
if (creation_date != NULL)
mz_win32_file_to_unix_time(ff32.ftCreationTime, creation_date);
FindClose(handle);
err = MZ_OK;
}
@ -99,10 +119,10 @@ int32_t mz_win32_get_file_date(const char *path, uint32_t *dos_date)
return err;
}
int32_t mz_win32_set_file_date(const char *path, uint32_t dos_date)
int32_t mz_win32_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date)
{
HANDLE handle = NULL;
FILETIME ftm, ftm_local, ftm_create, ftm_access, ftm_modified;
FILETIME ftm_creation, ftm_accessed, ftm_modified;
wchar_t *path_wide = NULL;
uint32_t path_wide_size = 0;
int32_t err = MZ_OK;
@ -123,11 +143,16 @@ int32_t mz_win32_set_file_date(const char *path, uint32_t dos_date)
if (handle != INVALID_HANDLE_VALUE)
{
GetFileTime(handle, &ftm_create, &ftm_access, &ftm_modified);
DosDateTimeToFileTime((WORD)(dos_date >> 16), (WORD)dos_date, &ftm_local);
LocalFileTimeToFileTime(&ftm_local, &ftm);
GetFileTime(handle, &ftm_creation, &ftm_accessed, &ftm_modified);
if (SetFileTime(handle, &ftm, &ftm_access, &ftm) == 0)
if (modified_date != 0)
mz_win32_unix_to_file_time(modified_date, &ftm_modified);
if (accessed_date != 0)
mz_win32_unix_to_file_time(accessed_date, &ftm_accessed);
if (creation_date != 0)
mz_win32_unix_to_file_time(creation_date, &ftm_creation);
if (SetFileTime(handle, &ftm_creation, &ftm_accessed, &ftm_modified) == 0)
err = MZ_INTERNAL_ERROR;
CloseHandle(handle);

4
src/mz_os_win32.h
View File

@ -32,8 +32,8 @@ typedef void* DIR;
/***************************************************************************/
int32_t mz_win32_rand(uint8_t *buf, int32_t size);
int32_t mz_win32_get_file_date(const char *path, uint32_t *dos_date);
int32_t mz_win32_set_file_date(const char *path, uint32_t dos_date);
int32_t mz_win32_get_file_date(const char *path, time_t *modified_date, time_t *accessed_date, time_t *creation_date);
int32_t mz_win32_set_file_date(const char *path, time_t modified_date, time_t accessed_date, time_t creation_date);
int32_t mz_win32_make_dir(const char *path);
DIR* mz_win32_open_dir(const char *path);
struct

219
src/mz_zip.c
View File

@ -19,6 +19,7 @@
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include "zlib.h"
@ -56,6 +57,7 @@
#define MZ_ZIP_SIZE_LOCALHEADER (0x1e)
#define MZ_ZIP_EXTENSION_ZIP64 (0x0001)
#define MZ_ZIP_EXTENSION_NTFS (0x000a)
#define MZ_ZIP_EXTENSION_AES (0x9901)
/***************************************************************************/
@ -645,10 +647,16 @@ static int16_t mz_zip_entry_get_version_needed(int16_t zip64, mz_zip_file *file_
// Get info about the current file in the zip file
static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file *file_info, void *file_info_stream)
{
uint64_t ntfs_time = 0;
uint32_t reserved = 0;
uint32_t magic = 0;
uint32_t dos_date = 0;
uint32_t extra_pos = 0;
uint32_t extra_data_size_read = 0;
uint16_t extra_header_id = 0;
uint16_t extra_data_size = 0;
uint16_t ntfs_attrib_id = 0;
uint16_t ntfs_attrib_size = 0;
uint16_t value16 = 0;
uint32_t value32 = 0;
uint64_t value64 = 0;
@ -682,7 +690,10 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
if (err == MZ_OK)
err = mz_stream_read_uint16(stream, &file_info->compression_method);
if (err == MZ_OK)
err = mz_stream_read_uint32(stream, &file_info->dos_date);
{
err = mz_stream_read_uint32(stream, &dos_date);
file_info->modified_date = mz_zip_dosdate_to_time_t(dos_date);
}
if (err == MZ_OK)
err = mz_stream_read_uint32(stream, &file_info->crc);
if (err == MZ_OK)
@ -762,6 +773,42 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
if ((err == MZ_OK) && (file_info->disk_num_start == UINT32_MAX))
err = mz_stream_read_uint32(file_info_stream, &file_info->disk_num_start);
}
// NTFS extra field
else if (extra_header_id == MZ_ZIP_EXTENSION_NTFS)
{
err = mz_stream_read_uint32(file_info_stream, &reserved);
extra_data_size_read = 4;
while ((err == MZ_OK) && (extra_data_size_read < extra_data_size))
{
err = mz_stream_read_uint16(file_info_stream, &ntfs_attrib_id);
if (err == MZ_OK)
err = mz_stream_read_uint16(file_info_stream, &ntfs_attrib_size);
if (ntfs_attrib_id == 0x01 && ntfs_attrib_size >= 8)
{
err = mz_stream_read_uint64(file_info_stream, &ntfs_time);
mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->modified_date);
if ((err == MZ_OK) && (ntfs_attrib_size >= 16))
{
err = mz_stream_read_uint64(file_info_stream, &ntfs_time);
mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->accessed_date);
}
if ((err == MZ_OK) && (ntfs_attrib_size >= 24))
{
err = mz_stream_read_uint64(file_info_stream, &ntfs_time);
mz_zip_ntfs_to_unix_time(ntfs_time, &file_info->creation_date);
}
}
else
{
err = mz_stream_seek(file_info_stream, ntfs_attrib_size, MZ_STREAM_SEEK_CUR);
}
extra_data_size_read += ntfs_attrib_size + 4;
}
}
#ifdef HAVE_AES
// AES extra field
else if (extra_header_id == MZ_ZIP_EXTENSION_AES)
@ -813,8 +860,13 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_file *file_info)
{
struct tm *local_time = NULL;
uint64_t ntfs_time = 0;
uint32_t reserved = 0;
uint32_t dos_date = 0;
uint16_t extrafield_size = 0;
uint16_t extrafield_zip64_size = 0;
uint16_t extrafield_ntfs_size = 0;
uint16_t filename_size = 0;
uint16_t comment_size = 0;
uint8_t zip64 = 0;
@ -844,6 +896,21 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
if ((file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version))
extrafield_size += 4 + 7;
#endif
// NTFS timestamps
if (file_info->modified_date != 0)
extrafield_ntfs_size += 8;
if (file_info->accessed_date != 0)
extrafield_ntfs_size += 8;
if (file_info->creation_date != 0)
extrafield_ntfs_size += 8;
if (extrafield_ntfs_size > 4)
{
extrafield_ntfs_size += 4 + 4;
extrafield_size += 4;
extrafield_size += extrafield_ntfs_size;
}
file_info->version_needed = mz_zip_entry_get_version_needed(zip64, file_info);
@ -870,7 +937,10 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
err = mz_stream_write_uint16(stream, file_info->compression_method);
}
if (err == MZ_OK)
err = mz_stream_write_uint32(stream, file_info->dos_date);
{
dos_date = mz_zip_time_t_to_dos_date(file_info->modified_date);
err = mz_stream_write_uint32(stream, dos_date);
}
if (err == MZ_OK)
err = mz_stream_write_uint32(stream, file_info->crc); // crc
@ -939,7 +1009,34 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
if ((err == MZ_OK) && (file_info->disk_offset >= UINT32_MAX))
err = mz_stream_write_uint64(stream, file_info->disk_offset);
}
// Write NTFS timestamps
if ((err == MZ_OK) && (extrafield_ntfs_size > 0))
{
err = mz_stream_write_uint16(stream, MZ_ZIP_EXTENSION_NTFS);
if (err == MZ_OK)
err = mz_stream_write_uint16(stream, extrafield_ntfs_size);
if (err == MZ_OK)
err = mz_stream_write_uint32(stream, reserved);
if (err == MZ_OK)
err = mz_stream_write_uint16(stream, 0x01);
if (err == MZ_OK)
err = mz_stream_write_uint16(stream, extrafield_ntfs_size - 8);
if ((err == MZ_OK) && (file_info->modified_date != 0))
{
mz_zip_unix_to_ntfs_time(file_info->modified_date, &ntfs_time);
err = mz_stream_write_uint64(stream, ntfs_time);
}
if ((err == MZ_OK) && (file_info->accessed_date != 0))
{
mz_zip_unix_to_ntfs_time(file_info->accessed_date, &ntfs_time);
err = mz_stream_write_uint64(stream, ntfs_time);
}
if ((err == MZ_OK) && (file_info->creation_date != 0))
{
mz_zip_unix_to_ntfs_time(file_info->creation_date, &ntfs_time);
err = mz_stream_write_uint64(stream, ntfs_time);
}
}
#ifdef HAVE_AES
// Write AES extra info header to central directory
if ((err == MZ_OK) && (file_info->flag & MZ_ZIP_FLAG_ENCRYPTED) && (file_info->aes_version))
@ -1013,14 +1110,17 @@ static int32_t mz_zip_entry_open_int(void *handle, int16_t compression_method, i
#endif
{
#ifdef HAVE_CRYPT
uint32_t dos_date = 0;
uint8_t verify1 = 0;
uint8_t verify2 = 0;
// Info-ZIP modification to ZipCrypto format:
// If bit 3 of the general purpose bit flag is set, it uses high byte of 16-bit File Time.
verify1 = (uint8_t)((zip->file_info.dos_date >> 16) & 0xff);
verify2 = (uint8_t)((zip->file_info.dos_date >> 8) & 0xff);
dos_date = mz_zip_time_t_to_dos_date(zip->file_info.modified_date);
verify1 = (uint8_t)((dos_date >> 16) & 0xff);
verify2 = (uint8_t)((dos_date >> 8) & 0xff);
mz_stream_crypt_create(&zip->crypt_stream);
mz_stream_crypt_set_password(zip->crypt_stream, password);
@ -1340,7 +1440,7 @@ static int32_t mz_zip_goto_next_entry_int(void *handle)
zip->entry_scanned = 0;
mz_stream_set_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, -1);
mz_stream_set_prop_int64(zip->cd_stream, MZ_STREAM_PROP_DISK_NUMBER, -1);
err = mz_stream_seek(zip->cd_stream, zip->cd_current_pos, MZ_STREAM_SEEK_SET);
if (err == MZ_OK)
@ -1408,4 +1508,109 @@ extern int32_t ZEXPORT mz_zip_locate_entry(void *handle, const char *filename, m
}
return err;
}
}
/***************************************************************************/
static int32_t mz_zip_invalid_date(const struct tm *ptm)
{
#define datevalue_in_range(min, max, value) ((min) <= (value) && (value) <= (max))
return (!datevalue_in_range(0, 207, ptm->tm_year) ||
!datevalue_in_range(0, 11, ptm->tm_mon) ||
!datevalue_in_range(1, 31, ptm->tm_mday) ||
!datevalue_in_range(0, 23, ptm->tm_hour) ||
!datevalue_in_range(0, 59, ptm->tm_min) ||
!datevalue_in_range(0, 59, ptm->tm_sec));
#undef datevalue_in_range
}
static void mz_zip_dosdate_to_raw_tm(uint64_t dos_date, struct tm *ptm)
{
uint64_t date = (uint64_t)(dos_date >> 16);
ptm->tm_mday = (uint16_t)(date & 0x1f);
ptm->tm_mon = (uint16_t)(((date & 0x1E0) / 0x20) - 1);
ptm->tm_year = (uint16_t)(((date & 0x0FE00) / 0x0200) + 80);
ptm->tm_hour = (uint16_t)((dos_date & 0xF800) / 0x800);
ptm->tm_min = (uint16_t)((dos_date & 0x7E0) / 0x20);
ptm->tm_sec = (uint16_t)(2 * (dos_date & 0x1f));
ptm->tm_isdst = -1;
}
int32_t mz_zip_dosdate_to_tm(uint64_t dos_date, struct tm *ptm)
{
if (ptm == NULL)
return MZ_PARAM_ERROR;
mz_zip_dosdate_to_raw_tm(dos_date, ptm);
if (mz_zip_invalid_date(ptm))
{
// Invalid date stored, so don't return it
memset(ptm, 0, sizeof(struct tm));
return MZ_FORMAT_ERROR;
}
return MZ_OK;
}
time_t mz_zip_dosdate_to_time_t(uint64_t dos_date)
{
struct tm ptm;
mz_zip_dosdate_to_raw_tm(dos_date, &ptm);
return mktime(&ptm);
}
int32_t mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm)
{
if (ptm == NULL)
return MZ_PARAM_ERROR;
memcpy(ptm, localtime(&unix_time), sizeof(struct tm));
return MZ_OK;
}
uint32_t mz_zip_time_t_to_dos_date(time_t unix_time)
{
struct tm ptm;
mz_zip_time_t_to_tm(unix_time, &ptm);
return mz_zip_tm_to_dosdate((const struct tm *)&ptm);
}
uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm)
{
struct tm fixed_tm = { 0 };
uint32_t dos_date = 0;
// Years supported:
// [00, 79] (assumed to be between 2000 and 2079)
// [80, 207] (assumed to be between 1980 and 2107, typical output of old
// software that does 'year-1900' to get a double digit year)
// [1980, 2107] (due to format limitations, only years 1980-2107 can be stored.)
memcpy(&fixed_tm, ptm, sizeof(struct tm));
if (fixed_tm.tm_year >= 1980) // range [1980, 2107]
fixed_tm.tm_year -= 1980;
else if (fixed_tm.tm_year >= 80) // range [80, 99]
fixed_tm.tm_year -= 80;
else // range [00, 79]
fixed_tm.tm_year += 20;
if (mz_zip_invalid_date(ptm))
return 0;
return (uint32_t)(((fixed_tm.tm_mday) + (32 * (fixed_tm.tm_mon + 1)) + (512 * fixed_tm.tm_year)) << 16) |
((fixed_tm.tm_sec / 2) + (32 * fixed_tm.tm_min) + (2048 * (uint32_t)fixed_tm.tm_hour));
}
int32_t mz_zip_ntfs_to_unix_time(uint64_t ntfs_time, time_t *unix_time)
{
*unix_time = (time_t)((ntfs_time - 116444736000000000LL) / 10000000);
return MZ_OK;
}
int32_t mz_zip_unix_to_ntfs_time(time_t unix_time, uint64_t *ntfs_time)
{
*ntfs_time = ((uint64_t)unix_time * 10000000) + 116444736000000000LL;
return MZ_OK;
}

84
src/mz_zip.h
View File

@ -31,27 +31,29 @@ extern "C" {
typedef struct mz_zip_file_s
{
uint16_t version_madeby; // 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 filename_size; // filename length 2 bytes
uint16_t extrafield_size; // extra field length 2 bytes
uint16_t comment_size; // file comment length 2 bytes
uint16_t version_madeby; // version made by
uint16_t version_needed; // version needed to extract
uint16_t flag; // general purpose bit flag
uint16_t compression_method; // compression method
time_t modified_date; // last modified date in unix time
time_t accessed_date; // last accessed date in unix time
time_t creation_date; // creation date in unix time
uint32_t crc; // crc-32
uint64_t compressed_size; // compressed size
uint64_t uncompressed_size; // uncompressed size
uint16_t filename_size; // filename length
uint16_t extrafield_size; // extra field length
uint16_t comment_size; // file comment length
uint32_t disk_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
uint32_t disk_num_start; // disk number start
uint16_t internal_fa; // internal file attributes
uint32_t external_fa; // external file attributes
uint64_t disk_offset; // relative offset of local header 8 bytes
uint64_t disk_offset; // relative offset of local header
const char *filename; // filename string
const uint8_t *extrafield; // extrafield data
const char *comment; // comment string
char *filename; // filename string
uint8_t *extrafield; // extrafield data
char *comment; // comment string
#ifdef HAVE_AES
uint16_t aes_version; // winzip aes extension if not 0
@ -62,11 +64,7 @@ typedef struct mz_zip_file_s
/***************************************************************************/
extern void * ZEXPORT mz_zip_open(void *stream, int32_t mode);
// Create a zip file
//
// NOTE: There is no delete function into a zip file. If you want delete file in a
// zip file, you must open a zip file, and create another. You can use RAW reading
// and writing to copy the file you did not want delete.
// Create a zip file, no delete file in zip functionality
extern int32_t ZEXPORT mz_zip_close(void *handle);
// Close the zip file
@ -97,14 +95,10 @@ extern int32_t ZEXPORT mz_zip_entry_read(void *handle, void *buf, uint32_t len);
// Read bytes from the current file in the zip file
extern int32_t ZEXPORT mz_zip_entry_get_info(void *handle, mz_zip_file **file_info);
// Get info about the current file
//
// NOTE: The file info is only valid while the current entry is open.
// Get info about the current file, only valid while current entry is open
extern int32_t ZEXPORT mz_zip_entry_get_local_info(void *handle, mz_zip_file **local_file_info);
// Get local info about the current file
//
// NOTE: The local file info is only valid while the current entry is being read.
// Get local info about the current file, only valid while current entry is being read
extern int32_t ZEXPORT mz_zip_entry_close_raw(void *handle, uint64_t uncompressed_size, uint32_t crc32);
// Close the current file in the zip file where raw is compressed data
@ -124,14 +118,32 @@ extern int32_t ZEXPORT mz_zip_goto_next_entry(void *handle);
// Go to the next entry in the zip file or MZ_END_OF_LIST if reaching the end
typedef int32_t (*mz_filename_compare_cb)(void *handle, const char *filename1, const char *filename2);
extern int32_t ZEXPORT mz_zip_locate_entry(void *handle, const char *filename,
mz_filename_compare_cb filename_compare_cb);
// Locate the file with the specified name in the zip file or MZ_END_LIST if not found
extern int32_t ZEXPORT mz_zip_locate_entry(void *handle, const char *filename, mz_filename_compare_cb filename_compare_cb);
// Locate the file with the specified name in the zip file
//
// NOTE: if filename_compare_cb == NULL, it uses strcmp
//
// return MZ_OK if the file is found (it becomes the current file)
// return MZ_END_OF_LIST if the file is not found
/***************************************************************************/
int32_t mz_zip_dosdate_to_tm(uint64_t dos_date, struct tm *ptm);
// Convert dos date/time format to struct tm
time_t mz_zip_dosdate_to_time_t(uint64_t dos_date);
// Convert dos date/time format to time_t
int32_t mz_zip_time_t_to_tm(time_t unix_time, struct tm *ptm);
// Convert time_t to time struct
uint32_t mz_zip_time_t_to_dos_date(time_t unix_time);
// Convert time_t to dos date/time format
uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm);
// Convert struct tm to dos date/time format
int32_t mz_zip_ntfs_to_unix_time(uint64_t ntfs_time, time_t *unix_time);
// Convert ntfs time to unix time
int32_t mz_zip_unix_to_ntfs_time(time_t unix_time, uint64_t *ntfs_time);
// Convert unix time to ntfs time
/***************************************************************************/