myvtm/DevAdapter/cw/pinpad.1.1/pinpadimpl.cpp

#include "pinpadimpl.h"
#include "cmb.h"


PinPadImpl::PinPadImpl()
{
    m_MacType = EPP_MAC_ALGO_ASNIX99;
    m_PinType = EPP_PIN_ALGO_ISO9564_1_ANSI;
    m_Ecb_Cbc = EPP_ALGO_MODE_ECB;
    memset(&m_DevErrInfo, 0, sizeof(m_DevErrInfo));
    m_bIsOPen = false;
    m_pPinpad=new PinPadXZF31();
    m_iPinLen = 0;
    m_sCardNo[0] = 0;
    m_iWorkKey = -1;
    m_EncType = EPP_ALGO_METHOD_3DES;
    m_bSMMode = false;
    m_bPinMode = false;
    m_iKeyGot = 0;
}

PinPadImpl::~PinPadImpl()
{
    delete m_pPinpad;
}

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 == NULL) 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;
}

ErrorCodeEnum PinPadImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "GetDevCategory");
    char szType[] = {"PVER=SUNSON#MID=SNK088A"};
    char szModel[] = {"PM=V2.0#MID=00000000#PID=00000000#FWID=%s"};
    char szVendor[] = {"cw"};

    ErrorCodeEnum err = Error_Succeed;
    strcpy(devCategory.szType, szType);
    strcpy(devCategory.szVendor, szVendor);

    char sPath[256], sFile[128] = {0};
    GetCurLibsPath(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;
    unsigned char sTemp[256];
    int iRet = m_pPinpad->getEppVersion(sTemp);
    iRet = GetErrorInfo(iRet, "GetDevCategory");
    if (iRet == Error_Succeed)
    {
        char* pSP = strstr((char*)sTemp, "F31-V");
        if (pSP)
            sprintf(devCategory.szModel, szModel, pSP + 5); //XZ-H602-F31-V1.03-D015
        else
            sprintf(devCategory.szModel, szModel, "00000000");
    }
    else
    {
        sprintf(devCategory.szModel, szModel, "00000000");
    }
    switch(iRet){
    case Error_Succeed:
    case Error_Param:
        devCategory.eState = DEVICE_STATUS_NORMAL;
        break;
    case Error_Closed:
        devCategory.eState = DEVICE_STATUS_NOT_READY;
        break;
    case Error_Hardware:
    default:
        devCategory.eState = DEVICE_STATUS_FAULT;
    }
    char sLog[512];
    sprintf(sLog, "GetDevCategory devCategory.version.wBuild =%d, devCategory.szType=%s ", devCategory.version.wBuild, devCategory.szType);
    LOG4VTM(INFO, sLog);
    return Error_Succeed;
}

//	Get the encrypt method supported.
//	return value:
// 	0x1:3des only; 0x2:sm4 only; 0x3:both 3des and sm4
int PinPadImpl::GetEncryptFunc()
{
    return 3;
}

//	Reset device.
//	Do the cleaning work and initialize device again in order to return to
//	the normal condition.
ErrorCodeEnum PinPadImpl::Reset()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "Reset");
    int iRet = m_pPinpad->resetEpp();
    iRet = GetErrorInfo(iRet, "Reset");
    return (ErrorCodeEnum)iRet;
}

