myvtm/DevAdapter/simulator/idcer.1.1/idcer_impl.cpp

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "stdafx.h"
#include "idcer_impl.h"
#include <cstring>
#include <cstdio>
#include "log4vendor.h"
#include <path.h>

#ifdef RVC_OS_WIN
#include <direct.h>
#define GetCurrentDir _getcwd
#else
#define GetCurrentDir getcwd
#endif // RVC_OS_WIN


#define w 102 //头像宽度
#define h 126 //头像高度

#define DEFAULT_URL "http://localhost:8080/avs/imitate/simulateData"

string get_current_directory() {
    char buff[256];
    GetCurrentDir(buff, 256);
    string  current_working_directory(buff);
    return current_working_directory;
}

//string GetLocalIP()
//{
//    hostent* ent = gethostbyname(NULL);
//    if (ent && ent->h_addr_list[0] != NULL)
//    {
//        int i = 0;
//        for (; ent->h_addr_list[i] != NULL; ++i)
//        {
//            struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
//            if (in->S_un.S_un_b.s_b1 == 99 || in->S_un.S_un_b.s_b1 == 10)
//                break;
//        }
//
//        if (ent->h_addr_list[i] == NULL)
//            i = 0;
//
//        auto in = (struct in_addr*)ent->h_addr_list[i];
//        char xIP[64] = {};
//        sprintf(xIP, "%d.%d.%d.%d", in->S_un.S_un_b.s_b1, in->S_un.S_un_b.s_b2, in->S_un.S_un_b.s_b3, in->S_un.S_un_b.s_b4);
//        LOG4VTM(INFO, "ip:" << xIP);
//
//        return string(xIP);
//    }
//}

typedef unsigned short UINT16;
typedef unsigned char UINT8;

#ifdef RVC_OS_WIN
char* ConvertGBKToUtf8(const char* gbk, int* n)
{
    int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
    WCHAR* wszGBK = new WCHAR[len + 1];
    memset(wszGBK, 0, len * 2 + 2);
    MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);

    len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
    char* szUtf8 = new char[len + 1];
    memset(szUtf8, 0, len + 1);
    WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);

    delete[] wszGBK;
    *n = len - 1;
    return szUtf8;
}

void ConvertGBKToUtf8(std::string& str)
{
    int len = 0;
    char* dst = ConvertGBKToUtf8(str.c_str(), &len);

    str = dst;
    delete[] dst;
}
#endif // RVC_OS_WIN

bool UTF8_to_UCS2(const UINT8* UINT8_code, UINT16* ucs2_code)
{
    UINT16 temp1, temp2;
    bool is_unrecognized = false;
    UINT8* in = (UINT8*)UINT8_code;

    if (!UINT8_code || !ucs2_code)
    {
        return is_unrecognized;
    }

    while (*in != 0)
    {
        //1字节 0xxxxxxx
        //0x80=1000,0000，判断最高位是否为0，如果为0，那么是ASCII字符
        //不需要处理，直接拷贝即可
        if (0x00 == (*in & 0x80))
        {
            /* 1 byte UTF-8 Charater.*/
            *ucs2_code = *in;
            is_unrecognized = true;
            in += 1;
        }
        //2字节 110xxxxx 10xxxxxx 
        //0xe0=1110,0000
        //0xc0=1100,0000
        else if (0xc0 == (*in & 0xe0) && 0x80 == (*(in + 1) & 0xc0))
        {
            /* 2 bytes UTF-8 Charater.*/
            //0x1f=0001,1111，获得第一个字节的后5位
            temp1 = (UINT16)(*in & 0x1f);

            //左移6位
            temp1 <<= 6;

            //0x3f=0011,1111，获得第二个字节的后6位
            //加上上面的5位一共有11位
            temp1 |= (UINT16)(*(in + 1) & 0x3f);

            *ucs2_code = temp1;

            is_unrecognized = true;

            in += 2;
        }
        //3字节 1110xxxx 10xxxxxx 10xxxxxx
        //中文要进入这一个分支
        else if (0xe0 == (*in & 0xf0) &&
            0x80 == (*(in + 1) & 0xc0) &&
            0x80 == (*(in + 2) & 0xc0)
            )
        {
            /* 3bytes UTF-8 Charater.*/
            //0x0f=0000,1111
            //取出第一个字节的低4位
            temp1 = (UINT16)(*in & 0x0f);
            temp1 <<= 12;

            //0x3f=0011,1111
            //取得第二个字节的低6位
            temp2 = (UINT16)(*(in + 1) & 0x3F);
            temp2 <<= 6;

            //取得第三个字节的低6位，最后组成16位
            temp1 = temp1 | temp2 | (UINT16)(*(in + 2) & 0x3F);
            *ucs2_code = temp1;

            //移动到下一个字符
            in += 3;
            is_unrecognized = true;
        }
        else
        {
            /* unrecognize byte. */
            *ucs2_code = 0x22e0;
            is_unrecognized = false;

            //直接退出循环
            break;
        }

        ucs2_code += 1;
    }

    return is_unrecognized;
}


