myvtm/Module/mod_BranchDevice/BranchDeviceFSM.cpp

#include "stdafx.h"
#include "GetDevInfoHelper.h"
#include "BranchDeviceFSM.h"
#include <assert.h>

//#define BRANCHDEBUG

//#define SetLowPriority
#define RestrictedTokens
//#define CreateProcessWithLogon
//#define DROP_MY_RIGHT
#ifdef DROP_MY_RIGHT
#include <WinSafer.h>
#include <aclapi.h>
#endif



#define ISSUCCEEDED(hr) ((hr) == Error_Succeed)
#define FAILURED(hr) (!(ISSUCCEEDED(hr)))

const int SMALL_RETVALUE_LEN = 128;
const int DEFAULT_RETVALUE_LEN = 512;
const int DEFAULT_TIMEOUT_MILLSEC = 15 * 1000;
const int MAX_FAILEDCOUNT = 5;

BOOLEAN SetPrivilege(HANDLE hToken, // access token handle
	LPCTSTR lpszPrivilege, // name of privilege to enable/disable
	BOOL bEnablePrivilege // to enable or disable privilege
	)
{
	TOKEN_PRIVILEGES tp;
	LUID luid;

	if(hToken == INVALID_HANDLE_VALUE)
	{
		if (!OpenProcessToken(GetCurrentProcess(), 
			TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
		{
			LOG_TRACE("OpenProcessToken error: %u", GetLastError());
			return FALSE;
		}
	}


	if ( !LookupPrivilegeValue( 
		NULL,            // lookup privilege on local system
		lpszPrivilege,   // privilege to lookup 
		&luid ) )        // receives LUID of privilege
	{
		LOG_TRACE("LookupPrivilegeValue error: %u", GetLastError()); 
		return FALSE; 
	}

	tp.PrivilegeCount = 1;
	tp.Privileges[0].Luid = luid;
	if (bEnablePrivilege)
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
	else
		tp.Privileges[0].Attributes = 0;

	// Enable the privilege or disable all privileges.

	if ( !AdjustTokenPrivileges(
		hToken, 
		FALSE, 
		&tp, 
		sizeof(TOKEN_PRIVILEGES), 
		(PTOKEN_PRIVILEGES) NULL, 
		(PDWORD) NULL) )
	{ 
		LOG_TRACE("AdjustTokenPrivileges error: %u.", GetLastError()); 
		return FALSE; 
	} 

	if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)
	{
		LOG_TRACE("The token does not have the specified privilege.");
		return FALSE;
	} 

	return TRUE;
}

///目录是否存在的检查：
bool CheckFolderExist(LPCTSTR lpszDirName)
{
	WIN32_FIND_DATA  wfd;
	bool rValue = false;
	HANDLE hFind = FindFirstFile(lpszDirName, &wfd);
	if ((hFind != INVALID_HANDLE_VALUE) 
		&& (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
	{
		rValue = true;
	}
	FindClose(hFind);
	return rValue;
}

#define MAX_PRINTF_MSG_LEN 512

//outCovertParam must be MAX_PRINTF_MSG_LEN len.
void CovertCmdParam(LPTSTR outCovertParam, LPCTSTR lpszParam)
{
	char szSecurParam[20] = {0};
	memset(outCovertParam, 0, sizeof(char)*MAX_PRINTF_MSG_LEN);
	memset(szSecurParam, 0, sizeof(szSecurParam));
	int len = strlen(lpszParam);
	bool bCoverted = false;
	if(len > 0)
	{
		if(len > 6)
		{
			szSecurParam[0] = lpszParam[0];
			szSecurParam[1] = lpszParam[1];
			szSecurParam[2] = lpszParam[2];
			strcat_s(szSecurParam, "***");
			szSecurParam[6] = lpszParam[len-3];
			szSecurParam[7] = lpszParam[len-2];
			szSecurParam[8] = lpszParam[len-1];
			szSecurParam[9] = '\0';
			bCoverted = true;
		}
		else if(len > 2)
		{
			szSecurParam[0] = lpszParam[0];
			szSecurParam[1] = '*';
			szSecurParam[2] = lpszParam[len-1];
			szSecurParam[3] = '\0';
			bCoverted = true;
		}
	}
	if(!bCoverted)
	{
		sprintf_s(outCovertParam, MAX_PRINTF_MSG_LEN, "(%s)", lpszParam);
	}
	else
	{
		sprintf_s(outCovertParam, MAX_PRINTF_MSG_LEN, "(%s)(len#%d)", szSecurParam, len);
	}
	return;
}


CRITICAL_SECTION CBranchDeviceFSM::s_cs;

ErrorCodeEnum CBranchDeviceFSM::OnInit()
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Succeed;
	Dbg("Josephus update in 2017-3-18");
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spRootConfig;
	erroCode = spEntityFunction->OpenConfig(Config_Root, spRootConfig);
	if(FAILURED(erroCode))
	{
		Dbg("Open Root.ini failed with 0x%08x", erroCode);
		return erroCode;
	}

	int nDevNum = 0;
	erroCode = spRootConfig->ReadConfigValueInt("Device.BranchDevice", "DevNum", nDevNum);
	if(FAILURED(erroCode)/* || nDevNum <= 0*/)
	{
		Dbg("unsuccessfully option: nDevNum(%d) ErrorCode(0x%08x) then return", nDevNum, erroCode);
		return Error_Param;
	}

	DWORD dwSpbranchPID = 0;
	int nFailCount = 0;
	while(m_pProcHelper->GetPIDByName("spbranch.exe", dwSpbranchPID))
	{
		Dbg("find previous survive spbranch.exe(%u) and try to kill it !", dwSpbranchPID);
		if(m_pProcHelper->DestoryProcess(dwSpbranchPID))
		{
			LogWarn(Severity_Middle, Error_Unexpect, 0, 
				"find previous survive spbranch.exe and try to kill it succ !");
		}
		else
		{
			 LogError(Severity_Middle, Error_Unexpect, 0, 
				"find previous survive spbranch.exe and kill it failed !");
			 if( ++nFailCount > MAX_FAILEDCOUNT)
			 {
				 Dbg("unsuccessful operations ecceeds %d times.", MAX_FAILEDCOUNT);
				 return Error_Unexpect;
			 }
		}
		Sleep(200);
	}

	Dbg("BranchDevice Count: %d", nDevNum);

	if(nDevNum <= 0)
	{
		Dbg("Cannot found any BranchDevice information, regard it as normal.");
		return Error_Succeed;
	}

	// --Josephus at 18:47:24 2017120
	//BOOL bPrivilege = CTWProcHelper::SetImpersonatePriv();
	//Dbg("SetImpersonatePriv returned %d.", bPrivilege);
	//if(FALSE /*Test exclude in job*/)
	if(m_pProcHelper != NULL && m_pProcHelper->Create(NULL, "SPRvc_BranceDeviceJob"))
	{
		m_bNeedJob = TRUE;
	}
	else
	{
		LogWarn(Severity_Middle, Error_Unexpect, 0, "Branch device Sandbox run failed !!!");
		return Error_Unexpect;
	}
	BOOL bRes = FALSE;
	if(m_bNeedJob)
	{
		m_hNotifyFinishedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		if(m_hNotifyFinishedEvent == NULL || m_hNotifyFinishedEvent == INVALID_HANDLE_VALUE)
		{
			Dbg("Create event failed, GLE: %d.", GetLastError());
			UINT uExitCode = 0;
			m_pProcHelper->Terminate(uExitCode);
			LogWarn(Severity_Middle, Error_Unexpect, 0, "Branch device Sandbox run failed !!!");
			m_bNeedJob = FALSE;
			return Error_Unexpect;
		}
		else
		{
			m_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
			JobNotifyTask* task = new JobNotifyTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);

			//LogWarn(Severity_Middle, Error_Unexpect, 0, "Branch device Sandbox not initialize !!!");
			bRes = JobInitialize();
		}
	}

	CSimpleStringA strDbgPath;
	spEntityFunction->GetPath("Dbg", strDbgPath);
	strDbgPath += "\\SpBranch";
	if(!CheckFolderExist(strDbgPath))
	{
		if (!CreateDirectory(strDbgPath, NULL)) 
		{ 
			Dbg("CreateDirectory(%s) failed (%d)", (LPCTSTR)strDbgPath, GetLastError()); 
		}
		else
		{
			Dbg("SetLowLabelToFile {%s}", (LPCTSTR)strDbgPath);
			CTWProcHelper::SetLowLabelToFile((LPCTSTR)strDbgPath);
		}
	}
	m_strSpBranchPath = strDbgPath;

#ifdef BRANCHDEBUG
	CSimpleStringA strBinPath;
	spEntityFunction->GetPath("bin", strDebugPath);
	strBinPath += "\\LogFiles";
	CTWProcHelper::SetLowLabelToFile(strBinPath);
#endif

	//CTWProcHelper::SearchTokenGroupsForSID();
	//if(CTWProcHelper::AddUserAccount())
	//{
	//	Dbg("Add accout suc.");
	//	CTWProcHelper::AddMemberToGroup();
	//}

	CAutoArray<CSimpleStringA> brDevNames;
	brDevNames.Init(nDevNum);
	CAutoArray<CSimpleStringA> brDevDllPaths;
	brDevDllPaths.Init(nDevNum);

	m_pDevHandles = (BranchDevHandle*)malloc(sizeof(BranchDevHandle) * nDevNum);
	if(m_pDevHandles == NULL)
	{
		Dbg("malloc memory for devHandls failed %d", GetLastError());
		return Error_Resource;
	}
	Dbg("after malloc DevHandles memory suc.");
	m_nDevNum = nDevNum;
	memset(m_pDevHandles, 0, sizeof(BranchDevHandle) * nDevNum);

	for(int idx=0; idx<nDevNum; ++idx)
	{
		m_pDevHandles[idx].nReserved = 0;
		CSimpleStringA csIndex = CSimpleStringA::Format("%d", idx+1);
		erroCode = spRootConfig->ReadConfigValue("Device.BranchDevice", (LPCTSTR)csIndex, brDevNames[idx]);
		if(ISSUCCEEDED(erroCode))
		{
			if(brDevNames[idx].GetLength() <= 0)
			{
				erroCode = Error_Unexpect;
				Dbg("Get value of key(%d) failed under BranchDevice in root.ini", idx);
			}
			else
			{
				erroCode = SpGetBrDevAdaptorPath(m_pEntity, brDevNames[idx], brDevDllPaths[idx]);
				if(ISSUCCEEDED(erroCode))
				{
					if(brDevDllPaths[idx].GetLength() <= 0)
					{
						erroCode = Error_Unexpect;
						Dbg("[%s] The Adapter dll path is invalide.");
					}
					else
					{
						Dbg("SN#%d...%s %s", idx+1, (LPCTSTR)brDevNames[idx], (LPCTSTR)brDevDllPaths[idx]);
					}
				}
				else
				{
					Dbg("SpGetBrDevAdaptorPath with param(%s) failed returned 0x%08x", 
						(LPCTSTR)brDevNames[idx], erroCode);
				}
			}
		}
		if(FAILURED(erroCode))
		{
			m_pDevHandles[idx].nStatus = -1;
			sprintf_s(m_pDevHandles[idx].szInfo, "DevName or DllFilePath is invalide.");
			continue;
		}

		m_pDevHandles[idx].nStatus = 0;
		strcpy_s(m_pDevHandles[idx].szDevName, (LPCTSTR)brDevNames[idx]);
		strcpy_s(m_pDevHandles[idx].szDevDllPath, (LPCTSTR)brDevDllPaths[idx]);
	}

	m_pRWStr = (PRWStruct*)malloc(sizeof(PRWStruct)* nDevNum);
	if(m_pRWStr == NULL)
	{
		Dbg("malloc memory for RWStruct failed %d", GetLastError());
		free(m_pDevHandles);
		m_pDevHandles = NULL;
		return Error_Resource;
	}

	Dbg("after malloc RWStruct memory suc.");
	ZeroMemory(m_pRWStr, sizeof(PRWStruct) * nDevNum);
	for(int idx=0; idx<nDevNum; ++idx)
	{
		m_pRWStr[idx] = new RWStruct();
		if(m_pRWStr[idx] == NULL)
		{
			for(int innerIdx = 0; innerIdx < idx; innerIdx++)
				delete m_pRWStr[innerIdx];
			free(m_pDevHandles);
			m_pDevHandles = NULL;
			free(m_pRWStr);
			m_pRWStr = NULL;
			Dbg("New RWStruct point failed fatally !!");
			return Error_Resource;
		}
	}

	return Error_Succeed;
}

ErrorCodeEnum CBranchDeviceFSM::OnExit()
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Succeed;
	Cleanup();
	return erroCode;
}

void CBranchDeviceFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	pTransactionContext->SendAnswer(Error_Succeed);
	BOOL bNeedNotify = TRUE;
	if(m_bNeedJob && m_eCurState != Error_NotInit)
	{
		for(int idx=0; idx<m_nDevNum; idx++)
		{
			if(m_pDevHandles[idx].nStatus != 0)
			{
				TCHAR szInfor[MAX_MSG_SIZE] = {0};
				sprintf_s(szInfor, "%s's invalid: %s(%d)",
					m_pDevHandles[idx].szDevName, m_pDevHandles[idx].szInfo, m_pDevHandles[idx].nStatus);
				LogWarn(Severity_Middle, Error_DevNotAvailable, 0, szInfor);
				if(m_pDevHandles[idx].nStatus == -2 || m_pDevHandles[idx].nStatus == -5/*necessary??*/)
				{
					if(RestartChildProcess(idx))
					{
						Sleep(1000);
						OpenSpecifiedDev(idx);
					}
				}
				else if(m_pDevHandles[idx].nStatus == -6 || m_pDevHandles[idx].nStatus == -4/*hardly*/)
				{
					OpenSpecifiedDev(idx);
				}
				else if(m_pDevHandles[idx].nStatus == -7)
				{
					if(RestartChildProcess(idx))
					{
						Sleep(1000);
						OpenSpecifiedDev(idx);
						bNeedNotify = FALSE;
					}
				}
			}
			if(m_pRWStr[idx] != NULL && m_pDevHandles[idx].nReserved == 1)
			{
				TCHAR szInfor[MAX_MSG_SIZE] = {0};
				sprintf_s(szInfor, "%s's process (PID = %u) is not in the Job !", 
					m_pDevHandles[idx].szDevName, m_pRWStr[idx]->dwProcessID);
				LogWarn(Severity_Middle, Error_Unexpect, 0, szInfor);
			}
		}
		if(bNeedNotify)
		{
			PostQueuedCompletionStatus(m_hIOCP, 0, COMPKEY_STATUS, NULL);
		}
	}
}

void CBranchDeviceFSM::s0_on_entry()
{
	LOG_FUNCTION();
	if(!m_bNeedJob)
	{
		PostEventFIFO(new FSMEvent(USER_EVT_CREATEPROCESS));
	}
}

void CBranchDeviceFSM::s0_on_exit()
{

}