//	Close device and do the cleaning work.
//	ex. close connection,close port,release memery and so on
ErrorCodeEnum PinPadImpl::DevClose()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "DevClose");
    StopInput();
    m_pPinpad->closeDevice();
    LOG4VTM(INFO, "device closed");
    m_bIsOPen = false;
    return Error_Succeed;
}
//	Get last error the device issued.
//	Error message must include explanatory memorandum ,the original error
//	code and anything in favour of location problem.
ErrorCodeEnum PinPadImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    memcpy(&devErrInfo, &m_DevErrInfo, sizeof(DevErrorInfo));
    return Error_Succeed;
}
//
//	Open device.
//	Arguments:
//	- dwPort[in]		com port number
//	- dwBaudRate[in]	Baud rate
//
ErrorCodeEnum PinPadImpl::DevOpen(DWORD dwPort,DWORD dwBaudRate)
{
    LOG4VTM_FUNCTION();
    char sPort[16],sGet[32];
    m_bIsOPen = false;
    sprintf(sPort, "COM%d", dwPort);
    if (SIni::GetValueFromIniFile("/cashway/setting/cashway.ini", "Serial", sPort, sGet, 30))
        strcpy(sPort, sGet);
//    if (!SIni::GetValueFromIniFile("/cashway/setting/cashway.ini", "Serial", "SMFlg", m_sKeyAttr, 32))
//        strcpy(m_sKeyAttr, "00000000000000000000000000000000");
//    m_sKeyAttr[32] = 0;

    if (m_pPinpad->Open(sPort, dwBaudRate))
    {
        m_bIsOPen = true;

        int iRet = m_pPinpad->resetEpp();
        iRet = GetErrorInfo(iRet, "DevOpen resetEpp");
        if (iRet != 0)
            return (ErrorCodeEnum)iRet;

        unsigned char sMode[32];
        iRet = m_pPinpad->GetEPPSMMode(sMode);
        iRet = GetErrorInfo(iRet, "DevOpen GetEPPSMMode");
        if (iRet != 0)
            return (ErrorCodeEnum)iRet;
        m_bSMMode = sMode[0] == 1;
        return GetErrorInfo(0, "DevOpen");
    }
    return GetErrorInfo(-1, "DevOpen");
}

//  DEC_SUCCESS DEC_HARDWARE DEC_TIMEOUT DEC_INVALID_PARAMETER DEC_INVALID_MASTER_KEY
const static CmbErrorDef sunsonErrInfo[] = {
    {0,    "成功", Error_Succeed, DEC_SUCCESS},
    {-1,   "指定的设备未打开", Error_Hardware, DEC_DEV_NOT_OPENED},
    {-2,   "设备响应超时", Error_DevCommFailed, DEC_TIMEOUT},
    {-3,   "传入参数错误", Error_Param, DEC_INVALID_PARAMETER},

//    //8088 错误码
//    {0x04, "命令成功执行", Error_Succeed, DEC_SUCCESS},
//    {0x15, "命令参数错", Error_Param, DEC_INVALID_PARAMETER},
//    {0x80, "超时错误", Error_Hardware, DEC_HARDWARE},
//    {0xA4, "主密钥无效", Error_Param, DEC_INVALID_PARAMETER},
//    {0xB5, "命令主密钥无效", Error_Param, DEC_HARDWARE},
//    {0xC4, "键盘电池可能损坏", Error_Hardware, DEC_HARDWARE},
//    {0xD5, "命令无效且电池损坏", Error_Param, DEC_HARDWARE},
//    {0xE0, "无效命令", Error_Param, DEC_INVALID_PARAMETER},
//    {0xF0, "CPU 错", Error_Hardware, DEC_HARDWARE},
//    {0xF1, "SRAM 错", Error_Hardware, DEC_HARDWARE},
//    {0xF2, "键盘有短路", Error_Hardware, DEC_HARDWARE},
//    {0xF3, "串口电平错", Error_Hardware, DEC_HARDWARE},
//    {0xF4, "CPU 卡出错", Error_Hardware, DEC_HARDWARE},
//    {0xF5, "电池可能损坏", Error_Hardware, DEC_HARDWARE},
//    {0xF6, "主密钥失效", Error_Hardware, DEC_HARDWARE},
//    {0xF7, "杂项错", Error_Hardware, DEC_HARDWARE},

    //F31错误码
    {0x02, "算法模式错误", Error_Param, DEC_INVALID_PARAMETER},
    {0x03, "指令格式错", Error_Param, DEC_INVALID_PARAMETER},
    {0x03, "密钥不存在", Error_Param, DEC_INVALID_PARAMETER},
    {0x0e, "密钥不存在", Error_Param, DEC_INVALID_PARAMETER},
    {0x0f, "密钥存在", Error_Param, DEC_INVALID_PARAMETER},
    {0x10, "密钥属性错", Error_Param, DEC_INVALID_PARAMETER},
    {0x12, "下载密钥失败", Error_Hardware, DEC_HARDWARE},
    {0x13, "Hash 类型错误", Error_Param, DEC_INVALID_PARAMETER},
    {0x17, "密钥号超出范围", Error_Param, DEC_INVALID_PARAMETER},
    {0x19, "无 PIN", Error_Param, DEC_INVALID_PARAMETER},
    {0x1c, "PIN 长度错", Error_Param, DEC_INVALID_PARAMETER},
    {0x1d, "卡号长度错", Error_Param, DEC_INVALID_PARAMETER},
    {0x30, "PINBLOCK 时卡号有误", Error_Param, DEC_INVALID_PARAMETER},
    {0x31, "数据运算时数据长度出错", Error_Param, DEC_INVALID_PARAMETER},
    {0x40, "无客户信息", Error_Param, DEC_INVALID_PARAMETER},
    {0x42, "密钥长度错", Error_Param, DEC_INVALID_PARAMETER},
    {0x47, "国密运算超时", Error_Hardware, DEC_HARDWARE},
    {0x48, "国密运算错误", Error_Hardware, DEC_HARDWARE},
    {0x50, "RSA E 值错误", Error_Hardware, DEC_HARDWARE},
    {0x51, "RSA 密钥长度错误", Error_Hardware, DEC_HARDWARE},
    {0x52, "RSA 签名数据错误", Error_Hardware, DEC_HARDWARE},
    {0x53, "RSA DER 错误", Error_Hardware, DEC_HARDWARE},
    {0x54, "RSA 运算错误", Error_Hardware, DEC_HARDWARE},
    {0x55, "RSA 公钥不存在", Error_Hardware, DEC_HARDWARE},
    {0xb0, "DER 数据长度错误", Error_Param, DEC_INVALID_PARAMETER},
    {0xb1, "填充算法错误", Error_Param, DEC_INVALID_PARAMETER},
    {0xb2, "密钥模长 N 错误", Error_Param, DEC_INVALID_PARAMETER},
    {0xb3, "运算数据长度错误", Error_Param, DEC_INVALID_PARAMETER},
    {0xb4, "内存不足", Error_Hardware, DEC_HARDWARE},
    {0xb5, "HASH 算法错误", Error_Param, DEC_INVALID_PARAMETER},
    {0xb6, "数据包错误", Error_Param, DEC_INVALID_PARAMETER},
    {0xb7, "---", Error_Hardware, DEC_HARDWARE},
    {0xb8, "验签失败", Error_Hardware, DEC_HARDWARE},

};

