• Linux下对PC/SC智能卡接口编程

    PC/SC（Personal Computer/Smart Card）规范，PC/SC 规范作为读卡器和卡与计算机之间有一个标准接口，实现不同生产商的卡和读卡器之间的交互操作

    Linux下运行的源码pcsc-lite 在http://pcsclite.alioth.debian.org/
    其中有demo例程

    1.建立资源管理器上下文

    1. LONG SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1,LPCVOID pvReserved2, LPSCARDCONTEXT phContext);
    2.  
    3. 说明：这必须是在PC / SC应用程序中调用的第一个 SCard函数，所有的应用进程都必须建立自己的上下文环境
    4. 参数：
    5.     dwScope:        输入类型：表示上下文建立的范围，建立本地连接或远程连接，目前支持 SCARD_SCOPE_SYSTEM（在系统域中完成设备数据库操作）
    6.     pvReserved1:    输入类型：保留，为NULL
    7.     pvReserved2:    输入类型：保留，为NULL
    8.     phContext:      输出类型：返回创建的资源管理器上下文
    9. 返回：
    10.     成功返回 SCARD_S_SUCCESS
    11.     失败返回其他值，定义在 pcsclite.h
    12.  
    13. //@code
    14. SCARDCONTEXT hContext;
    15. LONG rv;
    16.  
    17. rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &posContext);
    18. if(rv != SCARD_S_SUCCESS)
    19. {
    20.     LOGE("SCardEstablishContext::failed!\n");
    21.     ret = ERROR_APP_CONTEXT;
    22.     return ret;
    23. }

    2.获取系统可用读卡器列表

    1. LONG SCardListReaders(SCARDCONTEXT hContext, /*@unused@*/ LPCSTR mszGroups,LPSTR mszReaders, LPDWORD pcchReaders);
    2. 说明：
    3.     创建上下文后，就可在上下文中获取系统安装的可用的读卡器列表
    4.  
    5. 参数：
    6.     hContext:       输入类型；ScardEstablishContext()建立的资源管理器上下文，不能为NULL
    7.     mszGroups:      输入类型；读卡器组名，为 NULL 时，表示列出所有读卡器。
    8.     mszReaders:     输出类型；系统中安装的读卡器的名字，各个名字之间用'\0'分隔，最后一个名字后面为两个连续的'\0'
    9.     pcchReaders:    输入输出类型；mszReaders 的长度
    10.  
    11.     这个函数在使用时有多种用法，主要是为了给读卡器列表创建空间的方法不同
    12.     1).当mszReaders为 NULL 时，调用一次SCardListReaders会给pcchReaders输出mszReaders所需要的空间大小，然后自己malloc申请内存空间
    13.     2).当mszReaders为 NULL 且pcchReaders = SCARD_AUTOALLOCATE 时，SCardListReaders会自动申请内存，但是用完后必须要使用SCardFreeMemory(hContext, mszReaders)；释放
    14.     3).当mszReaders 不为 NULL 时，需用pcchReaders传入其长度，SCardListReaders会在已申请的空间内存放读卡器列表
    15.  
    16. 返回：
    17.     成功返回 SCARD_S_SUCCESS
    18.     失败返回其他值，定义在 pcsclite.h
    19.  
    20. 这里对3种创建方法做一下代码示例：
    21.  
    22. //@code1
    23. SCARDCONTEXT hContext;
    24. LPSTR mszReaders;
    25. DWORD dwReaders;
    26. LONG rv;
    27. ...
    28. rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
    29. rv = SCardListReaders(hContext, NULL, NULL, &dwReaders);
    30. mszReaders = malloc(sizeof(char)*dwReaders);
    31. rv = SCardListReaders(hContext, NULL, mszReaders, &dwReaders);
    32. ...
    33. free(mszReaders);
    34.  
    35. //@code2
    36. SCARDCONTEXT hContext;
    37. LPSTR mszReaders;
    38. DWORD dwReaders;
    39. LONG rv;
    40. ...
    41. rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
    42. dwReaders = SCARD_AUTOALLOCATE;
    43. rv = SCardListReaders(hContext, NULL, mszReaders, &dwReaders);
    44. ...
    45. rv = SCardFreeMemory(hContext, mszReaders);
    46.  
    47. //@code3
    48. SCARDCONTEXT hContext;
    49. LPSTR mszReaders[512];
    50. DWORD dwReaders;
    51. LONG rv;
    52. ...
    53. rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
    54. dwReaders = sizeof(mszReaders);
    55. rv = SCardListReaders(hContext, NULL, mszReaders, &dwReaders);
    56. ...
    57.  
    58. 下边是对读卡器名字的拾取代码
    59. char name[128][3];
    60. ptr = mszReaders;
    61. int count = 0;
    62. while ((*ptr != '\0') && (dwReaders > 0) && (count < 3))
    63. {
    64.     strcpy(&name[0][count], ptr);
    65.     lens = strlen(&name[0][count]);
    66.     ptr += (lens + 1);
    67.     dwReaders -= (lens + 1);
    68.     count++;
    69.     LOGD("SCardListReaders::Reader Count %d Name:%s\n", count, &name[0][count]);
    70. }
    71. 01-17 10:56:44.727: D/smartcardjni(2393): SCardListReaders::Reader Count 1 Name:ZNG Terminal2012-1402 00 00
    72. 01-17 10:56:44.727: D/smartcardjni(2393): SCardListReaders::Reader Count 2 Name:ZNG Terminal2012-1402 01 00

    3.监测卡片插入

    1. LONG SCardGetStatusChange(SCARDCONTEXT hContext, DWORD dwTimeout,SCARD_READERSTATE *rgReaderStates, DWORD cReaders);
    2.  
    3. 说明：
    4.     阻塞监听卡插入或状态发生改变
    5. 参数：
    6.     hContext:       输入类型；ScardEstablishContext()建立的资源管理器上下文
    7.     dwTimeout:      输入类型；监听等待时间，0 或 INFINITE(0xFFFFFFFF)表示永久等待
    8.     rgReaderStates: 输入输出类型；SCARD_READERSTATE 结构体
    9.     cReaders:       输入类型；卡通道数
    10. 返回：
    11.     成功返回 SCARD_S_SUCCESS
    12.     失败返回其他值，定义在 pcsclite.h
    13. typedef struct
    14. {
    15.     const char *szReader;   //读卡器名
    16.     void *pvUserData;       //私有数据
    17.     DWORD dwCurrentState;   //读卡器当前状态
    18.     DWORD dwEventState;     //读卡器状态改变后的事件
    19.     DWORD cbAtr;            //ATR长度
    20.     unsigned char rgbAtr[MAX_ATR_SIZE];//ATR
    21. }
    22. SCARD_READERSTATE, *LPSCARD_READERSTATE;
    23.  
    24. //@code
    25. SCARDCONTEXT hContext;
    26. SCARD_READERSTATE rgReaderStates[2];
    27. LONG rv;
    28. ...
    29. rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
    30. ...
    31. rgReaderStates[0].szReader = "Reader X";
    32. rgReaderStates[0].dwCurrentState = SCARD_STATE_UNAWARE;
    33.  
    34. rgReaderStates[1].szReader = "\\\\?PnP?\\Notification";
    35. rgReaderStates[1].dwCurrentState = SCARD_STATE_UNAWARE;
    36. ...
    37. rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 2);
    38. printf("reader state: 0x%04X\n", rgReaderStates[0].dwEventState);
    39. printf("reader state: 0x%04X\n", rgReaderStates[1].dwEventState);
    40. if(rgReaderStates[0].dwEventState & SCARD_STATE_PRESENT)//卡片插入
    41. {
    42.  
    43. }
    44. if(rgReaderStates[0].dwEventState & SCARD_STATE_EMPTY)//卡片移除
    45. {
    46.  
    47. }
    48. //@endcode

    4.连接读卡器

    1. LONG SCardConnect(SCARDCONTEXT hContext, LPCSTR szReader,DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,LPDWORD pdwActiveProtocol);
    2. 说明：使用该接口后，读卡器上电读取ATR
    3.  
    4. 参数：
    5.     hContext:               输入类型；ScardEstablishContext()建立的资源管理器上下文
    6.     szReader:               输入类型：要连接的读卡器名
    7.     dwShareMode:            输入类型：连接类型   SCARD_SHARE_SHARED      多个应用共享同一个智能卡
    8.                                                 SCARD_SHARE_EXCLUSIVE   应用独占智能卡
    9.                                                 SCARD_SHARE_DIRECT      私有类型，不允许其他应用访问
    10.     dwPreferredProtocols:   输入类型：使用的协议类型 
    11.                                         SCARD_PROTOCOL_T0       T=0协议
    12.                                         SCARD_PROTOCOL_T1       T=1协议
    13.                                         SCARD_PROTOCOL_RAW      原始协议
    14.     phCard:                 输出类型：卡的连接句柄
    15.     pdwActiveProtocol:      输出类型：实际使用的协议
    16.                                         SCARD_PROTOCOL_T0   Use the T=0 protocol.
    17.                                         SCARD_PROTOCOL_T1   Use the T=1 protocol.
    18. 返回：
    19.     成功返回 SCARD_S_SUCCESS
    20.     失败返回其他值，定义在 pcsclite.h
    21.  
    22.     rv = SCardConnect(hContext, "Reader X", SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &hCard, &dwActiveProtocol);

    5.获取卡片状态和ATR

    1. LONG SCardStatus(SCARDHANDLE hCard, LPSTR mszReaderName,LPDWORD pcchReaderLen, LPDWORD pdwState,LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen);
    2. 说明：
    3. 参数：
    4.     hCard:          输入类型：SCardConnect()建立的卡连接句柄
    5.     mszReaderName:  输入输出类型：连接的读卡器名
    6.     pcchReaderLen:  输入输出类型：mszReaderName 的长度，使用方法同 SCardListReaders 中的 pcchReaders
    7.     pdwState:       输出类型：读卡器的当前状态
    8.                                 SCARD_UNKNOWN           0x0001  /**< Unknown state */
    9.                                 SCARD_ABSENT            0x0002  /**< Card is absent */
    10.                                 SCARD_PRESENT           0x0004  /**< Card is present */
    11.                                 SCARD_SWALLOWED         0x0008  /**< Card not powered */
    12.                                 SCARD_POWERED           0x0010  /**< Card is powered */
    13.                                 SCARD_NEGOTIABLE        0x0020  /**< Ready for PTS */
    14.                                 SCARD_SPECIFIC          0x0040  /**< PTS has been set */
    15.     pdwProtocol:    输出类型：读卡器当前协议类型
    16.                                 SCARD_PROTOCOL_T0   Use the T=0 protocol.
    17.                                 SCARD_PROTOCOL_T1   Use the T=1 protocol.
    18.     pbAtr:          输出类型：当前卡片的ATR
    19.     pcbAtrLen:      输入输出类型：pbAtr 的长度，使用方法同 SCardListReaders 中的 pcchReaders
    20. 返回：
    21.     成功返回 SCARD_S_SUCCESS
    22.     失败返回其他值，定义在 pcsclite.h
    23. //@code
    24. ...
    25. dwAtrLen = sizeof(pbAtr);
    26. dwReaderLen = sizeof(pbReader);
    27. rv = SCardStatus(posReaderList.readerList[using_reader_id].hCard, pbReader, &dwReaderLen, &dwState, &dwProt, pbAtr, &dwAtrLen);
    28. if (rv != SCARD_S_SUCCESS)
    29. {
    30.     LOGE("SCardStatus %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    31.     ret = SCARD_STATUS_FALSE;
    32. }
    33. LOGD("pbReader: %s\n", pbReader);
    34. LOGD("pbAtr: %s\n", pbAtr);

    6.读卡器数据传输

    1. LONG SCardTransmit(SCARDHANDLE hCard, const SCARD_IO_REQUEST *pioSendPci,LPCBYTE pbSendBuffer, DWORD cbSendLength, SCARD_IO_REQUEST *pioRecvPci, LPBYTE pbRecvBuffer,LPDWORD pcbRecvLength);
    2.  
    3. 说明：从卡连接成功后就能进行APDU数据传输
    4. 参数：
    5.     hCard:          输入类型：SCardConnect()建立的卡连接句柄
    6.     pioSendPci:     输入输出类型：发送的指令协议头结构的指针，由 SCARD_IO_REQUEST 结构定义
    7.     pbSendBuffer:   输入类型：发送给卡的APDU指令
    8.     cbSendLength:   输入类型：APDU的长度
    9.     pioRecvPci:     输入输出类型：接收的指令协议头结构的指针，由 SCARD_IO_REQUEST 结构定义，如果不返回可设置为NULL
    10.     pbRecvBuffer:   输出类型：从卡返回的数据
    11.     pcbRecvLength:  输入输出类型：pbRecvBuffer 的实际大小
    12. 返回：
    13.     成功返回 SCARD_S_SUCCESS
    14.     失败返回其他值，定义在 pcsclite.h
    15.  
    16.  
    17. typedef struct
    18. {
    19.     unsigned long dwProtocol;   /**< Protocol identifier */
    20.     unsigned long cbPciLength;  /**< Protocol Control Inf Length */
    21. }SCARD_IO_REQUEST, *PSCARD_IO_REQUEST, *LPSCARD_IO_REQUEST;
    22.  
    23. //@code
    24. rv = SCardConnect(hContext, "Reader X", SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &hCard, &dwActiveProtocol);
    25. dwSendLength = sizeof(pbSendBuffer);
    26. dwRecvLength = sizeof(pbRecvBuffer);
    27. rv = SCardTransmit(hCard, SCARD_PCI_T0, pbSendBuffer, dwSendLength,&pioRecvPci, pbRecvBuffer, &dwRecvLength);

    7.独占访问

    这组操作一遍用于SCardTransmit() 前后，让传输操作更加安全可靠

    1. LONG SCardBeginTransaction(SCARDHANDLE hCard);
    2. 说明：启动一个事务，阻止其它应用程序访问智能卡
    3. 参数：
    4.     hCard:          输入类型：SCardConnect()建立的卡连接句柄
    5.  
    6.  
    7. LONG SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition);
    8. 说明：结束一个事务，允许其它引用程序访问智能卡
    9. 参数：
    10.     hCard:          输入类型：SCardConnect()建立的卡连接句柄
    11.     dwDisposition   输入类型：结束时对读卡器的操作

    8.重新连接读卡器

    1. LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol);
    2. 说明：将正在连接的读卡器重新连接，等于热复位
    3. 参数：
    4.     hCard:                  输入类型：SCardConnect()建立的卡连接句柄
    5.     dwShareMode:            输入类型：连接类型   SCARD_SHARE_SHARED      多个应用共享同一个智能卡
    6.                                         SCARD_SHARE_EXCLUSIVE   应用独占智能卡
    7.                                         SCARD_SHARE_DIRECT      私有类型，不允许其他应用访问
    8.     dwPreferredProtocols:   输入类型：使用的协议类型 
    9.                                         SCARD_PROTOCOL_T0       T=0协议
    10.                                         SCARD_PROTOCOL_T1       T=1协议
    11.                                         SCARD_PROTOCOL_RAW      原始协议
    12.     dwInitialization:       输入类型：读卡器指定的操作，常用作重启
    13.                                         SCARD_LEAVE_CARD     - Do nothing.
    14.                                         SCARD_RESET_CARD     - Reset the card (warm reset).
    15.                                         SCARD_UNPOWER_CARD   - Power down the card (cold reset).
    16.                                         SCARD_EJECT_CARD     - Eject the card.
    17.     pdwActiveProtocol:      输出类型：实际使用的协议
    18.  
    19. 返回：
    20.     成功返回 SCARD_S_SUCCESS
    21.     失败返回其他值，定义在 pcsclite.h

    9.断开读卡器

    1. LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition);
    2. 说明：断开读卡器连接
    3. 参数：
    4.     hCard:          输入类型：SCardConnect()建立的卡连接句柄
    5.     dwDisposition   输入类型：断开连接时对读卡器的操作
    6.                                 SCARD_LEAVE_CARD        0x0000  /**< Do nothing on close */
    7.                                 SCARD_RESET_CARD        0x0001  /**< Reset on close */
    8.                                 SCARD_UNPOWER_CARD      0x0002  /**< Power down on close */
    9.                                 SCARD_EJECT_CARD        0x0003  /**< Eject on close */
    10. 返回：
    11.     成功返回 SCARD_S_SUCCESS
    12.     失败返回其他值，定义在 pcsclite.h
    13.  
    14. //@code
    15. rv = SCardDisconnect(hCard, SCARD_UNPOWER_CARD);

    10.释放上下文

    1. LONG SCardReleaseContext(SCARDCONTEXT hContext);
    2. 说明：应用程序终止前，释放资源管理器上下文
    3. 参数：
    4.     hContext:       输入类型；ScardEstablishContext()建立的资源管理器上下文
    5. 返回：
    6.     成功返回 SCARD_S_SUCCESS
    7.     失败返回其他值，定义在 pcsclite.h

    示例代码：

    1.    //***********************************
    2.    #define MAX_READER_COUNTS 3
    3.  
    4.    typedef struct _strReaderListInfo
    5.    {
    6.     char reader[128];
    7.     int trans_begin;
    8.     SCARDHANDLE hCard;
    9.     DWORD dwActiveProtocol;
    10.     SCARD_IO_REQUEST pioSendPci;
    11.     SCARD_IO_REQUEST pioRecvPci;
    12.    }StrReaderListInfo, *pStrReaderListInfo;
    13.  
    14.    typedef struct _strReaderList
    15.    {
    16.     int count;
    17.     StrReaderListInfo readerList[MAX_READER_COUNTS];
    18.    }StrReaderList, *pStrReaderList;
    19.  
    20.    unsigned int posReaderId = 1;    //readerid
    21.    StrReaderList posReaderList = {0};
    22.    SCARDCONTEXT posContext = 0;
    23.    DWORD posActiveProtocol[MAX_READER_COUNTS];
    24.  
    25.  
    26.  
    27.    //上下文初始化
    28.    unsigned int Pcscd_Init()
    29.    {
    30.     LOGD("%s",__FUNCTION__);
    31.     unsigned int ret = ERROR_NONE;
    32.     LONG rv = 0;
    33.     unsigned int lens = 0;
    34.     DWORD dwReaders;
    35.     unsigned char reader_list_buf[512];
    36.     pStrReaderListInfo pStrInfo;
    37.     unsigned char *ptr = NULL;
    38.     unsigned int tryAgain = 0;
    39.  
    40.    START:
    41.     if(posContext != 0)
    42.     {
    43.         LOGE("SCardEstablishContext::Context has already been created,Release!\n");
    44.         rv = SCardReleaseContext(hContext);
    45.         if(rv != SCARD_S_SUCCESS)
    46.         {
    47.             LOGE("SCardReleaseContext::failed!\n");
    48.         }
    49.         hContext = 0;
    50.     }
    51.     //建立上下文
    52.     memset(&posReaderList, 0, sizeof(StrReaderList));
    53.     rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &posContext);
    54.     if(rv != SCARD_S_SUCCESS)
    55.     {
    56.         LOGE("SCardEstablishContext::failed!\n");
    57.         ret = ERROR_APP_CONTEXT;
    58.         return ret;
    59.     }
    60.     LOGD("SCardEstablishContext::success!\n");
    61.  
    62.     //获取读卡器列表
    63.     dwReaders = sizeof(reader_list_buf);
    64.     rv = SCardListReaders(posContext, NULL, reader_list_buf, &dwReaders);               
    65.     if(rv != SCARD_S_SUCCESS)
    66.     {
    67.         LOGE("SCardListReaders::native failed!(0x%x)\n",rv);
    68.         if(posContext != 0)
    69.         {
    70.             SCardReleaseContext(posContext);
    71.             posContext = 0;
    72.  
    73.         }
    74.         if(rv == SCARD_E_NO_READERS_AVAILABLE)
    75.         {
    76.             ret = ERROR_APP_REBOOT_POS;
    77.         }
    78.         else
    79.         {
    80.             ret = ERROR_APP_LISTREADER;
    81.         }
    82.         return ret;
    83.     }
    84.     reader_list_buf[dwReaders] = 0x00;
    85.     reader_list_buf[dwReaders + 1] = 0x00;
    86.  
    87.     posReaderList.count = 0;
    88.     ptr = reader_list_buf;
    89.     while ((*ptr != '\0') && (dwReaders > 0))
    90.     {
    91.         pStrInfo = &posReaderList.readerList[posReaderList.count];
    92.         strcpy(pStrInfo->reader, ptr);
    93.         lens = strlen(pStrInfo->reader);
    94.         ptr += (lens + 1);
    95.         dwReaders -= (lens + 1);
    96.    //       pStrInfo->hCard = 0;
    97.         posReaderList.count++;
    98.         LOGD("SCardListReaders::Reader Count %d Name:%s\n", posReaderList.count, pStrInfo->reader);
    99.         if(posReaderList.count >= MAX_READER_COUNTS)
    100.         {
    101.             break;
    102.         }
    103.     }
    104.     if (posReaderList.count < 2)
    105.     {
    106.         LOGE("[%d]::reader count = %d!!!\n",__LINE__,posReaderList.count);
    107.         SCardStopDeamon(posContext);
    108.         sleep(3);
    109.         if(posContext != 0)
    110.         {
    111.             SCardReleaseContext(posContext);
    112.             posContext = 0;
    113.         }
    114.         if(tryAgain == 0)
    115.         {
    116.             ret = ERROR_NONE;
    117.             tryAgain = 1;
    118.             LOGE("init try again");
    119.             goto START;
    120.         }
    121.         else
    122.         {
    123.             ret = ERROR_APP_LISTREADER;
    124.             return ret;
    125.         }
    126.     }
    127.     LOGD("SCardListReaders::success!\r\n");
    128.  
    129.  
    130.     ret = ERROR_NONE;
    131.     return ret;
    132.    }
    133.  
    134.    //释放上下文
    135.    unsigned int Pcscd_Release()
    136.    {
    137.     LOGD("%s",__FUNCTION__);
    138.     unsigned int ret = ERROR_NONE;
    139.     int rv;
    140.     pStrReaderListInfo pStrInfo;
    141.  
    142.     if(posContext == 0)
    143.     {
    144.         LOGE("SCardReleaseContext::Context has not been created!\n");
    145.         ret = ERROR_NONE;
    146.         return ret;
    147.     }
    148.     memset(&posReaderList, 0, sizeof(StrReaderList));
    149.     rv = SCardReleaseContext(posContext);
    150.     if(rv != SCARD_S_SUCCESS)
    151.     {
    152.         LOGE("SCardReleaseContext::native failed!\n");
    153.         posContext = 0;
    154.         ret = ERROR_APP_CONTEXT;
    155.         return ret;
    156.     }
    157.     posContext = 0;
    158.  
    159.     LOGD("SCardReleaseContext::success!\n");
    160.     ret = ERROR_NONE;
    161.     return ret;
    162.    }
    163.  
    164.    //断开卡连接
    165.    int PBOC_DisConnect(unsigned int using_reader_id)
    166.    {
    167.     LOGD("%s(%d)",__FUNCTION__,using_reader_id);
    168.     LONG rv;
    169.     pStrReaderListInfo pStrInfo;
    170.  
    171.     if(using_reader_id < 0 || using_reader_id >= posReaderList.count)
    172.     {
    173.         LOGE("[%d]reader id is wrong(%d)\n",__LINE__, using_reader_id);
    174.    //       Nok_Reason = ErrorReason_PCSCD_READERS_ID;
    175.         return FALSE;
    176.     }
    177.  
    178.     pStrInfo = &posReaderList.readerList[using_reader_id];
    179.  
    180.     if(pStrInfo->trans_begin == 1)
    181.     {
    182.         rv = SCardEndTransaction(pStrInfo->hCard,SCARD_LEAVE_CARD);
    183.         if (rv != SCARD_S_SUCCESS)
    184.         {
    185.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    186.             {
    187.                 Reset_Reader();
    188.             }
    189.             LOGE("[%d]::SCardEndTransaction: %s (0x%lX)\n",__LINE__ ,pcsc_stringify_error(rv),rv);
    190.         }
    191.         pStrInfo->trans_begin = 0;
    192.     }
    193.  
    194.     if(pStrInfo->hCard != 0)
    195.     {
    196.         rv = SCardDisconnect(pStrInfo->hCard,SCARD_UNPOWER_CARD);
    197.         if (rv != SCARD_S_SUCCESS)
    198.         {
    199.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    200.             {
    201.                 Reset_Reader();
    202.             }
    203.             LOGE("[%d]::SCardDisconnect: %s (0x%lX)\n",__LINE__ ,pcsc_stringify_error(rv),rv);
    204.         }
    205.         pStrInfo->hCard = 0;
    206.     }
    207.  
    208.  
    209.     return TRUE;
    210.    }
    211.    int PBOC_OpenCard(unsigned char* pAtr,unsigned int * pAtrlen)
    212.    {
    213.     int ret;
    214.  
    215.     LOGD("%s",__FUNCTION__);
    216.  
    217.     //检卡
    218.     DWORD dwReaderLen, dwState, dwProt, dwAtrLen;
    219.     BYTE pbAtr[MAX_ATR_SIZE] = "";
    220.     char pbReader[MAX_READERNAME] = "";
    221.  
    222.     pStrReaderListInfo pStrInfo;
    223.     SCARD_READERSTATE rgReaderStates[1];
    224.  
    225.     pStrInfo = &posReaderList.readerList[posReaderId];
    226.     dwAtrLen = sizeof(pbAtr);
    227.     dwReaderLen = sizeof(pbReader);
    228.  
    229.     smart_card_type = 0;
    230.     rgReaderStates[0].szReader =  posReaderList.readerList[posReaderId].reader;
    231.     rgReaderStates[0].dwCurrentState = SCARD_STATE_UNAWARE;
    232.     //检测是否有卡插入
    233.     ret = SCardGetStatusChange(posContext,INFINITE,rgReaderStates,1);
    234.     if (ret != SCARD_S_SUCCESS)
    235.     {
    236.         printf("SCardGetStatusChange err\r\n");
    237.         return -1;
    238.     }
    239.    LOGD("SCardGetStatusChange ok\r\n");
    240.    LOGD("rgReaderStates[0].dwEventState == %ld\r\n",rgReaderStates[0].dwEventState);        
    241.     if(rgReaderStates[0].dwEventState & SCARD_STATE_PRESENT)//卡在
    242.     {
    243.         ret= SCardConnect(posContext, pStrInfo->reader, SCARD_SHARE_SHARED,
    244.                     SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &pStrInfo->hCard, &posActiveProtocol[posReaderId]);
    245.         if (ret == SCARD_S_SUCCESS) 
    246.         {
    247.             ret = SCardStatus(pStrInfo->hCard, pbReader, &dwReaderLen, &dwState, &dwProt,pbAtr, &dwAtrLen);
    248.             if (ret != SCARD_S_SUCCESS)
    249.             {
    250.                 return -1;
    251.             }   
    252.             MyPrintfBuff("CardAtr:",pbAtr, dwAtrLen);
    253.             //判断ATR是否是非接触卡  
    254.             if((pbAtr[2] == 0x81 && pbAtr[3] == 0x01)||(pbAtr[2] == 0x11 && pbAtr[3] == 0x01) )
    255.             {
    256.                 smart_card_type = 2;
    257.             }
    258.             //判断ATR 多张非接触卡  
    259.             else if((pbAtr[1] == 0x70 && pbAtr[2] == 0x11) )
    260.             {
    261.                 smart_card_type = 3;
    262.             }
    263.             //判断ATR是否是接触卡   
    264.             else if(!((pbAtr[2] == 0x81 && pbAtr[3] == 0x01)||(pbAtr[2] == 0x11 && pbAtr[3] == 0x01) ||(pbAtr[1] == 0x60 && pbAtr[2] == 0x00))) 
    265.             {
    266.                 smart_card_type = 1;    
    267.             }
    268.             else
    269.             {
    270.                 smart_card_type = -1;
    271.             }
    272.             switch(posActiveProtocol[posReaderId])
    273.             {
    274.                 case SCARD_PROTOCOL_T0:
    275.                     pStrInfo->pioSendPci = *SCARD_PCI_T0;
    276.                     LOGD("using T0");
    277.                     break;
    278.                 case SCARD_PROTOCOL_T1:
    279.                     pStrInfo->pioSendPci = *SCARD_PCI_T1;
    280.                     LOGD("using T1");
    281.                     break;
    282.                 default:
    283.                     LOGE("Unknown protocol. No card present?\n");
    284.             }
    285.             MyMemcpy(pAtr,pbAtr, dwAtrLen);
    286.             *pAtrlen = dwAtrLen;
    287.         }
    288.         else
    289.         {
    290.  
    291.         }
    292.  
    293.     }
    294.  
    295.     return smart_card_type;
    296.  
    297.    }
    298.  
    299.    //建立卡连接，并做好传输准备
    300.    int PBOC_Connect(int using_reader_id)
    301.    {
    302.     LOGD("%s(%d)",__FUNCTION__,using_reader_id);
    303.     LONG rv;
    304.     int ret = TRUE;
    305.     DWORD dwReaderLen, dwState, dwProt, dwAtrLen;
    306.     BYTE pbAtr[MAX_ATR_SIZE] = "";
    307.     char pbReader[MAX_READERNAME] = "";
    308.     pStrReaderListInfo pStrInfo;
    309.     unsigned int i;
    310.     unsigned int counts = 0;
    311.  
    312.     if(using_reader_id < 0 || using_reader_id >= posReaderList.count)
    313.     {
    314.         LOGE("[%d]reader id is wrong(%d)\n",__LINE__, using_reader_id);
    315.         ret = FALSE;
    316.    //       Nok_Reason = ErrorReason_PCSCD_READERS_ID;
    317.         goto ERROR;
    318.     }
    319.     pStrInfo = &posReaderList.readerList[using_reader_id];
    320.  
    321.     /* connect to a reader (even without a card) */
    322.     LOGD("[%d]Using reader: %s\n",__LINE__, posReaderList.readerList[using_reader_id].reader);
    323.  
    324.     while(1)
    325.     {
    326.         if(posReaderList.readerList[using_reader_id].hCard != 0)
    327.         {
    328.             LOGD("connected(%d)",(int)posActiveProtocol[using_reader_id]);
    329.             rv = SCARD_S_SUCCESS;
    330.             LOGD("SCardReconnect");
    331.             rv = SCardReconnect(posReaderList.readerList[using_reader_id].hCard, /*SCARD_SHARE_SHARED*/SCARD_SHARE_SHARED, 
    332.                 SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,SCARD_RESET_CARD, (DWORD*)&posActiveProtocol);
    333.         }
    334.         else
    335.         {
    336.             LOGD("connect");
    337.             rv = SCardConnect(posContext, posReaderList.readerList[using_reader_id].reader, /*SCARD_SHARE_EXCLUSIVE*/SCARD_SHARE_SHARED,
    338.                 SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &posReaderList.readerList[using_reader_id].hCard, &posActiveProtocol[using_reader_id]);
    339.         }
    340.         if (rv != SCARD_S_SUCCESS)
    341.         {
    342.             LOGE("SCardConnect %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    343.             counts++;
    344.             if(rv == SCARD_E_SHARING_VIOLATION)
    345.             {
    346.                 if(counts < 10)
    347.                 {
    348.                     usleep(500*1000);
    349.                     LOGE("reader is busy,wait 500ms try again(%d)",counts);
    350.                     continue;
    351.                 }
    352.             }
    353.             else if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    354.             {
    355.                 Reset_Reader();
    356.                 if(counts < 2)
    357.                 {
    358.                     LOGE("try again(%d)",counts);
    359.                     continue;
    360.                 }
    361.             }
    362.             ret = FALSE;
    363.    //           Nok_Reason = ErrorReason_PCSCD_CONNECT_READERS;
    364.             goto ERROR_NOTHING;
    365.         }
    366.         else
    367.         {
    368.             break;
    369.         }
    370.     }
    371.     pStrInfo->dwActiveProtocol = posActiveProtocol[using_reader_id];
    372.     /* get card status */
    373.     dwAtrLen = sizeof(pbAtr);
    374.     dwReaderLen = sizeof(pbReader);
    375.  
    376.     rv = SCardStatus(posReaderList.readerList[using_reader_id].hCard, pbReader, &dwReaderLen, &dwState, &dwProt,
    377.         pbAtr, &dwAtrLen);
    378.     if (rv != SCARD_S_SUCCESS)
    379.     {
    380.         LOGE("SCardStatus %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    381.         ret = FALSE;
    382.    //       Nok_Reason = ErrorReason_PCSCD_GET_READERS_STATUS;
    383.         goto ERROR;
    384.     }
    385.     LOGD(" State: 0x%04lX\n", dwState);
    386.  
    387.     if (dwState & SCARD_ABSENT)
    388.     {
    389.         LOGE("No card inserted\n");
    390.         ret = FALSE;
    391.    //       Nok_Reason = ErrorReason_PCSCD_NO_CARDS_INSIDE;
    392.         goto ERROR;
    393.     }
    394.  
    395.     switch(posActiveProtocol[using_reader_id])
    396.     {
    397.         case SCARD_PROTOCOL_T0:
    398.             pStrInfo->pioSendPci = *SCARD_PCI_T0;
    399.             LOGD("using T0");
    400.             break;
    401.         case SCARD_PROTOCOL_T1:
    402.             pStrInfo->pioSendPci = *SCARD_PCI_T1;
    403.             LOGD("using T1");
    404.             break;
    405.         default:
    406.             LOGE("Unknown protocol. No card present?\n");
    407.             ret = FALSE;
    408.    //           Nok_Reason = ErrorReason_PCSCD_NO_PROTOCOLS_SELECT;
    409.             goto ERROR;
    410.     }
    411.     rv = SCardBeginTransaction(posReaderList.readerList[using_reader_id].hCard);
    412.     if (rv != SCARD_S_SUCCESS)
    413.     {
    414.         if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    415.         {
    416.             Reset_Reader();
    417.         }
    418.         LOGE("SCardBeginTransaction %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    419.         ret = FALSE;
    420.    //       Nok_Reason = ErrorReason_PCSCD_BEGIN_TRANSACTION;
    421.         goto ERROR;
    422.     }
    423.     pStrInfo->trans_begin = 1;
    424.     LOGD("SCardBeginTransaction::success!\n");
    425.     return ret;
    426.    ERROR:
    427.     rv = SCardDisconnect(posReaderList.readerList[using_reader_id].hCard,SCARD_UNPOWER_CARD);
    428.     if (rv != SCARD_S_SUCCESS)
    429.     {
    430.         if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    431.         {
    432.             Reset_Reader();
    433.         }
    434.         LOGE("[%d]::SCardDisconnect: %s (0x%lX)\n",__LINE__ ,pcsc_stringify_error(rv),rv);
    435.     }
    436.    ERROR_NOTHING:
    437.     return ret;
    438.    }
    439.    //卡上电连接并获取ATR
    440.    int PBOC_PowerOn(int using_reader_id,unsigned char* pAtr,unsigned int * pAtrlen)
    441.    {
    442.     LOGD("%s",__FUNCTION__);
    443.     LONG rv;
    444.     int ret = TRUE;
    445.     DWORD dwReaderLen, dwState, dwProt, dwAtrLen;
    446.     BYTE pbAtr[MAX_ATR_SIZE] = "";
    447.     char pbReader[MAX_READERNAME] = "";
    448.     pStrReaderListInfo pStrInfo;
    449.     unsigned int i;
    450.     unsigned int counts = 0;
    451.  
    452.     if(using_reader_id < 0 || using_reader_id >= posReaderList.count)
    453.     {
    454.         LOGE("[%d]reader id is wrong(%d)\n",__LINE__, using_reader_id);
    455.         ret = FALSE;
    456.         return ret;
    457.     }
    458.     pStrInfo = &posReaderList.readerList[using_reader_id];
    459.  
    460.     /* connect to a reader (even without a card) */
    461.     LOGD("[%d]Using reader: %s\n",__LINE__, posReaderList.readerList[using_reader_id].reader);
    462.  
    463.     while(1)
    464.     {
    465.         if(pStrInfo->hCard != 0)
    466.         {
    467.             LOGD("SCardConnect(%d)",(int)posActiveProtocol[using_reader_id]);
    468.             rv = SCARD_S_SUCCESS;
    469.             //LOGD("SCardReconnect");
    470.             //rv = SCardReconnect(pStrInfo->hCard, /*SCARD_SHARE_SHARED*/SCARD_SHARE_EXCLUSIVE, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,
    471.             //      SCARD_RESET_CARD, &dwposActiveProtocol);
    472.         }
    473.         else
    474.         {
    475.             LOGD("SCardConnect");
    476.             rv = SCardConnect(posContext, pStrInfo->reader, /*SCARD_SHARE_SHARED*/SCARD_SHARE_SHARED,
    477.                 SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &pStrInfo->hCard, &posActiveProtocol[using_reader_id]);
    478.         }
    479.         if (rv != SCARD_S_SUCCESS)
    480.         {
    481.             LOGE("SCardConnect %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    482.             counts++;
    483.             if(rv == SCARD_E_SHARING_VIOLATION)
    484.             {
    485.                 if(counts < 10)
    486.                 {
    487.                     usleep(500*1000);
    488.                     LOGE("reader is busy,wait 500ms try again(%d)",counts);
    489.                     continue;
    490.                 }
    491.             }
    492.             else if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    493.             {
    494.                 usleep(2000*1000);
    495.                 Pcscd_Init();
    496.                 if(counts < 2)
    497.                 {
    498.                     LOGE("try again(%d)",counts);
    499.                     continue;
    500.                 }
    501.             }
    502.             ret = FALSE;
    503.             goto ERROR_NOTHING;
    504.         }
    505.         else
    506.         {
    507.             break;
    508.         }
    509.     }
    510.     pStrInfo->dwActiveProtocol = posActiveProtocol[using_reader_id];
    511.     /* get card status */
    512.     dwAtrLen = sizeof(pbAtr);
    513.     dwReaderLen = sizeof(pbReader);
    514.     //获取卡状态信息
    515.     rv = SCardStatus(pStrInfo->hCard, pbReader, &dwReaderLen, &dwState, &dwProt,
    516.         pbAtr, &dwAtrLen);
    517.     if (rv != SCARD_S_SUCCESS)
    518.     {
    519.         LOGE("SCardStatus %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    520.         ret = FALSE;
    521.         goto ERROR;
    522.     }
    523.     LOGD(" State: 0x%04lX\n", dwState);
    524.  
    525.     if (dwState & SCARD_ABSENT)
    526.     {
    527.         LOGE("No card inserted\n");
    528.         ret = FALSE;
    529.         goto ERROR;
    530.     }
    531.  
    532.     switch(posActiveProtocol[using_reader_id])
    533.     {
    534.         case SCARD_PROTOCOL_T0:
    535.             pStrInfo->pioSendPci = *SCARD_PCI_T0;
    536.             LOGD("using T0");
    537.             break;
    538.         case SCARD_PROTOCOL_T1:
    539.             pStrInfo->pioSendPci = *SCARD_PCI_T1;
    540.             LOGD("using T1");
    541.             break;
    542.         default:
    543.             LOGE("Unknown protocol. No card present?\n");
    544.             ret = FALSE;
    545.             goto ERROR;
    546.     }
    547.     MyMemcpy(pbAtr,pAtr,dwAtrLen);
    548.     *pAtrlen = dwAtrLen;
    549.     //准备传输状态
    550.     rv = SCardBeginTransaction(pStrInfo->hCard);
    551.     if (rv != SCARD_S_SUCCESS)
    552.     {
    553.         if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    554.         {
    555.             Reset_Reader();
    556.         }
    557.         LOGE("SCardBeginTransaction %s (0x%lX)\n" , pcsc_stringify_error(rv), rv);
    558.         ret = FALSE;
    559.         goto ERROR;
    560.     }
    561.     pStrInfo->trans_begin = 1;
    562.     LOGD("SCardBeginTransaction::success!\n");
    563.     return ret;
    564.    ERROR:
    565.     rv = SCardDisconnect(pStrInfo->hCard,SCARD_UNPOWER_CARD);
    566.     if (rv != SCARD_S_SUCCESS)
    567.     {
    568.         if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    569.         {
    570.             Reset_Reader();
    571.         }
    572.         LOGE("[%d]::SCardDisconnect: %s (0x%lX)\n",__LINE__ ,pcsc_stringify_error(rv),rv);
    573.     }
    574.    ERROR_NOTHING:
    575.     return ret;
    576.  
    577.  
    578.    }
    579.    int PBOC_PowerOff(int using_reader_id)
    580.    {
    581.     LOGD("%s",__FUNCTION__);
    582.     LONG rv;
    583.     pStrReaderListInfo pStrInfo;
    584.  
    585.     pStrInfo = &posReaderList.readerList[using_reader_id];
    586.     //结束传输
    587.     if(pStrInfo->trans_begin == 1)
    588.     {
    589.         rv = SCardEndTransaction(pStrInfo->hCard,SCARD_LEAVE_CARD);
    590.         if (rv != SCARD_S_SUCCESS)
    591.         {
    592.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    593.             {
    594.                 ResetReader();
    595.             }
    596.             LOGE("[%d]::SCardEndTransaction: %s (0x%lX)\n",__LINE__ ,pcsc_stringify_error(rv),rv);
    597.         }
    598.         pStrInfo->trans_begin = 0;
    599.     }
    600.     //断开连接
    601.     if(posReaderList.readerList[using_reader_id].hCard != 0)
    602.     {
    603.         LOGD("SCardDisconnect");
    604.         rv = SCardDisconnect(pStrInfo->hCard,SCARD_UNPOWER_CARD);
    605.         if (rv != SCARD_S_SUCCESS)
    606.         {
    607.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    608.             {
    609.                 Reset_Reader();
    610.             }
    611.             LOGE("[%d]::CloudPos_PowerOff: %s (0x%lX)\n",__LINE__ ,pcsc_stringify_error(rv),rv);
    612.         }
    613.         pStrInfo->hCard = 0;
    614.     }
    615.     return rv;
    616.    }
    617.  
    618.    int PBOC_APDU_SendAPI(unsigned int using_reader_id,unsigned char * bSendBuffer,unsigned int send_length,unsigned char * bRecvBuffer,unsigned int *length)
    619.    {
    620.     LOGD("%s",__FUNCTION__);
    621.     LONG rv;
    622.     int ret = 0;
    623.     unsigned int i;
    624.     unsigned char temp[64] = {0};
    625.     //char debug_buffer[512] = {0};
    626.  
    627.     pStrReaderListInfo pStrInfo;
    628.  
    629.     if(using_reader_id < 0 || using_reader_id >= posReaderList.count)
    630.     {
    631.         LOGE("[%d]reader id is wrong(%d)\n",__LINE__, using_reader_id);
    632.         ret = FALSE;
    633.         goto SEND_ERROR;
    634.     }
    635.    #ifdef SE_KL81
    636.     if(send_length%64 == 54)
    637.     {
    638.         LOGI("fill 0xFFFF");
    639.         bSendBuffer[send_length] = 0xFF;
    640.         bSendBuffer[send_length+1] = 0xFF;
    641.         send_length += 2;
    642.     }
    643.    #endif
    644.     pStrInfo = &posReaderList.readerList[using_reader_id];
    645.  
    646.     /* APDU select applet */
    647.  
    648.     LOGD("[%d]::PBOC_APDU_SendAPI()::Dev send to card:\n",__LINE__);
    649.     if(send_length >= 256)
    650.     {
    651.         LOGD("send_length is bigger then print buffer length");
    652.     }
    653.     else
    654.     {
    655.         MyPrintfBuff("APDU_send:",bSendBuffer, send_length);
    656.     }
    657.     *length = MAX_BUFFER_SIZE_SZ;
    658.     MyMemset(bRecvBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    659.     if(memcmp(&pStrInfo->pioSendPci,SCARD_PCI_T0,sizeof(pStrInfo->pioSendPci)) == 0)
    660.     {
    661.         LOGD("using T0");
    662.     }
    663.     else if(memcmp(&pStrInfo->pioSendPci,SCARD_PCI_T1,sizeof(pStrInfo->pioSendPci)) == 0)
    664.     {
    665.         LOGD("using T1");
    666.     }
    667.     else
    668.     {
    669.         LOGD("using None");
    670.     }
    671.     rv = SCardTransmit(pStrInfo->hCard, &pStrInfo->pioSendPci, bSendBuffer, (DWORD)send_length,
    672.                             &pStrInfo->pioRecvPci, bRecvBuffer, (DWORD *)length);
    673.     if(rv != SCARD_S_SUCCESS)
    674.     {
    675.         if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    676.         {
    677.             Reset_Reader();
    678.         }
    679.         MyMemset(bRecvBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    680.         LOGE("SCardTransmit error,try again!(0x%08x)(%d)",(unsigned int)rv,*length);
    681.         snprintf(temp,sizeof(temp),"SCardTransmit error(0x%x)",(unsigned int)rv);
    682.         sleep(1);
    683.         *length = MAX_BUFFER_SIZE_SZ;
    684.         rv = SCardTransmit(pStrInfo->hCard, &pStrInfo->pioSendPci, bSendBuffer, (DWORD )send_length,
    685.                                 &pStrInfo->pioRecvPci, bRecvBuffer,(DWORD *) length);
    686.  
    687.         if(rv != SCARD_S_SUCCESS)
    688.         {
    689.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    690.             {
    691.                 Reset_Reader();
    692.             }
    693.             LOGE("(rv = 0x%08x)",(unsigned int)rv);
    694.             snprintf(temp,sizeof(temp),"SCardTransmit error again(0x%x)",(unsigned int)rv);
    695.             ret = FALSE;
    696.             goto SEND_ERROR;
    697.         }
    698.     }
    699.     LOGD("[%d]::Card response to dev:\n",__LINE__);
    700.     if(*length >= 5120)
    701.     {
    702.         LOGD("length is bigger then print buffer length.");
    703.     }
    704.     else
    705.     {
    706.         MyPrintfBuff("APDU_Recv:",bRecvBuffer, *length);
    707.     }
    708.     if(*length > 54 && (*length+10)%64 == 2 && (bRecvBuffer[*length-2] == 0xFF && bRecvBuffer[*length-1] == 0xFF))
    709.     {
    710.         LOGD("clean FFFF");
    711.         (*length) -= 2;
    712.     }
    713.  
    714.    PRASE_CARD_RETURN_STATUS:
    715.     if(bRecvBuffer[*length-2] == 0x61)
    716.     {
    717.         LOGD("[%d]::Dev 0x61 to card:\n",__LINE__);
    718.         memset(bSendBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    719.         usleep(100*1000);
    720.         LOGD("[%d]::Card with the remaining returned to %02x%02x\n",__LINE__,bRecvBuffer[0],bRecvBuffer[1]);
    721.         send_length = 5;//00 C0 00 00 2A
    722.         memcpy(bSendBuffer, "\x00\xC0\x00\x00",send_length-1);
    723.  
    724.         bSendBuffer[send_length-1] = bRecvBuffer[*length-1];
    725.  
    726.         LOGD("[%d]::Dev send to card:\n",__LINE__);
    727.         MyMemset(bRecvBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    728.         *length = MAX_BUFFER_SIZE_SZ;
    729.         rv = SCardTransmit(pStrInfo->hCard, &pStrInfo->pioSendPci, bSendBuffer, (DWORD )send_length,
    730.             &pStrInfo->pioRecvPci, bRecvBuffer, (DWORD *)length);
    731.         MyPrintfBuff("APDU_Recv:",bRecvBuffer, *length);
    732.         if(rv != SCARD_S_SUCCESS)
    733.         {
    734.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    735.             {
    736.                 Reset_Reader();
    737.             }
    738.             MyMemset(bRecvBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    739.             LOGE("SCardTransmit error,try again!");
    740.             snprintf(temp,sizeof(temp),"SCardTransmit error(0x%x)",(unsigned int)rv);
    741.             *length = MAX_BUFFER_SIZE_SZ;
    742.             sleep(1);
    743.             rv = SCardTransmit(pStrInfo->hCard, &pStrInfo->pioSendPci, bSendBuffer, (DWORD )send_length,
    744.                 &pStrInfo->pioRecvPci, bRecvBuffer, (DWORD *)length);
    745.             if(rv != SCARD_S_SUCCESS)
    746.             {
    747.                 if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    748.                 {
    749.                     Reset_Reader();
    750.                 }
    751.                 LOGE("SCardTransmit error!");
    752.                 snprintf(temp,sizeof(temp),"SCardTransmit error again(0x%x)",(unsigned int)rv);
    753.                 ret = FALSE;
    754.                 goto SEND_ERROR;
    755.             }
    756.         }
    757.         LOGD("[%d]::Card response to dev:\n",__LINE__);
    758.         //memset(debug_buffer,0,sizeof(debug_buffer));
    759.         if(*length >= 5120)
    760.         {
    761.             LOGE("length is bigger then print buffer length");
    762.         }
    763.         else
    764.         {
    765.         //  myAsciiToHex(bRecvBuffer, debug_buffer, *length);
    766.             MyPrintfBuff("APDU_Recv:",bRecvBuffer, *length);
    767.  
    768.         }
    769.         if(*length > 54 && (*length+10)%64 == 2 && (bRecvBuffer[*length-2] == 0xFF && bRecvBuffer[*length-1] == 0xFF))
    770.         {
    771.             LOGD("clean FFFF");
    772.             (*length) -= 2;
    773.         }
    774.     }
    775.     else if(bRecvBuffer[*length-2] == 0x6C)
    776.     {
    777.         LOGD("[%d]::Dev 0x6C to card:\n",__LINE__);
    778.         bSendBuffer[send_length-1] = bRecvBuffer[*length-1];
    779.         MyMemset(bRecvBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    780.         rv = SCardTransmit(pStrInfo->hCard, &pStrInfo->pioSendPci, bSendBuffer,(DWORD ) send_length,
    781.             &pStrInfo->pioRecvPci, bRecvBuffer, (DWORD *)length);
    782.         if(rv != SCARD_S_SUCCESS)
    783.         {
    784.             if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    785.             {
    786.                 Reset_Reader();
    787.             }
    788.             MyMemset(bRecvBuffer,0x00,MAX_BUFFER_SIZE_SZ);
    789.             LOGE("SCardTransmit error,try again!");
    790.             *length = MAX_BUFFER_SIZE_SZ;
    791.             sleep(1);
    792.             rv = SCardTransmit(pStrInfo->hCard, &pStrInfo->pioSendPci, bSendBuffer, (DWORD )send_length,
    793.                 &pStrInfo->pioRecvPci, bRecvBuffer, (DWORD*)length);
    794.             if(rv != SCARD_S_SUCCESS)
    795.             {
    796.                 if(rv == SCARD_E_NO_SERVICE || rv == SCARD_E_UNKNOWN_READER)
    797.                 {
    798.                     Reset_Reader();
    799.                 }
    800.    //               Nok_Reason = ErrorReason_PCSCD_TRANSMIT;
    801.                 ret = FALSE;
    802.                 goto SEND_ERROR;
    803.             }
    804.         }
    805.         if(*length > 54 && (*length+10)%64 == 2 && (bRecvBuffer[*length-2] == 0xFF && bRecvBuffer[*length-1] == 0xFF))
    806.         {
    807.             LOGD("clean FFFF");
    808.             (*length) -= 2;
    809.         }
    810.         goto PRASE_CARD_RETURN_STATUS;
    811.     }
    812.     else if((bRecvBuffer[*length-2] == 0x6A )&&( bRecvBuffer[*length-1] == 0x83))
    813.     {
    814.         LOGD("[%d]::Card response 6A83",__LINE__);
    815.     }
    816.     else if((bRecvBuffer[*length-2] != 0x90)||(bRecvBuffer[*length-1] != 0x00))
    817.     {
    818.         LOGE("Cards respont isn't 0x9000(0x%02X%02X)!\n",bRecvBuffer[*length-2],bRecvBuffer[*length-1]);
    819.     }
    820.     else
    821.     {
    822.         //LOGD("[%d]::Card response to dev:\n",__LINE__);
    823.         //memset(debug_buffer,0,sizeof(debug_buffer));
    824.         if(*length >= 5120)
    825.         {
    826.             LOGE("length is bigger then print buffer length");
    827.         }
    828.         else
    829.         {
    830.             //myAsciiToHex(bRecvBuffer, debug_buffer, *length);
    831.             //MyPrintfBuff("APDU_Recv:",bRecvBuffer, *length);
    832.         }
    833.     }
    834.    SEND_ERROR:
    835.     return ret;
    836.    }
    837.  
    838. //main.c
    839. //使用test程序做PSAM卡和ICC卡通道通讯
    840. ret = Pcscd_Init();
    841. if(ret != 0)//读卡器未找到
    842. {
    843.     return -1;
    844. }
    845. while(1)
    846. {
    847.     printf("Please input command:\n");
    848.     printf("################################\n");
    849.     printf("'0' is select PSAM CARD\n");
    850.     printf("'1' is select ICC CARD\n");
    851.     printf("'quit' is return\n");
    852.     printf("'break' is go back\n");
    853.     printf("################################\n");
    854.     MyMemset(camd_buf,0,sizeof(camd_buf));
    855.     scanf("%s",camd_buf);
    856.     getchar();
    857.     if(MyMemcmp("0",camd_buf,MyStrlen("0")) == 0)
    858.     {
    859.         while(1)
    860.         {
    861.             printf("Please input APDU:\n");
    862.             MyMemset(camd_buf,0,sizeof(camd_buf));
    863.             scanf("%s",camd_buf);
    864.             getchar();
    865.             if(MyMemcmp("break",camd_buf,MyStrlen("break")) == 0)
    866.                 break;
    867.             MyStrToHex((camd_buf),send_buf);
    868.             ret = CloudPos_SendToPcscd((unsigned char *)send_buf,0,recv_buf,&recv_len);
    869.  
    870.             MyPrintfBuff("recv_buf::",recv_buf,recv_len);
    871.         }
    872.     }
    873.     else if(memcmp("1",camd_buf,MyStrlen("1")) == 0)
    874.     {
    875.         ret = PBOC_Connect(1);
    876.         if(ret == FALSE)
    877.         {
    878.             printf("Connect(1) error Please try again!\n");
    879.         }
    880.         else
    881.         {
    882.             printf("Connect(1) sucess\n");
    883.             while(1)
    884.             {
    885.                 printf("Please input APDU:\n");
    886.                 MyMemset(camd_buf,0,sizeof(camd_buf));
    887.                 scanf("%s",camd_buf);
    888.                 getchar();
    889.                 if(MyMemcmp("break",camd_buf,MyStrlen("break")) == 0)
    890.                     break;
    891.                 send_len = MyStrToHex((camd_buf),send_buf);
    892.  
    893.                 ret = PBOC_APDU_SendAPI(1,send_buf,send_len,recv_buf,&recv_len);
    894.                 MyPrintfBuff("recv_buf::",recv_buf,recv_len);
    895.  
    896.             }
    897.         }
    898.         PBOC_DisConnect(1);
    899.     }
    900.     else if(MyMemcmp("quit",camd_buf,MyStrlen("quit")) == 0)
    901.     {
    902.         break;
    903.     }
    904. }
    905. Pcscd_Release();
  • 相关阅读:
    APS智能排产在电缆行业的应用
    springboot+vue+Elementui网络课程在线教学系统网站
    百度paddleocr检测训练
    ERROR 2003 (HY000) Can‘t connect to MySQL server on ‘localhost3306‘ (10061)解决办法
    Pytroch Nerf代码阅读笔记（LLFF 数据集pose 处理和Nerf 网络结构）
    C++ 引用的数组和数组的引用
    自用——平衡小车代码
    java二手车商城计算机毕业设计MyBatis+系统+LW文档+源码+调试部署
    FreeSWITCH dtmf事件测试
    K3S +Helm+NFS最小化测试安装部署只需十分钟
  • 原文地址：https://blog.csdn.net/apple_51426592/article/details/127384762