hane 1.0.0

package/vendor/zsign/src/common/archive.cpp

@@ -0,0 +1,246 @@
+#include "archive.h"
+
+#ifdef _WIN32
+#include <minizip/zip.h>
+#include <minizip/unzip.h>
+#else
+#include <zip.h>
+#include <unzip.h>
+#endif
+
+void Zip::GetModificationTime(const char* path, void* zfi)
+{
+	zip_fileinfo* zi = (zip_fileinfo*)zfi;
+	struct stat st = { 0 };
+	memset(zi, 0, sizeof(zip_fileinfo));
+	if (0 == stat(path, &st)) {
+#ifdef _WIN32
+		struct tm tm = { 0 };
+		localtime_s(&tm, &st.st_mtime);
+		zi->tmz_date.tm_sec = tm.tm_sec;
+		zi->tmz_date.tm_min = tm.tm_min;
+		zi->tmz_date.tm_hour = tm.tm_hour;
+		zi->tmz_date.tm_mday = tm.tm_mday;
+		zi->tmz_date.tm_mon = tm.tm_mon;
+		zi->tmz_date.tm_year = tm.tm_year + 1900;
+#else
+		struct tm* tm = localtime(&st.st_mtime);
+		zi->tmz_date.tm_sec = tm->tm_sec;
+		zi->tmz_date.tm_min = tm->tm_min;
+		zi->tmz_date.tm_hour = tm->tm_hour;
+		zi->tmz_date.tm_mday = tm->tm_mday;
+		zi->tmz_date.tm_mon = tm->tm_mon;
+		zi->tmz_date.tm_year = tm->tm_year + 1900;
+#endif
+	}
+}
+
+bool Zip::_WriteFileToZip(void* hZip, const string& strFile, const string& strRelativePath, int zip_level)
+{
+	FILE* fp = NULL;
+	_fopen64(fp, strFile.c_str(), "rb");
+	if (NULL == fp) {
+		ZLog::ErrorV(">>> Zip: Failed to open file: %s\n", strFile.c_str());
+		return false;
+	}
+
+	zip_fileinfo zi = { 0 };
+	GetModificationTime(strFile.c_str(), &zi);
+	if (ZIP_OK != zipOpenNewFileInZip3_64(hZip, strRelativePath.c_str(), &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, zip_level, 0, -MAX_WBITS, DEF_MEM_LEVEL, 0, NULL, 0, 0)) {
+		fclose(fp);
+		ZLog::ErrorV(">>> Zip: Failed to add file to zip: %s\n", strRelativePath.c_str());
+		return false;
+	}
+
+	bool bRet = true;
+	char buffer[4096];
+	size_t bytes_read = fread(buffer, 1, sizeof(buffer), fp);
+	while (bytes_read > 0) {
+		if (zipWriteInFileInZip(hZip, buffer, (uint32_t)bytes_read) < 0) {
+			bRet = false;
+			break;
+		}
+		bytes_read = fread(buffer, 1, sizeof(buffer), fp);
+	}
+
+	zipCloseFileInZip(hZip);
+	fclose(fp);
+	return bRet;
+}
+
+bool Zip::_CreateFolderToZip(void* hZip, const string& strFolder, const string& strRelativePath, int zip_level)
+{
+	zip_fileinfo zi = { 0 };
+	GetModificationTime(strFolder.c_str(), &zi);
+	if (ZIP_OK != zipOpenNewFileInZip3_64(hZip, strRelativePath.c_str(), &zi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, zip_level, 0, -MAX_WBITS, DEF_MEM_LEVEL, 0, NULL, 0, 0)) {
+		ZLog::ErrorV(">>> Zip: Failed to create folder to zip: %s\n", strRelativePath.c_str());
+		return false;
+	}
+	zipCloseFileInZip(hZip);
+	return true;
+}
+
+bool Zip::Archive(const string& strFolder, const string& strZipFile, int nZipLevel)
+{
+	 if (nZipLevel < 0 || nZipLevel > 9) {
+		ZLog::ErrorV(">>> Zip: Invalid compression level: %d\n", nZipLevel);
+        return false;
+    }
+    
+    zipFile zf = zipOpen64(strZipFile.c_str(), 0);
+    if (!zf) {
+		ZLog::ErrorV(">>> Zip: Failed to create zip file: %s\n", strZipFile.c_str());
+        return false;
+    }
+
+	bool bRet = true;
+	ZFile::EnumFolder(strFolder.c_str(), true, NULL, [&](bool bFolder, const string& strPath) {
+		string strRelativePath = strPath.substr(strFolder.size() + 1);
+		ZUtil::StringReplace(strRelativePath, "\\", "/");
+
+#ifdef _WIN32
+		iconv ic;
+		strRelativePath = ic.A2U8(strRelativePath);
+#endif
+
+		if (bFolder) {
+			strRelativePath += "/";
+			if (!_CreateFolderToZip(zf, strPath, strRelativePath, nZipLevel)) {
+				bRet = false;
+				return true;
+			}
+		} else {
+			if (!_WriteFileToZip(zf, strPath, strRelativePath, nZipLevel)) {
+				bRet = false;
+				return true;
+			}
+		}
+		return false;
+	});
+
+    zipClose(zf, NULL);
+	return bRet;
+}
+
+bool Zip::_EnumZipItems(const char* zip_file, enum_zip_items_callback callback)
+{
+	unzFile uf = unzOpen64(zip_file);
+	if (NULL == uf) {
+		return false;
+	}
+
+	unz_global_info64 gi;
+	if (UNZ_OK != unzGetGlobalInfo64(uf, &gi)) {
+		unzClose(uf);
+		return false;
+	}
+
+	bool bRet = true;
+	unz_file_info64 fi = { 0 };
+	char szPath[PATH_MAX] = { 0 };
+	for (int i = 0; i < gi.number_entry; i++) {
+		if (UNZ_OK != unzGetCurrentFileInfo64(uf, &fi, szPath, PATH_MAX, NULL, 0, NULL, 0)) {
+			bRet = false;
+			break;
+		}
+
+		string strPath = szPath;
+		ZUtil::StringTrim(strPath);
+
+#ifdef _WIN32
+		iconv ic;
+		strPath = ic.U82A(strPath);
+#endif
+
+		bool bFolder = false;
+		if (('/' == strPath.back())) {
+			bFolder = true;
+			strPath.pop_back();
+		}
+
+		if (NULL != callback) {
+			if (!callback(uf, bFolder, strPath)) {
+				bRet = false;
+				break;
+			}
+		}
+
+		if (i < gi.number_entry - 1) {
+			if (UNZ_OK != unzGoToNextFile(uf)) {
+				bRet = false;
+				break;
+			}
+		}
+	}
+
+	unzClose(uf);
+	return bRet;
+}
+
+bool Zip::_ReadFileFromZip(void* hZip, const string& strPath, const string& strRootFolder)
+{
+	string strFile = strRootFolder + "/" + strPath;
+	string strFolder = strFile;
+	ZFile::PathRemoveFileSpec(strFolder);
+	if (!ZFile::CreateFolder(strFolder.c_str())) {
+		return false;
+	}
+
+	if (UNZ_OK != unzOpenCurrentFile(hZip)) {
+		return false;
+	}
+
+	FILE* fp = NULL;
+	_fopen64(fp, strFile.c_str(), "wb");
+	if (NULL == fp) {
+		unzCloseCurrentFile(hZip);
+		return false;
+	}
+
+	bool bRet = true;
+	uint32_t uBufSize = 512 * 1024;
+	char* pbuff = (char*)malloc(uBufSize);
+	if (NULL != pbuff) {
+		int32_t nReaded = unzReadCurrentFile(hZip, pbuff, uBufSize);
+		while (nReaded > 0) {
+			if (nReaded != fwrite(pbuff, 1, nReaded, fp)) {
+				bRet = false;
+				break;
+			}
+			nReaded = unzReadCurrentFile(hZip, pbuff, uBufSize);
+		}
+		free(pbuff);
+	} else {
+		bRet = false;
+	}
+
+	fclose(fp);
+	unzCloseCurrentFile(hZip);
+	return bRet;
+}
+
+bool Zip::_Extract(const char* zip_file, const char* output_folder)
+{
+	return _EnumZipItems(zip_file, [&](unzFile uFile, bool bFolder, const string& strPath) {
+		if (bFolder) {
+			if (!ZFile::CreateFolderV("%s/%s", output_folder, strPath.c_str())) {
+				return false;
+			}
+		} else {
+			if (!_ReadFileFromZip(uFile, strPath, output_folder)) {
+				return false;
+			}
+		}
+		return true;
+	});
+}
+
+bool Zip::Extract(const char* zip_file, const char* output_folder)
+{
+	ZFile::RemoveFolder(output_folder);
+	if (!_Extract(zip_file, output_folder)) {
+		ZFile::RemoveFolder(output_folder);
+		return false;
+	}
+	return true;
+}

