| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! Data Protection API Prototypes and Definitions |
| // This header file provides the definitions and symbols necessary for an |
| // Application or Smart Card Service Provider to access the Smartcard Subsystem. |
| use shared::basetsd::ULONG_PTR; |
| use shared::guiddef::{LPCGUID, LPGUID}; |
| use shared::minwindef::{BOOL, BYTE, DWORD, LPBYTE, LPCVOID, LPDWORD, LPVOID, PBYTE}; |
| use shared::rpcdce::UUID; |
| use shared::windef::{HICON, HWND}; |
| use um::winnt::{CHAR, HANDLE, LONG, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PVOID, WCHAR}; |
| use um::winsmcrd::{LPCSCARD_IO_REQUEST, LPSCARD_IO_REQUEST}; |
| pub type LPCBYTE = *const BYTE; |
| pub type SCARDCONTEXT = ULONG_PTR; |
| pub type PSCARDCONTEXT = *mut SCARDCONTEXT; |
| pub type LPSCARDCONTEXT = *mut SCARDCONTEXT; |
| pub type SCARDHANDLE = ULONG_PTR; |
| pub type PSCARDHANDLE = *mut SCARDHANDLE; |
| pub type LPSCARDHANDLE = *mut SCARDHANDLE; |
| pub const SCARD_AUTOALLOCATE: DWORD = -1i32 as u32; |
| pub const SCARD_SCOPE_USER: DWORD = 0; |
| pub const SCARD_SCOPE_TERMINAL: DWORD = 1; |
| pub const SCARD_SCOPE_SYSTEM: DWORD = 2; |
| extern "system" { |
| pub fn SCardEstablishContext( |
| dwScope: DWORD, |
| pvReserved1: LPCVOID, |
| pvReserved2: LPCVOID, |
| phContext: LPSCARDCONTEXT, |
| ) -> LONG; |
| pub fn SCardReleaseContext( |
| hContext: SCARDCONTEXT, |
| ) -> LONG; |
| pub fn SCardIsValidContext( |
| hContext: SCARDCONTEXT, |
| ) -> LONG; |
| } |
| pub const SCARD_PROVIDER_PRIMARY: DWORD = 1; |
| pub const SCARD_PROVIDER_CSP: DWORD = 2; |
| pub const SCARD_PROVIDER_KSP: DWORD = 3; |
| extern "system" { |
| pub fn SCardListReaderGroupsA( |
| hContext: SCARDCONTEXT, |
| mszGroups: LPSTR, |
| pcchGroups: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListReaderGroupsW( |
| hContext: SCARDCONTEXT, |
| mszGroups: LPWSTR, |
| pcchGroups: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListReadersA( |
| hContext: SCARDCONTEXT, |
| mszGroups: LPCSTR, |
| mszReaders: LPSTR, |
| pcchReaders: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListReadersW( |
| hContext: SCARDCONTEXT, |
| mszGroups: LPCWSTR, |
| mszReaders: LPWSTR, |
| pcchReaders: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListCardsA( |
| hContext: SCARDCONTEXT, |
| pbAtr: LPCBYTE, |
| rgquidInterfaces: LPCGUID, |
| cguidInterfaceCount: DWORD, |
| mszCards: *mut CHAR, |
| pcchCards: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListCardsW( |
| hContext: SCARDCONTEXT, |
| pbAtr: LPCBYTE, |
| rgquidInterfaces: LPCGUID, |
| cguidInterfaceCount: DWORD, |
| mszCards: *mut WCHAR, |
| pcchCards: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListInterfacesA( |
| hContext: SCARDCONTEXT, |
| szCard: LPCSTR, |
| pguidInterfaces: LPGUID, |
| pcguidInterfaces: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListInterfacesW( |
| hContext: SCARDCONTEXT, |
| szCard: LPCWSTR, |
| pguidInterfaces: LPGUID, |
| pcguidInterfaces: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetProviderIdA( |
| hContext: SCARDCONTEXT, |
| szCard: LPCSTR, |
| pguidProviderId: LPGUID, |
| ) -> LONG; |
| pub fn SCardGetProviderIdW( |
| hContext: SCARDCONTEXT, |
| szCard: LPCWSTR, |
| pguidProviderId: LPGUID, |
| ) -> LONG; |
| pub fn SCardGetCardTypeProviderNameA( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCSTR, |
| dwProviderId: DWORD, |
| szProvider: *mut CHAR, |
| pcchProvider: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetCardTypeProviderNameW( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCWSTR, |
| dwProviderId: DWORD, |
| szProvider: *mut WCHAR, |
| pcchProvider: LPDWORD, |
| ) -> LONG; |
| pub fn SCardIntroduceReaderGroupA( |
| hContext: SCARDCONTEXT, |
| szGroupName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardIntroduceReaderGroupW( |
| hContext: SCARDCONTEXT, |
| szGroupName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardForgetReaderGroupA( |
| hContext: SCARDCONTEXT, |
| szGroupName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardForgetReaderGroupW( |
| hContext: SCARDCONTEXT, |
| szGroupName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardIntroduceReaderA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| szDeviceName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardIntroduceReaderW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| szDeviceName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardForgetReaderA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardForgetReaderW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardAddReaderToGroupA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| szGroupName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardAddReaderToGroupW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| szGroupName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardRemoveReaderFromGroupA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| szGroupName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardRemoveReaderFromGroupW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| szGroupName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardIntroduceCardTypeA( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCSTR, |
| pguidPrimaryProvider: LPCGUID, |
| rgguidInterfaces: LPCGUID, |
| dwInterfaceCount: DWORD, |
| pbAtr: LPCBYTE, |
| pbAtrMask: LPCBYTE, |
| cbAtrLen: DWORD, |
| ) -> LONG; |
| pub fn SCardIntroduceCardTypeW( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCWSTR, |
| pguidPrimaryProvider: LPCGUID, |
| rgguidInterfaces: LPCGUID, |
| dwInterfaceCount: DWORD, |
| pbAtr: LPCBYTE, |
| pbAtrMask: LPCBYTE, |
| cbAtrLen: DWORD, |
| ) -> LONG; |
| pub fn SCardSetCardTypeProviderNameA( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCSTR, |
| dwProviderId: DWORD, |
| szProvider: LPCSTR, |
| ) -> LONG; |
| pub fn SCardSetCardTypeProviderNameW( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCWSTR, |
| dwProviderId: DWORD, |
| szProvider: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardForgetCardTypeA( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCSTR, |
| ) -> LONG; |
| pub fn SCardForgetCardTypeW( |
| hContext: SCARDCONTEXT, |
| szCardName: LPCWSTR, |
| ) -> LONG; |
| pub fn SCardFreeMemory( |
| hContext: SCARDCONTEXT, |
| pvMem: LPCVOID, |
| ) -> LONG; |
| pub fn SCardAccessStartedEvent() -> HANDLE; |
| pub fn SCardReleaseStartedEvent(); |
| } |
| STRUCT!{struct SCARD_READERSTATEA { |
| szReader: LPCSTR, |
| pvUserData: LPVOID, |
| dwCurrentState: DWORD, |
| dwEventState: DWORD, |
| cbAtr: DWORD, |
| rgbAtr: [BYTE; 36], |
| }} |
| pub type PSCARD_READERSTATEA = *mut SCARD_READERSTATEA; |
| pub type LPSCARD_READERSTATEA = *mut SCARD_READERSTATEA; |
| STRUCT!{struct SCARD_READERSTATEW { |
| szReader: LPCWSTR, |
| pvUserData: LPVOID, |
| dwCurrentState: DWORD, |
| dwEventState: DWORD, |
| cbAtr: DWORD, |
| rgbAtr: [BYTE; 36], |
| }} |
| pub type PSCARD_READERSTATEW = *mut SCARD_READERSTATEW; |
| pub type LPSCARD_READERSTATEW = *mut SCARD_READERSTATEW; |
| pub type SCARD_READERSTATE_A = SCARD_READERSTATEA; |
| pub type SCARD_READERSTATE_W = SCARD_READERSTATEW; |
| pub type PSCARD_READERSTATE_A = PSCARD_READERSTATEA; |
| pub type PSCARD_READERSTATE_W = PSCARD_READERSTATEW; |
| pub type LPSCARD_READERSTATE_A = LPSCARD_READERSTATEA; |
| pub type LPSCARD_READERSTATE_W = LPSCARD_READERSTATEW; |
| pub const SCARD_STATE_UNAWARE: DWORD = 0x00000000; |
| pub const SCARD_STATE_IGNORE: DWORD = 0x00000001; |
| pub const SCARD_STATE_CHANGED: DWORD = 0x00000002; |
| pub const SCARD_STATE_UNKNOWN: DWORD = 0x00000004; |
| pub const SCARD_STATE_UNAVAILABLE: DWORD = 0x00000008; |
| pub const SCARD_STATE_EMPTY: DWORD = 0x00000010; |
| pub const SCARD_STATE_PRESENT: DWORD = 0x00000020; |
| pub const SCARD_STATE_ATRMATCH: DWORD = 0x00000040; |
| pub const SCARD_STATE_EXCLUSIVE: DWORD = 0x00000080; |
| pub const SCARD_STATE_INUSE: DWORD = 0x00000100; |
| pub const SCARD_STATE_MUTE: DWORD = 0x00000200; |
| pub const SCARD_STATE_UNPOWERED: DWORD = 0x00000400; |
| extern "system" { |
| pub fn SCardLocateCardsA( |
| hContext: SCARDCONTEXT, |
| mszCards: LPCSTR, |
| rgReaderStates: LPSCARD_READERSTATEA, |
| cReaders: DWORD, |
| ) -> LONG; |
| pub fn SCardLocateCardsW( |
| hContext: SCARDCONTEXT, |
| mszCards: LPCWSTR, |
| rgReaderStates: LPSCARD_READERSTATEW, |
| cReaders: DWORD, |
| ) -> LONG; |
| } |
| STRUCT!{struct SCARD_ATRMASK { |
| cbAtr: DWORD, |
| rgbAtr: [BYTE; 36], |
| rgbMask: [BYTE; 36], |
| }} |
| pub type PSCARD_ATRMASK = *mut SCARD_ATRMASK; |
| pub type LPSCARD_ATRMASK = *mut SCARD_ATRMASK; |
| extern "system" { |
| pub fn SCardLocateCardsByATRA( |
| hContext: SCARDCONTEXT, |
| rgAtrMasks: LPSCARD_ATRMASK, |
| cAtrs: DWORD, |
| rgReaderStates: LPSCARD_READERSTATEA, |
| cReaders: DWORD, |
| ) -> LONG; |
| pub fn SCardLocateCardsByATRW( |
| hContext: SCARDCONTEXT, |
| rgAtrMasks: LPSCARD_ATRMASK, |
| cAtrs: DWORD, |
| rgReaderStates: LPSCARD_READERSTATEW, |
| cReaders: DWORD, |
| ) -> LONG; |
| pub fn SCardGetStatusChangeA( |
| hContext: SCARDCONTEXT, |
| dwTimeout: DWORD, |
| rgReaderStates: LPSCARD_READERSTATEA, |
| cReaders: DWORD, |
| ) -> LONG; |
| pub fn SCardGetStatusChangeW( |
| hContext: SCARDCONTEXT, |
| dwTimeout: DWORD, |
| rgReaderStates: LPSCARD_READERSTATEW, |
| cReaders: DWORD, |
| ) -> LONG; |
| pub fn SCardCancel( |
| hContext: SCARDCONTEXT, |
| ) -> LONG; |
| } |
| pub const SCARD_SHARE_EXCLUSIVE: DWORD = 1; |
| pub const SCARD_SHARE_SHARED: DWORD = 2; |
| pub const SCARD_SHARE_DIRECT: DWORD = 3; |
| pub const SCARD_LEAVE_CARD: DWORD = 0; |
| pub const SCARD_RESET_CARD: DWORD = 1; |
| pub const SCARD_UNPOWER_CARD: DWORD = 2; |
| pub const SCARD_EJECT_CARD: DWORD = 3; |
| extern "system" { |
| pub fn SCardConnectA( |
| hContext: SCARDCONTEXT, |
| szReader: LPCSTR, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| phCard: LPSCARDHANDLE, |
| pdwActiveProtocol: LPDWORD, |
| ) -> LONG; |
| pub fn SCardConnectW( |
| hContext: SCARDCONTEXT, |
| szReader: LPCWSTR, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| phCard: LPSCARDHANDLE, |
| pdwActiveProtocol: LPDWORD, |
| ) -> LONG; |
| pub fn SCardReconnect( |
| hCard: SCARDHANDLE, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| dwInitialization: DWORD, |
| pdwActiveProtocol: LPDWORD, |
| ) -> LONG; |
| pub fn SCardDisconnect( |
| hCard: SCARDHANDLE, |
| dwDisposition: DWORD, |
| ) -> LONG; |
| pub fn SCardBeginTransaction( |
| hCard: SCARDHANDLE, |
| ) -> LONG; |
| pub fn SCardEndTransaction( |
| hCard: SCARDHANDLE, |
| dwDisposition: DWORD, |
| ) -> LONG; |
| pub fn SCardState( |
| hCard: SCARDHANDLE, |
| pdwState: LPDWORD, |
| pdwProtocol: LPDWORD, |
| pbAtr: LPBYTE, |
| pcbAtrLen: LPDWORD, |
| ) -> LONG; |
| pub fn SCardStatusA( |
| hCard: SCARDHANDLE, |
| mszReaderNames: LPSTR, |
| pcchReaderLen: LPDWORD, |
| pdwState: LPDWORD, |
| pdwProtocol: LPDWORD, |
| pbAtr: LPBYTE, |
| pcbAtrLen: LPDWORD, |
| ) -> LONG; |
| pub fn SCardStatusW( |
| hCard: SCARDHANDLE, |
| mszReaderNames: LPWSTR, |
| pcchReaderLen: LPDWORD, |
| pdwState: LPDWORD, |
| pdwProtocol: LPDWORD, |
| pbAtr: LPBYTE, |
| pcbAtrLen: LPDWORD, |
| ) -> LONG; |
| pub fn SCardTransmit( |
| hCard: SCARDHANDLE, |
| pioSendPci: LPCSCARD_IO_REQUEST, |
| pbSendBuffer: LPCBYTE, |
| cbSendLength: DWORD, |
| pioRecvPci: LPSCARD_IO_REQUEST, |
| pbRecvBuffer: LPBYTE, |
| pcbRecvLength: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetTransmitCount( |
| hCard: SCARDHANDLE, |
| pcTransmitCount: LPDWORD, |
| ) -> LONG; |
| pub fn SCardControl( |
| hCard: SCARDHANDLE, |
| dwControlCode: DWORD, |
| lpInBuffer: LPCVOID, |
| cbInBufferSize: DWORD, |
| lpOutBuffer: LPVOID, |
| cbOutBufferSize: DWORD, |
| lpBytesReturned: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetAttrib( |
| hCard: SCARDHANDLE, |
| dwAttrId: DWORD, |
| pbAttr: LPBYTE, |
| pcbAttrLen: LPDWORD, |
| ) -> LONG; |
| pub fn SCardSetAttrib( |
| hCard: SCARDHANDLE, |
| dwAttrId: DWORD, |
| pbAttr: LPCBYTE, |
| cbAttrLen: DWORD, |
| ) -> LONG; |
| } |
| pub const SC_DLG_MINIMAL_UI: DWORD = 0x01; |
| pub const SC_DLG_NO_UI: DWORD = 0x02; |
| pub const SC_DLG_FORCE_UI: DWORD = 0x04; |
| pub const SCERR_NOCARDNAME: DWORD = 0x4000; |
| pub const SCERR_NOGUIDS: DWORD = 0x8000; |
| FN!{stdcall LPOCNCONNPROCA( |
| SCARDCONTEXT, |
| LPSTR, |
| LPSTR, |
| PVOID, |
| ) -> SCARDHANDLE} |
| FN!{stdcall LPOCNCONNPROCW( |
| SCARDCONTEXT, |
| LPWSTR, |
| LPWSTR, |
| PVOID, |
| ) -> SCARDHANDLE} |
| FN!{stdcall LPOCNCHKPROC( |
| SCARDCONTEXT, |
| SCARDHANDLE, |
| PVOID, |
| ) -> BOOL} |
| FN!{stdcall LPOCNDSCPROC( |
| SCARDCONTEXT, |
| SCARDHANDLE, |
| PVOID, |
| ) -> ()} |
| STRUCT!{struct OPENCARD_SEARCH_CRITERIAA { |
| dwStructSize: DWORD, |
| lpstrGroupNames: LPSTR, |
| nMaxGroupNames: DWORD, |
| rgguidInterfaces: LPCGUID, |
| cguidInterfaces: DWORD, |
| lpstrCardNames: LPSTR, |
| nMaxCardNames: DWORD, |
| lpfnCheck: LPOCNCHKPROC, |
| lpfnConnect: LPOCNCONNPROCA, |
| lpfnDisconnect: LPOCNDSCPROC, |
| pvUserData: LPVOID, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| }} |
| pub type POPENCARD_SEARCH_CRITERIAA = *mut OPENCARD_SEARCH_CRITERIAA; |
| pub type LPOPENCARD_SEARCH_CRITERIAA = *mut OPENCARD_SEARCH_CRITERIAA; |
| STRUCT!{struct OPENCARD_SEARCH_CRITERIAW { |
| dwStructSize: DWORD, |
| lpstrGroupNames: LPWSTR, |
| nMaxGroupNames: DWORD, |
| rgguidInterfaces: LPCGUID, |
| cguidInterfaces: DWORD, |
| lpstrCardNames: LPWSTR, |
| nMaxCardNames: DWORD, |
| lpfnCheck: LPOCNCHKPROC, |
| lpfnConnect: LPOCNCONNPROCW, |
| lpfnDisconnect: LPOCNDSCPROC, |
| pvUserData: LPVOID, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| }} |
| pub type POPENCARD_SEARCH_CRITERIAW = *mut OPENCARD_SEARCH_CRITERIAW; |
| pub type LPOPENCARD_SEARCH_CRITERIAW = *mut OPENCARD_SEARCH_CRITERIAW; |
| STRUCT!{struct OPENCARDNAME_EXA { |
| dwStructSize: DWORD, |
| hSCardContext: SCARDCONTEXT, |
| hwndOwner: HWND, |
| dwFlags: DWORD, |
| lpstrTitle: LPCSTR, |
| lpstrSearchDesc: LPCSTR, |
| hIcon: HICON, |
| pOpenCardSearchCriteria: POPENCARD_SEARCH_CRITERIAA, |
| lpfnConnect: LPOCNCONNPROCA, |
| pvUserData: LPVOID, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| lpstrRdr: LPSTR, |
| nMaxRdr: DWORD, |
| lpstrCard: LPSTR, |
| nMaxCard: DWORD, |
| dwActiveProtocol: DWORD, |
| hCardHandle: SCARDHANDLE, |
| }} |
| pub type POPENCARDNAME_EXA = *mut OPENCARDNAME_EXA; |
| pub type LPOPENCARDNAME_EXA = *mut OPENCARDNAME_EXA; |
| STRUCT!{struct OPENCARDNAME_EXW { |
| dwStructSize: DWORD, |
| hSCardContext: SCARDCONTEXT, |
| hwndOwner: HWND, |
| dwFlags: DWORD, |
| lpstrTitle: LPCWSTR, |
| lpstrSearchDesc: LPCWSTR, |
| hIcon: HICON, |
| pOpenCardSearchCriteria: POPENCARD_SEARCH_CRITERIAW, |
| lpfnConnect: LPOCNCONNPROCW, |
| pvUserData: LPVOID, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| lpstrRdr: LPWSTR, |
| nMaxRdr: DWORD, |
| lpstrCard: LPWSTR, |
| nMaxCard: DWORD, |
| dwActiveProtocol: DWORD, |
| hCardHandle: SCARDHANDLE, |
| }} |
| pub type POPENCARDNAME_EXW = *mut OPENCARDNAME_EXW; |
| pub type LPOPENCARDNAME_EXW = *mut OPENCARDNAME_EXW; |
| pub type OPENCARDNAMEA_EX = OPENCARDNAME_EXA; |
| pub type OPENCARDNAMEW_EX = OPENCARDNAME_EXW; |
| pub type POPENCARDNAMEA_EX = POPENCARDNAME_EXA; |
| pub type POPENCARDNAMEW_EX = POPENCARDNAME_EXW; |
| pub type LPOPENCARDNAMEA_EX = LPOPENCARDNAME_EXA; |
| pub type LPOPENCARDNAMEW_EX = LPOPENCARDNAME_EXW; |
| pub const SCARD_READER_SEL_AUTH_PACKAGE: DWORD = -629i32 as u32; |
| ENUM!{enum READER_SEL_REQUEST_MATCH_TYPE { |
| RSR_MATCH_TYPE_READER_AND_CONTAINER = 1, |
| RSR_MATCH_TYPE_SERIAL_NUMBER, |
| RSR_MATCH_TYPE_ALL_CARDS, |
| }} |
| STRUCT!{struct READER_SEL_REQUEST_ReaderAndContainerParameter { |
| cbReaderNameOffset: DWORD, |
| cchReaderNameLength: DWORD, |
| cbContainerNameOffset: DWORD, |
| cchContainerNameLength: DWORD, |
| dwDesiredCardModuleVersion: DWORD, |
| dwCspFlags: DWORD, |
| }} |
| STRUCT!{struct READER_SEL_REQUEST_SerialNumberParameter { |
| cbSerialNumberOffset: DWORD, |
| cbSerialNumberLength: DWORD, |
| dwDesiredCardModuleVersion: DWORD, |
| }} |
| UNION!{union READER_SEL_REQUEST_u { |
| [u32; 6], |
| ReaderAndContainerParameter ReaderAndContainerParameter_mut: |
| READER_SEL_REQUEST_ReaderAndContainerParameter, |
| SerialNumberParameter SerialNumberParameter_mut: READER_SEL_REQUEST_SerialNumberParameter, |
| }} |
| STRUCT!{struct READER_SEL_REQUEST { |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| MatchType: READER_SEL_REQUEST_MATCH_TYPE, |
| u: READER_SEL_REQUEST_u, |
| }} |
| pub type PREADER_SEL_REQUEST = *mut READER_SEL_REQUEST; |
| STRUCT!{struct READER_SEL_RESPONSE { |
| cbReaderNameOffset: DWORD, |
| cchReaderNameLength: DWORD, |
| cbCardNameOffset: DWORD, |
| cchCardNameLength: DWORD, |
| }} |
| pub type PREADER_SEL_RESPONSE = *mut READER_SEL_RESPONSE; |
| STRUCT!{struct OPENCARDNAMEA { |
| dwStructSize: DWORD, |
| hwndOwner: HWND, |
| hSCardContext: SCARDCONTEXT, |
| lpstrGroupNames: LPSTR, |
| nMaxGroupNames: DWORD, |
| lpstrCardNames: LPSTR, |
| nMaxCardNames: DWORD, |
| rgguidInterfaces: LPCGUID, |
| cguidInterfaces: DWORD, |
| lpstrRdr: LPSTR, |
| nMaxRdr: DWORD, |
| lpstrCard: LPSTR, |
| nMaxCard: DWORD, |
| lpstrTitle: LPCSTR, |
| dwFlags: DWORD, |
| pvUserData: LPVOID, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| dwActiveProtocol: DWORD, |
| lpfnConnect: LPOCNCONNPROCA, |
| lpfnCheck: LPOCNCHKPROC, |
| lpfnDisconnect: LPOCNDSCPROC, |
| hCardHandle: SCARDHANDLE, |
| }} |
| pub type POPENCARDNAMEA = *mut OPENCARDNAMEA; |
| pub type LPOPENCARDNAMEA = *mut OPENCARDNAMEA; |
| STRUCT!{struct OPENCARDNAMEW { |
| dwStructSize: DWORD, |
| hwndOwner: HWND, |
| hSCardContext: SCARDCONTEXT, |
| lpstrGroupNames: LPWSTR, |
| nMaxGroupNames: DWORD, |
| lpstrCardNames: LPWSTR, |
| nMaxCardNames: DWORD, |
| rgguidInterfaces: LPCGUID, |
| cguidInterfaces: DWORD, |
| lpstrRdr: LPWSTR, |
| nMaxRdr: DWORD, |
| lpstrCard: LPWSTR, |
| nMaxCard: DWORD, |
| lpstrTitle: LPCWSTR, |
| dwFlags: DWORD, |
| pvUserData: LPVOID, |
| dwShareMode: DWORD, |
| dwPreferredProtocols: DWORD, |
| dwActiveProtocol: DWORD, |
| lpfnConnect: LPOCNCONNPROCW, |
| lpfnCheck: LPOCNCHKPROC, |
| lpfnDisconnect: LPOCNDSCPROC, |
| hCardHandle: SCARDHANDLE, |
| }} |
| pub type POPENCARDNAMEW = *mut OPENCARDNAMEW; |
| pub type LPOPENCARDNAMEW = *mut OPENCARDNAMEW; |
| pub type OPENCARDNAME_A = OPENCARDNAMEA; |
| pub type OPENCARDNAME_W = OPENCARDNAMEW; |
| pub type POPENCARDNAME_A = POPENCARDNAMEA; |
| pub type POPENCARDNAME_W = POPENCARDNAMEW; |
| pub type LPOPENCARDNAME_A = LPOPENCARDNAMEA; |
| pub type LPOPENCARDNAME_W = LPOPENCARDNAMEW; |
| extern "system" { |
| pub fn SCardReadCacheA( |
| hContext: SCARDCONTEXT, |
| CardIdentifier: *mut UUID, |
| FreshnessCounter: DWORD, |
| LookupName: LPSTR, |
| Data: PBYTE, |
| DataLen: *mut DWORD, |
| ) -> LONG; |
| pub fn SCardReadCacheW( |
| hContext: SCARDCONTEXT, |
| CardIdentifier: *mut UUID, |
| FreshnessCounter: DWORD, |
| LookupName: LPWSTR, |
| Data: PBYTE, |
| DataLen: *mut DWORD, |
| ) -> LONG; |
| pub fn SCardWriteCacheA( |
| hContext: SCARDCONTEXT, |
| CardIdentifier: *mut UUID, |
| FreshnessCounter: DWORD, |
| LookupName: LPSTR, |
| Data: PBYTE, |
| DataLen: DWORD, |
| ) -> LONG; |
| pub fn SCardWriteCacheW( |
| hContext: SCARDCONTEXT, |
| CardIdentifier: *mut UUID, |
| FreshnessCounter: DWORD, |
| LookupName: LPWSTR, |
| Data: PBYTE, |
| DataLen: DWORD, |
| ) -> LONG; |
| pub fn SCardGetReaderIconA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| pbIcon: LPBYTE, |
| pcbIcon: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetReaderIconW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| pbIcon: LPBYTE, |
| pcbIcon: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetDeviceTypeIdA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| pdwDeviceTypeId: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetDeviceTypeIdW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| pdwDeviceTypeId: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetReaderDeviceInstanceIdA( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCSTR, |
| szDeviceInstanceId: LPSTR, |
| pcchDeviceInstanceId: LPDWORD, |
| ) -> LONG; |
| pub fn SCardGetReaderDeviceInstanceIdW( |
| hContext: SCARDCONTEXT, |
| szReaderName: LPCWSTR, |
| szDeviceInstanceId: LPWSTR, |
| pcchDeviceInstanceId: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListReadersWithDeviceInstanceIdA( |
| hContext: SCARDCONTEXT, |
| szDeviceInstanceId: LPCSTR, |
| mszReaders: LPSTR, |
| pcchReaders: LPDWORD, |
| ) -> LONG; |
| pub fn SCardListReadersWithDeviceInstanceIdW( |
| hContext: SCARDCONTEXT, |
| szDeviceInstanceId: LPCWSTR, |
| mszReaders: LPWSTR, |
| pcchReaders: LPDWORD, |
| ) -> LONG; |
| } |
| pub const SCARD_AUDIT_CHV_FAILURE: DWORD = 0x0; |
| pub const SCARD_AUDIT_CHV_SUCCESS: DWORD = 0x1; |
| extern "system" { |
| pub fn SCardAudit( |
| hContext: SCARDCONTEXT, |
| dwEvent: DWORD, |
| ) -> LONG; |
| } |
