myvtm/Framework/spshell/spshell.cpp

#include "precompile.h"
#include "app.h"
#include "osutil.h"
#include "version.h"
#include "memtrace.h"
#include "sp_def.h"

#ifdef RVC_OS_WIN
#include <DbgHelp.h>
#include <TlHelp32.h>
#include <shellapi.h>
#else
#include <unistd.h>
#endif //RVC_OS_WIN

#include "fileutil.h"
#include "iniutil.h"
#include "getopt.h"
#include "toolkit.h"
#include "SimpleString.h"
#include "md5file.h"
#include "SpBase.h"
#include "SpComm.hpp"

#ifdef RVC_OS_WIN
#include <io.h>
#pragma comment(lib, "dbghelp.lib")
#else
#include <unistd.h>
#include <sys/syscall.h>
#endif //RVC_OS_WIN

#include <map> 
#include <iterator>
#include <fstream>

#include "libtoolkit/log.h"
#include <signal.h>
#include "SpBase.h"
#include "sp_dbg_export.h"
#include "versionBase.h"
#include "base64File.hpp"
#include "RVCEventCode.h"
#include "dbgutil.h"
#include <locale.h>
#include <winpr/library.h>
#include <winpr/environment.h>
#include <winpr/registry.h>
#include <winpr/sysinfo.h>

#ifdef realloc
	#undef realloc //(p, s)
#endif

using namespace std;

#ifdef WITH_QT
#include "PollCenter.h"
#include <QMessageBox>
//#pragma execution_character_set("utf-8")
#endif
#include <spbase/sp_runTask.h>

#ifndef RVC_OS_WIN
static int GetParentProcessID()
{
#if 0
    return getppid();
#else
    return (int)syscall(SYS_getppid);
#endif
}

#endif //NOT _WIN32

#ifdef RVC_OS_WIN
static char spshell_execute_name[] = "SpShell.exe";
static char sphost_execute_name[] = "SpHost.exe";
static char guardian_execute_name[] = "Guardian.exe";
static char cefclient_execute_name[] = "cefclient.exe";
#else
static char spshell_execute_name[] = "spshell";
static char sphost_execute_name[] = "sphost";
static char guardian_execute_name[] = "guardian";
static char cefclient_execute_name[] = "cefclient";
#endif //_WIN32

#define RESTART_MODE_DEFAULT 0
#define RESTART_MODE_NORMAL 1
#define RESTART_MODE_PRE 2
#define RESTART_MODE_SHUTDOWN 3
#define RESTART_MODE_POWEROFF 4
#define RESTART_MODE_REBOOT 5

#define DRIVER_NAME "HelloDDK"
#define DRIVER_PATH "InterceptDll.sys"

#define SET_EVENT		\
	CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define GET_SHARE_ADD	\
	CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)

HANDLE g_hEvent = NULL;
bool g_bMD5Exist = false;
bool g_bWow64 = false;
CSimpleStringA g_strMD5ListPath;
static int g_restartMode = RESTART_MODE_DEFAULT;
static bool g_immediately = false;
char* relate_processes[] = { spshell_execute_name, sphost_execute_name, cefclient_execute_name };
const int relate_processes_count = 3;
char* relate_processes_ex[] = { spshell_execute_name, sphost_execute_name, guardian_execute_name, cefclient_execute_name };
const int relate_processes_ex_count = 4;
const int MAX_LEN = 256;

//E:\Run\version\3.10.0.1\dep;E:\Run\version\3.10.0.1\bin;E:\Run\version\3.10.0.1\dev;E:\Run\version\3.10.0.1\imdep
static bool IsSpPathType(const CSimpleStringA& value)
{
#if defined(RVC_OS_WIN)
    const int leastLength = strlen("C:\\version\\1.0.0.0\\");
#else
    const int leastLength = strlen("Run/version/1.0.0.0/");
#endif //RVC_OS_WIN

    CSimpleStringA path(value.GetData());
    if (path.IsNullOrEmpty() || path.GetLength() < leastLength) return false;
    const int sionPos = path.IndexOf("version");
    const int verPos = sionPos + strlen("version" SPLIT_SLASH_STR);
    if (sionPos < 0) return false;
    int suffixPos = -1, i;
    int dotCnt = 0;
    bool lastIsNum = false;
    for (i = verPos; i < path.GetLength() && (path[i] >= '0' && path[i] <= '9' || path[i] == '.'); ++i) {
        lastIsNum = !(path[i] == '.');
        if (!lastIsNum) dotCnt++;
    }

    if (i >= path.GetLength() || dotCnt != 3 || !lastIsNum)
        return false;


    //if(path[i] == '\\' || path[i] == '//')

    return true;

}

static CSimpleStringA CutSpPathFromPathValue(const char* value, const char* prefix)
{
    CSimpleStringA path(value);
    CSimpleStringA result(true);
    CAutoArray<CSimpleStringA> values = path.Split(ENV_SEP_CHAR);
    if (values.GetCount() <= 0) {
        return path;
    }
    for (int i = 0; i < values.GetCount(); ++i) {
        if (values[i].IsStartWith(prefix) || !IsSpPathType(values[i])) {
            if (!result.IsNullOrEmpty()) result += ENV_SEP_STR;
            result += values[i];
        }
    }

    if (!result.IsNullOrEmpty() && path[path.GetLength() - 1] == ENV_SEP_CHAR) {
        result += ENV_SEP_STR;
    }

    return result;
}