ErrorCodeEnum PinPadImpl::GetErrorInfo(int iCode, char* sErr, ...)
{
    size_t iLenOne = sizeof(CmbErrorDef);
    size_t iLenAll = sizeof(sunsonErrInfo);
    int iCount = iLenAll / iLenOne;
    char sErrInfo[256]="";
    DWORD dSta = 0;
    int iErr = -1;
    for (int ia = 0; ia < iCount; ia++)
    {
        if (sunsonErrInfo[ia].iCode == iCode)
        {
            dSta = sunsonErrInfo[ia].iInf;
            strcpy(sErrInfo, sunsonErrInfo[ia].sInf);
            iErr = sunsonErrInfo[ia].iRet;
            break;
        }
    }
    if (iErr == -1)
    {
        sprintf(sErrInfo, "error code %02x", iCode);
        iErr = Error_Hardware;
        dSta = DEC_HARDWARE;
    }

    char sErrAll[300];
    va_list arglist;
    va_start(arglist, sErr);
    _vsnprintf(sErrAll, 128, sErr, arglist);
    va_end(arglist);

    if (sErrInfo[0])
    {
        strcat(sErrAll, " ");
        strcat(sErrAll, sErrInfo);
    }
    sErrAll[200] = 0;
    iLenOne = strlen(sErrAll);
    sprintf(m_DevErrInfo.szErrMsg, "{\"ErrCode\":\"%04x\"，\"Description\":\"%s\"}", iErr, sErrAll);
//    strcpy(m_DevErrInfo.szErrMsg, sErrAll);
    m_DevErrInfo.dwErrMsgLen = ((dSta << 16) & 0xffff0000) + iLenOne;
    if (iErr != 0)
        LOG4VTM(WARN, m_DevErrInfo.szErrMsg);
    else
        LOG4VTM(INFO, m_DevErrInfo.szErrMsg);
    return (ErrorCodeEnum)iErr;
}

