myvtm/DevAdapter/keba/PinPad.keba.1.1/PinPadClassImpl_ZT598M.cpp

#include "PinPadClassImpl_ZT598M.h"
#include <cstdio>

#define DES_KEY_NAME_PREFIX "DESKey"
#define SM_KEY_NAME_PREFIX "SMKey"
#define MASTER_KEY_NAEM_LABEL "MASTER"
#define WORKING_KEY_NAEM_LABEL "WORKING"
#define INTERNAL_TEST_KEY "InternalTestKey"

#define PINPAD_TYPE_M1FD "ZT598-M1FD-H16"

#define KEYBOARD_CODE_LIST \
    '1',  '2',  '3',  0x1B,\
    '4',  '5',  '6',  0x08,\
    '7',  '8',  '9',  0x20,\
    '.',  '0',  0x4F, 0x0D,\
    0x47, 0x42, 0x45, 0x44,\
    0x43, 0x46, 0x41, 0x48

#define MAX_AEL_KEY 8
#define BLOCK_SIZE 256
#define LOG_LEVEL_NONE                (0x7FFFFFFF)



typedef struct _key_ael
{
    WORD   wEnlargeId; //密钥的固件ID
    WORD   wVI;
    DWORD  dwKeyAttr;
}AELKEY, *LPAELKEY;

typedef struct _key_use_ael
{
    WORD   wAppId; //花瓶，密钥组ID，也是索引，范围?0 ~ (MAX_MAP_KEY - 1)
    WORD   wKeyLen;
    DWORD  dwKeyAttr;
    WORD   wEnKeyId;
    WORD   wEnKeyLen;
    AELKEY stKey[MAX_AEL_KEY];
//    char   szKeyName[MAX_KEY_NAME + 1];
    char   szKeyValue[24];
}ARTKEY, *LPARTKEY;

//乿2号为起始，先写这个文件头
typedef struct _file_ael_head
{
    DWORD dwFileLen;
    BYTE ucFlag;
    BYTE ucReserve;
}AELFILE, *LPAELFILE; //写入EPP的用户数据区时，会多写这个文件头再写Enlargekey.dat的数拿


extern EPPExchangeDataField m_stExchangeSendData;
extern EPPExchangeDataField m_stExchangeReceiveData;

CINIAccess g_iniAccess;
LOG_EXTERN()

int getFileVer(char* sFile, short &ch1, short &ch2)
{
        ch1 = 0;
        ch2 = 0;
        char* pFind = strstr(sFile, ".so");
        char* pTemp = pFind;
        while(pTemp)
        {
            pFind = pTemp;
            pTemp = strstr(pFind + 3, ".so");
        }
        if(pFind == nullptr) return 0;

        pTemp = pFind - 1;
        while(isdigit(*pTemp) && pTemp > sFile) pTemp--;
        if(*pTemp == '.')
            ch2 = atoi(pTemp + 1);

        pTemp--;
        while(isdigit(*pTemp) && pTemp > sFile) pTemp--;

        if(*pTemp == '.')
            ch1 = atoi(pTemp + 1);

        return 1;
}

PinPadClassImpl::PinPadClassImpl() :
    m_bDevOpen(FALSE),
    m_bConfirm(FALSE),
    m_bSM(FALSE),
    m_wCryptDataAlgorithm(PIN_CRYPT_CBC),
    m_wCryptMacAlgorithm(PIN_CRYPTTRIDESMAC),
    m_byPattern(PIN_CRYPT_TDES)
{
    LOG_FUNCTION();
    m_LPPinpadStatus=new PinpadStatus;
    memset(m_LPPinpadStatus,0x00,sizeof (PinpadStatus));
    memset(&m_cfgSP, 0x00, sizeof(m_cfgSP));
    memset(&m_pinpadReadData, 0x00, sizeof(m_pinpadReadData));
    memset(m_szMainChipSN, 0x00, sizeof(m_szMainChipSN));
    LogM("PinPad PinPadClassImpl creat function()! version:202104130936");
    ZT598M1FD_DevCtrl = NULL;
    ZT598M1FD_DevCtrl=new CZT598M1FD_DevCtrl();
    if(ZT598M1FD_DevCtrl == NULL)
    {
        LogM("ZT598M1FD_DevCtrl = NULL");
    }
}

PinPadClassImpl::~PinPadClassImpl()
{
    LOG_FUNCTION();
    if (ZT598M1FD_DevCtrl != NULL)
    {
        delete ZT598M1FD_DevCtrl;
        ZT598M1FD_DevCtrl = NULL;
    }
    return;
}

ErrorCodeEnum PinPadClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::GetDevCategory()");
    CHAR szHardwareSN[16] = {0};
    CHAR szTemp[128] = {0};
    memset(devCategory.szType, 0, MAX_DEV_TYPE_LEN);
    memset(devCategory.szModel, 0, MAX_DEV_MODEL_LEN);
    memset(devCategory.szVendor, 0, MAX_DEV_VENDOR_LEN);
    memset(&devCategory.version, 0, sizeof(devCategory.version));
    //PinpadStatus stPinpadStatus;
    //if(m_bDevOpen)
    //if(ZT598M1FD_DevCtrl->GetDevStatus(&stPinpadStatus) == STATUS_SUCCESS)
    if(ZT598M1FD_DevCtrl->GetDevStatus(m_LPPinpadStatus) == STATUS_SUCCESS)
    {
        sprintf(devCategory.szType, "PVER=SZZT#MID=keba.PinPad.%s-%s", m_sDevModel, m_sSMVer);
        sprintf(devCategory.szModel, "PM=V2.0#PID=%s#MID=%s#FWID=%s%s", m_szMainChipSN, m_szMainChipSN, m_sDevModel+(strlen(m_sDevModel) - 4), m_sSMVer+(strlen(m_sSMVer) - 4));
        sprintf(devCategory.szVendor,"keba");
    }
    else
    {
        sprintf(devCategory.szType, "PVER=SZZT#MID=");
        sprintf(devCategory.szModel, "PM=V2.0#PID=#MID=#FWID=");
        sprintf(devCategory.szVendor,"keba");
    }
    switch(m_LPPinpadStatus->wDevState)
    {
    case DEV_NORMAL:
        devCategory.eState = DEVICE_STATUS_NORMAL;
        break;
    case DEV_HWERR:
        devCategory.eState = DEVICE_STATUS_FAULT;
        break;
    case DEV_OFFLINE:
        devCategory.eState = DEVICE_STATUS_NOT_READY;
        break;
    default:
        devCategory.eState = DEVICE_STATUS_NOT_READY;
        break;
    }
    char sPath[256], sFile[128] = {0};
    GetCurModulePath(sPath, sFile);
    short v1,v2;
    getFileVer(sFile, v1, v2);

    devCategory.version.wMajor = v1;
    devCategory.version.wMinor = v2;

    devCategory.version.wRevision = 0xffff;
    devCategory.version.wBuild = FILE_VERSION;

    //devCategory.version.wRevision = 0xFFFF;
    //devCategory.version.wBuild = 1;
    //devCategory.version.wMajor = 0;
    //devCategory.version.wMinor = 0;
    LogM( "devCategory.szType=%s",devCategory.szType);
    LogM( "devCategory.szModel=%s [0x%x]", devCategory.szModel, m_szMainChipSN[9]);
    LogM( "devCategory.szVendor=%s",devCategory.szVendor);
    LogM( "devCategory.eState=%d",devCategory.eState);
    LogM( "devCategory.version=%d.%d.%d.%d", devCategory.version.wMajor, devCategory.version.wMinor, devCategory.version.wRevision, devCategory.version.wBuild);
    LogM("==>Leave PinPadClassImpl::GetDevCategory()");
    return Error_Succeed;
}

ErrorCodeEnum PinPadClassImpl::Reset()
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::Reset()");
    ErrorCodeEnum eRet = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    m_bDevOpen = FALSE;
    lRet = ZT598M1FD_DevCtrl->CloseDevice();
    if(lRet != STATUS_SUCCESS)
    {
        SaveErrorInfo(lRet);
    }
    LogM("==>Leave PinPadClassImpl::Reset() = %d", lRet);
    return DevOpen(0, 0);
}

ErrorCodeEnum PinPadClassImpl::DevClose()
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::DevClose()");
    ZT598M1FD_DevCtrl->CloseDevice();
    LogM("==>Leave PinPadClassImpl::DevClose()");
    return Error_Succeed;
}

ErrorCodeEnum PinPadClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::GetLastErr()");
    devErrInfo.dwErrMsgLen = 0;
    memset(devErrInfo.szErrMsg, 0, sizeof(devErrInfo.szErrMsg));

    devErrInfo.dwErrMsgLen = (m_shErrCode << 16);
    sprintf(devErrInfo.szErrMsg, m_szErrMsg);
    devErrInfo.dwErrMsgLen += (strlen(devErrInfo.szErrMsg) & 0x0000FFFF);
    LogM("==>Leave PinPadClassImpl::GetLastErr()");
    return Error_Succeed;
}