static void SetEnvPath()
{
	char path[MAX_PATH];
	char *buf;
	DWORD size;
	const char *var = "PATH";

	// set current path
	GetModuleFileNameA(NULL, path, MAX_PATH);
	*strrchr(path, SPLIT_SLASH) = 0;
	*strrchr(path, SPLIT_SLASH) = 0;
	SetCurrentDirectoryA(path);

	size = GetEnvironmentVariableA(var, NULL, 0);
	buf = (char*)malloc(size+MAX_PATH*3);
	size = GetEnvironmentVariableA(var, buf, size);

    CSimpleStringA newValue = CutSpPathFromPathValue(buf, path);
    if (newValue.GetLength() < size) {
        printf("before: %s,%d\n", buf, size);
        strcpy(buf, newValue.GetData());
        memset(buf + newValue.GetLength(), '\0', sizeof(char) * (size + MAX_PATH * 3 - newValue.GetLength()));
        size = newValue.GetLength();
        printf("after: %s,%d\n", buf, size);
    }

	strcpy(buf+size, ENV_SEP_STR);

    // append dep sub dir to %PATH%
    strcat(path, SPLIT_SLASH_STR "dep");
	strcat(buf+size, path);

	*strrchr(path, SPLIT_SLASH) = 0;
	strcat(path, SPLIT_SLASH_STR "bin");
	strcat(buf+size, ENV_SEP_STR);
	strcat(buf+size, path);
	
	*strrchr(path, SPLIT_SLASH) = 0;
	strcat(path, SPLIT_SLASH_STR "dev");
	strcat(buf+size, ENV_SEP_STR);
	strcat(buf+size, path);

	*strrchr(path, SPLIT_SLASH) = 0;
	strcat(path, SPLIT_SLASH_STR "imdep");
	strcat(buf + size, ENV_SEP_STR);
	strcat(buf + size, path);

	SetEnvironmentVariableA(var, buf);
	free(buf);

	SetEnvironmentVariableA("ModuleName", "SpShell");
}

#ifdef RVC_OS_WIN

static void SetWorkingSet()
{
	SIZE_T dwMinSize, dwMaxSize;
	HANDLE hCurrProcess = GetCurrentProcess();
	GetProcessWorkingSetSize(hCurrProcess, &dwMinSize, &dwMaxSize);
	if (dwMaxSize < (2 << 20))
		dwMaxSize = 2 << 20;
	SetProcessWorkingSetSize(hCurrProcess, dwMinSize, dwMaxSize);
}

static LONG WINAPI SuppressError(struct _EXCEPTION_POINTERS* ExceptionInfo)
{
	static bool hasCall = false;

	if (hasCall)
		ExitProcess(Error_Exception);
	else
		hasCall = true;

	char tmp[MAX_PATH];
	HANDLE hDumpFile;
	std::string dmpFileStr;
	GetModuleFileNameA(NULL, tmp, MAX_PATH);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;

	wsprintfA(tmp, "%s\\rvc\\dmp\\expt.spshell.%d.%s.dmp", tmp, GetCurrentProcessId(), STRFILEVER);
	hDumpFile = CreateFileA( tmp, GENERIC_READ | GENERIC_WRITE, 
		0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
	if( ( hDumpFile != NULL ) && ( hDumpFile != INVALID_HANDLE_VALUE ) ) 
	{
		MINIDUMP_EXCEPTION_INFORMATION mdei; 
		MINIDUMP_TYPE mdt;
		mdei.ThreadId = GetCurrentThreadId(); 
		mdei.ExceptionPointers  = ExceptionInfo; 
		mdei.ClientPointers = FALSE; 
		mdt = MiniDumpNormal; 
		MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), 
			hDumpFile, mdt, (ExceptionInfo != 0) ? &mdei : 0, 0, 0 ); 
		CloseHandle( hDumpFile ); 
	}

	char szCmd[256];
	sprintf_s(szCmd, 256, "TASKKILL /f /im sphost.exe");
	system(szCmd);

	sprintf_s(szCmd, 256, "TASKKILL /f /im sphost_re.exe");
	system(szCmd);

	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ERR_SPSHELL_EXCETION).setResultCode(RTAERR_SPSHELL_EXCEPTION)("spshell exit exception, saveDmp, %s, detail:%d:%s"
		, tmp, dmpFileStr.length() ,dmpFileStr.c_str());

	ExitProcess(Error_Exception); // exit process to suppress reporting exception

	return EXCEPTION_EXECUTE_HANDLER;
}

static void DisableSetUnhandledExceptionFilter()
{
	void* addr = (void*)GetProcAddress(LoadLibrary("kernel32.dll"), "SetUnhandledExceptionFilter");
	if (addr) {
		DWORD dwOldFlag, dwTempFlag;
		unsigned char code[] = {0x33, 0xC0, 0xC2, 0x04, 0x00}; // xor eax,eax; ret 4;
		//VirtualProtect(addr, sizeof(code), PAGE_READWRITE, &dwOldFlag);
		VirtualProtectEx(GetCurrentProcess(), addr, sizeof(code), PAGE_EXECUTE_READWRITE, &dwOldFlag);
		WriteProcessMemory(GetCurrentProcess(), addr, code, sizeof(code), NULL);
		VirtualProtect(addr, sizeof(code), dwOldFlag, &dwTempFlag);
	}
}

__declspec(dllimport) bool DisableCharmbar();
__declspec(dllimport) bool EnableCharmbar();


static HANDLE create_process(const char *app)
{	
	//BOOL bRet;
	STARTUPINFOA si = { sizeof(STARTUPINFOA) };
	si.wShowWindow = SW_SHOWMAXIMIZED;
	si.dwFlags = STARTF_USESHOWWINDOW;
	PROCESS_INFORMATION pi;
	DWORD dwSessionId;
	HANDLE hUserTokenDup, hThisToken;
	HANDLE hProcess = NULL;

	dwSessionId = WTSGetActiveConsoleSessionId();
	if (OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &hThisToken)) {
		LUID luid;
		TOKEN_PRIVILEGES tp;
		LPVOID pEnv = NULL;
		LookupPrivilegeValueA(NULL, SE_DEBUG_NAME, &luid);
		tp.PrivilegeCount = 1;
		tp.Privileges[0].Luid = luid;
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
		DuplicateTokenEx(hThisToken, MAXIMUM_ALLOWED, NULL,
			SecurityIdentification, TokenPrimary, &hUserTokenDup);
		SetTokenInformation(hUserTokenDup,
			TokenSessionId, (void*)&dwSessionId, sizeof(DWORD));
		AdjustTokenPrivileges(hUserTokenDup, FALSE, &tp, sizeof(TOKEN_PRIVILEGES),
			(PTOKEN_PRIVILEGES)NULL, NULL);
		//CreateEnvironmentBlock(&pEnv,hUserTokenDup,TRUE);
		if (CreateProcessAsUserA(hUserTokenDup, NULL, 
			(LPSTR)app,		// "D:\\Source\\RVC\\RVCProject\\Release\\version\\1.0.0.1\\bin\\MetroWatcher64.exe 732",
			NULL, NULL, FALSE, 0, pEnv, NULL, &si, &pi)) 
		{
			CloseHandle(pi.hThread);
			hProcess = pi.hProcess;
		}
		else 
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("create process failed! Error : ", GetLastError());

		//if (pEnv)
		//DestroyEnvironmentBlock(pEnv);
		CloseHandle(hUserTokenDup);
		CloseHandle(hThisToken);
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("open process token failed! Error : ", GetLastError());
	}

	return hProcess;
}

