myvtm/Module/mod_UpgradeRun/XUnZipZilb.cpp

#include "XUnZipZilb.h"
#include "libtoolkit/path.h"
#include "fileutil.h"
#include <string.h>
#ifdef RVC_OS_WIN
#else
#include <iconv.h>
#include <sys/stat.h>

#endif // RVC_OS_WIN
#define ZIP_ZILP_MAX_FILENAME 512
#define ZIP_ZILP_READ_SIZE 4096

int UnZipToDir(string zipFileName, string destDirPath)
{
	//	Dbg("zipFileName %s destDirPath %s", zipFileName.c_str(), destDirPath.c_str());
	unzFile zfile = unzOpen(zipFileName.c_str());
	if (zfile == NULL)
	{
		Dbg("could open zipFile (%s)", zipFileName.c_str());
		return -1;
	}
	//create directory
	if (!ExistsDirA(destDirPath.c_str())) {
		if (!CreateDirA(destDirPath.c_str(), true)) {
			Dbg("create temp unzip root dir fail: %s",destDirPath.c_str());
			return -1;
		}
	}
	unz_global_info global_info;
	if (unzGetGlobalInfo(zfile, &global_info) != UNZ_OK)
	{
		Dbg("could not read file global info (%s)", zipFileName.c_str());
		unzClose(zfile);
		return -1;
	}
	for (int i = 0; i < global_info.number_entry; i++) {
		if (unZipCurrentFile(zfile, destDirPath) != UNZ_OK) {
			Dbg("unzip fail %s", zipFileName.c_str());
			unzClose(zfile);
			return -1;
		}
		if ((i + 1) < global_info.number_entry) {
			int ret = unzGoToNextFile(zfile);
			if (ret != UNZ_OK) {
				Dbg("error %d with zipfile in unzGoToNextFile", ret);
				unzClose(zfile);
				return -1;
			}
		}
	}
	return 0;
}

int unZipCurrentFile(zipFile zf, string destDirPath)
{
	unz_file_info file_info;
	char zipFilename[ZIP_ZILP_MAX_FILENAME];
	
	string newFileName = "";
	bool isDir = false;
	if (unzGetCurrentFileInfo(zf, &file_info, zipFilename, ZIP_ZILP_MAX_FILENAME, NULL, 0, NULL, 0) != UNZ_OK)
	{
		Dbg("could not read file info");
		return -1;
	}
#ifdef RVC_OS_WIN
	if (is_str_utf8(zipFilename)) {
		//Dbg("file name is UTF8");
		newFileName = utf8_to_gbk(zipFilename);
	}
	else {
		//Dbg("file name is GBK");
		newFileName = zipFilename;
	}
#else
	if (!is_str_utf8(zipFilename)) {
		//Dbg("file name is GBK");
		//newFileName = gbk_to_utf8(zipFilename);
		unsigned char* tempName = utf8_string_create((const char*)zipFilename);
		if (tempName == NULL) {
			Dbg("get utf8 str is null");
			return -1;
		}
		newFileName = (const char*)tempName;
		free(tempName);
	}
	else {
		//Dbg("file name is UTF8");
		newFileName = zipFilename;
	}
#endif // RVC_OS_WIN
	Dbg("unZipCurrentFile newFileName %s", newFileName.c_str());
	string filestr = newFileName;
	//判断是文件还是文件夹

	if (filestr.substr(filestr.length() - 1, 1) == "/") {
		isDir = true;
	}

	if (isDir)
	{   //创建文件夹
		string dirPath = destDirPath + SPLIT_SLASH_STR + newFileName;
		Dbg("creating directory: %s", dirPath.c_str());
		if (!CreateDirA(dirPath.c_str(), true))
		{
			Dbg("creating directory fail: dirPath(%s) zipFileName(%s)", dirPath.c_str(), newFileName.c_str());
			return -1;
		}
	}
	else
	{   //打开zip里面的文件
		string fileNamePath = destDirPath + SPLIT_SLASH_STR + newFileName;
		Dbg("creating file:%s", fileNamePath.c_str());

		//先创建文件的父文件夹
		int pos = fileNamePath.find_last_of(SPLIT_SLASH);
		string newFileDirPath(fileNamePath.substr(0, pos));
		//Dbg("creating dir:%s", newFileDirPath.c_str());
		if (!CreateDirA(newFileDirPath.c_str(), true)) {
			Dbg("creating zip file dir fail: dirPath(%s)", newFileDirPath.c_str());
			return -1;
		}

		if (unzOpenCurrentFile(zf) != UNZ_OK)
		{
			Dbg("could not open zip file ，%s", newFileName);
			return -1;
		}
		// Open a file to write out the data.
		FILE* out = fopen(fileNamePath.c_str(), "wb");

		if (out == NULL)
		{
			Dbg("could not open destination file, %s", fileNamePath.c_str());
			unzCloseCurrentFile(zf);
			return -1;
		}

		int err = UNZ_OK;
		unsigned char * read_buffer= new unsigned char[ZIP_ZILP_READ_SIZE];
		memset(read_buffer, 0, ZIP_ZILP_READ_SIZE);
		do
		{
			err = unzReadCurrentFile(zf, read_buffer, ZIP_ZILP_READ_SIZE);
			if (err < 0)
			{
				Dbg("error %d with zipfile in unzReadCurrentFile", err);
				break;
			}

			// Write data to file.
			if (err > 0)
			{
				if (fwrite(read_buffer, err, 1, out) != 1) {
					Dbg("error in writing extracted file");
					err = UNZ_ERRNO;
					break;
				}
			}
		} while (err > 0);

		delete[] read_buffer;//删除临时对象

		if (out!=NULL) {
			if (fclose(out)!=0) {
				Dbg("fclose new file from zip fail, %s", fileNamePath.c_str());
				unzCloseCurrentFile(zf);
				return -1;
			}
		}

		if (err == UNZ_OK) {
			//正常结束
			err = unzCloseCurrentFile(zf);
			if (err != UNZ_OK) {
				Dbg("error %d with zipfile in unzCloseCurrentFile", err);
				return -1;
			}
			if (changeUnZipFileAtt(fileNamePath.c_str())!=0) {
				return -1;
			}
			return 0;
		}
		else {
			//异常结束
			unzCloseCurrentFile(zf); /* don't lose the error */
			return -1;
		}
	}
	return 0;
}

