/**
 * WinPR: Windows Portable Runtime
 * Smart Card API
 *
 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 * Copyright 2020 Armin Novak <armin.novak@thincast.com>
 * Copyright 2020 Thincast Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef WINPR_SMARTCARD_H
#define WINPR_SMARTCARD_H

#include <winpr/winpr.h>
#include <winpr/wtypes.h>

#include <winpr/io.h>
#include <winpr/error.h>

#ifndef _WINSCARD_H_
#define _WINSCARD_H_ /* do not include winscard.h */
#endif

#ifndef SCARD_S_SUCCESS

#define SCARD_S_SUCCESS NO_ERROR

#define SCARD_F_INTERNAL_ERROR (HRESULT)(0x80100001L)
#define SCARD_E_CANCELLED (HRESULT)(0x80100002L)
#define SCARD_E_INVALID_HANDLE (HRESULT)(0x80100003L)
#define SCARD_E_INVALID_PARAMETER (HRESULT)(0x80100004L)
#define SCARD_E_INVALID_TARGET (HRESULT)(0x80100005L)
#define SCARD_E_NO_MEMORY (HRESULT)(0x80100006L)
#define SCARD_F_WAITED_TOO_LONG (HRESULT)(0x80100007L)
#define SCARD_E_INSUFFICIENT_BUFFER (HRESULT)(0x80100008L)
#define SCARD_E_UNKNOWN_READER (HRESULT)(0x80100009L)
#define SCARD_E_TIMEOUT (HRESULT)(0x8010000AL)
#define SCARD_E_SHARING_VIOLATION (HRESULT)(0x8010000BL)
#define SCARD_E_NO_SMARTCARD (HRESULT)(0x8010000CL)
#define SCARD_E_UNKNOWN_CARD (HRESULT)(0x8010000DL)
#define SCARD_E_CANT_DISPOSE (HRESULT)(0x8010000EL)
#define SCARD_E_PROTO_MISMATCH (HRESULT)(0x8010000FL)
#define SCARD_E_NOT_READY (HRESULT)(0x80100010L)
#define SCARD_E_INVALID_VALUE (HRESULT)(0x80100011L)
#define SCARD_E_SYSTEM_CANCELLED (HRESULT)(0x80100012L)
#define SCARD_F_COMM_ERROR (HRESULT)(0x80100013L)
#define SCARD_F_UNKNOWN_ERROR (HRESULT)(0x80100014L)
#define SCARD_E_INVALID_ATR (HRESULT)(0x80100015L)
#define SCARD_E_NOT_TRANSACTED (HRESULT)(0x80100016L)
#define SCARD_E_READER_UNAVAILABLE (HRESULT)(0x80100017L)
#define SCARD_P_SHUTDOWN (HRESULT)(0x80100018L)
#define SCARD_E_PCI_TOO_SMALL (HRESULT)(0x80100019L)
#define SCARD_E_READER_UNSUPPORTED (HRESULT)(0x8010001AL)
#define SCARD_E_DUPLICATE_READER (HRESULT)(0x8010001BL)
#define SCARD_E_CARD_UNSUPPORTED (HRESULT)(0x8010001CL)
#define SCARD_E_NO_SERVICE (HRESULT)(0x8010001DL)
#define SCARD_E_SERVICE_STOPPED (HRESULT)(0x8010001EL)
#define SCARD_E_UNEXPECTED (HRESULT)(0x8010001FL)
#define SCARD_E_ICC_INSTALLATION (HRESULT)(0x80100020L)
#define SCARD_E_ICC_CREATEORDER (HRESULT)(0x80100021L)
#define SCARD_E_UNSUPPORTED_FEATURE (HRESULT)(0x80100022L)
#define SCARD_E_DIR_NOT_FOUND (HRESULT)(0x80100023L)
#define SCARD_E_FILE_NOT_FOUND (HRESULT)(0x80100024L)
#define SCARD_E_NO_DIR (HRESULT)(0x80100025L)
#define SCARD_E_NO_FILE (HRESULT)(0x80100026L)
#define SCARD_E_NO_ACCESS (HRESULT)(0x80100027L)
#define SCARD_E_WRITE_TOO_MANY (HRESULT)(0x80100028L)
#define SCARD_E_BAD_SEEK (HRESULT)(0x80100029L)
#define SCARD_E_INVALID_CHV (HRESULT)(0x8010002AL)
#define SCARD_E_UNKNOWN_RES_MNG (HRESULT)(0x8010002BL)
#define SCARD_E_NO_SUCH_CERTIFICATE (HRESULT)(0x8010002CL)
#define SCARD_E_CERTIFICATE_UNAVAILABLE (HRESULT)(0x8010002DL)
#define SCARD_E_NO_READERS_AVAILABLE (HRESULT)(0x8010002EL)
#define SCARD_E_COMM_DATA_LOST (HRESULT)(0x8010002FL)
#define SCARD_E_NO_KEY_CONTAINER (HRESULT)(0x80100030L)
#define SCARD_E_SERVER_TOO_BUSY (HRESULT)(0x80100031L)
#define SCARD_E_PIN_CACHE_EXPIRED (HRESULT)(0x80100032L)
#define SCARD_E_NO_PIN_CACHE (HRESULT)(0x80100033L)
#define SCARD_E_READ_ONLY_CARD (HRESULT)(0x80100034L)

#define SCARD_W_UNSUPPORTED_CARD (HRESULT)(0x80100065L)
#define SCARD_W_UNRESPONSIVE_CARD (HRESULT)(0x80100066L)
#define SCARD_W_UNPOWERED_CARD (HRESULT)(0x80100067L)
#define SCARD_W_RESET_CARD (HRESULT)(0x80100068L)
#define SCARD_W_REMOVED_CARD (HRESULT)(0x80100069L)
#define SCARD_W_SECURITY_VIOLATION (HRESULT)(0x8010006AL)
#define SCARD_W_WRONG_CHV (HRESULT)(0x8010006BL)
#define SCARD_W_CHV_BLOCKED (HRESULT)(0x8010006CL)
#define SCARD_W_EOF (HRESULT)(0x8010006DL)
#define SCARD_W_CANCELLED_BY_USER (HRESULT)(0x8010006EL)
#define SCARD_W_CARD_NOT_AUTHENTICATED (HRESULT)(0x8010006FL)
#define SCARD_W_CACHE_ITEM_NOT_FOUND (HRESULT)(0x80100070L)
#define SCARD_W_CACHE_ITEM_STALE (HRESULT)(0x80100071L)
#define SCARD_W_CACHE_ITEM_TOO_BIG (HRESULT)(0x80100072L)

#endif

#define SCARD_ATR_LENGTH 33

#define SCARD_PROTOCOL_UNDEFINED 0x00000000u
#define SCARD_PROTOCOL_T0 0x00000001u
#define SCARD_PROTOCOL_T1 0x00000002u
#define SCARD_PROTOCOL_RAW 0x00010000u

#define SCARD_PROTOCOL_Tx (SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1)
#define SCARD_PROTOCOL_DEFAULT 0x80000000u
#define SCARD_PROTOCOL_OPTIMAL 0x00000000u

#define SCARD_POWER_DOWN 0
#define SCARD_COLD_RESET 1
#define SCARD_WARM_RESET 2

#define SCARD_CTL_CODE(code) \
	CTL_CODE(FILE_DEVICE_SMARTCARD, (code), METHOD_BUFFERED, FILE_ANY_ACCESS)

#define IOCTL_SMARTCARD_POWER SCARD_CTL_CODE(1)
#define IOCTL_SMARTCARD_GET_ATTRIBUTE SCARD_CTL_CODE(2)
#define IOCTL_SMARTCARD_SET_ATTRIBUTE SCARD_CTL_CODE(3)
#define IOCTL_SMARTCARD_CONFISCATE SCARD_CTL_CODE(4)
#define IOCTL_SMARTCARD_TRANSMIT SCARD_CTL_CODE(5)
#define IOCTL_SMARTCARD_EJECT SCARD_CTL_CODE(6)
#define IOCTL_SMARTCARD_SWALLOW SCARD_CTL_CODE(7)
#define IOCTL_SMARTCARD_IS_PRESENT SCARD_CTL_CODE(10)
#define IOCTL_SMARTCARD_IS_ABSENT SCARD_CTL_CODE(11)
#define IOCTL_SMARTCARD_SET_PROTOCOL SCARD_CTL_CODE(12)
#define IOCTL_SMARTCARD_GET_STATE SCARD_CTL_CODE(14)
#define IOCTL_SMARTCARD_GET_LAST_ERROR SCARD_CTL_CODE(15)
#define IOCTL_SMARTCARD_GET_PERF_CNTR SCARD_CTL_CODE(16)

