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();
}
static int Lzip_read_string(lua_State *L) {
size_t len;
const char *s = luaL_checklstring(L, 1, &len);
mz_uint32 flags = (mz_uint32)luaL_optinteger(L, 2, 0);
mz_zip_archive *za = lua_newuserdata(L, sizeof(mz_zip_archive));
mz_zip_zero_struct(za);
if (!mz_zip_reader_init_mem(za, s, len, flags))
return lmz_zip_pusherror(L, za, NULL);
luaL_setmetatable(L, LMZ_ZIP_READER);
lua_pushvalue(L, 1);
lua_rawsetp(L, LUA_REGISTRYINDEX, za);
return 1;
}
// open from memory
bool ZipIO::openArchive(const void *Memory, size_t Size) {
// first close last opened archive
_kaname = "";
closeArchive();
// inite object
memset(&_kzarchive, 0, sizeof(_kzarchive));
// open archive
mz_bool status = mz_zip_reader_init_mem(&_kzarchive, Memory, Size, 0);
if (!status) return false;
_kaname = "memory-block";
_kisopen = true;
return true;
}
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);
}
}
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;
}
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;
}