static void AutoHideTaskBar(bool bHide)
{
	APPBARDATA apBar;
	memset(&apBar, 0, sizeof(apBar));
	apBar.cbSize = sizeof(apBar);
	apBar.lParam = bHide ? ABS_AUTOHIDE :  ABS_ALWAYSONTOP;
	apBar.hWnd = FindWindow("Shell_TrayWnd", NULL);

	if (apBar.hWnd != NULL)
	{
		SHAppBarMessage(ABM_SETSTATE, &apBar); 
	}
}



static bool AddRegIntValue(HKEY hKey, const char *szSubKey, const char *szKeyName, DWORD dwValue, bool bWin64)
{
	HKEY hSubKey;
	LONG nRet = ::RegCreateKeyEx(hKey,
		szSubKey,
		0,
		NULL,
		0,
		bWin64 ? (KEY_ALL_ACCESS | KEY_WOW64_64KEY) : (KEY_ALL_ACCESS | KEY_WOW64_32KEY),
		NULL,
		&hSubKey,
		NULL);
	if (nRet != ERROR_SUCCESS)
		return false;

	nRet = RegSetValueExA(hSubKey, szKeyName, 0, REG_DWORD, (BYTE*)&dwValue, sizeof(DWORD));
	RegCloseKey(hSubKey);
	return (nRet == ERROR_SUCCESS);
}




static bool AddFirewallRules()
{
	char szBinDir[MAX_PATH] = {};
	GetModuleFileNameA(NULL, szBinDir, MAX_PATH);
	*strrchr(szBinDir, SPLIT_SLASH) = 0;

	int nRet = (int)ShellExecute(NULL, "open", "cmd.exe", "/s /c  \"netsh advfirewall firewall delete rule name=\"\"SpShell\"\"", NULL, SW_HIDE);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", "/s /c  \"netsh advfirewall firewall delete rule name=\"\"SpShell\"\"", NULL, SW_HIDE);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", "/s /c  \"netsh advfirewall firewall delete rule name=\"\"SpHost\"\"", NULL, SW_HIDE);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", "/s /c  \"netsh advfirewall firewall delete rule name=\"\"SpGuardian\"\"", NULL, SW_HIDE);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", "/s /c  \"netsh advfirewall firewall delete rule name=\"\"cefclient\"\"", NULL, SW_HIDE);

	char szParam[1024] = {};
	sprintf_s(szParam, 1024, "/s /c  \"netsh advfirewall firewall add rule name=\"\"SpShell\"\" dir=out program=\"\"%s\\spshell.exe\"\" action=allow\"", szBinDir);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", szParam, NULL, SW_HIDE);

	sprintf_s(szParam, 1024, "/s /c  \"netsh advfirewall firewall add rule name=\"\"SpHost\"\" dir=out program=\"\"%s\\sphost.exe\"\" action=allow\"", szBinDir);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", szParam, NULL, SW_HIDE);

	sprintf_s(szParam, 1024, "/s /c  \"netsh advfirewall firewall add rule name=\"\"SpHost_re\"\" dir=out program=\"\"%s\\sphost_re.exe\"\" action=allow\"", szBinDir);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", szParam, NULL, SW_HIDE);

	sprintf_s(szParam, 1024, "/s /c  \"netsh advfirewall firewall add rule name=\"\"SpGuardian\"\" dir=out program=\"\"%s\\guardian.exe\"\" action=allow\"", szBinDir);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", szParam, NULL, SW_HIDE);

	sprintf_s(szParam, 1024, "/s /c  \"netsh advfirewall firewall add rule name=\"\"cefclient\"\" dir=out program=\"\"%s\\Chromium\\cefclient.exe\"\" action=allow\"", szBinDir);
	nRet = (int)ShellExecute(NULL, "open", "cmd.exe", szParam, NULL, SW_HIDE);

	return nRet > 32;
}

int AddFireAddFirewallRulesThread(void* param)
{
	if (!AddFirewallRules())
	{
		DbgWithLink(LOG_LEVEL_FATAL, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("设置Windows防火墙策略失败!!!");
		Sleep(10000);
		return -1;
	}
	else
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("设置Windows防火墙策略成功!!!");

	return 0;
}

static void AddFirewallRulesEx()
{
	CloseHandle(CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)& AddFireAddFirewallRulesThread, NULL, 0, NULL));
}



bool DisableWindowsCharmBar(void *param)
{

	auto AutoHideCharmBar = []()->bool
	{
		HWND hWnd = FindWindow(NULL, "Charm Bar");
		if (hWnd)
		{
			ShowWindow(hWnd, SW_HIDE);
			return true;
		}
		else
			return false;
		
	};
	static bool firstRun = true;
	while(true)
	{
		auto ret = AutoHideCharmBar();
		if(firstRun)
		{
			firstRun = false;
			if(ret) DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("disable windows 8 charmbar %s", "succ");
		}
		if (!ret) break;
		Sleep(5000);
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("disable windows 8 charmbar failed, end!!");
	return false;
}

static void DisableWindowsCharmBarThread(bool bX64)
{
	static bool curver = bX64;
	CloseHandle(CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&DisableWindowsCharmBar, &curver, 0, NULL));
}

#endif //RVC_OS_WIN

/*!
 * at Linux, judge whether current process runs as root privilege.
 * @return : True only if run as admin or root
 */
