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