Z991239-6390 #comment utf8编码转换调整

Framework/libtoolkit/charset.c

@@ -605,6 +605,208 @@ TOOLKIT_API int  toolkit_detect_utf8_str(const char* str)
     return is_utf8(str);
 }
 
+TOOLKIT_API int toolkit_detect_utf8_str2(const char* str)
+{
+	unsigned int nBytes = 0;//UFT8可用1-6个字节编码,ASCII用一个字节  
+	unsigned char chr = *str;
+	int bAllAscii = 1;
+
+	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 = 0;
+		}
+
+		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 0;
+				}
+
+				nBytes--;
+			}
+		}
+		else {
+			//多字节符的非首字节,应为 10xxxxxx 
+			if ((chr & 0xC0) != 0x80) {
+				return 0;
+			}
+			//减到为零为止
+			nBytes--;
+		}
+	}
+
+	//违返UTF8编码规则 
+	if (nBytes != 0) {
+		return 0;
+	}
+
+	if (bAllAscii) { //如果全部都是ASCII, 也是UTF8
+		return 1;
+	}
+
+	return 1;
+}
+
+
+
+size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size)
+{
+#ifdef _MSC_VER
+	wchar_t* wstr = NULL;
+	int n = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
+	if (n > 0) {
+		wstr = malloc(sizeof(wchar_t) * (n + 1));
+		if (wstr == NULL) {
+			return 0;
+		}
+		memset(wstr, 0, (n + 1) * sizeof(wchar_t));
+		MultiByteToWideChar(CP_ACP, 0, src, -1, &wstr[0], n);
+		wcscpy(dst, wstr);
+		FREE(wstr);
+		return n;
+	}
+	return 0;
+
+#else
+
+	unsigned len = 0;
+	wchar_t* p = NULL;
+	if (strlen(src) == 0) {
+		return 0;
+	}
+	const char* origin = setlocale(LC_CTYPE, NULL);
+	WLog_DBG(TAG, "%s: origin locale: %s, data:%s", __FUNCTION__, origin, src);
+	setlocale(LC_CTYPE, "");
+
+	len = mbstowcs(NULL, src, 0);
+	if (len == -1) {
+		WLog_DBG(TAG, "mbstowcs failed: %d", errno);
+		goto on_end;
+	}
+	len += 1;
+
+	if (dst == NULL) {
+		WLog_DBG(TAG, "mbstowcs to fetch need capacity: %d", len);
+		goto on_end;
+	}
+
+	p = malloc(sizeof(wchar_t) * len);
+	wmemset(p, 0, len);
+
+	len = mbstowcs(p, src, len);
+	if (len == -1) {
+		WLog_DBG(TAG, "mbstowcs after new malloc failed: %d", errno);
+		goto on_del;
+	}
+	wmemset(dst, 0, dst_size);
+	wcscpy(dst, p);
+	len = wcslen(dst);
+	WLog_DBG(TAG, "after mbstowcs returned: %ls(%d)", dst, len);
+
+on_del:
+
+	free(p);
+
+on_end:
+
+	setlocale(LC_CTYPE, origin);
+	return len;
+
+#endif
+}
+
+size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size)
+{
+#if defined(_MSC_VER)
+	char* str = NULL;
+	int n = 0;
+
+	n = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
+	if (n > 0) {
+		str = malloc(sizeof(char) * (n + 1));
+		if (str == NULL) {
+			return 0;
+		}
+		memset(str, 0, sizeof(char) * (n + 1));
+		WideCharToMultiByte(CP_ACP, 0, src, -1, &str[0], n, NULL, NULL);
+		memset(dst, 0, sizeof(char) * (dst_size));
+		strcpy(dst, str);
+		FREE(str);
+		return n;
+	}
+	return 0;
+
+#else
+
+	unsigned len;
+	char* str = NULL;
+	char* origin = NULL;
+
+	len = wcslen(src);
+	if (len == 0) {
+		return 0;
+	}
+	origin = setlocale(LC_CTYPE, NULL);
+	WLog_DBG(TAG, "%s: origin locale: %s, data: %ls", __FUNCTION__, origin, src);
+	setlocale(LC_CTYPE, "");
+
+	len = wcstombs(NULL, src, 0);
+	if (len == -1) {
+		WLog_DBG(TAG, "wcstombs failed: %d", errno);
+		goto on_end;
+	}
+	len += 1;
+
+	if (dst == NULL) {
+		WLog_DBG(TAG, "wcstombs to fetch need capacity: %d", len);
+		goto on_end;
+	}
+
+	str = malloc(sizeof(char) * len);
+	memset(str, 0, len * sizeof(char));
+
+	len = wcstombs(str, src, len);
+	if (len == -1) {
+		WLog_DBG(TAG, "wcstombs after new malloc failed: %d", errno);
+		goto on_del;
+	}
+
+	memset(dst, 0, dst_size * sizeof(char));
+	strcpy(dst, str);
+	len = strlen(dst);
+	WLog_DBG(TAG, "after wcstombs returned: %s(%d)", dst, len);
+
+on_del:
+
+	free(str);
+
+on_end:
+
+	setlocale(LC_CTYPE, origin);
+	return len;
+
+#endif //_MSC_VER
+}
+
 TOOLKIT_API char* ConvertGBKToUtf8(const char* gbk, int* n)
 {
 #ifdef _MSC_VER
@@ -642,7 +844,7 @@ TOOLKIT_API char* ConvertUtf8ToGBK(const char* strUtf8)
 
 	return szGBK;
 #else
-    return strUtf8;
+    return NULL;
 #endif
 
 }

Framework/libtoolkit/charset.h

@@ -22,10 +22,16 @@ extern "C" {
     //test now
     TOOLKIT_API char_encoding  detect_file_encoding(const char* file_path);
 
-    TOOLKIT_API int  toolkit_detect_utf8_str(const char* str);
+    TOOLKIT_API int toolkit_detect_utf8_str(const char* str);
+    /** from upgradetask  [Gifur@2025725]*/
+    //1:utf8;0:no utf8
+	TOOLKIT_API int toolkit_detect_utf8_str2(const char* str);
+
+	TOOLKIT_API size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size);
+	TOOLKIT_API size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size);
 
     //only valid in win and the user remember to free the return if not null
-    //return strUtf8 input param directory in UOS, please use toolkit_utf82gbk if you need
+    //return NULL input param directory in UOS, please use toolkit_utf82gbk if you need
     //copy from httpclient.h
     TOOLKIT_API char* ConvertUtf8ToGBK(const char* strUtf8);
 

Framework/libtoolkit/toolkit.c

@@ -153,146 +153,6 @@ void toolkit_free_cpu_info(toolkit_cpu_info_t* cpu_infos, int count)
 }
 
 