static bool  IsProcessRunAsAdmin()
{
	BOOL bAdmin = FALSE;

#ifdef RVC_OS_WIN
	SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
	PSID AdministratorsGroup = NULL;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("start AllocateAndInitializeSid");
	if (AllocateAndInitializeSid(
		&NtAuthority,
		2,
		SECURITY_BUILTIN_DOMAIN_RID,
		DOMAIN_ALIAS_RID_ADMINS,
		0, 0, 0, 0, 0, 0,
		&AdministratorsGroup))
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("start CheckTokenMembership");
		CheckTokenMembership(NULL, AdministratorsGroup, &bAdmin);

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("start FreeSid");
		FreeSid(AdministratorsGroup);
	}
#else
	if (geteuid() == 0) {
		bAdmin = TRUE;
	} else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("current process is not run as root privilege, euid:%u, uid:%d", geteuid(), getuid());
	}
#endif //RVC_OS_WIN
	return  bAdmin == TRUE;
}

const char *GetMachineType()
{
	auto env = sp_get_env();
	if (env == NULL)
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("sp_get_env return null");
		return NULL;
	}
	return env->cfg->root_ini->machine_type;
}



#ifdef RVC_OS_WIN

const char *GetCenterSettingNameBySite(const char *pszSite)
{
	///*TODO(80374374@3/23/2023): CenterSettings */
#if defined(_MSC_VER)
	return  "CenterSetting.ini";
#else
	if (pszSite == NULL || strlen(pszSite) == 0)
		return "CenterSetting.ini";

	if ((stricmp(pszSite, "CMB.LIB") == 0)
		|| (stricmp(pszSite, "CMB.SSB") == 0)) {
		return  "CenterSetting.LAN.ini";
	} else if ((stricmp(pszSite, "CMB.LSS") == 0)
		|| (stricmp(pszSite, "CMB.FLB") == 0)
		|| (stricmp(pszSite, "CMB.OSB") == 0)
		|| (stricmp(pszSite, "CMB.SMM") == 0)) {
		return   "CenterSetting.DMZ.ini";
	} else {
		return  "CenterSetting.DMZ.ini";
	}
#endif //_MSC_VER
}



#endif //RVC_OS_WIN

static bool SpTerminateProcess(HANDLE hProc, DWORD dwProcID)
{
	if (!TerminateProcess(hProc, -1))
	{
#ifdef RVC_OS_WIN
		char szCmd[256];
		int nRet = 0;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("terminate process %d fail: 0x%X, retry with taskkill", dwProcID, GetLastError());

		sprintf_s(szCmd, 256, "TASKKILL /PID %d /F", dwProcID);
		WinExec(szCmd, SW_HIDE);
		return nRet != -1;
#else
		return false;
#endif //RVC_OS_WIN

	}
	return true;
}

void DisplayUsage()
{
	char szHelp[4097] = { '\0' };
	sprintf_s(szHelp, 4096, "\n"
		"Usage spshell [--entity {EntityName}][--guardian][--test][--benchmark][--kill][--debug][--ipc <pipe|tcp>][--restart][--noroot]\n"
		"--entity {EntityName}  --启动特定的实体，选项后面输入实体名称\n"
		"--guardian                    --以后台进程的方式运行，暂未实现\n"
		"--test                            --以测试模式运行\n"
		"--debug                       --以调试模式运行，输出更为详细的日志\n"
		"--benchmark               --以压力测试的模式启动\n"
		"--kill                             --直接杀死终端相关进程，比如 spshell, sphost 等\n"
		"--shutdown                 --彻底退出终端相关进程，不单独使用\n"
		"--systemoff                 --执行系统关机指令，关机前会彻底退出应用，不单独使用\n"
		"--reboot                      --执行系统重启指令，重启关机前会彻底退出应用，不单独使用\n"
		"--ipc <pipe|tcp>          --指定实体间的通讯方式，使用管道或TCP，默认使用管道\n"
		"--noroot                      -- 允许以非管理员或Root权限方式启动\n"
		"--restart                       --重启当前应用\n"
		"--version                      --显示当前的版本\n"
#ifdef WITH_DEBUG
		"--telnet {listern port}   --激活远程调用功能\n"
#endif
	);

#ifdef WITH_QT
	QString str = QString::fromUtf8(szHelp);
	QMessageBox::information(NULL, "启动命令选项", str, QMessageBox::Ok);
#elif defined(RVC_OS_WIN)
	MessageBoxA(NULL, szHelp, "Spshell Usage Tip", MB_OK);
#else
	printf("%s\n", szHelp);
#endif
}

static CSimpleStringA GetTerminalVerFromShellConfig()
{
	char tmp[MAX_PATH];
	GetModuleFileNameA(NULL, tmp, MAX_PATH);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	strcat(tmp, SPLIT_SLASH_STR "cfg");
	strcat(tmp, SPLIT_SLASH_STR "shell.ini");
	char* value = inifile_read_str(tmp, "Main", "SoftwareVersion", "");
	if (value == NULL) return "";

	CSimpleStringA result(value);
	FREE(value);

	return result;
}


static void DestroyArgs(sp_cfg_start_args_t* args)
{
	if (args != NULL) {
		FREE(args->program);
        FREE(args->arguments);
	}
    FREE(args);
}