//	Set pinpad parameter.
ErrorCodeEnum PinPadImpl::SetParam(SetParamTypeEnum eType,SetParamValueEnum eValue)
{
    LOG4VTM_FUNCTION();
    char sLog[512];
    sprintf(sLog, "SetParam eType=%d, eValue=%d", (int)eType, (int)eValue);
    LOG4VTM(INFO, sLog);
    ErrorCodeEnum eRt = Error_Succeed;
    switch(eType)
    {
        case EPP_PT_SET_ENCRYPT_METHOD:
            m_EncType = eValue;
            break;
        case EPP_PT_SET_MAC_ALGORITH:
            m_MacType = eValue;
            break;
        case EPP_PT_SET_PIN_ALGORITH:
            m_PinType = eValue;
            break;
        case EPP_PT_SET_ECB_CBC_MODE:
            m_Ecb_Cbc = eValue;
            break;
        default:
            eRt = Error_Param;
            break;
    }
    return Error_Succeed;
}

ErrorCodeEnum PinPadImpl::SetAccNo(AccountInfo accInfo)
{
    LOG4VTM_FUNCTION();
    int iLen = accInfo.dwAccLen;
    unsigned char sTemp[33];
    memcpy(sTemp, accInfo.account, 32);
    sTemp[iLen] = 0;
    unsigned char* pNo = sTemp;
    if (iLen > 13)
    {
        pNo += (iLen - 13);
        iLen = 13;
    }
    if (iLen > 12)
    {
        pNo[12] = 0;
        iLen = 12;
    }
    strcpy(m_sCardNo, (char*)pNo);

    char sLog[256];
    sprintf(sLog, "SetAccNo %s", m_sCardNo);
    LOG4VTM(DEBUG, sLog);

    return Error_Succeed;
}

ErrorCodeEnum PinPadImpl::KeyRead(BYTE &ch)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "KeyRead");
    int iRet = m_pPinpad->scankeyPress(ch);
    if (iRet < 0)
        return GetErrorInfo(JT_HARDWARE_ERROR, "KeyRead");
    if (iRet == 0)
        return GetErrorInfo(JT_TIMEOUT, "KeyRead");

    if (m_bPinMode)
    {
        if (ch == 0x0d)
            return GetErrorInfo(JT_TIMEOUT, "KeyRead ch=0d");
        m_iKeyGot++;
        char sLog[256];
        sprintf(sLog, "KeyRead pin mode len =%d key=%d", m_iKeyGot, ch);
        LOG4VTM(INFO, sLog);
        if (ch == 0x2a) ch = 0x3f;
        if (ch == 0x2e || ch == 0x54) ch = 0x3d;
        if (ch == 0x08)
        {
            StartPinInput(m_iPinLen, m_bAutoEnd);
            m_iKeyGot = 0;
        }
        if (ch == 0x1b || //ch == 0x0d ||
            m_iKeyGot >= m_iPinLen)
        {
            unsigned char sTemp[32];
            m_pPinpad->SetBuzzerEnabled(0x31, sTemp);
        }
    }
    return Error_Succeed;
}

//	Load master key. (in plain text)
//	[key]:byte value in string type. ex. 0x123456FF  --> "123456FF"
ErrorCodeEnum PinPadImpl::LoadMasterKey(MasterKeyParam masterKey)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "LoadMasterKey");
    int iLen = strlen((char*)masterKey.key);
    if (iLen != 32)
        return GetErrorInfo(JT_PARA_ERR, "LoadMasterKey keylen= %d", iLen);

    char sLog[256];
    int iRet = 0;
    if (m_bSMMode != masterKey.smFlag)
    {
        iRet = m_pPinpad->SetEPPSMMode(masterKey.smFlag);
        sprintf(sLog, "LoadMasterKey SetEPPSMMode %d ret%d", masterKey.smFlag, iRet);
        LOG4VTM(INFO, sLog);
        if (iRet != Error_Succeed)
            return GetErrorInfo(iRet, "LoadMasterKey SetEPPSMMode");
        m_bSMMode = masterKey.smFlag;
    }

    unsigned char sTemp[32];
    m_pPinpad->EnableLoadSameKey(0x00, sTemp);
    ::HexStrToANSI((char*)masterKey.key, sTemp, iLen);
    int iMK = MK_HEAD + masterKey.dwSN;
