1
2
3
4
5
6
7
8 """
9 The smartcard.scard module is a simple wrapper on top of the C language
10 PCSC SCardXXX API.
11
12 The smartcard.scard module is the lower layer of the pyscard
13 framework that provides a higher level interface.
14
15 You should avoid using the smartcard.scard package directly, and use the
16 pyscard directly because:
17
18 - smartcard.scard being a C wrapper, the code tends to look like C code
19 written in python syntax
20
21 - the smartcard package provides higher level abstractions (e.g.
22 CardType, CardConnection), and makes programming easier since it is
23 totally written in Python
24
25 You can still use the smartcard.scard package if you want to write your
26 own framework, or if you want to perform quick-and-dirty port of C
27 language programs using SCardXXX calls, or if there are features of
28 SCardXXX API that you want to use and that are not available in the
29 pyscard library.
30
31 Introduction
32
33 The smartcard.scard module is a Python wrapper around PCSC smart card base
34 services. On Windows, the wrapper is performed around the smart card base
35 components winscard library. On linux, the wrapper is performed around
36 PCSC-lite library.
37
38
39 On Windows using the smart card base components, the smartcard.scard
40 module provides mapping for the following API functions:
41
42 - SCardAddReaderToGroup
43 - SCardBeginTransaction
44 - SCardCancel
45 - SCardConnect
46 - SCardControl
47 - SCardDisconnect
48 - SCardEndTransaction
49 - SCardEstablishContext
50 - SCardForgetCardType
51 - SCardForgetReader
52 - SCardForgetReaderGroup
53 - SCardGetAttrib
54 - SCardGetCardTypeProviderName
55 - SCardGetErrorMessage
56 - SCardGetStatusChange
57 - SCardIntroduceCardType
58 - SCardIntroduceReader
59 - SCardIntroduceReaderGroup
60 - SCardIsValidContext
61 - SCardListInterfaces
62 - SCardListCards
63 - SCardListReaders
64 - SCardListReaderGroups
65 - SCardLocateCards
66 - SCardReconnect
67 - SCardReleaseContext
68 - SCardRemoveReaderFromGroup
69 - SCardSetAttrib
70 - SCardStatus
71 - SCardTransmit
72
73 On linux or Mac OS X Leopard with PCSC lite, the smartcard.scard module
74 provides mapping for the following API functions:
75
76 - SCardBeginTransaction
77 - SCardCancel
78 - SCardConnect
79 - SCardControl
80 - SCardDisconnect
81 - SCardEndTransaction
82 - SCardEstablishContext
83 - SCardGetAttrib
84 - SCardGetStatusChange
85 - SCardIsValidContext
86 - SCardListReaders
87 - SCardListReaderGroups
88 - SCardReconnect
89 - SCardReleaseContext
90 - SCardSetAttrib
91 - SCardStatus
92 - SCardTransmit
93
94 On Mac OS X Tiger with PCSC lite, the smartcard.scard module provides
95 mapping for the following API functions:
96
97 - SCardBeginTransaction
98 - SCardCancel
99 - SCardConnect
100 - SCardControl
101 - SCardDisconnect
102 - SCardEndTransaction
103 - SCardEstablishContext
104 - SCardGetStatusChange
105 - SCardListReaders
106 - SCardListReaderGroups
107 - SCardReconnect
108 - SCardReleaseContext
109 - SCardStatus
110 - SCardTransmit
111
112 The following PCSC smart card functions are not wrapped by the scard
113 module on any platform:
114
115 - GetOpenCardName
116 - SCardFreeMemory
117 - SCardGetProviderId
118 - SCardSetCartTypeProviderName
119 - SCardUIDlgSelectCard
120
121 Comments, bug reports, improvements welcome.
122
123 -------------------------------------------------------------------------------
124 Copyright 2001-2011 gemalto
125 @Author: Jean-Daniel Aussel, mailto:jean-daniel.aussel@gemalto.com
126 @Author: Ludovic Rousseau, mailto:ludovic.rousseau@free.fr
127
128 This file is part of pyscard.
129
130 pyscard is free software; you can redistribute it and/or modify it
131 under the terms of the GNU Lesser General Public License as published by
132 the Free Software Foundation; either version 2.1 of the License, or (at
133 your option) any later version.
134
135 pyscard is distributed in the hope that it will be useful, but
136 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
137 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
138 License for more details.
139
140 You should have received a copy of the GNU Lesser General Public License
141 along with pyscard; if not, write to the Free Software Foundation,
142 Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
143
144
145 """
146
147
148 from sys import version_info
149 if version_info >= (2,6,0):
151 from os.path import dirname
152 import imp
153 fp = None
154 try:
155 fp, pathname, description = imp.find_module('_scard', [dirname(__file__)])
156 except ImportError:
157 import _scard
158 return _scard
159 if fp is not None:
160 try:
161 _mod = imp.load_module('_scard', fp, pathname, description)
162 finally:
163 fp.close()
164 return _mod
165 _scard = swig_import_helper()
166 del swig_import_helper
167 else:
168 import _scard
169 del version_info
170 try:
171 _swig_property = property
172 except NameError:
173 pass
175 if (name == "thisown"): return self.this.own(value)
176 if (name == "this"):
177 if type(value).__name__ == 'SwigPyObject':
178 self.__dict__[name] = value
179 return
180 method = class_type.__swig_setmethods__.get(name,None)
181 if method: return method(self,value)
182 if (not static):
183 self.__dict__[name] = value
184 else:
185 raise AttributeError("You cannot add attributes to %s" % self)
186
189
191 if (name == "thisown"): return self.this.own()
192 method = class_type.__swig_getmethods__.get(name,None)
193 if method: return method(self)
194 raise AttributeError(name)
195
197 try: strthis = "proxy of " + self.this.__repr__()
198 except: strthis = ""
199 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
200
201 try:
202 _object = object
203 _newclass = 1
204 except AttributeError:
206 _newclass = 0
207
208
209
211 """
212 SCardIsValidContext( hcontext) -> SCARDRETCODE
213
214 Parameters:
215 hcontext: context handle return from SCardEstablishContext()
216
217
218 This function determines whether a smart card context handle is still
219 valid. After a smart card context handle has been set by
220 SCardEstablishContext(), it may become not valid if the resource manager
221 service has been shut down.
222
223 from smartcard.scard import *
224 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
225 hresult = SCardIsValidContext(hcontext)
226 if hresult != SCARD_S_SUCCESS:
227 raise error, 'Invalid context: ' + SCardGetErrorMessage(hresult)
228 ...
229
230 """
231 return _scard.SCardIsValidContext(*args)
232
234 """
235 SCardGetAttrib( hcard, dwAttrId) -> SCARDRETCODE
236
237 Parameters:
238 hcard: card handle return from SCardConnect()
239 dwAttrId: value of attribute to get
240
241
242 This function get an attribute from the IFD Handler.
243
244 For PCSC lite, the list of possible attributes is:
245
246 * SCARD_ATTR_ASYNC_PROTOCOL_TYPES
247 * SCARD_ATTR_ATR_STRING
248 * SCARD_ATTR_CHANNEL_ID
249 * SCARD_ATTR_CHARACTERISTICS
250 * SCARD_ATTR_CURRENT_BWT
251 * SCARD_ATTR_CURRENT_CLK
252 * SCARD_ATTR_CURRENT_CWT
253 * SCARD_ATTR_CURRENT_D
254 * SCARD_ATTR_CURRENT_EBC_ENCODING
255 * SCARD_ATTR_CURRENT_F
256 * SCARD_ATTR_CURRENT_IFSC
257 * SCARD_ATTR_CURRENT_IFSD
258 * SCARD_ATTR_CURRENT_IO_STATE
259 * SCARD_ATTR_CURRENT_N
260 * SCARD_ATTR_CURRENT_PROTOCOL_TYPE
261 * SCARD_ATTR_CURRENT_W
262 * SCARD_ATTR_DEFAULT_CLK
263 * SCARD_ATTR_DEFAULT_DATA_RATE
264 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
265 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
266 * SCARD_ATTR_DEVICE_IN_USE
267 * SCARD_ATTR_DEVICE_SYSTEM_NAME_A
268 * SCARD_ATTR_DEVICE_SYSTEM_NAME_W
269 * SCARD_ATTR_DEVICE_UNIT
270 * SCARD_ATTR_ESC_AUTHREQUEST
271 * SCARD_ATTR_ESC_CANCEL
272 * SCARD_ATTR_ESC_RESET
273 * SCARD_ATTR_EXTENDED_BWT
274 * SCARD_ATTR_ICC_INTERFACE_STATUS
275 * SCARD_ATTR_ICC_PRESENCE
276 * SCARD_ATTR_ICC_TYPE_PER_ATR
277 * SCARD_ATTR_MAX_CLK
278 * SCARD_ATTR_MAX_DATA_RATE
279 * SCARD_ATTR_MAX_IFSD
280 * SCARD_ATTR_MAXINPUT
281 * SCARD_ATTR_POWER_MGMT_SUPPORT
282 * SCARD_ATTR_SUPRESS_T1_IFS_REQUEST
283 * SCARD_ATTR_SYNC_PROTOCOL_TYPES
284 * SCARD_ATTR_USER_AUTH_INPUT_DEVICE
285 * SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE
286 * SCARD_ATTR_VENDOR_IFD_SERIAL_NO
287 * SCARD_ATTR_VENDOR_IFD_TYPE
288 * SCARD_ATTR_VENDOR_IFD_VERSION
289 * SCARD_ATTR_VENDOR_NAME
290
291 For Windows Resource Manager, the list of possible attributes is:
292
293 * SCARD_ATTR_VENDOR_NAME
294 * SCARD_ATTR_VENDOR_IFD_TYPE
295 * SCARD_ATTR_VENDOR_IFD_VERSION
296 * SCARD_ATTR_VENDOR_IFD_SERIAL_NO
297 * SCARD_ATTR_CHANNEL_ID
298 * SCARD_ATTR_DEFAULT_CLK
299 * SCARD_ATTR_MAX_CLK
300 * SCARD_ATTR_DEFAULT_DATA_RATE
301 * SCARD_ATTR_MAX_DATA_RATE
302 * SCARD_ATTR_MAX_IFSD
303 * SCARD_ATTR_POWER_MGMT_SUPPORT
304 * SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE
305 * SCARD_ATTR_USER_AUTH_INPUT_DEVICE
306 * SCARD_ATTR_CHARACTERISTICS
307 * SCARD_ATTR_CURRENT_PROTOCOL_TYPE
308 * SCARD_ATTR_CURRENT_CLK
309 * SCARD_ATTR_CURRENT_F
310 * SCARD_ATTR_CURRENT_D
311 * SCARD_ATTR_CURRENT_N
312 * SCARD_ATTR_CURRENT_W
313 * SCARD_ATTR_CURRENT_IFSC
314 * SCARD_ATTR_CURRENT_IFSD
315 * SCARD_ATTR_CURRENT_BWT
316 * SCARD_ATTR_CURRENT_CWT
317 * SCARD_ATTR_CURRENT_EBC_ENCODING
318 * SCARD_ATTR_EXTENDED_BWT
319 * SCARD_ATTR_ICC_PRESENCE
320 * SCARD_ATTR_ICC_INTERFACE_STATUS
321 * SCARD_ATTR_CURRENT_IO_STATE
322 * SCARD_ATTR_ATR_STRING
323 * SCARD_ATTR_ICC_TYPE_PER_ATR
324 * SCARD_ATTR_ESC_RESET
325 * SCARD_ATTR_ESC_CANCEL
326 * SCARD_ATTR_ESC_AUTHREQUEST
327 * SCARD_ATTR_MAXINPUT
328 * SCARD_ATTR_DEVICE_UNIT
329 * SCARD_ATTR_DEVICE_IN_USE
330 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
331 * SCARD_ATTR_DEVICE_SYSTEM_NAME_A
332 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
333 * SCARD_ATTR_DEVICE_SYSTEM_NAME_W
334 * SCARD_ATTR_SUPRESS_T1_IFS_REQUEST
335
336 Not all the dwAttrId values listed above may be implemented in the IFD
337 Handler you are using. And some dwAttrId values not listed here may be
338 implemented.
339
340
341 from smartcard.scard import *
342 ... establish context and connect to card ...
343 hresult, attrib = SCardGetAttrib(hcard, SCARD_ATTR_ATR_STRING)
344 if hresult == SCARD_S_SUCCESS:
345 for j in attrib:
346 print '0x%.2X' % attrib,
347 ...
348
349 """
350 return _scard.SCardGetAttrib(*args)
351
353 """
354 SCardSetAttrib( hcard, dwAttrId, BYTELIST * ATTRIBUTESIN) -> SCARDRETCODE
355
356 Parameters:
357 hcard: card handle return from SCardConnect()
358 dwAttrId: value of attribute to get
359 ATTRIBUTESIN: BYTELIST *
360
361
362 This function sets an attribute from the IFD Handler. Not all
363 attributes are supported by all readers nor can they be set at all
364 times.
365
366 For PCSC lite, the list of possible attributes is:
367
368 * SCARD_ATTR_ASYNC_PROTOCOL_TYPES
369 * SCARD_ATTR_ATR_STRING
370 * SCARD_ATTR_CHANNEL_ID
371 * SCARD_ATTR_CHARACTERISTICS
372 * SCARD_ATTR_CURRENT_BWT
373 * SCARD_ATTR_CURRENT_CLK
374 * SCARD_ATTR_CURRENT_CWT
375 * SCARD_ATTR_CURRENT_D
376 * SCARD_ATTR_CURRENT_EBC_ENCODING
377 * SCARD_ATTR_CURRENT_F
378 * SCARD_ATTR_CURRENT_IFSC
379 * SCARD_ATTR_CURRENT_IFSD
380 * SCARD_ATTR_CURRENT_IO_STATE
381 * SCARD_ATTR_CURRENT_N
382 * SCARD_ATTR_CURRENT_PROTOCOL_TYPE
383 * SCARD_ATTR_CURRENT_W
384 * SCARD_ATTR_DEFAULT_CLK
385 * SCARD_ATTR_DEFAULT_DATA_RATE
386 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
387 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
388 * SCARD_ATTR_DEVICE_IN_USE
389 * SCARD_ATTR_DEVICE_SYSTEM_NAME_A
390 * SCARD_ATTR_DEVICE_SYSTEM_NAME_W
391 * SCARD_ATTR_DEVICE_UNIT
392 * SCARD_ATTR_ESC_AUTHREQUEST
393 * SCARD_ATTR_ESC_CANCEL
394 * SCARD_ATTR_ESC_RESET
395 * SCARD_ATTR_EXTENDED_BWT
396 * SCARD_ATTR_ICC_INTERFACE_STATUS
397 * SCARD_ATTR_ICC_PRESENCE
398 * SCARD_ATTR_ICC_TYPE_PER_ATR
399 * SCARD_ATTR_MAX_CLK
400 * SCARD_ATTR_MAX_DATA_RATE
401 * SCARD_ATTR_MAX_IFSD
402 * SCARD_ATTR_MAXINPUT
403 * SCARD_ATTR_POWER_MGMT_SUPPORT
404 * SCARD_ATTR_SUPRESS_T1_IFS_REQUEST
405 * SCARD_ATTR_SYNC_PROTOCOL_TYPES
406 * SCARD_ATTR_USER_AUTH_INPUT_DEVICE
407 * SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE
408 * SCARD_ATTR_VENDOR_IFD_SERIAL_NO
409 * SCARD_ATTR_VENDOR_IFD_TYPE
410 * SCARD_ATTR_VENDOR_IFD_VERSION
411 * SCARD_ATTR_VENDOR_NAME
412
413 For Windows Resource Manager, the list of possible attributes is:
414
415 * SCARD_ATTR_VENDOR_NAME
416 * SCARD_ATTR_VENDOR_IFD_TYPE
417 * SCARD_ATTR_VENDOR_IFD_VERSION
418 * SCARD_ATTR_VENDOR_IFD_SERIAL_NO
419 * SCARD_ATTR_CHANNEL_ID
420 * SCARD_ATTR_DEFAULT_CLK
421 * SCARD_ATTR_MAX_CLK
422 * SCARD_ATTR_DEFAULT_DATA_RATE
423 * SCARD_ATTR_MAX_DATA_RATE
424 * SCARD_ATTR_MAX_IFSD
425 * SCARD_ATTR_POWER_MGMT_SUPPORT
426 * SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE
427 * SCARD_ATTR_USER_AUTH_INPUT_DEVICE
428 * SCARD_ATTR_CHARACTERISTICS
429 * SCARD_ATTR_CURRENT_PROTOCOL_TYPE
430 * SCARD_ATTR_CURRENT_CLK
431 * SCARD_ATTR_CURRENT_F
432 * SCARD_ATTR_CURRENT_D
433 * SCARD_ATTR_CURRENT_N
434 * SCARD_ATTR_CURRENT_W
435 * SCARD_ATTR_CURRENT_IFSC
436 * SCARD_ATTR_CURRENT_IFSD
437 * SCARD_ATTR_CURRENT_BWT
438 * SCARD_ATTR_CURRENT_CWT
439 * SCARD_ATTR_CURRENT_EBC_ENCODING
440 * SCARD_ATTR_EXTENDED_BWT
441 * SCARD_ATTR_ICC_PRESENCE
442 * SCARD_ATTR_ICC_INTERFACE_STATUS
443 * SCARD_ATTR_CURRENT_IO_STATE
444 * SCARD_ATTR_ATR_STRING
445 * SCARD_ATTR_ICC_TYPE_PER_ATR
446 * SCARD_ATTR_ESC_RESET
447 * SCARD_ATTR_ESC_CANCEL
448 * SCARD_ATTR_ESC_AUTHREQUEST
449 * SCARD_ATTR_MAXINPUT
450 * SCARD_ATTR_DEVICE_UNIT
451 * SCARD_ATTR_DEVICE_IN_USE
452 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
453 * SCARD_ATTR_DEVICE_SYSTEM_NAME_A
454 * SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
455 * SCARD_ATTR_DEVICE_SYSTEM_NAME_W
456 * SCARD_ATTR_SUPRESS_T1_IFS_REQUEST
457
458 Not all the dwAttrId values listed above may be implemented in the IFD
459 Handler you are using. And some dwAttrId values not listed here may be
460 implemented.
461
462
463 from smartcard.scard import *
464 ... establish context and connect to card ...
465 hresult, attrib = SCardSetAttrib(hcard, SCARD_ATTR_VENDOR_NAME, ['G', 'e', 'm', 'a', 'l', 't', 'o'])
466 if hresult != SCARD_S_SUCCESS:
467 print 'Failed to set attribute'
468 ...
469
470 """
471 return _scard.SCardSetAttrib(*args)
472
474 """
475 SCardControl( hcard, dwControlCode, byte[] inbuffer) -> SCARDRETCODE
476
477 Parameters:
478 hcard: card handle return from SCardConnect()
479 dwControlCode: the control code to send
480 inbuffer: list of bytes to send with the control code
481
482
483 This function sends a control command to the reader connected to by
484 SCardConnect(). It returns a result and the control response.
485
486
487 from smartcard.scard import *
488 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
489 hresult, hcard, dwActiveProtocol = SCardConnect(
490 hcontext, 'SchlumbergerSema Reflex USB v.2 0', SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0)
491 CMD = [0x12, 0x34]
492 hresult, response = SCardControl(hcard, 42, CMD)
493 if hresult != SCARD_S_SUCCESS:
494 raise error, 'Failed to control: ' + SCardGetErrorMessage(hresult)
495
496 """
497 return _scard.SCardControl(*args)
498
500 """
501 SCardBeginTransaction( hcard) -> SCARDRETCODE
502
503 Parameters:
504 hcard: card handle return from SCardConnect()
505
506
507 This function establishes a temporary exclusive access mode for doing a
508 series of commands or transaction. You might want to use this when you
509 are selecting a few files and then writing a large file so you can make
510 sure that another application will not change the current file. If
511 another application has a lock on this reader or this application is in
512 SCARD_SHARE_EXCLUSIVE there will be no action taken.
513
514 from smartcard.scard import *
515 ... establish context ...
516 hresult, hcard, dwActiveProtocol = SCardConnect(
517 hcontext, 'SchlumbergerSema Reflex USB v.2 0', SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0)
518 if hresult!=SCARD_S_SUCCESS:
519 raise error, 'unable to connect: ' + SCardGetErrorMessage(hresult)
520 hresult = SCardBeginTransaction(hcard)
521 if hresult != SCARD_S_SUCCESS:
522 raise error, 'failed to begin transaction: ' + SCardGetErrorMessage(hresult)
523 ...
524
525 """
526 return _scard.SCardBeginTransaction(*args)
527
529 """
530 SCardCancel( hcontext) -> SCARDRETCODE
531
532 Parameters:
533 hcontext: context handle return from SCardEstablishContext()
534
535
536 This function cancels all pending blocking requests on the
537 ScardGetStatusChange() function.
538
539 from smartcard.scard import *
540 ... establish context ...
541 hresult = SCardCancel(hcard)
542 if hresult != SCARD_S_SUCCESS:
543 raise error, 'failed to cancel pending actions: ' + SCardGetErrorMessage(hresult)
544 ...
545 """
546 return _scard.SCardCancel(*args)
547
549 """
550 SCardConnect( hcontext, readername, dwShareMode, dwPreferredProtocols) -> SCARDRETCODE
551
552 Parameters:
553 hcontext: context handle return from SCardEstablishContext()
554 readername: card reader name
555 dwShareMode: share mode
556 dwPreferredProtocols: preferred protocols
557
558
559 This function establishes a connection to the friendly name of the reader
560 specified in szReader. The first connection will power up and perform a
561 reset on the card.
562
563 Value of dwShareMode Meaning
564 SCARD_SHARE_SHARED This application will allow others to share the reader
565 SCARD_SHARE_EXCLUSIVE This application will NOT allow others to share the reader
566 SCARD_SHARE_DIRECT Direct control of the reader, even without a card
567
568 SCARD_SHARE_DIRECT can be used before using SCardControl() to send control
569 commands to the reader even if a card is not present in the reader.
570
571 Value of dwPreferredProtocols Meaning
572 SCARD_PROTOCOL_T0 Use the T=0 protocol
573 SCARD_PROTOCOL_T1 Use the T=1 protocol
574 SCARD_PROTOCOL_RAW Use with memory type cards
575
576 from smartcard.scard import *
577 ... establish context ...
578 hresult, readers = SCardListReaders(hcontext, 'NULL')
579 if hresult != SCARD_S_SUCCESS:
580 raise error, 'Failed to list readers:: ' + SCardGetErrorMessage(hresult)
581 hresult, hcard, dwActiveProtocol = SCardConnect(
582 hcontext, readers[0], SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0)
583 if hresult != SCARD_S_SUCCESS:
584 raise error, 'unable to connect: ' + SCardGetErrorMessage(hresult)
585 ...
586
587 """
588 return _scard.SCardConnect(*args)
589
591 """
592 SCardDisconnect( hcard, dwDisposition) -> SCARDRETCODE
593
594 Parameters:
595 hcard: card handle return from SCardConnect()
596 dwDisposition: card disposition on return
597
598
599 This function terminates a connection to the connection made through
600 SCardConnect. disposition can have the following values:
601
602 Value of disposition Meaning
603 SCARD_LEAVE_CARD Do nothing
604 SCARD_RESET_CARD Reset the card (warm reset)
605 SCARD_UNPOWER_CARD Unpower the card (cold reset)
606 SCARD_EJECT_CARD Eject the card
607
608 from smartcard.scard import *
609 ... establish context and connect to card ...
610 hresult = SCardDisconnect(hcard, SCARD_UNPOWER_CARD)
611 if hresult != SCARD_S_SUCCESS:
612 raise error, 'failed to disconnect: ' + SCardGetErrorMessage(hresult)
613 ...
614
615 """
616 return _scard.SCardDisconnect(*args)
617
619 """
620 SCardEndTransaction( hcard, dwDisposition) -> SCARDRETCODE
621
622 Parameters:
623 hcard: card handle return from SCardConnect()
624 dwDisposition: card disposition on return
625
626
627 This function ends a previously begun transaction. The calling
628 application must be the owner of the previously begun transaction or an
629 error will occur. disposition can have the following values: The
630 disposition action is not currently used in this release.
631
632 Value of disposition Meaning
633 SCARD_LEAVE_CARD Do nothing
634 SCARD_RESET_CARD Reset the card
635 SCARD_UNPOWER_CARD Unpower the card
636 SCARD_EJECT_CARD Eject the card
637
638 from smartcard.scard import *
639 ... establish context, connect to card, begin transaction ...
640 hresult = SCardEndTransaction(hcard, SCARD_LEAVE_CARD)
641 if hresult != SCARD_S_SUCCESS:
642 raise error, 'failed to end transaction: ' + SCardGetErrorMessage(hresult)
643
644 """
645 return _scard.SCardEndTransaction(*args)
646
648 """
649 SCardEstablishContext( dwScope) -> SCARDRETCODE
650
651 Parameters:
652 dwScope: context scope
653
654
655 This function creates a communication context to the PC/SC Resource
656 Manager. This must be the first function called in a PC/SC application.
657
658 Value of dwScope Meaning
659 SCARD_SCOPE_USER Operations performed within the scope of the User
660 SCARD_SCOPE_TERMINAL Not used
661 SCARD_SCOPE_GLOBAL Not used
662 SCARD_SCOPE_SYSTEM Operations performed within the scope of the system
663
664
665 from smartcard.scard import *
666 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
667 if hresult != SCARD_S_SUCCESS:
668 raise error, 'Failed to establish context: ' + SCardGetErrorMessage(hresult)
669
670 """
671 return _scard.SCardEstablishContext(*args)
672
674 """
675 SCardGetStatusChange( hcontext, dwTimeout, tuple[] readerstatelist) -> SCARDRETCODE
676
677 Parameters:
678 hcontext: context handle return from SCardEstablishContext()
679 dwTimeout: timeout value, INFINITE for infinite time-out
680 readerstatelist: in input/output, a list of reader state tuple (readername, state, atr)
681
682
683 This function receives a structure or list of tuples containing reader
684 states. A READERSTATE hast three fields (readername, state, atr).
685 It then blocks for a change in state to occur on any of the OR'd
686 values contained in the current state for a maximum blocking time of
687 dwTimeout or forever if INFINITE is used. The new event state will be
688 contained in state. A status change might be a card insertion or
689 removal event, a change in ATR, etc.
690
691 Value of state Meaning
692 SCARD_STATE_UNAWARE The application is unaware of the current state, and would like to know. The use of this value results in an immediate return from state transition monitoring services. This is represented by all bits set to zero
693 SCARD_STATE_IGNORE This reader should be ignored
694 SCARD_STATE_CHANGED There is a difference between the state believed by the application, and the state known by the resource manager. When this bit is set, the application may assume a significant state change has occurred on this reader
695 SCARD_STATE_UNKNOWN The given reader name is not recognized by the resource manager. If this bit is set, then SCARD_STATE_CHANGED and SCARD_STATE_IGNORE will also be set
696 SCARD_STATE_UNAVAILABLE The actual state of this reader is not available. If this bit is set, then all the following bits are clear
697 SCARD_STATE_EMPTY There is no card in the reader. If this bit is set, all the following bits will be clear
698 SCARD_STATE_PRESENT There is a card in the reader
699 SCARD_STATE_ATRMATCH There is a card in the reader with an ATR matching one of the target cards. If this bit is set, SCARD_STATE_PRESENT will also be set. This bit is only returned on the SCardLocateCards function
700 SCARD_STATE_EXCLUSIVE The card in the reader is allocated for exclusive use by another application. If this bit is set, SCARD_STATE_PRESENT will also be set
701 SCARD_STATE_INUSE The card in the reader is in use by one or more other applications, but may be connected to in shared mode. If this bit is set, SCARD_STATE_PRESENT will also be set
702 SCARD_STATE_MUTE There is an unresponsive card in the reader
703
704
705 from smartcard.scard import *
706 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
707 hresult, readers = SCardListReaders(hcontext, [])
708 readerstates = []
709 cards = [ 'Schlumberger Cryptoflex 4k', 'Schlumberger Cryptoflex 8k', 'Schlumberger Cryptoflex 8k v2' ]
710 for i in xrange(len(readers)):
711 readerstates += [ (readers[i], SCARD_STATE_UNAWARE) ]
712 hresult, newstates = SCardLocateCards(hcontext, cards, readerstates)
713 print '----- Please insert or remove a card ------------'
714 hresult, newstates = SCardGetStatusChange(hcontext, INFINITE, newstates)
715 for i in newstates
716 reader, eventstate, atr = i
717 if eventstate & SCARD_STATE_ATRMATCH:
718 print ' Card found'
719 if eventstate & SCARD_STATE_EMPTY:
720 print ' Reader empty'
721
722 """
723 return _scard.SCardGetStatusChange(*args)
724
726 """
727 SCardListReaders( hcontext, [] readergroups) -> SCARDRETCODE
728
729 Parameters:
730 hcontext: context handle return from SCardEstablishContext()
731 readergroups: a list of reader groups to search for readers
732
733
734 This function returns a list of currently available readers on the system.
735 A list of group can be provided in input to list readers in a given
736 group only.
737
738 from smartcard.scard import *
739 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
740 hresult, readers = SCardListReaders(hcontext, [])
741 if hresult != SCARD_S_SUCCESS:
742 raise error, 'Failed to list readers: ' + SCardGetErrorMessage(hresult)
743 print 'PCSC Readers: ', readers
744 hresult, readers = SCardListReaders(hcontext, ['SCard$T1ProtocolReaders', 'SCard$MyOwnGroup']
745 ...
746
747 """
748 return _scard.SCardListReaders(*args)
749
751 """
752 SCardListReaderGroups( hcontext) -> SCARDRETCODE
753
754 Parameters:
755 hcontext: context handle return from SCardEstablishContext()
756
757
758 This function returns a list of currently available reader groups on the
759 system.
760
761 from smartcard.scard import *
762 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
763 hresult, readerGroups = SCardListReaderGroups(hcontext)
764 if hresult != SCARD_S_SUCCESS:
765 raise error, 'Unable to list reader groups: ' + SCardGetErrorMessage(hresult)
766 print 'PCSC Reader groups: ', readerGroups
767
768 """
769 return _scard.SCardListReaderGroups(*args)
770
772 """
773 SCardReconnect( hcard, dwShareMode, dwPreferredProtocols, dwInitialization) -> SCARDRETCODE
774
775 Parameters:
776 hcard: card handle return from SCardConnect()
777 dwShareMode: share mode
778 dwPreferredProtocols: preferred protocols
779 dwInitialization: the type of initialization that should be performed on the card
780
781
782 This function reestablishes a connection to a reader that was previously
783 connected to using SCardConnect(). In a multi application environment it
784 is possible for an application to reset the card in shared mode. When
785 this occurs any other application trying to access certain commands will
786 be returned the value SCARD_W_RESET_CARD. When this occurs
787 SCardReconnect() must be called in order to acknowledge that the card was
788 reset and allow it to change it's state accordingly.
789
790 Value of dwShareMode Meaning
791 SCARD_SHARE_SHARED This application will allow others to share the reader
792 SCARD_SHARE_EXCLUSIVE This application will NOT allow others to share the reader
793
794 Value of dwPreferredProtocols Meaning
795 SCARD_PROTOCOL_T0 Use the T=0 protocol
796 SCARD_PROTOCOL_T1 Use the T=1 protocol
797 SCARD_PROTOCOL_RAW Use with memory type cards
798
799 dwPreferredProtocols is a bit mask of acceptable protocols for the connection. You can use (SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1) if you do not have a preferred protocol.
800
801 Value of dwInitialization Meaning
802 SCARD_LEAVE_CARD Do nothing
803 SCARD_RESET_CARD Reset the card (warm reset)
804 SCARD_UNPOWER_CARD Unpower the card (cold reset)
805 SCARD_EJECT_CARD Eject the card
806
807
808 from smartcard.scard import *
809 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
810 hresult, hcard, dwActiveProtocol = SCardConnect(
811 hcontext, 'SchlumbergerSema Reflex USB v.2 0', SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0)
812 hresult, activeProtocol = SCardReconnect(hcard, SCARD_SHARE_EXCLUSIVE,
813 SCARD_PROTOCOL_T0, SCARD_RESET_CARD)
814 ...
815
816 """
817 return _scard.SCardReconnect(*args)
818
820 """
821 SCardReleaseContext( hcontext) -> SCARDRETCODE
822
823 Parameters:
824 hcontext: context handle return from SCardEstablishContext()
825
826
827 """
828 return _scard.SCardReleaseContext(*args)
829
831 """
832 SCardStatus( hcard) -> SCARDRETCODE
833
834 Parameters:
835 hcard: card handle return from SCardConnect()
836
837
838 This function returns the current status of the reader connected to by
839 hcard. The reader friendly name is returned, as well as the state,
840 protocol and ATR. The state is a DWORD possibly OR'd with the following
841 values:
842
843 Value of pdwState Meaning
844 SCARD_ABSENT There is no card in the reader
845 SCARD_PRESENT There is a card in the reader, but it has not been moved into position for use
846 SCARD_SWALLOWED There is a card in the reader in position for use. The card is not powered
847 SCARD_POWERED Power is being provided to the card, but the reader driver is unaware of the mode of the card
848 SCARD_NEGOTIABLE The card has been reset and is awaiting PTS negotiation
849 SCARD_SPECIFIC The card has been reset and specific communication protocols have been established
850
851 Value of pdwProtocol Meaning
852 SCARD_PROTOCOL_T0 Use the T=0 protocol
853 SCARD_PROTOCOL_T1 Use the T=1 protocol
854
855
856 from smartcard.scard import *
857 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
858 hresult, hcard, dwActiveProtocol = SCardConnect(
859 hcontext, 'SchlumbergerSema Reflex USB v.2 0', SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0)
860 hresult, reader, state, protocol, atr = SCardStatus(hcard)
861 if hresult != SCARD_S_SUCCESS:
862 raise error, 'failed to get status: ' + SCardGetErrorMessage(hresult)
863 print 'Reader: ', reader
864 print 'State: ', state
865 print 'Protocol: ', protocol
866 print 'ATR: ',
867 for i in xrange(len(atr)):
868 print '0x%.2X' % i,
869 print
870 ...
871
872 """
873 return _scard.SCardStatus(*args)
874
876 """
877 SCardTransmit( hcard, unsigned long pioSendPci, byte[] apducommand) -> SCARDRETCODE
878
879 Parameters:
880 hcard: card handle return from SCardConnect()
881 pioSendPci: unsigned long
882 apducommand: list of APDU bytes to transmit
883
884
885 This function sends an APDU to the smart card contained in the reader
886 connected to by SCardConnect().
887 It returns a result and the card APDU response.
888
889 Value of pioSendPci Meaning
890 SCARD_PCI_T0 Pre-defined T=0 PCI structure
891 SCARD_PCI_T1 Pre-defined T=1 PCI structure
892
893
894 from smartcard.scard import *
895 hresult, hcontext = SCardEstablishContext(SCARD_SCOPE_USER)
896 hresult, hcard, dwActiveProtocol = SCardConnect(
897 hcontext, 'SchlumbergerSema Reflex USB v.2 0', SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0)
898 SELECT = [0xA0, 0xA4, 0x00, 0x00, 0x02]
899 DF_TELECOM = [0x7F, 0x10]
900 hresult, response = SCardTransmit(hcard, SCARD_PCI_T0, SELECT + DF_TELECOM)
901 if hresult != SCARD_S_SUCCESS:
902 raise error, 'Failed to transmit: ' + SCardGetErrorMessage(hresult)
903
904 """
905 return _scard.SCardTransmit(*args)
906
908 """
909 SCARD_CTL_CODE(long code) -> long
910
911 Parameters:
912 code: long
913
914
915 This function returns the value of a control code
916
917 from smartcard.scard import *
918 ...
919 CM_IOCTL_GET_FEATURE_REQUEST = SCARD_CTL_CODE(3400)
920 ...
921
922 """
923 return _scard.SCARD_CTL_CODE(*args)
924
926 """
927 SCardGetErrorMessage(long lErrCode) -> ERRORSTRING *
928
929 Parameters:
930 lErrCode: long
931
932
933 This function return a human readable text for the given PC/SC error code.
934
935 from smartcard.scard import *
936 ...
937 hresult, response = SCardTransmit(hcard, SCARD_PCI_T0, SELECT + DF_TELECOM)
938 if hresult != SCARD_S_SUCCESS:
939 raise error, 'Failed to transmit: ' + SCardGetErrorMessage(hresult)
940 ...
941
942 """
943 return _scard.SCardGetErrorMessage(*args)
944 error = _scard.error
945
946 SCARD_SCOPE_USER = _scard.SCARD_SCOPE_USER
947 SCARD_SCOPE_TERMINAL = _scard.SCARD_SCOPE_TERMINAL
948 SCARD_SCOPE_SYSTEM = _scard.SCARD_SCOPE_SYSTEM
949 SCARD_SHARE_SHARED = _scard.SCARD_SHARE_SHARED
950 SCARD_SHARE_EXCLUSIVE = _scard.SCARD_SHARE_EXCLUSIVE
951 SCARD_SHARE_DIRECT = _scard.SCARD_SHARE_DIRECT
952 SCARD_LEAVE_CARD = _scard.SCARD_LEAVE_CARD
953 SCARD_RESET_CARD = _scard.SCARD_RESET_CARD
954 SCARD_UNPOWER_CARD = _scard.SCARD_UNPOWER_CARD
955 SCARD_EJECT_CARD = _scard.SCARD_EJECT_CARD
956 SCARD_STATE_UNAWARE = _scard.SCARD_STATE_UNAWARE
957 SCARD_STATE_IGNORE = _scard.SCARD_STATE_IGNORE
958 SCARD_STATE_CHANGED = _scard.SCARD_STATE_CHANGED
959 SCARD_STATE_UNKNOWN = _scard.SCARD_STATE_UNKNOWN
960 SCARD_STATE_UNAVAILABLE = _scard.SCARD_STATE_UNAVAILABLE
961 SCARD_STATE_EMPTY = _scard.SCARD_STATE_EMPTY
962 SCARD_STATE_PRESENT = _scard.SCARD_STATE_PRESENT
963 SCARD_STATE_ATRMATCH = _scard.SCARD_STATE_ATRMATCH
964 SCARD_STATE_EXCLUSIVE = _scard.SCARD_STATE_EXCLUSIVE
965 SCARD_STATE_INUSE = _scard.SCARD_STATE_INUSE
966 SCARD_STATE_MUTE = _scard.SCARD_STATE_MUTE
967 SCARD_STATE_UNPOWERED = _scard.SCARD_STATE_UNPOWERED
968 SCARD_PROTOCOL_UNSET = _scard.SCARD_PROTOCOL_UNSET
969 SCARD_PROTOCOL_T0 = _scard.SCARD_PROTOCOL_T0
970 SCARD_PROTOCOL_T1 = _scard.SCARD_PROTOCOL_T1
971 SCARD_PROTOCOL_RAW = _scard.SCARD_PROTOCOL_RAW
972 SCARD_PROTOCOL_T15 = _scard.SCARD_PROTOCOL_T15
973 SCARD_PROTOCOL_ANY = _scard.SCARD_PROTOCOL_ANY
974 SCARD_PROTOCOL_UNDEFINED = _scard.SCARD_PROTOCOL_UNDEFINED
975 SCARD_PROTOCOL_OPTIMAL = _scard.SCARD_PROTOCOL_OPTIMAL
976 SCARD_PROTOCOL_Tx = _scard.SCARD_PROTOCOL_Tx
977 SCARD_PROTOCOL_DEFAULT = _scard.SCARD_PROTOCOL_DEFAULT
978 SCARD_PCI_T0 = _scard.SCARD_PCI_T0
979 SCARD_PCI_T1 = _scard.SCARD_PCI_T1
980 SCARD_PCI_RAW = _scard.SCARD_PCI_RAW
981 SCARD_ATTR_VENDOR_NAME = _scard.SCARD_ATTR_VENDOR_NAME
982 SCARD_ATTR_VENDOR_IFD_TYPE = _scard.SCARD_ATTR_VENDOR_IFD_TYPE
983 SCARD_ATTR_VENDOR_IFD_VERSION = _scard.SCARD_ATTR_VENDOR_IFD_VERSION
984 SCARD_ATTR_VENDOR_IFD_SERIAL_NO = _scard.SCARD_ATTR_VENDOR_IFD_SERIAL_NO
985 SCARD_ATTR_CHANNEL_ID = _scard.SCARD_ATTR_CHANNEL_ID
986 SCARD_ATTR_ASYNC_PROTOCOL_TYPES = _scard.SCARD_ATTR_ASYNC_PROTOCOL_TYPES
987 SCARD_ATTR_DEFAULT_CLK = _scard.SCARD_ATTR_DEFAULT_CLK
988 SCARD_ATTR_MAX_CLK = _scard.SCARD_ATTR_MAX_CLK
989 SCARD_ATTR_DEFAULT_DATA_RATE = _scard.SCARD_ATTR_DEFAULT_DATA_RATE
990 SCARD_ATTR_MAX_DATA_RATE = _scard.SCARD_ATTR_MAX_DATA_RATE
991 SCARD_ATTR_MAX_IFSD = _scard.SCARD_ATTR_MAX_IFSD
992 SCARD_ATTR_SYNC_PROTOCOL_TYPES = _scard.SCARD_ATTR_SYNC_PROTOCOL_TYPES
993 SCARD_ATTR_POWER_MGMT_SUPPORT = _scard.SCARD_ATTR_POWER_MGMT_SUPPORT
994 SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE = _scard.SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE
995 SCARD_ATTR_USER_AUTH_INPUT_DEVICE = _scard.SCARD_ATTR_USER_AUTH_INPUT_DEVICE
996 SCARD_ATTR_CHARACTERISTICS = _scard.SCARD_ATTR_CHARACTERISTICS
997 SCARD_ATTR_CURRENT_PROTOCOL_TYPE = _scard.SCARD_ATTR_CURRENT_PROTOCOL_TYPE
998 SCARD_ATTR_CURRENT_CLK = _scard.SCARD_ATTR_CURRENT_CLK
999 SCARD_ATTR_CURRENT_F = _scard.SCARD_ATTR_CURRENT_F
1000 SCARD_ATTR_CURRENT_D = _scard.SCARD_ATTR_CURRENT_D
1001 SCARD_ATTR_CURRENT_N = _scard.SCARD_ATTR_CURRENT_N
1002 SCARD_ATTR_CURRENT_W = _scard.SCARD_ATTR_CURRENT_W
1003 SCARD_ATTR_CURRENT_IFSC = _scard.SCARD_ATTR_CURRENT_IFSC
1004 SCARD_ATTR_CURRENT_IFSD = _scard.SCARD_ATTR_CURRENT_IFSD
1005 SCARD_ATTR_CURRENT_BWT = _scard.SCARD_ATTR_CURRENT_BWT
1006 SCARD_ATTR_CURRENT_CWT = _scard.SCARD_ATTR_CURRENT_CWT
1007 SCARD_ATTR_CURRENT_EBC_ENCODING = _scard.SCARD_ATTR_CURRENT_EBC_ENCODING
1008 SCARD_ATTR_EXTENDED_BWT = _scard.SCARD_ATTR_EXTENDED_BWT
1009 SCARD_ATTR_ICC_PRESENCE = _scard.SCARD_ATTR_ICC_PRESENCE
1010 SCARD_ATTR_ICC_INTERFACE_STATUS = _scard.SCARD_ATTR_ICC_INTERFACE_STATUS
1011 SCARD_ATTR_CURRENT_IO_STATE = _scard.SCARD_ATTR_CURRENT_IO_STATE
1012 SCARD_ATTR_ATR_STRING = _scard.SCARD_ATTR_ATR_STRING
1013 SCARD_ATTR_ICC_TYPE_PER_ATR = _scard.SCARD_ATTR_ICC_TYPE_PER_ATR
1014 SCARD_ATTR_ESC_RESET = _scard.SCARD_ATTR_ESC_RESET
1015 SCARD_ATTR_ESC_CANCEL = _scard.SCARD_ATTR_ESC_CANCEL
1016 SCARD_ATTR_ESC_AUTHREQUEST = _scard.SCARD_ATTR_ESC_AUTHREQUEST
1017 SCARD_ATTR_MAXINPUT = _scard.SCARD_ATTR_MAXINPUT
1018 SCARD_ATTR_DEVICE_UNIT = _scard.SCARD_ATTR_DEVICE_UNIT
1019 SCARD_ATTR_DEVICE_IN_USE = _scard.SCARD_ATTR_DEVICE_IN_USE
1020 SCARD_ATTR_DEVICE_FRIENDLY_NAME_A = _scard.SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
1021 SCARD_ATTR_DEVICE_SYSTEM_NAME_A = _scard.SCARD_ATTR_DEVICE_SYSTEM_NAME_A
1022 SCARD_ATTR_DEVICE_FRIENDLY_NAME_W = _scard.SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
1023 SCARD_ATTR_DEVICE_SYSTEM_NAME_W = _scard.SCARD_ATTR_DEVICE_SYSTEM_NAME_W
1024 SCARD_ATTR_SUPRESS_T1_IFS_REQUEST = _scard.SCARD_ATTR_SUPRESS_T1_IFS_REQUEST
1025 SCARD_ATTR_DEVICE_FRIENDLY_NAME = _scard.SCARD_ATTR_DEVICE_FRIENDLY_NAME
1026 SCARD_ATTR_DEVICE_SYSTEM_NAME = _scard.SCARD_ATTR_DEVICE_SYSTEM_NAME
1027 SCARD_S_SUCCESS = _scard.SCARD_S_SUCCESS
1028 SCARD_F_INTERNAL_ERROR = _scard.SCARD_F_INTERNAL_ERROR
1029 SCARD_E_CANCELLED = _scard.SCARD_E_CANCELLED
1030 SCARD_E_INVALID_HANDLE = _scard.SCARD_E_INVALID_HANDLE
1031 SCARD_E_INVALID_PARAMETER = _scard.SCARD_E_INVALID_PARAMETER
1032 SCARD_E_INVALID_TARGET = _scard.SCARD_E_INVALID_TARGET
1033 SCARD_E_NO_MEMORY = _scard.SCARD_E_NO_MEMORY
1034 SCARD_F_WAITED_TOO_LONG = _scard.SCARD_F_WAITED_TOO_LONG
1035 SCARD_E_INSUFFICIENT_BUFFER = _scard.SCARD_E_INSUFFICIENT_BUFFER
1036 SCARD_E_UNKNOWN_READER = _scard.SCARD_E_UNKNOWN_READER
1037 SCARD_E_TIMEOUT = _scard.SCARD_E_TIMEOUT
1038 SCARD_E_SHARING_VIOLATION = _scard.SCARD_E_SHARING_VIOLATION
1039 SCARD_E_NO_SMARTCARD = _scard.SCARD_E_NO_SMARTCARD
1040 SCARD_E_UNKNOWN_CARD = _scard.SCARD_E_UNKNOWN_CARD
1041 SCARD_E_CANT_DISPOSE = _scard.SCARD_E_CANT_DISPOSE
1042 SCARD_E_PROTO_MISMATCH = _scard.SCARD_E_PROTO_MISMATCH
1043 SCARD_E_NOT_READY = _scard.SCARD_E_NOT_READY
1044 SCARD_E_INVALID_VALUE = _scard.SCARD_E_INVALID_VALUE
1045 SCARD_E_SYSTEM_CANCELLED = _scard.SCARD_E_SYSTEM_CANCELLED
1046 SCARD_F_COMM_ERROR = _scard.SCARD_F_COMM_ERROR
1047 SCARD_F_UNKNOWN_ERROR = _scard.SCARD_F_UNKNOWN_ERROR
1048 SCARD_E_INVALID_ATR = _scard.SCARD_E_INVALID_ATR
1049 SCARD_E_NOT_TRANSACTED = _scard.SCARD_E_NOT_TRANSACTED
1050 SCARD_E_READER_UNAVAILABLE = _scard.SCARD_E_READER_UNAVAILABLE
1051 SCARD_E_PCI_TOO_SMALL = _scard.SCARD_E_PCI_TOO_SMALL
1052 SCARD_E_READER_UNSUPPORTED = _scard.SCARD_E_READER_UNSUPPORTED
1053 SCARD_E_DUPLICATE_READER = _scard.SCARD_E_DUPLICATE_READER
1054 SCARD_E_CARD_UNSUPPORTED = _scard.SCARD_E_CARD_UNSUPPORTED
1055 SCARD_E_NO_SERVICE = _scard.SCARD_E_NO_SERVICE
1056 SCARD_E_SERVICE_STOPPED = _scard.SCARD_E_SERVICE_STOPPED
1057 SCARD_E_NO_READERS_AVAILABLE = _scard.SCARD_E_NO_READERS_AVAILABLE
1058 SCARD_E_UNSUPPORTED_FEATURE = _scard.SCARD_E_UNSUPPORTED_FEATURE
1059 SCARD_W_UNSUPPORTED_CARD = _scard.SCARD_W_UNSUPPORTED_CARD
1060 SCARD_W_UNRESPONSIVE_CARD = _scard.SCARD_W_UNRESPONSIVE_CARD
1061 SCARD_W_UNPOWERED_CARD = _scard.SCARD_W_UNPOWERED_CARD
1062 SCARD_W_RESET_CARD = _scard.SCARD_W_RESET_CARD
1063 SCARD_W_REMOVED_CARD = _scard.SCARD_W_REMOVED_CARD
1064 SCARD_W_SECURITY_VIOLATION = _scard.SCARD_W_SECURITY_VIOLATION
1065 SCARD_W_WRONG_CHV = _scard.SCARD_W_WRONG_CHV
1066 SCARD_W_CHV_BLOCKED = _scard.SCARD_W_CHV_BLOCKED
1067 SCARD_W_EOF = _scard.SCARD_W_EOF
1068 SCARD_W_CANCELLED_BY_USER = _scard.SCARD_W_CANCELLED_BY_USER
1069 SCARD_W_CARD_NOT_AUTHENTICATED = _scard.SCARD_W_CARD_NOT_AUTHENTICATED
1070 SCARD_E_UNEXPECTED = _scard.SCARD_E_UNEXPECTED
1071 SCARD_E_ICC_INSTALLATION = _scard.SCARD_E_ICC_INSTALLATION
1072 SCARD_E_ICC_CREATEORDER = _scard.SCARD_E_ICC_CREATEORDER
1073 SCARD_E_DIR_NOT_FOUND = _scard.SCARD_E_DIR_NOT_FOUND
1074 SCARD_E_FILE_NOT_FOUND = _scard.SCARD_E_FILE_NOT_FOUND
1075 SCARD_E_NO_DIR = _scard.SCARD_E_NO_DIR
1076 SCARD_E_NO_FILE = _scard.SCARD_E_NO_FILE
1077 SCARD_E_NO_ACCESS = _scard.SCARD_E_NO_ACCESS
1078 SCARD_E_WRITE_TOO_MANY = _scard.SCARD_E_WRITE_TOO_MANY
1079 SCARD_E_BAD_SEEK = _scard.SCARD_E_BAD_SEEK
1080 SCARD_E_INVALID_CHV = _scard.SCARD_E_INVALID_CHV
1081 SCARD_E_UNKNOWN_RES_MNG = _scard.SCARD_E_UNKNOWN_RES_MNG
1082 SCARD_E_NO_SUCH_CERTIFICATE = _scard.SCARD_E_NO_SUCH_CERTIFICATE
1083 SCARD_E_CERTIFICATE_UNAVAILABLE = _scard.SCARD_E_CERTIFICATE_UNAVAILABLE
1084 SCARD_E_COMM_DATA_LOST = _scard.SCARD_E_COMM_DATA_LOST
1085 SCARD_E_NO_KEY_CONTAINER = _scard.SCARD_E_NO_KEY_CONTAINER
1086 SCARD_E_SERVER_TOO_BUSY = _scard.SCARD_E_SERVER_TOO_BUSY
1087 INVALID_HANDLE = _scard.INVALID_HANDLE
1088 SCARD_P_SHUTDOWN = _scard.SCARD_P_SHUTDOWN
1089 INFINITE = _scard.INFINITE
1090 resourceManager = _scard.resourceManager
1091 resourceManagerSubType = _scard.resourceManagerSubType
1092
1093