sp_cfg_start_args_t* DealWithArgs(int argc, char** argv)
{
	int allocedEntitiyLen = 0;
	sp_cfg_start_args_t* args = MALLOC_T(sp_cfg_start_args_t);
	TOOLKIT_ASSERT(args);
	memset(args, 0, sizeof(sp_cfg_start_args_t));
	args->program = args->arguments = NULL;
    if (argc > 0) {
        args->program = CALLOC_T(strlen(argv[0]) + 1, char);
        if (!args->program) { exit(-1); }
        memset(args->program, '\0', sizeof(char) * (strlen(argv[0]) + 1));
        strcpy(args->program, argv[0]);
        printf("program: %s\n", args->program);
        std::string params;
        for (int i = 1, k=0; i < argc; ++i) {
			if(strcmp(argv[i], "--restart") == 0 || strcmp(argv[i], "-R") == 0 || strcmp(argv[i], "-Rwait")/*QT*/ == 0 || strcmp(argv[i], "wait") == 0)
				continue;
            if (k != 0) params += " ";
            params += argv[i];
			k++;
        }
        if (!params.empty()) {
            args->arguments = CALLOC_T(params.length() + 1, char);
            if (!args->arguments) { exit(-1); }
            memset(args->arguments, '\0', sizeof(char) * (params.length()));
            strcpy(args->arguments, params.c_str());
        }
        printf("param: %s\n", args->arguments);
    }
	args->gui = 1;
	args->root = 1;
	static struct option spshell_options[] = {
		{"entity", required_argument, 0, 'E' },
		{"guardian", no_argument, 0, 'G'},
		{"test", no_argument, 0, 'T'},
		{"debug", no_argument, 0, 'D'},
		{"ipc", required_argument, 0, 'I'},
		{"shutdown", no_argument, 0, 'S'},
		{"kill", no_argument, 0, 'K'},
		{"benchmark", no_argument, 0, 'B'},
		{"gui", required_argument, 0, 'U'},
#ifdef WITH_DEBUG
		{"telnet", required_argument, 0, 'N' },
#endif
		{"help", no_argument, 0, 'H'},
		{"version", no_argument, 0, 'V'},
		{"noroot", no_argument, 0, 'O'},
		{"restart", optional_argument, 0, 'R'},
		{"systemoff", optional_argument, 0, 'Y'},
		{"reboot", optional_argument, 0, 'J'},
		{"env", required_argument, 0, 'A' },
		{0, 0, 0, 0}
	};

	int spshell_index = 0;
	int c;
	while ((c = getopt_long(argc, argv, "E:GTDI:SKBU:HVOR::Y::J::A:?", spshell_options, &spshell_index)) != EOF) {
		switch (c) {
		case 'E':
		{
			if (optarg != NULL) {
				const int len = strlen(optarg);
				if (args->start_entities == NULL || len + strlen(args->start_entities) + 2 /*;\0*/ >= allocedEntitiyLen) {
					if (args->start_entities == NULL) {
						TOOLKIT_ASSERT(allocedEntitiyLen == 0);
						allocedEntitiyLen = 128;
						args->start_entities = CALLOC_T(allocedEntitiyLen, char);
						if (NULL == args->start_entities) {
							DestroyArgs(args);
							exit(-1);
						}

					} else {
						TOOLKIT_ASSERT(allocedEntitiyLen != 0);
						const int newLen = allocedEntitiyLen + len + 32;
						char* newAlloc = CALLOC_T(newLen, char);
						if (NULL == newAlloc) {
							DestroyArgs(args);
							exit(-1);
						}
						memset(newAlloc, '\0', sizeof(char) * newLen);
						strcpy_s(newAlloc, newLen, args->start_entities);
						FREE(args->start_entities);
						args->start_entities = newAlloc;
						allocedEntitiyLen = newLen;
					}
				}
				strcat(args->start_entities, optarg);
				strcat(args->start_entities, ";");
			}
		}
		break;
		case 'G':
			args->guardian_mode = 1;
			break;
		case 'D':
			args->debug_mode = 1;
			break;
		case 'T':
			args->test_mode = (args->test_mode | 1);
			break;
		case 'B':
			args->test_mode = (args->test_mode | 2);
			break;
		case 'I':
			if (optarg) {
				if (strnicmp(optarg, "tcp", strlen("tcp")) == 0)
					args->ipc_type = 1;
			}
			break;
#ifdef WITH_DEBUG
		case 'N':
			if (optarg) {
				int nPort = 0;
				if (0 < sscanf(optarg, "%d", &nPort))
					args->telnet_port = nPort;
			}
			break;
#endif
		case 'K':
		{
			osutil_terminate_related_process(relate_processes_ex, array_size(relate_processes_ex));
			DestroyArgs(args);
			exit(0);
		}
		break;
		case 'U':
			if (optarg) {
				if (strnicmp(optarg, "ON", strlen("ON")) == 0)
					args->gui = 1;
				else if(strnicmp(optarg, "OFF", strlen("OFF")) == 0)
					args->gui = 0;
			}
		break;
        case 'A':
            if (optarg) {
                if (strnicmp(optarg, "ST", strlen("ST")) == 0)
					args->test_mode = (args->test_mode | 4);
                else if (strnicmp(optarg, "UAT", strlen("UAT")) == 0)
					args->test_mode = (args->test_mode | 8);
            }
            break;
		case 'V':
		{
			DestroyArgs(args);
			exit(0);
			break;
		}
		break;
		case 'O':
			args->root = 0;
			break;
		case 'R':
			g_restartMode = RESTART_MODE_NORMAL;
            if (optarg && strcmp(optarg, "wait") == 0) {
				g_restartMode = RESTART_MODE_PRE;
            }
			break;
        case 'S':
            g_restartMode = RESTART_MODE_SHUTDOWN;
            break;
        case 'Y':
            g_restartMode = RESTART_MODE_POWEROFF;
            if (optarg && strnicmp(optarg, "now", strlen("now")) == 0) {
				g_immediately = true;
            }
            break;
        case 'J':
            g_restartMode = RESTART_MODE_REBOOT;
            if (optarg && strnicmp(optarg, "now", strlen("now")) == 0) {
                g_immediately = true;
            }
            break;
		case 'H':
		case '?':
		default:
			DisplayUsage();
			DestroyArgs(args);
			exit(0);
			break;
		}
	}

	if (optind < argc) {
		while (optind < argc) {
			//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("\t%s", argv[optind++]);
		}
	}

	if (args && args->start_entities != 0) {
		args->start_entities[strlen(args->start_entities) - 1] = '\0';
	}

	return args;
}

static void QtPostEvent(void* user_data)
{
#ifdef WITH_QT
	QApplication* app = (QApplication*)user_data;
	app->processEvents();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("test: QEventLoop::ExcludeUserInputEvents");
#endif
}

void normal_signal_handle(int num)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("receive signal %d", num);
	signal(num, SIG_DFL);
	raise(num);
}

static bool NeedToRestartFramework()
{
	//Shutdown 表明退掉框架不重启
	return !((g_restartMode == RESTART_MODE_SHUTDOWN
			  || g_restartMode == RESTART_MODE_POWEROFF
			 || g_restartMode == RESTART_MODE_REBOOT));
}