#define IOCTL_SMARTCARD_GET_FEATURE_REQUEST SCARD_CTL_CODE(3400)

#define MAXIMUM_ATTR_STRING_LENGTH 32
#define MAXIMUM_SMARTCARD_READERS 10

#define SCARD_ATTR_VALUE(Class, Tag) ((((ULONG)(Class)) << 16) | ((ULONG)(Tag)))

#define SCARD_CLASS_VENDOR_INFO 1
#define SCARD_CLASS_COMMUNICATIONS 2
#define SCARD_CLASS_PROTOCOL 3
#define SCARD_CLASS_POWER_MGMT 4
#define SCARD_CLASS_SECURITY 5
#define SCARD_CLASS_MECHANICAL 6
#define SCARD_CLASS_VENDOR_DEFINED 7
#define SCARD_CLASS_IFD_PROTOCOL 8
#define SCARD_CLASS_ICC_STATE 9
#define SCARD_CLASS_PERF 0x7FFE
#define SCARD_CLASS_SYSTEM 0x7FFF

#define SCARD_ATTR_VENDOR_NAME SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0100)
#define SCARD_ATTR_VENDOR_IFD_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0101)
#define SCARD_ATTR_VENDOR_IFD_VERSION SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0102)
#define SCARD_ATTR_VENDOR_IFD_SERIAL_NO SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_INFO, 0x0103)
#define SCARD_ATTR_CHANNEL_ID SCARD_ATTR_VALUE(SCARD_CLASS_COMMUNICATIONS, 0x0110)
#define SCARD_ATTR_PROTOCOL_TYPES SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0120)
#define SCARD_ATTR_DEFAULT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0121)
#define SCARD_ATTR_MAX_CLK SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0122)
#define SCARD_ATTR_DEFAULT_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0123)
#define SCARD_ATTR_MAX_DATA_RATE SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0124)
#define SCARD_ATTR_MAX_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_PROTOCOL, 0x0125)
#define SCARD_ATTR_POWER_MGMT_SUPPORT SCARD_ATTR_VALUE(SCARD_CLASS_POWER_MGMT, 0x0131)
#define SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0140)
#define SCARD_ATTR_USER_AUTH_INPUT_DEVICE SCARD_ATTR_VALUE(SCARD_CLASS_SECURITY, 0x0142)
#define SCARD_ATTR_CHARACTERISTICS SCARD_ATTR_VALUE(SCARD_CLASS_MECHANICAL, 0x0150)

#define SCARD_ATTR_CURRENT_PROTOCOL_TYPE SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0201)
#define SCARD_ATTR_CURRENT_CLK SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0202)
#define SCARD_ATTR_CURRENT_F SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0203)
#define SCARD_ATTR_CURRENT_D SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0204)
#define SCARD_ATTR_CURRENT_N SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0205)
#define SCARD_ATTR_CURRENT_W SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0206)
#define SCARD_ATTR_CURRENT_IFSC SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0207)
#define SCARD_ATTR_CURRENT_IFSD SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0208)
#define SCARD_ATTR_CURRENT_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x0209)
#define SCARD_ATTR_CURRENT_CWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020a)
#define SCARD_ATTR_CURRENT_EBC_ENCODING SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020b)
#define SCARD_ATTR_EXTENDED_BWT SCARD_ATTR_VALUE(SCARD_CLASS_IFD_PROTOCOL, 0x020c)

#define SCARD_ATTR_ICC_PRESENCE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0300)
#define SCARD_ATTR_ICC_INTERFACE_STATUS SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0301)
#define SCARD_ATTR_CURRENT_IO_STATE SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0302)
#define SCARD_ATTR_ATR_STRING SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0303)
#define SCARD_ATTR_ICC_TYPE_PER_ATR SCARD_ATTR_VALUE(SCARD_CLASS_ICC_STATE, 0x0304)

#define SCARD_ATTR_ESC_RESET SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA000)
#define SCARD_ATTR_ESC_CANCEL SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA003)
#define SCARD_ATTR_ESC_AUTHREQUEST SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA005)
#define SCARD_ATTR_MAXINPUT SCARD_ATTR_VALUE(SCARD_CLASS_VENDOR_DEFINED, 0xA007)

#define SCARD_ATTR_DEVICE_UNIT SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0001)
#define SCARD_ATTR_DEVICE_IN_USE SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0002)
#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0003)
#define SCARD_ATTR_DEVICE_SYSTEM_NAME_A SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0004)
#define SCARD_ATTR_DEVICE_FRIENDLY_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0005)
#define SCARD_ATTR_DEVICE_SYSTEM_NAME_W SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0006)
#define SCARD_ATTR_SUPRESS_T1_IFS_REQUEST SCARD_ATTR_VALUE(SCARD_CLASS_SYSTEM, 0x0007)

#define SCARD_PERF_NUM_TRANSMISSIONS SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0001)
#define SCARD_PERF_BYTES_TRANSMITTED SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0002)
#define SCARD_PERF_TRANSMISSION_TIME SCARD_ATTR_VALUE(SCARD_CLASS_PERF, 0x0003)

#ifdef UNICODE
#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_W
#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_W
#else
#define SCARD_ATTR_DEVICE_FRIENDLY_NAME SCARD_ATTR_DEVICE_FRIENDLY_NAME_A
#define SCARD_ATTR_DEVICE_SYSTEM_NAME SCARD_ATTR_DEVICE_SYSTEM_NAME_A
#endif

#define SCARD_T0_HEADER_LENGTH 7
#define SCARD_T0_CMD_LENGTH 5

#define SCARD_T1_PROLOGUE_LENGTH 3
#define SCARD_T1_EPILOGUE_LENGTH 2
#define SCARD_T1_MAX_IFS 254

#define SCARD_UNKNOWN 0
#define SCARD_ABSENT 1
#define SCARD_PRESENT 2
#define SCARD_SWALLOWED 3
#define SCARD_POWERED 4
#define SCARD_NEGOTIABLE 5
#define SCARD_SPECIFIC 6

#pragma pack(push, 1)

typedef struct _SCARD_IO_REQUEST
{
	DWORD dwProtocol;
	DWORD cbPciLength;
} SCARD_IO_REQUEST, *PSCARD_IO_REQUEST, *LPSCARD_IO_REQUEST;
typedef const SCARD_IO_REQUEST* LPCSCARD_IO_REQUEST;

typedef struct
{
	BYTE bCla, bIns, bP1, bP2, bP3;
} SCARD_T0_COMMAND, *LPSCARD_T0_COMMAND;

typedef struct
{
	SCARD_IO_REQUEST ioRequest;
	BYTE bSw1, bSw2;
	union {
		SCARD_T0_COMMAND CmdBytes;
		BYTE rgbHeader[5];
	} DUMMYUNIONNAME;
} SCARD_T0_REQUEST;

typedef SCARD_T0_REQUEST *PSCARD_T0_REQUEST, *LPSCARD_T0_REQUEST;

typedef struct
{
	SCARD_IO_REQUEST ioRequest;
} SCARD_T1_REQUEST;
typedef SCARD_T1_REQUEST *PSCARD_T1_REQUEST, *LPSCARD_T1_REQUEST;

#define SCARD_READER_SWALLOWS 0x00000001
#define SCARD_READER_EJECTS 0x00000002
#define SCARD_READER_CONFISCATES 0x00000004

#define SCARD_READER_TYPE_SERIAL 0x01
#define SCARD_READER_TYPE_PARALELL 0x02
#define SCARD_READER_TYPE_KEYBOARD 0x04
#define SCARD_READER_TYPE_SCSI 0x08
#define SCARD_READER_TYPE_IDE 0x10
#define SCARD_READER_TYPE_USB 0x20
#define SCARD_READER_TYPE_PCMCIA 0x40
#define SCARD_READER_TYPE_TPM 0x80
#define SCARD_READER_TYPE_NFC 0x100
#define SCARD_READER_TYPE_UICC 0x200
#define SCARD_READER_TYPE_VENDOR 0xF0

