myvtm/Tool/spbranch/spbranch.h

#pragma once

#include "resource.h"
#include <tchar.h>
#include <strsafe.h>
#include <Shlobj.h>
#include "branch_def.h"
#include "Logger.h"
#include "..\..\DeviceAdapter\DevInc\BranchDeviceClass.h"

using namespace SpBranch;

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

#define SAFE_FREE_LIBRARY(hModule)	\
	do {							\
	if(hModule){					\
	FreeLibrary(hModule);		\
	hModule = NULL;				\
	}							\
	}while(0)

#define GETFUNC_ERRORMSG(fuc, ec)	\
	GetAdapterLastErr(#fuc, ec)

#define MAX_PRINTF_MSG_LEN 512
#define MAX_PRINTF_INFOR_LEN 1024

typedef ErrorCodeEnum ( *LpCreateDevCom)(DeviceBaseClass *&baseObj);
typedef ErrorCodeEnum ( *LpReleaseDevCom)(DeviceBaseClass *&pBaseObj);

void InitLogger(LPCTSTR lpszDbgPath = NULL);

LPCTSTR ErrorMessage(DWORD error);
void FormatError(LPCTSTR fmt, ...);
void FormatInfo(LPCTSTR fmt, ...);
void PrintError(LPCTSTR errDesc, BOOL bGetLastError = TRUE);
void PrintInfo(LPCTSTR inforDesc);

//outCovertParam must be MAX_PRINTF_MSG_LEN len.
void CovertCmdParam(LPTSTR outCovertParam, LPCTSTR lpszParam)
{
	//PrintInfo("Test security param.");
	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;
}

class CSpBranch
{

public:

	CSpBranch()
		:m_hVendorDll(NULL),
		m_pDevClass(NULL),
		m_FuncCreate(NULL),
		m_FuncRelease(NULL),
		m_eStatus(State_NoInit),
		m_devErrCode(Error_Succeed)
	{
		memset(m_szDllName, 0, sizeof(char)*MAX_PATH);
		memset(m_szDevName, 0, sizeof(char)*MAX_PATH);
		memset(m_szInfo, 0, sizeof(char)*MAX_PRINTF_INFOR_LEN);
	}

	~CSpBranch()
	{
		//LOG_FUNCTION();
		if(m_eStatus >= State_LoadSucc)
		{
			if(m_eStatus > State_LoadSucc)
				CloseDevice();
			m_devErrCode = m_FuncRelease((DeviceBaseClass *&) m_pDevClass);
		}
		SAFE_FREE_LIBRARY(m_hVendorDll);
		FormatInfo("** The branch loaded process terminate ! processId = %u", GetCurrentProcessId());
	}

	//LoadLibrary and Create Object
	BOOL Init(_TCHAR* argv1, _TCHAR* argv2);
	BOOL OpenDevice(LPCTSTR lpszOpenParam1, LPCTSTR lpszOpenParam2);
	BOOL CloseDevice();

	BOOL ExecuteCmd(LPCTSTR lpszParam, CSimpleStringA& ssRetVal);
	BOOL GetDevCategory(DevCategoryInfo& info);

	DevThreadState GetDevThreadState() { return m_eStatus; }
	DWORD GetLastErrorCode() { return m_devErrCode; }
	void GetLastOperatError(DWORD& dwErrCode, CSimpleStringA& ssErrMsg)
	{
		//dwErrCode = m_eStatus;
		dwErrCode = m_devErrCode;
		ssErrMsg = m_szInfo;
	}
	void GetLastErrorMsg(CSimpleStringA& ssErrMsg)
	{
		ssErrMsg = m_szInfo;
	}

protected:
	ErrorCodeEnum GetAdapterLastErr(LPCTSTR lpDescFunc, ErrorCodeEnum errCodeFunc);

private:
	char m_szDllName[MAX_PATH];
	char m_szDevName[MAX_PATH];
	char m_szInfo[MAX_PRINTF_INFOR_LEN];

	HMODULE m_hVendorDll;

	BranchDeviceClass* m_pDevClass;
	LpCreateDevCom m_FuncCreate;
	LpReleaseDevCom m_FuncRelease;

	DevThreadState m_eStatus;

	DWORD m_devErrCode;
};

BOOL CSpBranch::Init(_TCHAR* argv1, _TCHAR* argv2)
{

	strcpy_s(m_szDllName, MAX_PATH, argv1);
	strcpy_s(m_szDevName, MAX_PATH, argv2);
	m_eStatus = State_LoadFailed;
	ErrorCodeEnum erroCode = Error_Unexpect;
	FormatInfo("DllPath: %s", m_szDllName);
	m_hVendorDll = LoadLibraryA(m_szDllName);

	if(m_hVendorDll == NULL || m_hVendorDll == INVALID_HANDLE_VALUE)
	{
		PrintError("LoadLibrary failed");
		sprintf_s(m_szInfo, "LoadLibrary(%s) failed", m_szDllName);
		m_devErrCode = Error_DevLoadFileFailed;
		return FALSE;
	}

	if((m_FuncCreate = (LpCreateDevCom)GetProcAddress(m_hVendorDll, "CreateDevComponent")) == NULL)
	{
		sprintf_s(m_szInfo, "Get CreateDevComponent failed");
		PrintError("Get CreateDevComponent failed");
		SAFE_FREE_LIBRARY(m_hVendorDll);
		m_devErrCode = Error_Unregisted;
		return FALSE;
	}

	if((m_FuncRelease = (LpReleaseDevCom)GetProcAddress(m_hVendorDll, "ReleaseDevComponent")) == NULL)
	{
		sprintf_s(m_szInfo, "Get ReleaseDevComponent failed");
		PrintError("Get ReleaseDevComponent failed");
		SAFE_FREE_LIBRARY(m_hVendorDll);
		m_devErrCode = Error_Unregisted;
		return FALSE;
	}

	PrintInfo("Get DevComponent functions suc.");
	erroCode = m_FuncCreate((DeviceBaseClass *&)m_pDevClass);
	if(FAILURED(erroCode) || !m_pDevClass)
	{
		sprintf_s(m_szInfo, "Create dll entity failed");
		FormatError("Create DevAdapter Object failed, EC = %d.", erroCode);
		SAFE_FREE_LIBRARY(m_hVendorDll);
		m_devErrCode = Error_NoTarget;
		return FALSE;
	}

	sprintf_s(m_szInfo, "Create DevAdapter dll entity suc");
	PrintInfo("Create DevAdapter dll entity suc");
	m_devErrCode = Error_Succeed;
	m_eStatus = State_LoadSucc;
	return TRUE;
}

BOOL CSpBranch::OpenDevice(LPCTSTR lpszOpenParam1, LPCTSTR lpszOpenParam2)
{
	if(m_pDevClass == NULL)
	{
		m_devErrCode = Error_NotInit;
		return FALSE;
	}

	ErrorCodeEnum erroCode = Error_Unexpect;
	BOOL bRet = FALSE;
	if(m_eStatus < State_LoadSucc)
	{
		PrintError("LoadLibraray first.", FALSE);
		m_devErrCode = Error_InvalidState;
		return FALSE;
	}
	if(m_eStatus >= State_Opened)
	{
		PrintInfo("BranchDevice been opened already.");
		m_devErrCode = Error_Duplication;
		return TRUE;
	}

	__try
	{
		FormatInfo("Start to open device with param: [%s][%s].", lpszOpenParam1, lpszOpenParam2);
		m_devErrCode = m_pDevClass->DevOpen(lpszOpenParam1, lpszOpenParam2);
		if(ISSUCCEEDED(m_devErrCode))
		{
			PrintInfo("Open device suc.");
			m_eStatus = State_Opened;
		}
		else
		{
			FormatError("Open device failed returned 0x%08x.", m_devErrCode);
			GETFUNC_ERRORMSG(DevOpen, (ErrorCodeEnum)m_devErrCode);
		}
	}
	__finally
	{
		if(AbnormalTermination())
		{
			FormatError("DevOpen([%s][%s]) appears exeception", lpszOpenParam1, lpszOpenParam2);
			m_devErrCode = Error_Exception;
			strcpy_s(m_szInfo, "DevOpen appears exeception");
		}
	}

	return (ISSUCCEEDED(m_devErrCode));
}

BOOL CSpBranch::CloseDevice()
{
	if(m_pDevClass == NULL)
	{
		m_devErrCode = Error_NotInit;
		return FALSE;
	}

	if(m_eStatus < State_Opened)
	{
		PrintError("BranchDevice is not opend current.", FALSE);
		m_devErrCode = Error_InvalidState;
		return TRUE;
	}

	__try
	{
		m_devErrCode = m_pDevClass->DevClose();
		if(ISSUCCEEDED(m_devErrCode))
		{
			PrintInfo("Close device succ.");
		}
		else
		{
			GETFUNC_ERRORMSG(DevClose, (ErrorCodeEnum)m_devErrCode);
		}
	}
	__finally
	{
		if(AbnormalTermination())
		{
			FormatError("DevClose appears exeception");
			m_devErrCode = Error_Exception;
			strcpy_s(m_szInfo, "DevOpen appears exeception");
		}
	}

	return (ISSUCCEEDED(m_devErrCode));
}

ErrorCodeEnum CSpBranch::GetAdapterLastErr(LPCTSTR lpDescFunc, ErrorCodeEnum errCodeFunc)
{
	if(m_pDevClass == NULL)
	{
		return Error_NotInit;
	}

	DevErrorInfo erroInfo;
	memset(erroInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
	ErrorCodeEnum errLastErr = m_pDevClass->GetLastErr(erroInfo);
	if(ISSUCCEEDED(errLastErr) && erroInfo.dwErrMsgLen > 0)
	{
		CSimpleStringA str = CSimpleStringA::Format("%s failed GLE: %s", lpDescFunc, erroInfo.szErrMsg);
		sprintf_s(m_szInfo, (LPCTSTR)str);
		FormatError("%s failed GLE: %s", lpDescFunc, erroInfo.szErrMsg);
	}
	else
	{
		FormatError("GetLastErr for %s failed, %d %s.", lpDescFunc, errLastErr, erroInfo.szErrMsg);
		CSimpleStringA str = CSimpleStringA::Format("%s failed returned 0x%08x", lpDescFunc, errCodeFunc);
		sprintf_s(m_szInfo, (LPCTSTR)str);
	}
	return errLastErr;
}

BOOL CSpBranch::ExecuteCmd(LPCTSTR lpszParam, CSimpleStringA& ssRetVal)
{
	if(m_pDevClass == NULL)
	{
		m_devErrCode = Error_NotInit;
		return FALSE;
	}

	char* retValue = new char[MAX_RETVALUE_LEN];
	ZeroMemory(retValue, MAX_RETVALUE_LEN);

	if(retValue == NULL)
	{
		strcpy_s(m_szInfo, "Allocate memory for retValue failed");
		PrintError("Allocate memory for retValue failed");
		m_devErrCode = Error_Resource;
		return FALSE;
	}
	__try
	{
		char szPrintMsg[MAX_PRINTF_MSG_LEN] = {0};
		CovertCmdParam(szPrintMsg, lpszParam);
		FormatInfo("Start to Invoke ExecuteCmd%s routine.", szPrintMsg);

		m_devErrCode = m_pDevClass->ExecuteCmd(lpszParam, retValue, MAX_RETVALUE_LEN);
		if(ISSUCCEEDED(m_devErrCode))
		{
			ssRetVal = retValue;
		}
		else
		{
			GETFUNC_ERRORMSG(ExecuteCmd, (ErrorCodeEnum)m_devErrCode);
		}
	}
	__finally
	{
		delete[] retValue;
		retValue = NULL;
		if(AbnormalTermination())
		{
			char szPrintMsg[MAX_PRINTF_MSG_LEN] = {0};
			CovertCmdParam(szPrintMsg, lpszParam);

			FormatError("ExecuteCmd%s appears exeception", szPrintMsg);
			m_devErrCode = Error_Exception;
			strcpy_s(m_szInfo, "ExecuteCmd appears exeception");
		}
	}

	return (ISSUCCEEDED(m_devErrCode));
}

BOOL CSpBranch::GetDevCategory(DevCategoryInfo& info)
{
	if(m_pDevClass == NULL)
	{
		m_devErrCode = Error_NotInit;
		return FALSE;
	}

	__try
	{
		memset((void*)&info, 0, sizeof(DevCategoryInfo));
		m_devErrCode = m_pDevClass->GetDevCategory(info);
		if(!ISSUCCEEDED(m_devErrCode))
		{
			GetAdapterLastErr("GetDevCategory", (ErrorCodeEnum)m_devErrCode);
		}
	}
	__finally
	{
		if(AbnormalTermination())
		{
			FormatError("GetDevCategory appears exeception");
			m_devErrCode = Error_Exception;
			strcpy_s(m_szInfo, "GetDevCategory appears exeception");
		}
	}
	return (ISSUCCEEDED(m_devErrCode));
}