unsigned int CBranchDeviceFSM::s0_on_event(FSMEvent* e)
{
	int nRet = 0;
	Dbg("s0_on_event: evtType(%d)", e->iEvt);
	if(e->iEvt == USER_EVT_JOBNOTIFYSTART || e->iEvt == USER_EVT_CREATEPROCESS)
	{
		e->SetHandled();
		CreateProcessTask* task = new CreateProcessTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	else if(e->iEvt == USER_EVT_CREATEPROCESSFINISHED)
	{
		e->SetHandled();
	}
	return nRet;
}

void CBranchDeviceFSM::s1_on_entry()
{
	LOG_FUNCTION();
	OpenDeviceTask* task = new OpenDeviceTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
}

void CBranchDeviceFSM::s1_on_exit()
{
	m_eCurState = Error_Succeed;
}

unsigned int CBranchDeviceFSM::s1_on_event(FSMEvent* e)
{
	int nRet = 0;
	if(e->iEvt == USER_EVT_OPENFINISHED)
	{
		e->SetHandled();
	}
	return nRet;
}

void CBranchDeviceFSM::s2_on_entry()
{
	LOG_FUNCTION();
}

void CBranchDeviceFSM::s2_on_exit()
{

}

unsigned int CBranchDeviceFSM::s2_on_event(FSMEvent* e)
{
	Dbg("s2_on_event: evtType(%d)", e->iEvt);
	int nRet = 0;
	if(e->iEvt == USER_EVT_CMD)
	{
		OperateCMDTask* task = new OperateCMDTask(this);
		OperateCMDEvent* evt = dynamic_cast<OperateCMDEvent*>(e);
		task->SetContext(evt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		e->SetHandled();
	}
	else if(e->iEvt == USER_EVT_GETINFO)
	{
		GetInfoTask* task = new GetInfoTask(this);
		GetInfoEvent* evt = dynamic_cast<GetInfoEvent*>(e);
		task->SetContext(evt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		e->SetHandled();
	}
	return nRet;
}

void CBranchDeviceFSM::s3_on_entry()
{
	LOG_FUNCTION();
}

void CBranchDeviceFSM::s3_on_exit()
{

}

unsigned int CBranchDeviceFSM::s3_on_event(FSMEvent* e)
{
	int nRet = 0;
	return nRet;
}

ErrorCodeEnum CBranchDeviceFSM::OpenSpecifiedDev(int devSN)
{
	ErrorCodeEnum erroCode = Error_Succeed;
	if(devSN < 0 || devSN >= m_nDevNum)
	{
		return Error_Param;
	}

	if(m_pDevHandles[devSN].nStatus == -1 || m_pDevHandles[devSN].nStatus == -2)
	{
		LOG_TRACE("[%s]DevOpen failed [devSN#%d][nStatus#%d][szInfo#%s]", 
			m_pDevHandles[devSN].szDevName,
			devSN, m_pDevHandles[devSN].nStatus,
			m_pDevHandles[devSN].szInfo);
		return Error_DevCommFailed;
	}

	if(!m_pRWStr[devSN]->IsValidRW() || m_pDevHandles[devSN].nStatus == -5)
	{
		LOG_TRACE("[%s][devSN#%d] Invalid pipe or process for process exchange.", 
			m_pDevHandles[devSN].szDevName, devSN);
		return Error_DevCommFailed;
	}

	//SpBranch_Command_Req rq;
	//rq.nCmdType = BRCMD_GETSTATE;

	//SpBranch_Command_Ans ans;
	//erroCode = ProcessExchange(devSN, rq, ans);

	//if(ISSUCCEEDED(erroCode) && ISSUCCEEDED(ans.dwErroCode))
	//{
	//	DevThreadState eState = (DevThreadState)ans.nparam1;
	//	if(eState >= State_LoadSucc)
	//	{
	//		
	//	}
	//	else
	//	{
	//		strcpy_s(m_pDevHandles[devSN].szInfo, (LPCTSTR)ans.ssparam1);
	//	}
	//}
	//else if(ISSUCCEEDED(erroCode))
	//{
	//	strcpy_s(m_pDevHandles[devSN].szInfo, (LPCTSTR)ans.desc);
	//}

	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spRootConfig;
	CSmartPointer<IConfigInfo> spCentConfig;
	erroCode = spEntityFunction->OpenConfig(Config_Root, spRootConfig);
	if(!ISSUCCEEDED(erroCode))
	{
		m_pDevHandles[devSN].nStatus = -4;
		Dbg("Open root.ini for %s failed with 0x%08x", m_pDevHandles[devSN].szDevName, erroCode);
		strcpy_s(m_pDevHandles[devSN].szInfo, "Open root.ini failed");
		return erroCode;
	}

	erroCode = spEntityFunction->OpenConfig(Config_CenterSetting, spCentConfig);
	if(!ISSUCCEEDED(erroCode))
	{
		m_pDevHandles[devSN].nStatus = -4;
		Dbg("Open centersetting.ini for %s failed with 0x%08x", m_pDevHandles[devSN].szDevName, erroCode);
		strcpy_s(m_pDevHandles[devSN].szInfo, "Open centersetting.ini failed");
		return erroCode;
	}

	CSimpleStringA devStName = CSimpleStringA::Format("BranchDevice.%s", m_pDevHandles[devSN].szDevName);
	CSimpleStringA csOpenParams;
	CSimpleStringA csOpenParamsCenter;
	erroCode = spRootConfig->ReadConfigValue((LPCTSTR)devStName, "Params", csOpenParams);
	if(FAILURED(erroCode)/* || csOpenParams.GetLength() <= 0*/)
	{
		m_pDevHandles[devSN].nStatus = -4;
		Dbg("Get Open param1 for %s failed param(%s) erroCode(0x%x)",
			m_pDevHandles[devSN].szDevName, (LPCTSTR)csOpenParams, erroCode);
		strcpy_s(m_pDevHandles[devSN].szInfo, "Get open praram1 failed");
		return Error_Param;
	}
	erroCode = spCentConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),
		m_pDevHandles[devSN].szDevName, csOpenParamsCenter);
	if(FAILURED(erroCode)/* || csOpenParamsCenter.GetLength() <= 0*/)
	{
		m_pDevHandles[devSN].nStatus = -4;
		Dbg("Get Open param2 for %s failed param(%s) erroCode(0x%x)",
			m_pDevHandles[devSN].szDevName, (LPCTSTR)csOpenParamsCenter, erroCode);
		strcpy_s(m_pDevHandles[devSN].szInfo, "Get open praram2 failed");
		return Error_Param;
	}
	
	Dbg("Start to open %s.", m_pDevHandles[devSN].szDevName);
	EnterCriticalSection(&(m_pRWStr[devSN]->csExe));
	Dbg("Param1=%s", (LPCTSTR)csOpenParams);
	Dbg("Param2=%s", (LPCTSTR)csOpenParamsCenter);

	SpBranch_Command_Req rq;
	rq.nCmdType = BRCMD_OPENDEV;
	rq.ssparam1 = csOpenParams;
	rq.ssparam2 = csOpenParamsCenter;

	SpBranch_Command_Ans ans;

	erroCode = ProcessExchange(devSN, rq, ans);

	if(ISSUCCEEDED(erroCode) && ISSUCCEEDED(ans.dwErroCode))
	{
		Dbg("Open %s entity suc.", m_pDevHandles[devSN].szDevName);
	}
	else
	{
		m_pDevHandles[devSN].nStatus = -6;
		Dbg("Open %s entity failed returned [0x%08x][0x%08x]", 
			m_pDevHandles[devSN].szDevName, erroCode, ans.dwErroCode);
		if(ISSUCCEEDED(erroCode))
		{
			if(ans.dwErroCode == Error_DevLoadFileFailed)
			{
				if(ans.nparam1 == (int)State_LoadFailed && ans.nparam2 != 0)
				{
					m_pDevHandles[devSN].nStatus = -7;
				}
			}
			Dbg("desc:%s", (LPCTSTR)ans.desc);
			strcpy_s(m_pDevHandles[devSN].szInfo, (LPCTSTR)ans.desc);
		}
		LeaveCriticalSection(&(m_pRWStr[devSN]->csExe));
		return Error_DevCommFailed;
	}
	strcpy_s(m_pDevHandles[devSN].szInfo, "Open device succ");
	m_pDevHandles[devSN].nStatus = 0;
	LeaveCriticalSection(&(m_pRWStr[devSN]->csExe));
	return Error_Succeed;
}

ErrorCodeEnum CBranchDeviceFSM::OpenDevs()
{
	ErrorCodeEnum erroCode = Error_Succeed;
	for(int idx=0; idx<m_nDevNum; ++idx)
	{
		OpenSpecifiedDev(idx);
		Sleep(100);
	}
	return erroCode;
}

ErrorCodeEnum CBranchDeviceFSM::CreateAdapterLoadedProcesses()
{
	ErrorCodeEnum erroCode = Error_Succeed;
	for(int idx=0; idx<m_nDevNum; ++idx)
	{
		if(m_pDevHandles[idx].nStatus == 0)
		{
			//Create DevAdapter Process
			if(!CreateSpecifiedProcess(idx))
			{
				Dbg("CreateChildProcess for %s failed, GLE = %u.", 
					(LPCTSTR)m_pDevHandles[idx].szDevName, GetLastError());
				m_pDevHandles[idx].nStatus = -5;
				continue;
			}
			//strcpy_s(m_pDevHandles[idx].szInfo, "Create process succ");
			Dbg("CreateProcess for %s suc, PID = %u.", 
				(LPCTSTR)m_pDevHandles[idx].szDevName, m_pRWStr[idx]->dwProcessID);
		}
	}
	return erroCode;
}

ErrorCodeEnum CBranchDeviceFSM::ReleaseDevs(bool bCloseDev)
{
	ErrorCodeEnum erroCode = Error_Succeed;
	for(int idx=0; idx<m_nDevNum; ++idx)
	{
		ReleaseSpcfDev(idx, bCloseDev);
		Sleep(100);
	}
	return erroCode;
}

ErrorCodeEnum CBranchDeviceFSM::ReleaseSpcfDev(int devSN, bool bCloseDev)
{
	ErrorCodeEnum erroCode = Error_Succeed;
	if(devSN < 0 || devSN >= m_nDevNum)
	{
		return Error_Param;
	}

	if(m_pDevHandles[devSN].nStatus == -1 || m_pDevHandles[devSN].nStatus == -2)
	{
		LOG_TRACE("[devSN#%d][devName#%s][nStatus#%d][szInfo#%s]", 
			devSN, m_pDevHandles[devSN].szDevName, -1, m_pDevHandles[devSN].szInfo);
		return Error_DevCommFailed;
	}

	if(!m_pRWStr[devSN]->IsValidRW() || m_pDevHandles[devSN].nStatus == -5)
	{
		LOG_TRACE("[devSN#%d][devName#%s] Invalid pipe for process exchange.", 
			devSN, m_pDevHandles[devSN].szDevName);
		return Error_DevCommFailed;
	}

	EnterCriticalSection(&(m_pRWStr[devSN]->csExe));
	
	SpBranch_Command_Req rq;
	rq.nCmdType = BRCMD_CLOSEDEV;
	SpBranch_Command_Ans ans;
	erroCode = ProcessExchange(devSN, rq, ans);
	if(ISSUCCEEDED(erroCode) && ISSUCCEEDED(ans.dwErroCode))
	{
		Dbg("Close %s entity succ.", m_pDevHandles[devSN].szDevName);
	}
	else
	{
		Dbg("DevClose for %s failed returned [0x%08x][0x%08x]",
			m_pDevHandles[devSN].szDevName, erroCode, ans.dwErroCode);
		if(ISSUCCEEDED(erroCode))
		{
			Dbg("desc: %s", (LPCTSTR)ans.desc);
			erroCode = (ErrorCodeEnum)ans.dwErroCode;
		}
	}
	LeaveCriticalSection(&(m_pRWStr[devSN]->csExe));
	return erroCode;
}

void CBranchDeviceFSM::HandleCMD(
	SpReqAnsContext<BranchDeviceService_OpCmd_Req, BranchDeviceService_OpCmd_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	//important.
	int aimSN = ctx->Req.DevSN - 1;

	ErrorCodeEnum erroCode = Error_Succeed;

	if(aimSN < 0 || aimSN >= m_nDevNum)
	{
		ctx->Ans.retCode = -3;
		ctx->Ans.retValue = CSimpleStringA::Format("DevSN is invalid which %d is not in [1, %d]",
			ctx->Req.DevSN, m_nDevNum);
		LogWarn(Severity_Middle, Error_NoTarget, 0, (LPCTSTR)(ctx->Ans.retValue));
		ctx->Answer(Error_NoTarget);
		return;
	}

	if(m_pDevHandles[aimSN].nStatus < 0)
	{
		ctx->Ans.retCode = m_pDevHandles[aimSN].nStatus;
		ctx->Ans.retValue = m_pDevHandles[aimSN].szInfo;
		ctx->Answer(Error_InvalidState);
		LogWarn(Severity_Middle, Error_InvalidState, 0,
			CSimpleStringA::Format("%s is invalid: %s", 
			m_pDevHandles[aimSN].szDevName,
			m_pDevHandles[aimSN].szInfo));
		return;
	}

	DWORD dwCurTickCount = GetTickCount();
	DWORD dwTimeoutMillsec = ctx->Req.uTimeoutMillsec;
	if(dwTimeoutMillsec == 0)
		dwTimeoutMillsec = DEFAULT_TIMEOUT_MILLSEC;
	BOOL bFlag = FALSE;
	while(TryEnterCriticalSection(&(m_pRWStr[aimSN]->csExe)) == FALSE)
	{
		if(!bFlag)
		{
			LogWarn(Severity_Low, Error_Unexpect, 0, 
				"Last operation has not been finished yet, new request is arrived !!");
			bFlag = TRUE;
		}
		
		if(GetTickCount() > (dwTimeoutMillsec + dwCurTickCount))
		{
			ctx->Answer(Error_TimeOut);
			return;
		}
	}

	if(bFlag)
	{
		dwTimeoutMillsec = (GetTickCount() - dwCurTickCount);
	}
	
	SpBranch_Command_Req rq;
	SpBranch_Command_Ans ans;

	Dbg("Start to Invoke ExecuteCmd routine...timeout value %u.", dwTimeoutMillsec);
	rq.nCmdType = BRCMD_SENDCMD;
	rq.ssparam1 = ctx->Req.param;
	erroCode = ProcessExchange(aimSN, rq, ans, dwTimeoutMillsec);
	if(ISSUCCEEDED(erroCode) && ISSUCCEEDED(ans.dwErroCode))
	{
		char szPrintMsg[MAX_PRINTF_MSG_LEN] = {0};
		CovertCmdParam(szPrintMsg, (LPCTSTR)ctx->Req.param);
		Dbg("[param:%s] ExecuteCmd succ.", szPrintMsg);
		ctx->Ans.retCode = ans.nparam1;
		ctx->Ans.retValue = ans.ssparam1;
		ctx->Answer();
	}
	else
	{
		if(ISSUCCEEDED(erroCode))
		{
			ctx->Ans.retCode = ans.dwErroCode;
			ctx->Ans.retValue = ans.desc;
			Dbg("desc: %s", (LPCTSTR)ans.desc);
			ctx->Answer();
		}
		else
		{
			ctx->Answer(erroCode);
		}
		char szPrintMsg[MAX_PRINTF_MSG_LEN] = {0};
		CovertCmdParam(szPrintMsg, (LPCTSTR)ctx->Req.param);
		Dbg("ExecuteCmd%s failed returned [0x%08x][0x%08x]",
			szPrintMsg, erroCode, ans.dwErroCode);
	}
	LeaveCriticalSection(&(m_pRWStr[aimSN]->csExe));
	return;
}

UINT WINAPI CBranchDeviceFSM::DispatchThreadFunc(void* pArguments)
{
	LOG_FUNCTION();
	CBranchDeviceFSM* fsm = (CBranchDeviceFSM*)pArguments;
	EnterCriticalSection(&CBranchDeviceFSM::s_cs);
	SpReqAnsContext<BranchDeviceService_OpCmd_Req, BranchDeviceService_OpCmd_Ans>::Pointer theContext = fsm->m_ctx;
	LeaveCriticalSection(&CBranchDeviceFSM::s_cs);
	fsm->HandleCMD(theContext);
	return 0;
}

void CBranchDeviceFSM::HandleGetInfo(SpReqAnsContext<BranchDeviceService_GetDevInfo_Req, BranchDeviceService_GetDevInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	//important.
	int aimSN = ctx->Req.DevSN - 1;

	ErrorCodeEnum erroCode = Error_Succeed;

	if(aimSN < 0 || aimSN >= m_nDevNum)
	{
		ctx->Answer(Error_NoTarget);
		CSimpleStringA csMsg = CSimpleStringA::Format("DevSN is invalid which %d is not in [1, %d]",
			ctx->Req.DevSN, m_nDevNum);
		LogWarn(Severity_Middle, Error_NoTarget, 0, (LPCTSTR)csMsg);
		Dbg("Invalid devSN %d, return previously.", aimSN + 1);
		return;
	}

	if(m_pDevHandles[aimSN].nStatus < 0)
	{
		ctx->Answer(Error_InvalidState);
		LogWarn(Severity_Middle, Error_InvalidState, 0,
			CSimpleStringA::Format("%s is invalid: %s", 
			m_pDevHandles[aimSN].szDevName,
			m_pDevHandles[aimSN].szInfo));
		Dbg("[devSN#%d]'s status is invalid, (%d){%s}, return previously.", 
			aimSN + 1, m_pDevHandles[aimSN].nStatus, m_pDevHandles[aimSN].szInfo);
		return;
	}

	EnterCriticalSection(&(m_pRWStr[aimSN]->csExe));

	SpBranch_Command_Req rq;
	SpBranch_Command_Ans ans;

	Dbg("Start to Invoke GetDevCategory routine.");
	rq.nCmdType = BRCMD_GETDEVINFO;
	erroCode = ProcessExchange(aimSN, rq, ans);

	if(ISSUCCEEDED(erroCode) && ISSUCCEEDED(ans.dwErroCode))
	{
		Dbg("[%s] GetDevCategory suc, start to set context.", m_pDevHandles[aimSN].szDevName);

		ctx->Ans.state = ans.nparam1;

		Dbg("szModel:%s", (LPCTSTR)ans.ssparam2);
		ctx->Ans.model = ans.ssparam2;

		Dbg("szVendor:%s", (LPCTSTR)ans.ssparam3);

		Dbg("szType:%s", (LPCTSTR)ans.ssparam1);
		ctx->Ans.type = ans.ssparam1;

		Dbg("version:%s", ans.ssparam4);
		ctx->Ans.version = ans.ssparam4;
		//	info.version.wMajor, info.version.wMinor, info.version.wRevision, info.version.wBuild);
		//ctx->Ans.version = CSimpleStringA::Format("%d.%d.%d.%d",
		//	info.version.wMajor, info.version.wMinor, info.version.wRevision, info.version.wBuild);
		ctx->Answer(Error_Succeed);
		Dbg("[%s] finish setting context.", m_pDevHandles[aimSN].szDevName);
	}
	else
	{
		if(ISSUCCEEDED(erroCode))
		{
			ctx->Answer((ErrorCodeEnum)ans.dwErroCode);
			Dbg("desc: %s", (LPCTSTR)ans.desc);
		}
		else
		{
			ctx->Answer(erroCode);
		}
		Dbg("[%s] GetDevCategory failed, returned [0x%08x][0x%08x]", 
			m_pDevHandles[aimSN].szDevName, erroCode, ans.dwErroCode);
	}
	LeaveCriticalSection(&(m_pRWStr[aimSN]->csExe));
	return;
}

BOOL CBranchDeviceFSM::JobInitialize()
{
	LOG_FUNCTION();

	TCHAR szDes[256] = {0};

	const int MAX_MB_COMMITPERPROCESS = 256 * 1024 * 1024;
	const int MIN_MB_LIMIT_WORKINGSET = 1 * 1024 * 1024;
	const int MAX_MB_LIMIT_WORKINGSET = 256 * 1024 * 1024;
	const int DEFAULT_PROCESSES_COUNT = 5;

	//简单地通知作业CPU时间到期
	m_pProcHelper->SetEndOfJobInfo(JOB_OBJECT_POST_AT_END_OF_JOB);

	//关联完成端口
	m_pProcHelper->AssociateCompletionPort(m_hIOCP, COMPKEY_JOBOBJECT);

	// Set Basic and Extended Limits
	JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobeli = { 0 };

	jobeli.BasicLimitInformation.LimitFlags = 0;

	//允许在查询基本统计信息的时候更改作业的限额
	jobeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_PRESERVE_JOB_TIME;

	jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PRIORITY_CLASS;
	jobeli.BasicLimitInformation.PriorityClass = IDLE_PRIORITY_CLASS;

	//jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_BREAKAWAY_OK;
	//jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK;


	// 当作业的最后一个句柄在关闭时，作业中的进程均会关闭
	//jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;

#ifndef BRANCHDEBUG

	// 进程在引发一个未处理的异常后，该进程会立即终止，不显示任何用户界面
	jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION;

	// 设置进程所能申请内存的限额
	jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_PROCESS_MEMORY;
	jobeli.ProcessMemoryLimit = MAX_MB_COMMITPERPROCESS;

	// 设置进程所能使用的工作集限额
	//jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_WORKINGSET;
	//jobeli.BasicLimitInformation.MinimumWorkingSetSize = MIN_MB_LIMIT_WORKINGSET;
	//jobeli.BasicLimitInformation.MaximumWorkingSetSize = MAX_MB_LIMIT_WORKINGSET;

#endif

	// 设置允许的进程数
	jobeli.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_ACTIVE_PROCESS;
	jobeli.BasicLimitInformation.ActiveProcessLimit = DEFAULT_PROCESSES_COUNT;

	if(!(m_pProcHelper->SetExtendedLimitInfo(&jobeli)))
	{
		sprintf_s(szDes, "设置作业扩展限额失败，GLE = %d ！", GetLastError());
		LogWarn(Severity_Middle, Error_Unexpect, 0, szDes);
		m_pProcHelper->PrintError("SetExtendedLimitInfo failed");
		return FALSE;
	}


	//////////////////////////////////////////////////////////////////////////

	// Set UI Restrictions
	DWORD jobuir =  JOB_OBJECT_UILIMIT_NONE;

	//阻止进程注销、关机、重启或断开系统电源
	jobuir |= JOB_OBJECT_UILIMIT_EXITWINDOWS;

	//阻止进程使用作业外部创建的用户对象 
	//jobuir |= JOB_OBJECT_UILIMIT_HANDLES;

	//阻止进程通过 SystemParametersInfo 更改系统参数
	jobuir |= JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS;

	//阻止进程对剪切板进行读取和清除
	jobuir |= JOB_OBJECT_UILIMIT_READCLIPBOARD;
	jobuir |= JOB_OBJECT_UILIMIT_WRITECLIPBOARD;

	//阻止进程创建或切换桌面
	//jobuir |= JOB_OBJECT_UILIMIT_DESKTOP;

	//阻止线程更改显示设置
	//jobuir |= JOB_OBJECT_UILIMIT_DISPLAYSETTINGS;

	if(!(m_pProcHelper->SetBasicUIRestrictions(jobuir)))
	{
		sprintf_s(szDes, "设置作业UI限额失败，GLE = %d ！", GetLastError());
		LogWarn(Severity_Middle, Error_Unexpect, 0, szDes);
		m_pProcHelper->PrintError("SetBasicUIRestrictions failed");
		return FALSE;
	}

	return TRUE;
}

void CBranchDeviceFSM::JobNotify()
{
	BOOL bDone = FALSE;
	LogEvent(Severity_None, 0, "Start Job Notify listening......");
	char szMsg[512] = {0};
	while(!bDone)
	{
		DWORD dwJobObjMsg;
		//完成键值
		ULONG_PTR CompKey;
		//进程ID
		LPOVERLAPPED po;

		GetQueuedCompletionStatus(m_hIOCP, &dwJobObjMsg, &CompKey, &po, INFINITE);
		//Dbg("Test Test Test");
		// The app is shutting down, exit this thread
		bDone = (CompKey == COMPKEY_TERMINATE);

		if (CompKey == COMPKEY_JOBOBJECT)
		{
			switch (dwJobObjMsg)
			{
			case JOB_OBJECT_MSG_END_OF_JOB_TIME:
				{
					LogWarn(Severity_Middle, Error_TimeOut, 0, "Job time limit reached");
				}
				break;

			case JOB_OBJECT_MSG_END_OF_PROCESS_TIME:
				{
					TCHAR szProcessName[MAX_PATH];
					GetProcessName(PtrToUlong(po), szProcessName, MAX_PATH);
					sprintf_s(szMsg, "Job process %s (Id=%d) time limit reached", szProcessName, po);
					LogWarn(Severity_Middle, Error_TimeOut, 0, szMsg);
				}
				CompKey = COMPKEY_STATUS;
				break;

			case JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT:
				{
					LogWarn(Severity_Middle, Error_TimeOut, 0, "Too many active processes in job !");
				}
				break;

			case JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO:
				{
					LogWarn(Severity_Middle, Error_NoTarget, 0, "Job contains no active processes.");
				}
				break;

			case JOB_OBJECT_MSG_NEW_PROCESS: 
				{
					TCHAR szProcessName[MAX_PATH] = {0};
					GetProcessName(PtrToUlong(po), szProcessName, MAX_PATH);
					int aimIdx = -1;
					DWORD pid = PtrToUlong(po);
					for(int idx=0; idx<m_nDevNum; idx++)
					{
						if(m_pRWStr[idx]->dwProcessID == pid)
						{
							aimIdx = idx;
							break;
						}
					}
					if(aimIdx == -1)
					{
						sprintf_s(szMsg, "Unexpect process %s (Id=%d) in Job.", szProcessName, po);
						LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
						break;
					}
					m_pDevHandles[aimIdx].nReserved = 2;
					sprintf_s(m_pDevHandles[aimIdx].szInfo, "Put process in Job succ");
					sprintf_s(szMsg, "New process %s (Id=%d) in Job", szProcessName, po);
					LogEvent(Severity_Middle, 0, szMsg);

				}
				break;

			case JOB_OBJECT_MSG_EXIT_PROCESS: 
				{
					TCHAR szProcessName[MAX_PATH] = {0};
					GetProcessName(PtrToUlong(po), szProcessName, MAX_PATH);
					Dbg("Process %s (Id=%d) terminated", szProcessName, po);
					int aimIdx = -1;
					DWORD pid = PtrToUlong(po);
					for(int idx=0; idx<m_nDevNum; idx++)
					{
						if(m_pRWStr[idx]->dwProcessID == pid)
						{
							aimIdx = idx;
							break;
						}
					}
					if(aimIdx == -1)
					{
						sprintf_s(szMsg, "Unexpect process %s (Id=%d) terminated.", szProcessName, po);
						LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
						break;
					}
					sprintf_s(szMsg, "Process %s (Id=%d) terminated.", szProcessName, po);
					LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
					m_pDevHandles[aimIdx].nStatus = -2;
					m_pDevHandles[aimIdx].nReserved = 0;
					strcpy_s(m_pDevHandles[aimIdx].szInfo, DEFAULT_INFO_SIZE, "The process terminated");
					m_pRWStr[aimIdx]->Cleanup();
				}
				CompKey = COMPKEY_STATUS;
				break;

			case JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS: 
				//https://msdn.microsoft.com/en-us/library/windows/desktop/ms684141(v=vs.85).aspx
				{
					TCHAR szProcessName[MAX_PATH];
					GetProcessName(PtrToUlong(po), szProcessName, MAX_PATH);
					Dbg("Process %s (Id=%d) terminated abnormally", szProcessName, po);
					int aimIdx = -1;
					DWORD pid = PtrToUlong(po);
					for(int idx=0; idx<m_nDevNum; idx++)
					{
						if(m_pRWStr[idx]->dwProcessID == pid)
						{
							aimIdx = idx;
							break;
						}
					}
					if(aimIdx == -1)
					{
						sprintf_s(szMsg, "Unexpect process %s (Id=%d) terminated abnormally.", szProcessName, po);
						LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
						break;
					}
					sprintf_s(szMsg, "Process %s (Id=%d) terminated abnormally !!", szProcessName, po);
					LogError(Severity_Middle, Error_Unexpect, 0, szMsg);
					m_pDevHandles[aimIdx].nStatus = -2;
					m_pDevHandles[aimIdx].nReserved = 0;
					strcpy_s(m_pDevHandles[aimIdx].szInfo, DEFAULT_INFO_SIZE, "The process terminated abnormally");
					m_pRWStr[aimIdx]->Cleanup();
				}
				CompKey = COMPKEY_STATUS;
				break;

			case JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT:
				{
					TCHAR szProcessName[MAX_PATH];
					GetProcessName(PtrToUlong(po), szProcessName, MAX_PATH);
					sprintf_s(szMsg, "Process (%s Id=%d) exceeded memory limit", szProcessName, po);
					LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
				}
				CompKey = COMPKEY_STATUS;
				break;

			case JOB_OBJECT_MSG_JOB_MEMORY_LIMIT: 
				{
					TCHAR szProcessName[MAX_PATH];
					GetProcessName(PtrToUlong(po), szProcessName, MAX_PATH);
					sprintf_s(szMsg, "Process %s (Id=%d) exceeded job memory limit", szProcessName, po);
					LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
				}
				CompKey = COMPKEY_STATUS;
				break;

			default:
				Dbg("Unknown notification: %d", dwJobObjMsg);
				break;
			}
		}

		if (CompKey == COMPKEY_STATUS) 
		{
			static UINT s_nStatusCount = 0;
			Dbg("--> Status Update (%d)", ++s_nStatusCount);

			// Show the basic accounting information
			
			JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION jobai;
			m_pProcHelper->QueryBaseAndIOInfo(&jobai);
			Dbg(
				"Total Time: User=%I64u, Kernel=%I64u        "
				"Period Time: User=%I64u, Kernel=%I64u", 
				jobai.BasicInfo.TotalUserTime.QuadPart,  //已使用用户模式的CPU时间
				jobai.BasicInfo.TotalKernelTime.QuadPart,//已使用内核模式的CPU时间
				jobai.BasicInfo.ThisPeriodTotalUserTime.QuadPart, 
				jobai.BasicInfo.ThisPeriodTotalKernelTime.QuadPart);

			Dbg( 
				"Page Faults=%u, Total Processes=%u, "
				"Active Processes=%u, Terminated Processes=%u", 
				jobai.BasicInfo.TotalPageFaultCount, //进程产生的错误页面总数
				jobai.BasicInfo.TotalProcesses, //曾经属于作业的所有进程数目
				jobai.BasicInfo.ActiveProcesses, //属于作业的当前进程数目
				jobai.BasicInfo.TotalTerminatedProcesses); //超过预定CPU时间限额而被杀死的进程数

			// Show the I/O accounting information
			Dbg(
				"Reads=%I64u (%I64u bytes), " //读操作次数和传输的字节总数
				"Write=%I64u (%I64u bytes), " //写操作次数和传输的字节总数 
				"Other=%I64u (%I64u bytes)",  //非读写操作次数和传输的字节总数
				jobai.IoInfo.ReadOperationCount,  jobai.IoInfo.ReadTransferCount, 
				jobai.IoInfo.WriteOperationCount, jobai.IoInfo.WriteTransferCount, 
				jobai.IoInfo.OtherOperationCount, jobai.IoInfo.OtherTransferCount);

			// Show the peak per-process and job memory usage
			JOBOBJECT_EXTENDED_LIMIT_INFORMATION joeli;
			m_pProcHelper->QueryExtendLimitInfo(&joeli);
			Dbg(
				"Peak memory used: Process=%I64u, Job=%I64u", 
				(__int64) joeli.PeakProcessMemoryUsed, 
				(__int64) joeli.PeakJobMemoryUsed);

			// Show the set of Process IDs 
			DWORD dwNumProcesses = 80;
			DWORD dwProcessIdList[80];
			m_pProcHelper->QueryBasicProcessIdList(dwNumProcesses, 
				dwProcessIdList, &dwNumProcesses);
			Dbg("The ProcessID with its belonged DevName: %s", (dwNumProcesses == 0) ? TEXT("(none)") : TEXT(""));

			TCHAR szProcessName[MAX_PATH];
			for (DWORD x = 0; x < dwNumProcesses; x++)
			{
				GetProcessName(dwProcessIdList[x], szProcessName, _countof(szProcessName));
				Dbg(TEXT("   %d - %s"), dwProcessIdList[x], szProcessName);
			}
		}
	}
	SetEvent(m_hNotifyFinishedEvent);
	LogEvent(Severity_None, Error_Succeed, "Job Notify listening done !");
	return;
}

BOOL CBranchDeviceFSM::CreateSpecifiedProcess(int idx)
{
	SECURITY_ATTRIBUTES sa;
	sa.nLength = sizeof(SECURITY_ATTRIBUTES);
	sa.bInheritHandle = TRUE;
	sa.lpSecurityDescriptor = NULL;
	
	assert(m_pRWStr[idx] != NULL);

	if(!CreatePipe(&(m_pRWStr[idx]->hParentRead), &(m_pRWStr[idx]->hChildWrite), &sa, 0))
	{
		Dbg("CreatePipe1 for %s failed, %d", (LPCTSTR)m_pDevHandles[idx].szDevName, GetLastError());
		return FALSE;
	}
	if(!SetHandleInformation(m_pRWStr[idx]->hParentRead, HANDLE_FLAG_INHERIT, 0))
	{
		Dbg("SetHandleInformation for %s failed, %d.", (LPCTSTR)m_pDevHandles[idx].szDevName, GetLastError());
		return FALSE;
	}

	if(!CreatePipe(&(m_pRWStr[idx]->hChildRead), &(m_pRWStr[idx]->hParentWrite), &sa, 0))
	{
		Dbg("CreatePipe2 for %s failed, %d.", (LPCTSTR)m_pDevHandles[idx].szDevName, GetLastError());
		return FALSE;
	}
	if(!SetHandleInformation(m_pRWStr[idx]->hParentWrite, HANDLE_FLAG_INHERIT, 0))
	{
		Dbg("SetHandleInformation for %s failed, %d.", (LPCTSTR)m_pDevHandles[idx].szDevName, GetLastError());
		return FALSE;
	}

	TCHAR szCmdLine[CMDLINE_SIZE] = {0};
	//sprintf_s(szCmdLine, CMDLINE_SIZE, "spbranch %s %s", 
	//	m_pDevHandles[idx].szDevDllPath, m_pDevHandles[idx].szDevName);
	sprintf_s(szCmdLine, CMDLINE_SIZE, "spbranch %s %s %s", 
		m_pDevHandles[idx].szDevDllPath, m_pDevHandles[idx].szDevName, (LPCTSTR)m_strSpBranchPath);
	Dbg("szCmdLine : {%s}", szCmdLine);

	HANDLE hToken = NULL;
	HANDLE hNewToken = NULL;
	HANDLE hNewExToken = NULL;
	// Integrity level SID
	/************************************************************************/
	/* 
	Name 
	S-1-16-4096
	Low Mandatory Level
	A low integrity process does not have write access to most areas
	under the user’s local profile area of the file system or the registry under HKCU.
	Low-integrity processes can write to and create subkeys under HKEY_CURRENT_USER\Software\AppDataLow
	Low-integrity processes can write and create subfolders under %USER PROFILE%\AppData\LocalLow

	S-1-16-8192
	Medium Mandatory Level

	S-1-16-12288
	High Mandatory Level

	S-1-16-16384
	System Mandatory Level
	/************************************************************************/
	CHAR szIntegritySid[20] = "S-1-16-4096";
	PSID pIntegritySid = NULL;
	PSID pUserGroupSID = NULL;
	PSID pAdminSID = NULL;

	TOKEN_MANDATORY_LABEL tml = {0};

	PROCESS_INFORMATION pi;
	STARTUPINFO si;

	BOOL bSuc = FALSE;
	ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

	ZeroMemory(&si, sizeof(STARTUPINFO));
	si.cb = sizeof(STARTUPINFO);
	GetStartupInfo(&si);
	DWORD fdwCreate = 0;

	si.hStdError = m_pRWStr[idx]->hChildWrite;
	si.hStdOutput = m_pRWStr[idx]->hChildWrite;
	si.hStdInput = m_pRWStr[idx]->hChildRead;
	//重设标准输入，标准输出，标准错误句柄
	si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
	si.wShowWindow = SW_HIDE;
	fdwCreate = NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW;

	if(m_bNeedJob)
	{
		fdwCreate |= CREATE_SUSPENDED;
	}

	__try
	{

		//Dbg("Leave and CreateProcess with normal intergrity.");
		//__leave;

#ifdef DROP_MY_RIGHT
		Dbg("Using DROP_MY_RIGHT way !!!");
		//SAFER_LEVELID_FULLYTRUSTED, SAFER_LEVELID_NORMALUSER, SAFER_LEVELID_CONSTRAINED, SAFER_LEVELID_UNTRUSTED 
		DWORD hSaferLevel = SAFER_LEVELID_NORMALUSER;
		SAFER_LEVEL_HANDLE hAuthzLevel = NULL;
		if (!SaferCreateLevel(SAFER_SCOPEID_USER,
			hSaferLevel,
			0, 
			&hAuthzLevel, NULL)) 
		{
			__leave;
		}
		//  Generate the restricted token we will use.
		if (SaferComputeTokenFromLevel(
			hAuthzLevel,    // SAFER Level handle
			NULL,           // NULL is current thread token.
			&hToken,        // Target token
			0,              // No flags
			NULL)) 
		{
			if(!(bSuc = CreateProcessAsUser(hToken, NULL,
				szCmdLine,     // command line 
				NULL,          // TODO: process security attributes 
				NULL,          // TODO: primary thread security attributes 
				TRUE,          // handles are inherited ?? 
				fdwCreate,     // creation flags
				NULL,          // use parent's environment 
				NULL,          // use parent's current directory 
				&si,           // STARTUPINFO pointer 
				&pi)))         // receives PROCESS_INFORMATION 
			{
				Dbg("CreateProcessAsUser in DropMyRights failed GLE=%u.", GetLastError());
			}
		}
		else
		{
			Dbg("SaferComputeTokenFromLevel failed GLE=%u.", GetLastError());
		}

		if(hAuthzLevel)
		{
			SaferCloseLevel(hAuthzLevel);
		}
		
#endif
		if (!OpenProcessToken(GetCurrentProcess(),
			//MAXIMUM_ALLOWED,
			TOKEN_DUPLICATE |
			TOKEN_ADJUST_DEFAULT |
			TOKEN_QUERY |
			TOKEN_ASSIGN_PRIMARY,
			&hToken))
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "OpenProcessToken failed, GLE = %u.", GetLastError());
			LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
			__leave;
		}
			

		//!!!! TEST!!!!!
		//CTWProcHelper::SetPrivilege(SE_CREATE_TOKEN_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_ASSIGNPRIMARYTOKEN_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_LOCK_MEMORY_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_INCREASE_QUOTA_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_UNSOLICITED_INPUT_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_MACHINE_ACCOUNT_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_TCB_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_SECURITY_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_TAKE_OWNERSHIP_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_LOAD_DRIVER_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_SYSTEM_PROFILE_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_SYSTEMTIME_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_PROF_SINGLE_PROCESS_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_INC_BASE_PRIORITY_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_CREATE_PAGEFILE_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_CREATE_PERMANENT_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_BACKUP_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_RESTORE_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_SHUTDOWN_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_DEBUG_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_AUDIT_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_SYSTEM_ENVIRONMENT_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_CHANGE_NOTIFY_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_REMOTE_SHUTDOWN_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_UNDOCK_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_SYNC_AGENT_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_ENABLE_DELEGATION_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_MANAGE_VOLUME_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_IMPERSONATE_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_CREATE_GLOBAL_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_TRUSTED_CREDMAN_ACCESS_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_RELABEL_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_INC_WORKING_SET_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_TIME_ZONE_NAME, TRUE);
		//CTWProcHelper::SetPrivilege(SE_CREATE_SYMBOLIC_LINK_NAME, TRUE);

#ifdef RestrictedTokens

		Dbg("Using RestrictedTokens way !!!");
		DWORD dwSize = 0;
		DWORD dwTokenInfoLength = 0;
		SID_IDENTIFIER_AUTHORITY SIDAuth = SECURITY_NT_AUTHORITY;
		SID_IDENTIFIER_AUTHORITY SIDAuthNT = SECURITY_NT_AUTHORITY;
		if(!AllocateAndInitializeSid(
			&SIDAuthNT, 
			0x2, 
			SECURITY_BUILTIN_DOMAIN_RID/*0×20*/, 
			DOMAIN_ALIAS_RID_USERS, 
			0, 0, 0, 0, 0, 0,
			&pUserGroupSID))
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "AllocateAndInitializeSid for UserGroup Error %u", GetLastError());
			LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
			__leave;
		}

		// Create a SID for the BUILTIN\Administrators group.
		if(! AllocateAndInitializeSid( &SIDAuth, 2,
			SECURITY_BUILTIN_DOMAIN_RID,
			DOMAIN_ALIAS_RID_ADMINS,
			0, 0, 0, 0, 0, 0,
			&pAdminSID) ) 
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "AllocateAndInitializeSid for AdminGroup Error %u", GetLastError());
			LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
			__leave;
		}

		SID_AND_ATTRIBUTES SidToDisable[1] = {0};
		SidToDisable[0].Sid = pAdminSID;
		SidToDisable[0].Attributes = 0;

		PTOKEN_PRIVILEGES pTokenPrivileges = NULL;
		PTOKEN_PRIVILEGES pTokenPrivilegesToDel = NULL;
		if(!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
		{
			if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
			{
				pTokenPrivileges = (PTOKEN_PRIVILEGES)LocalAlloc(0, dwSize);
				pTokenPrivilegesToDel = (PTOKEN_PRIVILEGES)LocalAlloc(0, dwSize);
				if(pTokenPrivileges != NULL && pTokenPrivilegesToDel != NULL)
				{
					if(!GetTokenInformation(hToken, TokenPrivileges, pTokenPrivileges, dwSize, &dwSize))
					{
						char szMsg[DEFAULT_MSG_SIZE] = {0};
						sprintf_s(szMsg, "GetTokenInformation about TokenPrivileges failed GTE = %u.", GetLastError());
						LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
						__leave;
					}
				}
				else
				{
					char szMsg[DEFAULT_MSG_SIZE] = {0};
					sprintf_s(szMsg, "LocalAlloc for pTokenPrivileges failed GTE = %u.", GetLastError());
					LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
					__leave;
				}
			}
		}

		LUID_AND_ATTRIBUTES *pTokenLUID = pTokenPrivileges->Privileges;
		Dbg("CurrentToken's TokenPrivileges Count: %u", pTokenPrivileges->PrivilegeCount);
		DWORD dwLuidCount = 0;
		PLUID pPrivilegeLuid = NULL;
		if(!CTWProcHelper::GetPrivilegeLUIDWithSID(pUserGroupSID, &pPrivilegeLuid, &dwLuidCount))
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "GetPrivilegeLUIDWithSID failed GTE = %u.", GetLastError());
			LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
			if(pPrivilegeLuid)
			{
				//HeapFree(GetProcessHeap(), 0, pPrivilegeLuid);
				LocalFree(pPrivilegeLuid);
				pPrivilegeLuid = NULL;
			}
			__leave;
		}
		Dbg("UserGroup's TokenPrivileges Count: %u", dwLuidCount);

		DWORD dwDelPrivilegeCount = 0;
		for(DWORD dwIdx=0; dwIdx<(pTokenPrivileges->PrivilegeCount); dwIdx++)
		{
			BOOL bFound = FALSE;
			DWORD dwJdx = 0;
			for(; dwJdx<dwLuidCount; dwJdx++)
			{
				//if(memcmp(&(pTokenLUID[dwIdx].Luid), &(pPrivilegeLuid[dwJdx]), sizeof(LUID)) == 0)
				if((pTokenLUID[dwIdx].Luid.HighPart == pPrivilegeLuid[dwJdx].HighPart)
					&&
					(pTokenLUID[dwIdx].Luid.LowPart == pPrivilegeLuid[dwJdx].LowPart))
				{
					bFound = TRUE;
					break;
				}
			}
			if(!bFound)
			{
				char szPrivilegeName[MAX_PATH] = {0};
				DWORD dwNameSize = MAX_PATH;
				if(!LookupPrivilegeName(NULL, &(pTokenLUID[dwIdx].Luid), szPrivilegeName, &dwNameSize))
				{
					Dbg("LookupPrivilegeName failed GTE = %u.", GetLastError());
					//Dbg("NoFound[%u]: i=%u, j=%u", dwDelPrivilegeCount, dwIdx, dwJdx);
				}
				//else
				//{
				//	Dbg("NoFound[%u]: i=%u, j=%u -> %s", dwDelPrivilegeCount, dwIdx, dwJdx, szPrivilegeName);
				//}
				pTokenPrivilegesToDel->Privileges[dwDelPrivilegeCount++].Luid = pTokenLUID[dwIdx].Luid;
			}
		}
		pTokenPrivilegesToDel->PrivilegeCount = dwDelPrivilegeCount;
		Dbg("TokenPrivileges to delete Count: %u", dwDelPrivilegeCount);
		if(pPrivilegeLuid)
		{
			//HeapFree(GetProcessHeap(), 0, pPrivilegeLuid);
			LocalFree(pPrivilegeLuid);
			pPrivilegeLuid = NULL;
		}

		if(!CreateRestrictedToken(hToken,
			0,
			1, SidToDisable,
			//0, NULL,
			dwDelPrivilegeCount, pTokenPrivilegesToDel->Privileges,
			0, NULL,
			&hNewToken
			))
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "CreateRestrictedToken failed GTE = %u.", GetLastError());
			LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
			__leave;
		}