std::string current_working_directory()
{
    char buff[250];
    GetCurrentDir(buff, 250);
    std::string current_working_directory(buff);
    return current_working_directory;
}

void WriteBMP(char* img, const char* filename)
{
    int l = (w * 3 + 3) / 4 * 4;
    int bmi[] = {
            l * h + 54,0,54,40,w,h,1 | 3 * 8 << 16,0,l * h,0,0,100,0 };
    FILE* fp = fopen(filename, "wb");
    fprintf(fp, "BM");
    fwrite(&bmi, 52, 1, fp);
    fwrite(img, 1, l * h, fp);
    fclose(fp);
}

IDCerClassImpl::IDCerClassImpl()
    :m_mode(0)
{
    lastErrMsg = "";
}

IDCerClassImpl::~IDCerClassImpl()
{

}

ErrorCodeEnum IDCerClassImpl::GetDevCategory(DevCategoryInfo& devCategory)
{

    ErrorCodeEnum err = Error_Succeed;
    err = Error_Unexpect;
    lastErrMsg = "{\"Description\": \"测试模式，获取适配器信息失败\"}";
    return err;

    strcpy(devCategory.szModel, "STYLE=IG#FUNCTION=ITF#CODE=UCS2");
    strcpy(devCategory.szType, "szCategory");
    strcpy(devCategory.szVendor, "szVendor=cmbszSimulator");
    return err;
}

