unsigned int VFSDirZip::load(bool /*ignored*/)
{
close();
if(!zip_reader_init_vfsfile(&_zip, _zf, 0))
return 0;
unsigned int files = mz_zip_reader_get_num_files(&_zip);
mz_zip_archive_file_stat fs;
for (unsigned int i = 0; i < files; ++i)
{
// FIXME: do we want empty dirs in the tree?
if(mz_zip_reader_is_file_a_directory(&_zip, i))
continue;
if(mz_zip_reader_is_file_encrypted(&_zip, i))
continue;
if(!mz_zip_reader_file_stat(&_zip, i, &fs))
continue;
if(getFile(fs.m_filename))
continue;
VFSFileZip *vf = new VFSFileZip(&_zip);
vf->_setOrigin(this);
memcpy(vf->getZipFileStat(), &fs, sizeof(mz_zip_archive_file_stat));
vf->_init();
addRecursive(vf, true, VFSDir::NONE);
vf->ref--;
}
// Not necessary to keep open all the time, VFSFileZip will re-open the archive if needed
//close();
return files;
}
ZipReader::ZipReader(const Path &p)
: _path(p),
_in(FileUtils::openInputStream(p))
{
if (!_in)
FAIL("Failed to construct ZipReader: Input stream is invalid");
uint64 size = FileUtils::fileSize(p);
if (size == 0)
FAIL("Failed to construct ZipReader: Error reading file size");
std::memset(&_archive, 0, sizeof(mz_zip_archive));
_archive.m_pRead = &minizFileReadFunc;
_archive.m_pIO_opaque = _in.get();
if (!mz_zip_reader_init(&_archive, size, 0))
FAIL("Initializing zip reader failed");
int count = mz_zip_reader_get_num_files(&_archive);
for (int i = 0; i < count; ++i) {
mz_zip_archive_file_stat stat;
mz_zip_reader_file_stat(&_archive, i, &stat);
ZipEntry entry;
entry.fullPath = Path(stat.m_filename);
entry.name = entry.fullPath.fileName();
entry.size = stat.m_uncomp_size;
entry.isDirectory = !entry.fullPath.empty() && entry.fullPath.asString().back() == '/';
entry.archiveIndex = i;
addPath(Path(stat.m_filename).stripSeparator(), std::move(entry));
}
}
FileSourceZip::FileSourceZip(FileSourceFS &fs, const std::string &zipPath) : FileSource(zipPath), m_archive(0)
{
mz_zip_archive *zip = static_cast<mz_zip_archive*>(std::calloc(1, sizeof(mz_zip_archive)));
FILE *file = fs.OpenReadStream(zipPath);
if (!mz_zip_reader_init_file_stream(zip, file, 0)) {
Output("FileSourceZip: unable to open '%s'\n", zipPath.c_str());
std::free(zip);
return;
}
mz_zip_archive_file_stat zipStat;
Uint32 numFiles = mz_zip_reader_get_num_files(zip);
for (Uint32 i = 0; i < numFiles; i++) {
if (mz_zip_reader_file_stat(zip, i, &zipStat)) {
bool is_dir = mz_zip_reader_is_file_a_directory(zip, i);
if (!mz_zip_reader_is_file_encrypted(zip, i)) {
std::string fname = zipStat.m_filename;
if ((fname.size() > 1) && (fname[fname.size()-1] == '/')) {
fname.resize(fname.size() - 1);
}
AddFile(zipStat.m_filename, FileStat(i, zipStat.m_uncomp_size,
MakeFileInfo(fname, is_dir ? FileInfo::FT_DIR : FileInfo::FT_FILE)));
}
}
}
m_archive = static_cast<void*>(zip);
}
static void on_zip_downloaded(_unused_ void* userdata, void* buffer, int size)
{
log_info("Done.");
mz_zip_archive za;
if (!mz_zip_reader_init_mem(&za, buffer, size, 0)) {
log_error("Cannot unzip game files: invalid archive");
return;
}
for (mz_uint i = 0; i < mz_zip_reader_get_num_files(&za); i++) {
mz_zip_archive_file_stat file_stat;
if (!mz_zip_reader_file_stat(&za, i, &file_stat)) {
log_error("Cannot unzip game files");
break;
}
const char* filename = file_stat.m_filename;
int r = mkdir_p(filename);
if (r < 0) {
log_error("Cannot unzip game files: %s", strerror(-r));
break;
}
if (!mz_zip_reader_is_file_a_directory(&za, i)) {
mz_zip_reader_extract_to_file(&za, i, filename, 0);
}
}
mz_zip_reader_end(&za);
engine_load();
}
void adapt_stop_serving(adapt_serving_context* context) {
int i;
if (context->server_context) {
mg_stop(context->server_context);
}
if (context->options) {
for (i = 0; context->options[i]; i++) {
free(context->options[i]);
}
free(context->options);
}
if (context->init_call) {
free(context->init_call);
}
if (context->content) {
free(context->content);
}
if (context->file_info) {
int file_count = mz_zip_reader_get_num_files(&context->zip);
for (i = 0; i < file_count; i++) {
adapt_file_info_clear(&context->file_info[i]);
}
free(context->file_info);
}
mz_zip_reader_end(&context->zip);
free(context);
}
BYTE uncomp_zip_control_in_archive(void) {
mz_zip_archive zip_archive;
int a, mode;
memset(&zip_archive, 0, sizeof(zip_archive));
if (!mz_zip_reader_init_file(&zip_archive, info.rom_file, 0)) {
fprintf(stderr, "mz_zip_reader_init_file() failed!\n");
return (EXIT_ERROR);
}
for (mode = UNCOMP_CTRL_FILE_COUNT_ROMS; mode <= UNCOMP_CTRL_FILE_SAVE_DATA; mode++) {
uncomp.files_founded = 0;
for (a = 0; a < (int) mz_zip_reader_get_num_files(&zip_archive); a++) {
mz_zip_archive_file_stat file_stat;
int b;
if (!mz_zip_reader_file_stat(&zip_archive, a, &file_stat)) {
fprintf(stderr, "mz_zip_reader_file_stat() failed!\n");
mz_zip_reader_end(&zip_archive);
return (EXIT_ERROR);
}
/* se e' una directory continuo */
if (mz_zip_reader_is_file_a_directory(&zip_archive, a)) {
continue;
}
for (b = 0; b < LENGTH(format_supported); b++) {
char *ext = strrchr(file_stat.m_filename, '.');
if ((ext != NULL) && (strcasecmp(ext, format_supported[b].ext) == 0)) {
if (mode == UNCOMP_CTRL_FILE_SAVE_DATA) {
uncomp.file[uncomp.files_founded].num = file_stat.m_file_index;
uncomp.file[uncomp.files_founded].format = format_supported[b].id;
}
uncomp.files_founded++;
break;
}
}
}
if ((mode == UNCOMP_CTRL_FILE_COUNT_ROMS) && (uncomp.files_founded > 0)) {
uncomp.file = (_uncomp_file_data *) malloc(
uncomp.files_founded * sizeof(_uncomp_file_data));
}
}
mz_zip_reader_end(&zip_archive);
return (EXIT_OK);
}
CZipArchive::CZipArchive(FileReader &file) : ArchiveBase(file)
//------------------------------------------------------------
{
zipFile = new mz_zip_archive();
mz_zip_archive *zip = static_cast<mz_zip_archive*>(zipFile);
MemsetZero(*zip);
if(!mz_zip_reader_init_mem(zip, file.GetRawData(), file.GetLength(), 0))
{
delete zip;
zip = nullptr;
zipFile = nullptr;
}
if(!zip)
{
return;
}
for(mz_uint i = 0; i < mz_zip_reader_get_num_files(zip); ++i)
{
ArchiveFileInfo info;
info.type = ArchiveFileInvalid;
mz_zip_archive_file_stat stat;
MemsetZero(stat);
if(mz_zip_reader_file_stat(zip, i, &stat))
{
info.type = ArchiveFileNormal;
info.name = mpt::PathString::FromWide(mpt::ToWide(mpt::CharsetCP437, stat.m_filename));
info.size = stat.m_uncomp_size;
}
if(mz_zip_reader_is_file_a_directory(zip, i))
{
info.type = ArchiveFileSpecial;
} else if(mz_zip_reader_is_file_encrypted(zip, i))
{
info.type = ArchiveFileSpecial;
}
contents.push_back(info);
}
}
int FileReader::unzipFile(QString &filename, QByteArray &file)
{
mz_bool status;
mz_zip_archive archive;
memset(&archive, 0, sizeof(archive));
status = mz_zip_reader_init_file(&archive, filename.toStdString().c_str(), 0);
if (status < MZ_OK)
return status;
if (mz_zip_reader_get_num_files(&archive) != 1)
{
emit ErrorMessage(trUtf8("The archive %1 more than one file, or no files in the archive").arg(filename));
return MZ_PARAM_ERROR;
}
mz_zip_archive_file_stat file_stat;
status = mz_zip_reader_file_stat(&archive, 0, &file_stat);
if (status < MZ_OK)
{
emit ErrorMessage(trUtf8("Error reading the file %1").arg(filename));
mz_zip_reader_end(&archive);
return MZ_PARAM_ERROR;
}
size_t uncompressed_size = file_stat.m_uncomp_size;
void *p = mz_zip_reader_extract_file_to_heap(&archive, file_stat.m_filename, &uncompressed_size, 0);
if (!p)
{
emit ErrorMessage(trUtf8("Error extracting file %1").arg(filename));
mz_zip_reader_end(&archive);
return MZ_PARAM_ERROR;
}
file.append(static_cast<char *>(p));
mz_zip_reader_end(&archive);
return 0;
}
bool decompress_archive( const char* data, std::size_t size, const std::string& directory ) {
auto zip_archive = sys::create_zeroed<mz_zip_archive>();
if( !mz_zip_reader_init_mem( &zip_archive, data, size, 0 ) ) {
std::cout << "mz_zip_reader_init_mem() failed!\n";
return false;
}
for( unsigned int i = 0; i < mz_zip_reader_get_num_files( &zip_archive ); i++ ) {
mz_zip_archive_file_stat file_stat;
if( !mz_zip_reader_file_stat( &zip_archive, i, &file_stat ) ) {
std::cout << "mz_zip_reader_file_stat() failed!\n";
mz_zip_reader_end( &zip_archive );
return false;
}
if( !mz_zip_reader_is_file_a_directory( &zip_archive, i ) ) {
auto filename = directory + ( directory.empty() ? "" : "/" ) + file_stat.m_filename;
if( !sys::create_directory_if_required( filename ) ) {
std::cout << "decompress_archive could not create directory.\n";
return false;
}
if( !mz_zip_reader_extract_to_file( &zip_archive, i, filename.c_str(), 0 ) ) {
std::cout << "mz_zip_reader_extract_to_file() failed!\n";
mz_zip_reader_end( &zip_archive );
return false;
}
}
}
if( !mz_zip_reader_end( &zip_archive ) ) {
std::cout << "mz_zip_reader_end() failed!\n";
return false;
}
return true;
}
bool ZipArchive::loadFromMemory(std::vector<char> compressedArchiveData) {
// Reset to an empty state.
reset();
// Initialize the buffer and archive with the input data.
buffer.swap(compressedArchiveData);
if (!mz_zip_reader_init_mem(&minizData, buffer.data(), buffer.size(), 0)) {
return false;
}
// Scan the archive entries into a list.
auto numberOfFiles = mz_zip_reader_get_num_files(&minizData);
entryList.reserve(numberOfFiles);
for (size_t i = 0; i < numberOfFiles; i++) {
Entry entry;
mz_zip_archive_file_stat stats;
if (mz_zip_reader_file_stat(&minizData, i, &stats)) {
entry.path = stats.m_filename;
entry.uncompressedSize = stats.m_uncomp_size;
}
entryList.push_back(entry);
}
return true;
}
FileSourceZip::FileSourceZip(const std::string &zipPath) : FileSource(zipPath), m_archive(0)
{
mz_zip_archive *zip = reinterpret_cast<mz_zip_archive*>(std::calloc(1, sizeof(mz_zip_archive)));
if (!mz_zip_reader_init_file(zip, zipPath.c_str(), 0)) {
printf("FileSourceZip: unable to open '%s'\n", zipPath.c_str());
std::free(zip);
return;
}
mz_zip_archive_file_stat zipStat;
Uint32 numFiles = mz_zip_reader_get_num_files(zip);
for (Uint32 i = 0; i < numFiles; i++) {
if (mz_zip_reader_file_stat(zip, i, &zipStat)) {
bool is_dir = mz_zip_reader_is_file_a_directory(zip, i);
if (!mz_zip_reader_is_file_encrypted(zip, i))
AddFile(zipStat.m_filename, FileStat(i, zipStat.m_uncomp_size, MakeFileInfo(zipStat.m_filename, is_dir ? FileInfo::FT_DIR : FileInfo::FT_FILE)));
}
}
m_archive = reinterpret_cast<void*>(zip);
}
bool fe_zip_get_dir(
const char *archive,
std::vector<std::string> &result )
{
mz_zip_archive zip;
memset( &zip, 0, sizeof( zip ) );
if ( !mz_zip_reader_init_file( &zip, archive, 0 ) )
{
std::cerr << "Error initializing zip: "
<< archive << std::endl;
return false;
}
for ( int i=0; i<(int)mz_zip_reader_get_num_files(&zip); i++)
{
mz_zip_archive_file_stat file_stat;
if ( mz_zip_reader_file_stat(&zip, i, &file_stat) )
result.push_back( file_stat.m_filename );
}
mz_zip_reader_end( &zip );
return true;
}
static int adapt_serve_zip_metadata(const char* method, struct mg_connection* connection,
adapt_serving_context* context, const char* item) {
if (strcmp(item, "list") == 0 && strcmp(method, "GET") == 0) {
// URL-encoding may turn one character into three.
char name_buffer[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE * 3 + 4];
int file_index = 0;
mz_zip_archive_file_stat file_info;
const char* sep = "";
mg_printf(connection,
"HTTP/1.1 200 Success\r\n"
"Content-Type: text/plain\r\n"
"\r\n[");
while (mz_zip_reader_file_stat(&context->zip, file_index, &file_info)) {
++file_index;
url_encode_name(file_info.m_filename, name_buffer, sizeof name_buffer);
mg_printf(connection, "%s{\"n\":\"%s\",\"m\":%d,\"c\":%llu,\"u\":%llu}",
sep, name_buffer, file_info.m_method, file_info.m_comp_size, file_info.m_uncomp_size);
sep = ",";
}
mg_printf(connection, "]\r\n");
return 1;
} else if (strcmp(item, "manifest") == 0 && strcmp(method, "POST") == 0) {
char file_name[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE+1];
int len = 0;
char* buf = adapt_read_connection(connection, &len);
if (buf) {
char* s = buf;
int file_index;
if (!context->file_info) {
int file_count = mz_zip_reader_get_num_files(&context->zip);
context->file_info = (struct adapt_file_info*)calloc(sizeof(struct adapt_file_info), file_count);
}
while (1) {
char* url = s;
char* media_type;
char* obfuscation_str = NULL;
s = strpbrk(s, " \n");
if (!s) {
break;
}
if (*s == '\n') {
continue;
}
*s = '\0';
s++;
url_decode_name(url, file_name, sizeof file_name);
media_type = s;
s = strpbrk(s, " \n");
if (!s) {
break;
}
if (*s == ' ') {
/* Have obfuscation data */
*s = '\0';
s++;
obfuscation_str = s;
s = strpbrk(s, " \n");
if (!s) {
break;
}
if (*s != '\n') {
/* Need to reach end of line */
*s = '\0';
s = strchr(s, '\n');
if (!s) {
break;
}
}
}
*s = '\0';
s++;
file_index = mz_zip_reader_locate_file(&context->zip, file_name, NULL,
MZ_ZIP_FLAG_CASE_SENSITIVE);
if (file_index >= 0) {
struct adapt_file_info* file_info = &context->file_info[file_index];
adapt_file_info_clear(file_info);
file_info->media_type = strcpy((char *)malloc(strlen(media_type) + 1), media_type);
if (obfuscation_str) {
char* sep = strchr(obfuscation_str, ':');
if (sep) {
unsigned int length;
*sep = '\0';
length = atoi(obfuscation_str);
if (length < 2048) { /* Sanity check */
char* mask_hex = sep + 1;
size_t mask_hex_length = strlen(mask_hex);
if (mask_hex_length % 2 == 0 && mask_hex_length <= 128) { /* Sanity check */
unsigned int k;
struct adapt_obfuscation* obfuscation =
(struct adapt_obfuscation*)calloc(sizeof(struct adapt_obfuscation), 1);
obfuscation->length = length;
obfuscation->mask_length = (unsigned int)(mask_hex_length / 2);
obfuscation->mask = (unsigned char *)calloc(1, obfuscation->mask_length);
for (k = 0; k < mask_hex_length; k += 2) {
char t[] = {mask_hex[k], mask_hex[k+1], '\0'};
obfuscation->mask[k/2] = (unsigned char)strtol(t, NULL, 16);
}
file_info->obfuscation = obfuscation;
}
}
}
}
}
}
free(buf);
}
}
return 0;
}
extern int process_pptx(char *pptx_file) {
// Returns the number of slides, -1 in case of severe failure
// (if the file doesn't exist, 0 is returned)
mz_bool status;
mz_zip_archive zip_archive;
char *xml_slide;
size_t xml_sz;
char *p;
char *q;
char *s;
char *t;
int i;
int deckid;
int maxslide = 0;
int notenum;
int slidenum = 0;
int slideid;
char xmlrel[FILENAME_MAX];
short kw;
short level;
memset(&zip_archive, 0, sizeof(zip_archive));
status = mz_zip_reader_init_file(&zip_archive, pptx_file, 0);
if (!status) {
fprintf(stderr, "Cannot read %s!\n", pptx_file);
} else {
deckid = new_deck(pptx_file);
// Get and print information about each file in the archive.
for (i = 0; i < (int)mz_zip_reader_get_num_files(&zip_archive); i++) {
mz_zip_archive_file_stat file_stat;
if (!mz_zip_reader_file_stat(&zip_archive, i, &file_stat)) {
fprintf(stderr, "mz_zip_reader_file_stat() failed!\n");
mz_zip_reader_end(&zip_archive);
return -1;
}
if (!mz_zip_reader_is_file_a_directory(&zip_archive, i)) {
if ((strncmp(file_stat.m_filename, "ppt/notesSlides/", 16) == 0)
&& strncmp(file_stat.m_filename, "ppt/notesSlides/_rels/", 22)) {
// Notes
//
// *** ACHTUNG ***
// Note numbers don't match the corresponding slide number,
// that would be too easy. You have to dig into "_rels"
//
if (!sscanf(&(file_stat.m_filename[26]), "%d", ¬enum)) {
fprintf(stderr, "Failed to extract note num from %s\n",
&(file_stat.m_filename[16]));
return -1;
}
sprintf(xmlrel,
"ppt/notesSlides/_rels/notesSlide%d.xml.rels",
notenum);
if ((xml_slide =
(char *)mz_zip_reader_extract_file_to_heap(&zip_archive,
(const char *)xmlrel,
&xml_sz, (mz_uint)0)) != (char *)NULL) {
// Try to find the b****y slide number
if ((p = strstr(xml_slide, "Target=\"../slides/slide"))
!= NULL) {
if (!sscanf(&(p[23]), "%d", &slidenum)) {
fprintf(stderr, "Failed to extract slidenum from %s\n",
&(p[36]));
return -1;
}
}
free(xml_slide);
}
if (slidenum) {
if (slidenum > maxslide) {
maxslide = slidenum;
}
slideid = new_slide(deckid, slidenum);
xml_sz = 0;
if ((xml_slide =
(char *)mz_zip_reader_extract_file_to_heap(&zip_archive,
(const char *)file_stat.m_filename,
&xml_sz, (mz_uint)0)) != (char *)NULL) {
if (get_mode() & OPT_TAGS) {
// Exclusively look for indexing words in the notes
q = xml_slide;
level = 0;
while ((p = strchr(q, '[')) != (char *)NULL) {
level++;
do {
p++;
} while (isspace(*p));
q = p + 1;
while (*q && ((*q != ']') || (level > 1))) {
switch (*q) {
case '[':
level++;
break;
case ']':
level--;
break;
default:
break;
}
q++;
}
if (*q == ']') {
*q = '\0';
if (get_sep() == ';') {
// Replace HTML entities if there are any
replace_entities(p);
}
while ((s = strchr(p, get_sep())) != (char *)NULL) {
*s++ = '\0';
if (*p == get_kw()) {
p++;
kw = 1;
} else {
if (autokw()) {
kw = lowercase_word(p);
} else {
kw = 0;
}
}
if ((t = cleanup(p)) != (char *)NULL) {
new_word_as_is(t, slideid, 'T', kw);
free(t);
}
p = s;
while (isspace(*p)) {
p++;
}
}
if (*p == get_kw()) {
p++;
kw = 1;
} else {
if (autokw()) {
kw = lowercase_word(p);
} else {
kw = 0;
}
}
if ((t = cleanup(p)) != (char *)NULL) {
new_word_as_is(t, slideid, 'T', kw);
free(t);
}
p = 1 + q;
} else {
break;
}
}
} else {
// Analyze text
analyze_text(slideid, xml_slide, 'N');
}
free(xml_slide);
} else {
fprintf(stderr, "Extract flopped\n");
return -1;
}
}
}
// We look at regular slides even if we are only interested
// in tags to check that we aren't missing any slide without
// notes and that our tag count is correct
if ((strncmp(file_stat.m_filename, "ppt/slides/", 11) == 0)
&& strncmp(file_stat.m_filename, "ppt/slides/_rels/", 17)) {
// Regular slide
if (!sscanf(&(file_stat.m_filename[16]), "%d", &slidenum)) {
fprintf(stderr, "Failed to extract num from %s\n",
&(file_stat.m_filename[11]));
return -1;
}
if (slidenum > maxslide) {
maxslide = slidenum;
}
slideid = new_slide(deckid, slidenum);
if (!(get_mode() & OPT_TAGS)) {
xml_sz = 0;
if ((xml_slide =
(char *)mz_zip_reader_extract_file_to_heap(&zip_archive,
(const char *)file_stat.m_filename,
&xml_sz, (mz_uint)0)) != (char *)NULL) {
// Analyze text
analyze_text(slideid, xml_slide, 'S');
// Analyze images
analyze_pic(slideid, xml_slide);
free(xml_slide);
} else {
fprintf(stderr, "Extract flopped\n");
return -1;
}
}
}
}
}
// Close the archive, freeing any resources it was using
mz_zip_reader_end(&zip_archive);
}
return maxslide;
}
static int Lreader_get_num_files(lua_State *L) {
mz_zip_archive *za = luaL_checkudata(L, 1, LMZ_ZIP_READER);
lua_pushinteger(L, mz_zip_reader_get_num_files(za));
return 1;
}
int main(int argc,char *argv[])
{
if(argc != 4) {
fprintf(stderr,"USAGE: %s extract <saz> <bin>\n",argv[0]);
return 1;
}
const char *inPath = argv[2];
const char *outPath = argv[3];
mz_zip_archive zip={0};
if(!mz_zip_reader_init_file(&zip,inPath,MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
fprintf(stderr,"Failed to open '%s' for reading or invalid archive.\n",inPath);
return 1;
}
FILE *outFile = fopen(outPath,"wb");
if(outFile == NULL) {
fprintf(stderr,"Failed to open '%s' for writing.\n",outPath);
return 1;
}
int files = mz_zip_reader_get_num_files(&zip);
for(int i=0;i<files;i++) {
char filename[1024];
if(!mz_zip_reader_get_filename(&zip,i,filename,sizeof(filename))) {
continue;
}
int httpIdx = -1;
char ext[1024];
if(sscanf(filename,"raw/%d_c.%s",&httpIdx,ext) != 2) {
continue;
}
size_t postSize;
char *post = (char *)mz_zip_reader_extract_to_heap(&zip,i,&postSize,0);
if(post == NULL) {
continue;
}
char *data = NULL;
int nl=0;
for(size_t j=0;j<postSize;j++) {
if(post[j] == '\n' || post[j] == '\r') {
nl++;
if(nl == 4) {
data = post+j+1;
break;
}
} else {
nl = 0;
}
}
if(data && postSize-(data-post)) {
fwrite(data,1,postSize-(data-post),outFile);
}
printf("%s\n",filename);
free(post);
}
fclose(outFile);
return 0;
}
U32 ZipIO::getFilesNumber(){
if (!_kisopen || _kmode == OpenMode::WRITE)
return 0;
return mz_zip_reader_get_num_files(&_kzarchive);
}
int test_zip(int argc, char *argv[])
{
int i, sort_iter;
mz_bool status;
size_t uncomp_size;
mz_zip_archive zip_archive; //mz_zip_archive is a struct of all stuff about the zip
void *p;
const int N = 50;
char data[2048];
char archive_filename[64];
//static const char *s_Test_archive_filename = "__mz_example2_test__.zip";
#ifdef MSC
static const char *s_Test_archive_filename = "hallelujah.zip";
#else
static const char *s_Test_archive_filename = "E:\\hallelujah.zip";
#endif
assert((strlen(s_pTest_str) + 64) < sizeof(data));
printf("miniz.c version: %s\n", MZ_VERSION);
(void)argc, (void)argv;
// Delete the test archive, so it doesn't keep growing as we run this test
remove(s_Test_archive_filename);
// Append a bunch of text files to the test archive
for (i = (N - 1); i >= 0; --i)
{
sprintf(archive_filename, "%u.txt", i);
sprintf(data, "%u %s %u", (N - 1) - i, s_pTest_str, i);
//sprintf(archive_filename, "E://look_a.zip");
// Add a new file to the archive. Note this is an IN-PLACE operation, so if it fails your archive is probably hosed (its central directory may not be complete) but it should be recoverable using zip -F or -FF. So use caution with this guy.
// A more robust way to add a file to an archive would be to read it into memory, perform the operation, then write a new archive out to a temp file and then delete/rename the files.
// Or, write a new archive to disk to a temp file, then delete/rename the files. For this test this API is fine.
status = mz_zip_add_mem_to_archive_file_in_place(s_Test_archive_filename, archive_filename, data, strlen(data) + 1, s_pComment, (uint16)strlen(s_pComment), MZ_BEST_COMPRESSION);
if (!status)
{
printf("mz_zip_add_mem_to_archive_file_in_place failed!\n");
return EXIT_FAILURE;
}
}
// Add a directory entry for testing
status = mz_zip_add_mem_to_archive_file_in_place(s_Test_archive_filename, "directory/", NULL, 0, "no comment", (uint16)strlen("no comment"), MZ_BEST_COMPRESSION);
if (!status)
{
printf("mz_zip_add_mem_to_archive_file_in_place failed!\n");
return EXIT_FAILURE;
}
// Now try to open the archive.
memset(&zip_archive, 0, sizeof(zip_archive));
status = mz_zip_reader_init_file(&zip_archive, s_Test_archive_filename, 0);
if (!status)
{
printf("mz_zip_reader_init_file() failed!\n");
return EXIT_FAILURE;
}
// Get and print information about each file in the archive.
for (i = 0; i < (int)mz_zip_reader_get_num_files(&zip_archive); i++)
{
mz_zip_archive_file_stat file_stat;
if (!mz_zip_reader_file_stat(&zip_archive, i, &file_stat))
{
printf("mz_zip_reader_file_stat() failed!\n");
mz_zip_reader_end(&zip_archive);
return EXIT_FAILURE;
}
printf("Filename: \"%s\", Comment: \"%s\", Uncompressed size: %u, Compressed size: %u, Is Dir: %u\n", file_stat.m_filename, file_stat.m_comment, (uint)file_stat.m_uncomp_size, (uint)file_stat.m_comp_size, mz_zip_reader_is_file_a_directory(&zip_archive, i));
if (!strcmp(file_stat.m_filename, "directory/"))
{
if (!mz_zip_reader_is_file_a_directory(&zip_archive, i))
{
printf("mz_zip_reader_is_file_a_directory() didn't return the expected results!\n");
mz_zip_reader_end(&zip_archive);
return EXIT_FAILURE;
}
}
}
// Close the archive, freeing any resources it was using
mz_zip_reader_end(&zip_archive);
// Now verify the compressed data
for (sort_iter = 0; sort_iter < 2; sort_iter++)
{
memset(&zip_archive, 0, sizeof(zip_archive));
status = mz_zip_reader_init_file(&zip_archive, s_Test_archive_filename, sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
if (!status)
{
printf("mz_zip_reader_init_file() failed!\n");
return EXIT_FAILURE;
}
for (i = 0; i < N; i++)
{
sprintf(archive_filename, "%u.txt", i);
sprintf(data, "%u %s %u", (N - 1) - i, s_pTest_str, i);
// Try to extract all the files to the heap.
p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
if (!p)
{
printf("mz_zip_reader_extract_file_to_heap() failed!\n");
mz_zip_reader_end(&zip_archive);
return EXIT_FAILURE;
}
// Make sure the extraction really succeeded.
if ((uncomp_size != (strlen(data) + 1)) || (memcmp(p, data, strlen(data))))
{
printf("mz_zip_reader_extract_file_to_heap() failed to extract the proper data\n");
mz_free(p);
mz_zip_reader_end(&zip_archive);
return EXIT_FAILURE;
}
printf("Successfully extracted file \"%s\", size %u\n", archive_filename, (uint)uncomp_size);
printf("File data: \"%s\"\n", (const char *)p);
// We're done.
mz_free(p);
}
// Close the archive, freeing any resources it was using
mz_zip_reader_end(&zip_archive);
}
printf("Success.\n");
return EXIT_SUCCESS;
}
static int lmz_reader_get_num_files(lua_State *L) {
lmz_file_t* zip = luaL_checkudata(L, 1, "miniz_reader");
lua_pushinteger(L, mz_zip_reader_get_num_files(&(zip->archive)));
return 1;
}
bool pak::bin( const std::string &bin_import ) //const
{
this->clear();
std::vector<pakfile> result;
if( !bin_import.size() )
return true; // :)
if( type == paktype::ZIP )
{
// Try to open the archive.
mz_zip_archive zip_archive;
memset(&zip_archive, 0, sizeof(zip_archive));
mz_bool status = mz_zip_reader_init_mem( &zip_archive, (void *)bin_import.c_str(), bin_import.size(), 0 );
if( !status )
return "mz_zip_reader_init_file() failed!", false;
// Get and print information about each file in the archive.
for( unsigned int i = 0; i < mz_zip_reader_get_num_files(&zip_archive); i++ )
{
mz_zip_archive_file_stat file_stat;
if( !mz_zip_reader_file_stat( &zip_archive, i, &file_stat ) )
{
mz_zip_reader_end( &zip_archive );
return "mz_zip_reader_file_stat() failed!", false;
}
result.push_back( pakfile() );
result.back()["filename"] = file_stat.m_filename;
result.back()["comment"] = file_stat.m_comment;
result.back()["size"] = (unsigned int)file_stat.m_uncomp_size;
result.back()["size_z"] = (unsigned int)file_stat.m_comp_size;
//result.back()["modify_time"] = ze.mtime;
//result.back()["access_time"] = ze.atime;
//result.back()["create_time"] = ze.ctime;
//result.back()["attributes"] = ze.attr;
if( const bool decode = true )
{
// Try to extract file to the heap.
size_t uncomp_size;
void *p = mz_zip_reader_extract_file_to_heap(&zip_archive, file_stat.m_filename, &uncomp_size, 0);
if( !p )
{
mz_zip_reader_end(&zip_archive);
return "mz_zip_reader_extract_file_to_heap() failed!", false;
}
// Make sure the extraction really succeeded.
/*
if ((uncomp_size != strlen(s_pStr)) || (memcmp(p, s_pStr, strlen(s_pStr))))
{
free(p);
mz_zip_reader_end(&zip_archive);
return "mz_zip_reader_extract_file_to_heap() failed to extract the proper data", false;
}
*/
result.back()["content"].resize( uncomp_size );
memcpy( (void *)result.back()["content"].data(), p, uncomp_size );
free(p);
}
}
// We're done.
mz_zip_reader_end(&zip_archive);
}
else
{}
this->resize( result.size() );
std::copy( result.begin(), result.end(), this->begin() );
return true;
}