-size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size)
-{
-#ifdef _MSC_VER
-    wchar_t* wstr = NULL;
-    int n = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
-    if (n > 0) {
-        wstr = malloc(sizeof(wchar_t) * (n + 1));
-        if (wstr == NULL) {
-            return 0;
-        }
-        memset(wstr, 0, (n + 1) * sizeof(wchar_t));
-        MultiByteToWideChar(CP_ACP, 0, src, -1, &wstr[0], n);
-        wcscpy(dst, wstr);
-        FREE(wstr);
-        return n;
-    }
-    return 0;
-
-#else
-
-    unsigned len = 0;
-    wchar_t* p = NULL;
-    if (strlen(src) == 0) {
-        return 0;
-    }
-    const char* origin = setlocale(LC_CTYPE, NULL);
-    WLog_DBG(TAG, "%s: origin locale: %s, data:%s", __FUNCTION__, origin, src);
-    setlocale(LC_CTYPE, "");
-
-    len = mbstowcs(NULL, src, 0);
-    if (len == -1) {
-        WLog_DBG(TAG, "mbstowcs failed: %d", errno);
-        goto on_end;
-    }
-    len += 1;
-
-    if (dst == NULL) {
-        WLog_DBG(TAG, "mbstowcs to fetch need capacity: %d", len);
-        goto on_end;
-    }
-
-    p = malloc(sizeof(wchar_t) * len);
-    wmemset(p, 0,  len);
-
-    len = mbstowcs(p, src, len);
-    if (len == -1) {
-        WLog_DBG(TAG, "mbstowcs after new malloc failed: %d", errno);
-        goto on_del;
-    }
-    wmemset(dst, 0, dst_size);
-    wcscpy(dst, p);
-    len = wcslen(dst);
-    WLog_DBG(TAG, "after mbstowcs returned: %ls(%d)", dst, len);
-
-on_del:
-
-    free(p);
-
-on_end:
-
-    setlocale(LC_CTYPE, origin);
-    return len;
-
-#endif
-}
-
-size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size)
-{
-#if defined(_MSC_VER)
-    char* str = NULL;
-    int n = 0;
-
-    n = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
-    if (n > 0) {
-        str = malloc(sizeof(char) * (n + 1));
-        if (str == NULL) {
-            return 0;
-        }
-        memset(str, 0, sizeof(char) * (n + 1));
-        WideCharToMultiByte(CP_ACP, 0, src, -1, &str[0], n, NULL, NULL);
-        memset(dst, 0, sizeof(char) * (dst_size));
-        strcpy(dst, str);
-        FREE(str);
-        return n;
-    }
-    return 0;
-
-#else
-
-    unsigned len;
-    char* str = NULL;
-    char* origin = NULL;
-
-    len = wcslen(src);
-    if (len == 0) {
-        return 0;
-    }
-    origin = setlocale(LC_CTYPE, NULL);
-    WLog_DBG(TAG, "%s: origin locale: %s, data: %ls", __FUNCTION__, origin, src);
-    setlocale(LC_CTYPE, "");
-
-    len = wcstombs(NULL, src, 0);
-    if (len == -1) {
-        WLog_DBG(TAG, "wcstombs failed: %d", errno);
-        goto on_end;
-    }
-    len += 1;
-
-    if (dst == NULL) {
-        WLog_DBG(TAG, "wcstombs to fetch need capacity: %d", len);
-        goto on_end;
-    }
-
-    str = malloc(sizeof(char) * len);
-    memset(str, 0, len * sizeof(char));
-
-    len = wcstombs(str, src, len);
-    if (len == -1) {
-        WLog_DBG(TAG, "wcstombs after new malloc failed: %d", errno);
-        goto on_del;
-    }
-
-    memset(dst, 0, dst_size * sizeof(char));
-    strcpy(dst, str);
-    len = strlen(dst);
-    WLog_DBG(TAG, "after wcstombs returned: %s(%d)", dst, len);
-
-on_del:
-
-    free(str);
-
-on_end:
-
-    setlocale(LC_CTYPE, origin);
-    return len;
-
-#endif //_MSC_VER
-}
-
-
 /** WARNING: need to FREE the copy msg!!!!*/
 static const char* toolkit__unknown_err_code(int err)
 {

Framework/libtoolkit/toolkit.h

@@ -286,9 +286,6 @@ extern "C" {
 
     TOOLKIT_API void toolkit_sleep(int msec);
 
-    TOOLKIT_API size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size);
-    TOOLKIT_API size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size);
-
     TOOLKIT_API int toolkit_os_getpriority(toolkit_pid_t pid, int* priority);
     TOOLKIT_API int toolkit_os_setpriority(toolkit_pid_t pid, int priority);
 

Framework/spbase/sp_tbs_unix.cpp

@@ -26,6 +26,7 @@
 #include "fileutil.h"
 #include "memutil.h"
 #include "toolkit.h"
+#include "charset.h"
 #include "uuid4.h"
 #include "dbgutil.h"
 #include <winpr/winsock.h>

Module/include/CommEntityUtil.hpp

@@ -32,6 +32,7 @@
 
 #include "path.h"
 #include "toolkit.h"
+#include "charset.h"
 #include <string>
 #include <iostream>
 #include <sstream>
@@ -512,99 +513,23 @@ static CSimpleStringA generateConsumeTimeJson(const CSimpleStringA& entityName,
 }
 
 #if defined(_MSC_VER)
-static char* ConvertUtf8ToGBK(const char* strUtf8)
-{
-	int len = MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szGBK = new char[len + 1];
-	memset(szGBK, 0, len + 1);
-	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
-	delete[] wszGBK;
-
-	return szGBK;
-}
 
-static void ConvertUtf8ToGBK(std::string& str)
+static void ConvertUtf82GBK(std::string& str)
 {
 	char* dst = ConvertUtf8ToGBK(str.c_str());
 	str = dst;
-	delete[] dst;
-}
-
-static char* ConvertGBKToUtf8(const char* gbk, int* n)
-{
-	int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szUtf8 = new char[len + 1];
-	memset(szUtf8, 0, len + 1);
-	WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
-
-	delete[] wszGBK;
-	*n = len - 1;
-	return szUtf8;
+	if(dst) free(dst);
 }
 
-static void ConvertGBKToUtf8(std::string& str)
+static void ConvertGBK2Utf8(std::string& str)
 {
 	int len = 0;
 	char* dst = ConvertGBKToUtf8(str.c_str(), &len);
 	str = dst;
-	delete[] dst;
+	if (dst) free(dst);
 }
 #endif //_MSC_VER
 
-static std::string W2S(const std::wstring wstr)
-{
-#if defined(_MSC_VER)
-	char* str = NULL;
-	int n = ::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
-	if (n > 0) {
-		str = new char[n + 1];
-		if (str == NULL) {
-			return std::string();
-		}
-		std::memset(str, 0, sizeof(char) * (n + 1));
-		::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, &str[0], n, NULL, NULL);
-		std::string strr(str);
-		delete [] str;
-		return strr;
-	}
-#else
-	///*TODO(80374374@3/7/2023):  */
-#endif //_MSC_VER
-	return std::string();
-}
-
-static std::wstring S2W(const std::string str)
-{
-#if defined(_MSC_VER)
-	wchar_t* wstr = NULL;
-	int n = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);
-	if (n > 0) {
-		wstr = new wchar_t[n + 1];
-		if (wstr == NULL) {
-			return std::wstring();
-		}
-		std::memset(wstr, 0, (n + 1) * sizeof(wchar_t));
-		::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, &wstr[0], n);
-		std::wstring strr(wstr);
-		delete [] wstr;
-		return strr;
-	}
-#else
-	///*TODO(80374374@3/7/2023):  */
-#endif //_MSC_VER
-	return std::wstring();
-}
-
 } //namespace Util
 
 namespace Net{

Module/mod_ResourceWatcher/ResourceWatcherFSM.cpp

@@ -2496,6 +2496,13 @@ bool ResourceWatcherFSM::RetrieveDigitalSignatureInfo(const char* pFilePath)
                         {
                             if (VerifyFirstCertificate(hStore, pSignerInfo)
                                 || VerifyOtherCertificate(pSignerInfo))
+
+                                delete[] pSignerInfo;
+
+								if (wpFilePath != NULL) {
+									delete[] wpFilePath;
+									wpFilePath = NULL;
+								}
                                 return true;
                         }
 
@@ -2518,6 +2525,12 @@ bool ResourceWatcherFSM::RetrieveDigitalSignatureInfo(const char* pFilePath)
         CryptMsgClose(hMsg);
         hMsg = NULL;
     }
+
+	if (wpFilePath != NULL) {
+		delete[] wpFilePath;
+		wpFilePath = NULL;
+	}
+
     return false;
 }
 

Module/mod_ResourceWatcher/mod_ResourceWatcher.cpp