#if 1
		// Duplicate the primary token of the current process.
		if (!DuplicateTokenEx(hNewToken, MAXIMUM_ALLOWED, NULL, SecurityImpersonation, 
			TokenPrimary, &hNewExToken))
		{
			Dbg("DuplicateTokenEx failed GTE = %u.", GetLastError());
			hNewExToken = NULL;
			//__leave;
		}
		else
		{
			if (ConvertStringSidToSid(szIntegritySid, &pIntegritySid))
			{
				tml.Label.Attributes = SE_GROUP_INTEGRITY;
				tml.Label.Sid = pIntegritySid;

				// Set the process integrity level
				if (!SetTokenInformation(hNewExToken, TokenIntegrityLevel, &tml,
					sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(pIntegritySid)))
				{
					Dbg("SetTokenInformation failed GTE = %u.", GetLastError());
					//__leave;
				}
				else
				{
					CloseHandle(hNewToken);
					hNewToken = hNewExToken;
					hNewExToken = NULL;
					Dbg("Assign Low Mandatory Level to New Token which used to CreateProcessAsUser.");
				}
			}

			//TOKEN_MANDATORY_POLICY tmp;
			//TOKEN_MANDATORY_POLICY_NO_WRITE_UP
			// Cannot write to objects that have a greater mandatory integrity level.
			// and has an integrity level that is the lesser of the parent-process integrity level 
			//and the executable-file integrity level.
			//tmp.Policy = TOKEN_MANDATORY_POLICY_NO_WRITE_UP/*TOKEN_MANDATORY_POLICY_VALID_MASK*/;
			//if(!SetTokenInformation(hNewExToken, TokenMandatoryPolicy, &tmp, sizeof(TOKEN_MANDATORY_POLICY)))
			//{
			//	Dbg("SetTokenInformation failed GTE = %u.", GetLastError());
			//__leave;
			//}
		}