#if defined(_MSC_VER)
///*TODO(80374374@3/23/2023): osutil_detect_unique_app 替代 */
static bool DetectDuplicateInstance(char** pNames, int nNum)
{
	DWORD dwCurProcID = GetCurrentProcessId();

	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

	std::shared_ptr<void> delHandleFun((void*)0, [&](void*) {
		if (NULL != hSnapshot)
			CloseHandle(hSnapshot);
		});

	if (hSnapshot) {
		PROCESSENTRY32 pe = {};
		pe.dwSize = sizeof(pe);
		if (Process32First(hSnapshot, &pe)) {
			do {
				for (int i = 0; i < nNum; i++) {
					if (stricmp(&pe.szExeFile[0], pNames[i]) == 0 && pe.th32ProcessID != dwCurProcID) {
						HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
						if (hProc == NULL) {
							DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("find duplicated process: %s, id: %d", pNames[i], pe.th32ProcessID);
							return false;
						}

						if (!SpTerminateProcess(hProc, pe.th32ProcessID)) {
							DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("terminate duplicated process %s fail, id: %d,  error: %d",
								pNames[i], pe.th32ProcessID, GetLastError());
							return false;
						}

						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("terminate duplicated process: %s, id: %d", pNames[i], pe.th32ProcessID);
					}
				}
			} while (Process32Next(hSnapshot, &pe));
		}

	} else
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("DetectDuplicateInstance can not enter Process32First!");

	return true;
}

#endif //_MSC_VER

void SPBASE_API __stdcall setCurEntityIdx(int idx);

std::string generateCenterSettingPath()
{
    char pathbuf[1024] = "";
    int  pathlen = ::GetModuleFileNameA(NULL, pathbuf, 1024);//获得GuiConsole路径
    // 替换掉单杠
    int times = 0;
    while (pathlen > 0) {
        if (pathbuf[pathlen--] == SPLIT_SLASH)
            times++;
        if (2 == times)
            break;
    }
    pathbuf[++pathlen] = '\0';
    std::string dstPath = pathbuf;
#if defined(_MSC_VER)
    dstPath.append(SPLIT_SLASH_STR  "cfg" SPLIT_SLASH_STR "CenterSetting.ini");
#else
    dstPath.append(SPLIT_SLASH_STR  "cfg" SPLIT_SLASH_STR "CenterSetting.LAN.ini");
#endif //_MSC_VER
    return dstPath;
}