package/vendor/zsign/src/common/archive.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "common.h"
+
+class Zip
+{
+public:
+	
+	static bool Archive(const string& strFolder, const string& strZipFile, int nZipLevel);
+	static bool Extract(const char* zip_file, const char* output_folder);
+
+private:
+	typedef function<bool(void* hFile, bool bFolder, const string& strPath)> enum_zip_items_callback;
+
+private:
+	static bool _EnumZipItems(const char* zip_file, enum_zip_items_callback callback);
+	static bool _ReadFileFromZip(void* hZip, const string& strPath, const string& strRootFolder);
+	static bool _Extract(const char* zip_file, const char* output_folder);
+	static bool _WriteFileToZip(void* hZip, const string& strFile, const string& strRootFolder, int zip_level);
+	static bool _CreateFolderToZip(void* hZip, const string& strFolder, const string& strRootFolder, int zip_level);
+	static void GetModificationTime(const char* path, void* zi);
+};

package/vendor/zsign/src/common/base64.cpp

@@ -0,0 +1,166 @@
+#include "base64.h"
+#include <string.h>
+
+#define B0(a) (a & 0xFF)
+#define B1(a) (a >> 8 & 0xFF)
+#define B2(a) (a >> 16 & 0xFF)
+#define B3(a) (a >> 24 & 0xFF)
+
+jbase64::jbase64()
+{
+}
+
+jbase64::~jbase64()
+{
+	if (!m_array_encodes.empty()) {
+		for (size_t i = 0; i < m_array_encodes.size(); i++) {
+			delete[] m_array_encodes[i];
+		}
+		m_array_encodes.clear();
+	}
+
+	if (!m_array_decodes.empty()) {
+		for (size_t i = 0; i < m_array_decodes.size(); i++) {
+			delete[] m_array_decodes[i];
+		}
+		m_array_decodes.clear();
+	}
+}
+
+char jbase64::get_b64_char(int index)
+{
+	static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	if (index >= 0 && index < 64) {
+		return table[index];
+	}
+	return '=';
+}
+
+int jbase64::get_b64_index(char ch)
+{
+	int index = -1;
+	if (ch >= 'A' && ch <= 'Z') {
+		index = ch - 'A';
+	} else if (ch >= 'a' && ch <= 'z') {
+		index = ch - 'a' + 26;
+	} else if (ch >= '0' && ch <= '9') {
+		index = ch - '0' + 52;
+	} else if (ch == '+') {
+		index = 62;
+	} else if (ch == '/') {
+		index = 63;
+	}
+	return index;
+}
+
+const char* jbase64::encode(const char* src, int src_len)
+{
+	if (0 == src_len) {
+		src_len = (int)strlen(src);
+	}
+
+	if (src_len <= 0) {
+		return "";
+	}
+
+	char* enc = new char[src_len * 3 + 128];
+	m_array_encodes.push_back(enc);
+
+	int i = 0;
+	char* p64 = enc;
+	unsigned char* pcursor = (unsigned char*)src;
+	for (i = 0; i < src_len - 3; i += 3) {
+		unsigned long temp = *(unsigned long*)pcursor;
+		int b0 = get_b64_char((B0(temp) >> 2) & 0x3F);
+		int b1 = get_b64_char((B0(temp) << 6 >> 2 | B1(temp) >> 4) & 0x3F);
+		int b2 = get_b64_char((B1(temp) << 4 >> 2 | B2(temp) >> 6) & 0x3F);
+		int b3 = get_b64_char((B2(temp) << 2 >> 2) & 0x3F);
+		*((unsigned long*)p64) = b0 | b1 << 8 | b2 << 16 | b3 << 24;
+		p64 += 4;
+		pcursor += 3;
+	}
+
+	if (i < src_len) {
+		int rest = src_len - i;
+		unsigned long temp = 0;
+		for (int j = 0; j < rest; ++j) {
+			*(((unsigned char*)&temp) + j) = *pcursor++;
+		}
+		p64[0] = get_b64_char((B0(temp) >> 2) & 0x3F);
+		p64[1] = get_b64_char((B0(temp) << 6 >> 2 | B1(temp) >> 4) & 0x3F);
+		p64[2] = rest > 1 ? get_b64_char((B1(temp) << 4 >> 2 | B2(temp) >> 6) & 0x3F) : '=';
+		p64[3] = rest > 2 ? get_b64_char((B2(temp) << 2 >> 2) & 0x3F) : '=';
+		p64 += 4;
+	}
+	*p64 = '\0';
+	return enc;
+}
+
+const char* jbase64::encode(const string& input)
+{
+	return encode(input.data(), (int)input.size());
+}
+
+const char* jbase64::decode(const char* src, int src_len, int* pdecode_len)
+{
+	if (0 == src_len) {
+		src_len = (int)strlen(src);
+	}
+
+	if (src_len <= 0) {
+		return "";
+	}
+
+	char* dec = new char[src_len];
+	m_array_decodes.push_back(dec);
+
+	int i = 0;
+	char* pbuf = dec;
+	unsigned char* psrc = (unsigned char*)src;
+	for (i = 0; i < src_len - 4; i += 4) {
+		unsigned long temp = *(unsigned long*)psrc;
+		int b0 = (get_b64_index((char)B0(temp)) << 2 | get_b64_index((char)B1(temp)) << 2 >> 6) & 0xFF;
+		int b1 = (get_b64_index((char)B1(temp)) << 4 | get_b64_index((char)B2(temp)) << 2 >> 4) & 0xFF;
+		int b2 = (get_b64_index((char)B2(temp)) << 6 | get_b64_index((char)B3(temp)) << 2 >> 2) & 0xFF;
+		*((unsigned long*)pbuf) = b0 | b1 << 8 | b2 << 16;
+		psrc += 4;
+		pbuf += 3;
+	}
+
+	if (i < src_len) {
+		int rest = src_len - i;
+		unsigned long temp = 0;
+		for (int j = 0; j < rest; ++j) {
+			*(((unsigned char*)&temp) + j) = *psrc++;
+		}
+
+		int b0 = (get_b64_index((char)B0(temp)) << 2 | get_b64_index((char)B1(temp)) << 2 >> 6) & 0xFF;
+		*pbuf++ = b0;
+
+		if ('=' != B1(temp) && '=' != B2(temp)) {
+			int b1 = (get_b64_index((char)B1(temp)) << 4 | get_b64_index((char)B2(temp)) << 2 >> 4) & 0xFF;
+			*pbuf++ = b1;
+		}
+
+		if ('=' != B2(temp) && '=' != B3(temp)) {
+			int b2 = (get_b64_index((char)B2(temp)) << 6 | get_b64_index((char)B3(temp)) << 2 >> 2) & 0xFF;
+			*pbuf++ = b2;
+		}
+	}
+	*pbuf = '\0';
+
+	if (NULL != pdecode_len) {
+		*pdecode_len = (int)(pbuf - dec);
+	}
+
+	return dec;
+}
+
+const char* jbase64::decode(const char* src, string& output)
+{
+	output.clear();
+	int dec_len = 0;
+	const char* p = decode(src, 0, &dec_len);
+	output.append(p, dec_len);
+	return output.data();
+}