ErrorCodeEnum PinPadClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::DevOpen(dwPort=%d, dwBaudRate=%d)", dwPort, dwBaudRate);
    BYTE byBuffer[256] = {0};
    SYSTEMTIME systemTime;
    LONG lRet = STATUS_SUCCESS;
    BOOL bRet = FALSE;
    //ErrorCodeEnum bRet=Error_Succeed;
    ReadEPPInfoResponse stReadEPPInfoRes;
    //LOG4VTM_FUNCTION();

    if (ReadPinpadConfig(&ZT598M1FD_DevCtrl->m_stPinpadDevConfig, &m_cfgSP) == FALSE)
    {
        LogE("ReadPinpadConfig() failed");
        LogM("==>Leave PinPadClassImpl::DevOpen() return Error_Param");
        return Error_Param;
    }

    lRet = ZT598M1FD_DevCtrl->InitDevice(m_sDevModel, sizeof(m_sDevModel), m_sSMVer, sizeof(m_sSMVer), m_szMainChipSN, sizeof(m_szMainChipSN));
    if(lRet != STATUS_SUCCESS)
    {
        LogM("==>Leave PinPadClassImpl::DevOpen(): InitDevice()=%d", lRet);
        return SaveErrorInfo(lRet);
    }
    //根据能力调整硬件配置
    //设置硬件配置参数
    lRet = ZT598M1FD_DevCtrl->SetDeviceConfigure(m_cfgDev, m_LPPinpadStatus);
    if(lRet != STATUS_SUCCESS)
    {
        LogM("==>Leave PinPadClassImpl::DevOpen(): SetDeviceConfigure=%d", lRet);
        return SaveErrorInfo(lRet);
    }
    if(PIN_INSTALL== m_cfgSP.byRemoveInstall||PIN_REMOVE==m_cfgSP.byRemoveInstall)
    {
        lRet=ZT598M1FD_DevCtrl->RemoveInstallAuthen(m_cfgSP.byRemoveInstall,&systemTime,m_LPPinpadStatus);
        if(ERR_PIN_PHYSICALLY_UNINSTALLED==lRet||ERR_PIN_LOGICALLY_UNINSTALLED==lRet)
        {
            LogM("==>Leave PinPadClassImpl::DevOpen():RemoveInstallAuthen=%d", lRet);
            return SaveErrorInfo(lRet);
        }
        if (STATUS_SUCCESS==lRet && PIN_REMOVE == m_cfgSP.byRemoveInstall)
        {
            LogM("==>Leave PinPadClassImpl::DevOpen():AuthRemove OK");
            return Error_Succeed;
        }
        //软复位？

        m_bNeedInitialization = FALSE;
        if (ZT598M1FD_DevCtrl->AuthenticateAllKeys(FALSE, m_LPPinpadStatus) == FALSE)
        {
            m_bNeedInitialization = TRUE;
            ZT598M1FD_DevCtrl->DevReset(PIN_HARD_RESET_ALL, m_LPPinpadStatus);
        }
    }
    //ZT598M1FD_DevCtrl->DevReset(PIN_HARD_RESET_ALL, m_LPPinpadStatus);
    m_bDevOpen = TRUE;
    LogM("==>Leave PinPadClassImpl::DevOpen() return Error_Succeed");
    return Error_Succeed;
}

ErrorCodeEnum PinPadClassImpl::KeyRead(BYTE &ch)
{
    LOG_FUNCTION();
    LONG lRet = STATUS_SUCCESS;
    LogM("<==Enter PinPadClassImpl::KeyRead()");
    ErrorCodeEnum ret = Error_Succeed;
    LogM("KeyRead():");
    BYTE byData[9] = {0};
    DWORD dwDataLen = sizeof(byData);
    BYTE byCurrentChar = 0;
    DWORD dwCoveredDataSize = 0;
    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        goto END_LABEL;
    }

    dwDataLen = ZT598M1FD_DevCtrl->ReadEntryText(byData, sizeof(byData));
    //if ReadEntryText= success
    {
        if (dwDataLen > 0)
        {
           LogM("PinPad input:%s; len:%d", byData, dwDataLen);
        }
        dwCoveredDataSize = m_pinpadReadData.dwSize % MAX_PIN_READ_SIZE;
        if (dwCoveredDataSize + dwDataLen > MAX_PIN_READ_SIZE)//缓冲区将要溢兿
        {
            memcpy(m_pinpadReadData.data + dwCoveredDataSize, byData, MAX_PIN_READ_SIZE - dwCoveredDataSize);//填满缓冲区尾避
           LogM("m_pinpadReadData.data buffer full!");
            memcpy(m_pinpadReadData.data, byData + MAX_PIN_READ_SIZE - dwCoveredDataSize, dwDataLen - (MAX_PIN_READ_SIZE - dwCoveredDataSize));	//剩余数据复写到缓冲区墿
        }
        else
        {
            memcpy(m_pinpadReadData.data + dwCoveredDataSize, byData, dwDataLen);
        }
        m_pinpadReadData.dwSize += dwDataLen;
        if (m_pinpadReadData.dwSize - m_pinpadReadData.dwCurrentRead > MAX_PIN_READ_SIZE)
        {
            LogM("Error! Data is covered!");
        }

        if (m_nCurrentEntryMode == PIN_ENTRY)
        {
            LogM("==>Leave PinPadClassImpl::KeyRead()");
            return PinRead(ch);
        }

        if (m_pinpadReadData.dwCurrentRead + 1 <= m_pinpadReadData.dwSize && m_nCurrentEntryMode == TEXT_ENTRY)
        {
            byCurrentChar = m_pinpadReadData.data[m_pinpadReadData.dwCurrentRead % MAX_PIN_READ_SIZE];
            m_pinpadReadData.dwCurrentRead++;
            if (0x30 <= byCurrentChar && byCurrentChar <= 0x39 ||
                byCurrentChar == 0x2e ||	//'.'
                byCurrentChar == 0x4f ||	//'00'
                byCurrentChar == 0x20 ||	//空白钿
                byCurrentChar == 0x1b ||	//cancel
                byCurrentChar == 0x08 ||	//clear
                byCurrentChar == 0x0d )		//confirm
            {
                ch = byCurrentChar;
                //sensitive info
                LogM("KeyRead: return char:%c(0x%02X)", ch, ch);
                LogM("pinpadReadData.data:%s pinpadReadData.dwSize:%d pinpadReadData.dwCurrentRead:%d", m_pinpadReadData.data, m_pinpadReadData.dwSize, m_pinpadReadData.dwCurrentRead);
                return Error_Succeed;
            }
            else
            {
                //special char
                LogM("KeyRead: return special char:%c(0x%02X) ", byCurrentChar, byCurrentChar);
                switch (byCurrentChar)
                {
                case 0x80:
                    ret = SaveErrorInfo(ERR_PIN_PRESS_KEY_OVERTIME);
                    break;
                case 0x82:
                default:
                    ret = SaveErrorInfo(ERR_PIN_KEY_CODE_NOT_FOUND);
                    break;
                }
                return ret;
            }

        }
        else
        {
            ret = Error_DevCommFailed;
            LogM("No Key Input!!!!");
            LogM("==>Leave PinPadClassImpl::KeyRead()");
            return Error_DevCommFailed;
        }
    }
    /*
    else
    {
        SaveErrorInfo(lRet);
        return Error_DevNotAvailable;
    }
    */
