2019-11-23 20:27:39 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
|
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
2021-07-15 23:03:43 +08:00
|
|
|
Copyright (c) 2021 Bytedance Inc.
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-10-01 16:24:52 +08:00
|
|
|
https://axmolengine.github.io/
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
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:
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
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.
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include "base/ZipUtils.h"
|
|
|
|
|
|
|
|
#ifdef MINIZIP_FROM_SYSTEM
|
2021-12-25 10:04:45 +08:00
|
|
|
# include <minizip/unzip.h>
|
|
|
|
#else // from our embedded sources
|
|
|
|
# include "unzip.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
#endif
|
2023-08-31 17:57:19 +08:00
|
|
|
#include "ioapi_mem.h"
|
2021-06-18 11:31:07 +08:00
|
|
|
#include <ioapi.h>
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
#include <memory>
|
|
|
|
|
|
|
|
#include <zlib.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <set>
|
|
|
|
|
2023-06-11 13:08:08 +08:00
|
|
|
#include "base/Data.h"
|
|
|
|
#include "base/Macros.h"
|
|
|
|
#include "platform/FileUtils.h"
|
2019-11-23 20:27:39 +08:00
|
|
|
#include <map>
|
2019-12-01 01:16:46 +08:00
|
|
|
#include <mutex>
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2023-06-24 21:18:27 +08:00
|
|
|
#include "yasio/string_view.hpp"
|
2021-07-15 23:03:43 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// minizip 1.2.0 is same with other platforms
|
2021-12-25 10:04:45 +08:00
|
|
|
#define unzGoToFirstFile64(A, B, C, D) unzGoToFirstFile2(A, B, C, D, NULL, 0, NULL, 0)
|
|
|
|
#define unzGoToNextFile64(A, B, C, D) unzGoToNextFile2(A, B, C, D, NULL, 0, NULL, 0)
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_BEGIN
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned int ZipUtils::s_uEncryptedPvrKeyParts[4] = {0, 0, 0, 0};
|
2019-11-23 20:27:39 +08:00
|
|
|
unsigned int ZipUtils::s_uEncryptionKey[1024];
|
|
|
|
bool ZipUtils::s_bEncryptionKeyIsValid = false;
|
|
|
|
|
|
|
|
// --------------------- ZipUtils ---------------------
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
inline void ZipUtils::decodeEncodedPvr(unsigned int* data, ssize_t len)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
const int enclen = 1024;
|
2019-11-23 20:27:39 +08:00
|
|
|
const int securelen = 512;
|
2021-12-25 10:04:45 +08:00
|
|
|
const int distance = 64;
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// check if key was set
|
|
|
|
// make sure to call caw_setkey_part() for all 4 key parts
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(s_uEncryptedPvrKeyParts[0] != 0,
|
2023-08-31 17:57:19 +08:00
|
|
|
"Cocos2D: CCZ file is encrypted but key part 0 is not set. Did you call "
|
2021-12-25 10:04:45 +08:00
|
|
|
"ZipUtils::setPvrEncryptionKeyPart(...)?");
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(s_uEncryptedPvrKeyParts[1] != 0,
|
2023-08-31 17:57:19 +08:00
|
|
|
"Cocos2D: CCZ file is encrypted but key part 1 is not set. Did you call "
|
2021-12-25 10:04:45 +08:00
|
|
|
"ZipUtils::setPvrEncryptionKeyPart(...)?");
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(s_uEncryptedPvrKeyParts[2] != 0,
|
2023-08-31 17:57:19 +08:00
|
|
|
"Cocos2D: CCZ file is encrypted but key part 2 is not set. Did you call "
|
2021-12-25 10:04:45 +08:00
|
|
|
"ZipUtils::setPvrEncryptionKeyPart(...)?");
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(s_uEncryptedPvrKeyParts[3] != 0,
|
2023-08-31 17:57:19 +08:00
|
|
|
"Cocos2D: CCZ file is encrypted but key part 3 is not set. Did you call "
|
2021-12-25 10:04:45 +08:00
|
|
|
"ZipUtils::setPvrEncryptionKeyPart(...)?");
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// create long key
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!s_bEncryptionKeyIsValid)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
unsigned int y, p, e;
|
|
|
|
unsigned int rounds = 6;
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned int sum = 0;
|
|
|
|
unsigned int z = s_uEncryptionKey[enclen - 1];
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
do
|
|
|
|
{
|
|
|
|
#define DELTA 0x9e3779b9
|
2021-12-25 10:04:45 +08:00
|
|
|
#define MX (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (s_uEncryptedPvrKeyParts[(p & 3) ^ e] ^ z)))
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
sum += DELTA;
|
|
|
|
e = (sum >> 2) & 3;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
for (p = 0; p < enclen - 1; p++)
|
|
|
|
{
|
|
|
|
y = s_uEncryptionKey[p + 1];
|
|
|
|
z = s_uEncryptionKey[p] += MX;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
y = s_uEncryptionKey[0];
|
|
|
|
z = s_uEncryptionKey[enclen - 1] += MX;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
} while (--rounds);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
s_bEncryptionKeyIsValid = true;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
int b = 0;
|
|
|
|
int i = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// encrypt first part completely
|
2021-12-25 10:04:45 +08:00
|
|
|
for (; i < len && i < securelen; i++)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
data[i] ^= s_uEncryptionKey[b++];
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (b >= enclen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
b = 0;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// encrypt second section partially
|
2021-12-25 10:04:45 +08:00
|
|
|
for (; i < len; i += distance)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
data[i] ^= s_uEncryptionKey[b++];
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (b >= enclen)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
b = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
inline unsigned int ZipUtils::checksumPvr(const unsigned int* data, ssize_t len)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
unsigned int cs = 0;
|
|
|
|
const int cslen = 128;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
len = (len < cslen) ? len : cslen;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
for (int i = 0; i < len; i++)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
cs = cs ^ data[i];
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return cs;
|
|
|
|
}
|
|
|
|
|
|
|
|
// memory in iPhone is precious
|
|
|
|
// Should buffer factor be 1.5 instead of 2 ?
|
|
|
|
#define BUFFER_INC_FACTOR (2)
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int ZipUtils::inflateMemoryWithHint(unsigned char* in,
|
|
|
|
ssize_t inLength,
|
|
|
|
unsigned char** out,
|
|
|
|
ssize_t* outLength,
|
|
|
|
ssize_t outLengthHint)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
/* ret value */
|
|
|
|
int err = Z_OK;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
ssize_t bufferSize = outLengthHint;
|
2021-12-25 10:04:45 +08:00
|
|
|
*out = (unsigned char*)malloc(bufferSize);
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
z_stream d_stream; /* decompression stream */
|
|
|
|
d_stream.zalloc = (alloc_func)0;
|
2021-12-25 10:04:45 +08:00
|
|
|
d_stream.zfree = (free_func)0;
|
2019-11-23 20:27:39 +08:00
|
|
|
d_stream.opaque = (voidpf)0;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
d_stream.next_in = in;
|
|
|
|
d_stream.avail_in = static_cast<unsigned int>(inLength);
|
|
|
|
d_stream.next_out = *out;
|
2019-11-23 20:27:39 +08:00
|
|
|
d_stream.avail_out = static_cast<unsigned int>(bufferSize);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* window size to hold 256k */
|
2021-12-25 10:04:45 +08:00
|
|
|
if ((err = inflateInit2(&d_stream, 15 + 32)) != Z_OK)
|
2019-11-23 20:27:39 +08:00
|
|
|
return err;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
err = inflate(&d_stream, Z_NO_FLUSH);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (err == Z_STREAM_END)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
switch (err)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
case Z_NEED_DICT:
|
|
|
|
err = Z_DATA_ERROR;
|
|
|
|
case Z_DATA_ERROR:
|
|
|
|
case Z_MEM_ERROR:
|
|
|
|
inflateEnd(&d_stream);
|
|
|
|
return err;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// not enough memory ?
|
|
|
|
if (err != Z_STREAM_END)
|
|
|
|
{
|
|
|
|
*out = (unsigned char*)realloc(*out, bufferSize * BUFFER_INC_FACTOR);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* not enough memory, ouch */
|
2021-12-25 10:04:45 +08:00
|
|
|
if (!*out)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: realloc failed");
|
2019-11-23 20:27:39 +08:00
|
|
|
inflateEnd(&d_stream);
|
|
|
|
return Z_MEM_ERROR;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
d_stream.next_out = *out + bufferSize;
|
2019-11-23 20:27:39 +08:00
|
|
|
d_stream.avail_out = static_cast<unsigned int>(bufferSize);
|
|
|
|
bufferSize *= BUFFER_INC_FACTOR;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
*outLength = bufferSize - d_stream.avail_out;
|
2021-12-25 10:04:45 +08:00
|
|
|
err = inflateEnd(&d_stream);
|
2019-11-23 20:27:39 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ssize_t ZipUtils::inflateMemoryWithHint(unsigned char* in, ssize_t inLength, unsigned char** out, ssize_t outLengthHint)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
ssize_t outLength = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
int err = inflateMemoryWithHint(in, inLength, out, &outLength, outLengthHint);
|
|
|
|
|
|
|
|
if (err != Z_OK || *out == nullptr)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
if (err == Z_MEM_ERROR)
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: Out of memory while decompressing map data!");
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (err == Z_VERSION_ERROR)
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: Incompatible zlib version!");
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else if (err == Z_DATA_ERROR)
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: Incorrect zlib compressed data!");
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: Unknown error while decompressing map data!");
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (*out)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
free(*out);
|
|
|
|
*out = nullptr;
|
|
|
|
}
|
|
|
|
outLength = 0;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return outLength;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ssize_t ZipUtils::inflateMemory(unsigned char* in, ssize_t inLength, unsigned char** out)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// 256k for hint
|
|
|
|
return inflateMemoryWithHint(in, inLength, out, 256 * 1024);
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int ZipUtils::inflateGZipFile(const char* path, unsigned char** out)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
int len;
|
|
|
|
unsigned int offset = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(out, "out can't be nullptr.");
|
|
|
|
AXASSERT(&*out, "&*out can't be nullptr.");
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-24 23:15:56 +08:00
|
|
|
gzFile inFile = gzopen(path, "rb");
|
2021-12-25 10:04:45 +08:00
|
|
|
if (inFile == nullptr)
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: error open gzip file: %s", path);
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
/* 512k initial decompress buffer */
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned int bufferSize = 512 * 1024;
|
2019-11-23 20:27:39 +08:00
|
|
|
unsigned int totalBufferSize = bufferSize;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
*out = (unsigned char*)malloc(bufferSize);
|
|
|
|
if (*out == NULL)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: out of memory");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
for (;;)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
len = gzread(inFile, *out + offset, bufferSize);
|
|
|
|
if (len < 0)
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: error in gzread");
|
2021-12-25 10:04:45 +08:00
|
|
|
free(*out);
|
2019-11-23 20:27:39 +08:00
|
|
|
*out = nullptr;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (len == 0)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
offset += len;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// finish reading the file
|
2021-12-25 10:04:45 +08:00
|
|
|
if ((unsigned int)len < bufferSize)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
bufferSize *= BUFFER_INC_FACTOR;
|
|
|
|
totalBufferSize += bufferSize;
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned char* tmp = (unsigned char*)realloc(*out, totalBufferSize);
|
|
|
|
|
|
|
|
if (!tmp)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: out of memory");
|
2021-12-25 10:04:45 +08:00
|
|
|
free(*out);
|
2019-11-23 20:27:39 +08:00
|
|
|
*out = nullptr;
|
|
|
|
return -1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
*out = tmp;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (gzclose(inFile) != Z_OK)
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: gzclose failed");
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool ZipUtils::isCCZFile(const char* path)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// load file into memory
|
|
|
|
Data compressedData = FileUtils::getInstance()->getDataFromFile(path);
|
|
|
|
|
|
|
|
if (compressedData.isNull())
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: loading file failed");
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return isCCZBuffer(compressedData.getBytes(), compressedData.getSize());
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool ZipUtils::isCCZBuffer(const unsigned char* buffer, ssize_t len)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (static_cast<size_t>(len) < sizeof(struct CCZHeader))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
struct CCZHeader* header = (struct CCZHeader*)buffer;
|
|
|
|
return header->sig[0] == 'C' && header->sig[1] == 'C' && header->sig[2] == 'Z' &&
|
|
|
|
(header->sig[3] == '!' || header->sig[3] == 'p');
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool ZipUtils::isGZipFile(const char* path)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// load file into memory
|
|
|
|
Data compressedData = FileUtils::getInstance()->getDataFromFile(path);
|
|
|
|
|
|
|
|
if (compressedData.isNull())
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: ZipUtils: loading file failed");
|
2019-11-23 20:27:39 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return isGZipBuffer(compressedData.getBytes(), compressedData.getSize());
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
bool ZipUtils::isGZipBuffer(const unsigned char* buffer, ssize_t len)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
if (len < 2)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return buffer[0] == 0x1F && buffer[1] == 0x8B;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int ZipUtils::inflateCCZBuffer(const unsigned char* buffer, ssize_t bufferLen, unsigned char** out)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
struct CCZHeader* header = (struct CCZHeader*)buffer;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// verify header
|
2021-12-25 10:04:45 +08:00
|
|
|
if (header->sig[0] == 'C' && header->sig[1] == 'C' && header->sig[2] == 'Z' && header->sig[3] == '!')
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// verify header version
|
2022-07-16 10:43:05 +08:00
|
|
|
unsigned int version = AX_SWAP_INT16_BIG_TO_HOST(header->version);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (version > 2)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: Unsupported CCZ header format");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// verify compression format
|
2022-07-16 10:43:05 +08:00
|
|
|
if (AX_SWAP_INT16_BIG_TO_HOST(header->compression_type) != CCZ_COMPRESSION_ZLIB)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: CCZ Unsupported compression method");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else if (header->sig[0] == 'C' && header->sig[1] == 'C' && header->sig[2] == 'Z' && header->sig[3] == 'p')
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
// encrypted ccz file
|
2021-12-25 10:04:45 +08:00
|
|
|
header = (struct CCZHeader*)buffer;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
// verify header version
|
2022-07-16 10:43:05 +08:00
|
|
|
unsigned int version = AX_SWAP_INT16_BIG_TO_HOST(header->version);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (version > 0)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: Unsupported CCZ header format");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// verify compression format
|
2022-07-16 10:43:05 +08:00
|
|
|
if (AX_SWAP_INT16_BIG_TO_HOST(header->compression_type) != CCZ_COMPRESSION_ZLIB)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: CCZ Unsupported compression method");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// decrypt
|
2021-12-25 10:04:45 +08:00
|
|
|
unsigned int* ints = (unsigned int*)(buffer + 12);
|
|
|
|
ssize_t enclen = (bufferLen - 12) / 4;
|
2019-11-23 20:27:39 +08:00
|
|
|
|
|
|
|
decodeEncodedPvr(ints, enclen);
|
|
|
|
|
2022-08-08 18:02:17 +08:00
|
|
|
#if _AX_DEBUG > 0
|
2019-11-23 20:27:39 +08:00
|
|
|
// verify checksum in debug mode
|
|
|
|
unsigned int calculated = checksumPvr(ints, enclen);
|
2022-07-16 10:43:05 +08:00
|
|
|
unsigned int required = AX_SWAP_INT32_BIG_TO_HOST(header->reserved);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (calculated != required)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: Can't decrypt image file. Is the decryption key valid?");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: Invalid CCZ file");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
unsigned int len = AX_SWAP_INT32_BIG_TO_HOST(header->len);
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
*out = (unsigned char*)malloc(len);
|
|
|
|
if (!*out)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: CCZ: Failed to allocate memory for texture");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2021-09-02 14:08:57 +08:00
|
|
|
unsigned long destlen = len;
|
2021-12-25 10:04:45 +08:00
|
|
|
size_t source = (size_t)buffer + sizeof(*header);
|
2023-08-31 17:57:19 +08:00
|
|
|
int ret = uncompress(*out, &destlen, (Bytef*)source, bufferLen - sizeof(*header));
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (ret != Z_OK)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: CCZ: Failed to uncompress data");
|
2021-12-25 10:04:45 +08:00
|
|
|
free(*out);
|
2019-11-23 20:27:39 +08:00
|
|
|
*out = nullptr;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int ZipUtils::inflateCCZFile(const char* path, unsigned char** out)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(out, "Invalid pointer for buffer!");
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// load file into memory
|
|
|
|
Data compressedData = FileUtils::getInstance()->getDataFromFile(path);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
if (compressedData.isNull())
|
|
|
|
{
|
2022-10-01 16:24:52 +08:00
|
|
|
AXLOG("axmol: Error loading CCZ compressed file");
|
2019-11-23 20:27:39 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return inflateCCZBuffer(compressedData.getBytes(), compressedData.getSize(), out);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ZipUtils::setPvrEncryptionKeyPart(int index, unsigned int value)
|
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
AXASSERT(index >= 0, "Cocos2d: key part index cannot be less than 0");
|
|
|
|
AXASSERT(index <= 3, "Cocos2d: key part index cannot be greater than 3");
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (s_uEncryptedPvrKeyParts[index] != value)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
s_uEncryptedPvrKeyParts[index] = value;
|
2021-12-25 10:04:45 +08:00
|
|
|
s_bEncryptionKeyIsValid = false;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void ZipUtils::setPvrEncryptionKey(unsigned int keyPart1,
|
|
|
|
unsigned int keyPart2,
|
|
|
|
unsigned int keyPart3,
|
|
|
|
unsigned int keyPart4)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
setPvrEncryptionKeyPart(0, keyPart1);
|
|
|
|
setPvrEncryptionKeyPart(1, keyPart2);
|
|
|
|
setPvrEncryptionKeyPart(2, keyPart3);
|
|
|
|
setPvrEncryptionKeyPart(3, keyPart4);
|
|
|
|
}
|
|
|
|
|
|
|
|
// --------------------- ZipFile ---------------------
|
|
|
|
// from unzip.cpp
|
|
|
|
#define UNZ_MAXFILENAMEINZIP 256
|
|
|
|
|
|
|
|
static const std::string emptyFilename("");
|
|
|
|
|
|
|
|
struct ZipEntryInfo
|
|
|
|
{
|
|
|
|
unz_file_pos pos;
|
2023-08-31 17:57:19 +08:00
|
|
|
uLong uncompressed_size;
|
2019-11-23 20:27:39 +08:00
|
|
|
};
|
|
|
|
|
2021-06-18 11:31:07 +08:00
|
|
|
struct ZipFilePrivate
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
ZipFilePrivate()
|
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
functionOverrides.zopen_file = ZipFile_open_file_func;
|
|
|
|
functionOverrides.zopendisk_file = ZipFile_opendisk_file_func;
|
2021-06-18 11:31:07 +08:00
|
|
|
functionOverrides.zread_file = ZipFile_read_file_func;
|
|
|
|
functionOverrides.zwrite_file = ZipFile_write_file_func;
|
2023-08-31 17:57:19 +08:00
|
|
|
functionOverrides.ztell_file = ZipFile_tell_file_func;
|
|
|
|
functionOverrides.zseek_file = ZipFile_seek_file_func;
|
2021-06-18 11:31:07 +08:00
|
|
|
functionOverrides.zclose_file = ZipFile_close_file_func;
|
|
|
|
functionOverrides.zerror_file = ZipFile_error_file_func;
|
|
|
|
functionOverrides.opaque = this;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
// unzip overrides to support FileStream
|
|
|
|
static long ZipFile_tell_file_func(voidpf opaque, voidpf stream)
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
if (stream == nullptr)
|
|
|
|
return -1;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
auto* fs = (FileStream*)stream;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-06-18 11:31:07 +08:00
|
|
|
return fs->tell();
|
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
static long ZipFile_seek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin)
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
if (stream == nullptr)
|
|
|
|
return -1;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
auto* fs = (FileStream*)stream;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
return fs->seek((int32_t)offset, origin); // must return 0 for success or -1 for error
|
2021-06-18 11:31:07 +08:00
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
static voidpf ZipFile_open_file_func(voidpf opaque, const char* filename, int mode)
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
FileStream::Mode fsMode;
|
2021-06-18 11:31:07 +08:00
|
|
|
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
|
2023-08-31 17:57:19 +08:00
|
|
|
fsMode = FileStream::Mode::READ;
|
2021-06-18 11:31:07 +08:00
|
|
|
else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
2023-08-31 17:57:19 +08:00
|
|
|
fsMode = FileStream::Mode::APPEND;
|
2021-06-18 11:31:07 +08:00
|
|
|
else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
2023-08-31 17:57:19 +08:00
|
|
|
fsMode = FileStream::Mode::WRITE;
|
2021-06-18 11:31:07 +08:00
|
|
|
else
|
|
|
|
return nullptr;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
return FileUtils::getInstance()->openFileStream(filename, fsMode).release();
|
2021-06-18 11:31:07 +08:00
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static voidpf ZipFile_opendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
if (stream == nullptr)
|
|
|
|
return nullptr;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
auto* zipFileInfo = (ZipFilePrivate*)opaque;
|
2021-06-18 11:31:07 +08:00
|
|
|
std::string diskFilename = zipFileInfo->zipFileName;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-06-18 11:31:07 +08:00
|
|
|
const auto pos = diskFilename.rfind('.', std::string::npos);
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (pos != std::string::npos && pos != 0)
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
const size_t bufferSize = 5;
|
|
|
|
char extensionBuffer[bufferSize];
|
|
|
|
snprintf(&extensionBuffer[0], bufferSize, ".z%02u", number_disk + 1);
|
2021-12-25 10:04:45 +08:00
|
|
|
diskFilename.replace(pos, std::min((size_t)4, zipFileInfo->zipFileName.size() - pos), extensionBuffer);
|
2021-06-18 11:31:07 +08:00
|
|
|
return ZipFile_open_file_func(opaque, diskFilename.c_str(), mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
2021-04-25 00:39:47 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static uint32_t ZipFile_read_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size)
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
if (stream == nullptr)
|
2021-12-25 10:04:45 +08:00
|
|
|
return (uint32_t)-1;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
auto* fs = (FileStream*)stream;
|
|
|
|
return fs->read(buf, size);
|
2021-06-18 11:31:07 +08:00
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static uint32_t ZipFile_write_file_func(voidpf opaque, voidpf stream, const void* buf, uint32_t size)
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
if (stream == nullptr)
|
2021-12-25 10:04:45 +08:00
|
|
|
return (uint32_t)-1;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
auto* fs = (FileStream*)stream;
|
|
|
|
return fs->write(buf, size);
|
2021-06-18 11:31:07 +08:00
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static int ZipFile_close_file_func(voidpf opaque, voidpf stream)
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
if (stream == nullptr)
|
|
|
|
return -1;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
auto* fs = (FileStream*)stream;
|
2021-12-25 10:04:45 +08:00
|
|
|
const auto result = fs->close(); // 0 for success, -1 for error
|
2021-06-18 11:31:07 +08:00
|
|
|
delete fs;
|
|
|
|
return result;
|
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
// THis isn't supported by FileStream, so just check if the stream is null and open
|
2021-12-25 10:04:45 +08:00
|
|
|
static int ZipFile_error_file_func(voidpf opaque, voidpf stream)
|
|
|
|
{
|
|
|
|
if (stream == nullptr)
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
auto* fs = (FileStream*)stream;
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (fs->isOpen())
|
|
|
|
{
|
2021-06-18 11:31:07 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-06-18 11:31:07 +08:00
|
|
|
return -1;
|
2021-04-25 00:39:47 +08:00
|
|
|
}
|
2021-06-18 11:31:07 +08:00
|
|
|
// End of Overrides
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2021-06-18 11:31:07 +08:00
|
|
|
std::string zipFileName;
|
|
|
|
unzFile zipFile;
|
|
|
|
std::mutex zipFileMtx;
|
2023-08-31 17:57:19 +08:00
|
|
|
std::unique_ptr<ourmemory_s> memfs;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2021-06-18 11:31:07 +08:00
|
|
|
// std::unordered_map is faster if available on the platform
|
2021-12-31 12:12:40 +08:00
|
|
|
typedef hlookup::string_map<struct ZipEntryInfo> FileListContainer;
|
2021-06-18 11:31:07 +08:00
|
|
|
FileListContainer fileList;
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
zlib_filefunc_def functionOverrides{};
|
2021-06-18 11:31:07 +08:00
|
|
|
};
|
2021-04-25 00:39:47 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
ZipFile* ZipFile::createWithBuffer(const void* buffer, unsigned int size)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
ZipFile* zip = new ZipFile();
|
|
|
|
if (zip->initWithBuffer(buffer, size))
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
return zip;
|
2023-08-31 17:57:19 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
delete zip;
|
|
|
|
return nullptr;
|
|
|
|
}
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
ZipFile::ZipFile() : _data(new ZipFilePrivate())
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
_data->zipFile = nullptr;
|
|
|
|
}
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
ZipFile::ZipFile(std::string_view zipFile, std::string_view filter) : _data(new ZipFilePrivate())
|
|
|
|
{
|
|
|
|
_data->zipFileName = zipFile;
|
|
|
|
_data->zipFile = unzOpen2(zipFile.data(), &_data->functionOverrides);
|
|
|
|
setFilter(filter);
|
|
|
|
}
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
ZipFile::~ZipFile()
|
|
|
|
{
|
|
|
|
if (_data && _data->zipFile)
|
|
|
|
{
|
|
|
|
unzClose(_data->zipFile);
|
|
|
|
}
|
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_SAFE_DELETE(_data);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool ZipFile::setFilter(std::string_view filter)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
do
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(!_data);
|
|
|
|
AX_BREAK_IF(!_data->zipFile);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// clear existing file list
|
|
|
|
_data->fileList.clear();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// UNZ_MAXFILENAMEINZIP + 1 - it is done so in unzLocateFile
|
|
|
|
char szCurrentFileName[UNZ_MAXFILENAMEINZIP + 1];
|
|
|
|
unz_file_info64 fileInfo;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
// go through all files and store position information about the required files
|
2021-12-25 10:04:45 +08:00
|
|
|
int err = unzGoToFirstFile64(_data->zipFile, &fileInfo, szCurrentFileName, sizeof(szCurrentFileName) - 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
while (err == UNZ_OK)
|
|
|
|
{
|
|
|
|
unz_file_pos posInfo;
|
|
|
|
int posErr = unzGetFilePos(_data->zipFile, &posInfo);
|
|
|
|
if (posErr == UNZ_OK)
|
|
|
|
{
|
|
|
|
std::string currentFileName = szCurrentFileName;
|
|
|
|
// cache info about filtered files only (like 'assets/')
|
2021-12-25 10:04:45 +08:00
|
|
|
if (filter.empty() || currentFileName.substr(0, filter.length()) == filter)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
ZipEntryInfo entry;
|
|
|
|
entry.pos = posInfo;
|
|
|
|
entry.uncompressed_size = (uLong)fileInfo.uncompressed_size;
|
|
|
|
_data->fileList[currentFileName] = entry;
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// next file - also get the information about it
|
2021-12-25 10:04:45 +08:00
|
|
|
err = unzGoToNextFile64(_data->zipFile, &fileInfo, szCurrentFileName, sizeof(szCurrentFileName) - 1);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
ret = true;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
} while (false);
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool ZipFile::fileExists(std::string_view fileName) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
do
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(!_data);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
ret = _data->fileList.find(fileName) != _data->fileList.end();
|
2021-12-25 10:04:45 +08:00
|
|
|
} while (false);
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
std::vector<std::string> ZipFile::listFiles(std::string_view pathname) const
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
// filter files which `filename.startsWith(pathname)`
|
|
|
|
// then make each path unique
|
|
|
|
|
2022-10-13 21:44:42 +08:00
|
|
|
std::set<std::string_view> fileSet;
|
2021-12-25 10:04:45 +08:00
|
|
|
ZipFilePrivate::FileListContainer::const_iterator it = _data->fileList.begin();
|
2019-11-23 20:27:39 +08:00
|
|
|
ZipFilePrivate::FileListContainer::const_iterator end = _data->fileList.end();
|
2021-12-25 10:04:45 +08:00
|
|
|
// ensure pathname ends with `/` as a directory
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string ensureDir;
|
|
|
|
std::string_view dirname = pathname[pathname.length() - 1] == '/' ? pathname : (ensureDir.append(pathname) += '/');
|
2022-07-21 19:19:08 +08:00
|
|
|
for (auto&& item : _data->fileList)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string_view filename = item.first;
|
|
|
|
if (cxx20::starts_with(filename, cxx17::string_view{dirname}))
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
2021-12-31 12:12:40 +08:00
|
|
|
std::string_view suffix{filename.substr(dirname.length())};
|
|
|
|
auto pos = suffix.find('/');
|
2019-11-23 20:27:39 +08:00
|
|
|
if (pos == std::string::npos)
|
|
|
|
{
|
2022-10-13 21:44:42 +08:00
|
|
|
fileSet.insert(suffix);
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// fileSet.insert(parts[0] + "/");
|
2022-10-13 21:44:42 +08:00
|
|
|
fileSet.insert(suffix.substr(0, pos + 1));
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-15 23:03:43 +08:00
|
|
|
return std::vector<std::string>{fileSet.begin(), fileSet.end()};
|
2019-11-23 20:27:39 +08:00
|
|
|
}
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
unsigned char* ZipFile::getFileData(std::string_view fileName, ssize_t* size)
|
|
|
|
{
|
|
|
|
unsigned char* buffer = nullptr;
|
|
|
|
if (size)
|
|
|
|
*size = 0;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
AX_BREAK_IF(!_data->zipFile);
|
|
|
|
AX_BREAK_IF(fileName.empty());
|
|
|
|
|
|
|
|
auto it = _data->fileList.find(fileName);
|
|
|
|
AX_BREAK_IF(it == _data->fileList.end());
|
|
|
|
|
|
|
|
ZipEntryInfo& fileInfo = it->second;
|
|
|
|
|
|
|
|
std::unique_lock<std::mutex> lck(_data->zipFileMtx);
|
|
|
|
|
|
|
|
int nRet = unzGoToFilePos(_data->zipFile, &fileInfo.pos);
|
|
|
|
AX_BREAK_IF(UNZ_OK != nRet);
|
|
|
|
|
|
|
|
nRet = unzOpenCurrentFile(_data->zipFile);
|
|
|
|
AX_BREAK_IF(UNZ_OK != nRet);
|
|
|
|
|
|
|
|
buffer = (unsigned char*)malloc(fileInfo.uncompressed_size);
|
|
|
|
int AX_UNUSED nSize =
|
|
|
|
unzReadCurrentFile(_data->zipFile, buffer, static_cast<unsigned int>(fileInfo.uncompressed_size));
|
|
|
|
AXASSERT(nSize == 0 || nSize == (int)fileInfo.uncompressed_size, "the file size is wrong");
|
|
|
|
|
|
|
|
if (size)
|
|
|
|
{
|
|
|
|
*size = fileInfo.uncompressed_size;
|
|
|
|
}
|
|
|
|
unzCloseCurrentFile(_data->zipFile);
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2021-12-31 12:12:40 +08:00
|
|
|
bool ZipFile::getFileData(std::string_view fileName, ResizableBuffer* buffer)
|
2019-11-23 20:27:39 +08:00
|
|
|
{
|
|
|
|
bool res = false;
|
|
|
|
do
|
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(!_data->zipFile);
|
|
|
|
AX_BREAK_IF(fileName.empty());
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-12-01 01:16:46 +08:00
|
|
|
ZipFilePrivate::FileListContainer::iterator it = _data->fileList.find(fileName);
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(it == _data->fileList.end());
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-12-01 01:16:46 +08:00
|
|
|
ZipEntryInfo& fileInfo = it->second;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-12-01 01:16:46 +08:00
|
|
|
std::unique_lock<std::mutex> lck(_data->zipFileMtx);
|
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
int nRet = unzGoToFilePos(_data->zipFile, &fileInfo.pos);
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(UNZ_OK != nRet);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
nRet = unzOpenCurrentFile(_data->zipFile);
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(UNZ_OK != nRet);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
buffer->resize(fileInfo.uncompressed_size);
|
2022-07-16 10:43:05 +08:00
|
|
|
int AX_UNUSED nSize =
|
2021-12-25 10:04:45 +08:00
|
|
|
unzReadCurrentFile(_data->zipFile, buffer->buffer(), static_cast<unsigned int>(fileInfo.uncompressed_size));
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(nSize == 0 || nSize == (int)fileInfo.uncompressed_size, "the file size is wrong");
|
2019-11-23 20:27:39 +08:00
|
|
|
unzCloseCurrentFile(_data->zipFile);
|
|
|
|
res = true;
|
|
|
|
} while (0);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2019-11-23 20:27:39 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string ZipFile::getFirstFilename()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (unzGoToFirstFile(_data->zipFile) != UNZ_OK)
|
|
|
|
return emptyFilename;
|
2019-11-23 20:27:39 +08:00
|
|
|
std::string path;
|
2021-06-18 11:31:07 +08:00
|
|
|
unz_file_info_s info;
|
2019-11-23 20:27:39 +08:00
|
|
|
getCurrentFileInfo(&path, &info);
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string ZipFile::getNextFilename()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (unzGoToNextFile(_data->zipFile) != UNZ_OK)
|
|
|
|
return emptyFilename;
|
2019-11-23 20:27:39 +08:00
|
|
|
std::string path;
|
2021-06-18 11:31:07 +08:00
|
|
|
unz_file_info_s info;
|
2019-11-23 20:27:39 +08:00
|
|
|
getCurrentFileInfo(&path, &info);
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
int ZipFile::getCurrentFileInfo(std::string* filename, unz_file_info_s* info)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
char path[FILENAME_MAX + 1];
|
|
|
|
int ret = unzGetCurrentFileInfo(_data->zipFile, info, path, sizeof(path), nullptr, 0, nullptr, 0);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (ret != UNZ_OK)
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
*filename = emptyFilename;
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-23 20:27:39 +08:00
|
|
|
filename->assign(path);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
bool ZipFile::initWithBuffer(const void* buffer, unsigned int size)
|
|
|
|
{
|
|
|
|
if (!buffer || size == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
zlib_filefunc_def memory_file = {0};
|
|
|
|
|
|
|
|
std::unique_ptr<ourmemory_t> memfs(
|
|
|
|
new ourmemory_t{(char*)const_cast<void*>(buffer), static_cast<uint32_t>(size), 0, 0, 0});
|
|
|
|
fill_memory_filefunc(&memory_file, memfs.get());
|
|
|
|
|
|
|
|
_data->zipFile = unzOpen2(nullptr, &memory_file);
|
|
|
|
if (!_data->zipFile)
|
|
|
|
return false;
|
|
|
|
_data->memfs = std::move(memfs);
|
|
|
|
|
|
|
|
setFilter(emptyFilename);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ZipFile::zfopen(std::string_view fileName, ZipFileStream* zfs)
|
2019-12-01 01:16:46 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
if (!zfs)
|
|
|
|
return false;
|
2019-12-01 01:16:46 +08:00
|
|
|
auto it = _data->fileList.find(fileName);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (it != _data->fileList.end())
|
2023-08-31 17:57:19 +08:00
|
|
|
{
|
|
|
|
zfs->entry = &it->second;
|
|
|
|
zfs->offset = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
zfs->entry = nullptr;
|
|
|
|
zfs->offset = -1;
|
|
|
|
return false;
|
2019-12-01 01:16:46 +08:00
|
|
|
}
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
int ZipFile::zfread(ZipFileStream* zfs, void* buf, unsigned int size)
|
2019-12-01 01:16:46 +08:00
|
|
|
{
|
|
|
|
int n = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
AX_BREAK_IF(zfs == nullptr || zfs->offset >= zfs->entry->uncompressed_size);
|
2019-12-01 01:16:46 +08:00
|
|
|
|
|
|
|
std::unique_lock<std::mutex> lck(_data->zipFileMtx);
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
int nRet = unzGoToFilePos(_data->zipFile, &zfs->entry->pos);
|
2022-07-16 10:43:05 +08:00
|
|
|
AX_BREAK_IF(UNZ_OK != nRet);
|
2019-12-01 01:16:46 +08:00
|
|
|
|
|
|
|
nRet = unzOpenCurrentFile(_data->zipFile);
|
2023-08-31 17:57:19 +08:00
|
|
|
unzSeek64(_data->zipFile, zfs->offset, SEEK_SET);
|
2019-12-01 01:16:46 +08:00
|
|
|
n = unzReadCurrentFile(_data->zipFile, buf, size);
|
|
|
|
if (n > 0)
|
2023-08-31 17:57:19 +08:00
|
|
|
zfs->offset += n;
|
2019-12-01 01:16:46 +08:00
|
|
|
|
|
|
|
unzCloseCurrentFile(_data->zipFile);
|
|
|
|
|
|
|
|
} while (false);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
int32_t ZipFile::zfseek(ZipFileStream* zfs, int32_t offset, int origin)
|
2019-12-01 01:16:46 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
int32_t result = -1;
|
|
|
|
if (zfs != nullptr)
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
|
|
|
switch (origin)
|
|
|
|
{
|
2019-12-01 01:16:46 +08:00
|
|
|
case SEEK_SET:
|
|
|
|
result = offset;
|
|
|
|
break;
|
|
|
|
case SEEK_CUR:
|
2023-08-31 17:57:19 +08:00
|
|
|
result = zfs->offset + offset;
|
2019-12-01 01:16:46 +08:00
|
|
|
break;
|
|
|
|
case SEEK_END:
|
2023-08-31 17:57:19 +08:00
|
|
|
result = (int32_t)zfs->entry->uncompressed_size + offset;
|
2019-12-01 01:16:46 +08:00
|
|
|
break;
|
|
|
|
default:;
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
if (result >= 0)
|
2023-08-31 17:57:19 +08:00
|
|
|
{
|
|
|
|
zfs->offset = result;
|
|
|
|
}
|
2019-12-01 01:16:46 +08:00
|
|
|
else
|
|
|
|
result = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2021-05-31 15:08:44 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
void ZipFile::zfclose(ZipFileStream* zfs)
|
|
|
|
{
|
|
|
|
if (zfs != nullptr && zfs->entry != nullptr)
|
|
|
|
{
|
|
|
|
zfs->entry = nullptr;
|
|
|
|
zfs->offset = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
long long ZipFile::zfsize(ZipFileStream* zfs)
|
2021-05-31 15:08:44 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
if (zfs != nullptr && zfs->entry != nullptr)
|
|
|
|
{
|
|
|
|
return zfs->entry->uncompressed_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
2021-05-31 15:08:44 +08:00
|
|
|
}
|
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
unsigned char* ZipFile::getFileDataFromZip(std::string_view zipFilePath, std::string_view filename, ssize_t* size)
|
2020-09-06 17:00:20 +08:00
|
|
|
{
|
2023-08-31 17:57:19 +08:00
|
|
|
unsigned char* buffer = nullptr;
|
|
|
|
unzFile file = nullptr;
|
|
|
|
*size = 0;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
AX_BREAK_IF(zipFilePath.empty());
|
|
|
|
|
|
|
|
file = unzOpen(zipFilePath.data());
|
|
|
|
AX_BREAK_IF(!file);
|
|
|
|
|
|
|
|
// minizip 1.2.0 is same with other platforms
|
|
|
|
int ret = unzLocateFile(file, filename.data(), nullptr);
|
|
|
|
|
|
|
|
AX_BREAK_IF(UNZ_OK != ret);
|
|
|
|
|
|
|
|
char filePathA[260];
|
|
|
|
unz_file_info_s fileInfo;
|
|
|
|
ret = unzGetCurrentFileInfo(file, &fileInfo, filePathA, sizeof(filePathA), nullptr, 0, nullptr, 0);
|
|
|
|
AX_BREAK_IF(UNZ_OK != ret);
|
|
|
|
|
|
|
|
ret = unzOpenCurrentFile(file);
|
|
|
|
AX_BREAK_IF(UNZ_OK != ret);
|
|
|
|
|
|
|
|
buffer = (unsigned char*)malloc(fileInfo.uncompressed_size);
|
|
|
|
int AX_UNUSED readedSize = unzReadCurrentFile(file, buffer, static_cast<unsigned>(fileInfo.uncompressed_size));
|
|
|
|
AXASSERT(readedSize == 0 || readedSize == (int)fileInfo.uncompressed_size, "the file size is wrong");
|
|
|
|
|
|
|
|
*size = fileInfo.uncompressed_size;
|
|
|
|
unzCloseCurrentFile(file);
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
if (file)
|
|
|
|
{
|
|
|
|
unzClose(file);
|
|
|
|
}
|
2020-09-06 17:00:20 +08:00
|
|
|
|
2023-08-31 17:57:19 +08:00
|
|
|
return buffer;
|
2020-09-06 17:00:20 +08:00
|
|
|
}
|
2019-12-01 01:16:46 +08:00
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
NS_AX_END
|