#endif
		if(!(bSuc = CreateProcessAsUser(hNewToken, NULL,
			szCmdLine,     // command line 
			NULL,          // TODO: process security attributes 
			NULL,          // TODO: primary thread security attributes 
			TRUE,         // handles are inherited ?? 
			fdwCreate,     // creation flags
			NULL,          // use parent's environment 
			NULL,          // use parent's current directory 
			&si,           // STARTUPINFO pointer 
			&pi)))         // receives PROCESS_INFORMATION 
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "CreateProcessAsUser failed GTE = %u.", GetLastError());
			LogWarn(Severity_Middle, Error_NewProcess, 0, szMsg);
			__leave;
		}

		if(pTokenPrivileges)
		{
			LocalFree(pTokenPrivileges);
		}
		if(pTokenPrivilegesToDel)
		{
			LocalFree(pTokenPrivilegesToDel);
		}

		//if(!CTWProcHelper::SetPrivilege(hToken, SE_TCB_NAME, TRUE))
		//{
		//	Dbg("SetPrivilege(SE_TCB_NAME) failed GTE = %u.", GetLastError());
		//	__leave;
		//}
		//if(!CTWProcHelper::SetPrivilege(hToken, SE_ASSIGNPRIMARYTOKEN_NAME, TRUE))
		//{
		//	Dbg("SetPrivilege(SE_ASSIGNPRIMARYTOKEN_NAME) failed GTE = %u.", GetLastError());
		//	__leave;
		//}
		//else if(!CTWProcHelper::SetPrivilege(hToken, SE_INCREASE_QUOTA_NAME, TRUE))
		//{
		//	Dbg("SetPrivilege(SE_INCREASE_QUOTA_NAME) failed GTE = %u.", GetLastError());
		//	__leave;
		//}
		//
		//if(LogonUser("cmbzephyr", ".", "Cmb@1111", 
		//	LOGON32_LOGON_NETWORK,
		//	LOGON32_PROVIDER_DEFAULT, &hNewToken))
		//{
			//You don't need to, nor should you be, impersonating the user token in order to
			//launch a new process in the user's desktop.
			//if (!ImpersonateLoggedOnUser(hNewToken))
			//{
			//	Dbg("ImpersonateLoggedOnUser failed GTE = %u.", GetLastError());
			//	__leave;
			//}

		//	if(!CreateRestrictedToken(hNewToken, DISABLE_MAX_PRIVILEGE, 0, NULL, 0, NULL, 0, NULL, &hNewExToken))
		//	{
		//		Dbg("CreateRestrictedToken failed GTE = %u.", GetLastError());
		//		__leave;
		//	}

		//	bSuc = CreateProcessAsUser(hNewExToken, NULL,
		//		szCmdLine,     // command line 
		//		NULL,          // TODO: process security attributes 
		//		NULL,          // TODO: primary thread security attributes 
		//		TRUE,         // handles are inherited ?? 
		//		fdwCreate,     // creation flags
		//		NULL,          // use parent's environment 
		//		NULL,          // use parent's current directory 
		//		&si,           // STARTUPINFO pointer 
		//		&pi);          // receives PROCESS_INFORMATION 
		//	if(!bSuc)
		//	{
		//		Dbg("CreateProcessAsUser failed GTE = %u.", GetLastError());
		//	}
		//}
		//else
		//{
		//	Dbg("LogonUser failed GLE=%d.", GetLastError());
		//}

		//RevertToSelf();