int main(int argc, char** argv)
{
#ifdef WITH_QT
    Center app(argc, argv);
#endif
	sp_cfg_start_args_t* args = DealWithArgs(argc, argv);
#ifdef WITH_QT
    app.Init();
    const Qt::Alignment bottomLeft = Qt::AlignBottom | Qt::AlignLeft;
	sp_trace_init();
#endif

#if defined(RVC_OS_LINUX)
	if (args->debug_mode) {
		SP::Perf::LeakDetector leakInstance;
		WLog_initRVC("SpShell");
	}
#else
	//WLog_initRVC("SpShell");
    _CrtSetDebugFillThreshold(0);
#endif //RVC_OS_LINUX

#ifdef RVC_SAVEFILE
	bool saveFile = true;
#else
	char tmp[MAX_LEN] = "";
	bool saveFile = false;
	if (Error_Succeed == sp_tryReadFromCenterSetting("Common", "SaveFile", tmp, MAX_LEN) && 0 == CSimpleStringA(tmp).Compare("1"))
		saveFile = true;
#endif // RVC_SAVEFILE
	if (saveFile)
		sp_dbg_init("SpShell", 1);
	else
		sp_dbg_init("SpShell", 0);
	EntityResource::setSaveFile(saveFile);
#if defined(RVC_OS_LINUX)
    sp_dbg_set_level(XLOG_LEVEL_DEBUG);
#endif //RVC_OS_LINUX
    if (argc > 1) {
        std::string args_str;
        char cmdline[1024] = { '\0' };
        for (int i = 0; i < argc; ++i) {
            sprintf_s(cmdline, 1024, "%s", argv[i]);
            if (i != 0) args_str += " ";
            args_str += cmdline;
        }
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("prefix: %s", args_str.c_str());
    }


#if defined(_MSC_VER)
	auto centersettingPath = generateCenterSettingPath();
	load_debugLevelInCentersetting(centersettingPath.c_str());
	load_specialRunInfoInCentersetting(centersettingPath.c_str());

	auto setAffinity = [](long ulCpuMask) {
		HANDLE hCurrentProc;
		DWORD_PTR dwpProcAffinityMask = ulCpuMask; 
		// Obtain a usable handle of the current process
		hCurrentProc = GetCurrentProcess();
		// Get the old affinity mask
		SetProcessAffinityMask(hCurrentProc, dwpProcAffinityMask);
		SetProcessAffinityUpdateMode(hCurrentProc, PROCESS_AFFINITY_ENABLE_AUTO_UPDATE);
		CloseHandle(hCurrentProc);
	};
	setAffinity(1);
	char* arrProcName[] = { "SpShell.exe", "SpHost.exe", "SpHost_re.exe" };
	//实际可以加快这个过程，如果进程过多会比较慢
	//后续可考虑用mutex进行控制
	if (!DetectDuplicateInstance(&arrProcName[0], sizeof(arrProcName) / sizeof(arrProcName[0]))) {
		DbgWithLink(LOG_LEVEL_FATAL, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setResultMsg(RTAERR_SPSHELL_REPEATPROCESS)("检测到重复spshell/sphost进程，系统启动失败!!!");
		Sleep(10000);
		return -200;
	}
#else
	if (!!g_restartMode) {
		const int maxTimes = 10;
		const int maxPreTimies = 60;
		const DWORD eachPreTimeout = 1000;
		const DWORD eachTimeout = 1000;
		const DWORD skipInterval = 5;
		int currTimes = 0, preTimes = 0;
		bool needWait = (g_restartMode > RESTART_MODE_NORMAL && !g_immediately); //Rwait 框架触发的重启
		const bool needlessRestart = !NeedToRestartFramework();
		int aliveCount = 0, lastAliveCount(1000);
		char** relates = relate_processes;
		int reletes_cnt = relate_processes_count;
		if (needWait) {
#ifdef WITH_QT
			app.GetSplash()->showMessage(QString("等待应用进程退出..."), bottomLeft, Qt::black);
#endif
		}
		if (needlessRestart) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to shutdown guardian...");
			char* tmp_processes[] = { guardian_execute_name };
			osutil_terminate_related_process(tmp_processes, array_size(tmp_processes));
			relates = relate_processes_ex;
			reletes_cnt = relate_processes_ex_count;
		}
		bool switch_flag = false;
		while (switch_flag || !osutil_detect_unique_app(relates, reletes_cnt, &aliveCount, NULL)) {
			if (!needWait && ++currTimes >= maxTimes) {
				DbgWithLink(LOG_LEVEL_FATAL, LOG_TYPE_SYSTEM)("detect ex-spshell or sphost process, abort cur boot !!!");
#ifdef WITH_QT
				app.GetSplash()->finish(nullptr);
				QMessageBox::critical(NULL, "错误", "等待应用进程退出超时，请尝试重启机器！", QMessageBox::Yes);
#endif
				sp_dbg_term();
				DestroyArgs(args);
				return -200;
		} else {
				if (needWait) {
					Sleep(eachPreTimeout);
					if (++preTimes >= maxPreTimies && (aliveCount >= lastAliveCount)) {
						needWait = false;
					}
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("wait... last active process count:%d, curr process count: %d, ppid: %d", lastAliveCount, aliveCount, GetParentProcessID());
					lastAliveCount = aliveCount;
				} else {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("detect ex-spshell or sphost process %d, %d !!!", preTimes, currTimes);
					osutil_terminate_related_process(relates, reletes_cnt);
					Sleep(eachTimeout);
				}
#ifdef WITH_QT
				const DWORD consumedTime = (currTimes * eachTimeout) / 1000 + (eachPreTimeout * preTimes) / 1000;
				if (consumedTime > 0) {
					app.GetSplash()->showMessage(QString("等待应用进程退出，已等待 %1 秒...").arg(consumedTime), bottomLeft, Qt::black);
				}
#endif
			}
			//aliveCount = 0; //important!!!
			switch_flag = (((preTimes + currTimes) % skipInterval) != 0);
			if (!switch_flag) {
				aliveCount = 0;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("will enter osutil_detect_unique_app");
			}
}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("finish detecting unique app.");

		if (needlessRestart) {
			const DWORD sleepMillsecs = 2000;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("restart mode: %d", g_restartMode);
#ifdef WITH_QT
			if (g_restartMode == RESTART_MODE_SHUTDOWN) {
				app.GetSplash()->showMessage(QString("应用进程已完全清理，退出当前窗口..."), bottomLeft, Qt::black);
			} else if (g_restartMode == RESTART_MODE_POWEROFF) {
				app.GetSplash()->showMessage(QString("应用进程已完全清理，准备关机..."), bottomLeft, Qt::black);
				osutil_shutdown_system();
				app.GetSplash()->showMessage(QString("应用进程已完全清理，正在关机..."), bottomLeft, Qt::black);
			} else if (g_restartMode == RESTART_MODE_REBOOT) {
				app.GetSplash()->showMessage(QString("应用进程已完全清理，准备关机重启..."), bottomLeft, Qt::black);
				osutil_restart_system();
				app.GetSplash()->showMessage(QString("应用进程已完全清理，正在关机并重启..."), bottomLeft, Qt::black);
		}
#endif
			Sleep(sleepMillsecs);
			sp_dbg_term();
			DestroyArgs(args);
			return 0;
		}
	} else if (!osutil_detect_unique_app(relate_processes, array_size(relate_processes), NULL, NULL)) {
		do {
#ifdef WITH_QT
			//QMessageBox::critical(NULL, "错误", "检测到有相关进程正在运行！", QMessageBox::Yes);
			const QMessageBox::StandardButton rb = QMessageBox::question(NULL, "警告", "检测到已有相关进程在运行！是否要强制启动？",
				QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
			if (rb == QMessageBox::Yes) {
				osutil_terminate_related_process(relate_processes, array_size(relate_processes));
				Sleep(1000);
				int count = MAX_ALIVE_PROCESS_COUNT;
				alive_process_info processes[MAX_ALIVE_PROCESS_COUNT];
				memset(processes, 0, sizeof(processes));
				if (osutil_detect_unique_app(relate_processes, array_size(relate_processes), &count, processes)) {
					break;
				}
				TOOLKIT_ASSERT(count > 0);
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("clear ex-spshell/sphost process failed!");
				QString str = QString("强制重启失败：无法完全清理已有进程！(%1)").arg(count);
				for (int i = 0; i < count; ++i) {
					str += "\n";
					QString tmp = QString("%1(%2) - %3").arg(processes[i].name).arg(processes[i].pid).arg(processes[i].path);
					str += tmp;
				}
				QMessageBox::critical(NULL, "错误", str, QMessageBox::Yes);
			}
			DbgWithLink(LOG_LEVEL_FATAL, LOG_TYPE_SYSTEM)("detect duplicate spshell/sphost process, abort cur boot !!!");
			app.GetSplash()->finish(nullptr);
#endif //WITH_QT

			//osutil_terminate_related_process(relate_processes, array_size(relate_processes));
		   // Sleep(3000);
			sp_dbg_term();
			DestroyArgs(args);
			return -200;
	} while (false);
	}
#endif //_MSC_VER
	sp_runtask_loadLogLevel();
    create_log_producer_default("SpShell", 0);
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("===================SpShell start=====================");
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("process id: %d, saveFile:%d", GetCurrentProcessId(), saveFile);
    if (argc > 1) {
        std::string args_str;
        char cmdline[1024] = { '\0' };
        for (int i = 0; i < argc; ++i) {
            sprintf_s(cmdline, 1024, "%s", argv[i]);
            if (i != 0) args_str += " ";
            args_str += cmdline;
        }
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)(args_str.c_str());
        SP_TRACE(args_str.c_str());
    }

    if (!IsProcessRunAsAdmin()) {
        if (args->root) {
            DbgWithLink(LOG_LEVEL_FATAL, LOG_TYPE_SYSTEM)("current process need run with administrator or root privilege !!!");
#ifdef WITH_QT
            QMessageBox::warning(NULL, "警告", "需要以管理员或ROOT用户权限启动！", QMessageBox::Yes);
#else
            DbgWithLink(LOG_LEVEL_FATAL, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setResultMsg(RTAERR_SPSHELL_NOPRIVILEGE)("需要以管理员权限运行!!!");
            Sleep(10000);
#endif
            sp_dbg_term();
			DestroyArgs(args);
            return -201;
        } else {
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("current process requires normal privilege.");
        }
    } else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("current process has been run with administrator or root privilege.");
		args->root = (char)1;
#if defined(_MSC_VER)
		SYSTEM_INFO SystemInfo;
		GetSystemInfo(&SystemInfo);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("当前以管理员权限运行, curProcessId:%d, curVersion:%s ,dwNumberOfProcessors=%u, dwActiveProcessorMask=%u, wProcessorLevel=%u, wProcessorArchitecture=%u, dwPageSize=%u",
			GetCurrentProcessId(), STRFILEVER, SystemInfo.dwNumberOfProcessors, SystemInfo.dwActiveProcessorMask, SystemInfo.wProcessorLevel,
			SystemInfo.wProcessorArchitecture, SystemInfo.dwPageSize);
#endif //_MSC_VER
	}

#ifdef RVC_OS_WIN
#ifdef WITH_QT
	app.GetSplash()->showMessage(QObject::tr("Config firewall policies......"), bottomLeft, Qt::black);
#endif
	// 设置防火墙注册表配置
	AddFirewallRulesEx();
#endif //RVC_OS_WIN
	
#ifdef RVC_OS_WIN
	setlocale(LC_ALL, "chs");
#else
	if (NULL == setlocale(LC_ALL, "zh_CN.UTF-8")) {
		//zh_CN.UTF-8    zh_CN.GBK
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("setlocale failed: %s", strerror(errno));
	}
#endif //RVC_OS_WIN

	SetEnvPath();

#ifdef RVC_OS_WIN

#ifdef WITH_QT
	app.GetSplash()->showMessage(QObject::tr("Config working set......"), bottomLeft, Qt::black);
#endif

	SetWorkingSet();//获取设置内存使用率，4G

#ifdef WITH_QT
	app.GetSplash()->showMessage(QObject::tr("Setup exception filter......"), bottomLeft, Qt::black);
#endif

#endif //RVC_OS_WIN

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("basic config success");

#ifdef RVC_OS_WIN

	// 检测是否Win8及64位
	OSVERSIONINFO ver = {};
	ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&ver);
	bool bWin8 = (ver.dwMajorVersion >= 7 || (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 2));	//version over 7 or over 6.2
	SYSTEM_INFO sysInfo = {};
	GetNativeSystemInfo(&sysInfo);
	bool bX64 = (sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64);

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("OS version: %s %d.%d.%d , SetErrorMode %s",	bX64 ? "windows 64" : "windows 32",	ver.dwMajorVersion, ver.dwMinorVersion, ver.dwBuildNumber,
		0 == SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX) ? "success" : "failed");

	SetUnhandledExceptionFilter(&SuppressError);