@@ -1260,14 +1260,14 @@ ErrorCodeEnum ResourceWatcherEntity::UnzipPack(const char* unZipPackName)
             if (zrc == ZR_OK) {
                 //兼容压缩包里面中文名称是utf8编码
                 if (is_str_utf8(ze.name)) {
-                    char* pGBK = SP::Module::Util::ConvertUtf8ToGBK((const char*)ze.name);
+                    char* pGBK = ConvertUtf8ToGBK((const char*)ze.name);
                     zrc = UnzipItem(hz, i, pGBK, 0, ZIP_FILENAME);
                     if (zrc == ZR_OK) {
-                        delete[] pGBK;
+                        if (pGBK) free(pGBK);
                     }
                     else {
                         DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("UnzipPack")("unzip [%s] UTF8 item fail,result=0x%X", pGBK, (int)zrc);
-                        delete[] pGBK;
+						if (pGBK) free(pGBK);
                         break;
                     }
                 }

Module/mod_UpgradeMgr/UpgradeTaskFSM.cpp

@@ -7,6 +7,7 @@
 #include <regex>
 #include "mod_UpgradeMgr.h"
 #include "UpgradeManager_msg_g.h"
+#include "CommEntityUtil.hpp"
 
 #ifdef RVC_OS_WIN
 #include <WinBase.h>
@@ -1522,8 +1523,10 @@ namespace Task
 
 			string jsonReq = writer.write(rootReq);
 			CSimpleStringA downloadUrl = m_fsm->m_currentTask.download_url;
+#if defined(RVC_OS_WIN) /** TODO 跟文涛确认UOS下是否需要调用  [Gifur@2025725]*/
 			//转码
-			m_fsm->ConvertGBKToUtf8(jsonReq);
+			SP::Module::Util::ConvertGBK2Utf8(jsonReq);
+#endif //RVC_OS_WIN
 
 			//打印发送请求
 			if(m_fsm->m_PrintHttpLog){
@@ -1563,8 +1566,10 @@ namespace Task
 				return false;//无params 失败
 			}else{
 				string respStr = iter->second;
+#if defined(RVC_OS_WIN)
 				//转码：
-				m_fsm->ConvertUtf8ToGBK(respStr);
+				SP::Module::Util::ConvertUtf82GBK(respStr);
+#endif //RVC_OS_WIN
 
 				//打印回应报文
 				if(m_fsm->m_PrintHttpLog){
@@ -3361,116 +3366,6 @@ int CUpgradeTaskFSM::waitSystem(string cmd, const char * par, bool nShow,CSimple
 #endif
 }
 
-char* CUpgradeTaskFSM::ConvertUtf8ToGBK(const char* strUtf8)
-{
-	int len = MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szGBK = new char[len + 1];
-	memset(szGBK, 0, len + 1);
-	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
-	delete[] wszGBK;
-
-	return szGBK;
-}
-
-void CUpgradeTaskFSM::ConvertUtf8ToGBK(std::string &str)
-{
-	char *dst = ConvertUtf8ToGBK(str.c_str());
-	str = dst;
-	delete[] dst;
-}
-
-char* CUpgradeTaskFSM::ConvertGBKToUtf8(const char* gbk, int *n)
-{
-	int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szUtf8 = new char[len + 1];
-	memset(szUtf8, 0, len + 1);
-	WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
-
-	delete[] wszGBK;
-	*n = len  - 1;
-	return szUtf8;
-}
-
-void CUpgradeTaskFSM::ConvertGBKToUtf8(std::string &str)
-{
-	int len = 0;
-	char *dst = ConvertGBKToUtf8(str.c_str(), &len);
-
-	str = dst;
-	delete[] dst;
-}
-
-bool CUpgradeTaskFSM::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;
-}
-
 ErrorCodeEnum CUpgradeTaskFSM::UnzipPack(const char* unZipPackName)
 {
 #ifdef RVC_OS_WIN
@@ -3536,15 +3431,14 @@ ErrorCodeEnum CUpgradeTaskFSM::UnzipPack(const char* unZipPackName)
 			zrc = GetZipItemA(hz,i,&ze);
 			if(zrc==ZR_OK){
 				//兼容压缩包里面中文名称是utf8编码
-				if(is_str_utf8(ze.name)){
+				if(!!toolkit_detect_utf8_str2(ze.name)){
 					char *pGBK = ConvertUtf8ToGBK((const char*)ze.name);
 					zrc = UnzipItem(hz,i,pGBK,0,ZIP_FILENAME);
 					if(zrc ==ZR_OK){
-						//Dbg("unzip [%s] UTF8 item succeed", pGBK);
-						delete[] pGBK; 
+						if (pGBK) free(pGBK);
 					}else{
 						DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("unzip [%s] UTF8 item fail,result=0x%X", pGBK,(int)zrc);
-						delete[] pGBK; 
+						if (pGBK) free(pGBK);
 						break;
 					}
 

Module/mod_UpgradeMgr/UpgradeTaskFSM.h

@@ -14,12 +14,12 @@
 #define	QUERY_IS_WORK_WARN_LIMIT 10
 using namespace std;
 
-#define WARN_TASK_COPY_FILE_ZERO 0x50620022 //升级copy文件夹文件个数为0
-#define ERR_TASK_QUERY_PRE_NEW_TASK_FAIL 0x50620023 //查询新任务报错
-#define ERR_TASK_QUERY_CONTINUE_NEW_TASK_FAIL 0x50620024 //查询继续新任务报错
-#define ERR_TASK_QUERY_CONTINUE_NEW_TASK_ERR 0x50620025 //查询继续新任务异常
+#define WARN_TASK_COPY_FILE_ZERO 0x50620022 //鍗囩骇copy鏂囦欢澶规枃浠朵釜鏁颁负0
+#define ERR_TASK_QUERY_PRE_NEW_TASK_FAIL 0x50620023 //鏌ヨ�鏂颁换鍔℃姤閿�
+#define ERR_TASK_QUERY_CONTINUE_NEW_TASK_FAIL 0x50620024 //鏌ヨ�缁х画鏂颁换鍔℃姤閿�
+#define ERR_TASK_QUERY_CONTINUE_NEW_TASK_ERR 0x50620025 //鏌ヨ�缁х画鏂颁换鍔″紓甯�
 
-#define WARN_BLACK_FILE_SUM 0x50600023 //黑名单文件数量
+#define WARN_BLACK_FILE_SUM 0x50600023 //榛戝悕鍗曟枃浠舵暟閲�
 
 #define UpgradeMgr_VERSION_DOWNLOAD_ID "QLR0402506Z10101"
 #define UpgradeMgr_VERSION_INSTALL_ID "QLR0402506Z10201"
@@ -42,7 +42,7 @@ using namespace std;
 
 namespace HttpStruct
 {
-	//发送文件hash列表接口
+	//鍙戦€佹枃浠秇ash鍒楄〃鎺ュ彛
 	struct SendSM3TaskReq : CHTTPReq {
 		string m_reqStr;
 		string ToJson() {
@@ -57,7 +57,7 @@ namespace HttpStruct
 		}
 	};
 
-	//更新任务状态接口
+	//鏇存柊浠诲姟鐘舵€佹帴鍙�
 	struct UpdateTaskStatusReq : CHTTPReq {
 		string m_reqStr;
 		string ToJson() {
@@ -72,7 +72,7 @@ namespace HttpStruct
 		}
 	};
 
-	//查询当前任务
+	//鏌ヨ�褰撳墠浠诲姟
 	struct QueryCurrTaskReq : CHTTPReq {
 		string m_reqStr;
 		string ToJson() {
@@ -87,7 +87,7 @@ namespace HttpStruct
 		}
 	};
 
-	//查询新任务
+	//鏌ヨ�鏂颁换鍔�
 	struct QueryNewTaskReq : CHTTPReq {
 		string m_reqStr;
 		string ToJson() {
@@ -102,7 +102,7 @@ namespace HttpStruct
 		}
 	};
 
-	//断点下载升级包
+	//鏂�偣涓嬭浇鍗囩骇鍖�
 	struct DownloadPackTaskRet{
 		long content_length;
         long origin_file_length;
@@ -114,7 +114,7 @@ namespace HttpStruct
 
 
 
-// 升级任务状态机
+// 鍗囩骇浠诲姟鐘舵€佹満
 class CUpgradeTaskFSM : public FSMImpl<CUpgradeTaskFSM>, public IFSMStateHooker, public ISysVarListener
 {
 public:
@@ -153,7 +153,7 @@ public:
 
 	struct SendSM3TaskEvent:public FSMEvent
 	{
-		bool isSucc;//是否写入成功
+		bool isSucc;//鏄�惁鍐欏叆鎴愬姛
 		SendSM3TaskEvent(bool isSendSucc) 
 			: FSMEvent(Event_EndSendSM3Task), isSucc(isSendSucc)
 		{}
@@ -162,7 +162,7 @@ public:
 
 	struct UpdateTaskStatusEvent:public FSMEvent
 	{
-		bool isSucc;//是否更新成功
+		bool isSucc;//鏄�惁鏇存柊鎴愬姛
 		UpdateTaskStatusEvent(bool isSendSucc) 
 			: FSMEvent(Event_EndUpdateTask), isSucc(isSendSucc)
 		{}
@@ -170,8 +170,8 @@ public:
 
 	struct QueryCurrTaskEvent:public FSMEvent
 	{
-		bool isSucc;//是否查询成功
-		bool isTask_valid;//任务是否有效
+		bool isSucc;//鏄�惁鏌ヨ�鎴愬姛
+		bool isTask_valid;//浠诲姟鏄�惁鏈夋晥
 		QueryCurrTaskEvent(bool isSendSucc,bool isValid) 
 			: FSMEvent(Event_EndQueryCurrTask), isSucc(isSendSucc),isTask_valid(isValid)
 		{}
@@ -179,7 +179,7 @@ public:
 
 	struct QueryNewTaskEvent:public FSMEvent
 	{
-		bool isSucc;//是否查询成功
+		bool isSucc;//鏄�惁鏌ヨ�鎴愬姛
 		QueryNewTaskEvent(bool isSendSucc) 
 			: FSMEvent(Event_EndPoll), isSucc(isSendSucc)
 		{}
@@ -187,7 +187,7 @@ public:
 
 	struct QueryNewContinueTaskEvent:public FSMEvent
 	{
-		int retParam;//是否查询成功
+		int retParam;//鏄�惁鏌ヨ�鎴愬姛
 		QueryNewContinueTaskEvent(int ret) 
 			: FSMEvent(Event_EndContinuePoll)
 		{
@@ -197,7 +197,7 @@ public:
 
 	struct QueryNewPreTaskEvent:public FSMEvent
 	{
-		bool isSucc;//是否查询成功
+		bool isSucc;//鏄�惁鏌ヨ�鎴愬姛
 		QueryNewPreTaskEvent(bool isSendSucc) 
 			: FSMEvent(Event_EndPrePoll), isSucc(isSendSucc)
 		{}
@@ -205,8 +205,8 @@ public:
 
 	struct QueryTaskStatusEvent:public FSMEvent
 	{
-		bool isSucc;//是否查询成功
-		bool isTask_valid;//任务是否有效
+		bool isSucc;//鏄�惁鏌ヨ�鎴愬姛
+		bool isTask_valid;//浠诲姟鏄�惁鏈夋晥
 		QueryTaskStatusEvent(bool isSendSucc,bool isValid) 
 			: FSMEvent(Event_EndQueryTaskStatus), isSucc(isSendSucc),isTask_valid(isValid)
 		{}
@@ -222,7 +222,7 @@ public:
 
 	struct DownloadPackTaskFailEvent:public FSMEvent
 	{
-		string errMsg;//错误信息
+		string errMsg;//閿欒�淇℃伅
 		DownloadPackTaskFailEvent(string errorMsg) 
 			: FSMEvent(Event_Download_Fail), errMsg(errorMsg)
 		{}
@@ -266,130 +266,123 @@ public:
 
 	struct CInstallStep
 	{
-		//不存储到运行时
-		int stepSeq; //步骤序号
-		CSimpleStringA cmdType;		//升级安装需执行命令类型:Delete、Copy、Run
-		int cmdFail;		//0：执行失败认为升级失败 1：执行失败忽略继续升级
-		CSimpleStringA srcPathType; //0：相对路径 1：绝对路径 2：当前版本相对路径 3：升级包相对路径
+		//涓嶅瓨鍌ㄥ埌杩愯�鏃�
+		int stepSeq; //姝ラ�搴忓彿
+		CSimpleStringA cmdType;		//鍗囩骇瀹夎�闇€鎵ц�鍛戒护绫诲瀷:Delete銆丆opy銆丷un
+		int cmdFail;		//0锛氭墽琛屽け璐ヨ�涓哄崌绾уけ璐� 1锛氭墽琛屽け璐ュ拷鐣ョ户缁�崌绾�
+		CSimpleStringA srcPathType; //0锛氱浉瀵硅矾寰� 1锛氱粷瀵硅矾寰� 2锛氬綋鍓嶇増鏈�浉瀵硅矾寰� 3锛氬崌绾у寘鐩稿�璺�緞
 		CSimpleStringA srcPath;		
-		CSimpleStringA dstPathType;	//0：相对路径 1：绝对路径 2：当前版本相对路径 3：升级版本相对路径 4：升级包相对路径
+		CSimpleStringA dstPathType;	//0锛氱浉瀵硅矾寰� 1锛氱粷瀵硅矾寰� 2锛氬綋鍓嶇増鏈�浉瀵硅矾寰� 3锛氬崌绾х増鏈�浉瀵硅矾寰� 4锛氬崌绾у寘鐩稿�璺�緞
 		CSimpleStringA dstPath;
 	};
 
-	// 待安装任务信息（运行时保存的中间变量）
+	// 寰呭畨瑁呬换鍔′俊鎭�紙杩愯�鏃朵繚瀛樼殑涓�棿鍙橀噺锛�
 	struct CTaskInfo
-	{	//存储到运行时
-		CSimpleStringA upgradeTaskId;	//升级任务编号
-		CSimpleStringA createTaskVersion;//创建升级任务时的版本号
-		CSimpleStringA cPendingState;	// 已下载D、安装中I、等待切换S、任务结果确认T
-		CSimpleStringA NewVersion;		// 任务升级后的版本号
-		CSimpleStringA pack_name;		//升级包名
-		CSimpleStringA task_type;		//任务类型 U:升级任务 R:回退任务
-		CSimpleStringA depNewVersion;    //适配器新版本号
-		//CSimpleStringA task_class;      //任务类别 A:应用版本任务 D:适配器任务 T:体系外任务
-		//不存储到运行时
-		CSimpleStringA pack_version;	//升级包指定的版本号
-		bool stop_media_play;   //停止广告播放（0:不停止 1:停止）
-		int reboot_type;		//重启策略类型（0:不启动 1:重启框架 2:重启系统）
-		CSimpleStringA file_path;       //升级包路径
-		CSimpleStringA download_url;    //升级包下载地址
-		CSimpleStringA pack_hash;		//升级包hash值
-		long pack_length;		//升级包长度(服务端暂时不传)
-
-		queue<CInstallStep*> install_step;//安装步骤队列
+	{	//瀛樺偍鍒拌繍琛屾椂
+		CSimpleStringA upgradeTaskId;	//鍗囩骇浠诲姟缂栧彿
+		CSimpleStringA createTaskVersion;//鍒涘缓鍗囩骇浠诲姟鏃剁殑鐗堟湰鍙�
+		CSimpleStringA cPendingState;	// 宸蹭笅杞紻銆佸畨瑁呬腑I銆佺瓑寰呭垏鎹�銆佷换鍔＄粨鏋滅‘璁�
+		CSimpleStringA NewVersion;		// 浠诲姟鍗囩骇鍚庣殑鐗堟湰鍙�
+		CSimpleStringA pack_name;		//鍗囩骇鍖呭悕
+		CSimpleStringA task_type;		//浠诲姟绫诲瀷 U:鍗囩骇浠诲姟 R:鍥為€€浠诲姟
+		CSimpleStringA depNewVersion;    //閫傞厤鍣ㄦ柊鐗堟湰鍙�
+		//CSimpleStringA task_class;      //浠诲姟绫诲埆 A:搴旂敤鐗堟湰浠诲姟 D:閫傞厤鍣ㄤ换鍔� T:浣撶郴澶栦换鍔�
+		//涓嶅瓨鍌ㄥ埌杩愯�鏃�
+		CSimpleStringA pack_version;	//鍗囩骇鍖呮寚瀹氱殑鐗堟湰鍙�
+		bool stop_media_play;   //鍋滄�骞垮憡鎾�斁锛�0:涓嶅仠姝� 1:鍋滄�锛�
+		int reboot_type;		//閲嶅惎绛栫暐绫诲瀷锛�0:涓嶅惎鍔� 1:閲嶅惎妗嗘灦 2:閲嶅惎绯荤粺锛�
+		CSimpleStringA file_path;       //鍗囩骇鍖呰矾寰�
+		CSimpleStringA download_url;    //鍗囩骇鍖呬笅杞藉湴鍧€
+		CSimpleStringA pack_hash;		//鍗囩骇鍖卙ash鍊�
+		long pack_length;		//鍗囩骇鍖呴暱搴�(鏈嶅姟绔�殏鏃朵笉浼�)
+
+		queue<CInstallStep*> install_step;//瀹夎�姝ラ�闃熷垪
 
 	};
 
 	
 	struct CTaskProcess
 	{
-		CSimpleStringA strPackName;//包名
-		CSimpleStringA installVersion;//安装版本号
-		CSimpleStringA CurrentVersion;//当前版本号
-		CSimpleStringA cInstallState;//升级状态
-		CSimpleStringA strInstallComment;//升级状态备注
+		CSimpleStringA strPackName;//鍖呭悕
+		CSimpleStringA installVersion;//瀹夎�鐗堟湰鍙�
+		CSimpleStringA CurrentVersion;//褰撳墠鐗堟湰鍙�
+		CSimpleStringA cInstallState;//鍗囩骇鐘舵€�
+		CSimpleStringA strInstallComment;//鍗囩骇鐘舵€佸�娉�
 	};
 
 	struct CenterUrl
 	{
-		string updateTaskUrl;		//更新升级任务url
-		string queryCurrTaskUrl;	//查询当前任务url
-		string queryNewTaskUrl;		//查询新任务url（旧版本使用）
-		string queryPreTaskUrl;		//预查询新任务url
-		string queryContinueTaskUrl; //继续查询新任务url
-		string queryTaskStatus;		//查询当前任务是否有效url
-		string sendSM3TaskUrl;		//发送文件hashurl
+		string updateTaskUrl;		//鏇存柊鍗囩骇浠诲姟url
+		string queryCurrTaskUrl;	//鏌ヨ�褰撳墠浠诲姟url
+		string queryNewTaskUrl;		//鏌ヨ�鏂颁换鍔�rl锛堟棫鐗堟湰浣跨敤锛�
+		string queryPreTaskUrl;		//棰勬煡璇㈡柊浠诲姟url
+		string queryContinueTaskUrl; //缁х画鏌ヨ�鏂颁换鍔�rl
+		string queryTaskStatus;		//鏌ヨ�褰撳墠浠诲姟鏄�惁鏈夋晥url
+		string sendSM3TaskUrl;		//鍙戦€佹枃浠秇ashurl
 	};
 
 	struct HashScanSet
 	{
-		CSimpleStringA relativeDir;	//相对路径
-		CSimpleStringA absoluteDir;	//绝对路径 
-		CSimpleStringA currVerDir;	//当前版本相对路径
-		CSimpleStringA blackFile;	//不纳入扫描的文件名称
-		CSimpleStringA blackDir;	//不纳入扫描的文件夹
+		CSimpleStringA relativeDir;	//鐩稿�璺�緞
+		CSimpleStringA absoluteDir;	//缁濆�璺�緞 
+		CSimpleStringA currVerDir;	//褰撳墠鐗堟湰鐩稿�璺�緞
+		CSimpleStringA blackFile;	//涓嶇撼鍏ユ壂鎻忕殑鏂囦欢鍚嶇О
+		CSimpleStringA blackDir;	//涓嶇撼鍏ユ壂鎻忕殑鏂囦欢澶�
 	};
 
 public:
 	CUpgradeTaskFSM(){
-		isSendHash = false;//默认查询策略不发送hash
-		m_isSM3HashSucc = false;//默认hash计算失败
+		isSendHash = false;//榛樿�鏌ヨ�绛栫暐涓嶅彂閫乭ash
+		m_isSM3HashSucc = false;//榛樿�hash璁＄畻澶辫触
 		m_bDownloadIdle = false;
 		m_bTaskCancel=false;
-		m_fileSM3ListHash="";//终端hash列表64位hash值
-		m_fileSM3List = "";//终端hash列表值
-		m_strPreTaskId="";//预检查任务ID
-		m_bNeedHash=0;//预检查是否需要hash
+		m_fileSM3ListHash="";//缁堢�hash鍒楄〃64浣峢ash鍊�
+		m_fileSM3List = "";//缁堢�hash鍒楄〃鍊�
+		m_strPreTaskId="";//棰勬�鏌ヤ换鍔�D
+		m_bNeedHash=0;//棰勬�鏌ユ槸鍚﹂渶瑕乭ash
 		m_newEachDownloadLen=DOWNLOAD_CONTENT_EACH_LEN;
 		m_PrintHttpLog =false;
 		m_startFlag = false;
 		m_iBlackFileCount=0;
 		m_bSwitchFlag = false;
 		m_bRollbackTask = false;
-		m_TempDepUpgradeFlag = false;//默认非适配器升级
-		m_queryNewTaskInterval = 240;//默认查询任务时间间隔
-		m_installStopCopyDep = false;//默认拷贝
+		m_TempDepUpgradeFlag = false;//榛樿�闈為€傞厤鍣ㄥ崌绾�
+		m_queryNewTaskInterval = 240;//榛樿�鏌ヨ�浠诲姟鏃堕棿闂撮殧
+		m_installStopCopyDep = false;//榛樿�鎷疯礉
 		m_downloadBreakOffCount = 0; 
 		m_queryIsWorkCount = 0;
 	}
 	~CUpgradeTaskFSM(){}
-	//具体实现方法
-	ErrorCodeEnum CreateNewVersion(CVersion NewSoftwareVersion,CSimpleStringA &strErrInfo);//创建新版本
-	ErrorCodeEnum ClearUpgradeFailVersion(CVersion NewSoftwareVersion);//清理升级新版本临时文件
-	bool GetSysUpgradeResult(const char *pszResultLog, CSimpleStringA &eErrorCode, CSimpleStringA &strErrMsg);//从体系外生成的result.log文件中获取结果
+	//鍏蜂綋瀹炵幇鏂规硶
+	ErrorCodeEnum CreateNewVersion(CVersion NewSoftwareVersion,CSimpleStringA &strErrInfo);//鍒涘缓鏂扮増鏈�
+	ErrorCodeEnum ClearUpgradeFailVersion(CVersion NewSoftwareVersion);//娓呯悊鍗囩骇鏂扮増鏈�复鏃舵枃浠�
+	bool GetSysUpgradeResult(const char *pszResultLog, CSimpleStringA &eErrorCode, CSimpleStringA &strErrMsg);//浠庝綋绯诲�鐢熸垚鐨剅esult.log鏂囦欢涓�幏鍙栫粨鏋�
 	
-	//安装执行步骤方法
-	int ExecInstall(CSimpleStringA &strErrMsg);//升级安装 0：失败 1：成功 -1：未知
+	//瀹夎�鎵ц�姝ラ�鏂规硶
+	int ExecInstall(CSimpleStringA &strErrMsg);//鍗囩骇瀹夎� 0锛氬け璐� 1锛氭垚鍔� -1锛氭湭鐭�
 	int ExecRunCmd(CSimpleStringA &strErrMsg,CInstallStep* ins);
 	bool ExecDeleteCmd(CSimpleStringA &strErrMsg,CInstallStep* ins);
 	bool ExecCpoyCmd(CSimpleStringA &strErrMsg,CInstallStep* ins);
-	bool GetRootTypePath(int rootType,CSimpleStringA &rootPath);//1:相对路径 2：当前版本相对路径 3：升级版本相对路径 4：升级包相对路径
+	bool GetRootTypePath(int rootType,CSimpleStringA &rootPath);//1:鐩稿�璺�緞 2锛氬綋鍓嶇増鏈�浉瀵硅矾寰� 3锛氬崌绾х増鏈�浉瀵硅矾寰� 4锛氬崌绾у寘鐩稿�璺�緞
 	ErrorCodeEnum CopyFileOperate(const char* srcPath, const char* destPath, int nCopyMode, CSimpleStringA &strErrMsg);
 
 
 
-	ErrorCodeEnum SetRunSucceed(const char* pPackFile);//成功切换新版本
-	ErrorCodeEnum UpgradeToNewVersion();//设置新版本状态
-	ErrorCodeEnum RollBackToHistoryVersion(CVersion historyVersion);//回退到某个历史版本
+	ErrorCodeEnum SetRunSucceed(const char* pPackFile);//鎴愬姛鍒囨崲鏂扮増鏈�
+	ErrorCodeEnum UpgradeToNewVersion();//璁剧疆鏂扮増鏈�姸鎬�
+	ErrorCodeEnum RollBackToHistoryVersion(CVersion historyVersion);//鍥為€€鍒版煇涓�巻鍙茬増鏈�
 	
 	void RecursiveGetSubFiles(const char *pszDir, const char *pszTrimStart, list<CSimpleStringA>& retList);
 	bool IsFileMatch(const char *pszFilter, const char *pszFileName);
-	bool RecursiveCopyDir(const char *pszSourceDir, const char *pszDestDir,CSimpleStringA &strErrInfo);//可以合并
-	CSimpleStringA GetFileDirectory(const char *pszFullPath);//查找文件的父路径
-	bool IsWow64Process();//判断是否是64位windows程序
-	int system_on(string cmdFilePath, bool isWait,CSimpleStringA &errMsg);//cmd窗口程序
-	int waitSystem(string cmd, const char * par, bool nShow,CSimpleStringA &errMsg);//起进程执行cmd
-	
-
-	char* ConvertUtf8ToGBK(const char* strUtf8);
-	void ConvertUtf8ToGBK(std::string &str);
-	char* ConvertGBKToUtf8(const char* gbk, int *n);
-	void ConvertGBKToUtf8(std::string &str);
-	bool is_str_utf8(const char* str);
-
-	ErrorCodeEnum UnzipPack(const char* unZipPackName);//解压文件
-	ErrorCodeEnum DeleteUnzipDir();//清理临时解压包文件
-	ErrorCodeEnum RollBackVersionCheck(string &failReason, CSimpleStringA& strErrMsg);//回退版本检查 C：一般错误 X：终端找不到需要回退的版本文件夹 、回退版本比现在版本高
+	bool RecursiveCopyDir(const char *pszSourceDir, const char *pszDestDir,CSimpleStringA &strErrInfo);//鍙�互鍚堝苟
+	CSimpleStringA GetFileDirectory(const char *pszFullPath);//鏌ユ壘鏂囦欢鐨勭埗璺�緞
+	bool IsWow64Process();//鍒ゆ柇鏄�惁鏄�64浣峸indows绋嬪簭
+	int system_on(string cmdFilePath, bool isWait,CSimpleStringA &errMsg);//cmd绐楀彛绋嬪簭
+	int waitSystem(string cmd, const char * par, bool nShow,CSimpleStringA &errMsg);//璧疯繘绋嬫墽琛宑md
+
+	ErrorCodeEnum UnzipPack(const char* unZipPackName);//瑙ｅ帇鏂囦欢
+	ErrorCodeEnum DeleteUnzipDir();//娓呯悊涓存椂瑙ｅ帇鍖呮枃浠�
+	ErrorCodeEnum RollBackVersionCheck(string &failReason, CSimpleStringA& strErrMsg);//鍥為€€鐗堟湰妫€鏌� C锛氫竴鑸�敊璇� X锛氱粓绔�壘涓嶅埌闇€瑕佸洖閫€鐨勭増鏈�枃浠跺す 銆佸洖閫€鐗堟湰姣旂幇鍦ㄧ増鏈�珮
 	
 	
 
@@ -397,56 +390,56 @@ public:
 	ErrorCodeEnum GetRunConfigStrValue(const char *pszSection, const char *pszKey, CSimpleStringA &strValue);
 	ErrorCodeEnum SetRunConfigStrValue(const char *pszSection, const char *pszKey, const char *pszValue);
 
-	bool ClearCurrTaskInfo();//任务无效清除运行时记录和残留下载包
-	bool ClearInstallStep();//清理历史任务安装步骤
+	bool ClearCurrTaskInfo();//浠诲姟鏃犳晥娓呴櫎杩愯�鏃惰�褰曞拰娈嬬暀涓嬭浇鍖�
+	bool ClearInstallStep();//娓呯悊鍘嗗彶浠诲姟瀹夎�姝ラ�
 
-	ErrorCodeEnum LoadPersistTaskInfo();//启动开始加载运行时文件
-	ErrorCodeEnum loadCenterCfgInfo();//启动开始加载集中配置文件
+	ErrorCodeEnum LoadPersistTaskInfo();//鍚�姩寮€濮嬪姞杞借繍琛屾椂鏂囦欢
+	ErrorCodeEnum loadCenterCfgInfo();//鍚�姩寮€濮嬪姞杞介泦涓�厤缃�枃浠�
 
-	bool GetFileLength(const char* filePath,long &fileLen);//获取文件长度
-	ErrorCodeEnum GetSM3List(CSimpleStringA &strSM3List);//获取版本文件hash集合字符串
+	bool GetFileLength(const char* filePath,long &fileLen);//鑾峰彇鏂囦欢闀垮害
+	ErrorCodeEnum GetSM3List(CSimpleStringA &strSM3List);//鑾峰彇鐗堟湰鏂囦欢hash闆嗗悎瀛楃�涓�
 	ErrorCodeEnum ScanSM3ByType(int type,CSimpleStringA pathFilter);
-	ErrorCodeEnum NewSM3Folder(CSimpleStringA scanFilter,CSimpleStringA replaceDir);//新的hash扫描文件夹实现
+	ErrorCodeEnum NewSM3Folder(CSimpleStringA scanFilter,CSimpleStringA replaceDir);//鏂扮殑hash鎵�弿鏂囦欢澶瑰疄鐜�
 
-	//新国密SM3函数，isSub表示是否截取新国密中间一段密文
+	//鏂板浗瀵哠M3鍑芥暟锛宨sSub琛ㄧず鏄�惁鎴�彇鏂板浗瀵嗕腑闂翠竴娈靛瘑鏂�
 	ErrorCodeEnum SM3FileToStr(CSimpleStringA strFilePath, CSimpleStringA &strSM3,bool isSub);
 	ErrorCodeEnum SM3DataToStr(CSimpleStringA strData, CSimpleStringA &strSM3,bool isSub);
 	ErrorCodeEnum SM3_Str(CSimpleStringA &strSM3,BYTE * SM3Byte,bool isSub);
 
-	bool IsPackDownloaded(const char *pPackName,const char* packHash,long packLen);//判断安装包是否已下载成功
+	bool IsPackDownloaded(const char *pPackName,const char* packHash,long packLen);//鍒ゆ柇瀹夎�鍖呮槸鍚﹀凡涓嬭浇鎴愬姛
 	bool DownloadFileWrite(byte* content,long contentLen,const char* filePath);
 
-	bool CheckIfCanSwitchNow();//是否允许切换
-	ErrorCodeEnum SwitchUpgradeNow();//切换版本
+	bool CheckIfCanSwitchNow();//鏄�惁鍏佽�鍒囨崲
+	ErrorCodeEnum SwitchUpgradeNow();//鍒囨崲鐗堟湰
 
-	ErrorCodeEnum DownloadProgress(long tempFileLen,long fileSumLen);//返回下载进度
-	char GetInstallState(int nState);//根据状态机获取升级状态
+	ErrorCodeEnum DownloadProgress(long tempFileLen,long fileSumLen);//杩斿洖涓嬭浇杩涘害
+	char GetInstallState(int nState);//鏍规嵁鐘舵€佹満鑾峰彇鍗囩骇鐘舵€�
 	ErrorCodeEnum GetUpgradeState(bool &bInstalling, CSimpleStringA &strPackFile, CSimpleStringA &strExecID,
 		char &cInstallState, bool &bSysInstall, bool &bLightPack, CSimpleStringA &strNewVersion);
 	
 	static void HttpsLogCallBack(const char* logtxt);
 
-	void judgeTaskClass();//临时判定升级任务类别
-	ErrorCodeEnum judgeRollbackTaskClass(CSimpleStringA verDirName, string& failReason, CSimpleStringA& strErrMsg);//临时判定回退任务类别
+	void judgeTaskClass();//涓存椂鍒ゅ畾鍗囩骇浠诲姟绫诲埆
+	ErrorCodeEnum judgeRollbackTaskClass(CSimpleStringA verDirName, string& failReason, CSimpleStringA& strErrMsg);//涓存椂鍒ゅ畾鍥為€€浠诲姟绫诲埆
 	
-	ErrorCodeEnum CreateNewDepVersion(CSimpleStringA NewSoftwareVersion, CSimpleStringA& strErrInfo);//升级时创建新适配器版本
-	ErrorCodeEnum CreateInstallDepVersion(CSimpleStringA NewSoftwareVersion, CSimpleStringA& strErrInfo);//安装时创建新适配器版本
-	ErrorCodeEnum ClearUpgradeFailDepVersion(CSimpleStringA NewSoftwareVersion);//清理升级新版本临时文件
-	ErrorCodeEnum UpgradeDepToNewVersion();//更新depactive文件
-	ErrorCodeEnum SwitchUpgradeDepNow();//切换适配器版本
-	ErrorCodeEnum RollBackDepVersionCheck(string& failReason, CSimpleStringA& strErrMsg);//回退版本检查 C：一般错误 X：终端找不到需要回退的版本文件夹
-	ErrorCodeEnum RollBackToHistoryDepVersion(CSimpleStringA historyDepVersion);//适配器回退到某个历史版本
-
-	//适配器安装函数
-	int ExecDepInstall(CSimpleStringA& strErrMsg);//适配器升级 0：失败 1：成功 
+	ErrorCodeEnum CreateNewDepVersion(CSimpleStringA NewSoftwareVersion, CSimpleStringA& strErrInfo);//鍗囩骇鏃跺垱寤烘柊閫傞厤鍣ㄧ増鏈�
+	ErrorCodeEnum CreateInstallDepVersion(CSimpleStringA NewSoftwareVersion, CSimpleStringA& strErrInfo);//瀹夎�鏃跺垱寤烘柊閫傞厤鍣ㄧ増鏈�
+	ErrorCodeEnum ClearUpgradeFailDepVersion(CSimpleStringA NewSoftwareVersion);//娓呯悊鍗囩骇鏂扮増鏈�复鏃舵枃浠�
+	ErrorCodeEnum UpgradeDepToNewVersion();//鏇存柊depactive鏂囦欢
+	ErrorCodeEnum SwitchUpgradeDepNow();//鍒囨崲閫傞厤鍣ㄧ増鏈�
+	ErrorCodeEnum RollBackDepVersionCheck(string& failReason, CSimpleStringA& strErrMsg);//鍥為€€鐗堟湰妫€鏌� C锛氫竴鑸�敊璇� X锛氱粓绔�壘涓嶅埌闇€瑕佸洖閫€鐨勭増鏈�枃浠跺す
+	ErrorCodeEnum RollBackToHistoryDepVersion(CSimpleStringA historyDepVersion);//閫傞厤鍣ㄥ洖閫€鍒版煇涓�巻鍙茬増鏈�
+
+	//閫傞厤鍣ㄥ畨瑁呭嚱鏁�
+	int ExecDepInstall(CSimpleStringA& strErrMsg);//閫傞厤鍣ㄥ崌绾� 0锛氬け璐� 1锛氭垚鍔� 
 	int ExecDepRunCmd(CSimpleStringA& strErrMsg, CInstallStep* ins);
 	bool ExecDepDeleteCmd(CSimpleStringA& strErrMsg, CInstallStep* ins);
 	bool ExecDepCpoyCmd(CSimpleStringA& strErrMsg, CInstallStep* ins);
-	bool GetDepRootTypePath(int rootType, CSimpleStringA& rootPath);//1:相对路径 2：当前版本相对路径 3：升级版本相对路径 4：升级包相对路径
+	bool GetDepRootTypePath(int rootType, CSimpleStringA& rootPath);//1:鐩稿�璺�緞 2锛氬綋鍓嶇増鏈�浉瀵硅矾寰� 3锛氬崌绾х増鏈�浉瀵硅矾寰� 4锛氬崌绾у寘鐩稿�璺�緞
 
 	CSimpleStringA getAlarmCurrVersion();
 
-	//升级时添加防火墙策略
+	//鍗囩骇鏃舵坊鍔犻槻鐏��绛栫暐
 	ErrorCodeEnum SetNewVersionPathToFirewall();
 
 	bool isWork();
@@ -469,13 +462,13 @@ private:
 	enum{s1, s2, s3, s4, s5, s6, s7};
 
 	BEGIN_FSM_STATE(CUpgradeTaskFSM)
-		FSM_STATE_ENTRY(s1, "Start",s1_on_entry,s1_on_exit,s1_on_event)//计算hash值
-		FSM_STATE_ENTRY(s2, "DealTask",s2_on_entry,s2_on_exit,s2_on_event)//处理上个任务，反馈任务结果，并根据任务状态跳转到其他状态
-		FSM_STATE_ENTRY(s3, "Poll",s3_on_entry,s3_on_exit,s3_on_event)//查询任务
-		FSM_STATE_ENTRY(s4, "Download", s4_on_entry, s4_on_exit, s4_on_event)//下载安装包
-		FSM_STATE_ENTRY(s5, "Install", s5_on_entry, s5_on_exit, s5_on_event)//安装升级包
-		FSM_STATE_ENTRY(s6, "Switch", s6_on_entry, s6_on_exit, s6_on_event)//进行版本切换
-		FSM_STATE_ENTRY(s7, "Disable", s7_on_entry, s7_on_exit, s7_on_event)//静止状态
+		FSM_STATE_ENTRY(s1, "Start",s1_on_entry,s1_on_exit,s1_on_event)//璁＄畻hash鍊�
+		FSM_STATE_ENTRY(s2, "DealTask",s2_on_entry,s2_on_exit,s2_on_event)//澶勭悊涓婁釜浠诲姟锛屽弽棣堜换鍔＄粨鏋滐紝骞舵牴鎹�换鍔＄姸鎬佽烦杞�埌鍏朵粬鐘舵€�
+		FSM_STATE_ENTRY(s3, "Poll",s3_on_entry,s3_on_exit,s3_on_event)//鏌ヨ�浠诲姟
+		FSM_STATE_ENTRY(s4, "Download", s4_on_entry, s4_on_exit, s4_on_event)//涓嬭浇瀹夎�鍖�
+		FSM_STATE_ENTRY(s5, "Install", s5_on_entry, s5_on_exit, s5_on_event)//瀹夎�鍗囩骇鍖�
+		FSM_STATE_ENTRY(s6, "Switch", s6_on_entry, s6_on_exit, s6_on_event)//杩涜�鐗堟湰鍒囨崲
+		FSM_STATE_ENTRY(s7, "Disable", s7_on_entry, s7_on_exit, s7_on_event)//闈欐�鐘舵€�
 	END_FSM_STATE()
 
 	BEGIN_FSM_RULE(CUpgradeTaskFSM,s1)
@@ -485,39 +478,39 @@ private:
 		FSM_RULE_ENTRY(s2, s5, Event_EndQueryCurrTask, 5)	
 		FSM_RULE_ENTRY(s2, s6, Event_EndQueryCurrTask, 6)
 		FSM_RULE_ENTRY_ANY(s3, s4, Event_StartDownload)
-		FSM_RULE_ENTRY_ANY(s3, s5, Event_StartInstall)//回退
+		FSM_RULE_ENTRY_ANY(s3, s5, Event_StartInstall)//鍥為€€
 		FSM_RULE_ENTRY_ANY(s4, s5, Event_StartInstall)
-		FSM_RULE_ENTRY_ANY(s4, s3, Event_StartPoll)//任务取消进入S3
-		FSM_RULE_ENTRY_ANY(s4, s2, Event_StartDealTask)//下载失败进入S2
+		FSM_RULE_ENTRY_ANY(s4, s3, Event_StartPoll)//浠诲姟鍙栨秷杩涘叆S3
+		FSM_RULE_ENTRY_ANY(s4, s2, Event_StartDealTask)//涓嬭浇澶辫触杩涘叆S2
 		FSM_RULE_ENTRY_ANY(s5, s6, Event_StartSwitch)
-		FSM_RULE_ENTRY_ANY(s5, s2, Event_StartDealTask)//安装失败进入S2
-		FSM_RULE_ENTRY_ANY(s6, s2, Event_StartDealTask)//无需重启框架和系统切换成功进入S2
-		FSM_RULE_ENTRY_ANY(s6, s3, Event_StartPoll)//取消任务进入S3
-		FSM_RULE_ENTRY_ANY(s6, s7, Event_PreRestart)//重启服务
+		FSM_RULE_ENTRY_ANY(s5, s2, Event_StartDealTask)//瀹夎�澶辫触杩涘叆S2
+		FSM_RULE_ENTRY_ANY(s6, s2, Event_StartDealTask)//鏃犻渶閲嶅惎妗嗘灦鍜岀郴缁熷垏鎹㈡垚鍔熻繘鍏�2
+		FSM_RULE_ENTRY_ANY(s6, s3, Event_StartPoll)//鍙栨秷浠诲姟杩涘叆S3
+		FSM_RULE_ENTRY_ANY(s6, s7, Event_PreRestart)//閲嶅惎鏈嶅姟
 	END_FSM_RULE()
 
 private:
-	//完成
+	//瀹屾垚
 	void s1_on_entry();
 	void s1_on_exit();
 	unsigned int s1_on_event(FSMEvent* event);
-	//完成
+	//瀹屾垚
 	void s2_on_entry();
 	void s2_on_exit();
 	unsigned int s2_on_event(FSMEvent* event);
-	//完成
+	//瀹屾垚
 	void s3_on_entry();
 	void s3_on_exit();
 	unsigned int s3_on_event(FSMEvent* event);
-	//完成
+	//瀹屾垚
 	void s4_on_entry();
 	void s4_on_exit();
 	unsigned int s4_on_event(FSMEvent* event);
-	//完成
+	//瀹屾垚
 	void s5_on_entry();
 	void s5_on_exit();
 	unsigned int s5_on_event(FSMEvent* event);
-	//完成
+	//瀹屾垚
 	void s6_on_entry();
 	void s6_on_exit();
 	unsigned int s6_on_event(FSMEvent* event);
@@ -530,45 +523,45 @@ private:
 
 	
 	
-	list<CSimpleStringA> m_DepWhitelist; //dep文件夹白名单
-	list<CSimpleStringA> m_DirBlacklist; //整体文件夹黑名单
-	list<CSimpleStringA> m_FileBlacklist; //整体文件黑名单
+	list<CSimpleStringA> m_DepWhitelist; //dep鏂囦欢澶圭櫧鍚嶅崟
+	list<CSimpleStringA> m_DirBlacklist; //鏁翠綋鏂囦欢澶归粦鍚嶅崟
+	list<CSimpleStringA> m_FileBlacklist; //鏁翠綋鏂囦欢榛戝悕鍗�
 
 public:
-	map<CSimpleStringA, CSimpleStringA> m_fileSM3Map;	// 版本文件hash值集合
-
-	CTaskInfo m_currentTask;	//当前的任务缓存变量
-	CVersion m_currentVersion;  //当前终端版本
-	CSimpleStringA m_currentDepVersion; //当前适配器版本
-
-	CenterUrl m_centerUrl;//访问总行的url地址集合
-	int m_newEachDownloadLen;//新的每次下载数据长度阈值(k)
-	bool m_PrintHttpLog;  //是否打印通讯日志
-	bool m_startFlag; //升级实体启动标志位,默认是不开，
-	bool m_stopSetFirewall;//是否停止设置防火墙路径，默认是不停止
-	HashScanSet m_hashScanSet;//扫描文件hash设置
-
-	bool m_isSM3HashSucc;//hash是否计算成功
-	bool isSendHash;//hash是否发送
-	CSimpleStringA m_fileSM3ListHash;//SM3 64位hash
-	CSimpleStringA m_fileSM3List;//版本文件hash集合字符串
-	DWORD m_beginSendSM3Time;//开始发送sm3hahs时间
-	int m_queryNewTaskCount;//查询新任务时无任务次数
+	map<CSimpleStringA, CSimpleStringA> m_fileSM3Map;	// 鐗堟湰鏂囦欢hash鍊奸泦鍚�
+
+	CTaskInfo m_currentTask;	//褰撳墠鐨勪换鍔＄紦瀛樺彉閲�
+	CVersion m_currentVersion;  //褰撳墠缁堢�鐗堟湰
+	CSimpleStringA m_currentDepVersion; //褰撳墠閫傞厤鍣ㄧ増鏈�
+
+	CenterUrl m_centerUrl;//璁块棶鎬昏�鐨剈rl鍦板潃闆嗗悎
+	int m_newEachDownloadLen;//鏂扮殑姣忔�涓嬭浇鏁版嵁闀垮害闃堝€�(k)
+	bool m_PrintHttpLog;  //鏄�惁鎵撳嵃閫氳�鏃ュ織
+	bool m_startFlag; //鍗囩骇瀹炰綋鍚�姩鏍囧織浣�,榛樿�鏄�笉寮€锛�
+	bool m_stopSetFirewall;//鏄�惁鍋滄�璁剧疆闃茬伀澧欒矾寰勶紝榛樿�鏄�笉鍋滄�
+	HashScanSet m_hashScanSet;//鎵�弿鏂囦欢hash璁剧疆
+
+	bool m_isSM3HashSucc;//hash鏄�惁璁＄畻鎴愬姛
+	bool isSendHash;//hash鏄�惁鍙戦€�
+	CSimpleStringA m_fileSM3ListHash;//SM3 64浣峢ash
+	CSimpleStringA m_fileSM3List;//鐗堟湰鏂囦欢hash闆嗗悎瀛楃�涓�
+	DWORD m_beginSendSM3Time;//寮€濮嬪彂閫乻m3hahs鏃堕棿
+	int m_queryNewTaskCount;//鏌ヨ�鏂颁换鍔℃椂鏃犱换鍔℃�鏁�
 	int m_queryIsWorkCount;
 	int m_downloadBreakOffCount;
 
-	bool m_bDownloadIdle;	//是否下载空闲 true: 不能下载，false: 可下载
-	bool m_bTaskCancel;		//是否任务取消 true: 任务取消，false: 未取消
+	bool m_bDownloadIdle;	//鏄�惁涓嬭浇绌洪棽 true: 涓嶈兘涓嬭浇锛宖alse: 鍙�笅杞�
+	bool m_bTaskCancel;		//鏄�惁浠诲姟鍙栨秷 true: 浠诲姟鍙栨秷锛宖alse: 鏈�彇娑�
 
-	int m_iBlackFileCount;    //黑名单文件数量
+	int m_iBlackFileCount;    //榛戝悕鍗曟枃浠舵暟閲�
 
-	CSimpleStringA m_strPreTaskId; //预检查taskId
-	int m_bNeedHash;//是否需要hash对比查询任务
-	bool m_bSwitchFlag;//是否启动后切换流程直接进入标志
-	bool m_bRollbackTask;//是否已经处于回退流程。
+	CSimpleStringA m_strPreTaskId; //棰勬�鏌�askId
+	int m_bNeedHash;//鏄�惁闇€瑕乭ash瀵规瘮鏌ヨ�浠诲姟
+	bool m_bSwitchFlag;//鏄�惁鍚�姩鍚庡垏鎹㈡祦绋嬬洿鎺ヨ繘鍏ユ爣蹇�
+	bool m_bRollbackTask;//鏄�惁宸茬粡澶勪簬鍥為€€娴佺▼銆�
 
-	bool m_TempDepUpgradeFlag;//临时适配器升级安装的判定标志 true 适配器 false 非适配器
-	int m_queryNewTaskInterval;//查询任务时间间隔，默认是240s
-	bool m_installStopCopyDep;//安装时是否停止拷贝应用dep公共文件夹
+	bool m_TempDepUpgradeFlag;//涓存椂閫傞厤鍣ㄥ崌绾у畨瑁呯殑鍒ゅ畾鏍囧織 true 閫傞厤鍣� false 闈為€傞厤鍣�
+	int m_queryNewTaskInterval;//鏌ヨ�浠诲姟鏃堕棿闂撮殧锛岄粯璁ゆ槸240s
+	bool m_installStopCopyDep;//瀹夎�鏃舵槸鍚﹀仠姝㈡嫹璐濆簲鐢╠ep鍏�叡鏂囦欢澶�
 };
 #endif //RVC_MOD_UPGRADETASK_FSM_H_

Module/mod_accessauth/AccessAuthFSM.cpp

@@ -833,7 +833,7 @@ DWORD CAccessAuthFSM::GetEncTerminalInfoWithKey(CBlob& encInfo, BYTE* key)
 	int len = 0;
 #ifdef RVC_OS_WIN
 	string tmpStr = strResult.second;
-	SP::Module::Util::ConvertGBKToUtf8(tmpStr);
+	SP::Module::Util::ConvertGBK2Utf8(tmpStr);
 	strcpy(pBuf, tmpStr.c_str()); //GBK转UTF8
 	len = tmpStr.size();
 #else

Module/mod_chromium/baseEx.cpp

@@ -19,6 +19,7 @@
 #include "exLog/log.h"
 #include "cJSON.h"
 #include "RVCComm.h"
+#include "CommEntityUtil.hpp"
 using namespace boost::interprocess;
 
 //read ini
@@ -55,43 +56,16 @@ const std::wstring specialStr = L"乗俓僜刓匼哱圽塡奬媆峔嶾廫慭怽
 
 std::string UtfToGbk(const char* utf8)
 {
-	int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
-	wchar_t* wstr = new wchar_t[len + 1];
-	memset(wstr, 0, len + 1);
-	MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
-	len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
-	char* str = new char[len + 1];
-	memset(str, 0, len + 1);
-	WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
-	if (wstr) delete[] wstr;
-	return str;
+	std::string val(utf8);
+	SP::Module::Util::ConvertUtf82GBK(val);
+	return val;
 }
 
-//GBK转化为UTF8格式
-std::string ConvertGBKToUtf8(std::string& strGBK)
-{
-	int len = MultiByteToWideChar(CP_ACP, 0, (LPCTSTR)strGBK.c_str(), -1, NULL, 0);
-	wchar_t* wszUtf8 = new wchar_t[len];
-	memset(wszUtf8, 0, len);
-	MultiByteToWideChar(CP_ACP, 0, (LPCTSTR)strGBK.c_str(), -1, wszUtf8, len);
-	len = WideCharToMultiByte(CP_UTF8, 0, wszUtf8, -1, NULL, 0, NULL, NULL);
-	char* szUtf8 = new char[len + 1];
-	memset(szUtf8, 0, len + 1);
-	WideCharToMultiByte(CP_UTF8, 0, wszUtf8, -1, szUtf8, len, NULL, NULL);
-	std::string ret = szUtf8;
-	delete[] szUtf8;
-	delete[] wszUtf8;
-	return ret;
-}
 #else
 std::string UtfToGbk(const char* utf8)
 {
 	return utf8;
 }
-std::string ConvertGBKToUtf8(std::string& strGBK)
-{
-	return strGBK;
-}
 #endif
 
 struct cefclientLog {

Module/mod_chromium/baseEx.h

@@ -56,7 +56,6 @@ struct ErrMsgStruct {
 std::pair<unsigned long, ErrMsgStruct> getErrMsgByRemark(std::string srcMsg, bool isSafe);
 
 std::string UtfToGbk(const char* utf8);
-std::string ConvertGBKToUtf8(std::string& strGBK);
 
 void hexdump(const char* buf, const int num);
 std::string hexdumpToString(const char* buf, const int num);

Module/mod_guiconsole/mod_guiconsole.cpp

@@ -668,35 +668,6 @@ std::pair<DWORD, std::string> CGUIConsoleEntity::GetHelpInformationArr(SpReqAnsC
 	}
 	return std::pair<DWORD, std::string>(ErrorCodeEnum::Error_Succeed, "");
 }
-#if(defined _WIN32 || defined _WIN64)
-
-char* ConvertGBKToUtf8(const char* gbk, int* n)
-{
-	int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szUtf8 = new char[len + 1];
-	memset(szUtf8, 0, len + 1);
-	WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
-
-	delete[] wszGBK;
-	*n = len - 1;
-	return szUtf8;
-}
-
-void ConvertGBKToUtf8(std::string& str)
-{
-	int len = 0;
-	char* dst = ConvertGBKToUtf8(str.c_str(), &len);
-	str = dst;
-	delete[] dst;
-}
-
-
-#endif
 
 static const std::string base64_chars =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -808,25 +779,6 @@ std::pair<DWORD, std::string> CGUIConsoleEntity::GetHelpDetail(SpReqAnsContext<G
 		}
 	}
 	std::string srcStr = dstStr.GetData();
-#if(defined _WIN32 || defined _WIN64)
-	//ConvertGBKToUtf8(srcStr);
-	//boost::locale::generator gen;
-	//std::locale loc = gen("zh_CN.GBK");
-	//srcStr = boost::locale::conv::to_utf<char>(srcStr, loc);
-	//dstStr = string_to_utf8(dstStr.GetData()).c_str();
-	//auto aaaStr = utf8_to_string(dstStr.GetData());
-#endif
-
-	/*
-	int base64Len = modp_b64_encode_len(srcStr.length());
-	char *base64Data = (char*)malloc(sizeof(char) * base64Len);
-	modp_b64_encode(base64Data, (const char*)srcStr.c_str(), srcStr.length());
-	*/
-
-	//auto base64Data = base64_encode(srcStr);
-
-	//ctx->Ans.detail = base64Data.c_str();
-
 	ctx->Ans.detail = srcStr.c_str();
 	return std::pair<DWORD, std::string>(ErrorCodeEnum::Error_Succeed, "");
 }