1 // Copyright © 2015-2017 winapi-rs developers
2 // Licensed under the Apache License, Version 2.0
3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
5 // All files in the project carrying such notice may not be copied, modified, or distributed
6 // except according to those terms.
7 //! Data Protection API Prototypes and Definitions
8 // This header file provides the definitions and symbols necessary for an
9 // Application or Smart Card Service Provider to access the Smartcard Subsystem.
10 use shared::basetsd::ULONG_PTR;
11 use shared::guiddef::{LPCGUID, LPGUID};
12 use shared::minwindef::{BOOL, BYTE, DWORD, LPBYTE, LPCVOID, LPDWORD, LPVOID, PBYTE};
13 use shared::rpcdce::UUID;
14 use shared::windef::{HICON, HWND};
15 use um::winnt::{CHAR, HANDLE, LONG, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PVOID, WCHAR};
16 use um::winsmcrd::{LPCSCARD_IO_REQUEST, LPSCARD_IO_REQUEST};
17 pub type LPCBYTE = *const BYTE;
18 pub type SCARDCONTEXT = ULONG_PTR;
19 pub type PSCARDCONTEXT = *mut SCARDCONTEXT;
20 pub type LPSCARDCONTEXT = *mut SCARDCONTEXT;
21 pub type SCARDHANDLE = ULONG_PTR;
22 pub type PSCARDHANDLE = *mut SCARDHANDLE;
23 pub type LPSCARDHANDLE = *mut SCARDHANDLE;
24 pub const SCARD_AUTOALLOCATE: DWORD = -1i32 as u32;
25 pub const SCARD_SCOPE_USER: DWORD = 0;
26 pub const SCARD_SCOPE_TERMINAL: DWORD = 1;
27 pub const SCARD_SCOPE_SYSTEM: DWORD = 2;
28 extern "system" {
SCardEstablishContext( dwScope: DWORD, pvReserved1: LPCVOID, pvReserved2: LPCVOID, phContext: LPSCARDCONTEXT, ) -> LONG29     pub fn SCardEstablishContext(
30         dwScope: DWORD,
31         pvReserved1: LPCVOID,
32         pvReserved2: LPCVOID,
33         phContext: LPSCARDCONTEXT,
34     ) -> LONG;
SCardReleaseContext( hContext: SCARDCONTEXT, ) -> LONG35     pub fn SCardReleaseContext(
36         hContext: SCARDCONTEXT,
37     ) -> LONG;
SCardIsValidContext( hContext: SCARDCONTEXT, ) -> LONG38     pub fn SCardIsValidContext(
39         hContext: SCARDCONTEXT,
40     ) -> LONG;
41 }
42 pub const SCARD_PROVIDER_PRIMARY: DWORD = 1;
43 pub const SCARD_PROVIDER_CSP: DWORD = 2;
44 pub const SCARD_PROVIDER_KSP: DWORD = 3;
45 extern "system" {
SCardListReaderGroupsA( hContext: SCARDCONTEXT, mszGroups: LPSTR, pcchGroups: LPDWORD, ) -> LONG46     pub fn SCardListReaderGroupsA(
47         hContext: SCARDCONTEXT,
48         mszGroups: LPSTR,
49         pcchGroups: LPDWORD,
50     ) -> LONG;
SCardListReaderGroupsW( hContext: SCARDCONTEXT, mszGroups: LPWSTR, pcchGroups: LPDWORD, ) -> LONG51     pub fn SCardListReaderGroupsW(
52         hContext: SCARDCONTEXT,
53         mszGroups: LPWSTR,
54         pcchGroups: LPDWORD,
55     ) -> LONG;
SCardListReadersA( hContext: SCARDCONTEXT, mszGroups: LPCSTR, mszReaders: LPSTR, pcchReaders: LPDWORD, ) -> LONG56     pub fn SCardListReadersA(
57         hContext: SCARDCONTEXT,
58         mszGroups: LPCSTR,
59         mszReaders: LPSTR,
60         pcchReaders: LPDWORD,
61     ) -> LONG;
SCardListReadersW( hContext: SCARDCONTEXT, mszGroups: LPCWSTR, mszReaders: LPWSTR, pcchReaders: LPDWORD, ) -> LONG62     pub fn SCardListReadersW(
63         hContext: SCARDCONTEXT,
64         mszGroups: LPCWSTR,
65         mszReaders: LPWSTR,
66         pcchReaders: LPDWORD,
67     ) -> LONG;
SCardListCardsA( hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: *mut CHAR, pcchCards: LPDWORD, ) -> LONG68     pub fn SCardListCardsA(
69         hContext: SCARDCONTEXT,
70         pbAtr: LPCBYTE,
71         rgquidInterfaces: LPCGUID,
72         cguidInterfaceCount: DWORD,
73         mszCards: *mut CHAR,
74         pcchCards: LPDWORD,
75     ) -> LONG;
SCardListCardsW( hContext: SCARDCONTEXT, pbAtr: LPCBYTE, rgquidInterfaces: LPCGUID, cguidInterfaceCount: DWORD, mszCards: *mut WCHAR, pcchCards: LPDWORD, ) -> LONG76     pub fn SCardListCardsW(
77         hContext: SCARDCONTEXT,
78         pbAtr: LPCBYTE,
79         rgquidInterfaces: LPCGUID,
80         cguidInterfaceCount: DWORD,
81         mszCards: *mut WCHAR,
82         pcchCards: LPDWORD,
83     ) -> LONG;
SCardListInterfacesA( hContext: SCARDCONTEXT, szCard: LPCSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD, ) -> LONG84     pub fn SCardListInterfacesA(
85         hContext: SCARDCONTEXT,
86         szCard: LPCSTR,
87         pguidInterfaces: LPGUID,
88         pcguidInterfaces: LPDWORD,
89     ) -> LONG;
SCardListInterfacesW( hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidInterfaces: LPGUID, pcguidInterfaces: LPDWORD, ) -> LONG90     pub fn SCardListInterfacesW(
91         hContext: SCARDCONTEXT,
92         szCard: LPCWSTR,
93         pguidInterfaces: LPGUID,
94         pcguidInterfaces: LPDWORD,
95     ) -> LONG;
SCardGetProviderIdA( hContext: SCARDCONTEXT, szCard: LPCSTR, pguidProviderId: LPGUID, ) -> LONG96     pub fn SCardGetProviderIdA(
97         hContext: SCARDCONTEXT,
98         szCard: LPCSTR,
99         pguidProviderId: LPGUID,
100     ) -> LONG;
SCardGetProviderIdW( hContext: SCARDCONTEXT, szCard: LPCWSTR, pguidProviderId: LPGUID, ) -> LONG101     pub fn SCardGetProviderIdW(
102         hContext: SCARDCONTEXT,
103         szCard: LPCWSTR,
104         pguidProviderId: LPGUID,
105     ) -> LONG;
SCardGetCardTypeProviderNameA( hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: *mut CHAR, pcchProvider: LPDWORD, ) -> LONG106     pub fn SCardGetCardTypeProviderNameA(
107         hContext: SCARDCONTEXT,
108         szCardName: LPCSTR,
109         dwProviderId: DWORD,
110         szProvider: *mut CHAR,
111         pcchProvider: LPDWORD,
112     ) -> LONG;
SCardGetCardTypeProviderNameW( hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: *mut WCHAR, pcchProvider: LPDWORD, ) -> LONG113     pub fn SCardGetCardTypeProviderNameW(
114         hContext: SCARDCONTEXT,
115         szCardName: LPCWSTR,
116         dwProviderId: DWORD,
117         szProvider: *mut WCHAR,
118         pcchProvider: LPDWORD,
119     ) -> LONG;
SCardIntroduceReaderGroupA( hContext: SCARDCONTEXT, szGroupName: LPCSTR, ) -> LONG120     pub fn SCardIntroduceReaderGroupA(
121         hContext: SCARDCONTEXT,
122         szGroupName: LPCSTR,
123     ) -> LONG;
SCardIntroduceReaderGroupW( hContext: SCARDCONTEXT, szGroupName: LPCWSTR, ) -> LONG124     pub fn SCardIntroduceReaderGroupW(
125         hContext: SCARDCONTEXT,
126         szGroupName: LPCWSTR,
127     ) -> LONG;
SCardForgetReaderGroupA( hContext: SCARDCONTEXT, szGroupName: LPCSTR, ) -> LONG128     pub fn SCardForgetReaderGroupA(
129         hContext: SCARDCONTEXT,
130         szGroupName: LPCSTR,
131     ) -> LONG;
SCardForgetReaderGroupW( hContext: SCARDCONTEXT, szGroupName: LPCWSTR, ) -> LONG132     pub fn SCardForgetReaderGroupW(
133         hContext: SCARDCONTEXT,
134         szGroupName: LPCWSTR,
135     ) -> LONG;
SCardIntroduceReaderA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, szDeviceName: LPCSTR, ) -> LONG136     pub fn SCardIntroduceReaderA(
137         hContext: SCARDCONTEXT,
138         szReaderName: LPCSTR,
139         szDeviceName: LPCSTR,
140     ) -> LONG;
SCardIntroduceReaderW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szDeviceName: LPCWSTR, ) -> LONG141     pub fn SCardIntroduceReaderW(
142         hContext: SCARDCONTEXT,
143         szReaderName: LPCWSTR,
144         szDeviceName: LPCWSTR,
145     ) -> LONG;
SCardForgetReaderA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, ) -> LONG146     pub fn SCardForgetReaderA(
147         hContext: SCARDCONTEXT,
148         szReaderName: LPCSTR,
149     ) -> LONG;
SCardForgetReaderW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, ) -> LONG150     pub fn SCardForgetReaderW(
151         hContext: SCARDCONTEXT,
152         szReaderName: LPCWSTR,
153     ) -> LONG;
SCardAddReaderToGroupA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR, ) -> LONG154     pub fn SCardAddReaderToGroupA(
155         hContext: SCARDCONTEXT,
156         szReaderName: LPCSTR,
157         szGroupName: LPCSTR,
158     ) -> LONG;
SCardAddReaderToGroupW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR, ) -> LONG159     pub fn SCardAddReaderToGroupW(
160         hContext: SCARDCONTEXT,
161         szReaderName: LPCWSTR,
162         szGroupName: LPCWSTR,
163     ) -> LONG;
SCardRemoveReaderFromGroupA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, szGroupName: LPCSTR, ) -> LONG164     pub fn SCardRemoveReaderFromGroupA(
165         hContext: SCARDCONTEXT,
166         szReaderName: LPCSTR,
167         szGroupName: LPCSTR,
168     ) -> LONG;
SCardRemoveReaderFromGroupW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szGroupName: LPCWSTR, ) -> LONG169     pub fn SCardRemoveReaderFromGroupW(
170         hContext: SCARDCONTEXT,
171         szReaderName: LPCWSTR,
172         szGroupName: LPCWSTR,
173     ) -> LONG;
SCardIntroduceCardTypeA( hContext: SCARDCONTEXT, szCardName: LPCSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD, ) -> LONG174     pub fn SCardIntroduceCardTypeA(
175         hContext: SCARDCONTEXT,
176         szCardName: LPCSTR,
177         pguidPrimaryProvider: LPCGUID,
178         rgguidInterfaces: LPCGUID,
179         dwInterfaceCount: DWORD,
180         pbAtr: LPCBYTE,
181         pbAtrMask: LPCBYTE,
182         cbAtrLen: DWORD,
183     ) -> LONG;
SCardIntroduceCardTypeW( hContext: SCARDCONTEXT, szCardName: LPCWSTR, pguidPrimaryProvider: LPCGUID, rgguidInterfaces: LPCGUID, dwInterfaceCount: DWORD, pbAtr: LPCBYTE, pbAtrMask: LPCBYTE, cbAtrLen: DWORD, ) -> LONG184     pub fn SCardIntroduceCardTypeW(
185         hContext: SCARDCONTEXT,
186         szCardName: LPCWSTR,
187         pguidPrimaryProvider: LPCGUID,
188         rgguidInterfaces: LPCGUID,
189         dwInterfaceCount: DWORD,
190         pbAtr: LPCBYTE,
191         pbAtrMask: LPCBYTE,
192         cbAtrLen: DWORD,
193     ) -> LONG;
SCardSetCardTypeProviderNameA( hContext: SCARDCONTEXT, szCardName: LPCSTR, dwProviderId: DWORD, szProvider: LPCSTR, ) -> LONG194     pub fn SCardSetCardTypeProviderNameA(
195         hContext: SCARDCONTEXT,
196         szCardName: LPCSTR,
197         dwProviderId: DWORD,
198         szProvider: LPCSTR,
199     ) -> LONG;
SCardSetCardTypeProviderNameW( hContext: SCARDCONTEXT, szCardName: LPCWSTR, dwProviderId: DWORD, szProvider: LPCWSTR, ) -> LONG200     pub fn SCardSetCardTypeProviderNameW(
201         hContext: SCARDCONTEXT,
202         szCardName: LPCWSTR,
203         dwProviderId: DWORD,
204         szProvider: LPCWSTR,
205     ) -> LONG;
SCardForgetCardTypeA( hContext: SCARDCONTEXT, szCardName: LPCSTR, ) -> LONG206     pub fn SCardForgetCardTypeA(
207         hContext: SCARDCONTEXT,
208         szCardName: LPCSTR,
209     ) -> LONG;
SCardForgetCardTypeW( hContext: SCARDCONTEXT, szCardName: LPCWSTR, ) -> LONG210     pub fn SCardForgetCardTypeW(
211         hContext: SCARDCONTEXT,
212         szCardName: LPCWSTR,
213     ) -> LONG;
SCardFreeMemory( hContext: SCARDCONTEXT, pvMem: LPCVOID, ) -> LONG214     pub fn SCardFreeMemory(
215         hContext: SCARDCONTEXT,
216         pvMem: LPCVOID,
217     ) -> LONG;
SCardAccessStartedEvent() -> HANDLE218     pub fn SCardAccessStartedEvent() -> HANDLE;
SCardReleaseStartedEvent()219     pub fn SCardReleaseStartedEvent();
220 }
221 STRUCT!{struct SCARD_READERSTATEA {
222     szReader: LPCSTR,
223     pvUserData: LPVOID,
224     dwCurrentState: DWORD,
225     dwEventState: DWORD,
226     cbAtr: DWORD,
227     rgbAtr: [BYTE; 36],
228 }}
229 pub type PSCARD_READERSTATEA = *mut SCARD_READERSTATEA;
230 pub type LPSCARD_READERSTATEA = *mut SCARD_READERSTATEA;
231 STRUCT!{struct SCARD_READERSTATEW {
232     szReader: LPCWSTR,
233     pvUserData: LPVOID,
234     dwCurrentState: DWORD,
235     dwEventState: DWORD,
236     cbAtr: DWORD,
237     rgbAtr: [BYTE; 36],
238 }}
239 pub type PSCARD_READERSTATEW = *mut SCARD_READERSTATEW;
240 pub type LPSCARD_READERSTATEW = *mut SCARD_READERSTATEW;
241 pub type SCARD_READERSTATE_A = SCARD_READERSTATEA;
242 pub type SCARD_READERSTATE_W = SCARD_READERSTATEW;
243 pub type PSCARD_READERSTATE_A = PSCARD_READERSTATEA;
244 pub type PSCARD_READERSTATE_W = PSCARD_READERSTATEW;
245 pub type LPSCARD_READERSTATE_A = LPSCARD_READERSTATEA;
246 pub type LPSCARD_READERSTATE_W = LPSCARD_READERSTATEW;
247 pub const SCARD_STATE_UNAWARE: DWORD = 0x00000000;
248 pub const SCARD_STATE_IGNORE: DWORD = 0x00000001;
249 pub const SCARD_STATE_CHANGED: DWORD = 0x00000002;
250 pub const SCARD_STATE_UNKNOWN: DWORD = 0x00000004;
251 pub const SCARD_STATE_UNAVAILABLE: DWORD = 0x00000008;
252 pub const SCARD_STATE_EMPTY: DWORD = 0x00000010;
253 pub const SCARD_STATE_PRESENT: DWORD = 0x00000020;
254 pub const SCARD_STATE_ATRMATCH: DWORD = 0x00000040;
255 pub const SCARD_STATE_EXCLUSIVE: DWORD = 0x00000080;
256 pub const SCARD_STATE_INUSE: DWORD = 0x00000100;
257 pub const SCARD_STATE_MUTE: DWORD = 0x00000200;
258 pub const SCARD_STATE_UNPOWERED: DWORD = 0x00000400;
259 extern "system" {
SCardLocateCardsA( hContext: SCARDCONTEXT, mszCards: LPCSTR, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD, ) -> LONG260     pub fn SCardLocateCardsA(
261         hContext: SCARDCONTEXT,
262         mszCards: LPCSTR,
263         rgReaderStates: LPSCARD_READERSTATEA,
264         cReaders: DWORD,
265     ) -> LONG;
SCardLocateCardsW( hContext: SCARDCONTEXT, mszCards: LPCWSTR, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD, ) -> LONG266     pub fn SCardLocateCardsW(
267         hContext: SCARDCONTEXT,
268         mszCards: LPCWSTR,
269         rgReaderStates: LPSCARD_READERSTATEW,
270         cReaders: DWORD,
271     ) -> LONG;
272 }
273 STRUCT!{struct SCARD_ATRMASK {
274     cbAtr: DWORD,
275     rgbAtr: [BYTE; 36],
276     rgbMask: [BYTE; 36],
277 }}
278 pub type PSCARD_ATRMASK = *mut SCARD_ATRMASK;
279 pub type LPSCARD_ATRMASK = *mut SCARD_ATRMASK;
280 extern "system" {
SCardLocateCardsByATRA( hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD, ) -> LONG281     pub fn SCardLocateCardsByATRA(
282         hContext: SCARDCONTEXT,
283         rgAtrMasks: LPSCARD_ATRMASK,
284         cAtrs: DWORD,
285         rgReaderStates: LPSCARD_READERSTATEA,
286         cReaders: DWORD,
287     ) -> LONG;
SCardLocateCardsByATRW( hContext: SCARDCONTEXT, rgAtrMasks: LPSCARD_ATRMASK, cAtrs: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD, ) -> LONG288     pub fn SCardLocateCardsByATRW(
289         hContext: SCARDCONTEXT,
290         rgAtrMasks: LPSCARD_ATRMASK,
291         cAtrs: DWORD,
292         rgReaderStates: LPSCARD_READERSTATEW,
293         cReaders: DWORD,
294     ) -> LONG;
SCardGetStatusChangeA( hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEA, cReaders: DWORD, ) -> LONG295     pub fn SCardGetStatusChangeA(
296         hContext: SCARDCONTEXT,
297         dwTimeout: DWORD,
298         rgReaderStates: LPSCARD_READERSTATEA,
299         cReaders: DWORD,
300     ) -> LONG;
SCardGetStatusChangeW( hContext: SCARDCONTEXT, dwTimeout: DWORD, rgReaderStates: LPSCARD_READERSTATEW, cReaders: DWORD, ) -> LONG301     pub fn SCardGetStatusChangeW(
302         hContext: SCARDCONTEXT,
303         dwTimeout: DWORD,
304         rgReaderStates: LPSCARD_READERSTATEW,
305         cReaders: DWORD,
306     ) -> LONG;
SCardCancel( hContext: SCARDCONTEXT, ) -> LONG307     pub fn SCardCancel(
308         hContext: SCARDCONTEXT,
309     ) -> LONG;
310 }
311 pub const SCARD_SHARE_EXCLUSIVE: DWORD = 1;
312 pub const SCARD_SHARE_SHARED: DWORD = 2;
313 pub const SCARD_SHARE_DIRECT: DWORD = 3;
314 pub const SCARD_LEAVE_CARD: DWORD = 0;
315 pub const SCARD_RESET_CARD: DWORD = 1;
316 pub const SCARD_UNPOWER_CARD: DWORD = 2;
317 pub const SCARD_EJECT_CARD: DWORD = 3;
318 extern "system" {
SCardConnectA( hContext: SCARDCONTEXT, szReader: LPCSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD, ) -> LONG319     pub fn SCardConnectA(
320         hContext: SCARDCONTEXT,
321         szReader: LPCSTR,
322         dwShareMode: DWORD,
323         dwPreferredProtocols: DWORD,
324         phCard: LPSCARDHANDLE,
325         pdwActiveProtocol: LPDWORD,
326     ) -> LONG;
SCardConnectW( hContext: SCARDCONTEXT, szReader: LPCWSTR, dwShareMode: DWORD, dwPreferredProtocols: DWORD, phCard: LPSCARDHANDLE, pdwActiveProtocol: LPDWORD, ) -> LONG327     pub fn SCardConnectW(
328         hContext: SCARDCONTEXT,
329         szReader: LPCWSTR,
330         dwShareMode: DWORD,
331         dwPreferredProtocols: DWORD,
332         phCard: LPSCARDHANDLE,
333         pdwActiveProtocol: LPDWORD,
334     ) -> LONG;
SCardReconnect( hCard: SCARDHANDLE, dwShareMode: DWORD, dwPreferredProtocols: DWORD, dwInitialization: DWORD, pdwActiveProtocol: LPDWORD, ) -> LONG335     pub fn SCardReconnect(
336         hCard: SCARDHANDLE,
337         dwShareMode: DWORD,
338         dwPreferredProtocols: DWORD,
339         dwInitialization: DWORD,
340         pdwActiveProtocol: LPDWORD,
341     ) -> LONG;
SCardDisconnect( hCard: SCARDHANDLE, dwDisposition: DWORD, ) -> LONG342     pub fn SCardDisconnect(
343         hCard: SCARDHANDLE,
344         dwDisposition: DWORD,
345     ) -> LONG;
SCardBeginTransaction( hCard: SCARDHANDLE, ) -> LONG346     pub fn SCardBeginTransaction(
347         hCard: SCARDHANDLE,
348     ) -> LONG;
SCardEndTransaction( hCard: SCARDHANDLE, dwDisposition: DWORD, ) -> LONG349     pub fn SCardEndTransaction(
350         hCard: SCARDHANDLE,
351         dwDisposition: DWORD,
352     ) -> LONG;
SCardState( hCard: SCARDHANDLE, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD, ) -> LONG353     pub fn SCardState(
354         hCard: SCARDHANDLE,
355         pdwState: LPDWORD,
356         pdwProtocol: LPDWORD,
357         pbAtr: LPBYTE,
358         pcbAtrLen: LPDWORD,
359     ) -> LONG;
SCardStatusA( hCard: SCARDHANDLE, mszReaderNames: LPSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD, ) -> LONG360     pub fn SCardStatusA(
361         hCard: SCARDHANDLE,
362         mszReaderNames: LPSTR,
363         pcchReaderLen: LPDWORD,
364         pdwState: LPDWORD,
365         pdwProtocol: LPDWORD,
366         pbAtr: LPBYTE,
367         pcbAtrLen: LPDWORD,
368     ) -> LONG;
SCardStatusW( hCard: SCARDHANDLE, mszReaderNames: LPWSTR, pcchReaderLen: LPDWORD, pdwState: LPDWORD, pdwProtocol: LPDWORD, pbAtr: LPBYTE, pcbAtrLen: LPDWORD, ) -> LONG369     pub fn SCardStatusW(
370         hCard: SCARDHANDLE,
371         mszReaderNames: LPWSTR,
372         pcchReaderLen: LPDWORD,
373         pdwState: LPDWORD,
374         pdwProtocol: LPDWORD,
375         pbAtr: LPBYTE,
376         pcbAtrLen: LPDWORD,
377     ) -> LONG;
SCardTransmit( hCard: SCARDHANDLE, pioSendPci: LPCSCARD_IO_REQUEST, pbSendBuffer: LPCBYTE, cbSendLength: DWORD, pioRecvPci: LPSCARD_IO_REQUEST, pbRecvBuffer: LPBYTE, pcbRecvLength: LPDWORD, ) -> LONG378     pub fn SCardTransmit(
379         hCard: SCARDHANDLE,
380         pioSendPci: LPCSCARD_IO_REQUEST,
381         pbSendBuffer: LPCBYTE,
382         cbSendLength: DWORD,
383         pioRecvPci: LPSCARD_IO_REQUEST,
384         pbRecvBuffer: LPBYTE,
385         pcbRecvLength: LPDWORD,
386     ) -> LONG;
SCardGetTransmitCount( hCard: SCARDHANDLE, pcTransmitCount: LPDWORD, ) -> LONG387     pub fn SCardGetTransmitCount(
388         hCard: SCARDHANDLE,
389         pcTransmitCount: LPDWORD,
390     ) -> LONG;
SCardControl( hCard: SCARDHANDLE, dwControlCode: DWORD, lpInBuffer: LPCVOID, cbInBufferSize: DWORD, lpOutBuffer: LPVOID, cbOutBufferSize: DWORD, lpBytesReturned: LPDWORD, ) -> LONG391     pub fn SCardControl(
392         hCard: SCARDHANDLE,
393         dwControlCode: DWORD,
394         lpInBuffer: LPCVOID,
395         cbInBufferSize: DWORD,
396         lpOutBuffer: LPVOID,
397         cbOutBufferSize: DWORD,
398         lpBytesReturned: LPDWORD,
399     ) -> LONG;
SCardGetAttrib( hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPBYTE, pcbAttrLen: LPDWORD, ) -> LONG400     pub fn SCardGetAttrib(
401         hCard: SCARDHANDLE,
402         dwAttrId: DWORD,
403         pbAttr: LPBYTE,
404         pcbAttrLen: LPDWORD,
405     ) -> LONG;
SCardSetAttrib( hCard: SCARDHANDLE, dwAttrId: DWORD, pbAttr: LPCBYTE, cbAttrLen: DWORD, ) -> LONG406     pub fn SCardSetAttrib(
407         hCard: SCARDHANDLE,
408         dwAttrId: DWORD,
409         pbAttr: LPCBYTE,
410         cbAttrLen: DWORD,
411     ) -> LONG;
412 }
413 pub const SC_DLG_MINIMAL_UI: DWORD = 0x01;
414 pub const SC_DLG_NO_UI: DWORD = 0x02;
415 pub const SC_DLG_FORCE_UI: DWORD = 0x04;
416 pub const SCERR_NOCARDNAME: DWORD = 0x4000;
417 pub const SCERR_NOGUIDS: DWORD = 0x8000;
418 FN!{stdcall LPOCNCONNPROCA(
419     SCARDCONTEXT,
420     LPSTR,
421     LPSTR,
422     PVOID,
423 ) -> SCARDHANDLE}
424 FN!{stdcall LPOCNCONNPROCW(
425     SCARDCONTEXT,
426     LPWSTR,
427     LPWSTR,
428     PVOID,
429 ) -> SCARDHANDLE}
430 FN!{stdcall LPOCNCHKPROC(
431     SCARDCONTEXT,
432     SCARDHANDLE,
433     PVOID,
434 ) -> BOOL}
435 FN!{stdcall LPOCNDSCPROC(
436     SCARDCONTEXT,
437     SCARDHANDLE,
438     PVOID,
439 ) -> ()}
440 STRUCT!{struct OPENCARD_SEARCH_CRITERIAA {
441     dwStructSize: DWORD,
442     lpstrGroupNames: LPSTR,
443     nMaxGroupNames: DWORD,
444     rgguidInterfaces: LPCGUID,
445     cguidInterfaces: DWORD,
446     lpstrCardNames: LPSTR,
447     nMaxCardNames: DWORD,
448     lpfnCheck: LPOCNCHKPROC,
449     lpfnConnect: LPOCNCONNPROCA,
450     lpfnDisconnect: LPOCNDSCPROC,
451     pvUserData: LPVOID,
452     dwShareMode: DWORD,
453     dwPreferredProtocols: DWORD,
454 }}
455 pub type POPENCARD_SEARCH_CRITERIAA = *mut OPENCARD_SEARCH_CRITERIAA;
456 pub type LPOPENCARD_SEARCH_CRITERIAA = *mut OPENCARD_SEARCH_CRITERIAA;
457 STRUCT!{struct OPENCARD_SEARCH_CRITERIAW {
458     dwStructSize: DWORD,
459     lpstrGroupNames: LPWSTR,
460     nMaxGroupNames: DWORD,
461     rgguidInterfaces: LPCGUID,
462     cguidInterfaces: DWORD,
463     lpstrCardNames: LPWSTR,
464     nMaxCardNames: DWORD,
465     lpfnCheck: LPOCNCHKPROC,
466     lpfnConnect: LPOCNCONNPROCW,
467     lpfnDisconnect: LPOCNDSCPROC,
468     pvUserData: LPVOID,
469     dwShareMode: DWORD,
470     dwPreferredProtocols: DWORD,
471 }}
472 pub type POPENCARD_SEARCH_CRITERIAW = *mut OPENCARD_SEARCH_CRITERIAW;
473 pub type LPOPENCARD_SEARCH_CRITERIAW = *mut OPENCARD_SEARCH_CRITERIAW;
474 STRUCT!{struct OPENCARDNAME_EXA {
475     dwStructSize: DWORD,
476     hSCardContext: SCARDCONTEXT,
477     hwndOwner: HWND,
478     dwFlags: DWORD,
479     lpstrTitle: LPCSTR,
480     lpstrSearchDesc: LPCSTR,
481     hIcon: HICON,
482     pOpenCardSearchCriteria: POPENCARD_SEARCH_CRITERIAA,
483     lpfnConnect: LPOCNCONNPROCA,
484     pvUserData: LPVOID,
485     dwShareMode: DWORD,
486     dwPreferredProtocols: DWORD,
487     lpstrRdr: LPSTR,
488     nMaxRdr: DWORD,
489     lpstrCard: LPSTR,
490     nMaxCard: DWORD,
491     dwActiveProtocol: DWORD,
492     hCardHandle: SCARDHANDLE,
493 }}
494 pub type POPENCARDNAME_EXA = *mut OPENCARDNAME_EXA;
495 pub type LPOPENCARDNAME_EXA = *mut OPENCARDNAME_EXA;
496 STRUCT!{struct OPENCARDNAME_EXW {
497     dwStructSize: DWORD,
498     hSCardContext: SCARDCONTEXT,
499     hwndOwner: HWND,
500     dwFlags: DWORD,
501     lpstrTitle: LPCWSTR,
502     lpstrSearchDesc: LPCWSTR,
503     hIcon: HICON,
504     pOpenCardSearchCriteria: POPENCARD_SEARCH_CRITERIAW,
505     lpfnConnect: LPOCNCONNPROCW,
506     pvUserData: LPVOID,
507     dwShareMode: DWORD,
508     dwPreferredProtocols: DWORD,
509     lpstrRdr: LPWSTR,
510     nMaxRdr: DWORD,
511     lpstrCard: LPWSTR,
512     nMaxCard: DWORD,
513     dwActiveProtocol: DWORD,
514     hCardHandle: SCARDHANDLE,
515 }}
516 pub type POPENCARDNAME_EXW = *mut OPENCARDNAME_EXW;
517 pub type LPOPENCARDNAME_EXW = *mut OPENCARDNAME_EXW;
518 pub type OPENCARDNAMEA_EX = OPENCARDNAME_EXA;
519 pub type OPENCARDNAMEW_EX = OPENCARDNAME_EXW;
520 pub type POPENCARDNAMEA_EX = POPENCARDNAME_EXA;
521 pub type POPENCARDNAMEW_EX = POPENCARDNAME_EXW;
522 pub type LPOPENCARDNAMEA_EX = LPOPENCARDNAME_EXA;
523 pub type LPOPENCARDNAMEW_EX = LPOPENCARDNAME_EXW;
524 pub const SCARD_READER_SEL_AUTH_PACKAGE: DWORD = -629i32 as u32;
525 ENUM!{enum READER_SEL_REQUEST_MATCH_TYPE {
526     RSR_MATCH_TYPE_READER_AND_CONTAINER = 1,
527     RSR_MATCH_TYPE_SERIAL_NUMBER,
528     RSR_MATCH_TYPE_ALL_CARDS,
529 }}
530 STRUCT!{struct READER_SEL_REQUEST_ReaderAndContainerParameter {
531     cbReaderNameOffset: DWORD,
532     cchReaderNameLength: DWORD,
533     cbContainerNameOffset: DWORD,
534     cchContainerNameLength: DWORD,
535     dwDesiredCardModuleVersion: DWORD,
536     dwCspFlags: DWORD,
537 }}
538 STRUCT!{struct READER_SEL_REQUEST_SerialNumberParameter {
539     cbSerialNumberOffset: DWORD,
540     cbSerialNumberLength: DWORD,
541     dwDesiredCardModuleVersion: DWORD,
542 }}
543 UNION!{union READER_SEL_REQUEST_u {
544     [u32; 6],
545     ReaderAndContainerParameter ReaderAndContainerParameter_mut:
546         READER_SEL_REQUEST_ReaderAndContainerParameter,
547     SerialNumberParameter SerialNumberParameter_mut: READER_SEL_REQUEST_SerialNumberParameter,
548 }}
549 STRUCT!{struct READER_SEL_REQUEST {
550     dwShareMode: DWORD,
551     dwPreferredProtocols: DWORD,
552     MatchType: READER_SEL_REQUEST_MATCH_TYPE,
553     u: READER_SEL_REQUEST_u,
554 }}
555 pub type PREADER_SEL_REQUEST = *mut READER_SEL_REQUEST;
556 STRUCT!{struct READER_SEL_RESPONSE {
557     cbReaderNameOffset: DWORD,
558     cchReaderNameLength: DWORD,
559     cbCardNameOffset: DWORD,
560     cchCardNameLength: DWORD,
561 }}
562 pub type PREADER_SEL_RESPONSE = *mut READER_SEL_RESPONSE;
563 STRUCT!{struct OPENCARDNAMEA {
564     dwStructSize: DWORD,
565     hwndOwner: HWND,
566     hSCardContext: SCARDCONTEXT,
567     lpstrGroupNames: LPSTR,
568     nMaxGroupNames: DWORD,
569     lpstrCardNames: LPSTR,
570     nMaxCardNames: DWORD,
571     rgguidInterfaces: LPCGUID,
572     cguidInterfaces: DWORD,
573     lpstrRdr: LPSTR,
574     nMaxRdr: DWORD,
575     lpstrCard: LPSTR,
576     nMaxCard: DWORD,
577     lpstrTitle: LPCSTR,
578     dwFlags: DWORD,
579     pvUserData: LPVOID,
580     dwShareMode: DWORD,
581     dwPreferredProtocols: DWORD,
582     dwActiveProtocol: DWORD,
583     lpfnConnect: LPOCNCONNPROCA,
584     lpfnCheck: LPOCNCHKPROC,
585     lpfnDisconnect: LPOCNDSCPROC,
586     hCardHandle: SCARDHANDLE,
587 }}
588 pub type POPENCARDNAMEA = *mut OPENCARDNAMEA;
589 pub type LPOPENCARDNAMEA = *mut OPENCARDNAMEA;
590 STRUCT!{struct OPENCARDNAMEW {
591     dwStructSize: DWORD,
592     hwndOwner: HWND,
593     hSCardContext: SCARDCONTEXT,
594     lpstrGroupNames: LPWSTR,
595     nMaxGroupNames: DWORD,
596     lpstrCardNames: LPWSTR,
597     nMaxCardNames: DWORD,
598     rgguidInterfaces: LPCGUID,
599     cguidInterfaces: DWORD,
600     lpstrRdr: LPWSTR,
601     nMaxRdr: DWORD,
602     lpstrCard: LPWSTR,
603     nMaxCard: DWORD,
604     lpstrTitle: LPCWSTR,
605     dwFlags: DWORD,
606     pvUserData: LPVOID,
607     dwShareMode: DWORD,
608     dwPreferredProtocols: DWORD,
609     dwActiveProtocol: DWORD,
610     lpfnConnect: LPOCNCONNPROCW,
611     lpfnCheck: LPOCNCHKPROC,
612     lpfnDisconnect: LPOCNDSCPROC,
613     hCardHandle: SCARDHANDLE,
614 }}
615 pub type POPENCARDNAMEW = *mut OPENCARDNAMEW;
616 pub type LPOPENCARDNAMEW = *mut OPENCARDNAMEW;
617 pub type OPENCARDNAME_A = OPENCARDNAMEA;
618 pub type OPENCARDNAME_W = OPENCARDNAMEW;
619 pub type POPENCARDNAME_A = POPENCARDNAMEA;
620 pub type POPENCARDNAME_W = POPENCARDNAMEW;
621 pub type LPOPENCARDNAME_A = LPOPENCARDNAMEA;
622 pub type LPOPENCARDNAME_W = LPOPENCARDNAMEW;
623 extern "system" {
SCardReadCacheA( hContext: SCARDCONTEXT, CardIdentifier: *mut UUID, FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: *mut DWORD, ) -> LONG624     pub fn SCardReadCacheA(
625         hContext: SCARDCONTEXT,
626         CardIdentifier: *mut UUID,
627         FreshnessCounter: DWORD,
628         LookupName: LPSTR,
629         Data: PBYTE,
630         DataLen: *mut DWORD,
631     ) -> LONG;
SCardReadCacheW( hContext: SCARDCONTEXT, CardIdentifier: *mut UUID, FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: *mut DWORD, ) -> LONG632     pub fn SCardReadCacheW(
633         hContext: SCARDCONTEXT,
634         CardIdentifier: *mut UUID,
635         FreshnessCounter: DWORD,
636         LookupName: LPWSTR,
637         Data: PBYTE,
638         DataLen: *mut DWORD,
639     ) -> LONG;
SCardWriteCacheA( hContext: SCARDCONTEXT, CardIdentifier: *mut UUID, FreshnessCounter: DWORD, LookupName: LPSTR, Data: PBYTE, DataLen: DWORD, ) -> LONG640     pub fn SCardWriteCacheA(
641         hContext: SCARDCONTEXT,
642         CardIdentifier: *mut UUID,
643         FreshnessCounter: DWORD,
644         LookupName: LPSTR,
645         Data: PBYTE,
646         DataLen: DWORD,
647     ) -> LONG;
SCardWriteCacheW( hContext: SCARDCONTEXT, CardIdentifier: *mut UUID, FreshnessCounter: DWORD, LookupName: LPWSTR, Data: PBYTE, DataLen: DWORD, ) -> LONG648     pub fn SCardWriteCacheW(
649         hContext: SCARDCONTEXT,
650         CardIdentifier: *mut UUID,
651         FreshnessCounter: DWORD,
652         LookupName: LPWSTR,
653         Data: PBYTE,
654         DataLen: DWORD,
655     ) -> LONG;
SCardGetReaderIconA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, pbIcon: LPBYTE, pcbIcon: LPDWORD, ) -> LONG656     pub fn SCardGetReaderIconA(
657         hContext: SCARDCONTEXT,
658         szReaderName: LPCSTR,
659         pbIcon: LPBYTE,
660         pcbIcon: LPDWORD,
661     ) -> LONG;
SCardGetReaderIconW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, pbIcon: LPBYTE, pcbIcon: LPDWORD, ) -> LONG662     pub fn SCardGetReaderIconW(
663         hContext: SCARDCONTEXT,
664         szReaderName: LPCWSTR,
665         pbIcon: LPBYTE,
666         pcbIcon: LPDWORD,
667     ) -> LONG;
SCardGetDeviceTypeIdA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, pdwDeviceTypeId: LPDWORD, ) -> LONG668     pub fn SCardGetDeviceTypeIdA(
669         hContext: SCARDCONTEXT,
670         szReaderName: LPCSTR,
671         pdwDeviceTypeId: LPDWORD,
672     ) -> LONG;
SCardGetDeviceTypeIdW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, pdwDeviceTypeId: LPDWORD, ) -> LONG673     pub fn SCardGetDeviceTypeIdW(
674         hContext: SCARDCONTEXT,
675         szReaderName: LPCWSTR,
676         pdwDeviceTypeId: LPDWORD,
677     ) -> LONG;
SCardGetReaderDeviceInstanceIdA( hContext: SCARDCONTEXT, szReaderName: LPCSTR, szDeviceInstanceId: LPSTR, pcchDeviceInstanceId: LPDWORD, ) -> LONG678     pub fn SCardGetReaderDeviceInstanceIdA(
679         hContext: SCARDCONTEXT,
680         szReaderName: LPCSTR,
681         szDeviceInstanceId: LPSTR,
682         pcchDeviceInstanceId: LPDWORD,
683     ) -> LONG;
SCardGetReaderDeviceInstanceIdW( hContext: SCARDCONTEXT, szReaderName: LPCWSTR, szDeviceInstanceId: LPWSTR, pcchDeviceInstanceId: LPDWORD, ) -> LONG684     pub fn SCardGetReaderDeviceInstanceIdW(
685         hContext: SCARDCONTEXT,
686         szReaderName: LPCWSTR,
687         szDeviceInstanceId: LPWSTR,
688         pcchDeviceInstanceId: LPDWORD,
689     ) -> LONG;
SCardListReadersWithDeviceInstanceIdA( hContext: SCARDCONTEXT, szDeviceInstanceId: LPCSTR, mszReaders: LPSTR, pcchReaders: LPDWORD, ) -> LONG690     pub fn SCardListReadersWithDeviceInstanceIdA(
691         hContext: SCARDCONTEXT,
692         szDeviceInstanceId: LPCSTR,
693         mszReaders: LPSTR,
694         pcchReaders: LPDWORD,
695     ) -> LONG;
SCardListReadersWithDeviceInstanceIdW( hContext: SCARDCONTEXT, szDeviceInstanceId: LPCWSTR, mszReaders: LPWSTR, pcchReaders: LPDWORD, ) -> LONG696     pub fn SCardListReadersWithDeviceInstanceIdW(
697         hContext: SCARDCONTEXT,
698         szDeviceInstanceId: LPCWSTR,
699         mszReaders: LPWSTR,
700         pcchReaders: LPDWORD,
701     ) -> LONG;
702 }
703 pub const SCARD_AUDIT_CHV_FAILURE: DWORD = 0x0;
704 pub const SCARD_AUDIT_CHV_SUCCESS: DWORD = 0x1;
705 extern "system" {
SCardAudit( hContext: SCARDCONTEXT, dwEvent: DWORD, ) -> LONG706     pub fn SCardAudit(
707         hContext: SCARDCONTEXT,
708         dwEvent: DWORD,
709     ) -> LONG;
710 }
711