//    m_sKeyAttr[iMK] = '0';
    iRet = m_pPinpad->LoadUserKey(iMK, 0xffff, 0x27, iLen>>1, sTemp, sTemp);
    iRet = GetErrorInfo(iRet, "LoadMasterKey sm=%d mk= %d", masterKey.smFlag, masterKey.dwSN);
//    if (iRet == 0)
//    {
//        if (m_sKeyAttr[iMK] - '0' != masterKey.smFlag)
//        {
//            m_sKeyAttr[iMK] = masterKey.smFlag + '0';
//            SIni::SetValueToIniFile("/cashway/setting/cashway.ini", "Serial", "SMFlg", m_sKeyAttr);
//            sprintf(sLog, "LoadMasterKey save key SM flag %d %d", iMK, masterKey.smFlag);
//            LOG4VTM(INFO, sLog);
//        }
//    }
    return (ErrorCodeEnum)iRet;
}

//	Load working key. (encrypted data)
//	Use the according master key to decrypt the key,then load result into pinpad
//	[key]:byte value in string type. ex. 0x123456FF  --> "123456FF"
ErrorCodeEnum PinPadImpl::LoadWorkingKey(WorkKeyParam wkKey)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "LoadWorkingKey");
    int iLen = strlen((char*)wkKey.key);
    if (iLen != 32)
        return GetErrorInfo(JT_PARA_ERR, "LoadWorkingKey keylen= %d", iLen);

    bool bSM = wkKey.smFlag == 1;
    int iRet = 0;
    if (m_bSMMode != bSM)
    {
        iRet = m_pPinpad->SetEPPSMMode(wkKey.smFlag);
        if (iRet != Error_Succeed)
            return GetErrorInfo(iRet, "LoadMasterKey setModeSMAlgorithm");
        m_bSMMode = bSM;
    }
    iRet = m_pPinpad->CheckEPPSMMode(m_bSMMode);
    if (iRet != Error_Succeed)
        return GetErrorInfo(iRet, "LoadMasterKey setModeSMAlgorithm");

    unsigned char sTemp[32];
    ::HexStrToANSI((char*)wkKey.key, sTemp, iLen);
    int iWk = WK_HEAD + wkKey.dwMasterSN * 4 + wkKey.dwWorkingSN;
    iRet = m_pPinpad->LoadUserKey(iWk, MK_HEAD + wkKey.dwMasterSN, 0x07, iLen>>1, sTemp, sTemp);
    iRet = GetErrorInfo(iRet, "LoadWorkingKey activeKey sm=%d mk= %d wk = %d", wkKey.smFlag, wkKey.dwMasterSN, wkKey.dwWorkingSN);
//    if (iRet == 0)
//    {
//        if (m_sKeyAttr[iWk] - '0' != wkKey.smFlag)
//        {
//            m_sKeyAttr[iWk] = wkKey.smFlag + '0';
//            SIni::SetValueToIniFile("/cashway/setting/cashway.ini", "Serial", "SMFlg", m_sKeyAttr);
//        }
//    }
    return (ErrorCodeEnum)iRet;
}

//	- dwMkSN:master key serial number
//	- dwWkSN:working key serial number
//	- ActiveWorkingKey(主密钥序号,99)表示激活“主密钥序号”的主密钥作为当前工作密钥
ErrorCodeEnum PinPadImpl::ActiveWorkingKey(DWORD dwMkSN, DWORD dwWkSN)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "ActiveWorkingKey");
    int iRet = 0;
    if (dwWkSN == 99)
        m_iWorkKey = MK_HEAD + dwMkSN;
    else
        m_iWorkKey = WK_HEAD + dwMkSN * 4 + dwWkSN;
    iRet = GetErrorInfo(iRet, "ActiveWorkingKey mk= %d wk= %d", dwMkSN, dwWkSN);
/*
    if (m_bSMMode != m_sKeyAttr[m_iWorkKey] - '0')
    {
        iRet = m_pPinpad->SetEPPSMMode(m_sKeyAttr[m_iWorkKey] - '0');
        if (iRet != Error_Succeed)
            return GetErrorInfo(iRet, "ActiveWorkingKey setModeSMAlgorithm");
        m_bSMMode = m_sKeyAttr[m_iWorkKey] - '0';
    }
//*/
    return (ErrorCodeEnum)iRet;
}