bool is_str_utf8(const char* str)
{
	unsigned int nBytes = 0;//UFT8可用1-6个字节编码,ASCII用一个字节  
	unsigned char chr = *str;
	bool bAllAscii = true;

	for (unsigned int i = 0; str[i] != '\0'; ++i) {
		chr = *(str + i);
		//判断是否ASCII编码,如果不是,说明有可能是UTF8,ASCII用7位编码,最高位标记为0,0xxxxxxx 
		if (nBytes == 0 && (chr & 0x80) != 0) {
			bAllAscii = false;
		}

		if (nBytes == 0) {
			//如果不是ASCII码,应该是多字节符,计算字节数  
			if (chr >= 0x80) {

				if (chr >= 0xFC && chr <= 0xFD) {
					nBytes = 6;
				}
				else if (chr >= 0xF8) {
					nBytes = 5;
				}
				else if (chr >= 0xF0) {
					nBytes = 4;
				}
				else if (chr >= 0xE0) {
					nBytes = 3;
				}
				else if (chr >= 0xC0) {
					nBytes = 2;
				}
				else {
					return false;
				}

				nBytes--;
			}
		}
		else {
			//多字节符的非首字节,应为 10xxxxxx 
			if ((chr & 0xC0) != 0x80) {
				return false;
			}
			//减到为零为止
			nBytes--;
		}
	}

	//违返UTF8编码规则 
	if (nBytes != 0) {
		return false;
	}

	if (bAllAscii) { //如果全部都是ASCII, 也是UTF8
		return true;
	}

	return true;
}

int changeUnZipFileAtt(const char* path)
{
#ifdef RVC_OS_WIN
	return 0;//windows 默认返回成功
#else
	struct stat attr_of_del;
	if (lstat(path, &attr_of_del) == 0)
	{
		//修改为775属性
		mode_t f_attrib = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH;
		if (chmod(path, f_attrib) != 0)
		{
			Dbg("set file attribute is fail,errno=%d, file=%s", errno, path);
			return -1;
		}
		return 0;
	}
	else {
		Dbg("get file attribute is fail,errno=%d, file=%s", errno, path);
		return -1;
	}
#endif
}

#ifdef RVC_OS_WIN
#else
unsigned char* utf8_string_create(const char* string) {
	iconv_t cd;
	const char* from_encoding = "CP936";
	size_t result = 0;
	size_t string_length = 0;
	size_t string_utf8_size = 0;
	unsigned char* string_utf8 = NULL;
	unsigned char* string_utf8_ptr = NULL;

	if (string == NULL)
		return NULL;

	cd = iconv_open("UTF-8", from_encoding);
	if (cd == (iconv_t)-1)
		return NULL;

	string_length = strlen(string);
	string_utf8_size = string_length * 2;
	string_utf8 = (unsigned char*)malloc((int)(string_utf8_size + 1));
	string_utf8_ptr = string_utf8;

	if (string_utf8) {
		memset(string_utf8, 0, string_utf8_size + 1);

		result = iconv(cd, (char**)&string, &string_length,
			(char**)&string_utf8_ptr, &string_utf8_size);
	}

	iconv_close(cd);

	if (result == (size_t)-1) {
		free(string_utf8);
		string_utf8 = NULL;
	}
	return string_utf8;
}

#endif //RVC_OS_WIN