#endif

#ifdef CreateProcessWithLogon
		Dbg("Using CreateProcessWithLogon way !!!");
		bSuc = StartInteractiveClientProcess("cmbzephyr", ".", "Cmb@1111",
			szCmdLine, &si, fdwCreate, &(pi.dwProcessId));
		if(bSuc)
		{
			Dbg("StartInteractiveClientProcess suc.");
		}
		else
		{
			Dbg("StartInteractiveClientProcess failed GLE=%d.", GetLastError());
		}
		__leave;

		DWORD dwSize;
		LPVOID lpvEnv;
		WCHAR szUserProfile[256] = L"";
		if(!LogonUser("cmbzephyr", ".", "Cmb@1111", 
			LOGON32_LOGON_NETWORK,
			LOGON32_PROVIDER_DEFAULT, &hNewToken))
		{
			Dbg("LogonUser failed GLE=%d.", GetLastError());
			__leave;
		}

		if (!CreateEnvironmentBlock(&lpvEnv, hNewToken, TRUE))
		{
			Dbg("CreateEnvironmentBlock failed GLE=%d.", GetLastError());
			__leave;
		}
		
		dwSize = sizeof(szUserProfile)/sizeof(WCHAR);
		if (!GetUserProfileDirectoryW(hToken, szUserProfile, &dwSize))
		{
			Dbg("GetUserProfileDirectory failed GLE=%d.", GetLastError());
			__leave;
		}
		

		PWSTR pWideChars;
		int nLenCmdline = strlen(szCmdLine);
		int nLenWideChar = MultiByteToWideChar(CP_ACP, 0, szCmdLine, nLenCmdline, NULL, 0);
		pWideChars = (PWSTR)HeapAlloc(GetProcessHeap(), 0, nLenWideChar*sizeof(wchar_t));
		if(pWideChars == NULL)
		{
			Dbg("HeapAlloc failed GLE=%d.", GetLastError());
			__leave;
		}

		MultiByteToWideChar(CP_ACP, 0, szCmdLine, nLenCmdline, pWideChars, nLenWideChar);

		PROCESS_INFORMATION w_pi;
		STARTUPINFOW w_si;

		ZeroMemory(&w_pi, sizeof(PROCESS_INFORMATION));

		ZeroMemory(&w_si, sizeof(STARTUPINFOW));
		w_si.cb = sizeof(STARTUPINFOW);
		GetStartupInfoW(&w_si);

		w_si.hStdError = m_pRWStr[idx]->hChildWrite;
		w_si.hStdOutput = m_pRWStr[idx]->hChildWrite;
		w_si.hStdInput = m_pRWStr[idx]->hChildRead;
		//重设标准输入，标准输出，标准错误句柄
		w_si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
		w_si.wShowWindow = SW_HIDE;
		w_si.lpDesktop = L"winsta0\\default";

		fdwCreate = NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT;
		if(m_bNeedJob)
		{
			fdwCreate |= CREATE_SUSPENDED;
		}

		if (!(bSuc = CreateProcessWithLogonW(L"cmbzephyr", L".", L"Cmb@1111", 
			LOGON_WITH_PROFILE, NULL, pWideChars, 
			/*CREATE_UNICODE_ENVIRONMENT*/fdwCreate, lpvEnv, szUserProfile, 
			&w_si, &pi)))
		{
			Dbg("CreateProcessWithLogonW failed GLE=%d.", GetLastError());
		}

		HeapFree(GetProcessHeap(), 0, pWideChars);

		if (!DestroyEnvironmentBlock(lpvEnv))
		{
			Dbg("DestroyEnvironmentBlock failed GLE=%d.", GetLastError());
		}