#endif //RVC_OS_WIN

	auto msg_lamda_func = [&](const char* msg, bool ctritial)->void {
#ifdef WITH_QT
		app.GetSplash()->showMessage(QObject::tr(msg), bottomLeft, ctritial ? Qt::red : Qt::black);
#endif
	};
#ifdef WITH_QT
	app.GetSplash()->showMessage(QObject::tr("应用初始化中..."), bottomLeft, Qt::black);
#endif

	//////////////////////////////////////////////////////////////////////////
#if defined(_MSC_VER)
	auto rc = app_init(args);
	int result = rc.first;
#else
	int result = app_init(args, msg_lamda_func);
#endif //_MSC_VER
	//////////////////////////////////////////////////////////////////////////
	if (result == 0)
	{
#ifdef WITH_QT
		app.GetSplash()->showMessage(QObject::tr("应用初始化完成"), bottomLeft, Qt::black);
		sp_trace_term();
#endif

#if NO_GUI_WITH_WTL
		if(args->gui) {
			app.Run();
		} else 
#endif
		{
#ifdef WITH_QT
			app.processEvents();
			app.GetSplash()->finish(app.mWidget);
#endif
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("run circle loop in main thread!!");
			result = app_run();
			app_term();
		}
	}	
	else
	{
		uint32_t waitIntervals = 10000;
#ifdef WITH_QT
        app.GetSplash()->finish(nullptr);
        if (sp_trace_exist()) {
            char* last_err = NULL;
            sp_trace_retrieve(&last_err, NULL);
            if (last_err) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to show last error dialog...");
				QString str = QString("%1").arg(last_err);
				QMessageBox::critical(NULL, "应用启动失败", str, QMessageBox::Yes);
				waitIntervals = 1;
				FREE(last_err);
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to show last error dialog done!");
            }
			sp_trace_term();
        }
#endif

#if defined(_MSC_VER)
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("======================================================");
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setResultMsg(RTAERR_SPSHELL_APPINITERR)(rc.second.GetData());
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("!!!!!! 启动失败，请检查dbg\\spshell日志排除故障 !!!!!!");
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("======================================================");
#else
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("======================================================");
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setResultMsg(RTAERR_SPSHELL_APPINITERR)("!!!!!! Startup failed, get more detail information from dbg/spshell !!!!!!");
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("======================================================");
#endif //_MSC_VER
		app_upload_last_log();
		Sleep(waitIntervals);
	}

#ifdef RVC_OS_WIN
	if (bWin8 && !bX64) {
		EnableCharmbar();
	}
#endif //RVC_OS_WIN

	sp_dbg_term();
	DestroyArgs(args);
	return result;
}

#ifdef RVC_OS_WIN

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	return main(__argc, __argv); 
}

#endif //RVC_OS_WIN