#ifndef WINSCARDAPI
#define WINSCARDAPI WINPR_API
#endif

typedef ULONG_PTR SCARDCONTEXT;
typedef SCARDCONTEXT *PSCARDCONTEXT, *LPSCARDCONTEXT;

typedef ULONG_PTR SCARDHANDLE;
typedef SCARDHANDLE *PSCARDHANDLE, *LPSCARDHANDLE;

#define SCARD_AUTOALLOCATE (DWORD)(-1)

#define SCARD_SCOPE_USER 0
#define SCARD_SCOPE_TERMINAL 1
#define SCARD_SCOPE_SYSTEM 2

#define SCARD_STATE_UNAWARE 0x00000000
#define SCARD_STATE_IGNORE 0x00000001
#define SCARD_STATE_CHANGED 0x00000002
#define SCARD_STATE_UNKNOWN 0x00000004
#define SCARD_STATE_UNAVAILABLE 0x00000008
#define SCARD_STATE_EMPTY 0x00000010
#define SCARD_STATE_PRESENT 0x00000020
#define SCARD_STATE_ATRMATCH 0x00000040
#define SCARD_STATE_EXCLUSIVE 0x00000080
#define SCARD_STATE_INUSE 0x00000100
#define SCARD_STATE_MUTE 0x00000200
#define SCARD_STATE_UNPOWERED 0x00000400

#define SCARD_SHARE_EXCLUSIVE 1
#define SCARD_SHARE_SHARED 2
#define SCARD_SHARE_DIRECT 3

#define SCARD_LEAVE_CARD 0
#define SCARD_RESET_CARD 1
#define SCARD_UNPOWER_CARD 2
#define SCARD_EJECT_CARD 3

#define SC_DLG_MINIMAL_UI 0x01
#define SC_DLG_NO_UI 0x02
#define SC_DLG_FORCE_UI 0x04

#define SCERR_NOCARDNAME 0x4000
#define SCERR_NOGUIDS 0x8000

typedef SCARDHANDLE(WINAPI* LPOCNCONNPROCA)(SCARDCONTEXT hSCardContext, LPSTR szReader,
                                            LPSTR mszCards, PVOID pvUserData);
typedef SCARDHANDLE(WINAPI* LPOCNCONNPROCW)(SCARDCONTEXT hSCardContext, LPWSTR szReader,
                                            LPWSTR mszCards, PVOID pvUserData);

typedef BOOL(WINAPI* LPOCNCHKPROC)(SCARDCONTEXT hSCardContext, SCARDHANDLE hCard, PVOID pvUserData);
typedef void(WINAPI* LPOCNDSCPROC)(SCARDCONTEXT hSCardContext, SCARDHANDLE hCard, PVOID pvUserData);

#define SCARD_READER_SEL_AUTH_PACKAGE ((DWORD)-629)

#define SCARD_AUDIT_CHV_FAILURE 0x0
#define SCARD_AUDIT_CHV_SUCCESS 0x1

#define SCardListCardTypes SCardListCards

#define PCSCardIntroduceCardType(hContext, szCardName, pbAtr, pbAtrMask, cbAtrLen,         \
                                 pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount) \
	SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces,   \
	                       dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen)

#define SCardGetReaderCapabilities SCardGetAttrib
#define SCardSetReaderCapabilities SCardSetAttrib

typedef struct
{
	LPSTR szReader;
	LPVOID pvUserData;
	DWORD dwCurrentState;
	DWORD dwEventState;
	DWORD cbAtr;
	BYTE rgbAtr[36];
} SCARD_READERSTATEA, *PSCARD_READERSTATEA, *LPSCARD_READERSTATEA;

typedef struct
{
	LPWSTR szReader;
	LPVOID pvUserData;
	DWORD dwCurrentState;
	DWORD dwEventState;
	DWORD cbAtr;
	BYTE rgbAtr[36];
} SCARD_READERSTATEW, *PSCARD_READERSTATEW, *LPSCARD_READERSTATEW;

typedef struct _SCARD_ATRMASK
{
	DWORD cbAtr;
	BYTE rgbAtr[36];
	BYTE rgbMask[36];
} SCARD_ATRMASK, *PSCARD_ATRMASK, *LPSCARD_ATRMASK;

typedef struct
{
	DWORD dwStructSize;
	LPSTR lpstrGroupNames;
	DWORD nMaxGroupNames;
	LPCGUID rgguidInterfaces;
	DWORD cguidInterfaces;
	LPSTR lpstrCardNames;
	DWORD nMaxCardNames;
	LPOCNCHKPROC lpfnCheck;
	LPOCNCONNPROCA lpfnConnect;
	LPOCNDSCPROC lpfnDisconnect;
	LPVOID pvUserData;
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
} OPENCARD_SEARCH_CRITERIAA, *POPENCARD_SEARCH_CRITERIAA, *LPOPENCARD_SEARCH_CRITERIAA;

typedef struct
{
	DWORD dwStructSize;
	LPWSTR lpstrGroupNames;
	DWORD nMaxGroupNames;
	LPCGUID rgguidInterfaces;
	DWORD cguidInterfaces;
	LPWSTR lpstrCardNames;
	DWORD nMaxCardNames;
	LPOCNCHKPROC lpfnCheck;
	LPOCNCONNPROCW lpfnConnect;
	LPOCNDSCPROC lpfnDisconnect;
	LPVOID pvUserData;
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
} OPENCARD_SEARCH_CRITERIAW, *POPENCARD_SEARCH_CRITERIAW, *LPOPENCARD_SEARCH_CRITERIAW;

typedef struct
{
	DWORD dwStructSize;
	SCARDCONTEXT hSCardContext;
	HWND hwndOwner;
	DWORD dwFlags;
	LPCSTR lpstrTitle;
	LPCSTR lpstrSearchDesc;
	HICON hIcon;
	POPENCARD_SEARCH_CRITERIAA pOpenCardSearchCriteria;
	LPOCNCONNPROCA lpfnConnect;
	LPVOID pvUserData;
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
	LPSTR lpstrRdr;
	DWORD nMaxRdr;
	LPSTR lpstrCard;
	DWORD nMaxCard;
	DWORD dwActiveProtocol;
	SCARDHANDLE hCardHandle;
} OPENCARDNAME_EXA, *POPENCARDNAME_EXA, *LPOPENCARDNAME_EXA;

typedef struct
{
	DWORD dwStructSize;
	SCARDCONTEXT hSCardContext;
	HWND hwndOwner;
	DWORD dwFlags;
	LPCWSTR lpstrTitle;
	LPCWSTR lpstrSearchDesc;
	HICON hIcon;
	POPENCARD_SEARCH_CRITERIAW pOpenCardSearchCriteria;
	LPOCNCONNPROCW lpfnConnect;
	LPVOID pvUserData;
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
	LPWSTR lpstrRdr;
	DWORD nMaxRdr;
	LPWSTR lpstrCard;
	DWORD nMaxCard;
	DWORD dwActiveProtocol;
	SCARDHANDLE hCardHandle;
} OPENCARDNAME_EXW, *POPENCARDNAME_EXW, *LPOPENCARDNAME_EXW;

#define OPENCARDNAMEA_EX OPENCARDNAME_EXA
#define OPENCARDNAMEW_EX OPENCARDNAME_EXW
#define POPENCARDNAMEA_EX POPENCARDNAME_EXA
#define POPENCARDNAMEW_EX POPENCARDNAME_EXW
#define LPOPENCARDNAMEA_EX LPOPENCARDNAME_EXA
#define LPOPENCARDNAMEW_EX LPOPENCARDNAME_EXW

typedef enum
{
	RSR_MATCH_TYPE_READER_AND_CONTAINER = 1,
	RSR_MATCH_TYPE_SERIAL_NUMBER,
	RSR_MATCH_TYPE_ALL_CARDS
} READER_SEL_REQUEST_MATCH_TYPE;