ErrorCodeEnum IDCerClassImpl::Reset()
{
    ErrorCodeEnum err = Error_Succeed;
    m_mode = 0;
    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
{
    ErrorCodeEnum err = Error_Succeed;
    /*bool flag = authHttpFunction();
    m_mode = 0;

    if (!flag)
    {
        err = Error_Dev_IDCardNotFound;
        lastErrMsg = "未识别到身份证件";
    }*/
    SimulatorCommonAns ans;
    err = SimulatorHttpFunction("IDCertificate", "IDCerAuthenticate", ans);

    return err;
}

ErrorCodeEnum IDCerClassImpl::ForceIDEject()
{
    ErrorCodeEnum err = Error_Succeed;
    m_mode = 0;
    return err;
}

ErrorCodeEnum IDCerClassImpl::ScanIDAndSaveImage()
{
    ErrorCodeEnum err = Error_NotImpl;
    m_mode = 0;
    SimulatorCommonAns ans;
    err = SimulatorHttpFunction("IDCertificate", "ScanIDAndSaveImage", ans);
    return err;
}

ErrorCodeEnum IDCerClassImpl::QueryCardPos(int& pos)
{
    ErrorCodeEnum err = Error_Succeed;
    m_mode = 0;

    SimulatorCommonAns ans;
    err = SimulatorHttpFunction("IDCertificate", "QueryCardPos", ans);

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerRFControl(bool bControl)
{
    ErrorCodeEnum err = Error_Succeed;
    m_mode = 0;

    if (!bControl)
    {
        SimulatorCommonAns ans;
        err = SimulatorHttpFunction("IDCertificate", "IDCerRFControl", ans);
    }

    return err;
}

ErrorCodeEnum IDCerClassImpl::DevOpen(DWORD dwPort)
{
    depCfgPath = get_current_directory() + SPLIT_SLASH_STR + "dep" + SPLIT_SLASH_STR + "cmbsz.ini";
    bool ret = iniRead.ReadConfig(depCfgPath);
    if (ret == false)
    {
        LOG4VTM(INFO, "dep ReadConfig is Error,cfg=" << depCfgPath);
    }

    ErrorCodeEnum err = Error_Succeed;
    return err;
}

ErrorCodeEnum IDCerClassImpl::DevClose()
{
    ErrorCodeEnum err = Error_Succeed;
    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerGetData(IDCerInfo& idCerInfo)
{
    ErrorCodeEnum err = Error_Succeed;
    memset(&idCerInfo, 0, sizeof(IDCerInfo));


    strcpy(idCerInfo.startDate.data, "2009.03.25");
    idCerInfo.startDate.dwSize = strlen("2009.03.25");

    strcpy(idCerInfo.endDate.data, "2029.03.24");
    idCerInfo.endDate.dwSize = strlen("2029.03.24");

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx(IDCerInfoEx& idCerInfoEx)
{
    ErrorCodeEnum err = Error_Succeed;
    memset(&idCerInfoEx, 0, sizeof(IDCerInfoEx));

    std::string path;
    path = current_working_directory();
    path = path + "/dep/zp.bmp";

    char img[w * h * 3];
    for (int i = 0; i < w * h * 3; i++)img[i] = rand() % 256;
    WriteBMP(img, path.c_str());
    bool testRe = exHttpFunction(idCerInfoEx);

    return err;
}

ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx2(IDCerInfoEx2& idCerInfoEx2)
{
    ErrorCodeEnum err = Error_Succeed;
    memset(&idCerInfoEx2, 0, sizeof(IDCerInfoEx2));

    bool testRe = ex2HttpFunction(idCerInfoEx2);
    if (!testRe)
    {
        lastErrMsg = "{\"Description\": \"获取身份证芯片数据失败\"}";
        err = Error_Unexpect;
        return err;
    }

    std::string path;
    path = current_working_directory();
    path = path + "/dep/zp.bmp";

    char img[w * h * 3];
    for (int i = 0; i < w * h * 3; i++)img[i] = rand() % 256;
    WriteBMP(img, path.c_str());

    return err;
}


ErrorCodeEnum IDCerClassImpl::GetLastErr(DevErrorInfo& devErrInfo)
{
    static int times = 0;
    char szMessage[128];
    //sprintf(szMessage, "这是第 %d 条错误信息", ++times);

    bool flag = authHttpFunction("GetLastErr");
    if (!flag)
    {
        lastErrMsg = "";
    }

    strcpy(devErrInfo.szErrMsg, lastErrMsg.c_str());
    devErrInfo.dwErrMsgLen = lastErrMsg.length();
    return Error_Succeed;
}

bool IDCerClassImpl::authHttpFunction(string depName)
{
    IHttpFunc* client;
    client = create_http(HttpsLogCallBack);

    IDCerDevReq idCerReq;
    IDCerDevRet idCerRet;

    idCerReq.ip = GetLocalIP();
    idCerReq.entityName = "IDCertificate";
    idCerReq.method = "readAndScan";
    idCerReq.adapterInterName = depName.c_str();

    string url = GetSimulatorUrl();
    if (url.length() == 0)
    {
        url = DEFAULT_URL;
    }
    idCerReq.m_url = url;

    LOG4VTM(INFO, "请求地址:" << idCerReq.m_url.c_str());

    bool ret = client->Post(idCerReq, idCerRet);

    if (ret) {
        if (idCerRet.success == false)
        {
            LOG4VTM(INFO, "请求失败");
            return false;
        }

        if (idCerRet.result == true)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        LOG4VTM(INFO, "ret = 0, 请求失败");
        return false;
    }
}

bool IDCerClassImpl::exHttpFunction(IDCerInfoEx& idCerInfoEx)
{
    IHttpFunc* client;
    client = create_http(HttpsLogCallBack);

    IDCerDevReq idCerReq;
    IDCerDevRet idCerRet;

    idCerReq.ip = GetLocalIP();
    idCerReq.entityName = "IDCertificate";
    idCerReq.method = "readAndScan";
    idCerReq.adapterInterName = "IDCerGetDataEx";

    string url = GetSimulatorUrl();
    if (url.length() == 0)
    {
        url = DEFAULT_URL;
    }
    idCerReq.m_url = url;

    LOG4VTM(INFO, "请求地址:" << idCerReq.m_url.c_str());

    bool ret = client->Post(idCerReq, idCerRet);

    if (ret) {
        if (!idCerRet.success)
        {
            LOG4VTM(INFO, "请求失败");
            return false;
        }

        std::strcpy(idCerInfoEx.name.data, idCerRet.name.c_str());
        idCerInfoEx.name.dwSize = strlen(idCerRet.name.c_str());

        std::strcpy(idCerInfoEx.sex.data, idCerRet.sex.c_str());
        idCerInfoEx.sex.dwSize = strlen(idCerRet.sex.c_str());

        std::strcpy(idCerInfoEx.nation.data, idCerRet.nation.c_str());
        idCerInfoEx.nation.dwSize = strlen(idCerRet.nation.c_str());

        std::strcpy(idCerInfoEx.birthday.data, idCerRet.birthday.c_str());
        idCerInfoEx.birthday.dwSize = strlen(idCerRet.birthday.c_str());

        std::strcpy(idCerInfoEx.address.data, idCerRet.address.c_str());
        idCerInfoEx.address.dwSize = strlen(idCerRet.address.c_str());

        if (strlen(idCerRet.idcode.c_str()) == 0)
        {
            idCerRet.idcode = "testnum00000";
        }
        std::strcpy(idCerInfoEx.idno.data, idCerRet.idcode.c_str());
        idCerInfoEx.idno.dwSize = strlen(idCerRet.idcode.c_str());

        std::strcpy(idCerInfoEx.department.data, idCerRet.department.c_str());
        idCerInfoEx.department.dwSize = strlen(idCerRet.department.c_str());

        std::strcpy(idCerInfoEx.startDate.data, idCerRet.startdate.c_str());
        idCerInfoEx.startDate.dwSize = strlen(idCerRet.startdate.c_str());

        std::strcpy(idCerInfoEx.endDate.data, idCerRet.enddate.c_str());
        idCerInfoEx.endDate.dwSize = strlen(idCerRet.enddate.c_str());

        std::strcpy(idCerInfoEx.englishName.data, idCerRet.englishname.c_str());
        idCerInfoEx.englishName.dwSize = strlen(idCerRet.englishname.c_str());

        std::strcpy(idCerInfoEx.nationality.data, idCerRet.nationality.c_str());
        idCerInfoEx.nationality.dwSize = strlen(idCerRet.nationality.c_str());

        std::strcpy(idCerInfoEx.idVersion.data, idCerRet.idversion.c_str());
        idCerInfoEx.idVersion.dwSize = strlen(idCerRet.idversion.c_str());

        std::strcpy(idCerInfoEx.idType.data, idCerRet.idtype.c_str());
        idCerInfoEx.idType.dwSize = strlen(idCerRet.idtype.c_str());

        std::strcpy(idCerInfoEx.reserved.data, idCerRet.reserved.c_str());
        idCerInfoEx.reserved.dwSize = strlen(idCerRet.reserved.c_str());

        return true;
    }
    else
    {
        LOG4VTM(INFO, "ret = 0, 请求失败");
        return false;
    }
}


bool IDCerClassImpl::ex2HttpFunction(IDCerInfoEx2& idCerInfoEx2)
{
    IHttpFunc* client;
    client = create_http(HttpsLogCallBack);

    IDCerDevReq idCerReq;
    IDCerDevRet idCerRet;

    idCerReq.ip = GetLocalIP();
    idCerReq.entityName = "IDCertificate";
    idCerReq.adapterInterName = "IDCerGetDataEx2";

    string url = GetSimulatorUrl();
    if (url.length() == 0)
    {
        url = DEFAULT_URL;
    }
    idCerReq.m_url = url;

    LOG4VTM(INFO, "请求地址:" << idCerReq.m_url.c_str());

    bool ret = client->Post(idCerReq, idCerRet);
    if (ret) {
        if (!idCerRet.success)
        {
            LOG4VTM(INFO, "请求失败");
            return false;
        }


        if (idCerRet.name.length() <= 0)
        {
            return false;
        }

#ifdef RVC_OS_WIN
        ConvertGBKToUtf8(idCerRet.name);
        ConvertGBKToUtf8(idCerRet.englishname);
        ConvertGBKToUtf8(idCerRet.sex);
        ConvertGBKToUtf8(idCerRet.birthday);
        ConvertGBKToUtf8(idCerRet.address);
        ConvertGBKToUtf8(idCerRet.department);
        ConvertGBKToUtf8(idCerRet.idcode);
        ConvertGBKToUtf8(idCerRet.startdate);
        ConvertGBKToUtf8(idCerRet.enddate);
        ConvertGBKToUtf8(idCerRet.nation);
        ConvertGBKToUtf8(idCerRet.nationality);        
#endif // RVC_OS_WIN

        char name[1024]; memset(name, 0, 1024);
        std::strcpy(name, idCerRet.name.c_str());
        UTF8_to_UCS2((UINT8*)name, (UINT16*)idCerInfoEx2.name.data);
        idCerInfoEx2.name.dwSize = strlen(idCerInfoEx2.name.data);

        char englishname[1024]; memset(englishname, 0, 1024);
        std::strcpy(englishname, idCerRet.englishname.c_str());
        UTF8_to_UCS2((UINT8*)englishname, (UINT16*)idCerInfoEx2.englishName.data);
        idCerInfoEx2.englishName.dwSize = strlen(idCerInfoEx2.englishName.data);

        char sex[1024]; memset(sex, 0, 1024);
        std::strcpy(sex, idCerRet.sex.c_str());
        UTF8_to_UCS2((UINT8*)sex, (UINT16*)idCerInfoEx2.sex.data);
        idCerInfoEx2.sex.dwSize = strlen(idCerInfoEx2.sex.data);

        char birthday[1024]; memset(birthday, 0, 1024);
        std::strcpy(birthday, idCerRet.birthday.c_str());
        UTF8_to_UCS2((UINT8*)birthday, (UINT16*)idCerInfoEx2.birthday.data);
        idCerInfoEx2.birthday.dwSize = strlen(idCerInfoEx2.birthday.data);

        char address[1024]; memset(address, 0, 1024);
        std::strcpy(address, idCerRet.address.c_str());
        UTF8_to_UCS2((UINT8*)address, (UINT16*)idCerInfoEx2.address.data);
        idCerInfoEx2.address.dwSize = strlen(idCerInfoEx2.address.data);

        char department[1024]; memset(department, 0, 1024);
        std::strcpy(department, idCerRet.department.c_str());
        UTF8_to_UCS2((UINT8*)department, (UINT16*)idCerInfoEx2.department.data);
        idCerInfoEx2.department.dwSize = strlen(idCerInfoEx2.department.data);

        char idno[1024]; memset(idno, 0, 1024);
        std::strcpy(idno, idCerRet.idcode.c_str());
        UTF8_to_UCS2((UINT8*)idno, (UINT16*)idCerInfoEx2.idno.data);
        idCerInfoEx2.idno.dwSize = strlen(idCerInfoEx2.idno.data);

        char startDate[1024]; memset(startDate, 0, 1024);
        std::strcpy(startDate, idCerRet.startdate.c_str());
        UTF8_to_UCS2((UINT8*)startDate, (UINT16*)idCerInfoEx2.startDate.data);
        idCerInfoEx2.startDate.dwSize = strlen(idCerInfoEx2.startDate.data);

        char endDate[1024]; memset(endDate, 0, 1024);
        std::strcpy(endDate, idCerRet.enddate.c_str());
        UTF8_to_UCS2((UINT8*)endDate, (UINT16*)idCerInfoEx2.endDate.data);
        idCerInfoEx2.endDate.dwSize = strlen(idCerInfoEx2.endDate.data);

        char nation[1024]; memset(nation, 0, 1024);
        std::strcpy(nation, idCerRet.nation.c_str());
        UTF8_to_UCS2((UINT8*)nation, (UINT16*)idCerInfoEx2.nation.data);
        idCerInfoEx2.nation.dwSize = strlen(idCerInfoEx2.nation.data);

        char nationality[1024]; memset(nationality, 0, 1024);
        std::strcpy(nationality, idCerRet.nationality.c_str());
        UTF8_to_UCS2((UINT8*)nationality, (UINT16*)idCerInfoEx2.nationality.data);
        idCerInfoEx2.nationality.dwSize = strlen(idCerInfoEx2.nationality.data);

        return true;
    }
    else
    {
        LOG4VTM(INFO, "ret = 0, 请求失败");
        return false;
    }
}

#ifdef RVC_OS_WIN
BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
#endif // RVC_OS_WIN

DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass*& pBaseObj)
{
    pBaseObj = new IDCerClassImpl();
    if (pBaseObj == NULL)
        return Error_Resource;

    cmb::log_init_config config;
    config.dev_name = "vendor_IDCertificate";
#ifdef RVC_OS_WIN
    config.log_dir = ("D:\\rvc\\dbg\\");
#else
    config.log_dir = ("/opt/rvc/dbg/");
#endif 
    std::string str;
    cmb::log4vendor::init(config, str);
    printf("init after: %s\n", str.c_str());

    return Error_Succeed;
}
DEVICEBASE_API ErrorCodeEnum ReleaseDevComponent(DeviceBaseClass*& pBaseObj)
{
    if (pBaseObj == NULL)
        return Error_Param;
    IDCerClassImpl* pTmp = (IDCerClassImpl*)(pBaseObj);
    delete pTmp;
    pTmp = NULL;
    pBaseObj = NULL;
    return Error_Succeed;
}

#ifdef NEWER_COMPILER_WORKAROUNDS

DEVICEBASE_API ErrorCodeEnum  GetDevAdapterVersion(DevSoftVersion& retVesion)
{
    retVesion.wMajor = retVesion.wMinor = retVesion.wBuild = retVesion.wRevision = 0;
    return Error_Succeed;
}

#endif // NEWER_COMPILER_WORKAROUNDS