PCSC那事儿(二十一--SCardControl)

最新推荐文章于 2018-12-03 18:22:18 发布
最新推荐文章于 2018-12-03 18:22:18 发布
阅读量4.6k 收藏 1
点赞数
文章标签： struct buffer string 数据结构 null testing
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenjunfen/article/details/5257962
版权

 

SCardControl

 

SCardControl 定义在 winscard_clnt.c

实现如下：

 

 

 

2365 LONG SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID pbSendBuffer,

2366         DWORD cbSendLength, LPVOID pbRecvBuffer, DWORD cbRecvLength,

2367         LPDWORD lpBytesReturned)

2368 {

2369         LONG rv;

2370         control_struct scControlStruct;

2371         sharedSegmentMsg msgStruct;

2372         int i;

2373         DWORD dwContextIndex, dwChannelIndex;

2374

2375         PROFILE_START

2376

2377         /* 0 bytes received by default */

2378         if (NULL != lpBytesReturned)

2379                 *lpBytesReturned = 0;

2380

 

 

 

2365~2380 行，要多说吗？

2381         rv = SCardCheckDaemonAvailability();

2382         if (rv != SCARD_S_SUCCESS)

2383                 return rv;

2384

2385         /*

2386          * Make sure this handle has been opened

2387          */

2388         rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

2389         if (rv == -1)

2390                 return SCARD_E_INVALID_HANDLE;

2391

2392         (void)SYS_MutexLock(psContextMap[dwContextIndex].mMutex);

2393

2394         /* check the handle is still valid */

2395         rv = SCardGetIndicesFromHandle(hCard, &dwContextIndex, &dwChannelIndex);

2396         if (rv == -1)

2397                 /* the handle is now invalid

2398                  * -> another thread may have called SCardReleaseContext

2399                   * -> so the mMutex has been unlocked */

2400                 return SCARD_E_INVALID_HANDLE;

2401

 

 

2381~2401 行，上面提过了。

问：有不少代码重复。

答案是，可以考虑 refator. 说说而已。

 

2402         for (i = 0; i < PCSCLITE_MAX_READERS_CONTEXTS; i++)

2403         {

2404                  char *r = psContextMap[dwContextIndex].psChannelMap[dwChannelIndex].readerName;

2405

2406                 /* by default r == NULL */

2407                 if (r && strcmp(r, (readerStates[i])->readerName) == 0)

2408                         break;

2409         }

2410

2411         if (i == PCSCLITE_MAX_READERS_CONTEXTS)

2412         {

2413                 (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2414                 return SCARD_E_READER_UNAVAILABLE;

2415         }

2416

2417         if ((cbSendLength > MAX_BUFFER_SIZE_EXTENDED)

2418                 || (cbRecvLength > MAX_BUFFER_SIZE_EXTENDED))

2419         {

2420                 (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2421                 return SCARD_E_INSUFFICIENT_BUFFER;

2422         }

 

 

 

2402~2422 行， “ 豁然回首月明中，雕栏玉砌应犹在 ...”

看看这些在 SCardTransmit 都有。不用重复解说了。

 

2423

2424         if ((cbSendLength > MAX_BUFFER_SIZE) || (cbRecvLength > MAX_BUFFER_SIZE))

2425         {

2426                 /* extended control */

2427                 unsigned char buffer[sizeof(sharedSegmentMsg) + MAX_BUFFER_SIZE_EXTENDED];

2428                 control_struct_extended *scControlStructExtended = (control_struct_extended *)buffer;

 

2429                 sharedSegmentMsg *pmsgStruct = (psharedSegmentMsg)buffer;

2430

2431                  scControlStructExtended->hCard = hCard;

2432                 scControlStructExtended->dwControlCode = dwControlCode;

2433                 scControlStructExtended->cbSendLength = cbSendLength;

2434                 scControlStructExtended->cbRecvLength = cbRecvLength;

2435                 scControlStructExtended->dwBytesReturned = 0;

2436                 scControlStructExtended->rv = SCARD_S_SUCCESS;

2437                 /* The size of data to send is the size of

2438                  * struct control_struct_extended WITHOUT the data[] field

2439                  * plus the effective data[] size

2440                  */

2441                 scControlStructExtended->size = sizeof(*scControlStructExtended)

2442                         - (sizeof(control_struct_extended) - offsetof(control_struct_extended, data))

2443                         + cbSendLength;

2444                  memcpy(scControlStructExtended->data, pbSendBuffer, cbSendLength);

 

 

 

2423~2444 行，这个是？好像在哪里看过。对了还是在 SCardTransmit 收发长 APDU

的时候。

上面提到了

长 APDU 用到的那两种结构。发送采用 transmit_struct_extended

结构，接收采用 sharedSegmentMsg 结构， data 域内嵌 transmit_struct_extended 结构。

相比，短 APDU 也用到了两种结构。发送采用 transmit_struct 结构，接收采用 sharedSegmentMsg 结构， data 域内嵌 transmit_struct 。

 

对于 SCardControl ，采用一样的策略，但不同的结构体。

想到什么了？没法使用模板，这里采用了 c 。

 

长 APDU 用到了两种结构。发送采用 control_struct_extended

结构，接收采用 sharedSegmentMsg 结构， data 域内嵌 control_struct_extended 结构。

相比，短 APDU 也用到了两种结构。发送采用 control_struct 结构，接收采用 sharedSegmentMsg 结构， data 域内嵌 control_struct 。

 

 

control_struct 定义在 winscard_msg.h

  struct control_struct

        {

                int32_t hCard;

                uint32_t dwControlCode;

                uint8_t pbSendBuffer[MAX_BUFFER_SIZE];

 

                uint32_t cbSendLength;

                uint8_t pbRecvBuffer[MAX_BUFFER_SIZE];

                uint32_t cbRecvLength;

                 uint32_t dwBytesReturned;

                uint32_t rv;

        };

        typedef struct control_struct control_struct;

 

 

 

 

control_struct_extended 定义在 winscard_msg.h

  struct control_struct_extended

        {

                int32_t hCard;

                uint32_t dwControlCode;

                uint32_t cbSendLength;

                uint32_t cbRecvLength;

                uint32_t dwBytesReturned;

                 uint32_t rv;

                uint64_t size;

                uint8_t data[1];

        };

        typedef struct control_struct_extended control_struct_extended;

 

2445

2446                 rv = WrapSHMWrite(SCARD_CONTROL_EXTENDED,

2447                          psContextMap[dwContextIndex].dwClientID,

2448                         scControlStructExtended->size,

2449                         PCSCLITE_CLIENT_ATTEMPTS, buffer);

2450

2451                 if (rv == -1)

2452                 {

2453                          (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2454                         return SCARD_E_NO_SERVICE;

2455                 }

2456

2457                 /*

2458                  * Read a message from the server

2459                   */

2460                 /* read the first block */

2461                 rv = SHMMessageReceive(buffer, sizeof(sharedSegmentMsg),

 

2462                         psContextMap[dwContextIndex].dwClientID, PCSCLITE_CLIENT_ATTEMPTS);

2463                 if (rv == -1)

2464                 {

2465                         (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2466                         return SCARD_F_COMM_ERROR;

2467                 }

2468

2469                 /* we receive a sharedSegmentMsg and not a control_struct_extended */

2470                 scControlStructExtended = (control_struct_extended *)&(pmsgStruct -> data);

2471

2472                 /* a second block is present */

2473                 if (scControlStructExtended->size > PCSCLITE_MAX_MESSAGE_SIZE)

2474                 {

2475                         rv = SHMMessageReceive(buffer + sizeof(sharedSegmentMsg),

2476                                 scControlStructExtended->size-PCSCLITE_MAX_MESSAGE_SIZE,

2477                                  psContextMap[dwContextIndex].dwClientID,

2478                                 PCSCLITE_CLIENT_ATTEMPTS);

2479                         if (rv == -1)

2480                         {

2481                                 (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2482                                 return SCARD_F_COMM_ERROR;

2483                         }

2484                 }

2485

2486                 if (scControlStructExtended -> rv == SCARD_S_SUCCESS)

2487                 {

2488                         /*

2489                          * Copy and zero it so any secret information is not leaked

2490                          */

2491                         memcpy(pbRecvBuffer, scControlStructExtended -> data,

2492                                  scControlStructExtended -> dwBytesReturned);

2493                         memset(scControlStructExtended -> data, 0x00,

2494                                 scControlStructExtended -> dwBytesReturned);

2495                 }

2496

2497                  if (NULL != lpBytesReturned)

2498                         *lpBytesReturned = scControlStructExtended -> dwBytesReturned;

2499

2500                 rv = scControlStructExtended -> rv;

2501          }

 

 

 

2445~2501 行，长 APDU 处理完成。方法和 SCardTransmit 的长 APDU 一样。

仅仅是方法处理的数据结构不同。您会想到 “ 模板 ” 的好。

 

2502         else

2503         {

2504                 scControlStruct.hCard = hCard;

2505                 scControlStruct.dwControlCode = dwControlCode;

2506                 scControlStruct.cbSendLength = cbSendLength;

2507                 scControlStruct.cbRecvLength = cbRecvLength;

2508                 memcpy(scControlStruct.pbSendBuffer, pbSendBuffer, cbSendLength);

2509

2510                 rv = WrapSHMWrite(SCARD_CONTROL,

2511                          psContextMap[dwContextIndex].dwClientID,

2512                         sizeof(scControlStruct), PCSCLITE_CLIENT_ATTEMPTS, &scControlStruct);

2513

2514                 if (rv == -1)

2515                 {

2516                         (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2517                         return SCARD_E_NO_SERVICE;

2518                 }

2519

2520                 /*

2521                  * Read a message from the server

2522                  */

2523                  rv = SHMClientRead(&msgStruct, psContextMap[dwContextIndex].dwClientID,

2524                         PCSCLITE_CLIENT_ATTEMPTS);

2525

2526                 if (rv == -1)

2527                 {

2528                         (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2529                         return SCARD_F_COMM_ERROR;

2530                 }

2531

2532                 memcpy(&scControlStruct, &msgStruct.data, sizeof(scControlStruct));

2533

2534                 if (NULL != lpBytesReturned)

2535                         *lpBytesReturned = scControlStruct.dwBytesReturned;

2536

2537                 if (scControlStruct.rv == SCARD_S_SUCCESS)

 

2538                 {

2539                         /*

2540                          * Copy and zero it so any secret information is not leaked

2541                          */

2542                         memcpy(pbRecvBuffer, scControlStruct.pbRecvBuffer,

2543                                 scControlStruct.cbRecvLength);

2544                         memset(scControlStruct.pbRecvBuffer, 0x00,

2545                                 sizeof(scControlStruct.pbRecvBuffer));

2546                 }

2547

2548                 rv = scControlStruct.rv;

2549         }

2550

2551         (void)SYS_MutexUnLock(psContextMap[dwContextIndex].mMutex);

2552

2553         PROFILE_END(rv)

2554

2555         return rv;

2556 }

 

 

 

2502~2556 行，短 APDU 的处理。方法和 SCardTransmit 中短 APDU 的处理一样。

仅仅是方法处理的数据结构不同。

 

长 APDU 的处理还是比较有技巧的。通过一次发，两次收，就可以收到 PCSCLITE_MAX_MESSAGE_SIZE ＋ MAX_BUFFER_SIZE_EXTENDED 这么长的交互数据。

或许会想到，要这么麻烦，结构嵌套结构？可以第一次仅仅返回数据长度，第二次返回所有数据。前面提到了， testpcsc 与 pcscd 之间采用 socket 通讯，虽然这里仅仅是一次发 ( 实际有可能是两次，详细见发送函数 WrapSHMWrite ) ，两次收，但对于底层来说，可能会被分解为多次的发，多次的收。如果第一次仅仅返回数据长度，这么小的信息量也要收一次，则发送效率比较低。所以第一次收的时候，除了返回数据长度，也返回了最大 PCSCLITE_MAX_MESSAGE_SIZE 长度的数据。

 

 

SCardControl 解说结束。

回头，回头。

 

回到 testpcsc.c

 

 

 

 

 

276         test_rv(rv, hContext, DONT_PANIC);

277

278         printf("Testing SCardGetAttrib/t/t: ");

279 #ifdef USE_AUTOALLOCATE

280         pcbAttrLen = SCARD_AUTOALLOCATE;

281         rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, (unsigned char *)&pbAttr,

282                 &pcbAttrLen);

283 #else

284         rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, NULL, &pcbAttrLen);

285         test_rv(rv, hContext, DONT_PANIC);

286         if (rv == SCARD_S_SUCCESS)

287         {

288                 printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld/n" NORMAL , pcbAttrLen);

289                 pbAttr = malloc(pcbAttrLen);

290         }

291

292         printf("Testing SCardGetAttrib/t/t: ");

293         rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, pbAttr, &pcbAttrLen);

294 #endif

 

 

 

 

 

281~282 行

  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, (unsigned char *)&pbAttr,

  &pcbAttrLen);

wenjunfen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
PCSC那事儿(二十二--SCardGetAttrib)
一段一段回忆
01-26 3801
 SCardGetAttribSCardGetAttrib定义在winscard_clnt.c实现如下： 2658 LONG SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,2659         LPDWORD pcbAttrLen)
PCSC那事儿(十三--SCardListReaderGroups)
一段一段回忆
01-26 2201
 SCardListReaderGroups实现在winscard_clnt.c定义如下：3395 LONG SCardListReaderGroups(SCARDCONTEXT hContext, LPSTR mszGroups,3396         LPDWORD pcchGroups)3397 {339
PC/SC规范介绍
xiliang_pan的专栏
09-21 5428
1．简介： PC/SC规范由微软公司与世界其它著名的智能卡厂商组成的PC/SC工作组提出的。PC/SC规范是一个基于WINDOWS平台的一个标准用户接口（AP1），提供了一个从个人电脑（Personal Computer）到智能卡（SmartCard）的整合环境，虽然到目前为止
c#编程指南(十五) 平台调用P-INVOKE完全掌握（完结篇）,自定义Mashaler
weixin_30289831的博客
08-27 107
这是P-INVOKE系列的最后一篇，也是万剑归宗的一篇，基本上只要函数签名对了，用他可以传递任何参数，函数的输入输出参数和返回值你也可以随心所欲地修改。 把这个放在最后也是最完美的结局吧！！ C++：测试代码如下： 1 struct Test 2 { 3 int test; 4 }; 5 6 //static Test _test; 7 8 Test Get...
【python】基于PCSC协议实现读卡器和卡片通信
每天进步一点点
12-03 9039
简介 PCSC协议是windows平台下的一套通用API,所 有 函 数 的 原 型 都 winscard.h中声明，应用程序需要包含winscard.lib，所有函数的正常返回值都 SCARD_S_SUCCESS。它为读卡器/卡片和电脑提供了一个标准接口，实现不同生产商的卡片和读卡器之间的互操作性。之前工作中使用的时候是在VC++环境下之间调用的winscard提供的api，学了py...
pcsc-lite-1.8.12.tar.bz2
04-07
linux 下pcsc工具源码 pcsc-lite-1.8.12.tar.bz2
pcsc-sdk_2017-01
04-02
pcsc-sdk_2017-01.zip springcard 公司提供的智能卡测试工具
pcsc-sharp-master.zip_C＃ windows_Sharp_pcsc-sharp
09-24
C# wrapper for talking to RFID boards
pcsc-sample-app-master_PCSC_
10-02
PCSC规范例子 常用API操作 可参考PCSC规范学习
SimCardPCSC读卡器通用驱动
03-19
SimCardPCSC读卡器通用驱动 PC/SC的SIM卡读卡器驱动程序，通用的哦，刚用了，好用。
通过原生PCSC接口向IC卡的发送APDU的C#程序
10-15
最近项目要求使用PCSC驱动IC卡，在网上找了不少资源，但是没几个好用的。于是花了几天查资料，来回调试，终于搞定了调用Winscard.dll的PCSC接口来驱动IC卡，不敢藏私，望对刚入行的朋友有所帮助
pcsc-lite-1.8.8.tar.bz2
04-28
pcsc-lite-1.8.8 嵌入式usb设备开发必不可少的代码支持库.
Windows下智能卡开发
rainkop的专栏
09-27 7526
Windows系统提供了大量的API来方便的进行智能卡应用程序的开发，通过它们我们可以直接控制智能卡读卡器对智能卡进行操作，也可以与智能卡建立直接的虚拟连接而不用考虑智能卡读卡器。 智能卡应用程序开发的一般流程是： 1）建立连接（使用函数SCardEstablishContext和SCardConnect，SCardReconnect）； 2）开始事务处理（使用函数SCardBeginTra
PCSC那事儿(二十六--SCardReconnect)
一段一段回忆
01-26 3895
 SCardReconnect SCardReconnect定义在winscard_clnt.c实现如下：等等，问：前面提过的API有SCardConnect，这次SCardReconnect做什么？为什么需要这个API？答案是，在共享访问模式下，其中一个应用rese
PCSC那事儿(二十四--SCardStatus)
一段一段回忆
01-26 3925
 SCardStatus 1532 LONG SCardStatus(SCARDHANDLE hCard, LPSTR mszReaderName,1533         LPDWORD pcchReaderLen, LPDWORD pdwState,1534         LPDWORD pdwProtocol, LPB
PCSC那事儿(十六--SCardListReaders)
一段一段回忆
01-26 6884
 SCardListReadersSCardListReaders做了什么？定义在winscard_clnt.c实现如下：3202 LONG SCardListReaders(SCARDCONTEXT hContext, /*@unused@*/ LPCSTR mszGroups,3203         LPS
ccid pcsc-lite
最新发布
09-17
CCID（Chip Card Interface Device）是一种用于智能卡接口设备的协议，它定义了智能卡与计算机之间的通信方式。CCID协议规定了智能卡读卡器与计算机之间的命令传输格式、通信速率和数据传输协议，使智能卡读卡器能够与计算机进行稳定和可靠的通信。 PC/SC（Personal Computer/Smart Card）是一种用于智能卡与计算机之间的通信接口标准，它定义了智能卡与计算机之间的物理连接和通信协议。PC/SC Lite是一个基于PC/SC标准的开源软件库，它提供了与智能卡读卡器通信的API接口，使开发者可以方便地使用智能卡读卡器进行开发和应用。 CCID PC/SC Lite是在PC/SC Lite软件库的基础上实现了CCID协议的智能卡读卡器驱动程序。它通过PC/SC Lite提供的API接口与智能卡读卡器进行通信，实现了对智能卡的读写操作。CCID PC/SC Lite使得智能卡读卡器在计算机上的应用更加方便和可靠，开发者可以通过简单调用API接口就可以实现对智能卡的各种操作，如读取卡号、读取卡片存储的数据等。 总结起来，CCID PC/SC Lite是一种智能卡读卡器驱动程序，它基于CCID协议和PC/SC标准，实现了智能卡与计算机的可靠通信，并提供了API接口供开发者使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值