typedef struct
{
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
	READER_SEL_REQUEST_MATCH_TYPE MatchType;
	union {
		struct
		{
			DWORD cbReaderNameOffset;
			DWORD cchReaderNameLength;
			DWORD cbContainerNameOffset;
			DWORD cchContainerNameLength;
			DWORD dwDesiredCardModuleVersion;
			DWORD dwCspFlags;
		} ReaderAndContainerParameter;
		struct
		{
			DWORD cbSerialNumberOffset;
			DWORD cbSerialNumberLength;
			DWORD dwDesiredCardModuleVersion;
		} SerialNumberParameter;
	};
} READER_SEL_REQUEST, *PREADER_SEL_REQUEST;

typedef struct
{
	DWORD cbReaderNameOffset;
	DWORD cchReaderNameLength;
	DWORD cbCardNameOffset;
	DWORD cchCardNameLength;
} READER_SEL_RESPONSE, *PREADER_SEL_RESPONSE;

typedef struct
{
	DWORD dwStructSize;
	HWND hwndOwner;
	SCARDCONTEXT hSCardContext;
	LPSTR lpstrGroupNames;
	DWORD nMaxGroupNames;
	LPSTR lpstrCardNames;
	DWORD nMaxCardNames;
	LPCGUID rgguidInterfaces;
	DWORD cguidInterfaces;
	LPSTR lpstrRdr;
	DWORD nMaxRdr;
	LPSTR lpstrCard;
	DWORD nMaxCard;
	LPCSTR lpstrTitle;
	DWORD dwFlags;
	LPVOID pvUserData;
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
	DWORD dwActiveProtocol;
	LPOCNCONNPROCA lpfnConnect;
	LPOCNCHKPROC lpfnCheck;
	LPOCNDSCPROC lpfnDisconnect;
	SCARDHANDLE hCardHandle;
} OPENCARDNAMEA, *POPENCARDNAMEA, *LPOPENCARDNAMEA;

typedef struct
{
	DWORD dwStructSize;
	HWND hwndOwner;
	SCARDCONTEXT hSCardContext;
	LPWSTR lpstrGroupNames;
	DWORD nMaxGroupNames;
	LPWSTR lpstrCardNames;
	DWORD nMaxCardNames;
	LPCGUID rgguidInterfaces;
	DWORD cguidInterfaces;
	LPWSTR lpstrRdr;
	DWORD nMaxRdr;
	LPWSTR lpstrCard;
	DWORD nMaxCard;
	LPCWSTR lpstrTitle;
	DWORD dwFlags;
	LPVOID pvUserData;
	DWORD dwShareMode;
	DWORD dwPreferredProtocols;
	DWORD dwActiveProtocol;
	LPOCNCONNPROCW lpfnConnect;
	LPOCNCHKPROC lpfnCheck;
	LPOCNDSCPROC lpfnDisconnect;
	SCARDHANDLE hCardHandle;
} OPENCARDNAMEW, *POPENCARDNAMEW, *LPOPENCARDNAMEW;

#pragma pack(pop)

#ifdef UNICODE
#define LPOCNCONNPROC LPOCNCONNPROCW
#define SCARD_READERSTATE SCARD_READERSTATEW
#define PSCARD_READERSTATE PSCARD_READERSTATEW
#define LPSCARD_READERSTATE LPSCARD_READERSTATEW
#define OPENCARD_SEARCH_CRITERIA OPENCARD_SEARCH_CRITERIAW
#define LOPENCARD_SEARCH_CRITERIA LOPENCARD_SEARCH_CRITERIAW
#define LPOPENCARD_SEARCH_CRITERIA LPOPENCARD_SEARCH_CRITERIAW
#define OPENCARDNAME_EX OPENCARDNAME_EXW
#define LOPENCARDNAME_EX LOPENCARDNAME_EXW
#define LPOPENCARDNAME_EX LPOPENCARDNAME_EXW
#define OPENCARDNAME OPENCARDNAMEW
#define LOPENCARDNAME LOPENCARDNAMEW
#define LPOPENCARDNAME LPOPENCARDNAMEW
#else
#define LPOCNCONNPROC LPOCNCONNPROCA
#define SCARD_READERSTATE SCARD_READERSTATEA
#define PSCARD_READERSTATE PSCARD_READERSTATEA
#define LPSCARD_READERSTATE LPSCARD_READERSTATEA
#define OPENCARD_SEARCH_CRITERIA OPENCARD_SEARCH_CRITERIAA
#define LOPENCARD_SEARCH_CRITERIA LOPENCARD_SEARCH_CRITERIAA
#define LPOPENCARD_SEARCH_CRITERIA LPOPENCARD_SEARCH_CRITERIAA
#define OPENCARDNAME_EX OPENCARDNAME_EXA
#define LOPENCARDNAME_EX LOPENCARDNAME_EXA
#define LPOPENCARDNAME_EX LPOPENCARDNAME_EXA
#define OPENCARDNAME OPENCARDNAMEA
#define LOPENCARDNAME LOPENCARDNAMEA
#define LPOPENCARDNAME LPOPENCARDNAMEA
#endif

