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