ErrorCodeEnum PinPadImpl::StartPinInput(int iLen, bool bAutoEnd)
{
    m_iPinLen = iLen;
    m_bAutoEnd = bAutoEnd;
    m_iKeyGot = 0;
    int iRet = 0;
    unsigned char sTemp[33];

    bool bSM = (m_PinType == EPP_PIN_ALGO_SM4);
    if (m_bSMMode != bSM)
    {
        int iRet = m_pPinpad->SetEPPSMMode(bSM);
        char sLog[256];
        sprintf(sLog, "StartPinInput SetEPPSMMode %d ret%d", bSM, iRet);
        LOG4VTM(INFO, sLog);
        if (iRet != Error_Succeed)
            return GetErrorInfo(iRet, "SetParam SetEPPSMMode");
        m_bSMMode = bSM;
    }

    Sleep(50);
    iRet = m_pPinpad->SetBuzzerEnabled(0x30, sTemp);
    iRet = GetErrorInfo(iRet, "StartPinInput SetBuzzerEnabled");
    if (iRet != Error_Succeed) return (ErrorCodeEnum)iRet;

    Sleep(50);
    iRet = m_pPinpad->GetPin(iLen, iLen, bAutoEnd, sTemp);
    iRet = GetErrorInfo(iRet, "StartPinInput ret %d %02x", iRet, iRet);
    if (iRet == 0)
        m_bPinMode = true;
    return (ErrorCodeEnum)iRet;
}

//	Start key press(pin mode).
//	byLen:输入密码长度，键盘检测到用户输入确认键后结束输入，计算pinblock
//
ErrorCodeEnum PinPadImpl::StartPinInputConfirm(BYTE byLen)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "StartPinInputConfirm");
    return StartPinInput(byLen, true);
}

ErrorCodeEnum PinPadImpl::StartPinInput(BYTE byLen)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "StartPinInput");
    return StartPinInput(byLen, false);
}

//	Start key press(plain text mode).
ErrorCodeEnum PinPadImpl::StartPlainInput()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "StartPlainInput");
    unsigned char sTemp[33];
    int iRet = 0;
    iRet = m_pPinpad->SetBuzzerEnabled(0x30, sTemp);
    iRet = GetErrorInfo(iRet, "StartPlainInput SetBuzzerEnabled");
    if (iRet != Error_Succeed) return (ErrorCodeEnum)iRet;
    iRet = m_pPinpad->UseEppPlainTextMode(0, 0, sTemp);
    iRet = GetErrorInfo(iRet, "StartPlainInput");
    m_bPinMode = false;
    return (ErrorCodeEnum)iRet;
}

ErrorCodeEnum PinPadImpl::StopInput()
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "StopInput");
    m_bPinMode = false;
    unsigned char sTemp[33];
    int iRet = m_pPinpad->CloseEppPlainTextMode(sTemp);
    iRet = GetErrorInfo(iRet, "StopInput ");
    iRet = m_pPinpad->SetBuzzerEnabled(0x31, sTemp);
    iRet = GetErrorInfo(iRet, "StopInput SetBuzzerEnabled");
    return (ErrorCodeEnum)iRet;
}

ErrorCodeEnum PinPadImpl::GetPinBlock(PinBlock &block)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "GetPinBlock");
    unsigned char    sPinRead[32];

    int iMode = 0x34;
    if (m_PinType == EPP_PIN_ALGO_ISO9564_1_ANSI || m_PinType == EPP_PIN_ALGO_SM4)
        iMode = 0x30;

    int iLenOut = 0;
    int iRet = m_pPinpad->GetPinBlock(m_iWorkKey, iMode, 0x00, strlen(m_sCardNo), (unsigned char*)m_sCardNo, sPinRead, iLenOut);
    iRet = GetErrorInfo(iRet, "GetPinBlock");
    if (iRet == Error_Succeed)
    {
        int iLength = m_bSMMode ? 16 : 8;
        block.dwSize = (iLength << 1);
        ANSIToHexStr(sPinRead, iLength, (char*)block.data);
    }
    return (ErrorCodeEnum)iRet;
}