#endif

#ifdef SetLowPriority
		Dbg("Using SetLowPriority way !!!");
		if (DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL,
			SecurityImpersonation, TokenPrimary, &hNewToken))
		{
			if (ConvertStringSidToSid(szIntegritySid, &pIntegritySid))
			{
				tml.Label.Attributes = SE_GROUP_INTEGRITY;
				tml.Label.Sid = pIntegritySid;

				// Set the process integrity level
				if (SetTokenInformation(hNewToken, TokenIntegrityLevel, &tml,
					sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(pIntegritySid)))
				{
					bSuc = CreateProcessAsUser(hNewToken, NULL,
						szCmdLine,     // command line 
						NULL,          // TODO: process security attributes 
						NULL,          // TODO: primary thread security attributes 
						TRUE,         // handles are inherited ?? 
						fdwCreate,     // creation flags
						NULL,          // use parent's environment 
						NULL,          // use parent's current directory 
						&si,           // STARTUPINFO pointer 
						&pi);          // receives PROCESS_INFORMATION 

					RevertToSelf();
				}
			}
		}
#endif

	}
	__finally
	{
		if(pIntegritySid)
		{
			LocalFree(pIntegritySid);
		}
		if(pUserGroupSID)
		{
			LocalFree(pUserGroupSID);
		}
		if(pAdminSID)
		{
			LocalFree(pAdminSID);
		}
		// 
		// Close the access token.
		// 
		if (hToken)
		{
			CloseHandle(hToken);
		}
		if(hNewToken)
		{
			CloseHandle(hNewToken);
		}
		if(hNewExToken)
		{
			CloseHandle(hNewExToken);
		}
		if(!bSuc)
		{
			LogWarn(Severity_Middle, Error_NewProcess, 0, "Retry to Create process in normal way.");
			//Create process.
			bSuc = CreateProcess(NULL, 
				szCmdLine,     // command line 
				NULL,          // TODO: process security attributes 
				NULL,          // TODO: primary thread security attributes 
				TRUE,          // handles are inherited ?? 
				fdwCreate,     // creation flags
				NULL,          // use parent's environment 
				NULL,          // use parent's current directory 
				&si,           // STARTUPINFO pointer 
				&pi);          // receives PROCESS_INFORMATION 
		}
	}

	if(!bSuc)
	{
		return FALSE;
	}

	m_pRWStr[idx]->dwProcessID = pi.dwProcessId;
	if(m_bNeedJob)
	{
		sprintf_s(m_pDevHandles[idx].szInfo, "Waitting JobNotify about being putted it in Job");
		m_pDevHandles[idx].nReserved = 1;
		if(!m_pProcHelper->AssignProcess(pi.hProcess))
		{
			char szMsg[DEFAULT_MSG_SIZE] = {0};
			sprintf_s(szMsg, "Add Process(id=%d) to Job failed, GLE = %u.",
				pi.dwProcessId, GetLastError());
			LogWarn(Severity_Middle, Error_Unexpect, 0, szMsg);
		}
		ResumeThread(pi.hThread);
	}
	else
	{
		sprintf_s(m_pDevHandles[idx].szInfo, "Create process succ");
	}
	// Close handle of process and its thread.
	// Not necessary
	CloseHandle(pi.hThread);
	CloseHandle(pi.hProcess);
	return TRUE;
}