END_LABEL:
    LogM("<==Leave PinPadClassImpl::KeyRead()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::PinRead(BYTE &ch)
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::PinRead()");

    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;

    BYTE byCurrentChar = 0;
	DWORD i = 0;
    BYTE byData[9] = {0};
    DWORD dwDataLen = sizeof(byData);
	
	if (m_pinpadReadData.dwCurrentRead < m_pinpadReadData.dwSize && m_nCurrentEntryMode == PIN_ENTRY)
	{
		byCurrentChar = m_pinpadReadData.data[m_pinpadReadData.dwCurrentRead];
		m_pinpadReadData.dwCurrentRead++;
		if (byCurrentChar == 0x00)//数字钿
		{
			m_nCurrentPinLen++;
			if (m_nCurrentPinLen < m_nMaxPinLen)
			{
				ch = 0x3f;
			}
			else if (m_nCurrentPinLen == m_nMaxPinLen)
			{
				ch = 0x3f;
				if (!m_bConfirm)//bconfirm == false,应该结束输入不需要等待按确认钿
				{
					for (i = m_pinpadReadData.dwCurrentRead; i < m_pinpadReadData.dwSize; i++)
					{
						byCurrentChar = m_pinpadReadData.data[m_pinpadReadData.dwCurrentRead];
						m_pinpadReadData.dwCurrentRead++;
						if (byCurrentChar == 0x00)
						{
                            ZT598M1FD_DevCtrl->DelEntryPinKey(DELETE_LAST_ENTERED, m_LPPinpadStatus);
						}
					}
                    lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
                    //lRet = ZT598M1FD_DevCtrl->SetControlMode(CONTROL_MODE_SBS, eBeep);  //close sound
                    m_nCurrentEntryMode = CLOSE_ENTRY;
				}
			}
			else//超过最大输入长帿
			{
                lRet = ZT598M1FD_DevCtrl->DelEntryPinKey(DELETE_LAST_ENTERED, m_LPPinpadStatus);
				m_nCurrentPinLen = m_nMaxPinLen;
                LogM("Exceed the maximum length.");
                ret = SaveErrorInfo(STATUS_INVALID_PIN_LENGTH);
                goto END_LABEL;
			}
		}
		else if (byCurrentChar == 0x1B || byCurrentChar == 0x08)//取消Cancel || 清除Clear(BackSpace)
		{
			ch  = byCurrentChar;
			for (i = 0; i < (DWORD)m_nCurrentPinLen; i++)
			{
                ZT598M1FD_DevCtrl->DelEntryPinKey(DELETE_LAST_ENTERED, m_LPPinpadStatus);
			}
			m_nCurrentPinLen = 0;
		}
		else if (byCurrentChar == 0x0D || byCurrentChar == 0x2A) //确认Enter
		{
			ch  = byCurrentChar;
			if (m_bConfirm)
			{
				for (i = m_pinpadReadData.dwCurrentRead; i < m_pinpadReadData.dwSize; i++)
				{
					byCurrentChar = m_pinpadReadData.data[m_pinpadReadData.dwCurrentRead];
					m_pinpadReadData.dwCurrentRead++;
					if (byCurrentChar == 0x00)
					{
                        ZT598M1FD_DevCtrl->DelEntryPinKey(DELETE_LAST_ENTERED, m_LPPinpadStatus);
                    }
				}
                lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
                //lRet = ZT598M1FD_DevCtrl->SetControlMode(CONTROL_MODE_SBS, eBeep);  //close sound
                m_nCurrentEntryMode = CLOSE_ENTRY;
            }
		}
		else if (byCurrentChar == 0x2e || byCurrentChar == 0x4f)//'.' || '00'
		{
			ch = 0x3d;
		}
		else
		{
			//special char
            LogM("KeyRead: return special char:%c(0x%02X) ", byCurrentChar, byCurrentChar);
			switch (byCurrentChar)
			{
			case 0x80:
                ret = SaveErrorInfo(ERR_PIN_PRESS_KEY_OVERTIME);
				break;
			case 0x81:
				if (m_nCurrentPinLen == 0)
				{
                    ret = SaveErrorInfo(ERR_PIN_TIMEOUT);
                    //SaveErrorInfo("等待按键输入超时", DEC_PRESS_KEY_TIMEOUT);
				}
				else
				{
                    ret = SaveErrorInfo(ERR_PIN_TIMEOUT);
                    //SaveErrorInfo("两次按键间隔时间超时", DEC_PRESS_KEY_INTERVAL_TIMEOUT);
				}
				break;
			default:
                ret = SaveErrorInfo(ERR_PIN_KEY_CODE_NOT_FOUND);
				break;
			}
            goto END_LABEL;
		}
		//sensitive info
        LogM("PinRead: return char:%c(0x%02X)", ch, ch);
        LogM("pinpadReadData.dwSize:%d pinpadReadData.dwCurrentRead:%d", m_pinpadReadData.dwSize, m_pinpadReadData.dwCurrentRead);
        goto END_LABEL;
	}
	else
	{
		//no key pressed
        ret = SaveErrorInfo(STATUS_PIN_NOPIN);
        goto END_LABEL;
	}
END_LABEL:
    LogM("<==Leave PinPadClassImpl::PinRead() return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::StartPinInputCommon(BYTE byLen)
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::StartPinInputCommon()");
    LogM("byLen=%d", byLen);

    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    BYTE byData[9] = {0};
    DWORD dwDataLen = 0;
    BYTE byTextBufer[256] = {0};
    int iConfirm = m_bConfirm ? 1 : 0;
    BOOL bBeep = m_nCurrentEntryMode == TEXT_ENTRY? m_cfgSP.bGetDataBeep:m_cfgSP.bGetPinBeep;
    ControlCodeBeep eBeep = bBeep?OPEN_BEEP_SOUND:CLOSE_BEEP_SOUND;

    if(!m_bDevOpen)
    {
        lRet = ERR_PIN_DEVNOTOPEN;
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }

    LogM("StartInput Mode: %s", m_nCurrentEntryMode == PIN_ENTRY ? "ENTRY_MODE_PIN" : m_nCurrentEntryMode == TEXT_ENTRY? "ENTRY_MODE_TEXT" : "ENTRY_MODE_ELSE");
    if (m_nCurrentEntryMode != TEXT_ENTRY && byLen == 0)
    {
        lRet = ERR_PARAM_ERROR;
        goto END_LABEL;
    }
    m_nCurrentPinLen = 0;
    m_nMaxPinLen = byLen;
    m_pinpadReadData.dwSize = 0;
    m_pinpadReadData.dwCurrentRead = 0;
    memset(m_pinpadReadData.data, 0x00, MAX_PIN_READ_SIZE);
    //清除缓冲势
    lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
    lRet = ZT598M1FD_DevCtrl->ReadEntryText(byTextBufer, sizeof(byTextBufer));

    lRet = ZT598M1FD_DevCtrl->SetControlMode(CONTROL_MODE_SBS, eBeep);

    lRet = ZT598M1FD_DevCtrl->SetEntryMode(m_nCurrentEntryMode, 0x0000, 0x0000);
    //lRet = ZT598M1FD_DevCtrl->ReadEntryText(byTextBufer, sizeof(byTextBufer));
    //lRet = ZT598M1FD_DevCtrl->ReadEntryText(byTextBufer, sizeof(byTextBufer));
END_LABEL:
    ret = SaveErrorInfo(lRet);
    LogM("<==Leave PinPadClassImpl::StartPinInputCommon()return %d", ret);
    return ret;
}
ErrorCodeEnum PinPadClassImpl::StartPinInput(BYTE byLen)
{
    LogM("==>Enter PinPadClassImpl::StartPinInput()");
    LogM("byLen=%d", byLen);

    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    m_bConfirm = FALSE;
    m_nCurrentEntryMode = PIN_ENTRY;
    ret = StartPinInputCommon(byLen);
    LogM("<==Leave PinPadClassImpl::StartPinInput()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::StartPinInputConfirm(BYTE byLen)
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::StartPinInputConfirm()");
    LogM("byLen=%d", byLen);

    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    m_bConfirm = TRUE;
    m_nCurrentEntryMode = PIN_ENTRY;
    lRet = StartPinInputCommon(byLen);
    if(lRet != STATUS_SUCCESS)
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }
END_LABEL:
    LogM("<==Leave PinPadClassImpl::StartPinInputConfirm()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::StartPlainInput()
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::StartPlainInput()");
    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }
    m_nCurrentEntryMode = TEXT_ENTRY;
    lRet = StartPinInputCommon(0);
    if(lRet != STATUS_SUCCESS)
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }
END_LABEL:
    LogM("<==Leave PinPadClassImpl::StartPlainInput() return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::StopInput()
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::StopInput()");
    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }
    m_bConfirm = false;
    m_pinpadReadData.dwSize = 0;
    m_pinpadReadData.dwCurrentRead = 0;
    memset(m_pinpadReadData.data, 0x00, MAX_PIN_READ_SIZE);
    lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
    m_nCurrentEntryMode = CLOSE_ENTRY;
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }
END_LABEL:
    LogM("<==Leave PinPadClassImpl::StopInput()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::LoadMasterKey(MasterKeyParam masterKey)
{
    LOG_FUNCTION();
    ErrorCodeEnum ret = Error_Succeed;
    LogM("==>Enter PinPadClassImpl::LoadMasterKey()");
    LogM( "masterKey.smFlag=%d masterKey.dwSN=%d masterkey.keylength=%d", masterKey.smFlag, masterKey.dwSN, strlen((CHAR*)masterKey.key));

    LONG lRet = STATUS_SUCCESS;
    CHAR szKeyName[32] = {0};
    BOOL bSM = masterKey.smFlag;
    BYTE byValue[MAX_MASTER_KEY_SIZE / 2] = {0};

    //DevCtrl LoadKey Param
    WORD wKeyType = bSM? KEY_TYPE_SM4:KEY_TYPE_DES;
    LPSTR lpsKeyName = szKeyName;
    LPSTR lpsEncKeyName = NULL;
    DWORD dwUse = 0;
    LPBYTE lpbKeyData = byValue;
    USHORT usKeyLength = 0;
    WORD wKeyCheckMode = PIN_KCVNONE;
    LPBYTE lpbKCVData = NULL;
    USHORT usKCVLength = 0;
    BYTE byKCV[SHORT_BUFF_SIZE_3] = {0};
    WORD wKCVLen = sizeof(byKCV);

    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }
    if (masterKey.smFlag > 1 || masterKey.smFlag < 0)
    {
        ret = SaveErrorInfo(ERR_PARAM_ERROR);
        LogM("PinPad:masterkey.smFlag is invalid param");
        return Error_Param;
    }

    //keyName
    sprintf(szKeyName, "%s%s%d", bSM? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, MASTER_KEY_NAEM_LABEL, masterKey.dwSN);
    //KeyValue
    usKeyLength = CDataConvert::StringToHex((CHAR*)masterKey.key, sizeof(masterKey.key), byValue, sizeof(byValue));
    //KeyUse
    dwUse = ATTR_MK /*| (bSM ? ATTR_SM4 : 0)*/;
    lRet = ZT598M1FD_DevCtrl->LoadKey(wKeyType, lpsKeyName, dwUse, lpbKeyData, usKeyLength,
        wKeyCheckMode, lpsEncKeyName, lpbKCVData, usKCVLength, byKCV, wKCVLen, m_LPPinpadStatus);
    if(lRet != STATUS_SUCCESS)
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }

END_LABEL:
    LogM("<==Leave PinPadClassImpl::LoadMasterKey()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::LoadWorkingKey(WorkKeyParam wkKey)
{
    LOG_FUNCTION();
    ErrorCodeEnum ret = Error_Succeed;
    LogM("==>Enter PinPadClassImpl::LoadWorkingKey()");
    LogM( "wkKey.smFlag=%d wkKey.dwWorkingSN=%d wkKey.dwMasterSN=%d swkKey.keylength=%d", wkKey.smFlag, wkKey.dwWorkingSN, wkKey.dwMasterSN, strlen((CHAR*)wkKey.key));

    LONG lRet = STATUS_SUCCESS;
    CHAR szKeyName[32] = {0};
    CHAR szEncKeyName[32] = {0};
    BOOL bSM = wkKey.smFlag;
    BYTE byValue[MAX_WORKING_KEY_SIZE/ 2] = {0};

    //DevCtrl LoadKey Param
    WORD wKeyType = bSM? KEY_TYPE_SM4:KEY_TYPE_DES;
    LPSTR lpsKeyName = szKeyName;
    LPSTR lpsEncKeyName = szEncKeyName;
    DWORD dwUse = 0;
    LPBYTE lpbKeyData = byValue;
    USHORT usKeyLength = 0;
    WORD wKeyCheckMode = PIN_KCVNONE;
    LPBYTE lpbKCVData = NULL;
    USHORT usKCVLength = 0;
    BYTE byKCV[SHORT_BUFF_SIZE_3] = {0};
    WORD wKCVLen = sizeof(byKCV);

    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }

    if (wkKey.smFlag > 1 || wkKey.smFlag < 0)
    {
        ret = SaveErrorInfo(ERR_PARAM_ERROR);
        LogM("PinPad:wkKey.smFlag is invalid param");
        return Error_Param;
    }

    //keyName
    sprintf(szKeyName, "%s%s%d", bSM? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, WORKING_KEY_NAEM_LABEL, wkKey.dwWorkingSN);
    sprintf(szEncKeyName, "%s%s%d", bSM? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, MASTER_KEY_NAEM_LABEL, wkKey.dwMasterSN);

    //KeyValue
    usKeyLength = CDataConvert::StringToHex((CHAR*)wkKey.key, sizeof(wkKey.key), byValue, sizeof(byValue));
    //KeyUse
    dwUse = ATTR_DK | ATTR_PK | ATTR_AK /*| (bSM ? ATTR_SM4 : 0)*/;
    lRet = ZT598M1FD_DevCtrl->LoadKey(wKeyType, lpsKeyName, dwUse, lpbKeyData, usKeyLength,
        wKeyCheckMode, lpsEncKeyName, lpbKCVData, usKCVLength, byKCV, wKCVLen, m_LPPinpadStatus);
    if(lRet != STATUS_SUCCESS)
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }

END_LABEL:
    LogM("<==Leave PinPadClassImpl::LoadWorkingKey()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::ActiveWorkingKey(DWORD dwMkSN, DWORD dwWkSN)
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::ActiveWorkingKey()");
    LogM( "Active: dwMkSN=%d dwWkSN=%d", dwMkSN, dwWkSN);
    m_dwMasterKeySN = dwMkSN;
    m_dwWorkingKeySN = dwWkSN;
    LogM("<==Leave PinPadClassImpl::ActiveWorkingKey()return Error_Succeed");
    return Error_Succeed;
}

ErrorCodeEnum PinPadClassImpl::SetParam(SetParamTypeEnum eType, SetParamValueEnum eValue)
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::SetParam()");
    LogM("eType=%d, eValue=%d", eType, eValue);
    switch (eType)
    {
    case EPP_PT_SET_ENCRYPT_METHOD:
        m_enumEncryptMethod = eValue;
        switch (m_enumEncryptMethod)
        {
        case EPP_ALGO_METHOD_DES:
            m_bSM = FALSE;
            if (m_enumEcbCbcMode == EPP_ALGO_MODE_ECB)
                //m_wCryptDataAlgorithm = PIN_CRYPTDESECB/*CRYPT_DESECB*/;
                m_wCryptDataAlgorithm = PIN_CRYPT_ECB;
            else if (m_enumEcbCbcMode == EPP_ALGO_MODE_CBC)
                //m_wCryptDataAlgorithm = PIN_CRYPTDESCBC;
                m_wCryptDataAlgorithm = PIN_CRYPT_CBC;
            break;
        case EPP_ALGO_METHOD_3DES:
            m_bSM = FALSE;
            if (m_enumEcbCbcMode == EPP_ALGO_MODE_ECB)
                //m_wCryptDataAlgorithm = PIN_CRYPTTRIDESECB;
                m_wCryptDataAlgorithm = PIN_CRYPT_ECB;
            else if (m_enumEcbCbcMode == EPP_ALGO_MODE_CBC)
                //m_wCryptDataAlgorithm = PIN_CRYPTTRIDESCBC;
                m_wCryptDataAlgorithm = PIN_CRYPT_CBC;
            break;
        case EPP_ALGO_METHOD_DES_TMK:
            m_bSM = FALSE;
            m_wCryptMacAlgorithm = PIN_CRYPTDESMAC;
            break;
        case EPP_ALGO_METHOD_3DES_TMK:
            m_wCryptMacAlgorithm = PIN_CRYPTTRIDESMAC;
            break;
        case EPP_ALGO_METHOD_SM4:
            m_bSM = TRUE;
            if (m_enumEcbCbcMode == EPP_ALGO_MODE_ECB)
                m_wCryptDataAlgorithm = PIN_CRYPTSM4ECB;
            else if (m_enumEcbCbcMode == EPP_ALGO_MODE_CBC)
                m_wCryptDataAlgorithm = PIN_CRYPTSM4CBC;
            break;
        default:
            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
            return Error_Param;
            break;
        }
        break;
    case EPP_PT_SET_MAC_ALGORITH:
        m_bSM = FALSE;
        m_enumMacAlgrithm = eValue;
        switch (m_enumMacAlgrithm)
        {
        case EPP_MAC_ALGO_ASNIX99:
            m_wMacMode = MAC_99;
            break;
        case EPP_MAC_ALGO_PBOC:
            if (m_enumEncryptMethod == EPP_ALGO_METHOD_SM4)
            {
                m_bSM = TRUE;
                m_wMacMode = /*SM4_*/MAC_PBOC;
            }
            else
            {
                m_wMacMode = MAC_PBOC;
            }
            break;
        case EPP_MAC_ALGO_UNIONPAY:
            if (m_enumEncryptMethod == EPP_ALGO_METHOD_SM4)
            {
                m_bSM = TRUE;
                m_wMacMode = /*SM4_*/MAC_UNION_PAY;
            }
            else
            {
                m_wMacMode = MAC_UNION_PAY;
            }
            break;
        default:
            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
            return Error_Param;
            break;
        }
        break;
    case EPP_PT_SET_PIN_ALGORITH:
        m_enumPinAlgrithm = eValue;
        switch (m_enumPinAlgrithm)
        {
        case EPP_PIN_ALGO_ISO9564_1_ANSI:
            m_bSM = FALSE;
            m_wPinFormat = PIN_FORMANSI;
            break;
        case EPP_PIN_ALGO_IBM3624:
            m_bSM = FALSE;
            m_wPinFormat = PIN_FORM3624;
            break;
        case EPP_PIN_ALGO_SM4:
            m_bSM = TRUE;
            m_wPinFormat = PIN_FORMISO0;  //TODO:WFS_PIN_FORMANSI or WFS_PIN_FORMISO0?
            break;
        default:
            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
            return Error_Param;
            break;
        }
        break;
    case EPP_PT_SET_ECB_CBC_MODE:
        m_enumEcbCbcMode = eValue;
        switch (m_enumEcbCbcMode)
        {
        case EPP_ALGO_MODE_DEC_ECB:
        case EPP_ALGO_MODE_3DEC_ECB:
        case EPP_ALGO_MODE_ECB:
            m_enumEcbCbcMode = EPP_ALGO_MODE_ECB;
            m_wCryptDataAlgorithm = PIN_CRYPT_ECB;
            break;
        case EPP_ALGO_MODE_DEC_CBC:
        case EPP_ALGO_MODE_3DEC_CBC:
        case EPP_ALGO_MODE_CBC:
            m_enumEcbCbcMode = EPP_ALGO_MODE_CBC;
            m_wCryptDataAlgorithm = PIN_CRYPT_CBC;
            break;
        default:
            SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
            return Error_Param;
            break;
        }
        break;
    default:
        SaveErrorInfo(STATUS_INVALID_DATA_SPECIFIED);
        return Error_Param;
        break;
    }
    switch(m_wCryptMacAlgorithm)
    {
    case PIN_CRYPTTRIDESMAC:
    case PIN_CRYPTTRIDESCBC:
    case PIN_CRYPTTRIDESECB:
        m_byPattern = PIN_CRYPT_TDES;
        break;
    case PIN_CRYPTDESCBC:
    case PIN_CRYPTDESECB:
    case PIN_CRYPTDESMAC:
        m_byPattern = PIN_CRYPT_DES;
        break;
    default:
        m_byPattern = PIN_CRYPT_TDES;
        break;
    }
    LogM("==>Leave PinPadClassImpl::SetParam()return Error_Succeed");
    return Error_Succeed;
}

