myvtm/DevAdapter/keba/IDCertificate.keba.1.1/idcertificate.cpp

#include "idcertificate.h"
#include <stdarg.h>
#include "log4vendor.h"
#include "stdafx.h"

LOG_EXTERN()
#define		MAX_PICTURE_SIZE	3*1024*1024
#define     MAX_FILE_PATH           260
CHAR		CurrendPath[MAX_FILE_PATH] = {0};
CHAR		PhotoPath[MAX_FILE_PATH] = {0};

char* strcpy_s(char* dest, const char* src)
{
    return strcpy(dest, src);
}
char* strcpy_s(char* dest, size_t size, const char* src)
{
    if ((dest == NULL) || (size < strlen(src) + 1))
    {
        return NULL;
    }

    return strcpy(dest, src);
}

char* strcat_s(char* dest, const char* src)
{
    return strcat(dest, src);
}

char* strcat_s(char* dest, size_t size, const char* src)
{
    if ((dest == NULL) || (size < strlen(dest) + strlen(src) + 1))
    {
        return NULL;
    }

    return strcat(dest, src);
}


unsigned long GetTickCount()
{
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
}

int GetDllPathLocal(std::string& dllPath)
{
    Dl_info path_info;
    dladdr("load_so",&path_info);
    char str_FilePath[256]{0};
    memcpy(str_FilePath,path_info.dli_fname,strlen(path_info.dli_fname));
    printf("first_str_FilePath=%s\n",str_FilePath);
    char *pLastSlath=strrchr(str_FilePath,'/');
    *(pLastSlath + 1)=0;
    std::string a(str_FilePath);
    dllPath = a;
    return 0;
}

IDCerClassImpl::IDCerClassImpl():
m_bDevOpen(false)
    ,m_bAuthed(false)
    ,m_iCardType(-1)
{
    LOG_FUNCTION();
    SecDeviceNum = 0;
}
IDCerClassImpl::~IDCerClassImpl()
{
    LOG_FUNCTION();
    m_bDevOpen = false;
    DevClose();
    SecDeviceNum = 0;
    std::string tmpPath = "";
    if( GetDllPathLocal(tmpPath) == Error_Succeed )
    {
    }
    else
    {
        tmpPath = "/";
    }
    std::string strFile = tmpPath + "zp.bmp";
    if(access(strFile.c_str(), 0) != -1)
    {
        LogM("file del:%s\n", strFile.c_str());
        remove(strFile.c_str());
    }
    else
    {
        LogM("file not found:%s\n", strFile.c_str());
    }
    strFile = tmpPath + "idback.bmp";
    if(access(strFile.c_str(), 0) != -1)
    {
        LogM("file del:%s\n", strFile.c_str());
        remove(strFile.c_str());
    }
    else
    {
        LogM("file not found:%s\n", strFile.c_str());
    }
    strFile = tmpPath + "idfront.bmp";
    if(access(strFile.c_str(), 0) != -1)
    {
        LogM("file del:%s\n", strFile.c_str());
        remove(strFile.c_str());
    }
    else
    {
        LogM("file not found:%s\n", strFile.c_str());
    }
    strFile = tmpPath + "ck.bmp";
    if(access(strFile.c_str(), 0) != -1)
    {
        LogM("file del:%s\n", strFile.c_str());
        remove(strFile.c_str());
    }
    else
    {
        LogM("file not found:%s\n", strFile.c_str());
    }

}

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;
}

