pcsc-lite  1.9.7
testpcsc.c
Go to the documentation of this file.
1 /*
2  * MUSCLE SmartCard Development ( https://pcsclite.apdu.fr/ )
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 
38 #include "config.h"
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 
43 #include "pcsclite.h"
44 #include "winscard.h"
45 #include "reader.h"
46 
47 #define PANIC 0
48 #define DONT_PANIC 1
49 
50 #define USE_AUTOALLOCATE
51 
52 #define BLUE "\33[34m"
53 #define RED "\33[31m"
54 #define BRIGHT_RED "\33[01;31m"
55 #define GREEN "\33[32m"
56 #define NORMAL "\33[0m"
57 #define MAGENTA "\33[35m"
58 
59 static void test_rv(LONG rv, SCARDCONTEXT hContext, int dont_panic)
60 {
61  if (rv != SCARD_S_SUCCESS)
62  {
63  if (dont_panic)
64  printf(BLUE "%s (don't panic)\n" NORMAL, pcsc_stringify_error(rv));
65  else
66  {
67  printf(RED "%s\n" NORMAL, pcsc_stringify_error(rv));
68  (void)SCardReleaseContext(hContext);
69  exit(-1);
70  }
71  }
72  else
73  (void)puts(pcsc_stringify_error(rv));
74 }
75 
76 int main(/*@unused@*/ int argc, /*@unused@*/ char **argv)
77 {
78  SCARDHANDLE hCard;
79  SCARDCONTEXT hContext;
80  SCARD_READERSTATE rgReaderStates[1];
81  DWORD dwReaderLen, dwState, dwProt, dwAtrLen;
82  DWORD dwPref, dwReaders = 0;
83  char *pcReader = NULL, *mszReaders;
84 #ifdef USE_AUTOALLOCATE
85  unsigned char *pbAtr = NULL;
86 #else
87  unsigned char pbAtr[MAX_ATR_SIZE];
88 #endif
89  union {
90  unsigned char as_char[100];
91  DWORD as_DWORD;
92  uint32_t as_uint32_t;
93  } buf;
94  DWORD dwBufLen;
95  unsigned char *pbAttr = NULL;
96  DWORD pcbAttrLen;
97  char *mszGroups;
98  DWORD dwGroups = 0;
99  long rv;
100  DWORD i;
101  int p, iReader;
102  int iList[16] = {0};
103  SCARD_IO_REQUEST ioRecvPci = *SCARD_PCI_T0; /* use a default value */
104  const SCARD_IO_REQUEST *pioSendPci;
105  unsigned char bSendBuffer[MAX_BUFFER_SIZE];
106  unsigned char bRecvBuffer[MAX_BUFFER_SIZE];
107  DWORD send_length, length;
108 
109  (void)argc;
110  (void)argv;
111 
112  printf("\nMUSCLE PC/SC Lite unitary test Program\n\n");
113 
114  printf(MAGENTA "THIS PROGRAM IS NOT DESIGNED AS A TESTING TOOL FOR END USERS!\n");
115  printf("Do NOT use it unless you really know what you do.\n\n" NORMAL);
116 
117  printf("Testing SCardEstablishContext\t: ");
118  rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
119  test_rv(rv, hContext, PANIC);
120 
121  printf("Testing SCardIsValidContext\t: ");
122  rv = SCardIsValidContext(hContext);
123  test_rv(rv, hContext, PANIC);
124 
125  printf("Testing SCardIsValidContext\t: ");
126  rv = SCardIsValidContext(hContext+1);
127  test_rv(rv, hContext, DONT_PANIC);
128 
129  printf("Testing SCardListReaderGroups\t: ");
130 #ifdef USE_AUTOALLOCATE
131  dwGroups = SCARD_AUTOALLOCATE;
132  rv = SCardListReaderGroups(hContext, (LPSTR)&mszGroups, &dwGroups);
133 #else
134  rv = SCardListReaderGroups(hContext, NULL, &dwGroups);
135  test_rv(rv, hContext, PANIC);
136 
137  printf("Testing SCardListReaderGroups\t: ");
138  mszGroups = calloc(dwGroups, sizeof(char));
139  rv = SCardListReaderGroups(hContext, mszGroups, &dwGroups);
140 #endif
141  test_rv(rv, hContext, PANIC);
142 
143  /*
144  * Have to understand the multi-string here
145  */
146  p = 0;
147  for (i = 0; i+1 < dwGroups; i++)
148  {
149  ++p;
150  printf(GREEN "Group %02d: %s\n" NORMAL, p, &mszGroups[i]);
151  while (mszGroups[++i] != 0) ;
152  }
153 
154 #ifdef USE_AUTOALLOCATE
155  printf("Testing SCardFreeMemory\t\t: ");
156  rv = SCardFreeMemory(hContext, mszGroups);
157  test_rv(rv, hContext, PANIC);
158 #else
159  free(mszGroups);
160 #endif
161 
162 wait_for_card_again:
163  mszGroups = NULL;
164  printf("Testing SCardListReaders\t: ");
165  rv = SCardListReaders(hContext, mszGroups, NULL, &dwReaders);
166  test_rv(rv, hContext, DONT_PANIC);
168  {
169  printf("Testing SCardGetStatusChange \n");
170  printf("Please insert a working reader\t: ");
171  (void)fflush(stdout);
172  rgReaderStates[0].szReader = "\\\\?PnP?\\Notification";
173  rgReaderStates[0].dwCurrentState = SCARD_STATE_EMPTY;
174 
175  rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 1);
176  test_rv(rv, hContext, PANIC);
177  }
178 
179  printf("Testing SCardListReaders\t: ");
180 #ifdef USE_AUTOALLOCATE
181  dwReaders = SCARD_AUTOALLOCATE;
182  rv = SCardListReaders(hContext, mszGroups, (LPSTR)&mszReaders, &dwReaders);
183 #else
184  rv = SCardListReaders(hContext, mszGroups, NULL, &dwReaders);
185  test_rv(rv, hContext, PANIC);
186 
187  printf("Testing SCardListReaders\t: ");
188  mszReaders = calloc(dwReaders, sizeof(char));
189  rv = SCardListReaders(hContext, mszGroups, mszReaders, &dwReaders);
190 #endif
191  test_rv(rv, hContext, DONT_PANIC);
192 
193  /*
194  * Have to understand the multi-string here
195  */
196  p = 0;
197  for (i = 0; i+1 < dwReaders; i++)
198  {
199  ++p;
200  printf(GREEN "Reader %02d: %s\n" NORMAL, p, &mszReaders[i]);
201  iList[p] = i;
202  while (mszReaders[++i] != 0) ;
203  }
204 
205  if (p > 1)
206  {
207  int again = 0;
208 
209  do
210  {
211  char input[80];
212  char *r;
213 
214  printf("Enter the reader number\t\t: ");
215  r = fgets(input, sizeof(input), stdin);
216  if (NULL == r)
217  iReader = -1;
218  else
219  iReader = atoi(input);
220 
221  if (iReader > p || iReader <= 0)
222  {
223  printf("Invalid Value - try again\n");
224  again = 1;
225  }
226  }
227  while (again);
228  }
229  else
230  iReader = 1;
231 
232  rgReaderStates[0].szReader = &mszReaders[iList[iReader]];
233  rgReaderStates[0].dwCurrentState = SCARD_STATE_EMPTY;
234 
235  printf("Waiting for card insertion\t: ");
236  (void)fflush(stdout);
237  rv = SCardGetStatusChange(hContext, INFINITE, rgReaderStates, 1);
238  test_rv(rv, hContext, PANIC);
239  if (rgReaderStates[0].dwEventState & SCARD_STATE_UNKNOWN)
240  {
241  printf("\nA reader has been connected/disconnected\n");
242  goto wait_for_card_again;
243  }
244 
245  printf("Testing SCardConnect\t\t: ");
246  rv = SCardConnect(hContext, &mszReaders[iList[iReader]],
248  &hCard, &dwPref);
249  test_rv(rv, hContext, PANIC);
250 
251  switch(dwPref)
252  {
253  case SCARD_PROTOCOL_T0:
254  pioSendPci = SCARD_PCI_T0;
255  break;
256  case SCARD_PROTOCOL_T1:
257  pioSendPci = SCARD_PCI_T1;
258  break;
259  case SCARD_PROTOCOL_RAW:
260  pioSendPci = SCARD_PCI_RAW;
261  break;
262  default:
263  printf("Unknown protocol\n");
264  return -1;
265  }
266 
267  /* APDU select file */
268  printf("Select file:");
269  send_length = 7;
270  memcpy(bSendBuffer, "\x00\xA4\x00\x00\x02\x3F\x00", send_length);
271  for (i=0; i<send_length; i++)
272  printf(" %02X", bSendBuffer[i]);
273  printf("\n");
274  length = sizeof(bRecvBuffer);
275 
276  printf("Testing SCardTransmit\t\t: ");
277  rv = SCardTransmit(hCard, pioSendPci, bSendBuffer, send_length,
278  &ioRecvPci, bRecvBuffer, &length);
279  test_rv(rv, hContext, PANIC);
280  printf(" card response:" GREEN);
281  for (i=0; i<length; i++)
282  printf(" %02X", bRecvBuffer[i]);
283  printf("\n" NORMAL);
284 
285  printf("Testing SCardControl\t\t: ");
286 #ifdef PCSC_PRE_120
287  {
288  char buffer[1024] = "Foobar";
289  DWORD cbRecvLength = sizeof(buffer);
290 
291  rv = SCardControl(hCard, buffer, 7, buffer, &cbRecvLength);
292  }
293 #else
294  {
295  char buffer[1024] = { 0x02 };
296  DWORD cbRecvLength = sizeof(buffer);
297 
298  rv = SCardControl(hCard, SCARD_CTL_CODE(1), buffer, 1, buffer,
299  sizeof(buffer), &cbRecvLength);
300  if (cbRecvLength && (SCARD_S_SUCCESS == rv))
301  {
302  for (i=0; i<cbRecvLength; i++)
303  printf("%c", buffer[i]);
304  printf(" ");
305  }
306  }
307 #endif
308  test_rv(rv, hContext, DONT_PANIC);
309 
310  printf("Testing SCardGetAttrib\t\t: ");
311 #ifdef USE_AUTOALLOCATE
312  pcbAttrLen = SCARD_AUTOALLOCATE;
313  rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, (unsigned char *)&pbAttr,
314  &pcbAttrLen);
315 #else
316  rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, NULL, &pcbAttrLen);
317  test_rv(rv, hContext, DONT_PANIC);
318  if (rv == SCARD_S_SUCCESS)
319  {
320  printf("SCARD_ATTR_DEVICE_FRIENDLY_NAME length: " GREEN "%ld\n" NORMAL, pcbAttrLen);
321  pbAttr = malloc(pcbAttrLen);
322  }
323 
324  printf("Testing SCardGetAttrib\t\t: ");
325  rv = SCardGetAttrib(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME, pbAttr, &pcbAttrLen);
326 #endif
327  test_rv(rv, hContext, DONT_PANIC);
328  if (rv == SCARD_S_SUCCESS)
329  printf("SCARD_ATTR_DEVICE_FRIENDLY_NAME: " GREEN "%s\n" NORMAL, pbAttr);
330 
331 #ifdef USE_AUTOALLOCATE
332  printf("Testing SCardFreeMemory\t\t: ");
333  rv = SCardFreeMemory(hContext, pbAttr);
334  test_rv(rv, hContext, PANIC);
335 #else
336  if (pbAttr)
337  free(pbAttr);
338 #endif
339 
340  printf("Testing SCardGetAttrib\t\t: ");
341 #ifdef USE_AUTOALLOCATE
342  pcbAttrLen = SCARD_AUTOALLOCATE;
343  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, (unsigned char *)&pbAttr,
344  &pcbAttrLen);
345 #else
346  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, NULL, &pcbAttrLen);
347  test_rv(rv, hContext, DONT_PANIC);
348  if (rv == SCARD_S_SUCCESS)
349  {
350  printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld\n" NORMAL, pcbAttrLen);
351  pbAttr = malloc(pcbAttrLen);
352  }
353 
354  printf("Testing SCardGetAttrib\t\t: ");
355  rv = SCardGetAttrib(hCard, SCARD_ATTR_ATR_STRING, pbAttr, &pcbAttrLen);
356 #endif
357  test_rv(rv, hContext, DONT_PANIC);
358  if (rv == SCARD_S_SUCCESS)
359  {
360  printf("SCARD_ATTR_ATR_STRING length: " GREEN "%ld\n" NORMAL, pcbAttrLen);
361  printf("SCARD_ATTR_ATR_STRING: " GREEN);
362  for (i = 0; i < pcbAttrLen; i++)
363  printf("%02X ", pbAttr[i]);
364  printf("\n" NORMAL);
365  }
366 
367 #ifdef USE_AUTOALLOCATE
368  printf("Testing SCardFreeMemory\t\t: ");
369  rv = SCardFreeMemory(hContext, pbAttr);
370  test_rv(rv, hContext, PANIC);
371 #else
372  if (pbAttr)
373  free(pbAttr);
374 #endif
375 
376  printf("Testing SCardGetAttrib\t\t: ");
377  dwBufLen = sizeof(buf);
378  rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_IFD_VERSION, buf.as_char, &dwBufLen);
379  test_rv(rv, hContext, DONT_PANIC);
380  if (rv == SCARD_S_SUCCESS)
381  {
382  int valid = 1; /* valid value by default */
383  long value;
384  printf("Vendor IFD version\t\t: ");
385  if (dwBufLen == sizeof(DWORD))
386  value = buf.as_DWORD;
387  else
388  {
389  if (dwBufLen == sizeof(uint32_t))
390  value = buf.as_uint32_t;
391  else
392  {
393  printf(RED "Unsupported size\n" NORMAL);
394  valid = 0; /* invalid value */
395  }
396  }
397 
398  if (valid)
399  {
400  int M = (value & 0xFF000000) >> 24; /* Major */
401  int m = (value & 0x00FF0000) >> 16; /* Minor */
402  int b = (value & 0x0000FFFF); /* build */
403  printf(GREEN "%d.%d.%d\n" NORMAL, M, m, b);
404  }
405  }
406 
407  printf("Testing SCardGetAttrib\t\t: ");
408  dwBufLen = sizeof(buf);
409  rv = SCardGetAttrib(hCard, SCARD_ATTR_MAXINPUT, buf.as_char, &dwBufLen);
410  test_rv(rv, hContext, DONT_PANIC);
411  if (rv == SCARD_S_SUCCESS)
412  {
413  if (dwBufLen == sizeof(uint32_t))
414  printf("Max message length\t\t: " GREEN "%d\n" NORMAL,
415  buf.as_uint32_t);
416  else
417  printf(RED "Wrong size" NORMAL);
418  }
419 
420  printf("Testing SCardGetAttrib\t\t: ");
421  dwBufLen = sizeof(buf);
422  rv = SCardGetAttrib(hCard, SCARD_ATTR_VENDOR_NAME, buf.as_char, &dwBufLen);
423  test_rv(rv, hContext, DONT_PANIC);
424  if (rv == SCARD_S_SUCCESS)
425  printf("Vendor name\t\t\t: " GREEN "%s\n" NORMAL, buf.as_char);
426 
427  printf("Testing SCardSetAttrib\t\t: ");
428  rv = SCardSetAttrib(hCard, SCARD_ATTR_ATR_STRING, (LPCBYTE)"", 1);
429  test_rv(rv, hContext, DONT_PANIC);
430 
431  printf("Testing SCardStatus\t\t: ");
432 
433 #ifdef USE_AUTOALLOCATE
434  dwReaderLen = SCARD_AUTOALLOCATE;
435  dwAtrLen = SCARD_AUTOALLOCATE;
436  rv = SCardStatus(hCard, (LPSTR)&pcReader, &dwReaderLen, &dwState, &dwProt,
437  (LPBYTE)&pbAtr, &dwAtrLen);
438 #else
439  dwReaderLen = 100;
440  pcReader = malloc(sizeof(char) * 100);
441  dwAtrLen = MAX_ATR_SIZE;
442 
443  rv = SCardStatus(hCard, pcReader, &dwReaderLen, &dwState, &dwProt,
444  pbAtr, &dwAtrLen);
445 #endif
446  test_rv(rv, hContext, PANIC);
447 
448  printf("Current Reader Name\t\t: " GREEN "%s\n" NORMAL, pcReader);
449  printf("Current Reader State\t\t: " GREEN "0x%.4lx\n" NORMAL, dwState);
450  printf("Current Reader Protocol\t\t: T=" GREEN "%ld\n" NORMAL, dwProt - 1);
451  printf("Current Reader ATR Size\t\t: " GREEN "%ld" NORMAL " bytes\n",
452  dwAtrLen);
453  printf("Current Reader ATR Value\t: " GREEN);
454 
455  for (i = 0; i < dwAtrLen; i++)
456  {
457  printf("%02X ", pbAtr[i]);
458  }
459  printf(NORMAL "\n");
460 
461 #ifdef USE_AUTOALLOCATE
462  printf("Testing SCardFreeMemory\t\t: ");
463  rv = SCardFreeMemory(hContext, pcReader);
464  test_rv(rv, hContext, PANIC);
465  printf("Testing SCardFreeMemory\t\t: ");
466  rv = SCardFreeMemory(hContext, pbAtr);
467  test_rv(rv, hContext, PANIC);
468 #else
469  if (pcReader)
470  free(pcReader);
471 #endif
472 
473  printf("Press enter: ");
474  (void)getchar();
475  printf("Testing SCardReconnect\t\t: ");
478  test_rv(rv, hContext, PANIC);
479 
480  printf("Testing SCardDisconnect\t\t: ");
481  rv = SCardDisconnect(hCard, SCARD_UNPOWER_CARD);
482  test_rv(rv, hContext, PANIC);
483 
484 #ifdef USE_AUTOALLOCATE
485  printf("Testing SCardFreeMemory\t\t: ");
486  rv = SCardFreeMemory(hContext, mszReaders);
487  test_rv(rv, hContext, PANIC);
488 #else
489  free(mszReaders);
490 #endif
491 
492  printf("Testing SCardReleaseContext\t: ");
493  rv = SCardReleaseContext(hContext);
494  test_rv(rv, hContext, PANIC);
495 
496  printf("\n");
497  printf("PC/SC Test Completed Successfully !\n");
498 
499  return 0;
500 }
#define SCARD_ATTR_ATR_STRING
Answer to reset (ATR) string.
Definition: reader.h:91
#define SCARD_ATTR_DEVICE_FRIENDLY_NAME
Reader&#39;s display name.
Definition: reader.h:111
#define SCARD_ATTR_VENDOR_IFD_VERSION
Vendor-supplied interface device version (DWORD in the form 0xMMmmbbbb where MM = major version...
Definition: reader.h:60
PCSC_API LONG SCardListReaders(SCARDCONTEXT hContext, LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)
Returns a list of currently available readers on the system.
#define SCARD_S_SUCCESS
No error was encountered.
Definition: pcsclite.h:107
#define MAX_BUFFER_SIZE
Maximum Tx/Rx Buffer for short APDU.
Definition: pcsclite.h:297
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:270
This keeps a list of defines shared between the driver and the application.
#define SCARD_E_NO_READERS_AVAILABLE
Cannot find a smart card reader.
Definition: pcsclite.h:201
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_PROTOCOL_T1
T=1 active protocol.
Definition: pcsclite.h:242
PCSC_API LONG SCardFreeMemory(SCARDCONTEXT hContext, LPCVOID pvMem)
Releases memory that has been returned from the resource manager using the SCARD_AUTOALLOCATE length ...
PCSC_API 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:1362
#define SCARD_PCI_T0
protocol control information (PCI) for T=0
Definition: pcsclite.h:95
PCSC_API LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
Terminates a connection made through SCardConnect().
Definition: winscard.c:827
#define SCARD_PCI_RAW
protocol control information (PCI) for RAW protocol
Definition: pcsclite.h:97
PCSC_API LONG SCardIsValidContext(SCARDCONTEXT hContext)
Check if a SCARDCONTEXT is valid.
#define INFINITE
Infinite timeout.
Definition: pcsclite.h:279
#define SCARD_STATE_UNKNOWN
Reader unknown.
Definition: pcsclite.h:268
#define SCARD_AUTOALLOCATE
see SCardFreeMemory()
Definition: pcsclite.h:233
LONG SCARDCONTEXT
hContext returned by SCardEstablishContext()
Definition: pcsclite.h:52
#define SCARD_SHARE_SHARED
Shared mode only.
Definition: pcsclite.h:249
#define SCARD_PROTOCOL_T0
T=0 active protocol.
Definition: pcsclite.h:241
#define SCARD_ATTR_MAXINPUT
FIXME.
Definition: reader.h:97
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:525
#define SCARD_PCI_T1
protocol control information (PCI) for T=1
Definition: pcsclite.h:96
#define SCARD_UNPOWER_CARD
Power down on close.
Definition: pcsclite.h:254
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:234
PCSC_API LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen)
Set an attribute of the IFD Handler.
Definition: winscard.c:1437
LONG SCARDHANDLE
hCard returned by SCardConnect()
Definition: pcsclite.h:55
#define SCARD_PROTOCOL_RAW
Raw active protocol.
Definition: pcsclite.h:243
#define SCARD_CTL_CODE(code)
Provide source compatibility on different platforms.
Definition: reader.h:118
Protocol Control Information (PCI)
Definition: pcsclite.h:79
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:1303
PCSC_API const char * pcsc_stringify_error(const LONG pcscError)
Returns a human readable text for the given PC/SC error code.
Definition: error.c:82
#define SCARD_ATTR_VENDOR_NAME
Vendor name.
Definition: reader.h:58
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:1240
#define MAX_ATR_SIZE
Maximum ATR size.
Definition: pcsclite.h:59
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:1487
#define SCARD_SCOPE_SYSTEM
Scope in system.
Definition: pcsclite.h:236
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