ErrorCodeEnum PinPadClassImpl::EncryptData(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo)
{ 
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::EncryptData()");
    ErrorCodeEnum ret = EncryptCommon(srcInfo, destInfo);
    LogM("==>Leave PinPadClassImpl::EncryptData()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::MacEncrypt(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo)
{
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::MacEncrypt()");
    ErrorCodeEnum ret = EncryptCommon(srcInfo, destInfo, TRUE);
    LogM("==>Leave PinPadClassImpl::MacEncrypt()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::GetPinBlock(PinBlock &block)
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::GetPinBlock()");
    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;

    WORD wKeyType = m_bSM? KEY_TYPE_SM4:KEY_TYPE_DES;
    CHAR szKeyName[32] = {0};
    LPSTR lpsKeyName =szKeyName;
    WORD wFormat = PIN_FORM3624;
    BYTE byPadding = 0x0F;
    LPSTR lpsXORData = NULL;
    LPSTR lpsEncKeyName = NULL;
    BYTE byResult[SHORT_BUFF_SIZE_3] = {0};
    WORD wResultLen = sizeof(byResult);

    //GetPinBlock(wKeyType, lpsKeyName, wFormat, byPadding, (LPCTSTR)byCustomerData, lpsXORData,
    //lpsEncKeyName, byResult, wResultLen, &m_stEPPCtrl.devStatus);

    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }
    lRet = ZT598M1FD_DevCtrl->SetEntryMode(CLOSE_ENTRY, 0xFFFF, 0xFFFF);
    if (sizeof(block.data) == 0 || block.data == NULL)
    {
        ret = SaveErrorInfo(ERR_PIN_INVALIDDATA);
        return Error_Param;
    }
    sprintf(szKeyName, "%s%s%d", m_bSM ? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, WORKING_KEY_NAEM_LABEL, m_dwWorkingKeySN);
    wFormat = m_wPinFormat;
    lRet = ZT598M1FD_DevCtrl->GetPinBlock(wKeyType, lpsKeyName, wFormat, byPadding, m_wPinFormat == PIN_FORM3624 ? NULL : (LPCTSTR)m_accountInfo.account, lpsXORData,
           lpsEncKeyName, byResult, wResultLen, m_LPPinpadStatus);
    if(lRet != STATUS_SUCCESS)
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }
    block.dwSize = CDataConvert::HexToString(byResult, wResultLen, (CHAR*)block.data, sizeof(block.data));

END_LABEL:
    LogM("<==Leave PinPadClassImpl::GetPinBlock()return %d", ret);
    return ret;
}

ErrorCodeEnum PinPadClassImpl::SetAccNo(AccountInfo accInfo)
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::SetAccNo():%s", accInfo.account);
    if (accInfo.dwAccLen == 0 || accInfo.dwAccLen >= MAX_ACCOUNT_LEN)
    {
        SaveErrorInfo(ERR_PIN_INVALIDCUSTOMERDATA);
        return Error_Param;
    }
    //sensitive info
    memcpy(m_accountInfo.account, accInfo.account, MAX_ACCOUNT_LEN);
    m_accountInfo.dwAccLen = accInfo.dwAccLen;
    LogM("<==Leave PinPadClassImpl::SetAccNo()return Error_Succeed");
    return Error_Succeed;
}

int PinPadClassImpl::GetEncryptFunc()
{
    LOG_FUNCTION();
    LogM("==>Enter PinPadClassImpl::GetEncryptFunc()");
    LogM("<==Leave PinPadClassImpl::GetEncryptFunc()return 0x03");
    return 0x03;
}

BOOL PinPadClassImpl::ReadPinpadConfig(/*LPCTSTR lpszSPIniPath,*/
    LPPinpadDevConfig lpDevConfig, LPPinpadSPConfig lpSPConfig)
{
    LOG_FUNCTION();
    CHAR szPath[MAX_PATH] = {0};
    CHAR szTemp[MAX_PATH] = {0};
    CHAR szKeyCode[MID_BUFF_SIZE_3] = {0};

    if (CFileDir::GetFilePathName(
            getpid(), INI_ADAPTER_PATH, INI_ADAPTER_FILENAME,
            m_sIniPath, sizeof(m_sIniPath)) == FALSE)
    {
        return FALSE;
    }
    if ((m_sIniPath == NULL) || (strlen(m_sIniPath) == 0) ||
        ((lpDevConfig == NULL) && (lpSPConfig == NULL)))
    {
        return FALSE;
    }

    Dl_info path_info;
    dladdr("LoadSDKDll",&path_info);
    char str_FilePath1[256]{0};
    char str_FilePath2[256]{0};
    char *a="/keba/DesKeyMap.dat";
    char *b="/keba/SM4KeyMap.dat";
    memcpy(str_FilePath1,path_info.dli_fname,strlen(path_info.dli_fname));
    memcpy(str_FilePath2,path_info.dli_fname,strlen(path_info.dli_fname));
    char *pLastSlath1=strrchr(str_FilePath1,'/');
    char *pLastSlath2=strrchr(str_FilePath2,'/');
    *pLastSlath1=0;
    *pLastSlath2=0;
    strncat(str_FilePath1,a,strlen(a));
    strncat(str_FilePath2,b,strlen(b));
    memcpy(lpDevConfig->sDESKeyIndexFilePath, str_FilePath1, strlen(str_FilePath1));
    memcpy(lpDevConfig->sSM4KeyIndexFilePath, str_FilePath2, strlen(str_FilePath2));

    //memcpy(lpDevConfig->sDESKeyIndexFilePath, "/home/keba/CBPM.ADAPTER/keba/assets/DesKeyMap.dat", sizeof("/home/keba/CBPM.ADAPTER/keba/assets/DesKeyMap.dat"));
    //memcpy(lpDevConfig->sSM4KeyIndexFilePath, "/home/keba/CBPM.ADAPTER/keba/assets/SM4KeyMap.dat", sizeof("/home/keba/CBPM.ADAPTER/keba/assets/SM4KeyMap.dat"));
    lpDevConfig->bKeyIndexFileSaveToEPP = FALSE;
    lpDevConfig->byRemoveInstall = AUTH_INSTALL;
    memcpy(szKeyCode, "3132331B00000000343536080000000037383920000000002E304F0D00000000", sizeof("3132331B00000000343536080000000037383920000000002E304F0D00000000"));
    CDataConvert::StringToHex(szKeyCode, sizeof(szKeyCode), (LPBYTE)lpDevConfig->byKeyCodeMatrix, sizeof(lpDevConfig->byKeyCodeMatrix));
    lpDevConfig->byHWDESKCVMaxLen = 3;
    lpDevConfig->byKCVLength = 8;
    lpDevConfig->byBeepLength = 0x10;
    //lpSPConfig
    lpSPConfig->byRemoveInstall = PIN_INSTALL;
    lpSPConfig->bGetPinBeep = TRUE;
    lpSPConfig->bGetDataBeep = TRUE;


    return TRUE;
}