#ifdef __cplusplus
extern "C"
{
#endif

	extern const SCARD_IO_REQUEST g_rgSCardT0Pci;
	extern const SCARD_IO_REQUEST g_rgSCardT1Pci;
	extern const SCARD_IO_REQUEST g_rgSCardRawPci;

#define SCARD_PCI_T0 (&g_rgSCardT0Pci)
#define SCARD_PCI_T1 (&g_rgSCardT1Pci)
#define SCARD_PCI_RAW (&g_rgSCardRawPci)

	WINSCARDAPI LONG WINAPI SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1,
	                                              LPCVOID pvReserved2, LPSCARDCONTEXT phContext);

	WINSCARDAPI LONG WINAPI SCardReleaseContext(SCARDCONTEXT hContext);

	WINSCARDAPI LONG WINAPI SCardIsValidContext(SCARDCONTEXT hContext);

	WINSCARDAPI LONG WINAPI SCardListReaderGroupsA(SCARDCONTEXT hContext, LPSTR mszGroups,
	                                               LPDWORD pcchGroups);
	WINSCARDAPI LONG WINAPI SCardListReaderGroupsW(SCARDCONTEXT hContext, LPWSTR mszGroups,
	                                               LPDWORD pcchGroups);

	WINSCARDAPI LONG WINAPI SCardListReadersA(SCARDCONTEXT hContext, LPCSTR mszGroups,
	                                          LPSTR mszReaders, LPDWORD pcchReaders);
	WINSCARDAPI LONG WINAPI SCardListReadersW(SCARDCONTEXT hContext, LPCWSTR mszGroups,
	                                          LPWSTR mszReaders, LPDWORD pcchReaders);

	WINSCARDAPI LONG WINAPI SCardListCardsA(SCARDCONTEXT hContext, LPCBYTE pbAtr,
	                                        LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount,
	                                        CHAR* mszCards, LPDWORD pcchCards);

	WINSCARDAPI LONG WINAPI SCardListCardsW(SCARDCONTEXT hContext, LPCBYTE pbAtr,
	                                        LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount,
	                                        WCHAR* mszCards, LPDWORD pcchCards);

	WINSCARDAPI LONG WINAPI SCardListInterfacesA(SCARDCONTEXT hContext, LPCSTR szCard,
	                                             LPGUID pguidInterfaces, LPDWORD pcguidInterfaces);
	WINSCARDAPI LONG WINAPI SCardListInterfacesW(SCARDCONTEXT hContext, LPCWSTR szCard,
	                                             LPGUID pguidInterfaces, LPDWORD pcguidInterfaces);

	WINSCARDAPI LONG WINAPI SCardGetProviderIdA(SCARDCONTEXT hContext, LPCSTR szCard,
	                                            LPGUID pguidProviderId);
	WINSCARDAPI LONG WINAPI SCardGetProviderIdW(SCARDCONTEXT hContext, LPCWSTR szCard,
	                                            LPGUID pguidProviderId);

	WINSCARDAPI LONG WINAPI SCardGetCardTypeProviderNameA(SCARDCONTEXT hContext, LPCSTR szCardName,
	                                                      DWORD dwProviderId, CHAR* szProvider,
	                                                      LPDWORD pcchProvider);
	WINSCARDAPI LONG WINAPI SCardGetCardTypeProviderNameW(SCARDCONTEXT hContext, LPCWSTR szCardName,
	                                                      DWORD dwProviderId, WCHAR* szProvider,
	                                                      LPDWORD pcchProvider);

	WINSCARDAPI LONG WINAPI SCardIntroduceReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName);
	WINSCARDAPI LONG WINAPI SCardIntroduceReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName);

	WINSCARDAPI LONG WINAPI SCardForgetReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName);
	WINSCARDAPI LONG WINAPI SCardForgetReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName);

	WINSCARDAPI LONG WINAPI SCardIntroduceReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName,
	                                              LPCSTR szDeviceName);
	WINSCARDAPI LONG WINAPI SCardIntroduceReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
	                                              LPCWSTR szDeviceName);

	WINSCARDAPI LONG WINAPI SCardForgetReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName);
	WINSCARDAPI LONG WINAPI SCardForgetReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName);

	WINSCARDAPI LONG WINAPI SCardAddReaderToGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName,
	                                               LPCSTR szGroupName);
	WINSCARDAPI LONG WINAPI SCardAddReaderToGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
	                                               LPCWSTR szGroupName);

	WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName,
	                                                    LPCSTR szGroupName);
	WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
	                                                    LPCWSTR szGroupName);

	WINSCARDAPI LONG WINAPI SCardIntroduceCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName,
	                                                LPCGUID pguidPrimaryProvider,
	                                                LPCGUID rgguidInterfaces,
	                                                DWORD dwInterfaceCount, LPCBYTE pbAtr,
	                                                LPCBYTE pbAtrMask, DWORD cbAtrLen);
	WINSCARDAPI LONG WINAPI SCardIntroduceCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName,
	                                                LPCGUID pguidPrimaryProvider,
	                                                LPCGUID rgguidInterfaces,
	                                                DWORD dwInterfaceCount, LPCBYTE pbAtr,
	                                                LPCBYTE pbAtrMask, DWORD cbAtrLen);

	WINSCARDAPI LONG WINAPI SCardSetCardTypeProviderNameA(SCARDCONTEXT hContext, LPCSTR szCardName,
	                                                      DWORD dwProviderId, LPCSTR szProvider);
	WINSCARDAPI LONG WINAPI SCardSetCardTypeProviderNameW(SCARDCONTEXT hContext, LPCWSTR szCardName,
	                                                      DWORD dwProviderId, LPCWSTR szProvider);

	WINSCARDAPI LONG WINAPI SCardForgetCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName);
	WINSCARDAPI LONG WINAPI SCardForgetCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName);

	WINSCARDAPI LONG WINAPI SCardFreeMemory(SCARDCONTEXT hContext, LPVOID pvMem);

	WINSCARDAPI HANDLE WINAPI SCardAccessStartedEvent(void);

	WINSCARDAPI void WINAPI SCardReleaseStartedEvent(void);

	WINSCARDAPI LONG WINAPI SCardLocateCardsA(SCARDCONTEXT hContext, LPCSTR mszCards,
	                                          LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders);
	WINSCARDAPI LONG WINAPI SCardLocateCardsW(SCARDCONTEXT hContext, LPCWSTR mszCards,
	                                          LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders);

	WINSCARDAPI LONG WINAPI SCardLocateCardsByATRA(SCARDCONTEXT hContext,
	                                               LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs,
	                                               LPSCARD_READERSTATEA rgReaderStates,
	                                               DWORD cReaders);
	WINSCARDAPI LONG WINAPI SCardLocateCardsByATRW(SCARDCONTEXT hContext,
	                                               LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs,
	                                               LPSCARD_READERSTATEW rgReaderStates,
	                                               DWORD cReaders);

	WINSCARDAPI LONG WINAPI SCardGetStatusChangeA(SCARDCONTEXT hContext, DWORD dwTimeout,
	                                              LPSCARD_READERSTATEA rgReaderStates,
	                                              DWORD cReaders);
	WINSCARDAPI LONG WINAPI SCardGetStatusChangeW(SCARDCONTEXT hContext, DWORD dwTimeout,
	                                              LPSCARD_READERSTATEW rgReaderStates,
	                                              DWORD cReaders);

	WINSCARDAPI LONG WINAPI SCardCancel(SCARDCONTEXT hContext);

	WINSCARDAPI LONG WINAPI SCardConnectA(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode,
	                                      DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
	                                      LPDWORD pdwActiveProtocol);
	WINSCARDAPI LONG WINAPI SCardConnectW(SCARDCONTEXT hContext, LPCWSTR szReader,
	                                      DWORD dwShareMode, DWORD dwPreferredProtocols,
	                                      LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol);

	WINSCARDAPI LONG WINAPI SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
	                                       DWORD dwPreferredProtocols, DWORD dwInitialization,
	                                       LPDWORD pdwActiveProtocol);

	WINSCARDAPI LONG WINAPI SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition);

	WINSCARDAPI LONG WINAPI SCardBeginTransaction(SCARDHANDLE hCard);

	WINSCARDAPI LONG WINAPI SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition);

	WINSCARDAPI LONG WINAPI SCardCancelTransaction(SCARDHANDLE hCard);

	WINSCARDAPI LONG WINAPI SCardState(SCARDHANDLE hCard, LPDWORD pdwState, LPDWORD pdwProtocol,
	                                   LPBYTE pbAtr, LPDWORD pcbAtrLen);

	WINSCARDAPI LONG WINAPI SCardStatusA(SCARDHANDLE hCard, LPSTR mszReaderNames,
	                                     LPDWORD pcchReaderLen, LPDWORD pdwState,
	                                     LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen);
	WINSCARDAPI LONG WINAPI SCardStatusW(SCARDHANDLE hCard, LPWSTR mszReaderNames,
	                                     LPDWORD pcchReaderLen, LPDWORD pdwState,
	                                     LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen);

	WINSCARDAPI LONG WINAPI SCardTransmit(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci,
	                                      LPCBYTE pbSendBuffer, DWORD cbSendLength,
	                                      LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer,
	                                      LPDWORD pcbRecvLength);

	WINSCARDAPI LONG WINAPI SCardGetTransmitCount(SCARDHANDLE hCard, LPDWORD pcTransmitCount);

	WINSCARDAPI LONG WINAPI SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID lpInBuffer,
	                                     DWORD cbInBufferSize, LPVOID lpOutBuffer,
	                                     DWORD cbOutBufferSize, LPDWORD lpBytesReturned);

	WINSCARDAPI LONG WINAPI SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,
	                                       LPDWORD pcbAttrLen);

	WINSCARDAPI LONG WINAPI SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr,
	                                       DWORD cbAttrLen);

	WINSCARDAPI LONG WINAPI SCardUIDlgSelectCardA(LPOPENCARDNAMEA_EX pDlgStruc);
	WINSCARDAPI LONG WINAPI SCardUIDlgSelectCardW(LPOPENCARDNAMEW_EX pDlgStruc);

	WINSCARDAPI LONG WINAPI GetOpenCardNameA(LPOPENCARDNAMEA pDlgStruc);
	WINSCARDAPI LONG WINAPI GetOpenCardNameW(LPOPENCARDNAMEW pDlgStruc);

	WINSCARDAPI LONG WINAPI SCardDlgExtendedError(void);

	WINSCARDAPI LONG WINAPI SCardReadCacheA(SCARDCONTEXT hContext, UUID* CardIdentifier,
	                                        DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data,
	                                        DWORD* DataLen);
	WINSCARDAPI LONG WINAPI SCardReadCacheW(SCARDCONTEXT hContext, UUID* CardIdentifier,
	                                        DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data,
	                                        DWORD* DataLen);

	WINSCARDAPI LONG WINAPI SCardWriteCacheA(SCARDCONTEXT hContext, UUID* CardIdentifier,
	                                         DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data,
	                                         DWORD DataLen);
	WINSCARDAPI LONG WINAPI SCardWriteCacheW(SCARDCONTEXT hContext, UUID* CardIdentifier,
	                                         DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data,
	                                         DWORD DataLen);

	WINSCARDAPI LONG WINAPI SCardGetReaderIconA(SCARDCONTEXT hContext, LPCSTR szReaderName,
	                                            LPBYTE pbIcon, LPDWORD pcbIcon);
	WINSCARDAPI LONG WINAPI SCardGetReaderIconW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
	                                            LPBYTE pbIcon, LPDWORD pcbIcon);

	WINSCARDAPI LONG WINAPI SCardGetDeviceTypeIdA(SCARDCONTEXT hContext, LPCSTR szReaderName,
	                                              LPDWORD pdwDeviceTypeId);
	WINSCARDAPI LONG WINAPI SCardGetDeviceTypeIdW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
	                                              LPDWORD pdwDeviceTypeId);

	WINSCARDAPI LONG WINAPI SCardGetReaderDeviceInstanceIdA(SCARDCONTEXT hContext,
	                                                        LPCSTR szReaderName,
	                                                        LPSTR szDeviceInstanceId,
	                                                        LPDWORD pcchDeviceInstanceId);
	WINSCARDAPI LONG WINAPI SCardGetReaderDeviceInstanceIdW(SCARDCONTEXT hContext,
	                                                        LPCWSTR szReaderName,
	                                                        LPWSTR szDeviceInstanceId,
	                                                        LPDWORD pcchDeviceInstanceId);

	WINSCARDAPI LONG WINAPI SCardListReadersWithDeviceInstanceIdA(SCARDCONTEXT hContext,
	                                                              LPCSTR szDeviceInstanceId,
	                                                              LPSTR mszReaders,
	                                                              LPDWORD pcchReaders);
	WINSCARDAPI LONG WINAPI SCardListReadersWithDeviceInstanceIdW(SCARDCONTEXT hContext,
	                                                              LPCWSTR szDeviceInstanceId,
	                                                              LPWSTR mszReaders,
	                                                              LPDWORD pcchReaders);

	WINSCARDAPI LONG WINAPI SCardAudit(SCARDCONTEXT hContext, DWORD dwEvent);