// 	- srcInfo.data:source plain text data
//		(byte value in string type. ex. 0x123456FF  --> "123456FF")
// 	- destInfo.data:destination encrypted data
ErrorCodeEnum PinPadImpl::EncryptData(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo)
{
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "DevClose");

    bool bSM = (m_EncType == EPP_ALGO_METHOD_SM4);
    if (m_bSMMode != bSM)
    {
        int iRet = m_pPinpad->SetEPPSMMode(bSM);
        char sLog[256];
        sprintf(sLog, "EncryptData SetEPPSMMode %d ret%d", bSM, iRet);
        LOG4VTM(INFO, sLog);
        if (iRet != Error_Succeed)
            return GetErrorInfo(iRet, "EncryptData SetEPPSMMode");
        m_bSMMode = bSM;
    }

    unsigned char    sData[260], sOut[260];
    int iSize = min((size_t)srcInfo.dwSize, strlen((char*)srcInfo.data));
    HexStrToANSI((const char*)srcInfo.data, sData, iSize);
    int iRet = 0;
    iSize /= 2;
    int iOut = 0;
    switch (m_Ecb_Cbc)
    {
    case EPP_ALGO_MODE_DEC_ECB:
    case EPP_ALGO_MODE_3DEC_ECB:
    case EPP_ALGO_MODE_ECB:
        iRet = m_pPinpad->DataCompute(m_iWorkKey, 0x31, 0x30, 0x0f, iSize, sData, sOut, iOut);
        break;
    case EPP_ALGO_MODE_DEC_CBC:
    case EPP_ALGO_MODE_3DEC_CBC:
    case EPP_ALGO_MODE_CBC:
        iRet = m_pPinpad->DataCompute(m_iWorkKey, 0x31, 0x31, 0x0f, iSize, sData, sOut, iOut);
        break;
    default:
        iRet = JT_PARA_ERR;
    }
    iRet = GetErrorInfo(iRet, "EncryptData");
    if (iRet == Error_Succeed)
    {
        destInfo.dwSize = (iOut << 1);
        ANSIToHexStr(sOut, iOut, (char*)destInfo.data);
    }
    return (ErrorCodeEnum)iRet;
}

// 	- srcInfo.data:source plain text data
//		(byte value in string type. ex. 0x123456FF  --> "123456FF")
// 	- destInfo.data:destination encrypted data
ErrorCodeEnum PinPadImpl::MacEncrypt(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo)
{
    //该功能没有使用，实际传入参数不清楚
    LOG4VTM_FUNCTION();
    if (!m_bIsOPen)
        return GetErrorInfo(-1, "MacEncrypt");

    bool bSM = (m_MacType == EPP_ALGO_METHOD_SM4);
    if (m_bSMMode != bSM)
    {
        int iRet = m_pPinpad->SetEPPSMMode(bSM);
        char sLog[256];
        sprintf(sLog, "EncryptData SetEPPSMMode %d ret%d", bSM, iRet);
        LOG4VTM(INFO, sLog);
        if (iRet != Error_Succeed)
            return GetErrorInfo(iRet, "EncryptData SetEPPSMMode");
        m_bSMMode = bSM;
    }

    unsigned char    sData[260], sOut[64];
    int iSize = ((int)srcInfo.dwSize, strlen((char*)srcInfo.data));
    HexStrToANSI((const char*)srcInfo.data, sData, iSize);
    int iRet = 0;
    iSize /= 2;
    BYTE IV[16] = {0x00};
    m_pPinpad->SetStartValue(IV, sOut);
    int iRecv = 0;
    switch(m_MacType)
    {
    case EPP_MAC_ALGO_ASNIX99:
        iRet = m_pPinpad->MakeMac(m_iWorkKey, 0x33, iSize, sData, sOut, iRecv);
        break;
    case EPP_MAC_ALGO_PBOC:
        iRet = m_pPinpad->MakeMac(m_iWorkKey, 0x34, iSize, sData, sOut, iRecv);
        break;
    }
    iRet = GetErrorInfo(iRet, "EncryptData");
    if (iRet == Error_Succeed)
    {
        destInfo.dwSize = iRecv*2;
        ANSIToHexStr(sOut, iRecv, (char*)destInfo.data);
    }
    return (ErrorCodeEnum)iRet;
}