ErrorCodeEnum PinPadClassImpl::EncryptCommon(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo, bool bMac)
{
    //todo: deal with byIV
    LOG_FUNCTION();
    LogM("<==Enter PinPadClassImpl::EncryptCommon()");
    ErrorCodeEnum ret = Error_Succeed;
    LONG lRet = STATUS_SUCCESS;
    DWORD dwMaxMacDataSize = 0, dwMaxCryptDataSize = 0;
    LPBYTE lpbyResult = NULL;
    ULONGLONG ullDataUnit1 = 0, ullDataUnit2 = 0;
    int i = 0, j = 0;
    BYTE byIV[SHORT_BUFF_SIZE_3] = {0};

    WORD wKeyType = m_bSM? KEY_TYPE_SM4:KEY_TYPE_DES;
    CHAR szKeyName[32] = {0};
    WORD wMode = PIN_MODEENCRYPT;
    BYTE byAlgorithmECBCBC = m_wCryptDataAlgorithm;
    BYTE byPattern = m_byPattern;
    LPBYTE lpbyTempResult = NULL;
    USHORT usCryptDataLen = srcInfo.dwSize/2;
    WORD wTempResultLen = 0;
    LPBYTE lpbyCryptData = new BYTE[usCryptDataLen];
    BYTE byPadding = 0x00;
    LPBYTE lpbyIV = byIV;
    WORD wIVLen = 0;
    WORD wGroupLength = 0;
    LPSTR lpszStartValueKey = NULL;
    LPBYTE lpbyTempCryptData = NULL;
    WORD wTempCryptDataLen = 0;
    WORD wResultLen = 0;


    if(!m_bDevOpen)
    {
        ret = SaveErrorInfo(ERR_PIN_DEVNOTOPEN);
        LogM("PinPad:Device not open");
        goto END_LABEL;
    }
    if (srcInfo.dwSize == 0 || srcInfo.dwSize > MAX_EN_DECRYPT_DATA_SIZE)
    {
        ret = SaveErrorInfo(ERR_PIN_INVALIDDATA);
        return Error_Param;
    }

    //todo: need initialization\wKeyState\pin access denied

    sprintf(szKeyName, "%s%s%d", m_bSM ? SM_KEY_NAME_PREFIX : DES_KEY_NAME_PREFIX, WORKING_KEY_NAEM_LABEL, m_dwWorkingKeySN);
    if((srcInfo.dwSize == 0) || (srcInfo.dwSize != strlen((CHAR*)srcInfo.data)))
    {
            ret = SaveErrorInfo(ERR_PIN_INVALIDDATA);
            return Error_Param;
    }
    if (wKeyType == KEY_TYPE_DES)
    {
        dwMaxMacDataSize = ZT598M1FD_DevCtrl->m_stDevCap.dwMaxDESMacDataSize;  //todo
        dwMaxCryptDataSize = ZT598M1FD_DevCtrl->m_stDevCap.dwMaxDESCryptDataSize;
    }
    else if (wKeyType == KEY_TYPE_SM4)
    {
        dwMaxMacDataSize = ZT598M1FD_DevCtrl->m_stDevCap.dwMaxSM4MacDataSize;
        dwMaxCryptDataSize = ZT598M1FD_DevCtrl->m_stDevCap.dwMaxSM4CryptDataSize;
    }
    else
    {
        dwMaxMacDataSize = 0;
        dwMaxCryptDataSize = 256;
    }
    CDataConvert::StringToHex((CHAR*)srcInfo.data, srcInfo.dwSize, lpbyCryptData, usCryptDataLen);
    if(bMac)
    {
        lpbyResult = new BYTE[SHORT_BUFF_SIZE_3];
        lpbyTempCryptData = new BYTE[dwMaxMacDataSize];
        lpbyTempResult = new BYTE[SHORT_BUFF_SIZE_3];
        memset(lpbyResult, 0x00, SHORT_BUFF_SIZE_3);
        for (i = 0; i < (int)((usCryptDataLen - 1) / dwMaxMacDataSize + 1); i++)
        {
            memset(lpbyTempCryptData, 0x00, dwMaxMacDataSize);

            if (i == (int)((usCryptDataLen - 1) / dwMaxMacDataSize))
            {
                wTempCryptDataLen = usCryptDataLen % dwMaxMacDataSize;
                if (wTempCryptDataLen == 0)
                {
                    wTempCryptDataLen = (WORD)dwMaxMacDataSize;
                }
            }
            else
            {
                wTempCryptDataLen = (WORD)dwMaxMacDataSize;
            }
            memcpy(lpbyTempCryptData, lpbyCryptData + dwMaxMacDataSize * i, wTempCryptDataLen);
            if (i == 0)
            {
                lpszStartValueKey = NULL;
                wIVLen = 0;
                lpbyIV = byIV;
            }
            else
            {
                lpszStartValueKey = NULL;
                wIVLen = (wKeyType == KEY_TYPE_SM4) ? SM4_DATA_GROUP_LENGTH : DES_DATA_GROUP_LENGTH;
                memcpy(byIV, lpbyTempResult, wIVLen);
                memset(lpbyTempResult, 0x00, SHORT_BUFF_SIZE_3);
                if ((wKeyType == KEY_TYPE_DES) && (m_wMacMode == MAC_UNION_PAY))
                //if ((wKeyType == KEY_TYPE_DES) && (m_wMacMode == PIN_MAC_UNIONPAY))
                {
                    while (wTempCryptDataLen < DES_DATA_GROUP_LENGTH)
                    {
                        *(lpbyTempCryptData + wTempCryptDataLen) = byPadding;
                        wTempCryptDataLen++;
                    }
                    memcpy(&ullDataUnit2, lpbyTempCryptData, sizeof(ullDataUnit2));
                    ullDataUnit1 ^= ullDataUnit2;
                    memcpy(lpbyTempCryptData, &ullDataUnit1, sizeof(ullDataUnit1));
                }
            }

            if (wKeyType == KEY_TYPE_DES)
            {
                if (i == (int)((usCryptDataLen - 1) / dwMaxMacDataSize))
                {
                    //byAlgorithmMac = (wKeyType == KEY_TYPE_SM4) ? m_cfgSP.bySM4AlgorithmMac : m_cfgSP.byAlgorithmMac;
                    //byAlgorithmMac = m_wMacMode;
                }
                else
                {
                    if(m_wMacMode == PIN_MAC_UNIONPAY)
                    {
                        ullDataUnit1 = 0;
                        for (j = 0; j < (int)(dwMaxMacDataSize / 8); j++)
                        {
                            memcpy(&ullDataUnit2, lpbyTempCryptData + 8 * j, sizeof(ullDataUnit2));
                            ullDataUnit1 ^= ullDataUnit2;
                        }
                        memcpy(lpbyTempResult, &ullDataUnit1, sizeof(ullDataUnit1));
                        continue;
                    }
                }
            }
            else if (wKeyType == KEY_TYPE_SM4)
            {
                //byAlgorithmMac = (wKeyType == KEY_TYPE_SM4) ? m_cfgSP.bySM4AlgorithmMac : m_cfgSP.byAlgorithmMac;
            }
            wTempResultLen = SHORT_BUFF_SIZE_3;
            wResultLen = SHORT_BUFF_SIZE_3;
            lRet = ZT598M1FD_DevCtrl->CalcMac(wKeyType, szKeyName, m_wMacMode, lpbyTempCryptData, wTempCryptDataLen, byPadding,
                byIV, wIVLen, lpszStartValueKey, NULL, 0, lpbyTempResult, wTempResultLen, m_LPPinpadStatus);
            wResultLen = wTempResultLen;
            memcpy(lpbyResult, lpbyTempResult, wResultLen);
        }
     }
    else
    {
        if (wKeyType != KEY_TYPE_RSA)
        {
            lpbyResult = new BYTE[usCryptDataLen + SHORT_BUFF_SIZE_3];//可能有补码而且考虑兼容SM所乿+SHORT_BUFF_SIZE_3
            memset(lpbyResult, 0x00, usCryptDataLen + SHORT_BUFF_SIZE_3);
        }
        else
        {
            lpbyResult = new BYTE[usCryptDataLen + 256];//可能有补码而且考虑兼容SM所乿+SHORT_BUFF_SIZE_3
            memset(lpbyResult, 0x00, usCryptDataLen + 256);
        }
        lpbyTempCryptData = new BYTE[dwMaxCryptDataSize];
        lpbyTempResult = new BYTE[dwMaxCryptDataSize];
        if (wMode == PIN_MODEENCRYPT)
        {
            for (i = 0; i < (int)((usCryptDataLen - 1) / dwMaxCryptDataSize + 1); i++)
            {
                memset(lpbyTempCryptData, 0x00, dwMaxCryptDataSize);

                if (i == (int)((usCryptDataLen - 1) / dwMaxCryptDataSize))
                {
                    wTempCryptDataLen = usCryptDataLen % dwMaxCryptDataSize;
                    if (wTempCryptDataLen == 0)
                    {
                        wTempCryptDataLen = (WORD)dwMaxCryptDataSize;
                    }
                }
                else
                {
                    wTempCryptDataLen = (WORD)dwMaxCryptDataSize;
                }
                memcpy(lpbyTempCryptData, lpbyCryptData + dwMaxCryptDataSize * i, wTempCryptDataLen);
               if (byAlgorithmECBCBC == PIN_CRYPT_CBC)
                {
                   if (i == 0)
                   {
                       lpszStartValueKey = NULL;
                       wIVLen = 0;
                       memset(byIV, 0x00, sizeof(byIV));
                   }
                   else
                   {
                       lpszStartValueKey = NULL;
                       wIVLen = (wKeyType == KEY_TYPE_SM4) ? SM4_DATA_GROUP_LENGTH : DES_DATA_GROUP_LENGTH;
                       memcpy(byIV, lpbyTempResult + (dwMaxCryptDataSize - wIVLen), wIVLen);
                       memset(lpbyTempResult, 0x00, dwMaxCryptDataSize);
                   }
                }
               else
               {
                   wIVLen = 0;
                   lpszStartValueKey = NULL;
                   memset(byIV, 0x00, sizeof(byIV));
               }
                wTempResultLen = (WORD)dwMaxCryptDataSize;
                lRet = ZT598M1FD_DevCtrl->CryptData(wKeyType, szKeyName, wMode, byAlgorithmECBCBC, byPattern, lpbyTempCryptData, wTempCryptDataLen, byPadding,
                    byIV, wIVLen, lpszStartValueKey, NULL, 0, lpbyTempResult, wTempResultLen, m_LPPinpadStatus);
                wResultLen += wTempResultLen;
                memcpy(lpbyResult + dwMaxCryptDataSize * i, lpbyTempResult, wTempResultLen);
            }
        }
        else if (wMode == PIN_MODEDECRYPT)
        {
            for (i = (int)((usCryptDataLen - 1) / dwMaxCryptDataSize); i >= 0 ; i--)
            {
                memset(lpbyTempCryptData, 0x00, dwMaxCryptDataSize);
                memset(lpbyTempResult, 0x00, dwMaxCryptDataSize);

                if (i == (int)((usCryptDataLen - 1) / dwMaxCryptDataSize))
                {
                    wTempCryptDataLen = usCryptDataLen % dwMaxCryptDataSize;
                    if (wTempCryptDataLen == 0)
                    {
                        wTempCryptDataLen = (WORD)dwMaxCryptDataSize;
                    }
                }
                else
                {
                    wTempCryptDataLen = (WORD)dwMaxCryptDataSize;
                }
                memcpy(lpbyTempCryptData, lpbyCryptData + dwMaxCryptDataSize * i, wTempCryptDataLen);
                if (wKeyType != KEY_TYPE_RSA)
                {
                    if (m_cfgSP.bStartValueUsingPos != FALSE)
                    {
                        //长度补齐
                        while (wTempCryptDataLen % 8 > 0 && wTempCryptDataLen < dwMaxCryptDataSize)
                        {
                            lpbyTempCryptData[wTempCryptDataLen] = byPadding;
                            wTempCryptDataLen++;
                        }
                    }
                    if (byAlgorithmECBCBC == PIN_CRYPT_CBC)
                    {
                        if (m_cfgSP.bStartValueUsingPos != FALSE)
                        {
                            wIVLen = 0;
                            lpszStartValueKey = NULL;
                            memset(byIV, 0x00, sizeof(byIV));
                            if (i == 0)
                            {
                                wIVLen = 0;
                                lpszStartValueKey = NULL;
                                memset(byIV, 0x00, sizeof(byIV));
                            }
                            else
                            {
                                lpszStartValueKey = NULL;
                                wIVLen = (wKeyType == KEY_TYPE_SM4) ? SM4_DATA_GROUP_LENGTH : DES_DATA_GROUP_LENGTH;
                                memcpy(byIV, lpbyCryptData + dwMaxCryptDataSize * (i - 1) + (dwMaxCryptDataSize - wIVLen), wIVLen);
                            }
                            if (i == (int)((usCryptDataLen - 1) / dwMaxCryptDataSize))
                            {
                                if (lpszStartValueKey != NULL)//lpCrypt->lpsStartValueKey不起作用
                                {
                                    wGroupLength = (wKeyType == KEY_TYPE_SM4) ? SM4_DATA_GROUP_LENGTH : DES_DATA_GROUP_LENGTH;
                                    for (j = 0; j < wGroupLength; j++)
                                    {
                                        lpbyTempCryptData[((usCryptDataLen - 1) % dwMaxCryptDataSize) / wGroupLength * wGroupLength + j] ^= lpszStartValueKey[j];
                                    }
                                }
                            }

                        }
                        else
                        {
                            if (i == 0)
                            {
                                lpszStartValueKey = NULL;
                                if (lpszStartValueKey != NULL )
                                {
                                    wIVLen = 0;
                                    memcpy(byIV, 0x00, sizeof(byIV));
                                }
                            }
                            else
                            {
                                lpszStartValueKey = NULL;
                                wIVLen = (wKeyType == KEY_TYPE_SM4) ? SM4_DATA_GROUP_LENGTH : DES_DATA_GROUP_LENGTH;
                                memcpy(byIV, lpbyCryptData + dwMaxCryptDataSize * (i - 1) + (dwMaxCryptDataSize - wIVLen), wIVLen);
                            }
                        }
                    }
                    else
                    {
                        wIVLen = 0;
                        lpszStartValueKey = NULL;
                        memset(byIV, 0x00, sizeof(byIV));
                    }
                }
                wTempResultLen = (WORD)dwMaxCryptDataSize;
                lRet = ZT598M1FD_DevCtrl->CryptData(wKeyType, szKeyName, wMode, byAlgorithmECBCBC, byPattern, lpbyTempCryptData, wTempCryptDataLen, byPadding,
                    byIV, wIVLen, lpszStartValueKey, NULL, 0, lpbyTempResult, wTempResultLen, m_LPPinpadStatus);
                wResultLen += wTempResultLen;
                memcpy(lpbyResult + dwMaxCryptDataSize * i, lpbyTempResult, wTempResultLen);
            }
        }
        else
        {}
    }
    if (lpbyTempCryptData != NULL)
    {
        delete[] lpbyTempCryptData;
    }
    if (lpbyTempResult != NULL)
    {
        delete[] lpbyTempResult;
    }
    if(lRet != STATUS_SUCCESS)
    {
        ret = SaveErrorInfo(lRet);
        goto END_LABEL;
    }
    destInfo.dwSize = CDataConvert::HexToString(lpbyResult, wResultLen, (CHAR*)destInfo.data, sizeof(destInfo.data));
    END_LABEL:
    LogM("==>Leave PinPadClassImpl::EncryptCommon()");
    return ret;
}
ErrorCodeEnum PinPadClassImpl::SaveErrorInfo(int iErrCode)
{
    LOG_FUNCTION();
    ErrorCodeEnum ret;
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    strcpy(m_szErrMsg, ZT598M1FD_DevCtrl->m_stPinpadStatus.sDescription);

    switch (iErrCode)
    {
    case STATUS_SUCCESS:
        m_shErrCode = DEC_SUCCESS;
        ret = Error_Succeed;
        break;
    case STATUS_INVALID_COMMAND_LENGTH:
    case ERR_COMMON_ERROR:
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case STATUS_INVALID_KEYID:
        m_shErrCode = DEC_INVALID_KEY_ID;
        ret = Error_Param;
        break;
    case STATUS_KEYID_NOT_EXIST:
        m_shErrCode = DEC_KEY_NOT_EXIST;
        ret = Error_Param;
        break;
    case STATUS_KEYID_LOCKED:
        m_shErrCode = DEC_KEY_LOCKED;
        ret = Error_Param;
        break;
    case STATUS_INVALID_WRITE_MODE:
    case STATUS_INVALID_IV_ATTRIBUTES:
    case STATUS_INVALID_KEY_ATTRIBUTES:
    case STATUS_KEY_ATTRIBUTES_NOT_MATCHED:
    case STATUS_KEY_USEVIOLATION:
    case STATUS_KEY_NOTALLOWED:
        m_shErrCode = DEC_E_KEY_LOST;
        ret = Error_Param;
        break;
    case STATUS_KCV_VERIFICATION_FAIL:
    case STATUS_INVALID_CHECK_MODE:
    case STATUS_INVALID_VERIFY_MODE:
        m_shErrCode = DEC_E_KCV_VERIFICATION;
        ret = Error_Param;
        break;
    case STATUS_INVALID_AUTHENTICATION_MODE:
        m_shErrCode = DEC_INVALID_AUTHENTICATION_MODE;
        ret = Error_Param;
        break;
    case STATUS_INVALID_MACING:
        m_shErrCode = DEC_INVALID_MAC;
        ret = Error_Param;
        break;
    case STATUS_INVALID_MODE:
        m_shErrCode = DEC_INVALID_MODE;
        ret = Error_Param;
        break;
    case STATUS_INVALID_DATA_SPECIFIED:
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case STATUS_INVALID_KEY_VALUE:
    case STATUS_KEY_INVALID:
        m_shErrCode = DEC_INVALID_KEY_VALUE;
        ret = Error_Param;
        break;
    case STATUS_INVALID_KEY_LENGTH:
    case STATUS_INVALID_LENGTH_OR_SUM:
        m_shErrCode = DEC_INVALID_KEY_LEN;
        ret = Error_Param;
        break;
    case STATUS_INVALID_OFFSET_LENGTH:
        m_shErrCode = DEC_INVALID_LENGTH;
        ret = Error_Param;
        break;
    case STATUS_INVALID_PIN_LENGTH:
    case STATUS_PIN_NOPIN:
    case STATUS_INVALID_PIN2_LENGTH:
        m_shErrCode = DEC_INVALID_PIN_LEN;
        ret = Error_Param;
        break;
    case STATUS_PIN_VERIFICATION_FAIL:
    case STATUS_PIN2_VERIFICATION_FAIL:
        m_shErrCode = DEC_VERIFICATION_FAILED;
        ret = Error_Param;
        break;
    case STATUS_PIN_ENCRYPTION_SUSPENDED:
        m_shErrCode = DEC_ENCRYPT_SUSPENDED;
        ret = Error_Param;
        break;
    case STATUS_INVALID_MODULUS_LENGTH:
    case ERR_PIN_INVALID_MOD_LEN:
        m_shErrCode = DEC_INVALID_MODULE_LEN;
        ret = Error_Param;
        break;
    case STATUS_INVALID_EXPONENT_LENGTH:
        m_shErrCode = DEC_INVALID_EXPONENT_LEN;
        ret = Error_Param;
        break;
    case STATUS_INVALID_PKCS_STRUCTURE:
    case STATUS_INVALID_PKCS_PADDING:
        m_shErrCode = DEC_INVALID_PKCS;
        ret = Error_Param;
        break;
    case STATUS_INVALID_SIGNATURE_LENGTH:
    case ERR_PIN_SIG_NOT_SUPP:
    case ERR_PIN_SIG_KEYNOTFOUND:
    case ERR_PIN_SIG_KEYUSEVIOLATION:

        m_shErrCode = DEC_INVALID_SIGNATURE;
        ret = Error_Param;
        break;
    case STATUS_SIGNATURE_VERIFICATION_FAIL:
        m_shErrCode = DEC_E_SIGNATURE_VERIFICATION;
        ret = Error_Param;
        break;
    case STATUS_KEY_NOT_LOADED:
        m_shErrCode = DEC_KEY_NOT_LOADED;
        ret = Error_Param;
        break;
    case STATUS_INVALID_CERTIFICATE_FROMAT:
    case STATUS_INVALID_CERTIFICATE_VERSION:
    case STATUS_INVALID_CERTIFICATE_VALIDITY:
    case STATUS_INVALID_CERTIFICATE_ISSUER:
    case STATUS_INVALID_CERTIFICATE_SUBJECT:
    case STATUS_INVALID_CERTIFICATE_ALGOR:
    case STATUS_CERTIFICATE_NOT_EXIST:
        m_shErrCode = DEC_INVALID_CERTIFICATE;
        ret = Error_Param;
        break;
    case STATUS_INVALID_DATA_DISABLEED:
        m_shErrCode = DEC_INVALID_DATA;
        ret = Error_Param;
        break;
    case STATUS_INVALID_USERBLOCK_ADDRESS:
        m_shErrCode = DEC_INVALID_USER_BLOCK_ADDR;
        ret = Error_Param;
        break;
    case STATUS_INVALID_SERIALNO_SPECIFIED:
        m_shErrCode = DEC_E_SERIAL_NUMBER;
        ret = Error_Param;
        break;
    case STATUS_NO_CARD:
    case STATUS_CARD_APDU_ERROR:
        m_shErrCode = DEC_E_SERIAL_NUMBER;
        ret = Error_Param;
        break;
    case STATUS_EMV_NOT_INITIALIZED:
    case STATUS_EPP_NOT_INITIALIZED:
    case ERR_PIN_NEED_INITIALIZATION:
        m_shErrCode = DEC_EPP_NOT_INITIALIZED;
        ret = Error_Param;
        break;
    case STATUS_EMV_NOT_READY:
        m_shErrCode = DEC_EMV_NOT_READY;
        ret = Error_Param;
        break;
    case STATUS_EMV_NEED_REINITIALIZE:
        m_shErrCode = DEC_EMV_NEED_REINITIALIZE;
        ret = Error_Param;
        break;
    case STATUS_EMV_TIMEOUT:
        m_shErrCode = DEC_EMV_TIMEOUT;
        ret = Error_Param;
        break;
    case STATUS_EMV_ALREADY_INITIALIZED:
        m_shErrCode = DEC_EMV_INIT_ALREADY;
        ret = Error_Param;
        break;
    case STATUS_ALGORITHMNOTSUPP:
        m_shErrCode = DEC_ALGORITHM_UNSUPPORTED;
        ret = Error_Param;
        break;
    case STATUS_COMMANDUPSUPP:
    case STATUS_SM2_ENCRYPT_FAILURE:
    case STATUS_SM2_DECRYPT_FAILURE:
    case STATUS_SM2_SIGNATURE_FAILURE:
    case STATUS_SM2_VERSIG_FAILURE:
    case STATUS_SM2_KEYEXC_FAILURE:
    case STATUS_SM2_VER_KEYEXC_FAILURE:
    case STATUS_FW_VERIFY_FIAL:
    case STATUS_FW_WRITE_FAIL:
    case STATUS_FW_EARSE_FAIL:
    case ERR_PIN_INVALID_FW_FILE:
        m_shErrCode = DEC_COMMAND_UNSUPPORTED;
        ret = Error_Param;
        break;
    case STATUS_ERROR_INTER_ERROR:
    case STATUS_MRAM_HARDWARE_ERROR:
    case STATUS_OTHER_ABNORMAL_ERROR:
    case ERR_INTERNAL_ERROR:
        m_shErrCode = DEC_HARDWARE;
        ret = Error_Hardware;
        break;
    case STATUS_COMMAND_LOCK:
        m_shErrCode = DEC_COMMAND_LOCKED;
        ret = Error_Hardware;
        break;
    case STATUS_INVALID_COMMAND_MAC:
        m_shErrCode = DEC_INVALID_MAC;
        ret = Error_Param;
        break;
    case STATUS_AUTHENTICATION_FAILED:
    case STATUS_NOT_AUTHENTE:
        m_shErrCode = DEC_EPP_NOT_AUTHORIZED;
        ret = Error_Param;
        break;
    case STATUS_EPP_ALREADY_INITIALIZED:
        m_shErrCode = DEC_EPP_INIT_ALREADY;
        ret = Error_Hardware;
        break;
    case STATUS_CERTIFICATE_ALREADY:
        m_shErrCode = DEC_EPP_CERTIFICATE_ALREADY;
        ret = Error_Hardware;
        break;
    case STATUS_PHYSICALLY_NOT_INSTALLED:
    case ERR_PIN_PHYSICALLY_UNINSTALLED:
        m_shErrCode = DEC_EPP_NOT_PHYSICALLY_INSTALLED;
        ret = Error_Hardware;
        break;
    case STATUS_LOGICALLY_NOT_INSTALLED:
    case ERR_PIN_LOGICALLY_UNINSTALLED:
        m_shErrCode = DEC_EPP_NOT_LOGICALLY_INSTALLED;
        ret = Error_Hardware;
        break;
    case STATUS_INPUT_KEY_TIMEOUT:
        m_shErrCode = DEC_PRESS_KEY_TIMEOUT;
        ret = Error_Param;
        break;
    case STATUS_INVLAID_PASSWORD_LENGTH:
        m_shErrCode = DEC_INVALID_PASSWORD_LEN;
        ret = Error_Hardware;
        break;
    case STATUS_INVALID_PASSWORD:
        m_shErrCode = DEC_INVALID_PASSWORD;
        ret = Error_Hardware;
        break;
    case STATUS_INPUT_PASSWORD_LOCKED:
        m_shErrCode = DEC_PASSWORD_UPDATE_CMD_LOCKED;
        ret = Error_Hardware;
        break;
    case STATUS_SYSTEM_TIME_NOT_SET:
        m_shErrCode = DEC_SYSTEM_TIME_NOT_SET;
        ret = Error_Hardware;
        break;
    case STATUS_SYSTEM_TIME_ALREADY_SET:
        m_shErrCode = DEC_SYSTEM_TIME_SET_ALREADY;
        ret = Error_Hardware;
        break;
    case STATUS_DEVICE_TAMPERED:
        m_shErrCode = DEC_DEVICE_TAMPERED;
        ret = Error_Hardware;
        break;
    case STATUS_A980_NO_RESPONSE:
        m_shErrCode = DEC_COMMUNICATION_FAILED;
        ret = Error_Hardware;
        break;
    case STATUS_INVALID_SM4_KEYVAL:
        m_shErrCode = DEC_INVALID_SM4_KEY;
        ret = Error_Param;
        break;
    case STATUS_EXTERNAL_FALSH_WRITE_ERROR:
    case STATUS_FLASH_CRC_CHECK_ERROR:
        m_shErrCode = DEC_E_EXTERNAL_FLASH_HARDWARE;
        ret = Error_Hardware;
        break;
    case STATUS_ADDRESS_OUTRANG:
        m_shErrCode = DEC_INVALID_USER_BLOCK_ADDR;
        ret = Error_Param;
        break;
    case ERR_EXCHANGE_FAILED:
        m_shErrCode = DEC_DEV_NOT_FOUND;
        ret = Error_DevNotAvailable;
        break;
    case ERR_PIN_AUTHENTICATION_FAILED:
    case ERR_PIN_HOST_AUTHENTICATE_FAILED:
        m_shErrCode = DEC_INVALID_AUTHENTICATION_MODE;
        ret = Error_DevNotAvailable;
        break;
    case ERR_PIN_INVALIDCUSTOMERDATA:
        m_shErrCode =DEC_INVALID_PAN;
        ret = Error_Param;
        break;
    case ERR_PIN_ENC_KEYNOTFOUND:
    case ERR_PIN_KEYNOTFOUND:
    case ERR_PIN_STARTVALUE_KEYNOTFOUND:
        m_shErrCode = DEC_INVALID_KEY_ID;
        ret = Error_Param;
        break;
    case ERR_PIN_BATTERY_LOW:
        m_shErrCode = DEC_EPP_BATTERY_LOWORERROR;
        ret = Error_Succeed;
        break;
    case ERR_PIN_INVALIDDATA:
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case ERR_PARAM_ERROR:
        m_shErrCode =DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case ERR_PIN_DEVNOTOPEN:
        m_shErrCode =DEC_DEV_NOT_OPENED;
        ret = Error_DevNotAvailable;
        break;
    case ERR_PIN_INVALIDKEYLENGTH:
        m_shErrCode = DEC_INVALID_KEY_LEN;
        ret = Error_Param;
        break;
    case ERR_PIN_ENC_KEYUSEVIOLATION:
    case ERR_PIN_USEVIOLATION:
    case ERR_PIN_STARTVALUE_KEYUSEVIOLATION:
        m_shErrCode = DEC_KEY_VIOLATION;
        ret = Error_Param;
        break;
    case ERR_PIN_DUPLICATEKEY:
        m_shErrCode = DEC_KEY_LOADED_ALREADY;
        ret = Error_Param;
        break;
    case ERR_DATA_TOO_LONG:
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
    case ERR_PIN_NOKEYRAM:
        m_shErrCode = DEC_KEY_NO_MORE_SPACE;
        ret = Error_Hardware;
        break;
    case ERR_PIN_CHECK_KCV_FAILED:
        m_shErrCode = DEC_VERIFICATION_FAILED;
        ret = Error_Param;
        break;
    case ERR_PIN_PRESS_KEY_OVERTIME:
        m_shErrCode = DEC_PRESS_KEY_TIMEOUT;
        ret = Error_DevCommFailed;
        break;
    case ERR_PIN_TIMEOUT:
        m_shErrCode = DEC_PRESS_KEY_TIMEOUT;
        ret = Error_DevCommFailed;
        break;
    case ERR_PIN_KEY_CODE_NOT_FOUND:
        m_shErrCode = DEC_UNEXPECTED_RET_VALUE;
        ret = Error_DevCommFailed;
        break;
    case ERR_PIN_UNSUPPORT:
    case ERR_PIN_NOT_SUPP:
        m_shErrCode = DEC_PIN_FORMAT_UNSUPPORTED;
        ret = Error_Param;
        break;
    default:
        m_shErrCode = DEC_ERROR_CODE_UNRECOGNIZABLE;
        ret = Error_NoDefine;
        break;
    }
    LogM("ErrorInfo:[0x%x][0x%x]:%s", ret, iErrCode, m_szErrMsg);
    return ret;
}