#ifdef UNICODE
#define SCardListReaderGroups SCardListReaderGroupsW
#define SCardListReaders SCardListReadersW
#define SCardListCards SCardListCardsW
#define SCardListInterfaces SCardListInterfacesW
#define SCardGetProviderId SCardGetProviderIdW
#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameW
#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupW
#define SCardForgetReaderGroup SCardForgetReaderGroupW
#define SCardIntroduceReader SCardIntroduceReaderW
#define SCardForgetReader SCardForgetReaderW
#define SCardAddReaderToGroup SCardAddReaderToGroupW
#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupW
#define SCardIntroduceCardType SCardIntroduceCardTypeW
#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameW
#define SCardForgetCardType SCardForgetCardTypeW
#define SCardLocateCards SCardLocateCardsW
#define SCardLocateCardsByATR SCardLocateCardsByATRW
#define SCardGetStatusChange SCardGetStatusChangeW
#define SCardConnect SCardConnectW
#define SCardStatus SCardStatusW
#define SCardUIDlgSelectCard SCardUIDlgSelectCardW
#define GetOpenCardName GetOpenCardNameW
#define SCardReadCache SCardReadCacheW
#define SCardWriteCache SCardWriteCacheW
#define SCardGetReaderIcon SCardGetReaderIconW
#define SCardGetDeviceTypeId SCardGetDeviceTypeIdW
#define SCardGetReaderDeviceInstanceId SCardGetReaderDeviceInstanceIdW
#define SCardListReadersWithDeviceInstanceId SCardListReadersWithDeviceInstanceIdW
#else
#define SCardListReaderGroups SCardListReaderGroupsA
#define SCardListReaders SCardListReadersA
#define SCardListCards SCardListCardsA
#define SCardListInterfaces SCardListInterfacesA
#define SCardGetProviderId SCardGetProviderIdA
#define SCardGetCardTypeProviderName SCardGetCardTypeProviderNameA
#define SCardIntroduceReaderGroup SCardIntroduceReaderGroupA
#define SCardForgetReaderGroup SCardForgetReaderGroupA
#define SCardIntroduceReader SCardIntroduceReaderA
#define SCardForgetReader SCardForgetReaderA
#define SCardAddReaderToGroup SCardAddReaderToGroupA
#define SCardRemoveReaderFromGroup SCardRemoveReaderFromGroupA
#define SCardIntroduceCardType SCardIntroduceCardTypeA
#define SCardSetCardTypeProviderName SCardSetCardTypeProviderNameA
#define SCardForgetCardType SCardForgetCardTypeA
#define SCardLocateCards SCardLocateCardsA
#define SCardLocateCardsByATR SCardLocateCardsByATRA
#define SCardGetStatusChange SCardGetStatusChangeA
#define SCardConnect SCardConnectA
#define SCardStatus SCardStatusA
#define SCardUIDlgSelectCard SCardUIDlgSelectCardA
#define GetOpenCardName GetOpenCardNameA
#define SCardReadCache SCardReadCacheA
#define SCardWriteCache SCardWriteCacheA
#define SCardGetReaderIcon SCardGetReaderIconA
#define SCardGetDeviceTypeId SCardGetDeviceTypeIdA
#define SCardGetReaderDeviceInstanceId SCardGetReaderDeviceInstanceIdA
#define SCardListReadersWithDeviceInstanceId SCardListReadersWithDeviceInstanceIdA
#endif

#ifdef __cplusplus
}
#endif

/**
 * Extended API
 */

typedef LONG(WINAPI* fnSCardEstablishContext)(DWORD dwScope, LPCVOID pvReserved1,
                                              LPCVOID pvReserved2, LPSCARDCONTEXT phContext);

typedef LONG(WINAPI* fnSCardReleaseContext)(SCARDCONTEXT hContext);

typedef LONG(WINAPI* fnSCardIsValidContext)(SCARDCONTEXT hContext);

typedef LONG(WINAPI* fnSCardListReaderGroupsA)(SCARDCONTEXT hContext, LPSTR mszGroups,
                                               LPDWORD pcchGroups);
typedef LONG(WINAPI* fnSCardListReaderGroupsW)(SCARDCONTEXT hContext, LPWSTR mszGroups,
                                               LPDWORD pcchGroups);

typedef LONG(WINAPI* fnSCardListReadersA)(SCARDCONTEXT hContext, LPCSTR mszGroups, LPSTR mszReaders,
                                          LPDWORD pcchReaders);
typedef LONG(WINAPI* fnSCardListReadersW)(SCARDCONTEXT hContext, LPCWSTR mszGroups,
                                          LPWSTR mszReaders, LPDWORD pcchReaders);

typedef LONG(WINAPI* fnSCardListCardsA)(SCARDCONTEXT hContext, LPCBYTE pbAtr,
                                        LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount,
                                        CHAR* mszCards, LPDWORD pcchCards);

typedef LONG(WINAPI* fnSCardListCardsW)(SCARDCONTEXT hContext, LPCBYTE pbAtr,
                                        LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount,
                                        WCHAR* mszCards, LPDWORD pcchCards);

typedef LONG(WINAPI* fnSCardListInterfacesA)(SCARDCONTEXT hContext, LPCSTR szCard,
                                             LPGUID pguidInterfaces, LPDWORD pcguidInterfaces);
typedef LONG(WINAPI* fnSCardListInterfacesW)(SCARDCONTEXT hContext, LPCWSTR szCard,
                                             LPGUID pguidInterfaces, LPDWORD pcguidInterfaces);

typedef LONG(WINAPI* fnSCardGetProviderIdA)(SCARDCONTEXT hContext, LPCSTR szCard,
                                            LPGUID pguidProviderId);
typedef LONG(WINAPI* fnSCardGetProviderIdW)(SCARDCONTEXT hContext, LPCWSTR szCard,
                                            LPGUID pguidProviderId);

typedef LONG(WINAPI* fnSCardGetCardTypeProviderNameA)(SCARDCONTEXT hContext, LPCSTR szCardName,
                                                      DWORD dwProviderId, CHAR* szProvider,
                                                      LPDWORD pcchProvider);
typedef LONG(WINAPI* fnSCardGetCardTypeProviderNameW)(SCARDCONTEXT hContext, LPCWSTR szCardName,
                                                      DWORD dwProviderId, WCHAR* szProvider,
                                                      LPDWORD pcchProvider);

