pcsc-lite  1.8.13
testpcsc.c
Go to the documentation of this file.
1 /*
2  * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html )
3  *
4  * Copyright (C) 1999
5  * David Corcoran <corcoran@musclecard.com>
6  * Copyright (C) 2004-2010
7  * Ludovic Rousseau <ludovic.rousseau@free.fr>
8  *
9 Redistribution and use in source and binary forms, with or without
10 modification, are permitted provided that the following conditions
11 are met:
12 
13 1. Redistributions of source code must retain the above copyright
14  notice, this list of conditions and the following disclaimer.
15 2. Redistributions in binary form must reproduce the above copyright
16  notice, this list of conditions and the following disclaimer in the
17  documentation and/or other materials provided with the distribution.
18 3. The name of the author may not be used to endorse or promote products
19  derived from this software without specific prior written permission.
20 
21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $Id: testpcsc.c 7004 2014-10-02 09:26:36Z rousseau $
33  */
34 
40 #include "config.h"
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 
45 #include "pcsclite.h"
46 #include "winscard.h"
47 #include "reader.h"
48 
49 #define PANIC 0
50 #define DONT_PANIC 1
51 
52 #define USE_AUTOALLOCATE
53 
54 #define BLUE "\33[34m"
55 #define RED "\33[31m"
56 #define BRIGHT_RED "\33[01;31m"
57 #define GREEN "\33[32m"
58 #define NORMAL "\33[0m"
59 #define MAGENTA "\33[35m"
60 
61 static void test_rv(LONG rv, SCARDCONTEXT hContext, int dont_panic)
62 {
63  if (rv != SCARD_S_SUCCESS)
64  {
65  if (dont_panic)
66  printf(BLUE "%s (don't panic)\n" NORMAL, pcsc_stringify_error(rv));
67  else
68  {
69  printf(RED "%s\n" NORMAL, pcsc_stringify_error(rv));
70  (void)SCardReleaseContext(hContext);
71  exit(-1);
72  }
73  }
74  else
75  (void)puts(pcsc_stringify_error(rv));
76 }
77 
78 int main(/*@unused@*/ int argc, /*@unused@*/ char **argv)
79 {
80  SCARDHANDLE hCard;
81  SCARDCONTEXT hContext;
82  SCARD_READERSTATE rgReaderStates[1];
83  DWORD dwReaderLen, dwState, dwProt, dwAtrLen;
84  DWORD dwPref, dwReaders = 0;
85  char *pcReaders = NULL, *mszReaders;
86 #ifdef USE_AUTOALLOCATE
87  unsigned char *pbAtr = NULL;
88 #else
89  unsigned char pbAtr[MAX_ATR_SIZE];
90 #endif
91  union {
92  unsigned char as_char[100];
93  DWORD as_DWORD;
94  uint32_t as_uint32_t;
95  } buf;
96  DWORD dwBufLen;
97  unsigned char *pbAttr = NULL;
98  DWORD pcbAttrLen;
99  char *mszGroups;
100  DWORD dwGroups = 0;
101  long rv;
102  DWORD i;
103  int p, iReader;
104  int iList[16] = {0};
105  SCARD_IO_REQUEST ioRecvPci = *SCARD_PCI_T0; /* use a default value */
106  const SCARD_IO_REQUEST *pioSendPci;
107  unsigned char bSendBuffer[MAX_BUFFER_SIZE];
108  unsigned char bRecvBuffer[MAX_BUFFER_SIZE];
109  DWORD send_length, length;
110 
111  (void)argc;
112  (void)argv;
113 
114  printf("\nMUSCLE PC/SC Lite unitary test Program\n\n");
115 
116  printf(MAGENTA "THIS PROGRAM IS NOT DESIGNED AS A TESTING TOOL FOR END USERS!\n");
117  printf("Do NOT use it unless you really know what you do.\n\n" NORMAL);
118 
119  printf("Testing SCardEstablishContext\t: ");
120  rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
121  test_rv(rv, hContext, PANIC);
122 
123  printf("Testing SCardIsValidContext\t: ");
124  rv = SCardIsValidContext(hContext);
125  test_rv(rv, hContext, PANIC);
126 
127  printf("Testing SCardIsValidContext\t: ");
128  rv = SCardIsValidContext(hContext+1);
129  test_rv(rv, hContext, DONT_PANIC);
130 
131  printf("Testing SCardListReaderGroups\t: ");
132 #ifdef USE_AUTOALLOCATE
133  dwGroups = SCARD_AUTOALLOCATE;
134  rv = SCardListReaderGroups(hContext, (LPSTR)&mszGroups, &dwGroups);
135 #else
136  rv = SCardListReaderGroups(hContext, NULL, &dwGroups);
137  test_rv(rv, hContext, PANIC);
138 
139  printf("Testing SCardListReaderGroups\t: ");
140  mszGroups = calloc(dwGroups, sizeof(char));
141  rv = SCardListReaderGroups(hContext, mszGroups, &dwGroups);
142 #endif
143  test_rv(rv, hContext, PANIC);
144 
145  /*
146  * Have to understand the multi-string here
147  */
148  p = 0;
149  for (i = 0; i+1 < dwGroups; i++)
150  {
151  ++p;
152  printf(GREEN "Group %02d: %s\n" NORMAL, p, &mszGroups[i]);
153  while (mszGroups[++i] != 0) ;
154  }
155 
156 #ifdef USE_AUTOALLOCATE
157  printf("Testing SCardFreeMemory\t\t: ");
158  rv = SCardFreeMemory(hContext, mszGroups);
159  test_rv(rv, hContext, PANIC);
160 #else
161  free(mszGroups);
162 #endif
163 
164 wait_for_card_again:
165  mszGroups = NULL;
166  printf("Testing SCardListReaders\t: ");
167  rv = SCardListReaders(hContext, mszGroups, NULL, &dwReaders);
168  test_rv(rv, hContext, DONT_PANIC);
170  {
171  printf("Testing SCardGetStatusChange \n");
172  printf("Please insert a working reader\t: ");
173  (void)fflush(stdout);
174  rgReaderStates[0].szReader = "\\\\?PnP?\\Notification";
175  rgReaderStates[0].dwCurrentState = SCARD_STATE_EMPTY;
176 
177  rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 1);
178  test_rv(rv, hContext, PANIC);
179  }
180 
181  printf("Testing SCardListReaders\t: ");
182 #ifdef USE_AUTOALLOCATE
183  dwReaders = SCARD_AUTOALLOCATE;
184  rv = SCardListReaders(hContext, mszGroups, (LPSTR)&mszReaders, &dwReaders);
185 #else
186  rv = SCardListReaders(hContext, mszGroups, NULL, &dwReaders);
187  test_rv(rv, hContext, PANIC);
188 
189  printf("Testing SCardListReaders\t: ");
190  mszReaders = calloc(dwReaders, sizeof(char));
191  rv = SCardListReaders(hContext, mszGroups, mszReaders, &dwReaders);
192 #endif
193  test_rv(rv, hContext, DONT_PANIC);
194 
195  /*
196  * Have to understand the multi-string here
197  */
198  p = 0;
199  for (i = 0; i+1 < dwReaders; i++)
200  {
201  ++p;
202  printf(GREEN "Reader %02d: %s\n" NORMAL, p, &mszReaders[i]);
203  iList[p] = i;
204  while (mszReaders[++i] != 0) ;
205  }
206 
207  if (p > 1)
208  do
209  {
210  char input[80];
211  char *r;
212 
213  printf("Enter the reader number\t\t: ");
214  r = fgets(input, sizeof(input), stdin);
215  if (NULL == r)
216  iReader = -1;
217  else
218  iReader = atoi(input);
219 
220  if (iReader > p || iReader <= 0)
221  printf("Invalid Value - try again\n");
222  }
223  while (iReader > p || iReader <= 0);
224  else
225  iReader = 1;
226 
227  rgReaderStates[0].szReader = &mszReaders[iList[iReader]];
228  rgReaderStates[0].dwCurrentState = SCARD_STATE_EMPTY;
229 
230  printf("Waiting for card insertion\t: ");
231  (void)fflush(stdout);
232  rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 1);
233  test_rv(rv, hContext, PANIC);
234  if (rgReaderStates[0].dwEventState & SCARD_STATE_UNKNOWN)
235  {
236  printf("\nA reader has been connected/disconnected\n");
237  goto wait_for_card_again;
238  }
239 
240  printf("Testing SCardConnect\t\t: ");
241  rv = SCardConnect(hContext, &mszReaders[iList[iReader]],
243  &hCard, &dwPref);
244  test_rv(rv, hContext, PANIC);
245 
246  switch(dwPref)
247  {
248  case SCARD_PROTOCOL_T0:
249  pioSendPci = SCARD_PCI_T0;
250  break;
251  case SCARD_PROTOCOL_T1:
252  pioSendPci = SCARD_PCI_T1;
253  break;
254  case SCARD_PROTOCOL_RAW:
255  pioSendPci = SCARD_PCI_RAW;
256  break;
257  default:
258  printf("Unknown protocol\n");
259  return -1;
260  }
261 
262  /* APDU select file */
263  printf("Select file:");
264  send_length = 7;
265  memcpy(bSendBuffer, "\x00\xA4\x00\x00\x02\x3F\x00", send_length);
266  for (i=0; i<send_length; i++)
267  printf(" %02X", bSendBuffer[i]);
268  printf("\n");
269  length = sizeof(bRecvBuffer);
270 
271  printf("Testing SCardTransmit\t\t: ");
272  rv = SCardTransmit(hCard, pioSendPci, bSendBuffer, send_length,
273  &ioRecvPci, bRecvBuffer, &length);
274  test_rv(rv, hContext, PANIC);
275  printf(" card response:" GREEN);
276  for (i=0; i<length; i++)
277  printf(" %02X", bRecvBuffer[i]);
278  printf("\n" NORMAL);
279 
280  printf("Testing SCardControl\t\t: ");
281 #ifdef PCSC_PRE_120
282  {
283  char buffer[1024] = "Foobar";
284  DWORD cbRecvLength = sizeof(buffer);
285 
286  rv = SCardControl(hCard, buffer, 7, buffer, &cbRecvLength);
287  }
288 #else
289  {
290  char buffer[1024] = { 0x02 };
291  DWORD cbRecvLength = sizeof(buffer);
292 
293  rv = SCardControl(hCard, SCARD_CTL_CODE(1), buffer, 1, buffer,
294  sizeof(buffer), &cbRecvLength);
295  if (cbRecvLength && (SCARD_S_SUCCESS == rv))
296  {
297  for (i=0; i<cbRecvLength; i++)
298  printf("%c", buffer[i]);
299  printf(" ");
300  }
301  }
302 #endif
303  test_rv(rv, hContext, DONT_PANIC);
304 
305  printf("Testing SCardGetAttrib\t\t: ");
306 #ifdef USE_AUTOALLOCATE
307  pcbAttrLen = SCARD_AUTOALLOCATE;
308  rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, (unsigned char *)&pbAttr,
309  &pcbAttrLen);
310 #else
311  rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, NULL, &pcbAttrLen);
312  test_rv(rv, hContext, DONT_PANIC);
313  if (rv == SCARD_S_SUCCESS)
314  {
315  printf("SCARD_ATTR_DEVICE_FRIENDLY_NAME length: " GREEN "%ld\n" NORMAL, pcbAttrLen);
316  pbAttr = malloc(pcbAttrLen);
317  }
318 
319  printf("Testing SCardGetAttrib\t\t: ");
320  rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, pbAttr, &pcbAttrLen);
321 #endif
322  test_rv(rv, hContext, DONT_PANIC);
323  if (rv == SCARD_S_SUCCESS)
324  printf("SCARD_ATTR_DEVICE_FRIENDLY_NAME: " GREEN "%s\n" NORMAL, pbAttr);
325 
326 #ifdef USE_AUTOALLOCATE
327  printf("Testing SCardFreeMemory\t\t: ");
328  rv = SCardFreeMemory(hContext, pbAttr);
329  test_rv(rv, hContext, PANIC);
330 #else
331  if (pbAttr)
332  free(pbAttr);
333 #endif
334 
335  printf("Testing SCardGetAttrib\t\t: ");
336 #ifdef USE_AUTOALLOCATE
337  pcbAttrLen = SCARD_AUTOALLOCATE;
338  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, (unsigned char *)&pbAttr,
339  &pcbAttrLen);
340 #else
341  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, NULL, &pcbAttrLen);
342  test_rv(rv, hContext, DONT_PANIC);
343  if (rv == SCARD_S_SUCCESS)
344  {
345  printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld\n" NORMAL, pcbAttrLen);
346  pbAttr = malloc(pcbAttrLen);
347  }
348 
349  printf("Testing SCardGetAttrib\t\t: ");
350  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, pbAttr, &pcbAttrLen);
351 #endif
352  test_rv(rv, hContext, DONT_PANIC);
353  if (rv == SCARD_S_SUCCESS)
354  {
355  printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld\n" NORMAL, pcbAttrLen);
356  printf("SCARD_ATTR_ATR_STRING: " GREEN);
357  for (i = 0; i < pcbAttrLen; i++)
358  printf("%02X ", pbAttr[i]);
359  printf("\n" NORMAL);
360  }
361 
362 #ifdef USE_AUTOALLOCATE
363  printf("Testing SCardFreeMemory\t\t: ");
364  rv = SCardFreeMemory(hContext, pbAttr);
365  test_rv(rv, hContext, PANIC);
366 #else
367  if (pbAttr)
368  free(pbAttr);
369 #endif
370 
371  printf("Testing SCardGetAttrib\t\t: ");
372  dwBufLen = sizeof(buf);
373  rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_IFD_VERSION, buf.as_char, &dwBufLen);
374  test_rv(rv, hContext, DONT_PANIC);
375  if (rv == SCARD_S_SUCCESS)
376  printf("Vendor IFD version\t\t: " GREEN "0x%08lX\n" NORMAL,
377  buf.as_DWORD);
378 
379  printf("Testing SCardGetAttrib\t\t: ");
380  dwBufLen = sizeof(buf);
381  rv = SCardGetAttrib(hCard, SCARD_ATTR_MAXINPUT, buf.as_char, &dwBufLen);
382  test_rv(rv, hContext, DONT_PANIC);
383  if (rv == SCARD_S_SUCCESS)
384  {
385  if (dwBufLen == sizeof(uint32_t))
386  printf("Max message length\t\t: " GREEN "%d\n" NORMAL,
387  buf.as_uint32_t);
388  else
389  printf(RED "Wrong size" NORMAL);
390  }
391 
392  printf("Testing SCardGetAttrib\t\t: ");
393  dwBufLen = sizeof(buf);
394  rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_NAME, buf.as_char, &dwBufLen);
395  test_rv(rv, hContext, DONT_PANIC);
396  if (rv == SCARD_S_SUCCESS)
397  printf("Vendor name\t\t\t: " GREEN "%s\n" NORMAL, buf.as_char);
398 
399  printf("Testing SCardSetAttrib\t\t: ");
400  rv = SCardSetAttrib(hCard, SCARD_ATTR_ATR_STRING, (LPCBYTE)"", 1);
401  test_rv(rv, hContext, DONT_PANIC);
402 
403  printf("Testing SCardStatus\t\t: ");
404 
405 #ifdef USE_AUTOALLOCATE
406  dwReaderLen = SCARD_AUTOALLOCATE;
407  dwAtrLen = SCARD_AUTOALLOCATE;
408  rv = SCardStatus(hCard, (LPSTR)&pcReaders, &dwReaderLen, &dwState, &dwProt,
409  (LPBYTE)&pbAtr, &dwAtrLen);
410 #else
411  dwReaderLen = 100;
412  pcReaders = malloc(sizeof(char) * 100);
413  dwAtrLen = MAX_ATR_SIZE;
414 
415  rv = SCardStatus(hCard, pcReaders, &dwReaderLen, &dwState, &dwProt,
416  pbAtr, &dwAtrLen);
417 #endif
418  test_rv(rv, hContext, PANIC);
419 
420  printf("Current Reader Name\t\t: " GREEN "%s\n" NORMAL, pcReaders);
421  printf("Current Reader State\t\t: " GREEN "0x%.4lx\n" NORMAL, dwState);
422  printf("Current Reader Protocol\t\t: T=" GREEN "%ld\n" NORMAL, dwProt - 1);
423  printf("Current Reader ATR Size\t\t: " GREEN "%ld" NORMAL " bytes\n",
424  dwAtrLen);
425  printf("Current Reader ATR Value\t: " GREEN);
426 
427  for (i = 0; i < dwAtrLen; i++)
428  {
429  printf("%02X ", pbAtr[i]);
430  }
431  printf(NORMAL "\n");
432 
433 #ifdef USE_AUTOALLOCATE
434  printf("Testing SCardFreeMemory\t\t: ");
435  rv = SCardFreeMemory(hContext, pcReaders);
436  test_rv(rv, hContext, PANIC);
437  printf("Testing SCardFreeMemory\t\t: ");
438  rv = SCardFreeMemory(hContext, pbAtr);
439  test_rv(rv, hContext, PANIC);
440 #else
441  if (pcReaders)
442  free(pcReaders);
443 #endif
444 
445  if (rv != SCARD_S_SUCCESS)
446  {
447  (void)SCardDisconnect(hCard, SCARD_RESET_CARD);
448  (void)SCardReleaseContext(hContext);
449  }
450 
451  printf("Press enter: ");
452  (void)getchar();
453  printf("Testing SCardReconnect\t\t: ");
456  test_rv(rv, hContext, PANIC);
457 
458  printf("Testing SCardDisconnect\t\t: ");
459  rv = SCardDisconnect(hCard, SCARD_UNPOWER_CARD);
460  test_rv(rv, hContext, PANIC);
461 
462 #ifdef USE_AUTOALLOCATE
463  printf("Testing SCardFreeMemory\t\t: ");
464  rv = SCardFreeMemory(hContext, mszReaders);
465  test_rv(rv, hContext, PANIC);
466 #else
467  free(mszReaders);
468 #endif
469 
470  printf("Testing SCardReleaseContext\t: ");
471  rv = SCardReleaseContext(hContext);
472  test_rv(rv, hContext, PANIC);
473 
474  printf("\n");
475  printf("PC/SC Test Completed Successfully !\n");
476 
477  return 0;
478 }
#define SCARD_ATTR_ATR_STRING
Answer to reset (ATR) string.
Definition: reader.h:93
#define SCARD_ATTR_DEVICE_FRIENDLY_NAME
Reader's display name.
Definition: reader.h:113
#define SCARD_ATTR_VENDOR_IFD_VERSION
Vendor-supplied interface device version (DWORD in the form 0xMMmmbbbb where MM = major version...
Definition: reader.h:62
PCSC_API LONG SCardListReaders(SCARDCONTEXT hContext, LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)
Returns a list of currently available readers on the system.
#define MAX_BUFFER_SIZE
Maximum Tx/Rx Buffer for short APDU.
Definition: pcsclite.h:231
PCSC_API LONG SCardListReaderGroups(SCARDCONTEXT hContext, LPSTR mszGroups, LPDWORD pcchGroups)
Returns a list of currently available reader groups on the system.
#define SCARD_STATE_EMPTY
Card removed.
Definition: pcsclite.h:204
This keeps a list of defines shared between the driver and the application.
PCSC_API char * pcsc_stringify_error(const LONG pcscError)
Returns a human readable text for the given PC/SC error code.
Definition: error.c:79
PCSC_API LONG SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
Creates an Application Context to the PC/SC Resource Manager.
Definition: winscard.c:196
#define SCARD_E_NO_READERS_AVAILABLE
Cannot find a smart card reader.
Definition: pcsclite.h:150
#define SCARD_PROTOCOL_T1
T=1 active protocol.
Definition: pcsclite.h:176
PCSC_API LONG SCardFreeMemory(SCARDCONTEXT hContext, LPCVOID pvMem)
Releases memory that has been returned from the resource manager using the SCARD_AUTOALLOCATE length ...
LONG SCardGetStatusChange(SCARDCONTEXT hContext, DWORD dwTimeout, SCARD_READERSTATE *rgReaderStates, DWORD cReaders)
Blocks execution until the current availability of the cards in a specific set of readers changes...
PCSC_API LONG SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen)
Get an attribute from the IFD Handler (reader driver).
Definition: winscard.c:1378
#define SCARD_PCI_T0
protocol control information (PCI) for T=0
Definition: pcsclite.h:97
PCSC_API LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
Terminates a connection made through SCardConnect().
Definition: winscard.c:821
#define SCARD_PCI_RAW
protocol control information (PCI) for RAW protocol
Definition: pcsclite.h:99
PCSC_API LONG SCardIsValidContext(SCARDCONTEXT hContext)
Check if a SCARDCONTEXT is valid.
#define INFINITE
Infinite timeout.
Definition: pcsclite.h:213
#define SCARD_STATE_UNKNOWN
Reader unknown.
Definition: pcsclite.h:202
#define SCARD_AUTOALLOCATE
see SCardFreeMemory()
Definition: pcsclite.h:168
LONG SCARDCONTEXT
hContext returned by SCardEstablishContext()
Definition: pcsclite.h:54
#define SCARD_SHARE_SHARED
Shared mode only.
Definition: pcsclite.h:183
#define SCARD_PROTOCOL_T0
T=0 active protocol.
Definition: pcsclite.h:175
#define SCARD_ATTR_MAXINPUT
FIXME.
Definition: reader.h:99
PCSC_API LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode, DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol)
Reestablishes a connection to a reader that was previously connected to using SCardConnect().
Definition: winscard.c:520
#define SCARD_PCI_T1
protocol control information (PCI) for T=1
Definition: pcsclite.h:98
#define SCARD_UNPOWER_CARD
Power down on close.
Definition: pcsclite.h:188
This keeps a list of defines for pcsc-lite.
PCSC_API LONG SCardConnect(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
Establishes a connection to the reader specified in * szReader.
Definition: winscard.c:232
PCSC_API LONG SCardStatus(SCARDHANDLE hCard, LPSTR mszReaderName, LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
Returns the current status of the reader connected to by hCard.
Definition: winscard.c:1256
PCSC_API LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen)
Set an attribute of the IFD Handler.
Definition: winscard.c:1454
#define SCARD_RESET_CARD
Reset on close.
Definition: pcsclite.h:187
LONG SCARDHANDLE
hCard returned by SCardConnect()
Definition: pcsclite.h:57
#define SCARD_PROTOCOL_RAW
Raw active protocol.
Definition: pcsclite.h:177
#define SCARD_CTL_CODE(code)
Provide source compatibility on different platforms.
Definition: reader.h:120
Protocol Control Information (PCI)
Definition: pcsclite.h:81
PCSC_API LONG SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID pbSendBuffer, DWORD cbSendLength, LPVOID pbRecvBuffer, DWORD cbRecvLength, LPDWORD lpBytesReturned)
Sends a command directly to the IFD Handler (reader driver) to be processed by the reader...
Definition: winscard.c:1319
#define SCARD_ATTR_VENDOR_NAME
Vendor name.
Definition: reader.h:60
#define MAX_ATR_SIZE
Maximum ATR size.
Definition: pcsclite.h:61
PCSC_API LONG SCardTransmit(SCARDHANDLE hCard, const SCARD_IO_REQUEST *pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, SCARD_IO_REQUEST *pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength)
Sends an APDU to the smart card contained in the reader connected to by SCardConnect().
Definition: winscard.c:1504
#define SCARD_S_SUCCESS
error codes from http://msdn.microsoft.com/en-us/library/aa924526.aspx
Definition: pcsclite.h:103
#define SCARD_SCOPE_SYSTEM
Scope in system.
Definition: pcsclite.h:171
This handles smart card reader communications.
PCSC_API LONG SCardReleaseContext(SCARDCONTEXT hContext)
Destroys a communication context to the PC/SC Resource Manager.
Definition: winscard.c:221