package/vendor/zsign/src/common/base64.h

@@ -0,0 +1,30 @@
+#ifndef BASE64_INCLUDED
+#define BASE64_INCLUDED
+
+#include <string>
+#include <vector>
+
+using namespace std;
+
+class jbase64
+{
+public:
+	jbase64();
+	~jbase64();
+
+public:
+	const char* encode(const char* src, int src_len = 0);
+	const char* encode(const string& input);
+	const char* decode(const char* src, int src_len = 0, int* pdecode_len = NULL);
+	const char* decode(const char* src, string& output);
+
+private:
+	inline int get_b64_index(char ch);
+	inline char get_b64_char(int index);
+
+private:
+	vector<char*> m_array_decodes;
+	vector<char*> m_array_encodes;
+};
+
+#endif // BASE64_INCLUDED

package/vendor/zsign/src/common/common.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _WIN32
+
+#include "common_win32.h"
+
+#else
+
+#include <unistd.h>
+#include <ftw.h>
+#include <dirent.h>
+#include <libgen.h>
+#include <getopt.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+
+#define _fopen64(fp, path, mode) {fp = fopen(path, mode); }
+#define _fseeki64	fseeko
+#define _ftelli64	ftello
+
+#endif
+
+#include <set>
+#include <map>
+#include <mutex>
+#include <vector>
+#include <string>
+#include <memory>
+#include <iostream>
+#include <algorithm>
+#include <functional>
+using namespace std;
+
+#define FORMAT_V(x, format) char format[1024] = { 0 }; \
+                        	va_list va_args; \
+							va_start(va_args, x); \
+							vsnprintf(format, 1024, x, va_args); \
+							va_end(va_args);
+
+#include "fs.h"
+#include "sha.h"
+#include "log.h"
+#include "util.h"