typedef LONG(WINAPI* fnSCardIntroduceReaderGroupA)(SCARDCONTEXT hContext, LPCSTR szGroupName);
typedef LONG(WINAPI* fnSCardIntroduceReaderGroupW)(SCARDCONTEXT hContext, LPCWSTR szGroupName);

typedef LONG(WINAPI* fnSCardForgetReaderGroupA)(SCARDCONTEXT hContext, LPCSTR szGroupName);
typedef LONG(WINAPI* fnSCardForgetReaderGroupW)(SCARDCONTEXT hContext, LPCWSTR szGroupName);

typedef LONG(WINAPI* fnSCardIntroduceReaderA)(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                              LPCSTR szDeviceName);
typedef LONG(WINAPI* fnSCardIntroduceReaderW)(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                              LPCWSTR szDeviceName);

typedef LONG(WINAPI* fnSCardForgetReaderA)(SCARDCONTEXT hContext, LPCSTR szReaderName);
typedef LONG(WINAPI* fnSCardForgetReaderW)(SCARDCONTEXT hContext, LPCWSTR szReaderName);

typedef LONG(WINAPI* fnSCardAddReaderToGroupA)(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                               LPCSTR szGroupName);
typedef LONG(WINAPI* fnSCardAddReaderToGroupW)(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                               LPCWSTR szGroupName);

typedef LONG(WINAPI* fnSCardRemoveReaderFromGroupA)(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                                    LPCSTR szGroupName);
typedef LONG(WINAPI* fnSCardRemoveReaderFromGroupW)(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                                    LPCWSTR szGroupName);

typedef LONG(WINAPI* fnSCardIntroduceCardTypeA)(SCARDCONTEXT hContext, LPCSTR szCardName,
                                                LPCGUID pguidPrimaryProvider,
                                                LPCGUID rgguidInterfaces, DWORD dwInterfaceCount,
                                                LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen);
typedef LONG(WINAPI* fnSCardIntroduceCardTypeW)(SCARDCONTEXT hContext, LPCWSTR szCardName,
                                                LPCGUID pguidPrimaryProvider,
                                                LPCGUID rgguidInterfaces, DWORD dwInterfaceCount,
                                                LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen);

typedef LONG(WINAPI* fnSCardSetCardTypeProviderNameA)(SCARDCONTEXT hContext, LPCSTR szCardName,
                                                      DWORD dwProviderId, LPCSTR szProvider);
typedef LONG(WINAPI* fnSCardSetCardTypeProviderNameW)(SCARDCONTEXT hContext, LPCWSTR szCardName,
                                                      DWORD dwProviderId, LPCWSTR szProvider);

typedef LONG(WINAPI* fnSCardForgetCardTypeA)(SCARDCONTEXT hContext, LPCSTR szCardName);
typedef LONG(WINAPI* fnSCardForgetCardTypeW)(SCARDCONTEXT hContext, LPCWSTR szCardName);

typedef LONG(WINAPI* fnSCardFreeMemory)(SCARDCONTEXT hContext, LPVOID pvMem);

typedef HANDLE(WINAPI* fnSCardAccessStartedEvent)(void);

typedef void(WINAPI* fnSCardReleaseStartedEvent)(void);

typedef LONG(WINAPI* fnSCardLocateCardsA)(SCARDCONTEXT hContext, LPCSTR mszCards,
                                          LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders);
typedef LONG(WINAPI* fnSCardLocateCardsW)(SCARDCONTEXT hContext, LPCWSTR mszCards,
                                          LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders);

typedef LONG(WINAPI* fnSCardLocateCardsByATRA)(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
                                               DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates,
                                               DWORD cReaders);
typedef LONG(WINAPI* fnSCardLocateCardsByATRW)(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
                                               DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates,
                                               DWORD cReaders);

typedef LONG(WINAPI* fnSCardGetStatusChangeA)(SCARDCONTEXT hContext, DWORD dwTimeout,
                                              LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders);
typedef LONG(WINAPI* fnSCardGetStatusChangeW)(SCARDCONTEXT hContext, DWORD dwTimeout,
                                              LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders);

typedef LONG(WINAPI* fnSCardCancel)(SCARDCONTEXT hContext);

typedef LONG(WINAPI* fnSCardConnectA)(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode,
                                      DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
                                      LPDWORD pdwActiveProtocol);
typedef LONG(WINAPI* fnSCardConnectW)(SCARDCONTEXT hContext, LPCWSTR szReader, DWORD dwShareMode,
                                      DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
                                      LPDWORD pdwActiveProtocol);

typedef LONG(WINAPI* fnSCardReconnect)(SCARDHANDLE hCard, DWORD dwShareMode,
                                       DWORD dwPreferredProtocols, DWORD dwInitialization,
                                       LPDWORD pdwActiveProtocol);

typedef LONG(WINAPI* fnSCardDisconnect)(SCARDHANDLE hCard, DWORD dwDisposition);

typedef LONG(WINAPI* fnSCardBeginTransaction)(SCARDHANDLE hCard);

typedef LONG(WINAPI* fnSCardEndTransaction)(SCARDHANDLE hCard, DWORD dwDisposition);

typedef LONG(WINAPI* fnSCardCancelTransaction)(SCARDHANDLE hCard);

typedef LONG(WINAPI* fnSCardState)(SCARDHANDLE hCard, LPDWORD pdwState, LPDWORD pdwProtocol,
                                   LPBYTE pbAtr, LPDWORD pcbAtrLen);

typedef LONG(WINAPI* fnSCardStatusA)(SCARDHANDLE hCard, LPSTR mszReaderNames, LPDWORD pcchReaderLen,
                                     LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr,
                                     LPDWORD pcbAtrLen);
typedef LONG(WINAPI* fnSCardStatusW)(SCARDHANDLE hCard, LPWSTR mszReaderNames,
                                     LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol,
                                     LPBYTE pbAtr, LPDWORD pcbAtrLen);

typedef LONG(WINAPI* fnSCardTransmit)(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci,
                                      LPCBYTE pbSendBuffer, DWORD cbSendLength,
                                      LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer,
                                      LPDWORD pcbRecvLength);

typedef LONG(WINAPI* fnSCardGetTransmitCount)(SCARDHANDLE hCard, LPDWORD pcTransmitCount);

typedef LONG(WINAPI* fnSCardControl)(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID lpInBuffer,
                                     DWORD cbInBufferSize, LPVOID lpOutBuffer,
                                     DWORD cbOutBufferSize, LPDWORD lpBytesReturned);

typedef LONG(WINAPI* fnSCardGetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,
                                       LPDWORD pcbAttrLen);

typedef LONG(WINAPI* fnSCardSetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr,
                                       DWORD cbAttrLen);

typedef LONG(WINAPI* fnSCardUIDlgSelectCardA)(LPOPENCARDNAMEA_EX pDlgStruc);
typedef LONG(WINAPI* fnSCardUIDlgSelectCardW)(LPOPENCARDNAMEW_EX pDlgStruc);

typedef LONG(WINAPI* fnGetOpenCardNameA)(LPOPENCARDNAMEA pDlgStruc);
typedef LONG(WINAPI* fnGetOpenCardNameW)(LPOPENCARDNAMEW pDlgStruc);

typedef LONG(WINAPI* fnSCardDlgExtendedError)(void);

typedef LONG(WINAPI* fnSCardReadCacheA)(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                        DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data,
                                        DWORD* DataLen);
typedef LONG(WINAPI* fnSCardReadCacheW)(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                        DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data,
                                        DWORD* DataLen);

typedef LONG(WINAPI* fnSCardWriteCacheA)(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                         DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data,
                                         DWORD DataLen);
typedef LONG(WINAPI* fnSCardWriteCacheW)(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                         DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data,
                                         DWORD DataLen);

typedef LONG(WINAPI* fnSCardGetReaderIconA)(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                            LPBYTE pbIcon, LPDWORD pcbIcon);
typedef LONG(WINAPI* fnSCardGetReaderIconW)(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                            LPBYTE pbIcon, LPDWORD pcbIcon);