ErrorCodeEnum IDCerClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG_FUNCTION();
    LogM("GetDevCategory() Entry.");
    memset(devCategory.szType, 0, MAX_DEV_TYPE_LEN);
    memset(devCategory.szModel, 0, MAX_DEV_MODEL_LEN);
    memset(devCategory.szVendor, 0, MAX_DEV_VENDOR_LEN);
    memcpy(devCategory.szType, "PVER=SNBC#MID=ID8101", strlen("PVER=SNBC#MID=ID8101"));
    memcpy(devCategory.szVendor, "keba", strlen("keba"));
    devCategory.eState = DEVICE_STATUS_NORMAL;

    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 = 2;


    memcpy(devCategory.szModel, "STYLE=IG#FUNCTION=ITF", strlen("STYLE=IG#FUNCTION=ITF"));
    LogM("GetDevCategory() return:\n\
                      devCategory.szType = %s, \n\
                      devCategory.szVendor = %s, \n\
                      devCategory.eState = %d, \n\
                      devCategory.version.wMajor = %d, \n\
                      devCategory.version.wMinor = %d, \n\
                      devCategory.version.wRevision = %d, \n\
                      devCategory.version.wBuild= %d, \n\
                      devCategory..szModel = %s, \n",
                      devCategory.szType,
                      devCategory.szVendor,
                      devCategory.eState,
                      devCategory.version.wMajor,
                      devCategory.version.wMinor,
                      devCategory.version.wRevision,
                      devCategory.version.wBuild,
                      devCategory.szModel);
    return Error_Succeed;
}
//	Reset device.
//	Do the cleaning work and initialize device again in order to return to
//	the normal condition.
ErrorCodeEnum IDCerClassImpl::Reset()
{
    LOG_FUNCTION();
    LogM("Reset() Entry.");
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        LogM("Reset(), 设备未打开, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }

    int nRet = m_cBS_ID81IDCImpl.ResetWithAction(SecDeviceNum, 0);//复位模式，0---退卡，1---吞卡，2---退卡并持卡，3---无动作。
    if (IDDIGITALCOPIER_NO_ERROR != nRet)
    {
        SaveErrorInfo("设备通信异常", Error_DevConnFailed);
        LogM("Reset() 复位模式， 0-- 退卡 动作失败");
        return Error_DevConnFailed;
    }
    m_bAuthed = false;
    m_iCardType = -1;
    LogM("Reset() 复位模式， 0-- 退卡 动作成功");
    return Error_Succeed;
}
//
//	Close device and do the cleaning work.
//	ex. close connection,close port,release memery and so on
ErrorCodeEnum IDCerClassImpl::DevClose()
{
    LOG_FUNCTION();
    LogM("DevClose() Entry.");
    int nRet = m_cBS_ID81IDCImpl.CloseDev(SecDeviceNum);
    if (IDDIGITALCOPIER_NO_ERROR != nRet)
    {
        SaveErrorInfo("设备通信异常", Error_DevConnFailed);
        LogM("DevClose(), 设备通信异常, nRet=%d", nRet);
        return Error_DevConnFailed;
    }

    m_bDevOpen = false;
    m_bAuthed = false;
    m_iCardType = -1;
    LogM("DevClose(), nRet=%d", nRet);
    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 IDCerClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    LOG_FUNCTION();
    LogM("IDCerClassImpl::Entry->IDCerClassImpl GetLastErr()!");
    devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);

    memcpy(devErrInfo.szErrMsg, m_szErrMsg, MIN(devErrInfo.dwErrMsgLen, MAX_DEV_ERROR_MSG_LEN));
    LogM("GetLastErr() return：\n\
                        devErrInfo.szErrMsg = %s, \n\
                        devErrInfo.dwErrMsgLen = %d", devErrInfo.szErrMsg, devErrInfo.dwErrMsgLen);

    return Error_Succeed;
}
//
//	Open device.
//	if usb device,set dwPort=0
//
ErrorCodeEnum IDCerClassImpl::DevOpen(DWORD dwPort)
{
    LOG_FUNCTION();
    LogM("DevOpen(dwPort = %d) Entry.", dwPort);
    unsigned int DevNumber = 8;	//统计当前设备数量
    ScannerInfoRec  ScannerInfo[8] = {0};                  //设备信息
    m_bAuthed = false;
    m_iCardType = -1;

    int nRet = m_cBS_ID81IDCImpl.EnumScannerDev(ScannerInfo, &DevNumber);
    if (DevNumber <= 0)
    {
        m_bDevOpen = false;
        SaveErrorInfo("未找到设备", Error_DevNotAvailable);
        SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
        SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
        SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
        return Error_DevNotAvailable;
    }

    for (unsigned int i = 0; i < DevNumber; i++)
    {
        SecDeviceNum = ScannerInfo[i].DeviceID;
        printf(" SecDeviceNum=%d", SecDeviceNum);
        nRet = m_cBS_ID81IDCImpl.OpenDev(SecDeviceNum);
        if (IDDIGITALCOPIER_NO_ERROR == nRet)
        {
            m_bDevOpen = true;
            SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
            SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
            SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
            LogM("DevOpen(), nRet=%d.", nRet);
            return Error_Succeed;
        }
    }
    m_bDevOpen = false;
    SaveErrorInfo("设备通信异常", Error_DevConnFailed);
    SH_DeleteFileOrDirectory("LogModuleErrMsg.log");
    SH_DeleteFileOrDirectory("bin\\LogModuleErrMsg.log");
    SH_DeleteFileOrDirectory("..\\bin\\LogModuleErrMsg.log");
    LogE("DevOpen, 设备通信异常, nRet = %d. ", nRet);
    return Error_DevConnFailed;
}
//
//	Optional.
//	Open or close RF.
//	Arguments:
//	- bControl:true:open RF,false close RF
//
ErrorCodeEnum IDCerClassImpl::IDCerRFControl(bool bControl)
{
    LOG_FUNCTION();
    LogM("IDCerRFControl(), bControl = %d", bControl);
    if(!m_bDevOpen)
    {
        //g_pLog->Print("IDCerRFControl(), !m_bDevOpen, nRet=%d", Error_DevNotAvailable);
        LogE("IDCerRFControl(), !m_bDevOpen, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }
    if (bControl)
    {
        /*
        //------------2019-07-19--------根据DevTestTool连续测试的指令流程，应在此处检测入卡；
        //IDCerAuthenticate();
        DWORD	dwStart = GetTickCount();
        DWORD	dwNow = dwStart;
        DEVSTATUS m_DeviceStatus;
        int pos = -1;
        int nRet;
        bool bCard = false;
        while ((dwNow - dwStart) <= 1000)
        {
            pos = -1;
            memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
            nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
            if (nRet != IDDIGITALCOPIER_NO_ERROR)
            {
                char err[MAX_DEV_ERROR_MSG_LEN] = {0};
                sprintf(err, "通讯异常%d", nRet);
                SaveErrorInfo(err, Error_DevCommFailed);
                //m_cBS_ID81IDCImpl.ResetDev(SecDeviceNum);
                return Error_DevCommFailed;
                //SaveErrorInfo("通讯异常", Error_DevCommFailed);
                //return Error_DevCommFailed;
            }
            if ((m_DeviceStatus.iStatusInputSensorHaveCard == 1) &&
                (m_DeviceStatus.iStatusMiddleSensorHaveCard == 0) &&
                (m_DeviceStatus.iStatusScanSensorHaveCard ==0))
            {
                pos = 2;
            }
            else if ((m_DeviceStatus.iStatusMiddleSensorHaveCard == 1) ||
                     (m_DeviceStatus.iStatusScanSensorHaveCard ==1))
            {
                pos = 1;
            }
            else
            {
                pos = 0;
            }
            if (pos <= 0)
            {
                Sleep(100);
                dwNow = GetTickCount();
            }
            else
            {
                bCard = true;
                break;
            }
        }
        if (!bCard)
        {
            SaveErrorInfo("未检测到卡", Error_Unexpect);
            return Error_Unexpect;
        }

        nRet = m_cBS_ID81IDCImpl.CheckIdCard(SecDeviceNum, 100);
        if ((IDDIGITALCOPIER_TIMEOUT_ERROR == nRet) ||
            (IDDIGITALCOPIER_NO_CARD == nRet))
        {
            //2019-02-28 《可视化柜台设备厂商适配器开发说明文档V1.3.doc》 P12关于身份证读卡器改造说明
            //1.	检测到有卡片插入/放置，但不是身份证时，IDCerAuthenticate返回Error_DevMedia；
            //2.	未检测到卡片插入/放置，IDCerAuthenticate返回Error_Unexpect；
            //3.	检测到身份证且认证成功（注意：部分厂商不做卡认证直接返回成功，需要根据实际情况按照步骤1和2返回对应值），IDCerAuthenticate返回Error_Succeed。
            //SaveErrorInfo("未检测到卡", Error_DevMedia);
            //printf(" SecDeviceNum=%d",SecDeviceNum);
            //return Error_DevMedia;
            SaveErrorInfo("未检测到卡", Error_Unexpect);
            return Error_Unexpect;
        }
        else if (IDDIGITALCOPIER_NO_ERROR != nRet)
        {
            char err[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(err, "通讯失败%d", nRet);
            SaveErrorInfo(err, Error_DevConnFailed);
            //m_cBS_ID81IDCImpl.ResetDev(SecDeviceNum);
            return Error_DevConnFailed;
        }
        */
    }
    else
    {
        ForceIDEject();
    }
    LogM("IDCerRFControl(), nRet = %d", Error_Succeed);
    return Error_Succeed;
}
//
//	Optional.
//	Certificate authentication.
//
ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
{
    LOG_FUNCTION();
    LogM("IDCerAuthenticate() Entry.");
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        LogE("IDCerAuthenticate(), !m_bDevOpen, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }
    DWORD	dwStart = GetTickCount();
    DWORD	dwNow = dwStart;
    DEVSTATUS m_DeviceStatus;
    int pos = -1;
    int nRet;
    bool bCard = false;
    while ((dwNow - dwStart) <= 1000)
    {
        pos = -1;
        memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));
        nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
        if (nRet != IDDIGITALCOPIER_NO_ERROR)
        {
            char err[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(err, "通讯异常%d", nRet);
            SaveErrorInfo(err, Error_DevCommFailed);
            LogE("IDCerAuthenticate(), 通讯异常%d, nRet=%d", nRet, Error_DevCommFailed);
            return Error_DevCommFailed;
        }
        if ((m_DeviceStatus.iStatusInputSensorHaveCard == 1) &&
            (m_DeviceStatus.iStatusMiddleSensorHaveCard == 0) &&
            (m_DeviceStatus.iStatusScanSensorHaveCard ==0))
        {
            pos = 2;
        }
        else if ((m_DeviceStatus.iStatusMiddleSensorHaveCard == 1) ||
                    (m_DeviceStatus.iStatusScanSensorHaveCard ==1))
        {
            pos = 1;
        }
        else
        {
            pos = 0;
        }
        if (pos <= 0)
        {
            usleep(100*1000);
            dwNow = GetTickCount();
        }
        else
        {
            bCard = true;
            break;
        }
    }
    if (!bCard)
    {
        SaveErrorInfo("未检测到卡", Error_Unexpect);
        LogE("IDCerAuthenticate()，未检测到卡, nRet=%d", Error_Unexpect);
        return Error_Unexpect;
    }

    nRet = m_cBS_ID81IDCImpl.CheckIdCard(SecDeviceNum, 100);
    if ((IDDIGITALCOPIER_TIMEOUT_ERROR == nRet) ||
        (IDDIGITALCOPIER_NO_CARD == nRet))
    {
        SaveErrorInfo("未检测到卡", Error_Unexpect);
        LogE("IDCerAuthenticate()，未检测到卡, nRet=%d", Error_Unexpect);
        return Error_Unexpect;
    }
    else if (IDDIGITALCOPIER_NO_ERROR != nRet)
    {
        char err[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(err, "通讯失败%d", nRet);
        SaveErrorInfo(err, Error_DevConnFailed);
        LogE("IDCerAuthenticate()，通讯失败，nRet=%d", nRet, Error_DevConnFailed);
        return Error_DevConnFailed;
    }
    int iCardType = -1;
    memset(&m_IDInfoEx, 0x00, sizeof(IDInfoEx));
    memset(&m_IDForeignInfo, 0x00, sizeof(IDInfoForeign));
    memset(&m_IDInfoGAT, 0x00, sizeof(IDInfoGAT));
    memset(PhotoPath, 0, MAX_FILE_PATH);
    std::string dllPath;
    int bRet = GetDllPathLocal(dllPath);
    memcpy(PhotoPath, dllPath.c_str(), dllPath.length());
    dllPath += "zp.bmp";
    char FileName0[256]={0};
    memcpy(FileName0, dllPath.c_str(), dllPath.length());
    std::string strLog = "IDCerAuthenticate(),PhotoPath=[" + dllPath + "]";
    LogM("%s",strLog.c_str());
    nRet = m_cBS_ID81IDCImpl.GetMyIDCardType(SecDeviceNum, &iCardType);
    if(nRet == IDDIGITALCOPIER_NO_ERROR)
    {

    }
    else if (nRet == IDDIGITALCOPIER_IDDATA_PROCESS_ERROR)
    {
        SaveErrorInfo("无效卡", Error_DevMedia);
        LogE("IDCerAuthenticate()，无效卡, nRet=%d", Error_DevMedia);
        //m_cBS_ID81IDCImpl.BackAndHoldCard(SecDeviceNum);
        return Error_DevMedia;
    }
    else
    {
        SaveErrorInfo("通讯异常", Error_DevCommFailed);
        LogE("IDCerAuthenticate()，通讯异常%d，nRet=%d", nRet, Error_DevCommFailed);
        return Error_DevCommFailed;
    }

    void *AllTypeInfo = NULL;
    if (iCardType == 0)                     // 0-身份证
    {
        AllTypeInfo = &m_IDInfoEx;
    }
    else if (iCardType == 1)                //1-外国人居住证
    {
        AllTypeInfo = &m_IDForeignInfo;
    }
    else if (iCardType == 2)                //2-港澳台
    {
        AllTypeInfo = &m_IDInfoGAT;
    }
    else
    {

    }
    if (iCardType == 2)
    {
        nRet = m_cBS_ID81IDCImpl.GetMyGATIDInfo(SecDeviceNum, &m_IDInfoGAT, FileName0);

    }
    else
    {
        nRet = m_cBS_ID81IDCImpl.GetAllTypeCardInfo(SecDeviceNum, iCardType, AllTypeInfo, FileName0);
    }


    if(nRet == IDDIGITALCOPIER_NO_ERROR)
    {
        LogM("IDCerAuthenticate()，认证成功");
    }
    else if ((nRet == IDDIGITALCOPIER_NO_ERROR) ||
        (nRet == IDDIGITALCOPIER_IDDATA_PROCESS_ERROR))    //身份证电子信息处理错误
    {
        SaveErrorInfo("无效卡", Error_DevMedia);
        LogE("IDCerAuthenticate()，无效卡, nRet=%d", Error_DevMedia);
        m_cBS_ID81IDCImpl.BackAndHoldCard(SecDeviceNum);
        return Error_DevMedia;
    }
    else
    {
        char err[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(err, "通讯失败%d", nRet);
        SaveErrorInfo(err, Error_DevConnFailed);
        LogE("IDCerAuthenticate()通讯失败, nRet=%d", Error_DevCommFailed);
        return Error_DevConnFailed;
    }
    m_bAuthed = true;     // true：认证成功；
    m_iCardType = iCardType;    // 认证成功后，卡的类型；
    LogM("IDCerAuthenticate(), nRet=%d", Error_Succeed);
    return Error_Succeed;
}
//  获取证件信息，包括二代身份证、外国人永久居留证
//	Get Identity Card info.
//
ErrorCodeEnum IDCerClassImpl::IDCerGetData(IDCerInfo &idCerInfo)
{
    LOG_FUNCTION();
    LogM("IDCerGetData() Entry.");
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        LogE("IDCerGetData()，设备未打开, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }
    if (!m_bAuthed)
    {
        SaveErrorInfo("未认证成功。", Error_DevMedia);
        LogE("IDCerGetData()，未认证成功, nRet=%d", Error_DevMedia);
        return Error_DevMedia;
    }
    m_bAuthed = false;  //认证成功只能读一次，下次必须重新认证；
    std::string dllPath;
    int bRet = GetDllPathLocal(dllPath);
    std::string ckStr = dllPath + "ck.bmp";
    std::string zpStr = dllPath + "zp.bmp";
    std::string commond="mv"+std::string(" ")+ckStr+std::string(" ")+zpStr;
    system(commond.c_str());
    std::string strLog = "IDCerGetData(),ckStr=[" + ckStr + "],zpStr=[" + zpStr + "]";
    LogM("%s",strLog.c_str());
    memset(PhotoPath, 0, MAX_FILE_PATH);
    memcpy(PhotoPath, zpStr.c_str(), zpStr.length());

    memset(&idCerInfo, 0, sizeof(IDCerInfo));
    //--------在IDCerAuthenticate里，对有效卡读出数据，在IDCerGetData和IDCerGetDataEx不再去读数据，否则应用会崩溃（未知原因，参考E1000的处理）；
    if (m_iCardType == 0)     //0-身份证
    {
        //身份证
        //1姓名
        std::string dataStr = m_IDInfoEx.name;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.name.data,m_IDInfoEx.name);
        idCerInfo.name.dwSize = dataStr.size();

        //2性别
        dataStr = m_IDInfoEx.sex;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.sex.data, m_IDInfoEx.sex);
        idCerInfo.sex.dwSize = dataStr.size();

        //3国籍（民族）
        dataStr = m_IDInfoEx.nation;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.nation.data, m_IDInfoEx.nation);
        idCerInfo.nation.dwSize = dataStr.size();

        //4出生日期
        dataStr = m_IDInfoEx.birthday;
        dataStr = trim(dataStr);
        std::string year = dataStr.substr(0, 4);
        std::string month = dataStr.substr(4, 2);
        std::string day = dataStr.substr(6, 2);
        std::string date = year + "年" + month + "月" + day + "日";
        strcpy_s(idCerInfo.birthday.data, date.c_str());
        idCerInfo.birthday.dwSize = dataStr.size();

        //5地址
        dataStr = m_IDInfoEx.address;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.address.data,m_IDInfoEx.address);
        idCerInfo.address.dwSize = dataStr.size();

        //6身份证号
        dataStr = m_IDInfoEx.number;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.idno.data, m_IDInfoEx.number);
        idCerInfo.idno.dwSize = dataStr.size();

        //7发证机关
        dataStr = m_IDInfoEx.department;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.department.data, m_IDInfoEx.department);
        idCerInfo.department.dwSize = dataStr.size();

        //8有效期起始时间
        char starttime[9];
        memset(starttime, 0, 9);
        for (int i=0; i<8; i++)
        {
            starttime[i] = m_IDInfoEx.timeLimit[i];
        }
        starttime[8]='\0';
        dataStr = starttime;
        dataStr = dataStr.insert(4,1,'.');
        dataStr = dataStr.insert(7,1,'.');
        strcpy_s(idCerInfo.startDate.data, dataStr.c_str());
        idCerInfo.startDate.dwSize = dataStr.size();

        //9有效期终止时间
        int len = strlen(m_IDInfoEx.timeLimit);
        if (len > 15)
        {
            char endtime[9]={0};
            for (int i=0; i<8; i++)
            {
                if( m_IDInfoEx.timeLimit[i] != '.' )
                {
                    endtime[i] = m_IDInfoEx.timeLimit[i + 9];
                }
            }
            endtime[8] = '\0';
            dataStr = endtime;
            dataStr = dataStr.insert(4,1,'.');
            dataStr = dataStr.insert(7,1,'.');
            strcpy_s(idCerInfo.endDate.data, dataStr.c_str());
            idCerInfo.endDate.dwSize = dataStr.size();
        }
        else
        {
            dataStr = m_IDInfoEx.timeLimit;
            dataStr = dataStr.substr(9, len-9);
            strcpy_s(idCerInfo.endDate.data, dataStr.c_str());
            idCerInfo.endDate.dwSize = dataStr.size();
        }

        //10附加地址
        memset(idCerInfo.newAddress.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfo.newAddress.dwSize = 0;

        //11头像图片保存地址
        dataStr = PhotoPath;
        strcpy_s(idCerInfo.photoPath.data, PhotoPath);
        idCerInfo.photoPath.dwSize = dataStr.size();
        LogM("IDCerGetData(), 身份证");
    }
    else if (m_iCardType == 1)      //1-外国人居住证
    {
        //外国人
        //1姓名
        std::string dataStr = m_IDForeignInfo.NameCHN;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.name.data,m_IDForeignInfo.NameCHN);
        idCerInfo.name.dwSize = dataStr.size();

        //2性别
        dataStr = m_IDForeignInfo.Sex;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.sex.data, m_IDForeignInfo.Sex);
        idCerInfo.sex.dwSize = dataStr.size();

        //2019-06-11
        //3国籍  ID81开发包没有中文国籍，先用英文代码；
        //2019-09-06 V1.0.0.9---------此项为民族，只是二代证专用，见IDCerInfoEx解释；
        //dataStr = m_IDForeignInfo.Nation;
        //dataStr = trim(dataStr);
        //strcpy_s(idCerInfo.nation.data, m_IDForeignInfo.Nation);
        //idCerInfo.nation.dwSize = dataStr.size();
        memset(idCerInfo.nation.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfo.nation.dwSize = 0;

        //4出生日期
        dataStr = m_IDForeignInfo.Born;
        dataStr = trim(dataStr);
        std::string year = dataStr.substr(0, 4);
        std::string month = dataStr.substr(4, 2);
        std::string day = dataStr.substr(6, 2);
        std::string date = year + "年" + month + "月" + day + "日";
        strcpy_s(idCerInfo.birthday.data, date.c_str());
        idCerInfo.birthday.dwSize = dataStr.size();

        //5地址
        memset(idCerInfo.address.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfo.address.dwSize = 0;

        //6证件号码
        dataStr = m_IDForeignInfo.IDCardNO;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.idno.data, m_IDForeignInfo.IDCardNO);
        idCerInfo.idno.dwSize = dataStr.size();

        //7发证机关
        dataStr = m_IDForeignInfo.Department;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.department.data, m_IDForeignInfo.Department);
        idCerInfo.department.dwSize = dataStr.size();

        //8有效期起始时间
        dataStr = m_IDForeignInfo.TimeLimitBegin;
        dataStr = trim(dataStr);
        dataStr = dataStr.insert(4,1,'.');
        dataStr = dataStr.insert(7,1,'.');
        strcpy_s(idCerInfo.startDate.data, dataStr.c_str());
        idCerInfo.startDate.dwSize = dataStr.size();

        //9有效期终止时间
        dataStr = m_IDForeignInfo.TimeLimitEnd;
        dataStr = trim(dataStr);
        //2019-06-11 修改，注释下面语句，拷贝到endDate(原来拷贝到startDate，错)；
        //if (strlen(m_IDForeignInfo.TimeLimitEnd) == 8)
        {
            dataStr = dataStr.insert(4,1,'.');
            dataStr = dataStr.insert(7,1,'.');
        }
        strcpy_s(idCerInfo.endDate.data, dataStr.c_str());
        idCerInfo.endDate.dwSize = dataStr.size();

        //10附加地址
        memset(idCerInfo.newAddress.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfo.newAddress.dwSize = 0;

        //11头像图片文件保存地址
        dataStr = PhotoPath;
        strcpy_s(idCerInfo.photoPath.data, PhotoPath);
        idCerInfo.photoPath.dwSize = dataStr.size();
        LogM("IDCerGetData(), 外国人");
    }
    else if (m_iCardType == 2)      //2-港澳台
    {
        //港澳台
        //1姓名
        std::string dataStr = m_IDInfoGAT.name;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.name.data, m_IDInfoGAT.name);
        idCerInfo.name.dwSize = dataStr.size();

        //2性别
        dataStr = m_IDInfoGAT.sex;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.sex.data, m_IDInfoGAT.sex);
        idCerInfo.sex.dwSize = dataStr.size();

        //3民族
        memset(idCerInfo.nation.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfo.nation.dwSize = 0;

        //4出生日期
        dataStr = m_IDInfoGAT.birthday;
        dataStr = trim(dataStr);
        std::string year = dataStr.substr(0, 4);
        std::string month = dataStr.substr(4, 2);
        std::string day = dataStr.substr(6, 2);
        std::string date = year + "年" + month + "月" + day + "日";
        strcpy_s(idCerInfo.birthday.data, date.c_str());
        idCerInfo.birthday.dwSize = dataStr.size();

        //5地址
        dataStr = m_IDInfoGAT.address;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.address.data,m_IDInfoGAT.address);
        idCerInfo.address.dwSize = dataStr.size();

        //6身份证号
        dataStr = m_IDInfoGAT.number;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.idno.data, m_IDInfoGAT.number);
        idCerInfo.idno.dwSize = dataStr.size();

        //7发证机关
        dataStr = m_IDInfoGAT.department;
        dataStr = trim(dataStr);
        strcpy_s(idCerInfo.department.data, m_IDInfoGAT.department);
        idCerInfo.department.dwSize = dataStr.size();

        //8有效期起始时间
        char starttime[9];
        memset(starttime, 0, 9);
        for (int i=0; i<8; i++)
        {
            starttime[i] = m_IDInfoGAT.timeLimit[i];
        }
        starttime[8]='\0';
        dataStr = starttime;
        dataStr = dataStr.insert(4,1,'.');
        dataStr = dataStr.insert(7,1,'.');
        strcpy_s(idCerInfo.startDate.data, dataStr.c_str());
        idCerInfo.startDate.dwSize = dataStr.size();

        //9有效期终止时间
        int len = strlen(m_IDInfoGAT.timeLimit);
        if (len > 15)
        {
            char endtime[9]={0};
            for (int i=0; i<8; i++)
            {
                if( m_IDInfoGAT.timeLimit[i] != '.' )
                {
                    endtime[i] = m_IDInfoGAT.timeLimit[i + 9];
                }
            }
            endtime[8] = '\0';
            dataStr = endtime;
            dataStr = dataStr.insert(4,1,'.');
            dataStr = dataStr.insert(7,1,'.');
            strcpy_s(idCerInfo.endDate.data, dataStr.c_str());
            idCerInfo.endDate.dwSize = dataStr.size();
        }
        else
        {
            dataStr = m_IDInfoGAT.timeLimit;
            dataStr = dataStr.substr(9, len-9);
            strcpy_s(idCerInfo.endDate.data, dataStr.c_str());
            idCerInfo.endDate.dwSize = dataStr.size();
        }

        //10最新地址
        memset(idCerInfo.newAddress.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfo.newAddress.dwSize = 0;

        //11头像保存路径和文件名
        dataStr = PhotoPath;
        strcpy_s(idCerInfo.photoPath.data, PhotoPath);
        idCerInfo.photoPath.dwSize = dataStr.size();
        LogM("IDCerGetData(), 港澳台");
    }
    else
    {
        //无效卡（这里包括港澳台居住证，因为未接到招行提出改造此接口要求；）
        SaveErrorInfo("无效卡", Error_DevMedia);
        LogE("IDCerGetData(), 无效卡, nRet=%d", Error_DevMedia);
        return Error_DevMedia;
    }
    LogM("IDCerGetData(), nRet=%d", Error_Succeed);
    LogM("IDCerGetData() return:\
              \nName:%s\n Sex:%s\nNation: %s\nBirth: %s\nAddress:%s\nIDCode:%s\
            \nDepart: %s\nStartDate: %s\nEndDate: %s\nNewAddress:%s\nPhotoPath:%s\n",
            idCerInfo.name.data, idCerInfo.sex.data, idCerInfo.nation.data,
            idCerInfo.birthday.data, idCerInfo.address.data, idCerInfo.idno.data,
            idCerInfo.department.data, idCerInfo.startDate.data, idCerInfo.endDate.data,
            idCerInfo.newAddress.data, idCerInfo.photoPath.data);
    return Error_Succeed;
}
//2017-06-19 增加外国人永久居留证接口
//  获取证件信息，包括二代身份证、外国人永久居留证
//	Get Identity Card info.
//
ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx(IDCerInfoEx &idCerInfoEx)
{
    LOG_FUNCTION();
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        LogE("IDCerGetDataEx()，设备未打开, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }
    if (!m_bAuthed)
    {
        SaveErrorInfo("未认证成功。", Error_DevMedia);
        LogE("IDCerGetDataEx()，未认证成功, nRet=%d", Error_DevMedia);
        return Error_DevMedia;
    }
    m_bAuthed = false;  //认证成功只能读一次，下次必须重新认证；

    std::string dllPath;
    int bRet = GetDllPathLocal(dllPath);

    std::string ckStr = dllPath + "ck.bmp";
    std::string zpStr = dllPath + "zp.bmp";
    std::string commond="mv"+std::string(" ")+ckStr+std::string(" ")+zpStr;
    system(commond.c_str());

    std::string strLog = "IDCerGetData(),ckStr=[" + ckStr + "],zpStr=[" + zpStr + "]";
    LogM("%s",strLog.c_str());
    memset(PhotoPath, 0, MAX_FILE_PATH);
    memcpy(PhotoPath, zpStr.c_str(), zpStr.length());

    memset(&idCerInfoEx, 0, sizeof(IDCerInfoEx));

    if (m_iCardType == 0)    //0-身份证
    {
        //身份证
        //1姓名
        std::string dataStr = m_IDInfoEx.name;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.name.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.name.data, m_IDInfoEx.name);
        idCerInfoEx.name.dwSize = dataStr.size();

        //2性别
        dataStr = m_IDInfoEx.sex;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.sex.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.sex.data, m_IDInfoEx.sex);
        idCerInfoEx.sex.dwSize = dataStr.size();

        //3民族
        dataStr = m_IDInfoEx.nation;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.nation.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.nation.data, m_IDInfoEx.nation);
        idCerInfoEx.nation.dwSize = dataStr.size();

        //4出生日期
        dataStr = m_IDInfoEx.birthday;
        dataStr = trim(dataStr);
        std::string year = dataStr.substr(0, 4);
        std::string month = dataStr.substr(4, 2);
        std::string day = dataStr.substr(6, 2);
        std::string date = year + "年" + month + "月" + day + "日";
        memset(idCerInfoEx.birthday.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.birthday.data, date.c_str());
        idCerInfoEx.birthday.dwSize = dataStr.size();

        //5地址
        dataStr = m_IDInfoEx.address;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.address.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.address.data,m_IDInfoEx.address);
        idCerInfoEx.address.dwSize = dataStr.size();

        //6身份证号
        dataStr = m_IDInfoEx.number;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.idno.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.idno.data, m_IDInfoEx.number);
        idCerInfoEx.idno.dwSize = dataStr.size();

        //7发证机关
        dataStr = m_IDInfoEx.department;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.department.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.department.data, m_IDInfoEx.department);
        idCerInfoEx.department.dwSize = dataStr.size();

        //8有效期起始时间
        char starttime[9];
        memset(starttime, 0, 9);
        for (int i=0; i<8; i++)
        {
            starttime[i] = m_IDInfoEx.timeLimit[i];
        }
        starttime[8]='\0';
        dataStr = starttime;
        dataStr = dataStr.insert(4,1,'.');
        dataStr = dataStr.insert(7,1,'.');
        memset(idCerInfoEx.startDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.startDate.data, dataStr.c_str());
        idCerInfoEx.startDate.dwSize = dataStr.size();

        //9有效期终止时间
        int len = strlen(m_IDInfoEx.timeLimit);
        if (len > 15)
        {
            char endtime[9]={0};
            for (int i=0; i<8; i++)
            {
                if( m_IDInfoEx.timeLimit[i] != '.' )
                {
                    endtime[i] = m_IDInfoEx.timeLimit[i + 9];
                }

            }
            endtime[8] = '\0';
            dataStr = endtime;
            dataStr = dataStr.insert(4,1,'.');
            dataStr = dataStr.insert(7,1,'.');
            memset(idCerInfoEx.endDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
            strcpy_s(idCerInfoEx.endDate.data, dataStr.c_str());
            idCerInfoEx.endDate.dwSize = dataStr.size();
        }
        else
        {
            dataStr = m_IDInfoEx.timeLimit;
            dataStr = dataStr.substr(9, len-9);
            memset(idCerInfoEx.endDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
            strcpy_s(idCerInfoEx.endDate.data, dataStr.c_str());
            idCerInfoEx.endDate.dwSize = dataStr.size();
        }

        //10最新地址
        memset(idCerInfoEx.newAddress.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfoEx.newAddress.dwSize = 0;

        //11头像保存路径和文件名
        dataStr = PhotoPath;
        memset(idCerInfoEx.photoPath.data, 0, MAX_IDCER_PHOTO_PATH);
        strcpy_s(idCerInfoEx.photoPath.data, PhotoPath);
        idCerInfoEx.photoPath.dwSize = dataStr.size();

        //12英文姓名
        memset(idCerInfoEx.englishName.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfoEx.englishName.dwSize = 0;

        //13民族代码
        memset(idCerInfoEx.nationality.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.nationality.dwSize = 0;

        //14证件版本号
        memset(idCerInfoEx.idVersion.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.idVersion.dwSize = 0;

        //15证件类型标识，空（二代证），'I'（外国人），'J'（港澳台）
        memset(idCerInfoEx.idType.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.idType.dwSize = 0;

        //16保留字段
        memset(idCerInfoEx.reserved.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.reserved.dwSize = 0;

        //港澳台扩展
        /* 先注释这部分，因为测试工具DevTestTool.exe暂不支持；
        */
        //17通行证号码
        memset(idCerInfoEx.txzCode.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.txzCode.dwSize = 0;

        //18签发次数
        memset(idCerInfoEx.issuedSN.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.issuedSN.dwSize = 0;

        //19备用2
        memset(idCerInfoEx.reserved2.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved2.dwSize = 0;

        //20备用3
        memset(idCerInfoEx.reserved3.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved3.dwSize = 0;

        //21备用4
        memset(idCerInfoEx.reserved4.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved4.dwSize = 0;

        //22备用5
        memset(idCerInfoEx.reserved5.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved5.dwSize = 0;
        LogM("IDCerGetDataEx(), 身份证");
    }
    else if	(m_iCardType == 1)      //1-外国人居住证
    {
        //外国人
        //1姓名
        std::string dataStr = m_IDForeignInfo.NameCHN;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.name.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.name.data,m_IDForeignInfo.NameCHN);
        idCerInfoEx.name.dwSize = dataStr.size();

        //2性别
        dataStr = m_IDForeignInfo.Sex;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.sex.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.sex.data, m_IDForeignInfo.Sex);
        idCerInfoEx.sex.dwSize = dataStr.size();

        //2019-06-11
        //3国籍  ID81开发包没有中文国籍，先用英文代码；
        memset(idCerInfoEx.nation.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.nation.dwSize = 0;

        //4出生日期
        dataStr = m_IDForeignInfo.Born;
        dataStr = trim(dataStr);
        std::string year = dataStr.substr(0, 4);
        std::string month = dataStr.substr(4, 2);
        std::string day = dataStr.substr(6, 2);
        std::string date = year + "年" + month + "月" + day + "日";
        memset(idCerInfoEx.birthday.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.birthday.data, date.c_str());
        idCerInfoEx.birthday.dwSize = dataStr.size();

        //5地址
        memset(idCerInfoEx.address.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfoEx.address.dwSize = 0;

        //6证件号码
        dataStr = m_IDForeignInfo.IDCardNO;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.idno.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.idno.data, m_IDForeignInfo.IDCardNO);
        idCerInfoEx.idno.dwSize = dataStr.size();

        //7发证机关
        dataStr = m_IDForeignInfo.Department;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.department.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.department.data, m_IDForeignInfo.Department);
        idCerInfoEx.department.dwSize = dataStr.size();

        //8有效期起始时间
        dataStr = m_IDForeignInfo.TimeLimitBegin;
        dataStr = trim(dataStr);
        dataStr = dataStr.insert(4,1,'.');
        dataStr = dataStr.insert(7,1,'.');
        memset(idCerInfoEx.startDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.startDate.data, dataStr.c_str());
        idCerInfoEx.startDate.dwSize = dataStr.size();

        //9有效期终止时间
        dataStr = m_IDForeignInfo.TimeLimitEnd;
        dataStr = trim(dataStr);
        //2019-06-11 修改，注释下面语句，拷贝到endDate(原来拷贝到startDate，错)；
        //if (strlen(m_IDForeignInfo.TimeLimitEnd) == 8)
        {
            dataStr = dataStr.insert(4,1,'.');
            dataStr = dataStr.insert(7,1,'.');
        }
        memset(idCerInfoEx.endDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.endDate.data, dataStr.c_str());
        idCerInfoEx.endDate.dwSize = dataStr.size();
        //----------------------------------------------

        //10最新地址
        memset(idCerInfoEx.newAddress.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfoEx.newAddress.dwSize = 0;

        //11头像保存路径和文件名
        dataStr = PhotoPath;
        memset(idCerInfoEx.photoPath.data, 0, MAX_IDCER_PHOTO_PATH);
        strcpy_s(idCerInfoEx.photoPath.data, PhotoPath);
        idCerInfoEx.photoPath.dwSize = dataStr.size();

        //12英文姓名，外国人专用
        dataStr = m_IDForeignInfo.NameENG;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.englishName.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.englishName.data, m_IDForeignInfo.NameENG);
        idCerInfoEx.englishName.dwSize = dataStr.size();

        //13国籍或地区代码，外国人专用
        dataStr = m_IDForeignInfo.Nation;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.nationality.data, 0, IDCER_EIGHT_BYTE_SIZE);
        strcpy_s(idCerInfoEx.nationality.data, m_IDForeignInfo.Nation);
        idCerInfoEx.nationality.dwSize = dataStr.size();

        //14证件版本号，外国人专用
        dataStr = m_IDForeignInfo.IDVersion;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.idVersion.data, 0, IDCER_EIGHT_BYTE_SIZE);
        strcpy_s(idCerInfoEx.idVersion.data, m_IDForeignInfo.IDVersion);
        idCerInfoEx.idVersion.dwSize = dataStr.size();

        //15证件类型标识，外国人取值'I'，二代证为空，'J'（港澳台）
        memset(idCerInfoEx.idType.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.idType.dwSize = 1;
        idCerInfoEx.idType.data[0] = 'I';

        //16保留字段，外国人专用
        memset(idCerInfoEx.reserved.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.reserved.dwSize = 0;

        //港澳台扩展
        /* 先注释这部分，因为测试工具DevTestTool.exe暂不支持；
        */
        //17通行证号码
        memset(idCerInfoEx.txzCode.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.txzCode.dwSize = 0;

        //18签发次数
        memset(idCerInfoEx.issuedSN.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.issuedSN.dwSize = 0;

        //19备用2
        memset(idCerInfoEx.reserved2.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved2.dwSize = 0;

        //20备用3
        memset(idCerInfoEx.reserved3.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved3.dwSize = 0;

        //21备用4
        memset(idCerInfoEx.reserved4.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved4.dwSize = 0;

        //22备用5
        memset(idCerInfoEx.reserved5.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved5.dwSize = 0;
        LogM("IDCerGetDataEx(), 外国人");
    }
    else if (m_iCardType == 2)      //2-港澳台
    {
        //港澳台
        //1姓名
        std::string dataStr = m_IDInfoGAT.name;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.name.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.name.data, m_IDInfoGAT.name);
        idCerInfoEx.name.dwSize = dataStr.size();

        //2性别
        dataStr = m_IDInfoGAT.sex;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.sex.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.sex.data, m_IDInfoGAT.sex);
        idCerInfoEx.sex.dwSize = dataStr.size();

        //3民族
        memset(idCerInfoEx.nation.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.nation.dwSize = 0;

        //4出生日期
        dataStr = m_IDInfoGAT.birthday;
        dataStr = trim(dataStr);
        std::string year = dataStr.substr(0, 4);
        std::string month = dataStr.substr(4, 2);
        std::string day = dataStr.substr(6, 2);
        std::string date = year + "年" + month + "月" + day + "日";
        memset(idCerInfoEx.birthday.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.birthday.data, date.c_str());
        idCerInfoEx.birthday.dwSize = dataStr.size();

        //5地址
        dataStr = m_IDInfoGAT.address;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.address.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.address.data,m_IDInfoGAT.address);
        idCerInfoEx.address.dwSize = dataStr.size();

        //6身份证号
        dataStr = m_IDInfoGAT.number;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.idno.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.idno.data, m_IDInfoGAT.number);
        idCerInfoEx.idno.dwSize = dataStr.size();

        //7发证机关
        dataStr = m_IDInfoGAT.department;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.department.data, 0, MAX_IDCER_INFO_SIZE);
        strcpy_s(idCerInfoEx.department.data, m_IDInfoGAT.department);
        idCerInfoEx.department.dwSize = dataStr.size();

        //8有效期起始时间
        char starttime[9];
        memset(starttime, 0, 9);
        for (int i=0; i<8; i++)
        {
            starttime[i] = m_IDInfoGAT.timeLimit[i];
        }
        starttime[8]='\0';
        dataStr = starttime;
        dataStr = dataStr.insert(4,1,'.');
        dataStr = dataStr.insert(7,1,'.');
        memset(idCerInfoEx.startDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.startDate.data, dataStr.c_str());
        idCerInfoEx.startDate.dwSize = dataStr.size();

        //9有效期终止时间
        int len = strlen(m_IDInfoGAT.timeLimit);
        if (len > 15)
        {
            char endtime[9]={0};
            for (int i=0; i<8; i++)
            {
                if( m_IDInfoGAT.timeLimit[i] != '.' )
                {
                    endtime[i] = m_IDInfoGAT.timeLimit[i + 9];
                }
            }
            endtime[8] = '\0';
            dataStr = endtime;
            dataStr = dataStr.insert(4,1,'.');
            dataStr = dataStr.insert(7,1,'.');
            memset(idCerInfoEx.endDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
            strcpy_s(idCerInfoEx.endDate.data, dataStr.c_str());
            idCerInfoEx.endDate.dwSize = dataStr.size();
        }
        else
        {
            dataStr = m_IDInfoGAT.timeLimit;
            dataStr = dataStr.substr(9, len-9);
            memset(idCerInfoEx.endDate.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
            strcpy_s(idCerInfoEx.endDate.data, dataStr.c_str());
            idCerInfoEx.endDate.dwSize = dataStr.size();
        }

        //10最新地址
        memset(idCerInfoEx.newAddress.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfoEx.newAddress.dwSize = 0;

        //11头像保存路径和文件名
        dataStr = PhotoPath;
        memset(idCerInfoEx.photoPath.data, 0, MAX_IDCER_PHOTO_PATH);
        strcpy_s(idCerInfoEx.photoPath.data, PhotoPath);
        idCerInfoEx.photoPath.dwSize = dataStr.size();

        //12英文姓名
        memset(idCerInfoEx.englishName.data, 0, MAX_IDCER_INFO_SIZE);
        idCerInfoEx.englishName.dwSize = 0;

        //13民族代码
        memset(idCerInfoEx.nationality.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.nationality.dwSize = 0;

        //14证件版本号
        memset(idCerInfoEx.idVersion.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.idVersion.dwSize = 0;

        //15证件类型标识，空（二代证），'I'（外国人），'J'（港澳台）
        memset(idCerInfoEx.idType.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.idType.dwSize = 1;
        idCerInfoEx.idType.data[0] = 'J';

        //16保留字段
        memset(idCerInfoEx.reserved.data, 0, IDCER_EIGHT_BYTE_SIZE);
        idCerInfoEx.reserved.dwSize = 0;

        //港澳台扩展
        /* 先注释这部分，因为测试工具DevTestTool.exe暂不支持；
        */
        //17通行证号码
        dataStr = m_IDInfoGAT.passport;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.txzCode.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        strcpy_s(idCerInfoEx.txzCode.data, m_IDInfoGAT.passport);
        idCerInfoEx.txzCode.dwSize = dataStr.size();

        //18签发次数
        dataStr = m_IDInfoGAT.issue;
        dataStr = trim(dataStr);
        memset(idCerInfoEx.issuedSN.data, 0, IDCER_EIGHT_BYTE_SIZE);
        strcpy_s(idCerInfoEx.issuedSN.data,m_IDInfoGAT.issue);
        idCerInfoEx.issuedSN.dwSize = dataStr.size();

        //19备用2
        memset(idCerInfoEx.reserved2.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved2.dwSize = 0;

        //20备用3
        memset(idCerInfoEx.reserved3.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved3.dwSize = 0;

        //21备用4
        memset(idCerInfoEx.reserved4.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved4.dwSize = 0;

        //22备用5
        memset(idCerInfoEx.reserved5.data, 0, MAX_IDCER_SIMPLE_INFO_SIZE);
        idCerInfoEx.reserved5.dwSize = 0;
        //g_pLog->Print("IDCerGetDataEx(), 港澳台");
        LogM("IDCerGetDataEx(), 港澳台");
    }
    else
    {
        //无效卡（这里包括港澳台居住证，因为未接到招行提出改造此接口要求；）
        SaveErrorInfo("无效卡", Error_DevMedia);
        //g_pLog->Print("IDCerGetDataEx(), 无效卡, nRet=%d", Error_DevMedia);
        return Error_DevMedia;
    }
    LogM("IDCerGetDataEx(), nRet=%d", Error_Succeed);
    LogM("IDCerGetDataEx() return:\
                          \nName:%s\n Sex:%s\nNation: %s\nBirth: %s\nAddress:%s\nIDCode:%s\nDepart: %s\nStartDate: %s\nEndDate: %s\
                                              \nNewAddress: %s\nphotoPath: %s\nEnglishName: %s\nNationality: %s\nIdVersin: %s\nIdType: %s\nreserved: %s\nissuedSN: %s\
                                              \nzCotxde: %s\nreserved2: %s\nreserved3: %s\nreserved4: %s\nreserved5: %s",
                                              idCerInfoEx.name.data, idCerInfoEx.sex.data, idCerInfoEx.nation.data,
                                              idCerInfoEx.birthday.data, idCerInfoEx.address.data, idCerInfoEx.idno.data,
                                              idCerInfoEx.department.data, idCerInfoEx.startDate.data, idCerInfoEx.endDate.data,
                                              idCerInfoEx.newAddress.data, idCerInfoEx.photoPath.data, idCerInfoEx.englishName.data,
                                              idCerInfoEx.nationality.data, idCerInfoEx.idVersion.data, idCerInfoEx.idType.data,
                                              idCerInfoEx.reserved.data, idCerInfoEx.issuedSN.data, idCerInfoEx.txzCode.data,
                                              idCerInfoEx.reserved2.data, idCerInfoEx.reserved3.data, idCerInfoEx.reserved4.data, idCerInfoEx.reserved5.data);
    return Error_Succeed;
}

ErrorCodeEnum IDCerClassImpl::ForceIDEject()
{
    LOG_FUNCTION();
    LogM("ForceIDEject() Entry.");
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        //g_pLog->Print("ForceIDEject(), 设备未打开, nRet=%d", Error_DevNotAvailable);
        LogM("ForceIDEject(), 设备未打开, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }
    int pos = -1;
    ErrorCodeEnum nRet = QueryCardPos(pos);
    if ((nRet == Error_Succeed) && pos == 0)
    {
        SaveErrorInfo("未检测到卡", Error_DevMedia);
        LogM("ForceIDEject(), 未检测到卡, nRet=%d", Error_DevMedia);
        return Error_DevMedia;
    }
    int bRet = m_cBS_ID81IDCImpl.EjectIdCard(SecDeviceNum);
    if (bRet != IDDIGITALCOPIER_NO_ERROR)
    {
        SaveErrorInfo("通讯异常", Error_DevCommFailed);
        LogM("ForceIDEject(), 通讯异常, nRet=%d", Error_DevCommFailed);
        return Error_DevCommFailed;
    }
    LogM("ForceIDEject(), nRet=%d", Error_Succeed);
    return Error_Succeed;
}

ErrorCodeEnum IDCerClassImpl::ScanIDAndSaveImage()
{
    LOG_FUNCTION();
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        LogM("ScanIDAndSaveImage(), 设备未打开, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }
    memset(PhotoPath, 0, MAX_FILE_PATH);
    std::string dllPath;
    GetDllPathLocal(dllPath);
    memcpy(PhotoPath, dllPath.c_str(), dllPath.length());
    char FileNamefront[256] = {0};
    char FileNameback[256] = {0};
    strcpy_s(FileNamefront, PhotoPath);
    strcat_s(FileNamefront, "idfront.bmp");
    strcpy_s(FileNameback, PhotoPath);
    strcat_s(FileNameback, "idback.bmp");
    int nRet = m_cBS_ID81IDCImpl.StartScan(SecDeviceNum);
    if (nRet != IDDIGITALCOPIER_NO_ERROR)
    {
        SaveErrorInfo("通讯异常", Error_DevCommFailed);
        LogM("ScanIDAndSaveImage(), 通讯异常, nRet=%d", Error_DevCommFailed);
        return Error_DevCommFailed;
    }
    int iFrontLen;
    int iRearLen;
    //--------------改为与厂家DEMO相似，采用NEW方式申请数组空间；
    char* cFrontImgBuf = new char[MAX_PICTURE_SIZE];
    char* cRearImgBuf = new char[MAX_PICTURE_SIZE];
    nRet=m_cBS_ID81IDCImpl.ReadCard(SecDeviceNum, cFrontImgBuf, cRearImgBuf, &iFrontLen, &iRearLen);
    if (iFrontLen > 0)
    {
        nRet = m_cBS_ID81IDCImpl.SaveToFile(SecDeviceNum, cFrontImgBuf, iFrontLen, FileNamefront, 1);
        if (nRet != IDDIGITALCOPIER_NO_ERROR)
        {
            SaveErrorInfo("通讯异常", Error_DevCommFailed);
            nRet = m_cBS_ID81IDCImpl.BackAndHoldCard(SecDeviceNum);
            LogM("ScanIDAndSaveImage(), 通讯异常, nRet=%d", Error_DevCommFailed);
            delete []cFrontImgBuf;
            delete []cRearImgBuf;
            return Error_DevCommFailed;
        }
    }
    if (iRearLen>0)
    {
        nRet = m_cBS_ID81IDCImpl.SaveToFile(SecDeviceNum,cRearImgBuf,iRearLen,FileNameback,1);
        if (nRet != IDDIGITALCOPIER_NO_ERROR)
        {
            SaveErrorInfo("通讯异常", Error_DevCommFailed);
            nRet = m_cBS_ID81IDCImpl.BackAndHoldCard(SecDeviceNum);
            LogM("ScanIDAndSaveImage(), 通讯异常, nRet=%d", Error_DevCommFailed);
            delete []cFrontImgBuf;
            delete []cRearImgBuf;
            return Error_DevCommFailed;
        }
    }
    nRet = m_cBS_ID81IDCImpl.BackAndHoldCard(SecDeviceNum);
    LogM("ScanIDAndSaveImage(), nRet=%d", Error_Succeed);
    delete []cFrontImgBuf;
    delete []cRearImgBuf;
    return Error_Succeed;
}

ErrorCodeEnum IDCerClassImpl::QueryCardPos(int &pos)
{
    LOG_FUNCTION();
    LogM("QueryCardPos() Entry.");
    if(!m_bDevOpen)
    {
        SaveErrorInfo("设备未打开", Error_DevNotAvailable);
        LogM("QueryCardPos(), 设备未打开, nRet=%d", Error_DevNotAvailable);
        return Error_DevNotAvailable;
    }

    DEVSTATUS m_DeviceStatus;
    memset(&m_DeviceStatus, 0x00, sizeof(DEVSTATUS));

    int nRet = m_cBS_ID81IDCImpl.DeviceStatus(SecDeviceNum, &m_DeviceStatus);
    if (nRet != IDDIGITALCOPIER_NO_ERROR)
    {
        SaveErrorInfo("通讯异常", Error_DevCommFailed);
        LogM("QueryCardPos(), 通讯异常, nRet=%d", Error_DevCommFailed);
        return Error_DevCommFailed;
    }

    if ((m_DeviceStatus.iStatusInputSensorHaveCard == 1) &&
        (m_DeviceStatus.iStatusMiddleSensorHaveCard == 0) &&
        (m_DeviceStatus.iStatusScanSensorHaveCard ==0))
    {
        pos = 2;
        LogM("QueryCardPos(), pos=2, 证件在进卡口");
    }
    if ((m_DeviceStatus.iStatusMiddleSensorHaveCard == 1) ||
        (m_DeviceStatus.iStatusScanSensorHaveCard ==1))
    {
        pos = 1;
        LogM("QueryCardPos(), pos=1, 证件在读卡器内部");
    }
    if ((m_DeviceStatus.iStatusInputSensorHaveCard == 0) &&
        (m_DeviceStatus.iStatusMiddleSensorHaveCard == 0) &&
        (m_DeviceStatus.iStatusScanSensorHaveCard ==0))
    {
        pos = 0;
        LogM("QueryCardPos(), pos=0, 未检测到任何证件");
    }
    LogM("QueryCardPos(), nRet=%d", Error_Succeed);
    return Error_Succeed;
}


//Private
void IDCerClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
{
    LOG_FUNCTION();
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    sprintf(m_szErrMsg, "%s[%d]", errMsg, errCode);
}
int IDCerClassImpl::string_format(std::string &str, const std::string fmt, ...)
{
    char *buf;
    va_list ap;

    va_start(ap, fmt);
    int len = vprintf (fmt.c_str(), ap) + 1;
    buf = (char *) malloc (len * sizeof (char));
    if (!buf)
    {
        return -1;
    }
    memset(buf, 0, len);
    int nRet = vsnprintf (buf, len, fmt.c_str(), ap);
    va_end(ap);

    str = std::string(buf);
    free(buf);

    return nRet;
}
//删除某目录下的文件，不删除子目录文件，不放回回收站，支持通配符*、?，例如：SH_DeleteFileOrDirectory("c:\\data\\1??.*");
//删除所有文件夹及文件，不放回回收站，例如：SH_DeleteFileOrDirectory("c:\\data");
bool IDCerClassImpl::SH_DeleteFileOrDirectory(char *strFileName)
{
    int nLength = strlen(strFileName);
    char *strSrc = new char[nLength+2];
    memset(strSrc, 0, nLength+2);
    //strcpy(strSrc, strFileName);
    strcpy_s(strSrc, nLength+1, strFileName);
    strSrc[nLength+1] = '\0';

   std::string trash_path="/root/.local/share/Trash/";
   trash_path=trash_path+std::string(strSrc);
   std::string commond="cp"+std::string(" ")+std::string(strSrc)+std::string(" ")+trash_path;
   bool ret=system(commond.c_str());

   if (ret == false)
   {
       return ret;
   }
   //ret = file.remove(); //删除文件
   ret=remove(strSrc);

   delete []strSrc;

    return ret;
}
std::string& IDCerClassImpl::trim(std::string &sStr, std::string sPatten)
{
    if (sStr.empty())
    {
        return sStr;
    }
    sStr.erase(0, sStr.find_first_not_of(sPatten));
    sStr.erase(sStr.find_last_not_of(sPatten) + 1);
    return sStr;
}