Update zip library to current head. Closes assimp/assimp#2388
parent
a43ac5b3fd
commit
bb11f90983
|
@ -36,3 +36,21 @@
|
||||||
# Temporary
|
# Temporary
|
||||||
*.swp
|
*.swp
|
||||||
.DS_Store
|
.DS_Store
|
||||||
|
|
||||||
|
# CMake
|
||||||
|
CMakeScripts
|
||||||
|
*.cmake
|
||||||
|
|
||||||
|
# Xcode
|
||||||
|
*.build
|
||||||
|
*.xcodeproj
|
||||||
|
zip.sln
|
||||||
|
zip.vcxproj.filters
|
||||||
|
zip.vcxproj
|
||||||
|
ALL_BUILD.vcxproj.filters
|
||||||
|
ALL_BUILD.vcxproj
|
||||||
|
CMakeFiles/
|
||||||
|
zip.dir/
|
||||||
|
test/test.exe.vcxproj.filters
|
||||||
|
test/test.exe.vcxproj
|
||||||
|
test/test.exe.dir/
|
||||||
|
|
|
@ -0,0 +1,18 @@
|
||||||
|
#!/bin/bash
|
||||||
|
#
|
||||||
|
# Build script for travis-ci.org builds.
|
||||||
|
#
|
||||||
|
if [ $ANALYZE = "true" ] && [ "$CC" = "clang" ]; then
|
||||||
|
# scan-build -h
|
||||||
|
scan-build cmake -G "Unix Makefiles"
|
||||||
|
scan-build -enable-checker security.FloatLoopCounter \
|
||||||
|
-enable-checker security.insecureAPI.UncheckedReturn \
|
||||||
|
--status-bugs -v \
|
||||||
|
make -j 8 \
|
||||||
|
make -j 8 test
|
||||||
|
else
|
||||||
|
cmake -DCMAKE_BUILD_TYPE=Debug -DSANITIZE_ADDRESS=On -DCMAKE_INSTALL_PREFIX=_install
|
||||||
|
make -j 8
|
||||||
|
make install
|
||||||
|
ASAN_OPTIONS=detect_leaks=0 LSAN_OPTIONS=verbosity=1:log_threads=1 ctest -V
|
||||||
|
fi
|
|
@ -1,10 +1,22 @@
|
||||||
language: c
|
language: c
|
||||||
|
addons:
|
||||||
|
apt:
|
||||||
|
packages: &1
|
||||||
|
- lcov
|
||||||
# Compiler selection
|
# Compiler selection
|
||||||
compiler:
|
compiler:
|
||||||
- clang
|
- clang
|
||||||
- gcc
|
- gcc
|
||||||
|
env:
|
||||||
|
- ANALYZE=false
|
||||||
|
- ANALYZE=true
|
||||||
# Build steps
|
# Build steps
|
||||||
script:
|
script:
|
||||||
- mkdir build
|
- ./.travis.sh
|
||||||
- cd build
|
after_success:
|
||||||
- cmake -DCMAKE_BUILD_TYPE=Debug .. && make && make test
|
# Creating report
|
||||||
|
- cmake -DENABLE_COVERAGE=ON
|
||||||
|
- make
|
||||||
|
- make test
|
||||||
|
# Uploading report to CodeCov
|
||||||
|
- bash <(curl -s https://codecov.io/bash)
|
|
@ -1,18 +1,47 @@
|
||||||
cmake_minimum_required(VERSION 2.8)
|
cmake_minimum_required(VERSION 2.8)
|
||||||
project(zip)
|
project(zip)
|
||||||
|
enable_language(C)
|
||||||
|
set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
|
||||||
|
|
||||||
if (MSVC)
|
if (MSVC)
|
||||||
# Use secure functions by defaualt and suppress warnings about "deprecated" functions
|
# Use secure functions by defaualt and suppress warnings about "deprecated" functions
|
||||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1")
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1")
|
||||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1")
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1")
|
||||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1")
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _CRT_NONSTDC_NO_WARNINGS=1 /D _CRT_SECURE_NO_WARNINGS=1")
|
||||||
|
elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
|
||||||
|
"${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
|
||||||
|
"${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
|
||||||
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror -pedantic")
|
||||||
endif (MSVC)
|
endif (MSVC)
|
||||||
|
|
||||||
# zip
|
# zip
|
||||||
set(SRC src/miniz.h src/zip.h src/zip.c)
|
set(SRC src/miniz.h src/zip.h src/zip.c)
|
||||||
add_library(${CMAKE_PROJECT_NAME} ${SRC})
|
add_library(${PROJECT_NAME} ${SRC})
|
||||||
|
target_include_directories(${PROJECT_NAME} INTERFACE src)
|
||||||
|
|
||||||
# test
|
# test
|
||||||
|
if (NOT CMAKE_DISABLE_TESTING)
|
||||||
enable_testing()
|
enable_testing()
|
||||||
add_subdirectory(test)
|
add_subdirectory(test)
|
||||||
|
find_package(Sanitizers)
|
||||||
|
add_sanitizers(${PROJECT_NAME} test.exe)
|
||||||
|
add_sanitizers(${PROJECT_NAME} test_miniz.exe)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
install(TARGETS ${PROJECT_NAME}
|
||||||
|
RUNTIME DESTINATION bin
|
||||||
|
ARCHIVE DESTINATION lib
|
||||||
|
LIBRARY DESTINATION lib
|
||||||
|
COMPONENT library)
|
||||||
|
install(FILES ${PROJECT_SOURCE_DIR}/src/zip.h DESTINATION include)
|
||||||
|
|
||||||
|
# uninstall target (https://gitlab.kitware.com/cmake/community/wikis/FAQ#can-i-do-make-uninstall-with-cmake)
|
||||||
|
if(NOT TARGET uninstall)
|
||||||
|
configure_file(
|
||||||
|
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
|
||||||
|
"${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake"
|
||||||
|
IMMEDIATE @ONLY)
|
||||||
|
|
||||||
|
add_custom_target(uninstall
|
||||||
|
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake)
|
||||||
|
endif()
|
||||||
|
|
|
@ -1,12 +1,11 @@
|
||||||
### A portable (OSX/Linux/Windows), simple zip library written in C
|
### A portable (OSX/Linux/Windows), simple zip library written in C
|
||||||
This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API.
|
This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API.
|
||||||
|
|
||||||
[![Windows][win-badge]][win-link] [![OS X][osx-linux-badge]][osx-linux-link]
|
[![Windows](https://ci.appveyor.com/api/projects/status/bph8dr3jacgmjv32/branch/master?svg=true&label=windows)](https://ci.appveyor.com/project/kuba--/zip)
|
||||||
|
[![Linux](https://travis-ci.org/kuba--/zip.svg?branch=master&label=linux%2fosx)](https://travis-ci.org/kuba--/zip)
|
||||||
|
[![Version](https://badge.fury.io/gh/kuba--%2Fzip.svg)](https://github.com/kuba--/zip/releases)
|
||||||
|
[![Codecov](https://codecov.io/gh/kuba--/zip/branch/master/graph/badge.svg)](https://codecov.io/gh/kuba--/zip)
|
||||||
|
|
||||||
[win-badge]: https://img.shields.io/appveyor/ci/kuba--/zip/master.svg?label=windows "AppVeyor build status"
|
|
||||||
[win-link]: https://ci.appveyor.com/project/kuba--/zip "AppVeyor build status"
|
|
||||||
[osx-linux-badge]: https://img.shields.io/travis/kuba--/zip/master.svg?label=linux/osx "Travis CI build status"
|
|
||||||
[osx-linux-link]: https://travis-ci.org/kuba--/zip "Travis CI build status"
|
|
||||||
|
|
||||||
# The Idea
|
# The Idea
|
||||||
<img src="zip.png" name="zip" />
|
<img src="zip.png" name="zip" />
|
||||||
|
@ -27,7 +26,7 @@ It was the reason, why I decided to write zip module on top of the miniz. It req
|
||||||
{
|
{
|
||||||
zip_entry_open(zip, "foo-1.txt");
|
zip_entry_open(zip, "foo-1.txt");
|
||||||
{
|
{
|
||||||
char *buf = "Some data here...";
|
const char *buf = "Some data here...\0";
|
||||||
zip_entry_write(zip, buf, strlen(buf));
|
zip_entry_write(zip, buf, strlen(buf));
|
||||||
}
|
}
|
||||||
zip_entry_close(zip);
|
zip_entry_close(zip);
|
||||||
|
@ -50,7 +49,7 @@ It was the reason, why I decided to write zip module on top of the miniz. It req
|
||||||
{
|
{
|
||||||
zip_entry_open(zip, "foo-3.txt");
|
zip_entry_open(zip, "foo-3.txt");
|
||||||
{
|
{
|
||||||
char *buf = "Append some data here...";
|
const char *buf = "Append some data here...\0";
|
||||||
zip_entry_write(zip, buf, strlen(buf));
|
zip_entry_write(zip, buf, strlen(buf));
|
||||||
}
|
}
|
||||||
zip_entry_close(zip);
|
zip_entry_close(zip);
|
||||||
|
@ -90,6 +89,27 @@ It was the reason, why I decided to write zip module on top of the miniz. It req
|
||||||
free(buf);
|
free(buf);
|
||||||
```
|
```
|
||||||
|
|
||||||
|
* Extract a zip entry into memory (no internal allocation).
|
||||||
|
```c
|
||||||
|
unsigned char *buf;
|
||||||
|
size_t bufsize;
|
||||||
|
|
||||||
|
struct zip_t *zip = zip_open("foo.zip", 0, 'r');
|
||||||
|
{
|
||||||
|
zip_entry_open(zip, "foo-1.txt");
|
||||||
|
{
|
||||||
|
bufsize = zip_entry_size(zip);
|
||||||
|
buf = calloc(sizeof(unsigned char), bufsize);
|
||||||
|
|
||||||
|
zip_entry_noallocread(zip, (void *)buf, bufsize);
|
||||||
|
}
|
||||||
|
zip_entry_close(zip);
|
||||||
|
}
|
||||||
|
zip_close(zip);
|
||||||
|
|
||||||
|
free(buf);
|
||||||
|
```
|
||||||
|
|
||||||
* Extract a zip entry into memory using callback.
|
* Extract a zip entry into memory using callback.
|
||||||
```c
|
```c
|
||||||
struct buffer_t {
|
struct buffer_t {
|
||||||
|
@ -137,3 +157,153 @@ It was the reason, why I decided to write zip module on top of the miniz. It req
|
||||||
zip_close(zip);
|
zip_close(zip);
|
||||||
```
|
```
|
||||||
|
|
||||||
|
* List of all zip entries
|
||||||
|
```c
|
||||||
|
struct zip_t *zip = zip_open("foo.zip", 0, 'r');
|
||||||
|
int i, n = zip_total_entries(zip);
|
||||||
|
for (i = 0; i < n; ++i) {
|
||||||
|
zip_entry_openbyindex(zip, i);
|
||||||
|
{
|
||||||
|
const char *name = zip_entry_name(zip);
|
||||||
|
int isdir = zip_entry_isdir(zip);
|
||||||
|
unsigned long long size = zip_entry_size(zip);
|
||||||
|
unsigned int crc32 = zip_entry_crc32(zip);
|
||||||
|
}
|
||||||
|
zip_entry_close(zip);
|
||||||
|
}
|
||||||
|
zip_close(zip);
|
||||||
|
```
|
||||||
|
|
||||||
|
# Bindings
|
||||||
|
Compile zip library as a dynamic library.
|
||||||
|
```shell
|
||||||
|
$ mkdir build
|
||||||
|
$ cd build
|
||||||
|
$ cmake -DBUILD_SHARED_LIBS=true ..
|
||||||
|
$ make
|
||||||
|
```
|
||||||
|
|
||||||
|
### Go (cgo)
|
||||||
|
```go
|
||||||
|
package main
|
||||||
|
|
||||||
|
/*
|
||||||
|
#cgo CFLAGS: -I../src
|
||||||
|
#cgo LDFLAGS: -L. -lzip
|
||||||
|
#include <zip.h>
|
||||||
|
*/
|
||||||
|
import "C"
|
||||||
|
import "unsafe"
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
path := C.CString("/tmp/go.zip")
|
||||||
|
zip := C.zip_open(path, 6, 'w')
|
||||||
|
|
||||||
|
entryname := C.CString("test")
|
||||||
|
C.zip_entry_open(zip, entryname)
|
||||||
|
|
||||||
|
content := "test content"
|
||||||
|
buf := unsafe.Pointer(C.CString(content))
|
||||||
|
bufsize := C.size_t(len(content))
|
||||||
|
C.zip_entry_write(zip, buf, bufsize)
|
||||||
|
|
||||||
|
C.zip_entry_close(zip)
|
||||||
|
|
||||||
|
C.zip_close(zip)
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### Ruby (ffi)
|
||||||
|
Install _ffi_ gem.
|
||||||
|
```shell
|
||||||
|
$ gem install ffi
|
||||||
|
```
|
||||||
|
|
||||||
|
Bind in your module.
|
||||||
|
```ruby
|
||||||
|
require 'ffi'
|
||||||
|
|
||||||
|
module Zip
|
||||||
|
extend FFI::Library
|
||||||
|
ffi_lib "./libzip.#{::FFI::Platform::LIBSUFFIX}"
|
||||||
|
|
||||||
|
attach_function :zip_open, [:string, :int, :char], :pointer
|
||||||
|
attach_function :zip_close, [:pointer], :void
|
||||||
|
|
||||||
|
attach_function :zip_entry_open, [:pointer, :string], :int
|
||||||
|
attach_function :zip_entry_close, [:pointer], :void
|
||||||
|
attach_function :zip_entry_write, [:pointer, :string, :int], :int
|
||||||
|
end
|
||||||
|
|
||||||
|
ptr = Zip.zip_open("/tmp/ruby.zip", 6, "w".bytes()[0])
|
||||||
|
|
||||||
|
status = Zip.zip_entry_open(ptr, "test")
|
||||||
|
|
||||||
|
content = "test content"
|
||||||
|
status = Zip.zip_entry_write(ptr, content, content.size())
|
||||||
|
|
||||||
|
Zip.zip_entry_close(ptr)
|
||||||
|
Zip.zip_close(ptr)
|
||||||
|
```
|
||||||
|
|
||||||
|
### Python (cffi)
|
||||||
|
Install _cffi_ package
|
||||||
|
```shell
|
||||||
|
$ pip install cffi
|
||||||
|
```
|
||||||
|
|
||||||
|
Bind in your package.
|
||||||
|
```python
|
||||||
|
import ctypes.util
|
||||||
|
from cffi import FFI
|
||||||
|
|
||||||
|
ffi = FFI()
|
||||||
|
ffi.cdef("""
|
||||||
|
struct zip_t *zip_open(const char *zipname, int level, char mode);
|
||||||
|
void zip_close(struct zip_t *zip);
|
||||||
|
|
||||||
|
int zip_entry_open(struct zip_t *zip, const char *entryname);
|
||||||
|
int zip_entry_close(struct zip_t *zip);
|
||||||
|
int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize);
|
||||||
|
""")
|
||||||
|
|
||||||
|
Zip = ffi.dlopen(ctypes.util.find_library("zip"))
|
||||||
|
|
||||||
|
ptr = Zip.zip_open("/tmp/python.zip", 6, 'w')
|
||||||
|
|
||||||
|
status = Zip.zip_entry_open(ptr, "test")
|
||||||
|
|
||||||
|
content = "test content"
|
||||||
|
status = Zip.zip_entry_write(ptr, content, len(content))
|
||||||
|
|
||||||
|
Zip.zip_entry_close(ptr)
|
||||||
|
Zip.zip_close(ptr)
|
||||||
|
```
|
||||||
|
|
||||||
|
### Ring
|
||||||
|
The language comes with RingZip based on this library
|
||||||
|
```ring
|
||||||
|
load "ziplib.ring"
|
||||||
|
|
||||||
|
new Zip {
|
||||||
|
setFileName("myfile.zip")
|
||||||
|
open("w")
|
||||||
|
newEntry() {
|
||||||
|
open("test.c")
|
||||||
|
writefile("test.c")
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
close()
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
# Contribution Rules/Coding Standards
|
||||||
|
No need to throw away your coding style, just do your best to follow default clang-format style.
|
||||||
|
Apply `clang-format` to the source files before commit:
|
||||||
|
```sh
|
||||||
|
for file in $(git ls-files | \grep -E '\.(c|h)$' | \grep -v -- '#')
|
||||||
|
do
|
||||||
|
clang-format -i $file
|
||||||
|
done
|
||||||
|
```
|
||||||
|
|
||||||
|
|
|
@ -1,4 +1,4 @@
|
||||||
version: 1.0.{build}
|
version: zip-0.1.9.{build}
|
||||||
build_script:
|
build_script:
|
||||||
- cmd: >-
|
- cmd: >-
|
||||||
cd c:\projects\zip
|
cd c:\projects\zip
|
||||||
|
|
|
@ -0,0 +1,55 @@
|
||||||
|
#!/bin/sh
|
||||||
|
|
||||||
|
# The MIT License (MIT)
|
||||||
|
#
|
||||||
|
# Copyright (c)
|
||||||
|
# 2013 Matthew Arsenault
|
||||||
|
# 2015-2016 RWTH Aachen University, Federal Republic of Germany
|
||||||
|
#
|
||||||
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
# of this software and associated documentation files (the "Software"), to deal
|
||||||
|
# in the Software without restriction, including without limitation the rights
|
||||||
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
# copies of the Software, and to permit persons to whom the Software is
|
||||||
|
# furnished to do so, subject to the following conditions:
|
||||||
|
#
|
||||||
|
# The above copyright notice and this permission notice shall be included in all
|
||||||
|
# copies or substantial portions of the Software.
|
||||||
|
#
|
||||||
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
# SOFTWARE.
|
||||||
|
|
||||||
|
# This script is a wrapper for AddressSanitizer. In some special cases you need
|
||||||
|
# to preload AddressSanitizer to avoid error messages - e.g. if you're
|
||||||
|
# preloading another library to your application. At the moment this script will
|
||||||
|
# only do something, if we're running on a Linux platform. OSX might not be
|
||||||
|
# affected.
|
||||||
|
|
||||||
|
|
||||||
|
# Exit immediately, if platform is not Linux.
|
||||||
|
if [ "$(uname)" != "Linux" ]
|
||||||
|
then
|
||||||
|
exec $@
|
||||||
|
fi
|
||||||
|
|
||||||
|
|
||||||
|
# Get the used libasan of the application ($1). If a libasan was found, it will
|
||||||
|
# be prepended to LD_PRELOAD.
|
||||||
|
libasan=$(ldd $1 | grep libasan | sed "s/^[[:space:]]//" | cut -d' ' -f1)
|
||||||
|
if [ -n "$libasan" ]
|
||||||
|
then
|
||||||
|
if [ -n "$LD_PRELOAD" ]
|
||||||
|
then
|
||||||
|
export LD_PRELOAD="$libasan:$LD_PRELOAD"
|
||||||
|
else
|
||||||
|
export LD_PRELOAD="$libasan"
|
||||||
|
fi
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Execute the application.
|
||||||
|
exec $@
|
|
@ -0,0 +1,23 @@
|
||||||
|
# copied from https://gitlab.kitware.com/cmake/community/wikis/FAQ#can-i-do-make-uninstall-with-cmake
|
||||||
|
if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
|
||||||
|
message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
|
||||||
|
endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
|
||||||
|
|
||||||
|
file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
|
||||||
|
string(REGEX REPLACE "\n" ";" files "${files}")
|
||||||
|
foreach(file ${files})
|
||||||
|
message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
|
||||||
|
if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
|
||||||
|
exec_program(
|
||||||
|
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
|
||||||
|
OUTPUT_VARIABLE rm_out
|
||||||
|
RETURN_VALUE rm_retval
|
||||||
|
)
|
||||||
|
if(NOT "${rm_retval}" STREQUAL 0)
|
||||||
|
message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
|
||||||
|
endif(NOT "${rm_retval}" STREQUAL 0)
|
||||||
|
else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
|
||||||
|
message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
|
||||||
|
endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
|
||||||
|
endforeach(file)
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -7,16 +7,15 @@
|
||||||
* 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.
|
||||||
*/
|
*/
|
||||||
|
#define __STDC_WANT_LIB_EXT1__ 1
|
||||||
#include "zip.h"
|
|
||||||
#include "miniz.h"
|
|
||||||
|
|
||||||
#include <errno.h>
|
#include <errno.h>
|
||||||
#include <sys/stat.h>
|
#include <sys/stat.h>
|
||||||
#include <time.h>
|
#include <time.h>
|
||||||
|
|
||||||
#if defined _WIN32 || defined __WIN32__
|
#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) || \
|
||||||
/* Win32, DOS */
|
defined(__MINGW32__)
|
||||||
|
/* Win32, DOS, MSVC, MSVS */
|
||||||
#include <direct.h>
|
#include <direct.h>
|
||||||
|
|
||||||
#define MKDIR(DIRNAME) _mkdir(DIRNAME)
|
#define MKDIR(DIRNAME) _mkdir(DIRNAME)
|
||||||
|
@ -28,8 +27,20 @@
|
||||||
#define ISSLASH(C) ((C) == '/' || (C) == '\\')
|
#define ISSLASH(C) ((C) == '/' || (C) == '\\')
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
|
#include <unistd.h> // needed for symlink() on BSD
|
||||||
|
int symlink(const char *target, const char *linkpath); // needed on Linux
|
||||||
|
|
||||||
#define MKDIR(DIRNAME) mkdir(DIRNAME, 0755)
|
#define MKDIR(DIRNAME) mkdir(DIRNAME, 0755)
|
||||||
#define STRCLONE(STR) ((STR) ? strdup(STR) : NULL)
|
#define STRCLONE(STR) ((STR) ? strdup(STR) : NULL)
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include "miniz.h"
|
||||||
|
#include "zip.h"
|
||||||
|
|
||||||
|
#ifndef HAS_DEVICE
|
||||||
|
#define HAS_DEVICE(P) 0
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef FILESYSTEM_PREFIX_LEN
|
#ifndef FILESYSTEM_PREFIX_LEN
|
||||||
|
@ -48,7 +59,7 @@
|
||||||
} \
|
} \
|
||||||
} while (0)
|
} while (0)
|
||||||
|
|
||||||
static char *basename(const char *name) {
|
static const char *base_name(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;
|
||||||
|
@ -61,20 +72,30 @@ 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) --base;
|
if (*base == '\0' && ISSLASH(*name) && all_slashes)
|
||||||
|
--base;
|
||||||
|
|
||||||
return (char *)base;
|
return base;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int mkpath(const char *path) {
|
static int mkpath(const char *path) {
|
||||||
char const *p;
|
char const *p;
|
||||||
char npath[MAX_PATH + 1] = {0};
|
char npath[MAX_PATH + 1];
|
||||||
int len = 0;
|
int len = 0;
|
||||||
|
int has_device = HAS_DEVICE(path);
|
||||||
|
|
||||||
for (p = path; *p && len < MAX_PATH; p++) {
|
memset(npath, 0, MAX_PATH + 1);
|
||||||
if (ISSLASH(*p) && len > 0) {
|
if (has_device) {
|
||||||
|
// only on windows
|
||||||
|
npath[0] = path[0];
|
||||||
|
npath[1] = path[1];
|
||||||
|
len = 2;
|
||||||
|
}
|
||||||
|
for (p = path + len; *p && len < MAX_PATH; p++) {
|
||||||
|
if (ISSLASH(*p) && ((!has_device && len > 0) || (has_device && len > 2))) {
|
||||||
if (MKDIR(npath) == -1)
|
if (MKDIR(npath) == -1)
|
||||||
if (errno != EEXIST) return -1;
|
if (errno != EEXIST)
|
||||||
|
return -1;
|
||||||
}
|
}
|
||||||
npath[len++] = *p;
|
npath[len++] = *p;
|
||||||
}
|
}
|
||||||
|
@ -82,24 +103,28 @@ static int mkpath(const char *path) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static char *strrpl(const char *str, char oldchar, char newchar) {
|
static char *strrpl(const char *str, size_t n, char oldchar, char newchar) {
|
||||||
char *rpl = (char *)malloc(sizeof(char) * (1 + strlen(str)));
|
|
||||||
char *begin = rpl;
|
|
||||||
char c;
|
char c;
|
||||||
while((c = *str++)) {
|
size_t i;
|
||||||
|
char *rpl = (char *)calloc((1 + n), sizeof(char));
|
||||||
|
char *begin = rpl;
|
||||||
|
if (!rpl) {
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; (i < n) && (c = *str++); ++i) {
|
||||||
if (c == oldchar) {
|
if (c == oldchar) {
|
||||||
c = newchar;
|
c = newchar;
|
||||||
}
|
}
|
||||||
*rpl++ = c;
|
*rpl++ = c;
|
||||||
}
|
}
|
||||||
*rpl = '\0';
|
|
||||||
|
|
||||||
return begin;
|
return begin;
|
||||||
}
|
}
|
||||||
|
|
||||||
struct zip_entry_t {
|
struct zip_entry_t {
|
||||||
int index;
|
int index;
|
||||||
const char *name;
|
char *name;
|
||||||
mz_uint64 uncomp_size;
|
mz_uint64 uncomp_size;
|
||||||
mz_uint64 comp_size;
|
mz_uint64 comp_size;
|
||||||
mz_uint32 uncomp_crc32;
|
mz_uint32 uncomp_crc32;
|
||||||
|
@ -109,13 +134,14 @@ struct zip_entry_t {
|
||||||
mz_uint16 method;
|
mz_uint16 method;
|
||||||
mz_zip_writer_add_state state;
|
mz_zip_writer_add_state state;
|
||||||
tdefl_compressor comp;
|
tdefl_compressor comp;
|
||||||
|
mz_uint32 external_attr;
|
||||||
|
time_t m_time;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct zip_t {
|
struct zip_t {
|
||||||
mz_zip_archive archive;
|
mz_zip_archive archive;
|
||||||
mz_uint level;
|
mz_uint level;
|
||||||
struct zip_entry_t entry;
|
struct zip_entry_t entry;
|
||||||
char mode;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
struct zip_t *zip_open(const char *zipname, int level, char mode) {
|
struct zip_t *zip_open(const char *zipname, int level, char mode) {
|
||||||
|
@ -126,17 +152,18 @@ struct zip_t *zip_open(const char *zipname, int level, char mode) {
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (level < 0) level = MZ_DEFAULT_LEVEL;
|
if (level < 0)
|
||||||
|
level = MZ_DEFAULT_LEVEL;
|
||||||
if ((level & 0xF) > MZ_UBER_COMPRESSION) {
|
if ((level & 0xF) > MZ_UBER_COMPRESSION) {
|
||||||
// Wrong compression level
|
// Wrong compression level
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
zip = (struct zip_t *)calloc((size_t)1, sizeof(struct zip_t));
|
zip = (struct zip_t *)calloc((size_t)1, sizeof(struct zip_t));
|
||||||
if (!zip) goto cleanup;
|
if (!zip)
|
||||||
|
goto cleanup;
|
||||||
|
|
||||||
zip->level = level;
|
zip->level = (mz_uint)level;
|
||||||
zip->mode = mode;
|
|
||||||
switch (mode) {
|
switch (mode) {
|
||||||
case 'w':
|
case 'w':
|
||||||
// Create a new archive.
|
// Create a new archive.
|
||||||
|
@ -150,18 +177,16 @@ struct zip_t *zip_open(const char *zipname, int level, char mode) {
|
||||||
case 'a':
|
case 'a':
|
||||||
if (!mz_zip_reader_init_file(
|
if (!mz_zip_reader_init_file(
|
||||||
&(zip->archive), zipname,
|
&(zip->archive), zipname,
|
||||||
level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
|
zip->level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
|
||||||
// An archive file does not exist or cannot initialize
|
// An archive file does not exist or cannot initialize
|
||||||
// zip_archive reader
|
// zip_archive reader
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (mode == 'a' &&
|
if (mode == 'a' &&
|
||||||
!mz_zip_writer_init_from_reader(&(zip->archive), zipname)) {
|
!mz_zip_writer_init_from_reader(&(zip->archive), zipname)) {
|
||||||
mz_zip_reader_end(&(zip->archive));
|
mz_zip_reader_end(&(zip->archive));
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
break;
|
break;
|
||||||
|
|
||||||
default:
|
default:
|
||||||
|
@ -189,10 +214,10 @@ void zip_close(struct zip_t *zip) {
|
||||||
}
|
}
|
||||||
|
|
||||||
int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
||||||
char *locname = NULL;
|
|
||||||
size_t entrylen = 0;
|
size_t entrylen = 0;
|
||||||
mz_zip_archive *pzip = NULL;
|
mz_zip_archive *pzip = NULL;
|
||||||
mz_uint num_alignment_padding_bytes, level;
|
mz_uint num_alignment_padding_bytes, level;
|
||||||
|
mz_zip_archive_file_stat stats;
|
||||||
|
|
||||||
if (!zip || !entryname) {
|
if (!zip || !entryname) {
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -203,7 +228,6 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
pzip = &(zip->archive);
|
|
||||||
/*
|
/*
|
||||||
.ZIP File Format Specification Version: 6.3.3
|
.ZIP File Format Specification Version: 6.3.3
|
||||||
|
|
||||||
|
@ -215,40 +239,56 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
||||||
and UNIX file systems etc. If input came from standard
|
and UNIX file systems etc. If input came from standard
|
||||||
input, there is no file name field.
|
input, there is no file name field.
|
||||||
*/
|
*/
|
||||||
locname = strrpl(entryname, '\\', '/');
|
zip->entry.name = strrpl(entryname, entrylen, '\\', '/');
|
||||||
|
|
||||||
if (zip->mode == 'r') {
|
|
||||||
zip->entry.index = mz_zip_reader_locate_file(pzip, locname, NULL, 0);
|
|
||||||
CLEANUP(locname);
|
|
||||||
return (zip->entry.index < 0) ? -1 : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
zip->entry.index = zip->archive.m_total_files;
|
|
||||||
zip->entry.name = locname;
|
|
||||||
if (!zip->entry.name) {
|
if (!zip->entry.name) {
|
||||||
// Cannot parse zip entry name
|
// Cannot parse zip entry name
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pzip = &(zip->archive);
|
||||||
|
if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) {
|
||||||
|
zip->entry.index =
|
||||||
|
mz_zip_reader_locate_file(pzip, zip->entry.name, NULL, 0);
|
||||||
|
if (zip->entry.index < 0) {
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!mz_zip_reader_file_stat(pzip, (mz_uint)zip->entry.index, &stats)) {
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
|
||||||
|
zip->entry.comp_size = stats.m_comp_size;
|
||||||
|
zip->entry.uncomp_size = stats.m_uncomp_size;
|
||||||
|
zip->entry.uncomp_crc32 = stats.m_crc32;
|
||||||
|
zip->entry.offset = stats.m_central_dir_ofs;
|
||||||
|
zip->entry.header_offset = stats.m_local_header_ofs;
|
||||||
|
zip->entry.method = stats.m_method;
|
||||||
|
zip->entry.external_attr = stats.m_external_attr;
|
||||||
|
zip->entry.m_time = stats.m_time;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
zip->entry.index = (int)zip->archive.m_total_files;
|
||||||
zip->entry.comp_size = 0;
|
zip->entry.comp_size = 0;
|
||||||
zip->entry.uncomp_size = 0;
|
zip->entry.uncomp_size = 0;
|
||||||
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,
|
memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8));
|
||||||
MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8));
|
|
||||||
zip->entry.method = 0;
|
zip->entry.method = 0;
|
||||||
|
zip->entry.external_attr = 0;
|
||||||
|
|
||||||
num_alignment_padding_bytes =
|
num_alignment_padding_bytes =
|
||||||
mz_zip_writer_compute_padding_needed_for_file_alignment(pzip);
|
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
|
||||||
return -1;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
if (zip->level & MZ_ZIP_FLAG_COMPRESSED_DATA) {
|
if (zip->level & MZ_ZIP_FLAG_COMPRESSED_DATA) {
|
||||||
// Wrong zip compression level
|
// Wrong zip compression level
|
||||||
return -1;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
// no zip64 support yet
|
// no zip64 support yet
|
||||||
if ((pzip->m_total_files == 0xFFFF) ||
|
if ((pzip->m_total_files == 0xFFFF) ||
|
||||||
|
@ -256,27 +296,26 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
||||||
MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
|
MZ_ZIP_LOCAL_DIR_HEADER_SIZE + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
|
||||||
entrylen) > 0xFFFFFFFF)) {
|
entrylen) > 0xFFFFFFFF)) {
|
||||||
// No zip64 support yet
|
// No zip64 support yet
|
||||||
return -1;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
if (!mz_zip_writer_write_zeros(
|
if (!mz_zip_writer_write_zeros(pzip, zip->entry.offset,
|
||||||
pzip, zip->entry.offset,
|
num_alignment_padding_bytes +
|
||||||
num_alignment_padding_bytes + sizeof(zip->entry.header))) {
|
sizeof(zip->entry.header))) {
|
||||||
// Cannot memset zip entry header
|
// Cannot memset zip entry header
|
||||||
return -1;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
zip->entry.header_offset += num_alignment_padding_bytes;
|
zip->entry.header_offset += num_alignment_padding_bytes;
|
||||||
if (pzip->m_file_offset_alignment) {
|
if (pzip->m_file_offset_alignment) {
|
||||||
MZ_ASSERT((zip->entry.header_offset &
|
MZ_ASSERT(
|
||||||
(pzip->m_file_offset_alignment - 1)) == 0);
|
(zip->entry.header_offset & (pzip->m_file_offset_alignment - 1)) == 0);
|
||||||
}
|
}
|
||||||
zip->entry.offset +=
|
zip->entry.offset += num_alignment_padding_bytes + sizeof(zip->entry.header);
|
||||||
num_alignment_padding_bytes + sizeof(zip->entry.header);
|
|
||||||
|
|
||||||
if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, zip->entry.name,
|
if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.offset, zip->entry.name,
|
||||||
entrylen) != entrylen) {
|
entrylen) != entrylen) {
|
||||||
// Cannot write data to zip entry
|
// Cannot write data to zip entry
|
||||||
return -1;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
zip->entry.offset += entrylen;
|
zip->entry.offset += entrylen;
|
||||||
|
@ -288,14 +327,88 @@ int zip_entry_open(struct zip_t *zip, const char *entryname) {
|
||||||
|
|
||||||
if (tdefl_init(&(zip->entry.comp), mz_zip_writer_add_put_buf_callback,
|
if (tdefl_init(&(zip->entry.comp), mz_zip_writer_add_put_buf_callback,
|
||||||
&(zip->entry.state),
|
&(zip->entry.state),
|
||||||
tdefl_create_comp_flags_from_zip_params(
|
(int)tdefl_create_comp_flags_from_zip_params(
|
||||||
level, -15, MZ_DEFAULT_STRATEGY)) !=
|
(int)level, -15, MZ_DEFAULT_STRATEGY)) !=
|
||||||
TDEFL_STATUS_OKAY) {
|
TDEFL_STATUS_OKAY) {
|
||||||
// Cannot initialize the zip compressor
|
// Cannot initialize the zip compressor
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
zip->entry.m_time = time(NULL);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
cleanup:
|
||||||
|
CLEANUP(zip->entry.name);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int zip_entry_openbyindex(struct zip_t *zip, int index) {
|
||||||
|
mz_zip_archive *pZip = NULL;
|
||||||
|
mz_zip_archive_file_stat stats;
|
||||||
|
mz_uint namelen;
|
||||||
|
const mz_uint8 *pHeader;
|
||||||
|
const char *pFilename;
|
||||||
|
|
||||||
|
if (!zip) {
|
||||||
|
// zip_t handler is not initialized
|
||||||
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pZip = &(zip->archive);
|
||||||
|
if (pZip->m_zip_mode != MZ_ZIP_MODE_READING) {
|
||||||
|
// open by index requires readonly mode
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (index < 0 || (mz_uint)index >= pZip->m_total_files) {
|
||||||
|
// index out of range
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(pHeader = &MZ_ZIP_ARRAY_ELEMENT(
|
||||||
|
&pZip->m_pState->m_central_dir, mz_uint8,
|
||||||
|
MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets,
|
||||||
|
mz_uint32, index)))) {
|
||||||
|
// cannot find header in central directory
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
namelen = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
|
||||||
|
pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
|
||||||
|
|
||||||
|
/*
|
||||||
|
.ZIP File Format Specification Version: 6.3.3
|
||||||
|
|
||||||
|
4.4.17.1 The name of the file, with optional relative path.
|
||||||
|
The path stored MUST not contain a drive or
|
||||||
|
device letter, or a leading slash. All slashes
|
||||||
|
MUST be forward slashes '/' as opposed to
|
||||||
|
backwards slashes '\' for compatibility with Amiga
|
||||||
|
and UNIX file systems etc. If input came from standard
|
||||||
|
input, there is no file name field.
|
||||||
|
*/
|
||||||
|
zip->entry.name = strrpl(pFilename, namelen, '\\', '/');
|
||||||
|
if (!zip->entry.name) {
|
||||||
|
// local entry name is NULL
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!mz_zip_reader_file_stat(pZip, (mz_uint)index, &stats)) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
zip->entry.index = index;
|
||||||
|
zip->entry.comp_size = stats.m_comp_size;
|
||||||
|
zip->entry.uncomp_size = stats.m_uncomp_size;
|
||||||
|
zip->entry.uncomp_crc32 = stats.m_crc32;
|
||||||
|
zip->entry.offset = stats.m_central_dir_ofs;
|
||||||
|
zip->entry.header_offset = stats.m_local_header_ofs;
|
||||||
|
zip->entry.method = stats.m_method;
|
||||||
|
zip->entry.external_attr = stats.m_external_attr;
|
||||||
|
zip->entry.m_time = stats.m_time;
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -304,21 +417,20 @@ int zip_entry_close(struct zip_t *zip) {
|
||||||
mz_uint level;
|
mz_uint level;
|
||||||
tdefl_status done;
|
tdefl_status done;
|
||||||
mz_uint16 entrylen;
|
mz_uint16 entrylen;
|
||||||
time_t t;
|
|
||||||
struct tm *tm;
|
|
||||||
mz_uint16 dos_time, dos_date;
|
mz_uint16 dos_time, dos_date;
|
||||||
int status = -1;
|
int status = -1;
|
||||||
|
|
||||||
if (!zip) {
|
if (!zip) {
|
||||||
// zip_t handler is not initialized
|
// zip_t handler is not initialized
|
||||||
return -1;
|
goto cleanup;
|
||||||
}
|
|
||||||
|
|
||||||
if (zip->mode == 'r') {
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pzip = &(zip->archive);
|
pzip = &(zip->archive);
|
||||||
|
if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) {
|
||||||
|
status = 0;
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
|
||||||
level = zip->level & 0xF;
|
level = zip->level & 0xF;
|
||||||
if (level) {
|
if (level) {
|
||||||
done = tdefl_compress_buffer(&(zip->entry.comp), "", 0, TDEFL_FINISH);
|
done = tdefl_compress_buffer(&(zip->entry.comp), "", 0, TDEFL_FINISH);
|
||||||
|
@ -332,20 +444,13 @@ 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);
|
|
||||||
tm = localtime(&t);
|
|
||||||
dos_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) +
|
|
||||||
((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) ||
|
if ((zip->entry.comp_size > 0xFFFFFFFF) || (zip->entry.offset > 0xFFFFFFFF)) {
|
||||||
(zip->entry.offset > 0xFFFFFFFF)) {
|
|
||||||
// No zip64 support, yet
|
// No zip64 support, yet
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
mz_zip_time_t_to_dos_time(zip->entry.m_time, &dos_time, &dos_date);
|
||||||
if (!mz_zip_writer_create_local_dir_header(
|
if (!mz_zip_writer_create_local_dir_header(
|
||||||
pzip, zip->entry.header, entrylen, 0, zip->entry.uncomp_size,
|
pzip, zip->entry.header, entrylen, 0, zip->entry.uncomp_size,
|
||||||
zip->entry.comp_size, zip->entry.uncomp_crc32, zip->entry.method, 0,
|
zip->entry.comp_size, zip->entry.uncomp_crc32, zip->entry.method, 0,
|
||||||
|
@ -355,17 +460,17 @@ int zip_entry_close(struct zip_t *zip) {
|
||||||
}
|
}
|
||||||
|
|
||||||
if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset,
|
if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset,
|
||||||
zip->entry.header, sizeof(zip->entry.header)) !=
|
zip->entry.header,
|
||||||
sizeof(zip->entry.header)) {
|
sizeof(zip->entry.header)) != sizeof(zip->entry.header)) {
|
||||||
// Cannot write zip entry header
|
// Cannot write zip entry header
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!mz_zip_writer_add_to_central_dir(
|
if (!mz_zip_writer_add_to_central_dir(
|
||||||
pzip, zip->entry.name, entrylen, NULL, 0, "", 0,
|
pzip, zip->entry.name, entrylen, NULL, 0, "", 0,
|
||||||
zip->entry.uncomp_size, zip->entry.comp_size,
|
zip->entry.uncomp_size, zip->entry.comp_size, zip->entry.uncomp_crc32,
|
||||||
zip->entry.uncomp_crc32, zip->entry.method, 0, dos_time, dos_date,
|
zip->entry.method, 0, dos_time, dos_date, zip->entry.header_offset,
|
||||||
zip->entry.header_offset, 0)) {
|
zip->entry.external_attr)) {
|
||||||
// Cannot write to zip central dir
|
// Cannot write to zip central dir
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
@ -375,10 +480,54 @@ int zip_entry_close(struct zip_t *zip) {
|
||||||
status = 0;
|
status = 0;
|
||||||
|
|
||||||
cleanup:
|
cleanup:
|
||||||
|
if (zip) {
|
||||||
|
zip->entry.m_time = 0;
|
||||||
CLEANUP(zip->entry.name);
|
CLEANUP(zip->entry.name);
|
||||||
|
}
|
||||||
return status;
|
return status;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
const char *zip_entry_name(struct zip_t *zip) {
|
||||||
|
if (!zip) {
|
||||||
|
// zip_t handler is not initialized
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return zip->entry.name;
|
||||||
|
}
|
||||||
|
|
||||||
|
int zip_entry_index(struct zip_t *zip) {
|
||||||
|
if (!zip) {
|
||||||
|
// zip_t handler is not initialized
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return zip->entry.index;
|
||||||
|
}
|
||||||
|
|
||||||
|
int zip_entry_isdir(struct zip_t *zip) {
|
||||||
|
if (!zip) {
|
||||||
|
// zip_t handler is not initialized
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (zip->entry.index < 0) {
|
||||||
|
// zip entry is not opened
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return (int)mz_zip_reader_is_file_a_directory(&zip->archive,
|
||||||
|
(mz_uint)zip->entry.index);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned long long zip_entry_size(struct zip_t *zip) {
|
||||||
|
return zip ? zip->entry.uncomp_size : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned int zip_entry_crc32(struct zip_t *zip) {
|
||||||
|
return zip ? zip->entry.uncomp_crc32 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
|
int zip_entry_write(struct zip_t *zip, const void *buf, size_t bufsize) {
|
||||||
mz_uint level;
|
mz_uint level;
|
||||||
mz_zip_archive *pzip = NULL;
|
mz_zip_archive *pzip = NULL;
|
||||||
|
@ -421,15 +570,34 @@ 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];
|
||||||
|
struct MZ_FILE_STAT_STRUCT file_stat;
|
||||||
|
|
||||||
if (!zip) {
|
if (!zip) {
|
||||||
// zip_t handler is not initialized
|
// zip_t handler is not initialized
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
stream = fopen(filename, "rb");
|
memset(buf, 0, MZ_ZIP_MAX_IO_BUF_SIZE);
|
||||||
if (!stream) {
|
memset((void *)&file_stat, 0, sizeof(struct MZ_FILE_STAT_STRUCT));
|
||||||
|
if (MZ_FILE_STAT(filename, &file_stat) != 0) {
|
||||||
|
// problem getting information - check errno
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((file_stat.st_mode & 0200) == 0) {
|
||||||
|
// MS-DOS read-only attribute
|
||||||
|
zip->entry.external_attr |= 0x01;
|
||||||
|
}
|
||||||
|
zip->entry.external_attr |= (mz_uint32)((file_stat.st_mode & 0xFFFF) << 16);
|
||||||
|
zip->entry.m_time = file_stat.st_mtime;
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
if (fopen_s(&stream, filename, "rb"))
|
||||||
|
#else
|
||||||
|
if (!(stream = fopen(filename, "rb")))
|
||||||
|
#endif
|
||||||
|
{
|
||||||
// Cannot open filename
|
// Cannot open filename
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
@ -446,53 +614,101 @@ int zip_entry_fwrite(struct zip_t *zip, const char *filename) {
|
||||||
return status;
|
return status;
|
||||||
}
|
}
|
||||||
|
|
||||||
int zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize) {
|
ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize) {
|
||||||
mz_zip_archive *pzip = NULL;
|
mz_zip_archive *pzip = NULL;
|
||||||
mz_uint idx;
|
mz_uint idx;
|
||||||
|
size_t size = 0;
|
||||||
|
|
||||||
if (!zip) {
|
if (!zip) {
|
||||||
// zip_t handler is not initialized
|
// zip_t handler is not initialized
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (zip->mode != 'r' || zip->entry.index < 0) {
|
pzip = &(zip->archive);
|
||||||
|
if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
|
||||||
// the entry is not found or we do not have read access
|
// the entry is not found or we do not have read access
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
pzip = &(zip->archive);
|
|
||||||
idx = (mz_uint)zip->entry.index;
|
idx = (mz_uint)zip->entry.index;
|
||||||
if (mz_zip_reader_is_file_a_directory(pzip, idx)) {
|
if (mz_zip_reader_is_file_a_directory(pzip, idx)) {
|
||||||
// the entry is a directory
|
// the entry is a directory
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
*buf = mz_zip_reader_extract_to_heap(pzip, idx, bufsize, 0);
|
*buf = mz_zip_reader_extract_to_heap(pzip, idx, &size, 0);
|
||||||
return (*buf) ? 0 : -1;
|
if (*buf && bufsize) {
|
||||||
|
*bufsize = size;
|
||||||
|
}
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) {
|
||||||
|
mz_zip_archive *pzip = NULL;
|
||||||
|
|
||||||
|
if (!zip) {
|
||||||
|
// zip_t handler is not initialized
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
pzip = &(zip->archive);
|
||||||
|
if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
|
||||||
|
// the entry is not found or we do not have read access
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!mz_zip_reader_extract_to_mem_no_alloc(pzip, (mz_uint)zip->entry.index,
|
||||||
|
buf, bufsize, 0, NULL, 0)) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return (ssize_t)zip->entry.uncomp_size;
|
||||||
}
|
}
|
||||||
|
|
||||||
int zip_entry_fread(struct zip_t *zip, const char *filename) {
|
int zip_entry_fread(struct zip_t *zip, const char *filename) {
|
||||||
mz_zip_archive *pzip = NULL;
|
mz_zip_archive *pzip = NULL;
|
||||||
mz_uint idx;
|
mz_uint idx;
|
||||||
|
mz_uint32 xattr = 0;
|
||||||
|
mz_zip_archive_file_stat info;
|
||||||
|
|
||||||
if (!zip) {
|
if (!zip) {
|
||||||
// zip_t handler is not initialized
|
// zip_t handler is not initialized
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (zip->mode != 'r' || zip->entry.index < 0) {
|
memset((void *)&info, 0, sizeof(mz_zip_archive_file_stat));
|
||||||
|
pzip = &(zip->archive);
|
||||||
|
if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
|
||||||
// the entry is not found or we do not have read access
|
// the entry is not found or we do not have read access
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
pzip = &(zip->archive);
|
|
||||||
idx = (mz_uint)zip->entry.index;
|
idx = (mz_uint)zip->entry.index;
|
||||||
if (mz_zip_reader_is_file_a_directory(pzip, idx)) {
|
if (mz_zip_reader_is_file_a_directory(pzip, idx)) {
|
||||||
// the entry is a directory
|
// the entry is a directory
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
return (mz_zip_reader_extract_to_file(pzip, idx, filename, 0)) ? 0 : -1;
|
if (!mz_zip_reader_extract_to_file(pzip, idx, filename, 0)) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#else
|
||||||
|
if (!mz_zip_reader_file_stat(pzip, idx, &info)) {
|
||||||
|
// Cannot get information about zip archive;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
xattr = (info.m_external_attr >> 16) & 0xFFFF;
|
||||||
|
if (xattr > 0) {
|
||||||
|
if (chmod(filename, (mode_t)xattr) < 0) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int zip_entry_extract(struct zip_t *zip,
|
int zip_entry_extract(struct zip_t *zip,
|
||||||
|
@ -507,23 +723,33 @@ int zip_entry_extract(struct zip_t *zip,
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (zip->mode != 'r' || zip->entry.index < 0) {
|
pzip = &(zip->archive);
|
||||||
|
if (pzip->m_zip_mode != MZ_ZIP_MODE_READING || zip->entry.index < 0) {
|
||||||
// the entry is not found or we do not have read access
|
// the entry is not found or we do not have read access
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
pzip = &(zip->archive);
|
|
||||||
idx = (mz_uint)zip->entry.index;
|
idx = (mz_uint)zip->entry.index;
|
||||||
|
|
||||||
return (mz_zip_reader_extract_to_callback(pzip, idx, on_extract, arg, 0))
|
return (mz_zip_reader_extract_to_callback(pzip, idx, on_extract, arg, 0))
|
||||||
? 0
|
? 0
|
||||||
: -1;
|
: -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int zip_total_entries(struct zip_t *zip) {
|
||||||
|
if (!zip) {
|
||||||
|
// zip_t handler is not initialized
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return (int)zip->archive.m_total_files;
|
||||||
|
}
|
||||||
|
|
||||||
int zip_create(const char *zipname, const char *filenames[], size_t len) {
|
int zip_create(const char *zipname, const char *filenames[], size_t len) {
|
||||||
int status = 0;
|
int status = 0;
|
||||||
size_t i;
|
size_t i;
|
||||||
mz_zip_archive zip_archive;
|
mz_zip_archive zip_archive;
|
||||||
|
struct MZ_FILE_STAT_STRUCT file_stat;
|
||||||
|
mz_uint32 ext_attributes = 0;
|
||||||
|
|
||||||
if (!zipname || strlen(zipname) < 1) {
|
if (!zipname || strlen(zipname) < 1) {
|
||||||
// zip_t archive name is empty or NULL
|
// zip_t archive name is empty or NULL
|
||||||
|
@ -541,6 +767,8 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
memset((void *)&file_stat, 0, sizeof(struct MZ_FILE_STAT_STRUCT));
|
||||||
|
|
||||||
for (i = 0; i < len; ++i) {
|
for (i = 0; i < len; ++i) {
|
||||||
const char *name = filenames[i];
|
const char *name = filenames[i];
|
||||||
if (!name) {
|
if (!name) {
|
||||||
|
@ -548,8 +776,20 @@ 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,
|
if (MZ_FILE_STAT(name, &file_stat) != 0) {
|
||||||
ZIP_DEFAULT_COMPRESSION_LEVEL)) {
|
// problem getting information - check errno
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((file_stat.st_mode & 0200) == 0) {
|
||||||
|
// MS-DOS read-only attribute
|
||||||
|
ext_attributes |= 0x01;
|
||||||
|
}
|
||||||
|
ext_attributes |= (mz_uint32)((file_stat.st_mode & 0xFFFF) << 16);
|
||||||
|
|
||||||
|
if (!mz_zip_writer_add_file(&zip_archive, base_name(name), name, "", 0,
|
||||||
|
ZIP_DEFAULT_COMPRESSION_LEVEL,
|
||||||
|
ext_attributes)) {
|
||||||
// Cannot add file to zip_archive
|
// Cannot add file to zip_archive
|
||||||
status = -1;
|
status = -1;
|
||||||
break;
|
break;
|
||||||
|
@ -565,11 +805,15 @@ int zip_extract(const char *zipname, const char *dir,
|
||||||
int (*on_extract)(const char *filename, void *arg), void *arg) {
|
int (*on_extract)(const char *filename, void *arg), void *arg) {
|
||||||
int status = -1;
|
int status = -1;
|
||||||
mz_uint i, n;
|
mz_uint i, n;
|
||||||
char path[MAX_PATH + 1] = {0};
|
char path[MAX_PATH + 1];
|
||||||
|
char symlink_to[MAX_PATH + 1];
|
||||||
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;
|
||||||
|
mz_uint32 xattr = 0;
|
||||||
|
|
||||||
|
memset(path, 0, sizeof(path));
|
||||||
|
memset(symlink_to, 0, sizeof(symlink_to));
|
||||||
if (!memset(&(zip_archive), 0, sizeof(zip_archive))) {
|
if (!memset(&(zip_archive), 0, sizeof(zip_archive))) {
|
||||||
// Cannot memset zip archive
|
// Cannot memset zip archive
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -591,9 +835,16 @@ int zip_extract(const char *zipname, const char *dir,
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
memset((void *)&info, 0, sizeof(mz_zip_archive_file_stat));
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
strcpy_s(path, MAX_PATH, dir);
|
||||||
|
#else
|
||||||
strcpy(path, dir);
|
strcpy(path, dir);
|
||||||
|
#endif
|
||||||
|
|
||||||
if (!ISSLASH(path[dirlen - 1])) {
|
if (!ISSLASH(path[dirlen - 1])) {
|
||||||
#if defined _WIN32 || defined __WIN32__
|
#if defined(_WIN32) || defined(__WIN32__)
|
||||||
path[dirlen] = '\\';
|
path[dirlen] = '\\';
|
||||||
#else
|
#else
|
||||||
path[dirlen] = '/';
|
path[dirlen] = '/';
|
||||||
|
@ -608,12 +859,31 @@ int zip_extract(const char *zipname, const char *dir,
|
||||||
// Cannot get information about zip archive;
|
// Cannot get information about zip archive;
|
||||||
goto out;
|
goto out;
|
||||||
}
|
}
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
strncpy_s(&path[dirlen], MAX_PATH - dirlen, info.m_filename,
|
||||||
|
MAX_PATH - dirlen);
|
||||||
|
#else
|
||||||
strncpy(&path[dirlen], info.m_filename, MAX_PATH - dirlen);
|
strncpy(&path[dirlen], info.m_filename, MAX_PATH - dirlen);
|
||||||
|
#endif
|
||||||
if (mkpath(path) < 0) {
|
if (mkpath(path) < 0) {
|
||||||
// Cannot make a path
|
// Cannot make a path
|
||||||
goto out;
|
goto out;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if ((((info.m_version_made_by >> 8) == 3) || ((info.m_version_made_by >> 8) == 19)) // if zip is produced on Unix or macOS (3 and 19 from section 4.4.2.2 of zip standard)
|
||||||
|
&& info.m_external_attr & (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40 is directory)
|
||||||
|
#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) || \
|
||||||
|
defined(__MINGW32__)
|
||||||
|
#else
|
||||||
|
if (info.m_uncomp_size > MAX_PATH || !mz_zip_reader_extract_to_mem_no_alloc(&zip_archive, i, symlink_to, MAX_PATH, 0, NULL, 0)) {
|
||||||
|
goto out;
|
||||||
|
}
|
||||||
|
symlink_to[info.m_uncomp_size] = '\0';
|
||||||
|
if (symlink(symlink_to, path) != 0) {
|
||||||
|
goto out;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
} else {
|
||||||
if (!mz_zip_reader_is_file_a_directory(&zip_archive, i)) {
|
if (!mz_zip_reader_is_file_a_directory(&zip_archive, i)) {
|
||||||
if (!mz_zip_reader_extract_to_file(&zip_archive, i, path, 0)) {
|
if (!mz_zip_reader_extract_to_file(&zip_archive, i, path, 0)) {
|
||||||
// Cannot extract zip archive to file
|
// Cannot extract zip archive to file
|
||||||
|
@ -621,6 +891,17 @@ int zip_extract(const char *zipname, const char *dir,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#else
|
||||||
|
xattr = (info.m_external_attr >> 16) & 0xFFFF;
|
||||||
|
if (xattr > 0) {
|
||||||
|
if (chmod(path, (mode_t)xattr) < 0) {
|
||||||
|
goto out;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
if (on_extract) {
|
if (on_extract) {
|
||||||
if (on_extract(path, arg) < 0) {
|
if (on_extract(path, arg) < 0) {
|
||||||
goto out;
|
goto out;
|
||||||
|
|
|
@ -13,11 +13,24 @@
|
||||||
#define ZIP_H
|
#define ZIP_H
|
||||||
|
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
extern "C" {
|
extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) && \
|
||||||
|
!defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(__ssize_t_defined)
|
||||||
|
#define _SSIZE_T
|
||||||
|
// 64-bit Windows is the only mainstream platform
|
||||||
|
// where sizeof(long) != sizeof(void*)
|
||||||
|
#ifdef _WIN64
|
||||||
|
typedef long long ssize_t; /* byte count or error */
|
||||||
|
#else
|
||||||
|
typedef long ssize_t; /* byte count or error */
|
||||||
|
#endif
|
||||||
|
#endif
|
||||||
|
|
||||||
#ifndef MAX_PATH
|
#ifndef MAX_PATH
|
||||||
#define MAX_PATH 32767 /* # chars in a path name including NULL */
|
#define MAX_PATH 32767 /* # chars in a path name including NULL */
|
||||||
#endif
|
#endif
|
||||||
|
@ -47,7 +60,7 @@ struct zip_t;
|
||||||
extern struct zip_t *zip_open(const char *zipname, int level, char mode);
|
extern struct zip_t *zip_open(const char *zipname, int level, char mode);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Closes zip archive, releases resources - always finalize.
|
Closes the zip archive, releases resources - always finalize.
|
||||||
|
|
||||||
Args:
|
Args:
|
||||||
zip: zip archive handler.
|
zip: zip archive handler.
|
||||||
|
@ -55,7 +68,10 @@ extern struct zip_t *zip_open(const char *zipname, int level, char mode);
|
||||||
extern void zip_close(struct zip_t *zip);
|
extern void zip_close(struct zip_t *zip);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Opens a new entry for writing in a zip archive.
|
Opens an entry by name in the zip archive.
|
||||||
|
For zip archive opened in 'w' or 'a' mode the function will append
|
||||||
|
a new entry. In readonly mode the function tries to locate the entry
|
||||||
|
in global dictionary.
|
||||||
|
|
||||||
Args:
|
Args:
|
||||||
zip: zip archive handler.
|
zip: zip archive handler.
|
||||||
|
@ -66,6 +82,19 @@ extern void zip_close(struct zip_t *zip);
|
||||||
*/
|
*/
|
||||||
extern int zip_entry_open(struct zip_t *zip, const char *entryname);
|
extern int zip_entry_open(struct zip_t *zip, const char *entryname);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Opens a new entry by index in the zip archive.
|
||||||
|
This function is only valid if zip archive was opened in 'r' (readonly) mode.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
index: index in local dictionary.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The return code - 0 on success, negative number (< 0) on error.
|
||||||
|
*/
|
||||||
|
extern int zip_entry_openbyindex(struct zip_t *zip, int index);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Closes a zip entry, flushes buffer and releases resources.
|
Closes a zip entry, flushes buffer and releases resources.
|
||||||
|
|
||||||
|
@ -77,6 +106,67 @@ extern int zip_entry_open(struct zip_t *zip, const char *entryname);
|
||||||
*/
|
*/
|
||||||
extern int zip_entry_close(struct zip_t *zip);
|
extern int zip_entry_close(struct zip_t *zip);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Returns a local name of the current zip entry.
|
||||||
|
The main difference between user's entry name and local entry name
|
||||||
|
is optional relative path.
|
||||||
|
Following .ZIP File Format Specification - the path stored MUST not contain
|
||||||
|
a drive or device letter, or a leading slash.
|
||||||
|
All slashes MUST be forward slashes '/' as opposed to backwards slashes '\'
|
||||||
|
for compatibility with Amiga and UNIX file systems etc.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The pointer to the current zip entry name, or NULL on error.
|
||||||
|
*/
|
||||||
|
extern const char *zip_entry_name(struct zip_t *zip);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Returns an index of the current zip entry.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The index on success, negative number (< 0) on error.
|
||||||
|
*/
|
||||||
|
extern int zip_entry_index(struct zip_t *zip);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Determines if the current zip entry is a directory entry.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The return code - 1 (true), 0 (false), negative number (< 0) on error.
|
||||||
|
*/
|
||||||
|
extern int zip_entry_isdir(struct zip_t *zip);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Returns an uncompressed size of the current zip entry.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The uncompressed size in bytes.
|
||||||
|
*/
|
||||||
|
extern unsigned long long zip_entry_size(struct zip_t *zip);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Returns CRC-32 checksum of the current zip entry.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The CRC-32 checksum.
|
||||||
|
*/
|
||||||
|
extern unsigned int zip_entry_crc32(struct zip_t *zip);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Compresses an input buffer for the current zip entry.
|
Compresses an input buffer for the current zip entry.
|
||||||
|
|
||||||
|
@ -116,9 +206,31 @@ extern int zip_entry_fwrite(struct zip_t *zip, const char *filename);
|
||||||
- for large entries, please take a look at zip_entry_extract function.
|
- for large entries, please take a look at zip_entry_extract function.
|
||||||
|
|
||||||
Returns:
|
Returns:
|
||||||
The return code - 0 on success, negative number (< 0) on error.
|
The return code - the number of bytes actually read on success.
|
||||||
|
Otherwise a -1 on error.
|
||||||
*/
|
*/
|
||||||
extern int zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize);
|
extern ssize_t zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Extracts the current zip entry into a memory buffer using no memory
|
||||||
|
allocation.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
buf: preallocated output buffer.
|
||||||
|
bufsize: output buffer size (in bytes).
|
||||||
|
|
||||||
|
Note:
|
||||||
|
- ensure supplied output buffer is large enough.
|
||||||
|
- zip_entry_size function (returns uncompressed size for the current entry)
|
||||||
|
can be handy to estimate how big buffer is needed.
|
||||||
|
- for large entries, please take a look at zip_entry_extract function.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The return code - the number of bytes actually read on success.
|
||||||
|
Otherwise a -1 on error (e.g. bufsize is not large enough).
|
||||||
|
*/
|
||||||
|
extern ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Extracts the current zip entry into output file.
|
Extracts the current zip entry into output file.
|
||||||
|
@ -133,7 +245,7 @@ extern int zip_entry_read(struct zip_t *zip, void **buf, size_t *bufsize);
|
||||||
extern int zip_entry_fread(struct zip_t *zip, const char *filename);
|
extern int zip_entry_fread(struct zip_t *zip, const char *filename);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Extract the current zip entry using a callback function (on_extract).
|
Extracts the current zip entry using a callback function (on_extract).
|
||||||
|
|
||||||
Args:
|
Args:
|
||||||
zip: zip archive handler.
|
zip: zip archive handler.
|
||||||
|
@ -144,13 +256,24 @@ extern int zip_entry_fread(struct zip_t *zip, const char *filename);
|
||||||
Returns:
|
Returns:
|
||||||
The return code - 0 on success, negative number (< 0) on error.
|
The return code - 0 on success, negative number (< 0) on error.
|
||||||
*/
|
*/
|
||||||
extern int zip_entry_extract(struct zip_t *zip,
|
extern int
|
||||||
size_t (*on_extract)(void *arg,
|
zip_entry_extract(struct zip_t *zip,
|
||||||
unsigned long long offset,
|
size_t (*on_extract)(void *arg, unsigned long long offset,
|
||||||
const void *data,
|
const void *data, size_t size),
|
||||||
size_t size),
|
|
||||||
void *arg);
|
void *arg);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Returns the number of all entries (files and directories) in the zip archive.
|
||||||
|
|
||||||
|
Args:
|
||||||
|
zip: zip archive handler.
|
||||||
|
|
||||||
|
Returns:
|
||||||
|
The return code - the number of entries on success,
|
||||||
|
negative number (< 0) on error.
|
||||||
|
*/
|
||||||
|
extern int zip_total_entries(struct zip_t *zip);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Creates a new archive and puts files into a single zip archive.
|
Creates a new archive and puts files into a single zip archive.
|
||||||
|
|
||||||
|
|
|
@ -1,7 +1,19 @@
|
||||||
cmake_minimum_required(VERSION 2.8)
|
cmake_minimum_required(VERSION 2.8)
|
||||||
|
|
||||||
|
if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
|
||||||
|
if(ENABLE_COVERAGE)
|
||||||
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g ")
|
||||||
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0")
|
||||||
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs")
|
||||||
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage")
|
||||||
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
|
||||||
|
endif()
|
||||||
|
endif ()
|
||||||
|
|
||||||
# test
|
# test
|
||||||
include_directories(../src)
|
include_directories(../src)
|
||||||
add_executable(test.exe test.c ../src/zip.c)
|
add_executable(test.exe test.c ../src/zip.c)
|
||||||
|
add_executable(test_miniz.exe test_miniz.c)
|
||||||
|
|
||||||
add_test(NAME test COMMAND test.exe)
|
add_test(NAME test COMMAND test.exe)
|
||||||
|
add_test(NAME test_miniz COMMAND test_miniz.exe)
|
||||||
|
|
|
@ -4,10 +4,34 @@
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
#include <sys/stat.h>
|
||||||
|
|
||||||
#define ZIPNAME "test.zip"
|
#if defined(_MSC_VER) || defined(__MINGW64__) || defined(__MINGW32__)
|
||||||
|
#define MZ_FILE_STAT_STRUCT _stat
|
||||||
|
#define MZ_FILE_STAT _stat
|
||||||
|
#else
|
||||||
|
#define MZ_FILE_STAT_STRUCT stat
|
||||||
|
#define MZ_FILE_STAT stat
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define ZIPNAME "test.zip\0"
|
||||||
#define TESTDATA1 "Some test data 1...\0"
|
#define TESTDATA1 "Some test data 1...\0"
|
||||||
|
#define CRC32DATA1 2220805626
|
||||||
#define TESTDATA2 "Some test data 2...\0"
|
#define TESTDATA2 "Some test data 2...\0"
|
||||||
|
#define CRC32DATA2 2532008468
|
||||||
|
|
||||||
|
#define RFILE "4.txt\0"
|
||||||
|
#define RMODE 0100444
|
||||||
|
|
||||||
|
#define WFILE "6.txt\0"
|
||||||
|
#define WMODE 0100666
|
||||||
|
|
||||||
|
#define XFILE "7.txt\0"
|
||||||
|
#define XMODE 0100777
|
||||||
|
|
||||||
|
#define UNUSED(x) (void)x
|
||||||
|
|
||||||
|
static int total_entries = 0;
|
||||||
|
|
||||||
static void test_write(void) {
|
static void test_write(void) {
|
||||||
struct zip_t *zip = zip_open(ZIPNAME, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
|
struct zip_t *zip = zip_open(ZIPNAME, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
|
||||||
|
@ -15,6 +39,11 @@ static void test_write(void) {
|
||||||
|
|
||||||
assert(0 == zip_entry_open(zip, "test/test-1.txt"));
|
assert(0 == zip_entry_open(zip, "test/test-1.txt"));
|
||||||
assert(0 == zip_entry_write(zip, TESTDATA1, strlen(TESTDATA1)));
|
assert(0 == zip_entry_write(zip, TESTDATA1, strlen(TESTDATA1)));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-1.txt"));
|
||||||
|
assert(total_entries == zip_entry_index(zip));
|
||||||
|
assert(strlen(TESTDATA1) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA1 == zip_entry_crc32(zip));
|
||||||
|
++total_entries;
|
||||||
assert(0 == zip_entry_close(zip));
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
zip_close(zip);
|
zip_close(zip);
|
||||||
|
@ -25,7 +54,31 @@ static void test_append(void) {
|
||||||
assert(zip != NULL);
|
assert(zip != NULL);
|
||||||
|
|
||||||
assert(0 == zip_entry_open(zip, "test\\test-2.txt"));
|
assert(0 == zip_entry_open(zip, "test\\test-2.txt"));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-2.txt"));
|
||||||
|
assert(total_entries == zip_entry_index(zip));
|
||||||
assert(0 == zip_entry_write(zip, TESTDATA2, strlen(TESTDATA2)));
|
assert(0 == zip_entry_write(zip, TESTDATA2, strlen(TESTDATA2)));
|
||||||
|
assert(strlen(TESTDATA2) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA2 == zip_entry_crc32(zip));
|
||||||
|
|
||||||
|
++total_entries;
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "test\\empty/"));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/empty/"));
|
||||||
|
assert(0 == zip_entry_size(zip));
|
||||||
|
assert(0 == zip_entry_crc32(zip));
|
||||||
|
|
||||||
|
assert(total_entries == zip_entry_index(zip));
|
||||||
|
++total_entries;
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "empty/"));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "empty/"));
|
||||||
|
assert(0 == zip_entry_size(zip));
|
||||||
|
assert(0 == zip_entry_crc32(zip));
|
||||||
|
|
||||||
|
assert(total_entries == zip_entry_index(zip));
|
||||||
|
++total_entries;
|
||||||
assert(0 == zip_entry_close(zip));
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
zip_close(zip);
|
zip_close(zip);
|
||||||
|
@ -33,13 +86,18 @@ static void test_append(void) {
|
||||||
|
|
||||||
static void test_read(void) {
|
static void test_read(void) {
|
||||||
char *buf = NULL;
|
char *buf = NULL;
|
||||||
size_t bufsize;
|
ssize_t bufsize;
|
||||||
|
size_t buftmp;
|
||||||
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
assert(zip != NULL);
|
assert(zip != NULL);
|
||||||
|
|
||||||
assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
|
assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
|
||||||
assert(0 == zip_entry_read(zip, (void **)&buf, &bufsize));
|
assert(strlen(TESTDATA1) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA1 == zip_entry_crc32(zip));
|
||||||
|
|
||||||
|
bufsize = zip_entry_read(zip, (void **)&buf, &buftmp);
|
||||||
assert(bufsize == strlen(TESTDATA1));
|
assert(bufsize == strlen(TESTDATA1));
|
||||||
|
assert((size_t)bufsize == buftmp);
|
||||||
assert(0 == strncmp(buf, TESTDATA1, bufsize));
|
assert(0 == strncmp(buf, TESTDATA1, bufsize));
|
||||||
assert(0 == zip_entry_close(zip));
|
assert(0 == zip_entry_close(zip));
|
||||||
free(buf);
|
free(buf);
|
||||||
|
@ -47,9 +105,42 @@ static void test_read(void) {
|
||||||
bufsize = 0;
|
bufsize = 0;
|
||||||
|
|
||||||
assert(0 == zip_entry_open(zip, "test/test-2.txt"));
|
assert(0 == zip_entry_open(zip, "test/test-2.txt"));
|
||||||
assert(0 == zip_entry_read(zip, (void **)&buf, &bufsize));
|
assert(strlen(TESTDATA2) == zip_entry_size(zip));
|
||||||
assert(bufsize == strlen(TESTDATA2));
|
assert(CRC32DATA2 == zip_entry_crc32(zip));
|
||||||
assert(0 == strncmp(buf, TESTDATA2, bufsize));
|
|
||||||
|
bufsize = zip_entry_read(zip, (void **)&buf, NULL);
|
||||||
|
assert((size_t)bufsize == strlen(TESTDATA2));
|
||||||
|
assert(0 == strncmp(buf, TESTDATA2, (size_t)bufsize));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
free(buf);
|
||||||
|
buf = NULL;
|
||||||
|
bufsize = 0;
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "test\\empty/"));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/empty/"));
|
||||||
|
assert(0 == zip_entry_size(zip));
|
||||||
|
assert(0 == zip_entry_crc32(zip));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
buftmp = strlen(TESTDATA2);
|
||||||
|
buf = calloc(buftmp, sizeof(char));
|
||||||
|
assert(0 == zip_entry_open(zip, "test/test-2.txt"));
|
||||||
|
|
||||||
|
bufsize = zip_entry_noallocread(zip, (void *)buf, buftmp);
|
||||||
|
assert(buftmp == (size_t)bufsize);
|
||||||
|
assert(0 == strncmp(buf, TESTDATA2, buftmp));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
free(buf);
|
||||||
|
buf = NULL;
|
||||||
|
bufsize = 0;
|
||||||
|
|
||||||
|
buftmp = strlen(TESTDATA1);
|
||||||
|
buf = calloc(buftmp, sizeof(char));
|
||||||
|
assert(0 == zip_entry_open(zip, "test/test-1.txt"));
|
||||||
|
|
||||||
|
bufsize = zip_entry_noallocread(zip, (void *)buf, buftmp);
|
||||||
|
assert(buftmp == (size_t)bufsize);
|
||||||
|
assert(0 == strncmp(buf, TESTDATA1, buftmp));
|
||||||
assert(0 == zip_entry_close(zip));
|
assert(0 == zip_entry_close(zip));
|
||||||
free(buf);
|
free(buf);
|
||||||
buf = NULL;
|
buf = NULL;
|
||||||
|
@ -65,6 +156,8 @@ struct buffer_t {
|
||||||
|
|
||||||
static size_t on_extract(void *arg, unsigned long long offset, const void *data,
|
static size_t on_extract(void *arg, unsigned long long offset, const void *data,
|
||||||
size_t size) {
|
size_t size) {
|
||||||
|
UNUSED(offset);
|
||||||
|
|
||||||
struct buffer_t *buf = (struct buffer_t *)arg;
|
struct buffer_t *buf = (struct buffer_t *)arg;
|
||||||
buf->data = realloc(buf->data, buf->size + size + 1);
|
buf->data = realloc(buf->data, buf->size + size + 1);
|
||||||
assert(NULL != buf->data);
|
assert(NULL != buf->data);
|
||||||
|
@ -77,10 +170,11 @@ static size_t on_extract(void *arg, unsigned long long offset, const void *data,
|
||||||
}
|
}
|
||||||
|
|
||||||
static void test_extract(void) {
|
static void test_extract(void) {
|
||||||
struct buffer_t buf = {0};
|
struct buffer_t buf;
|
||||||
|
|
||||||
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
assert(zip != NULL);
|
assert(zip != NULL);
|
||||||
|
memset((void *)&buf, 0, sizeof(struct buffer_t));
|
||||||
|
|
||||||
assert(0 == zip_entry_open(zip, "test/test-1.txt"));
|
assert(0 == zip_entry_open(zip, "test/test-1.txt"));
|
||||||
assert(0 == zip_entry_extract(zip, on_extract, &buf));
|
assert(0 == zip_entry_extract(zip, on_extract, &buf));
|
||||||
|
@ -95,11 +189,273 @@ static void test_extract(void) {
|
||||||
zip_close(zip);
|
zip_close(zip);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void test_total_entries(void) {
|
||||||
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
|
assert(zip != NULL);
|
||||||
|
|
||||||
|
int n = zip_total_entries(zip);
|
||||||
|
zip_close(zip);
|
||||||
|
|
||||||
|
assert(n == total_entries);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_entry_name(void) {
|
||||||
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
|
assert(zip != NULL);
|
||||||
|
|
||||||
|
assert(zip_entry_name(zip) == NULL);
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
|
||||||
|
assert(NULL != zip_entry_name(zip));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-1.txt"));
|
||||||
|
assert(strlen(TESTDATA1) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA1 == zip_entry_crc32(zip));
|
||||||
|
assert(0 == zip_entry_index(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "test/test-2.txt"));
|
||||||
|
assert(NULL != zip_entry_name(zip));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-2.txt"));
|
||||||
|
assert(strlen(TESTDATA2) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA2 == zip_entry_crc32(zip));
|
||||||
|
assert(1 == zip_entry_index(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
zip_close(zip);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_entry_index(void) {
|
||||||
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
|
assert(zip != NULL);
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
|
||||||
|
assert(0 == zip_entry_index(zip));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-1.txt"));
|
||||||
|
assert(strlen(TESTDATA1) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA1 == zip_entry_crc32(zip));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_open(zip, "test/test-2.txt"));
|
||||||
|
assert(1 == zip_entry_index(zip));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-2.txt"));
|
||||||
|
assert(strlen(TESTDATA2) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA2 == zip_entry_crc32(zip));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
zip_close(zip);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_entry_openbyindex(void) {
|
||||||
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
|
assert(zip != NULL);
|
||||||
|
|
||||||
|
assert(0 == zip_entry_openbyindex(zip, 1));
|
||||||
|
assert(1 == zip_entry_index(zip));
|
||||||
|
assert(strlen(TESTDATA2) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA2 == zip_entry_crc32(zip));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-2.txt"));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
assert(0 == zip_entry_openbyindex(zip, 0));
|
||||||
|
assert(0 == zip_entry_index(zip));
|
||||||
|
assert(strlen(TESTDATA1) == zip_entry_size(zip));
|
||||||
|
assert(CRC32DATA1 == zip_entry_crc32(zip));
|
||||||
|
assert(0 == strcmp(zip_entry_name(zip), "test/test-1.txt"));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
zip_close(zip);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_list_entries(void) {
|
||||||
|
struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
|
||||||
|
assert(zip != NULL);
|
||||||
|
|
||||||
|
int i = 0, n = zip_total_entries(zip);
|
||||||
|
for (; i < n; ++i) {
|
||||||
|
assert(0 == zip_entry_openbyindex(zip, i));
|
||||||
|
fprintf(stdout, "[%d]: %s", i, zip_entry_name(zip));
|
||||||
|
if (zip_entry_isdir(zip)) {
|
||||||
|
fprintf(stdout, " (DIR)");
|
||||||
|
}
|
||||||
|
fprintf(stdout, "\n");
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
}
|
||||||
|
|
||||||
|
zip_close(zip);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_fwrite(void) {
|
||||||
|
const char *filename = WFILE;
|
||||||
|
FILE *stream = NULL;
|
||||||
|
struct zip_t *zip = NULL;
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
if (0 != fopen_s(&stream, filename, "w+"))
|
||||||
|
#else
|
||||||
|
if (!(stream = fopen(filename, "w+")))
|
||||||
|
#endif
|
||||||
|
{
|
||||||
|
// Cannot open filename
|
||||||
|
fprintf(stdout, "Cannot open filename\n");
|
||||||
|
assert(0 == -1);
|
||||||
|
}
|
||||||
|
fwrite(TESTDATA1, sizeof(char), strlen(TESTDATA1), stream);
|
||||||
|
assert(0 == fclose(stream));
|
||||||
|
|
||||||
|
zip = zip_open(ZIPNAME, 9, 'w');
|
||||||
|
assert(zip != NULL);
|
||||||
|
assert(0 == zip_entry_open(zip, WFILE));
|
||||||
|
assert(0 == zip_entry_fwrite(zip, WFILE));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
|
||||||
|
zip_close(zip);
|
||||||
|
remove(WFILE);
|
||||||
|
remove(ZIPNAME);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_exe_permissions(void) {
|
||||||
|
#if defined(_WIN32) || defined(__WIN32__)
|
||||||
|
#else
|
||||||
|
struct MZ_FILE_STAT_STRUCT file_stats;
|
||||||
|
const char *filenames[] = {XFILE};
|
||||||
|
FILE *f = fopen(XFILE, "w");
|
||||||
|
fclose(f);
|
||||||
|
chmod(XFILE, XMODE);
|
||||||
|
|
||||||
|
remove(ZIPNAME);
|
||||||
|
|
||||||
|
assert(0 == zip_create(ZIPNAME, filenames, 1));
|
||||||
|
|
||||||
|
remove(XFILE);
|
||||||
|
|
||||||
|
assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL));
|
||||||
|
|
||||||
|
assert(0 == MZ_FILE_STAT(XFILE, &file_stats));
|
||||||
|
assert(XMODE == file_stats.st_mode);
|
||||||
|
|
||||||
|
remove(XFILE);
|
||||||
|
remove(ZIPNAME);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_read_permissions(void) {
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#else
|
||||||
|
|
||||||
|
struct MZ_FILE_STAT_STRUCT file_stats;
|
||||||
|
const char *filenames[] = {RFILE};
|
||||||
|
FILE *f = fopen(RFILE, "w");
|
||||||
|
fclose(f);
|
||||||
|
chmod(RFILE, RMODE);
|
||||||
|
|
||||||
|
remove(ZIPNAME);
|
||||||
|
|
||||||
|
assert(0 == zip_create(ZIPNAME, filenames, 1));
|
||||||
|
|
||||||
|
// chmod from 444 to 666 to be able delete the file on windows
|
||||||
|
chmod(RFILE, WMODE);
|
||||||
|
remove(RFILE);
|
||||||
|
|
||||||
|
assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL));
|
||||||
|
|
||||||
|
assert(0 == MZ_FILE_STAT(RFILE, &file_stats));
|
||||||
|
assert(RMODE == file_stats.st_mode);
|
||||||
|
|
||||||
|
chmod(RFILE, WMODE);
|
||||||
|
remove(RFILE);
|
||||||
|
remove(ZIPNAME);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_write_permissions(void) {
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#else
|
||||||
|
|
||||||
|
struct MZ_FILE_STAT_STRUCT file_stats;
|
||||||
|
const char *filenames[] = {WFILE};
|
||||||
|
FILE *f = fopen(WFILE, "w");
|
||||||
|
fclose(f);
|
||||||
|
chmod(WFILE, WMODE);
|
||||||
|
|
||||||
|
remove(ZIPNAME);
|
||||||
|
|
||||||
|
assert(0 == zip_create(ZIPNAME, filenames, 1));
|
||||||
|
|
||||||
|
remove(WFILE);
|
||||||
|
|
||||||
|
assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL));
|
||||||
|
|
||||||
|
assert(0 == MZ_FILE_STAT(WFILE, &file_stats));
|
||||||
|
assert(WMODE == file_stats.st_mode);
|
||||||
|
|
||||||
|
remove(WFILE);
|
||||||
|
remove(ZIPNAME);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_mtime(void) {
|
||||||
|
struct MZ_FILE_STAT_STRUCT file_stat1, file_stat2;
|
||||||
|
|
||||||
|
const char *filename = WFILE;
|
||||||
|
FILE *stream = NULL;
|
||||||
|
struct zip_t *zip = NULL;
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
if (0 != fopen_s(&stream, filename, "w+"))
|
||||||
|
#else
|
||||||
|
if (!(stream = fopen(filename, "w+")))
|
||||||
|
#endif
|
||||||
|
{
|
||||||
|
// Cannot open filename
|
||||||
|
fprintf(stdout, "Cannot open filename\n");
|
||||||
|
assert(0 == -1);
|
||||||
|
}
|
||||||
|
fwrite(TESTDATA1, sizeof(char), strlen(TESTDATA1), stream);
|
||||||
|
assert(0 == fclose(stream));
|
||||||
|
|
||||||
|
memset(&file_stat1, 0, sizeof(file_stat1));
|
||||||
|
memset(&file_stat2, 0, sizeof(file_stat2));
|
||||||
|
zip = zip_open(ZIPNAME, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
|
||||||
|
assert(zip != NULL);
|
||||||
|
assert(0 == zip_entry_open(zip, filename));
|
||||||
|
assert(0 == zip_entry_fwrite(zip, filename));
|
||||||
|
assert(0 == zip_entry_close(zip));
|
||||||
|
zip_close(zip);
|
||||||
|
|
||||||
|
assert(0 == MZ_FILE_STAT(filename, &file_stat1));
|
||||||
|
|
||||||
|
remove(filename);
|
||||||
|
assert(0 == zip_extract(ZIPNAME, ".", NULL, NULL));
|
||||||
|
assert(0 == MZ_FILE_STAT(filename, &file_stat2));
|
||||||
|
fprintf(stdout, "file_stat1.st_mtime: %lu\n", file_stat1.st_mtime);
|
||||||
|
fprintf(stdout, "file_stat2.st_mtime: %lu\n", file_stat2.st_mtime);
|
||||||
|
assert(labs(file_stat1.st_mtime - file_stat2.st_mtime) <= 1);
|
||||||
|
|
||||||
|
remove(filename);
|
||||||
|
remove(ZIPNAME);
|
||||||
|
}
|
||||||
|
|
||||||
int main(int argc, char *argv[]) {
|
int main(int argc, char *argv[]) {
|
||||||
|
UNUSED(argc);
|
||||||
|
UNUSED(argv);
|
||||||
|
|
||||||
|
remove(ZIPNAME);
|
||||||
|
|
||||||
test_write();
|
test_write();
|
||||||
test_append();
|
test_append();
|
||||||
test_read();
|
test_read();
|
||||||
test_extract();
|
test_extract();
|
||||||
|
test_total_entries();
|
||||||
|
test_entry_name();
|
||||||
|
test_entry_index();
|
||||||
|
test_entry_openbyindex();
|
||||||
|
test_list_entries();
|
||||||
|
test_fwrite();
|
||||||
|
test_read_permissions();
|
||||||
|
test_write_permissions();
|
||||||
|
test_exe_permissions();
|
||||||
|
test_mtime();
|
||||||
|
|
||||||
return remove(ZIPNAME);
|
remove(ZIPNAME);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -0,0 +1,104 @@
|
||||||
|
// Demonstrates miniz.c's compress() and uncompress() functions
|
||||||
|
// (same as zlib's). Public domain, May 15 2011, Rich Geldreich,
|
||||||
|
// richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
|
||||||
|
|
||||||
|
#include <miniz.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
typedef unsigned char uint8;
|
||||||
|
typedef unsigned short uint16;
|
||||||
|
typedef unsigned int uint;
|
||||||
|
|
||||||
|
// The string to compress.
|
||||||
|
static const char *s_pStr =
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson."
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson."
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson."
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson."
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson."
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson."
|
||||||
|
"Good morning Dr. Chandra. This is Hal. I am ready for my first lesson.";
|
||||||
|
|
||||||
|
int main(int argc, char *argv[]) {
|
||||||
|
uint step = 0;
|
||||||
|
int cmp_status;
|
||||||
|
uLong src_len = (uLong)strlen(s_pStr);
|
||||||
|
uLong cmp_len = compressBound(src_len);
|
||||||
|
uLong uncomp_len = src_len;
|
||||||
|
uint8 *pCmp, *pUncomp;
|
||||||
|
uint total_succeeded = 0;
|
||||||
|
(void)argc, (void)argv;
|
||||||
|
|
||||||
|
printf("miniz.c version: %s\n", MZ_VERSION);
|
||||||
|
|
||||||
|
do {
|
||||||
|
// Allocate buffers to hold compressed and uncompressed data.
|
||||||
|
pCmp = (mz_uint8 *)malloc((size_t)cmp_len);
|
||||||
|
pUncomp = (mz_uint8 *)malloc((size_t)src_len);
|
||||||
|
if ((!pCmp) || (!pUncomp)) {
|
||||||
|
printf("Out of memory!\n");
|
||||||
|
return EXIT_FAILURE;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compress the string.
|
||||||
|
cmp_status =
|
||||||
|
compress(pCmp, &cmp_len, (const unsigned char *)s_pStr, src_len);
|
||||||
|
if (cmp_status != Z_OK) {
|
||||||
|
printf("compress() failed!\n");
|
||||||
|
free(pCmp);
|
||||||
|
free(pUncomp);
|
||||||
|
return EXIT_FAILURE;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("Compressed from %u to %u bytes\n", (mz_uint32)src_len,
|
||||||
|
(mz_uint32)cmp_len);
|
||||||
|
|
||||||
|
if (step) {
|
||||||
|
// Purposely corrupt the compressed data if fuzzy testing (this is a
|
||||||
|
// very crude fuzzy test).
|
||||||
|
uint n = 1 + (rand() % 3);
|
||||||
|
while (n--) {
|
||||||
|
uint i = rand() % cmp_len;
|
||||||
|
pCmp[i] ^= (rand() & 0xFF);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decompress.
|
||||||
|
cmp_status = uncompress(pUncomp, &uncomp_len, pCmp, cmp_len);
|
||||||
|
total_succeeded += (cmp_status == Z_OK);
|
||||||
|
|
||||||
|
if (step) {
|
||||||
|
printf("Simple fuzzy test: step %u total_succeeded: %u\n", step,
|
||||||
|
total_succeeded);
|
||||||
|
} else {
|
||||||
|
if (cmp_status != Z_OK) {
|
||||||
|
printf("uncompress failed!\n");
|
||||||
|
free(pCmp);
|
||||||
|
free(pUncomp);
|
||||||
|
return EXIT_FAILURE;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("Decompressed from %u to %u bytes\n", (mz_uint32)cmp_len,
|
||||||
|
(mz_uint32)uncomp_len);
|
||||||
|
|
||||||
|
// Ensure uncompress() returned the expected data.
|
||||||
|
if ((uncomp_len != src_len) ||
|
||||||
|
(memcmp(pUncomp, s_pStr, (size_t)src_len))) {
|
||||||
|
printf("Decompression failed!\n");
|
||||||
|
free(pCmp);
|
||||||
|
free(pUncomp);
|
||||||
|
return EXIT_FAILURE;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
free(pCmp);
|
||||||
|
free(pUncomp);
|
||||||
|
|
||||||
|
step++;
|
||||||
|
|
||||||
|
// Keep on fuzzy testing if there's a non-empty command line.
|
||||||
|
} while (argc >= 2);
|
||||||
|
|
||||||
|
printf("Success.\n");
|
||||||
|
return EXIT_SUCCESS;
|
||||||
|
}
|
Loading…
Reference in New Issue