typedef LONG(WINAPI* fnSCardGetDeviceTypeIdA)(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                              LPDWORD pdwDeviceTypeId);
typedef LONG(WINAPI* fnSCardGetDeviceTypeIdW)(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                              LPDWORD pdwDeviceTypeId);

typedef LONG(WINAPI* fnSCardGetReaderDeviceInstanceIdA)(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                                        LPSTR szDeviceInstanceId,
                                                        LPDWORD pcchDeviceInstanceId);
typedef LONG(WINAPI* fnSCardGetReaderDeviceInstanceIdW)(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                                        LPWSTR szDeviceInstanceId,
                                                        LPDWORD pcchDeviceInstanceId);

typedef LONG(WINAPI* fnSCardListReadersWithDeviceInstanceIdA)(SCARDCONTEXT hContext,
                                                              LPCSTR szDeviceInstanceId,
                                                              LPSTR mszReaders,
                                                              LPDWORD pcchReaders);
typedef LONG(WINAPI* fnSCardListReadersWithDeviceInstanceIdW)(SCARDCONTEXT hContext,
                                                              LPCWSTR szDeviceInstanceId,
                                                              LPWSTR mszReaders,
                                                              LPDWORD pcchReaders);

typedef LONG(WINAPI* fnSCardAudit)(SCARDCONTEXT hContext, DWORD dwEvent);

struct _SCardApiFunctionTable
{
	DWORD dwVersion;
	DWORD dwFlags;

	fnSCardEstablishContext pfnSCardEstablishContext;
	fnSCardReleaseContext pfnSCardReleaseContext;
	fnSCardIsValidContext pfnSCardIsValidContext;
	fnSCardListReaderGroupsA pfnSCardListReaderGroupsA;
	fnSCardListReaderGroupsW pfnSCardListReaderGroupsW;
	fnSCardListReadersA pfnSCardListReadersA;
	fnSCardListReadersW pfnSCardListReadersW;
	fnSCardListCardsA pfnSCardListCardsA;
	fnSCardListCardsW pfnSCardListCardsW;
	fnSCardListInterfacesA pfnSCardListInterfacesA;
	fnSCardListInterfacesW pfnSCardListInterfacesW;
	fnSCardGetProviderIdA pfnSCardGetProviderIdA;
	fnSCardGetProviderIdW pfnSCardGetProviderIdW;
	fnSCardGetCardTypeProviderNameA pfnSCardGetCardTypeProviderNameA;
	fnSCardGetCardTypeProviderNameW pfnSCardGetCardTypeProviderNameW;
	fnSCardIntroduceReaderGroupA pfnSCardIntroduceReaderGroupA;
	fnSCardIntroduceReaderGroupW pfnSCardIntroduceReaderGroupW;
	fnSCardForgetReaderGroupA pfnSCardForgetReaderGroupA;
	fnSCardForgetReaderGroupW pfnSCardForgetReaderGroupW;
	fnSCardIntroduceReaderA pfnSCardIntroduceReaderA;
	fnSCardIntroduceReaderW pfnSCardIntroduceReaderW;
	fnSCardForgetReaderA pfnSCardForgetReaderA;
	fnSCardForgetReaderW pfnSCardForgetReaderW;
	fnSCardAddReaderToGroupA pfnSCardAddReaderToGroupA;
	fnSCardAddReaderToGroupW pfnSCardAddReaderToGroupW;
	fnSCardRemoveReaderFromGroupA pfnSCardRemoveReaderFromGroupA;
	fnSCardRemoveReaderFromGroupW pfnSCardRemoveReaderFromGroupW;
	fnSCardIntroduceCardTypeA pfnSCardIntroduceCardTypeA;
	fnSCardIntroduceCardTypeW pfnSCardIntroduceCardTypeW;
	fnSCardSetCardTypeProviderNameA pfnSCardSetCardTypeProviderNameA;
	fnSCardSetCardTypeProviderNameW pfnSCardSetCardTypeProviderNameW;
	fnSCardForgetCardTypeA pfnSCardForgetCardTypeA;
	fnSCardForgetCardTypeW pfnSCardForgetCardTypeW;
	fnSCardFreeMemory pfnSCardFreeMemory;
	fnSCardAccessStartedEvent pfnSCardAccessStartedEvent;
	fnSCardReleaseStartedEvent pfnSCardReleaseStartedEvent;
	fnSCardLocateCardsA pfnSCardLocateCardsA;
	fnSCardLocateCardsW pfnSCardLocateCardsW;
	fnSCardLocateCardsByATRA pfnSCardLocateCardsByATRA;
	fnSCardLocateCardsByATRW pfnSCardLocateCardsByATRW;
	fnSCardGetStatusChangeA pfnSCardGetStatusChangeA;
	fnSCardGetStatusChangeW pfnSCardGetStatusChangeW;
	fnSCardCancel pfnSCardCancel;
	fnSCardConnectA pfnSCardConnectA;
	fnSCardConnectW pfnSCardConnectW;
	fnSCardReconnect pfnSCardReconnect;
	fnSCardDisconnect pfnSCardDisconnect;
	fnSCardBeginTransaction pfnSCardBeginTransaction;
	fnSCardEndTransaction pfnSCardEndTransaction;
	fnSCardCancelTransaction pfnSCardCancelTransaction;
	fnSCardState pfnSCardState;
	fnSCardStatusA pfnSCardStatusA;
	fnSCardStatusW pfnSCardStatusW;
	fnSCardTransmit pfnSCardTransmit;
	fnSCardGetTransmitCount pfnSCardGetTransmitCount;
	fnSCardControl pfnSCardControl;
	fnSCardGetAttrib pfnSCardGetAttrib;
	fnSCardSetAttrib pfnSCardSetAttrib;
	fnSCardUIDlgSelectCardA pfnSCardUIDlgSelectCardA;
	fnSCardUIDlgSelectCardW pfnSCardUIDlgSelectCardW;
	fnGetOpenCardNameA pfnGetOpenCardNameA;
	fnGetOpenCardNameW pfnGetOpenCardNameW;
	fnSCardDlgExtendedError pfnSCardDlgExtendedError;
	fnSCardReadCacheA pfnSCardReadCacheA;
	fnSCardReadCacheW pfnSCardReadCacheW;
	fnSCardWriteCacheA pfnSCardWriteCacheA;
	fnSCardWriteCacheW pfnSCardWriteCacheW;
	fnSCardGetReaderIconA pfnSCardGetReaderIconA;
	fnSCardGetReaderIconW pfnSCardGetReaderIconW;
	fnSCardGetDeviceTypeIdA pfnSCardGetDeviceTypeIdA;
	fnSCardGetDeviceTypeIdW pfnSCardGetDeviceTypeIdW;
	fnSCardGetReaderDeviceInstanceIdA pfnSCardGetReaderDeviceInstanceIdA;
	fnSCardGetReaderDeviceInstanceIdW pfnSCardGetReaderDeviceInstanceIdW;
	fnSCardListReadersWithDeviceInstanceIdA pfnSCardListReadersWithDeviceInstanceIdA;
	fnSCardListReadersWithDeviceInstanceIdW pfnSCardListReadersWithDeviceInstanceIdW;
	fnSCardAudit pfnSCardAudit;
};

typedef struct _SCardApiFunctionTable SCardApiFunctionTable;
typedef SCardApiFunctionTable* PSCardApiFunctionTable;

#ifdef __cplusplus
extern "C"
{
#endif

	WINSCARDAPI const char* WINAPI SCardGetErrorString(LONG errorCode);
	WINSCARDAPI const char* WINAPI SCardGetAttributeString(DWORD dwAttrId);
	WINSCARDAPI const char* WINAPI SCardGetProtocolString(DWORD dwProtocols);
	WINSCARDAPI const char* WINAPI SCardGetShareModeString(DWORD dwShareMode);
	WINSCARDAPI const char* WINAPI SCardGetDispositionString(DWORD dwDisposition);
	WINSCARDAPI const char* WINAPI SCardGetScopeString(DWORD dwScope);
	WINSCARDAPI const char* WINAPI SCardGetCardStateString(DWORD dwCardState);
	WINSCARDAPI char* WINAPI SCardGetReaderStateString(DWORD dwReaderState);

#ifdef __cplusplus
}
#endif

#endif /* WINPR_SMARTCARD_H */
