vendor/winapi-0.3.3/src/um/winscard.rs

   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" {
  29     pub fn SCardEstablishContext(
  30         dwScope: DWORD,
  31         pvReserved1: LPCVOID,
  32         pvReserved2: LPCVOID,
  33         phContext: LPSCARDCONTEXT,
  34     ) -> LONG;
  35     pub fn SCardReleaseContext(
  36         hContext: SCARDCONTEXT,
  37     ) -> LONG;
  38     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" {
  46     pub fn SCardListReaderGroupsA(
  47         hContext: SCARDCONTEXT,
  48         mszGroups: LPSTR,
  49         pcchGroups: LPDWORD,
  50     ) -> LONG;
  51     pub fn SCardListReaderGroupsW(
  52         hContext: SCARDCONTEXT,
  53         mszGroups: LPWSTR,
  54         pcchGroups: LPDWORD,
  55     ) -> LONG;
  56     pub fn SCardListReadersA(
  57         hContext: SCARDCONTEXT,
  58         mszGroups: LPCSTR,
  59         mszReaders: LPSTR,
  60         pcchReaders: LPDWORD,
  61     ) -> LONG;
  62     pub fn SCardListReadersW(
  63         hContext: SCARDCONTEXT,
  64         mszGroups: LPCWSTR,
  65         mszReaders: LPWSTR,
  66         pcchReaders: LPDWORD,
  67     ) -> LONG;
  68     pub fn SCardListCardsA(
  69         hContext: SCARDCONTEXT,
  70         pbAtr: LPCBYTE,
  71         rgquidInterfaces: LPCGUID,
  72         cguidInterfaceCount: DWORD,
  73         mszCards: *mut CHAR,
  74         pcchCards: LPDWORD,
  75     ) -> LONG;
  76     pub fn SCardListCardsW(
  77         hContext: SCARDCONTEXT,
  78         pbAtr: LPCBYTE,
  79         rgquidInterfaces: LPCGUID,
  80         cguidInterfaceCount: DWORD,
  81         mszCards: *mut WCHAR,
  82         pcchCards: LPDWORD,
  83     ) -> LONG;
  84     pub fn SCardListInterfacesA(
  85         hContext: SCARDCONTEXT,
  86         szCard: LPCSTR,
  87         pguidInterfaces: LPGUID,
  88         pcguidInterfaces: LPDWORD,
  89     ) -> LONG;
  90     pub fn SCardListInterfacesW(
  91         hContext: SCARDCONTEXT,
  92         szCard: LPCWSTR,
  93         pguidInterfaces: LPGUID,
  94         pcguidInterfaces: LPDWORD,
  95     ) -> LONG;
  96     pub fn SCardGetProviderIdA(
  97         hContext: SCARDCONTEXT,
  98         szCard: LPCSTR,
  99         pguidProviderId: LPGUID,
 100     ) -> LONG;
 101     pub fn SCardGetProviderIdW(
 102         hContext: SCARDCONTEXT,
 103         szCard: LPCWSTR,
 104         pguidProviderId: LPGUID,
 105     ) -> LONG;
 106     pub fn SCardGetCardTypeProviderNameA(
 107         hContext: SCARDCONTEXT,
 108         szCardName: LPCSTR,
 109         dwProviderId: DWORD,
 110         szProvider: *mut CHAR,
 111         pcchProvider: LPDWORD,
 112     ) -> LONG;
 113     pub fn SCardGetCardTypeProviderNameW(
 114         hContext: SCARDCONTEXT,
 115         szCardName: LPCWSTR,
 116         dwProviderId: DWORD,
 117         szProvider: *mut WCHAR,
 118         pcchProvider: LPDWORD,
 119     ) -> LONG;
 120     pub fn SCardIntroduceReaderGroupA(
 121         hContext: SCARDCONTEXT,
 122         szGroupName: LPCSTR,
 123     ) -> LONG;
 124     pub fn SCardIntroduceReaderGroupW(
 125         hContext: SCARDCONTEXT,
 126         szGroupName: LPCWSTR,
 127     ) -> LONG;
 128     pub fn SCardForgetReaderGroupA(
 129         hContext: SCARDCONTEXT,
 130         szGroupName: LPCSTR,
 131     ) -> LONG;
 132     pub fn SCardForgetReaderGroupW(
 133         hContext: SCARDCONTEXT,
 134         szGroupName: LPCWSTR,
 135     ) -> LONG;
 136     pub fn SCardIntroduceReaderA(
 137         hContext: SCARDCONTEXT,
 138         szReaderName: LPCSTR,
 139         szDeviceName: LPCSTR,
 140     ) -> LONG;
 141     pub fn SCardIntroduceReaderW(
 142         hContext: SCARDCONTEXT,
 143         szReaderName: LPCWSTR,
 144         szDeviceName: LPCWSTR,
 145     ) -> LONG;
 146     pub fn SCardForgetReaderA(
 147         hContext: SCARDCONTEXT,
 148         szReaderName: LPCSTR,
 149     ) -> LONG;
 150     pub fn SCardForgetReaderW(
 151         hContext: SCARDCONTEXT,
 152         szReaderName: LPCWSTR,
 153     ) -> LONG;
 154     pub fn SCardAddReaderToGroupA(
 155         hContext: SCARDCONTEXT,
 156         szReaderName: LPCSTR,
 157         szGroupName: LPCSTR,
 158     ) -> LONG;
 159     pub fn SCardAddReaderToGroupW(
 160         hContext: SCARDCONTEXT,
 161         szReaderName: LPCWSTR,
 162         szGroupName: LPCWSTR,
 163     ) -> LONG;
 164     pub fn SCardRemoveReaderFromGroupA(
 165         hContext: SCARDCONTEXT,
 166         szReaderName: LPCSTR,
 167         szGroupName: LPCSTR,
 168     ) -> LONG;
 169     pub fn SCardRemoveReaderFromGroupW(
 170         hContext: SCARDCONTEXT,
 171         szReaderName: LPCWSTR,
 172         szGroupName: LPCWSTR,
 173     ) -> LONG;
 174     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;
 184     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;
 194     pub fn SCardSetCardTypeProviderNameA(
 195         hContext: SCARDCONTEXT,
 196         szCardName: LPCSTR,
 197         dwProviderId: DWORD,
 198         szProvider: LPCSTR,
 199     ) -> LONG;
 200     pub fn SCardSetCardTypeProviderNameW(
 201         hContext: SCARDCONTEXT,
 202         szCardName: LPCWSTR,
 203         dwProviderId: DWORD,
 204         szProvider: LPCWSTR,
 205     ) -> LONG;
 206     pub fn SCardForgetCardTypeA(
 207         hContext: SCARDCONTEXT,
 208         szCardName: LPCSTR,
 209     ) -> LONG;
 210     pub fn SCardForgetCardTypeW(
 211         hContext: SCARDCONTEXT,
 212         szCardName: LPCWSTR,
 213     ) -> LONG;
 214     pub fn SCardFreeMemory(
 215         hContext: SCARDCONTEXT,
 216         pvMem: LPCVOID,
 217     ) -> LONG;
 218     pub fn SCardAccessStartedEvent() -> HANDLE;
 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" {
 260     pub fn SCardLocateCardsA(
 261         hContext: SCARDCONTEXT,
 262         mszCards: LPCSTR,
 263         rgReaderStates: LPSCARD_READERSTATEA,
 264         cReaders: DWORD,
 265     ) -> LONG;
 266     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" {
 281     pub fn SCardLocateCardsByATRA(
 282         hContext: SCARDCONTEXT,
 283         rgAtrMasks: LPSCARD_ATRMASK,
 284         cAtrs: DWORD,
 285         rgReaderStates: LPSCARD_READERSTATEA,
 286         cReaders: DWORD,
 287     ) -> LONG;
 288     pub fn SCardLocateCardsByATRW(
 289         hContext: SCARDCONTEXT,
 290         rgAtrMasks: LPSCARD_ATRMASK,
 291         cAtrs: DWORD,
 292         rgReaderStates: LPSCARD_READERSTATEW,
 293         cReaders: DWORD,
 294     ) -> LONG;
 295     pub fn SCardGetStatusChangeA(
 296         hContext: SCARDCONTEXT,
 297         dwTimeout: DWORD,
 298         rgReaderStates: LPSCARD_READERSTATEA,
 299         cReaders: DWORD,
 300     ) -> LONG;
 301     pub fn SCardGetStatusChangeW(
 302         hContext: SCARDCONTEXT,
 303         dwTimeout: DWORD,
 304         rgReaderStates: LPSCARD_READERSTATEW,
 305         cReaders: DWORD,
 306     ) -> LONG;
 307     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" {
 319     pub fn SCardConnectA(
 320         hContext: SCARDCONTEXT,
 321         szReader: LPCSTR,
 322         dwShareMode: DWORD,
 323         dwPreferredProtocols: DWORD,
 324         phCard: LPSCARDHANDLE,
 325         pdwActiveProtocol: LPDWORD,
 326     ) -> LONG;
 327     pub fn SCardConnectW(
 328         hContext: SCARDCONTEXT,
 329         szReader: LPCWSTR,
 330         dwShareMode: DWORD,
 331         dwPreferredProtocols: DWORD,
 332         phCard: LPSCARDHANDLE,
 333         pdwActiveProtocol: LPDWORD,
 334     ) -> LONG;
 335     pub fn SCardReconnect(
 336         hCard: SCARDHANDLE,
 337         dwShareMode: DWORD,
 338         dwPreferredProtocols: DWORD,
 339         dwInitialization: DWORD,
 340         pdwActiveProtocol: LPDWORD,
 341     ) -> LONG;
 342     pub fn SCardDisconnect(
 343         hCard: SCARDHANDLE,
 344         dwDisposition: DWORD,
 345     ) -> LONG;
 346     pub fn SCardBeginTransaction(
 347         hCard: SCARDHANDLE,
 348     ) -> LONG;
 349     pub fn SCardEndTransaction(
 350         hCard: SCARDHANDLE,
 351         dwDisposition: DWORD,
 352     ) -> LONG;
 353     pub fn SCardState(
 354         hCard: SCARDHANDLE,
 355         pdwState: LPDWORD,
 356         pdwProtocol: LPDWORD,
 357         pbAtr: LPBYTE,
 358         pcbAtrLen: LPDWORD,
 359     ) -> LONG;
 360     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;
 369     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;
 378     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;
 387     pub fn SCardGetTransmitCount(
 388         hCard: SCARDHANDLE,
 389         pcTransmitCount: LPDWORD,
 390     ) -> LONG;
 391     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;
 400     pub fn SCardGetAttrib(
 401         hCard: SCARDHANDLE,
 402         dwAttrId: DWORD,
 403         pbAttr: LPBYTE,
 404         pcbAttrLen: LPDWORD,
 405     ) -> LONG;
 406     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" {
 624     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;
 632     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;
 640     pub fn SCardWriteCacheA(
 641         hContext: SCARDCONTEXT,
 642         CardIdentifier: *mut UUID,
 643         FreshnessCounter: DWORD,
 644         LookupName: LPSTR,
 645         Data: PBYTE,
 646         DataLen: DWORD,
 647     ) -> LONG;
 648     pub fn SCardWriteCacheW(
 649         hContext: SCARDCONTEXT,
 650         CardIdentifier: *mut UUID,
 651         FreshnessCounter: DWORD,
 652         LookupName: LPWSTR,
 653         Data: PBYTE,
 654         DataLen: DWORD,
 655     ) -> LONG;
 656     pub fn SCardGetReaderIconA(
 657         hContext: SCARDCONTEXT,
 658         szReaderName: LPCSTR,
 659         pbIcon: LPBYTE,
 660         pcbIcon: LPDWORD,
 661     ) -> LONG;
 662     pub fn SCardGetReaderIconW(
 663         hContext: SCARDCONTEXT,
 664         szReaderName: LPCWSTR,
 665         pbIcon: LPBYTE,
 666         pcbIcon: LPDWORD,
 667     ) -> LONG;
 668     pub fn SCardGetDeviceTypeIdA(
 669         hContext: SCARDCONTEXT,
 670         szReaderName: LPCSTR,
 671         pdwDeviceTypeId: LPDWORD,
 672     ) -> LONG;
 673     pub fn SCardGetDeviceTypeIdW(
 674         hContext: SCARDCONTEXT,
 675         szReaderName: LPCWSTR,
 676         pdwDeviceTypeId: LPDWORD,
 677     ) -> LONG;
 678     pub fn SCardGetReaderDeviceInstanceIdA(
 679         hContext: SCARDCONTEXT,
 680         szReaderName: LPCSTR,
 681         szDeviceInstanceId: LPSTR,
 682         pcchDeviceInstanceId: LPDWORD,
 683     ) -> LONG;
 684     pub fn SCardGetReaderDeviceInstanceIdW(
 685         hContext: SCARDCONTEXT,
 686         szReaderName: LPCWSTR,
 687         szDeviceInstanceId: LPWSTR,
 688         pcchDeviceInstanceId: LPDWORD,
 689     ) -> LONG;
 690     pub fn SCardListReadersWithDeviceInstanceIdA(
 691         hContext: SCARDCONTEXT,
 692         szDeviceInstanceId: LPCSTR,
 693         mszReaders: LPSTR,
 694         pcchReaders: LPDWORD,
 695     ) -> LONG;
 696     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" {
 706     pub fn SCardAudit(
 707         hContext: SCARDCONTEXT,
 708         dwEvent: DWORD,
 709     ) -> LONG;
 710 }