ErrorCodeEnum CBranchDeviceFSM::ProcessExchange(int nIdentifier, 
	SpBranch_Command_Req& req, SpBranch_Command_Ans& ans, DWORD dwMillSec /*= 30000*/)
{

	assert(nIdentifier >= 0 && nIdentifier < m_nDevNum);

	ans.Init();
	ErrorCodeEnum erroCode = Error_Unexpect;
	BOOL bSuc = FALSE;
	DWORD dwRead, dwWritten;
	HANDLE hRead = m_pRWStr[nIdentifier]->hParentRead;
	HANDLE hWrite = m_pRWStr[nIdentifier]->hParentWrite;

	CAutoBuffer buf = SpObject2Buffer(req);
	dwRead = buf.GetCount();
	//https://msdn.microsoft.com/en-us/library/windows/desktop/aa365747%28v=vs.85%29.aspx
	bSuc = WriteFile(hWrite, buf, dwRead, &dwWritten, NULL);
	Dbg("[%s]WriteFile %ssuccessfully: should write(%d), actually written(%d).", 
		m_pDevHandles[nIdentifier].szDevName, (bSuc ? "" : "un"), dwRead, dwWritten);

	if (!bSuc)
	{
		char szMsg[DEFAULT_MSG_SIZE] = {0};
		sprintf_s(szMsg, DEFAULT_MSG_SIZE, "WriteFile opertaion failed, GLE = %u.", GetLastError());
		LogError(Severity_Middle, Error_IO, 0, szMsg);
		return Error_IO;
	}

	Dbg("[%s]Write fininshed and start reading...", m_pDevHandles[nIdentifier].szDevName);
	BYTE* btBuf = new BYTE[BUFSIZE];
	if(btBuf == NULL)
	{
		Dbg("Create byte for reading failed GTL = %u.", GetLastError());
		return Error_Resource;
	}
	DWORD dwTimeout = GetTickCount() + dwMillSec;

	for(;;)
	{
		ZeroMemory(btBuf, BUFSIZE);
		bSuc = PeekNamedPipe(hRead, btBuf, BUFSIZE, &dwRead, NULL, NULL);
		if(!bSuc)
		{
			DWORD dwCode = GetLastError();
			Dbg("PeekNamedPipe failed, GLE = %u.", dwCode);
			if(dwCode == ERROR_INVALID_HANDLE)
			{
				//Custom add.
				erroCode = Error_NotIntegrated;
			}
			break;
		}

		if(dwRead != 0)
		{
			Dbg("[%s] Receive response informaion contains %u bytes, and start to ReadFile.",
				m_pDevHandles[nIdentifier].szDevName, dwRead);

			bSuc = ReadFile(hRead, btBuf, dwRead, &dwRead, NULL);
			if(!bSuc || dwRead == 0)
			{
				char szMsg[DEFAULT_MSG_SIZE] = {0};
				sprintf_s(szMsg, "ReadFile opertaion failed (bSuc=%d)(dwRead=%d), GLE = %u.",
					bSuc, dwRead, GetLastError());
				LogError(Severity_Middle, Error_IO, 0, szMsg);
				erroCode = Error_IO;
				break;
			}

			buf.Clear();
			buf.Attach(btBuf, dwRead);
			SpBuffer2Object(buf, ans);
			Dbg("[%s]Response status: EC=%u, Info: %s",
				m_pDevHandles[nIdentifier].szDevName, ans.dwErroCode, (LPCTSTR)ans.desc);
			return Error_Succeed;
		}

		if(GetTickCount() > dwTimeout)
		{
			Dbg("[%s]Response occurs Timeout !!!",
				m_pDevHandles[nIdentifier].szDevName);
			erroCode = Error_TimeOut;
			break;
		}
	}

	delete[] btBuf;
	btBuf = NULL;
	return erroCode;
}

BOOL CBranchDeviceFSM::RestartChildProcess(int idx)
{
	if(idx < 0 || idx >= m_nDevNum)
	{
		return FALSE;
	}

	if(m_pRWStr[idx]->dwProcessID != 0)
	{
		if(m_pProcHelper->DestoryProcess(m_pRWStr[idx]->dwProcessID))
		{
			//TODO: Waiting the process terminate eventually.
			Sleep(1000);
			m_pRWStr[idx]->Cleanup();
		}
	}
	m_pDevHandles[idx].nReserved = 0;
	//Create DevAdapter Process
	if(!CreateSpecifiedProcess(idx))
	{
		Dbg("CreateChildProcess for %s failed, GLE = %u.", m_pDevHandles[idx].szDevName, GetLastError());
		m_pDevHandles[idx].nStatus = -5;
		return FALSE;
	}

	Dbg("CreateProcess for %s succ, PID = %u.", m_pDevHandles[idx].szDevName, m_pRWStr[idx]->dwProcessID);
	m_pDevHandles[idx].nStatus = 0;
	return TRUE;
}