pcsc-lite  1.8.14
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$
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  {
377  int valid = 1; /* valid value by default */
378  long value;
379  printf("Vendor IFD version\t\t: ");
380  if (dwBufLen == sizeof(DWORD))
381  value = buf.as_DWORD;
382  else
383  {
384  if (dwBufLen == sizeof(uint32_t))
385  value = buf.as_uint32_t;
386  else
387  {
388  printf(RED "Unsupported size\n" NORMAL);
389  valid = 0; /* invalid value */
390  }
391  }
392 
393  if (valid)
394  {
395  int M = (value & 0xFF000000) >> 24; /* Major */
396  int m = (value & 0x00FF0000) >> 16; /* Minor */
397  int b = (value & 0x0000FFFF); /* build */
398  printf(GREEN "%d.%d.%d\n" NORMAL, M, m, b);
399  }
400  }
401 
402  printf("Testing SCardGetAttrib\t\t: ");
403  dwBufLen = sizeof(buf);
404  rv = SCardGetAttrib(hCard, SCARD_ATTR_MAXINPUT, buf.as_char, &dwBufLen);
405  test_rv(rv, hContext, DONT_PANIC);
406  if (rv == SCARD_S_SUCCESS)
407  {
408  if (dwBufLen == sizeof(uint32_t))
409  printf("Max message length\t\t: " GREEN "%d\n" NORMAL,
410  buf.as_uint32_t);
411  else
412  printf(RED "Wrong size" NORMAL);
413  }
414 
415  printf("Testing SCardGetAttrib\t\t: ");
416  dwBufLen = sizeof(buf);
417  rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_NAME, buf.as_char, &dwBufLen);
418  test_rv(rv, hContext, DONT_PANIC);
419  if (rv == SCARD_S_SUCCESS)
420  printf("Vendor name\t\t\t: " GREEN "%s\n" NORMAL, buf.as_char);
421 
422  printf("Testing SCardSetAttrib\t\t: ");
423  rv = SCardSetAttrib(hCard, SCARD_ATTR_ATR_STRING, (LPCBYTE)"", 1);
424  test_rv(rv, hContext, DONT_PANIC);
425 
426  printf("Testing SCardStatus\t\t: ");
427 
428 #ifdef USE_AUTOALLOCATE
429  dwReaderLen = SCARD_AUTOALLOCATE;
430  dwAtrLen = SCARD_AUTOALLOCATE;
431  rv = SCardStatus(hCard, (LPSTR)&pcReaders, &dwReaderLen, &dwState, &dwProt,
432  (LPBYTE)&pbAtr, &dwAtrLen);
433 #else
434  dwReaderLen = 100;
435  pcReaders = malloc(sizeof(char) * 100);
436  dwAtrLen = MAX_ATR_SIZE;
437 
438  rv = SCardStatus(hCard, pcReaders, &dwReaderLen, &dwState, &dwProt,
439  pbAtr, &dwAtrLen);
440 #endif
441  test_rv(rv, hContext, PANIC);
442 
443  printf("Current Reader Name\t\t: " GREEN "%s\n" NORMAL, pcReaders);
444  printf("Current Reader State\t\t: " GREEN "0x%.4lx\n" NORMAL, dwState);
445  printf("Current Reader Protocol\t\t: T=" GREEN "%ld\n" NORMAL, dwProt - 1);
446  printf("Current Reader ATR Size\t\t: " GREEN "%ld" NORMAL " bytes\n",
447  dwAtrLen);
448  printf("Current Reader ATR Value\t: " GREEN);
449 
450  for (i = 0; i < dwAtrLen; i++)
451  {
452  printf("%02X ", pbAtr[i]);
453  }
454  printf(NORMAL "\n");
455 
456 #ifdef USE_AUTOALLOCATE
457  printf("Testing SCardFreeMemory\t\t: ");
458  rv = SCardFreeMemory(hContext, pcReaders);
459  test_rv(rv, hContext, PANIC);
460  printf("Testing SCardFreeMemory\t\t: ");
461  rv = SCardFreeMemory(hContext, pbAtr);
462  test_rv(rv, hContext, PANIC);
463 #else
464  if (pcReaders)
465  free(pcReaders);
466 #endif
467 
468  if (rv != SCARD_S_SUCCESS)
469  {
470  (void)SCardDisconnect(hCard, SCARD_RESET_CARD);
471  (void)SCardReleaseContext(hContext);
472  }
473 
474  printf("Press enter: ");
475  (void)getchar();
476  printf("Testing SCardReconnect\t\t: ");
479  test_rv(rv, hContext, PANIC);
480 
481  printf("Testing SCardDisconnect\t\t: ");
482  rv = SCardDisconnect(hCard, SCARD_UNPOWER_CARD);
483  test_rv(rv, hContext, PANIC);
484 
485 #ifdef USE_AUTOALLOCATE
486  printf("Testing SCardFreeMemory\t\t: ");
487  rv = SCardFreeMemory(hContext, mszReaders);
488  test_rv(rv, hContext, PANIC);
489 #else
490  free(mszReaders);
491 #endif
492 
493  printf("Testing SCardReleaseContext\t: ");
494  rv = SCardReleaseContext(hContext);
495  test_rv(rv, hContext, PANIC);
496 
497  printf("\n");
498  printf("PC/SC Test Completed Successfully !\n");
499 
500  return 0;
501 }
#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:195
#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:1377
#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:820
#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:519
#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:231
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:1255
PCSC_API LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen)
Set an attribute of the IFD Handler.
Definition: winscard.c:1452
#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:1318
#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:1502
#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:220