diff --git a/winpr/include/winpr/smartcard.h b/winpr/include/winpr/smartcard.h index 706972868..954bacb7c 100644 --- a/winpr/include/winpr/smartcard.h +++ b/winpr/include/winpr/smartcard.h @@ -642,7 +642,7 @@ WINSCARDAPI LONG WINAPI SCardAddReaderToGroupA(SCARDCONTEXT hContext, WINSCARDAPI LONG WINAPI SCardAddReaderToGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szGroupName); -WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupA( SCARDCONTEXT hContext, +WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szGroupName); WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szGroupName); @@ -835,6 +835,272 @@ WINSCARDAPI LONG WINAPI SCardAudit(SCARDCONTEXT hContext, DWORD dwEvent); * 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, LPCVOID 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 diff --git a/winpr/libwinpr/smartcard/CMakeLists.txt b/winpr/libwinpr/smartcard/CMakeLists.txt index aa43cdb93..8d34b556b 100644 --- a/winpr/libwinpr/smartcard/CMakeLists.txt +++ b/winpr/libwinpr/smartcard/CMakeLists.txt @@ -20,7 +20,9 @@ set(MODULE_PREFIX "WINPR_SMARTCARD") set(${MODULE_PREFIX}_SRCS smartcard.c - smartcard.h) + smartcard.h + smartcard_pcsc.c + smartcard_pcsc.h) if(MSVC AND (NOT MONOLITHIC_BUILD)) set(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_SRCS} module.def) diff --git a/winpr/libwinpr/smartcard/smartcard.c b/winpr/libwinpr/smartcard/smartcard.c index 66a4f01ce..69be67826 100644 --- a/winpr/libwinpr/smartcard/smartcard.c +++ b/winpr/libwinpr/smartcard/smartcard.c @@ -25,117 +25,10 @@ #include #include -#ifndef _WIN32 - #include "smartcard.h" -/** - * libpcsclite.so.1: - * - * SCardEstablishContext - * SCardReleaseContext - * SCardIsValidContext - * SCardConnect - * SCardReconnect - * SCardDisconnect - * SCardBeginTransaction - * SCardEndTransaction - * SCardStatus - * SCardGetStatusChange - * SCardControl - * SCardTransmit - * SCardListReaderGroups - * SCardListReaders - * SCardFreeMemory - * SCardCancel - * SCardGetAttrib - * SCardSetAttrib - */ - -struct _PCSCLiteFunctionTable -{ - LONG (* pfnSCardEstablishContext)(DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext); - LONG (* pfnSCardReleaseContext)(SCARDCONTEXT hContext); - LONG (* pfnSCardIsValidContext)(SCARDCONTEXT hContext); - LONG (* pfnSCardConnect)(SCARDCONTEXT hContext, - LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, - LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol); - LONG (* pfnSCardReconnect)(SCARDHANDLE hCard, - DWORD dwShareMode, DWORD dwPreferredProtocols, - DWORD dwInitialization, LPDWORD pdwActiveProtocol); - LONG (* pfnSCardDisconnect)(SCARDHANDLE hCard, DWORD dwDisposition); - LONG (* pfnSCardBeginTransaction)(SCARDHANDLE hCard); - LONG (* pfnSCardEndTransaction)(SCARDHANDLE hCard, DWORD dwDisposition); - LONG (* pfnSCardStatus)(SCARDHANDLE hCard, - LPSTR mszReaderName, LPDWORD pcchReaderLen, LPDWORD pdwState, - LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen); - LONG (* pfnSCardGetStatusChange)(SCARDCONTEXT hContext, - DWORD dwTimeout, LPSCARD_READERSTATE rgReaderStates, DWORD cReaders); - LONG (* pfnSCardControl)(SCARDHANDLE hCard, - DWORD dwControlCode, LPCVOID pbSendBuffer, DWORD cbSendLength, - LPVOID pbRecvBuffer, DWORD cbRecvLength, LPDWORD lpBytesReturned); - LONG (* pfnSCardTransmit)(SCARDHANDLE hCard, - const SCARD_IO_REQUEST* pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, - SCARD_IO_REQUEST* pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength); - LONG (* pfnSCardListReaderGroups)(SCARDCONTEXT hContext, LPSTR mszGroups, LPDWORD pcchGroups); - LONG (* pfnSCardListReaders)(SCARDCONTEXT hContext, - LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders); - LONG (* pfnSCardFreeMemory)(SCARDCONTEXT hContext, LPCVOID pvMem); - LONG (* pfnSCardCancel)(SCARDCONTEXT hContext); - LONG (* pfnSCardGetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen); - LONG (* pfnSCardSetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen); -}; -typedef struct _PCSCLiteFunctionTable PCSCLiteFunctionTable; - static BOOL g_Initialized = FALSE; -static HMODULE g_PCSCLiteModule = NULL; - -static PCSCLiteFunctionTable* g_PCSCLite = NULL; - -void InitializePCSCLite(void) -{ - if (g_PCSCLite) - return; - - g_PCSCLiteModule = LoadLibraryA("libpcsclite.so.1"); - - if (!g_PCSCLiteModule) - return; - - g_PCSCLite = calloc(1, sizeof(PCSCLiteFunctionTable)); - - if (!g_PCSCLite) - return; - - g_PCSCLite->pfnSCardEstablishContext = GetProcAddress(g_PCSCLiteModule, "SCardEstablishContext"); - g_PCSCLite->pfnSCardReleaseContext = GetProcAddress(g_PCSCLiteModule, "SCardReleaseContext"); - g_PCSCLite->pfnSCardIsValidContext = GetProcAddress(g_PCSCLiteModule, "SCardIsValidContext"); - g_PCSCLite->pfnSCardConnect = GetProcAddress(g_PCSCLiteModule, "SCardConnect"); - g_PCSCLite->pfnSCardReconnect = GetProcAddress(g_PCSCLiteModule, "SCardReconnect"); - g_PCSCLite->pfnSCardDisconnect = GetProcAddress(g_PCSCLiteModule, "SCardDisconnect"); - g_PCSCLite->pfnSCardBeginTransaction = GetProcAddress(g_PCSCLiteModule, "SCardBeginTransaction"); - g_PCSCLite->pfnSCardEndTransaction = GetProcAddress(g_PCSCLiteModule, "SCardEndTransaction"); - g_PCSCLite->pfnSCardStatus = GetProcAddress(g_PCSCLiteModule, "SCardStatus"); - g_PCSCLite->pfnSCardGetStatusChange = GetProcAddress(g_PCSCLiteModule, "SCardGetStatusChange"); - g_PCSCLite->pfnSCardControl = GetProcAddress(g_PCSCLiteModule, "SCardControl"); - g_PCSCLite->pfnSCardTransmit = GetProcAddress(g_PCSCLiteModule, "SCardTransmit"); - g_PCSCLite->pfnSCardListReaderGroups = GetProcAddress(g_PCSCLiteModule, "SCardListReaderGroups"); - g_PCSCLite->pfnSCardListReaders = GetProcAddress(g_PCSCLiteModule, "SCardListReaders"); - g_PCSCLite->pfnSCardFreeMemory = GetProcAddress(g_PCSCLiteModule, "SCardFreeMemory"); - g_PCSCLite->pfnSCardCancel = GetProcAddress(g_PCSCLiteModule, "SCardCancel"); - g_PCSCLite->pfnSCardGetAttrib = GetProcAddress(g_PCSCLiteModule, "SCardGetAttrib"); - g_PCSCLite->pfnSCardSetAttrib = GetProcAddress(g_PCSCLiteModule, "SCardSetAttrib"); -} - -void InitializeSCardStubs(void) -{ - if (g_Initialized) - return; - - g_Initialized = TRUE; - - InitializePCSCLite(); -} +static PSCardApiFunctionTable g_SCardApi = NULL; /** * Standard Windows Smart Card API @@ -144,623 +37,460 @@ void InitializeSCardStubs(void) WINSCARDAPI LONG WINAPI SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardEstablishContext) - { - return g_PCSCLite->pfnSCardEstablishContext(dwScope, pvReserved1, pvReserved2, phContext); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardEstablishContext, + dwScope, pvReserved1, pvReserved2, phContext); } WINSCARDAPI LONG WINAPI SCardReleaseContext(SCARDCONTEXT hContext) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardReleaseContext) - { - return g_PCSCLite->pfnSCardReleaseContext(hContext); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardReleaseContext, hContext); } WINSCARDAPI LONG WINAPI SCardIsValidContext(SCARDCONTEXT hContext) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardIsValidContext) - { - return g_PCSCLite->pfnSCardIsValidContext(hContext); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIsValidContext, hContext); } WINSCARDAPI LONG WINAPI SCardListReaderGroupsA(SCARDCONTEXT hContext, LPSTR mszGroups, LPDWORD pcchGroups) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardListReaderGroups) - { - return g_PCSCLite->pfnSCardListReaderGroups(hContext, mszGroups, pcchGroups); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListReaderGroupsA, hContext, mszGroups, pcchGroups); } WINSCARDAPI LONG WINAPI SCardListReaderGroupsW(SCARDCONTEXT hContext, LPWSTR mszGroups, LPDWORD pcchGroups) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardListReaderGroups) - { - mszGroups = NULL; - pcchGroups = 0; - - /* FIXME: unicode conversion */ - - return g_PCSCLite->pfnSCardListReaderGroups(hContext, (LPSTR) mszGroups, pcchGroups); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListReaderGroupsW, hContext, mszGroups, pcchGroups); } WINSCARDAPI LONG WINAPI SCardListReadersA(SCARDCONTEXT hContext, LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardListReaders) - { - return g_PCSCLite->pfnSCardListReaders(hContext, mszGroups, mszReaders, pcchReaders); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListReadersA, hContext, mszGroups, mszReaders, pcchReaders); } WINSCARDAPI LONG WINAPI SCardListReadersW(SCARDCONTEXT hContext, LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardListReaders) - { - mszGroups = NULL; - - mszReaders = NULL; - pcchReaders = 0; - - /* FIXME: unicode conversion */ - - return g_PCSCLite->pfnSCardListReaders(hContext, (LPSTR) mszGroups, (LPSTR) mszReaders, pcchReaders); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListReadersW, hContext, mszGroups, mszReaders, pcchReaders); } WINSCARDAPI LONG WINAPI SCardListCardsA(SCARDCONTEXT hContext, LPCBYTE pbAtr, LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount, CHAR* mszCards, LPDWORD pcchCards) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListCardsA, hContext, pbAtr, + rgquidInterfaces, cguidInterfaceCount, mszCards, pcchCards); } WINSCARDAPI LONG WINAPI SCardListCardsW(SCARDCONTEXT hContext, LPCBYTE pbAtr, LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount, WCHAR* mszCards, LPDWORD pcchCards) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListCardsW, hContext, pbAtr, + rgquidInterfaces, cguidInterfaceCount, mszCards, pcchCards); } WINSCARDAPI LONG WINAPI SCardListInterfacesA(SCARDCONTEXT hContext, LPCSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListInterfacesA, hContext, szCard, pguidInterfaces, pcguidInterfaces); } + WINSCARDAPI LONG WINAPI SCardListInterfacesW(SCARDCONTEXT hContext, LPCWSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListInterfacesW, hContext, szCard, pguidInterfaces, pcguidInterfaces); } WINSCARDAPI LONG WINAPI SCardGetProviderIdA(SCARDCONTEXT hContext, LPCSTR szCard, LPGUID pguidProviderId) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetProviderIdA, hContext, szCard, pguidProviderId); } + WINSCARDAPI LONG WINAPI SCardGetProviderIdW(SCARDCONTEXT hContext, LPCWSTR szCard, LPGUID pguidProviderId) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetProviderIdW, hContext, szCard, pguidProviderId); } WINSCARDAPI LONG WINAPI SCardGetCardTypeProviderNameA(SCARDCONTEXT hContext, LPCSTR szCardName, DWORD dwProviderId, CHAR* szProvider, LPDWORD pcchProvider) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetCardTypeProviderNameA, hContext, szCardName, + dwProviderId, szProvider, pcchProvider); } + WINSCARDAPI LONG WINAPI SCardGetCardTypeProviderNameW(SCARDCONTEXT hContext, LPCWSTR szCardName, DWORD dwProviderId, WCHAR* szProvider, LPDWORD pcchProvider) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetCardTypeProviderNameW, hContext, szCardName, + dwProviderId, szProvider, pcchProvider); } WINSCARDAPI LONG WINAPI SCardIntroduceReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIntroduceReaderGroupA, hContext, szGroupName); } + WINSCARDAPI LONG WINAPI SCardIntroduceReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIntroduceReaderGroupW, hContext, szGroupName); } WINSCARDAPI LONG WINAPI SCardForgetReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardForgetReaderGroupA, hContext, szGroupName); } + WINSCARDAPI LONG WINAPI SCardForgetReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardForgetReaderGroupW, hContext, szGroupName); } WINSCARDAPI LONG WINAPI SCardIntroduceReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szDeviceName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIntroduceReaderA, hContext, szReaderName, szDeviceName); } + WINSCARDAPI LONG WINAPI SCardIntroduceReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szDeviceName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIntroduceReaderW, hContext, szReaderName, szDeviceName); } WINSCARDAPI LONG WINAPI SCardForgetReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardForgetReaderA, hContext, szReaderName); } + WINSCARDAPI LONG WINAPI SCardForgetReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardForgetReaderW, hContext, szReaderName); } WINSCARDAPI LONG WINAPI SCardAddReaderToGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardAddReaderToGroupA, hContext, szReaderName, szGroupName); } + WINSCARDAPI LONG WINAPI SCardAddReaderToGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardAddReaderToGroupW, hContext, szReaderName, szGroupName); } -WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupA( SCARDCONTEXT hContext, +WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPCSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardRemoveReaderFromGroupA, hContext, szReaderName, szGroupName); } + WINSCARDAPI LONG WINAPI SCardRemoveReaderFromGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPCWSTR szGroupName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardRemoveReaderFromGroupW, hContext, szReaderName, szGroupName); } WINSCARDAPI LONG WINAPI SCardIntroduceCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces, DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIntroduceCardTypeA, hContext, szCardName, pguidPrimaryProvider, + rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen); } + WINSCARDAPI LONG WINAPI SCardIntroduceCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces, DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardIntroduceCardTypeW, hContext, szCardName, pguidPrimaryProvider, + rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen); } WINSCARDAPI LONG WINAPI SCardSetCardTypeProviderNameA(SCARDCONTEXT hContext, LPCSTR szCardName, DWORD dwProviderId, LPCSTR szProvider) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardSetCardTypeProviderNameA, hContext, szCardName, dwProviderId, szProvider); } + WINSCARDAPI LONG WINAPI SCardSetCardTypeProviderNameW(SCARDCONTEXT hContext, LPCWSTR szCardName, DWORD dwProviderId, LPCWSTR szProvider) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardSetCardTypeProviderNameW, hContext, szCardName, dwProviderId, szProvider); } WINSCARDAPI LONG WINAPI SCardForgetCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardForgetCardTypeA, hContext, szCardName); } + WINSCARDAPI LONG WINAPI SCardForgetCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardForgetCardTypeW, hContext, szCardName); } WINSCARDAPI LONG WINAPI SCardFreeMemory(SCARDCONTEXT hContext, LPCVOID pvMem) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardFreeMemory) - { - return g_PCSCLite->pfnSCardFreeMemory(hContext, pvMem); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardFreeMemory, hContext, pvMem); } WINSCARDAPI HANDLE WINAPI SCardAccessStartedEvent(void) { - return 0; + SCARDAPI_STUB_CALL_HANDLE(SCardAccessStartedEvent); } WINSCARDAPI void WINAPI SCardReleaseStartedEvent(void) { - + SCARDAPI_STUB_CALL_VOID(SCardReleaseStartedEvent); } WINSCARDAPI LONG WINAPI SCardLocateCardsA(SCARDCONTEXT hContext, LPCSTR mszCards, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardLocateCardsA, hContext, mszCards, rgReaderStates, cReaders); } + WINSCARDAPI LONG WINAPI SCardLocateCardsW(SCARDCONTEXT hContext, LPCWSTR mszCards, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardLocateCardsW, hContext, mszCards, rgReaderStates, cReaders); } WINSCARDAPI LONG WINAPI SCardLocateCardsByATRA(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardLocateCardsByATRA, hContext, rgAtrMasks, cAtrs, rgReaderStates, cReaders); } WINSCARDAPI LONG WINAPI SCardLocateCardsByATRW(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardLocateCardsByATRW, hContext, rgAtrMasks, cAtrs, rgReaderStates, cReaders); } WINSCARDAPI LONG WINAPI SCardGetStatusChangeA(SCARDCONTEXT hContext, DWORD dwTimeout, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardGetStatusChange) - { - return g_PCSCLite->pfnSCardGetStatusChange(hContext, dwTimeout, rgReaderStates, cReaders); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetStatusChangeA, hContext, dwTimeout, rgReaderStates, cReaders); } WINSCARDAPI LONG WINAPI SCardGetStatusChangeW(SCARDCONTEXT hContext, DWORD dwTimeout, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardGetStatusChange) - { - SCARD_READERSTATEA rgReaderStatesA; - - cReaders = 0; - ZeroMemory(&rgReaderStatesA, sizeof(SCARD_READERSTATEA)); - - /* FIXME: unicode conversion */ - return g_PCSCLite->pfnSCardGetStatusChange(hContext, dwTimeout, &rgReaderStatesA, cReaders); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetStatusChangeW, hContext, dwTimeout, rgReaderStates, cReaders); } WINSCARDAPI LONG WINAPI SCardCancel(SCARDCONTEXT hContext) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardCancel) - { - return g_PCSCLite->pfnSCardCancel(hContext); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardCancel, hContext); } WINSCARDAPI LONG WINAPI SCardConnectA(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardConnect) - { - return g_PCSCLite->pfnSCardConnect(hContext, szReader, - dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardConnectA, hContext, szReader, dwShareMode, + dwPreferredProtocols, phCard, pdwActiveProtocol); } WINSCARDAPI LONG WINAPI SCardConnectW(SCARDCONTEXT hContext, LPCWSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardConnect) - { - LONG status; - LPSTR szReaderA = NULL; - - if (szReader) - ConvertFromUnicode(CP_UTF8, 0, szReader, -1, &szReaderA, 0, NULL, NULL); - - status = g_PCSCLite->pfnSCardConnect(hContext, szReaderA, - dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); - - free(szReaderA); - - return status; - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardConnectW, hContext, szReader, dwShareMode, + dwPreferredProtocols, phCard, pdwActiveProtocol); } WINSCARDAPI LONG WINAPI SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode, DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardReconnect) - { - return g_PCSCLite->pfnSCardReconnect(hCard, dwShareMode, - dwPreferredProtocols, dwInitialization, pdwActiveProtocol); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardReconnect, hCard, dwShareMode, + dwPreferredProtocols, dwInitialization, pdwActiveProtocol); } WINSCARDAPI LONG WINAPI SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardDisconnect) - { - return g_PCSCLite->pfnSCardDisconnect(hCard, dwDisposition); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardDisconnect, hCard, dwDisposition); } WINSCARDAPI LONG WINAPI SCardBeginTransaction(SCARDHANDLE hCard) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardBeginTransaction) - { - return g_PCSCLite->pfnSCardBeginTransaction(hCard); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardBeginTransaction, hCard); } WINSCARDAPI LONG WINAPI SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardEndTransaction) - { - return g_PCSCLite->pfnSCardEndTransaction(hCard, dwDisposition); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardEndTransaction, hCard, dwDisposition); } WINSCARDAPI LONG WINAPI SCardCancelTransaction(SCARDHANDLE hCard) { - InitializeSCardStubs(); - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardCancelTransaction, hCard); } WINSCARDAPI LONG WINAPI SCardState(SCARDHANDLE hCard, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardState, hCard, pdwState, pdwProtocol, pbAtr, pcbAtrLen); } WINSCARDAPI LONG WINAPI SCardStatusA(SCARDHANDLE hCard, LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardStatus) - { - return g_PCSCLite->pfnSCardStatus(hCard, mszReaderNames, pcchReaderLen, - pdwState, pdwProtocol, pbAtr, pcbAtrLen); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardStatusA, hCard, mszReaderNames, pcchReaderLen, + pdwState, pdwProtocol, pbAtr, pcbAtrLen); } WINSCARDAPI LONG WINAPI SCardStatusW(SCARDHANDLE hCard, LPWSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardStatus) - { - mszReaderNames = NULL; - pcchReaderLen = 0; - - /* FIXME: unicode conversion */ - - return g_PCSCLite->pfnSCardStatus(hCard, (LPSTR) mszReaderNames, pcchReaderLen, - pdwState, pdwProtocol, pbAtr, pcbAtrLen); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardStatusW, hCard, mszReaderNames, pcchReaderLen, + pdwState, pdwProtocol, pbAtr, pcbAtrLen); } WINSCARDAPI LONG WINAPI SCardTransmit(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardTransmit) - { - return g_PCSCLite->pfnSCardTransmit(hCard, pioSendPci, pbSendBuffer, - cbSendLength, pioRecvPci, pbRecvBuffer, pcbRecvLength); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardTransmit, hCard, pioSendPci, pbSendBuffer, cbSendLength, + pioRecvPci, pbRecvBuffer, pcbRecvLength); } WINSCARDAPI LONG WINAPI SCardGetTransmitCount(SCARDHANDLE hCard, LPDWORD pcTransmitCount) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetTransmitCount, hCard, pcTransmitCount); } WINSCARDAPI LONG WINAPI SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardControl) - { - return g_PCSCLite->pfnSCardControl(hCard, - dwControlCode, lpInBuffer, cbInBufferSize, - lpOutBuffer, cbOutBufferSize, lpBytesReturned); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardControl, hCard, dwControlCode, lpInBuffer, cbInBufferSize, + lpOutBuffer, cbOutBufferSize, lpBytesReturned); } WINSCARDAPI LONG WINAPI SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardGetAttrib) - { - return g_PCSCLite->pfnSCardGetAttrib(hCard, dwAttrId, pbAttr, pcbAttrLen); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetAttrib, hCard, dwAttrId, pbAttr, pcbAttrLen); } WINSCARDAPI LONG WINAPI SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen) { - InitializeSCardStubs(); - - if (g_PCSCLite && g_PCSCLite->pfnSCardSetAttrib) - { - return g_PCSCLite->pfnSCardSetAttrib(hCard, dwAttrId, pbAttr, cbAttrLen); - } - - return 0; + SCARDAPI_STUB_CALL_LONG(SCardSetAttrib, hCard, dwAttrId, pbAttr, cbAttrLen); } WINSCARDAPI LONG WINAPI SCardUIDlgSelectCardA(LPOPENCARDNAMEA_EX pDlgStruc) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardUIDlgSelectCardA, pDlgStruc); } + WINSCARDAPI LONG WINAPI SCardUIDlgSelectCardW(LPOPENCARDNAMEW_EX pDlgStruc) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardUIDlgSelectCardW, pDlgStruc); } WINSCARDAPI LONG WINAPI GetOpenCardNameA(LPOPENCARDNAMEA pDlgStruc) { - return 0; + SCARDAPI_STUB_CALL_LONG(GetOpenCardNameA, pDlgStruc); } + WINSCARDAPI LONG WINAPI GetOpenCardNameW(LPOPENCARDNAMEW pDlgStruc) { - return 0; + SCARDAPI_STUB_CALL_LONG(GetOpenCardNameW, pDlgStruc); } WINSCARDAPI LONG WINAPI SCardDlgExtendedError(void) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardDlgExtendedError); } WINSCARDAPI LONG WINAPI SCardReadCacheA(SCARDCONTEXT hContext, UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data, DWORD* DataLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardReadCacheA, hContext, CardIdentifier, + FreshnessCounter, LookupName, Data, DataLen); } + WINSCARDAPI LONG WINAPI SCardReadCacheW(SCARDCONTEXT hContext, UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data, DWORD* DataLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardReadCacheW, hContext, CardIdentifier, + FreshnessCounter, LookupName, Data, DataLen); } WINSCARDAPI LONG WINAPI SCardWriteCacheA(SCARDCONTEXT hContext, UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data, DWORD DataLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardWriteCacheA, hContext, CardIdentifier, + FreshnessCounter, LookupName, Data, DataLen); } + WINSCARDAPI LONG WINAPI SCardWriteCacheW(SCARDCONTEXT hContext, UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data, DWORD DataLen) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardWriteCacheW, hContext, CardIdentifier, + FreshnessCounter, LookupName, Data, DataLen); } WINSCARDAPI LONG WINAPI SCardGetReaderIconA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetReaderIconA, hContext, szReaderName, pbIcon, pcbIcon); } + WINSCARDAPI LONG WINAPI SCardGetReaderIconW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetReaderIconW, hContext, szReaderName, pbIcon, pcbIcon); } WINSCARDAPI LONG WINAPI SCardGetDeviceTypeIdA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPDWORD pdwDeviceTypeId) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetDeviceTypeIdA, hContext, szReaderName, pdwDeviceTypeId); } + WINSCARDAPI LONG WINAPI SCardGetDeviceTypeIdW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPDWORD pdwDeviceTypeId) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetDeviceTypeIdW, hContext, szReaderName, pdwDeviceTypeId); } WINSCARDAPI LONG WINAPI SCardGetReaderDeviceInstanceIdA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPSTR szDeviceInstanceId, LPDWORD pcchDeviceInstanceId) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetReaderDeviceInstanceIdA, hContext, szReaderName, + szDeviceInstanceId, pcchDeviceInstanceId); } + WINSCARDAPI LONG WINAPI SCardGetReaderDeviceInstanceIdW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPWSTR szDeviceInstanceId, LPDWORD pcchDeviceInstanceId) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardGetReaderDeviceInstanceIdW, hContext, szReaderName, + szDeviceInstanceId, pcchDeviceInstanceId); } WINSCARDAPI LONG WINAPI SCardListReadersWithDeviceInstanceIdA(SCARDCONTEXT hContext, LPCSTR szDeviceInstanceId, LPSTR mszReaders, LPDWORD pcchReaders) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListReadersWithDeviceInstanceIdA, + hContext, szDeviceInstanceId, mszReaders, pcchReaders); } + WINSCARDAPI LONG WINAPI SCardListReadersWithDeviceInstanceIdW(SCARDCONTEXT hContext, LPCWSTR szDeviceInstanceId, LPWSTR mszReaders, LPDWORD pcchReaders) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardListReadersWithDeviceInstanceIdW, + hContext, szDeviceInstanceId, mszReaders, pcchReaders); } WINSCARDAPI LONG WINAPI SCardAudit(SCARDCONTEXT hContext, DWORD dwEvent) { - return 0; + SCARDAPI_STUB_CALL_LONG(SCardAudit, hContext, dwEvent); } -#endif - /** * Extended API */ @@ -909,3 +639,13 @@ WINSCARDAPI const char* WINAPI SCardGetErrorString(LONG errorCode) return "SCARD_E_UNKNOWN"; } + +void InitializeSCardApiStubs(void) +{ + g_Initialized = TRUE; + + if (PCSC_InitializeSCardApi() >= 0) + { + g_SCardApi = PCSC_GetSCardApiFunctionTable(); + } +} diff --git a/winpr/libwinpr/smartcard/smartcard.h b/winpr/libwinpr/smartcard/smartcard.h index 2482badb7..d44125b5c 100644 --- a/winpr/libwinpr/smartcard/smartcard.h +++ b/winpr/libwinpr/smartcard/smartcard.h @@ -22,4 +22,29 @@ #include +#define SCARDAPI_STUB_CALL_LONG(_name, ...) \ + if (!g_Initialized) \ + InitializeSCardApiStubs(); \ + if (!g_SCardApi || !g_SCardApi->pfn ## _name) \ + return 0; \ + return g_SCardApi->pfn ## _name ( __VA_ARGS__ ) + +#define SCARDAPI_STUB_CALL_HANDLE(_name, ...) \ + if (!g_Initialized) \ + InitializeSCardApiStubs(); \ + if (!g_SCardApi || !g_SCardApi->pfn ## _name) \ + return NULL; \ + return g_SCardApi->pfn ## _name ( __VA_ARGS__ ) + +#define SCARDAPI_STUB_CALL_VOID(_name, ...) \ + if (!g_Initialized) \ + InitializeSCardApiStubs(); \ + if (!g_SCardApi || !g_SCardApi->pfn ## _name) \ + return; \ + g_SCardApi->pfn ## _name ( __VA_ARGS__ ) + +void InitializeSCardApiStubs(void); + +#include "smartcard_pcsc.h" + #endif /* WINPR_SMARTCARD_PRIVATE_H */ diff --git a/winpr/libwinpr/smartcard/smartcard_pcsc.c b/winpr/libwinpr/smartcard/smartcard_pcsc.c new file mode 100644 index 000000000..1b2cdd2a5 --- /dev/null +++ b/winpr/libwinpr/smartcard/smartcard_pcsc.c @@ -0,0 +1,743 @@ +/** + * WinPR: Windows Portable Runtime + * Smart Card API + * + * Copyright 2014 Marc-Andre Moreau + * + * 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. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include + +#include "smartcard_pcsc.h" + +static HMODULE g_PCSCModule = NULL; +static PCSCFunctionTable g_PCSC = { 0 }; + +/** + * Standard Windows Smart Card API (PCSC) + */ + +WINSCARDAPI LONG WINAPI PCSC_SCardEstablishContext(DWORD dwScope, + LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext) +{ + if (g_PCSC.pfnSCardEstablishContext) + { + return g_PCSC.pfnSCardEstablishContext(dwScope, pvReserved1, pvReserved2, phContext); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardReleaseContext(SCARDCONTEXT hContext) +{ + if (g_PCSC.pfnSCardReleaseContext) + { + return g_PCSC.pfnSCardReleaseContext(hContext); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIsValidContext(SCARDCONTEXT hContext) +{ + if (g_PCSC.pfnSCardIsValidContext) + { + return g_PCSC.pfnSCardIsValidContext(hContext); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsA(SCARDCONTEXT hContext, + LPSTR mszGroups, LPDWORD pcchGroups) +{ + if (g_PCSC.pfnSCardListReaderGroups) + { + return g_PCSC.pfnSCardListReaderGroups(hContext, mszGroups, pcchGroups); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsW(SCARDCONTEXT hContext, + LPWSTR mszGroups, LPDWORD pcchGroups) +{ + if (g_PCSC.pfnSCardListReaderGroups) + { + mszGroups = NULL; + pcchGroups = 0; + + /* FIXME: unicode conversion */ + + return g_PCSC.pfnSCardListReaderGroups(hContext, (LPSTR) mszGroups, pcchGroups); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListReadersA(SCARDCONTEXT hContext, + LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders) +{ + if (g_PCSC.pfnSCardListReaders) + { + return g_PCSC.pfnSCardListReaders(hContext, mszGroups, mszReaders, pcchReaders); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListReadersW(SCARDCONTEXT hContext, + LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders) +{ + if (g_PCSC.pfnSCardListReaders) + { + mszGroups = NULL; + + mszReaders = NULL; + pcchReaders = 0; + + /* FIXME: unicode conversion */ + + return g_PCSC.pfnSCardListReaders(hContext, (LPSTR) mszGroups, (LPSTR) mszReaders, pcchReaders); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListCardsA(SCARDCONTEXT hContext, + LPCBYTE pbAtr, LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount, CHAR* mszCards, LPDWORD pcchCards) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListCardsW(SCARDCONTEXT hContext, + LPCBYTE pbAtr, LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount, WCHAR* mszCards, LPDWORD pcchCards) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListInterfacesA(SCARDCONTEXT hContext, + LPCSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListInterfacesW(SCARDCONTEXT hContext, + LPCWSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetProviderIdA(SCARDCONTEXT hContext, + LPCSTR szCard, LPGUID pguidProviderId) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetProviderIdW(SCARDCONTEXT hContext, + LPCWSTR szCard, LPGUID pguidProviderId) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetCardTypeProviderNameA(SCARDCONTEXT hContext, + LPCSTR szCardName, DWORD dwProviderId, CHAR* szProvider, LPDWORD pcchProvider) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetCardTypeProviderNameW(SCARDCONTEXT hContext, + LPCWSTR szCardName, DWORD dwProviderId, WCHAR* szProvider, LPDWORD pcchProvider) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderA(SCARDCONTEXT hContext, + LPCSTR szReaderName, LPCSTR szDeviceName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderW(SCARDCONTEXT hContext, + LPCWSTR szReaderName, LPCWSTR szDeviceName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardAddReaderToGroupA(SCARDCONTEXT hContext, + LPCSTR szReaderName, LPCSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardAddReaderToGroupW(SCARDCONTEXT hContext, + LPCWSTR szReaderName, LPCWSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardRemoveReaderFromGroupA(SCARDCONTEXT hContext, + LPCSTR szReaderName, LPCSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardRemoveReaderFromGroupW(SCARDCONTEXT hContext, + LPCWSTR szReaderName, LPCWSTR szGroupName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceCardTypeA(SCARDCONTEXT hContext, + LPCSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces, + DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceCardTypeW(SCARDCONTEXT hContext, + LPCWSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces, + DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardSetCardTypeProviderNameA(SCARDCONTEXT hContext, + LPCSTR szCardName, DWORD dwProviderId, LPCSTR szProvider) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardSetCardTypeProviderNameW(SCARDCONTEXT hContext, + LPCWSTR szCardName, DWORD dwProviderId, LPCWSTR szProvider) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardForgetCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardForgetCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardFreeMemory(SCARDCONTEXT hContext, LPCVOID pvMem) +{ + if (g_PCSC.pfnSCardFreeMemory) + { + return g_PCSC.pfnSCardFreeMemory(hContext, pvMem); + } + + return 0; +} + +WINSCARDAPI HANDLE WINAPI PCSC_SCardAccessStartedEvent(void) +{ + return 0; +} + +WINSCARDAPI void WINAPI PCSC_SCardReleaseStartedEvent(void) +{ + +} + +WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsA(SCARDCONTEXT hContext, + LPCSTR mszCards, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsW(SCARDCONTEXT hContext, + LPCWSTR mszCards, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsByATRA(SCARDCONTEXT hContext, + LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsByATRW(SCARDCONTEXT hContext, + LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChangeA(SCARDCONTEXT hContext, + DWORD dwTimeout, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders) +{ + if (g_PCSC.pfnSCardGetStatusChange) + { + return g_PCSC.pfnSCardGetStatusChange(hContext, dwTimeout, rgReaderStates, cReaders); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChangeW(SCARDCONTEXT hContext, + DWORD dwTimeout, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) +{ + if (g_PCSC.pfnSCardGetStatusChange) + { + SCARD_READERSTATEA rgReaderStatesA; + + cReaders = 0; + ZeroMemory(&rgReaderStatesA, sizeof(SCARD_READERSTATEA)); + + /* FIXME: unicode conversion */ + return g_PCSC.pfnSCardGetStatusChange(hContext, dwTimeout, &rgReaderStatesA, cReaders); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardCancel(SCARDCONTEXT hContext) +{ + if (g_PCSC.pfnSCardCancel) + { + return g_PCSC.pfnSCardCancel(hContext); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardConnectA(SCARDCONTEXT hContext, + LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, + LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol) +{ + if (g_PCSC.pfnSCardConnect) + { + return g_PCSC.pfnSCardConnect(hContext, szReader, + dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardConnectW(SCARDCONTEXT hContext, + LPCWSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, + LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol) +{ + if (g_PCSC.pfnSCardConnect) + { + LONG status; + LPSTR szReaderA = NULL; + + if (szReader) + ConvertFromUnicode(CP_UTF8, 0, szReader, -1, &szReaderA, 0, NULL, NULL); + + status = g_PCSC.pfnSCardConnect(hContext, szReaderA, + dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); + + free(szReaderA); + + return status; + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardReconnect(SCARDHANDLE hCard, + DWORD dwShareMode, DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol) +{ + if (g_PCSC.pfnSCardReconnect) + { + return g_PCSC.pfnSCardReconnect(hCard, dwShareMode, + dwPreferredProtocols, dwInitialization, pdwActiveProtocol); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition) +{ + if (g_PCSC.pfnSCardDisconnect) + { + return g_PCSC.pfnSCardDisconnect(hCard, dwDisposition); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardBeginTransaction(SCARDHANDLE hCard) +{ + if (g_PCSC.pfnSCardBeginTransaction) + { + return g_PCSC.pfnSCardBeginTransaction(hCard); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition) +{ + if (g_PCSC.pfnSCardEndTransaction) + { + return g_PCSC.pfnSCardEndTransaction(hCard, dwDisposition); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardCancelTransaction(SCARDHANDLE hCard) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardState(SCARDHANDLE hCard, + LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardStatusA(SCARDHANDLE hCard, + LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState, + LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) +{ + if (g_PCSC.pfnSCardStatus) + { + return g_PCSC.pfnSCardStatus(hCard, mszReaderNames, pcchReaderLen, + pdwState, pdwProtocol, pbAtr, pcbAtrLen); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardStatusW(SCARDHANDLE hCard, + LPWSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState, + LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) +{ + if (g_PCSC.pfnSCardStatus) + { + mszReaderNames = NULL; + pcchReaderLen = 0; + + /* FIXME: unicode conversion */ + + return g_PCSC.pfnSCardStatus(hCard, (LPSTR) mszReaderNames, pcchReaderLen, + pdwState, pdwProtocol, pbAtr, pcbAtrLen); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardTransmit(SCARDHANDLE hCard, + LPCSCARD_IO_REQUEST pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, + LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength) +{ + if (g_PCSC.pfnSCardTransmit) + { + return g_PCSC.pfnSCardTransmit(hCard, pioSendPci, pbSendBuffer, + cbSendLength, pioRecvPci, pbRecvBuffer, pcbRecvLength); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetTransmitCount(SCARDHANDLE hCard, LPDWORD pcTransmitCount) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardControl(SCARDHANDLE hCard, + DWORD dwControlCode, LPCVOID lpInBuffer, DWORD cbInBufferSize, + LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned) +{ + if (g_PCSC.pfnSCardControl) + { + return g_PCSC.pfnSCardControl(hCard, + dwControlCode, lpInBuffer, cbInBufferSize, + lpOutBuffer, cbOutBufferSize, lpBytesReturned); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen) +{ + if (g_PCSC.pfnSCardGetAttrib) + { + return g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, pbAttr, pcbAttrLen); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen) +{ + if (g_PCSC.pfnSCardSetAttrib) + { + return g_PCSC.pfnSCardSetAttrib(hCard, dwAttrId, pbAttr, cbAttrLen); + } + + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardUIDlgSelectCardA(LPOPENCARDNAMEA_EX pDlgStruc) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardUIDlgSelectCardW(LPOPENCARDNAMEW_EX pDlgStruc) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_GetOpenCardNameA(LPOPENCARDNAMEA pDlgStruc) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_GetOpenCardNameW(LPOPENCARDNAMEW pDlgStruc) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardDlgExtendedError(void) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardReadCacheA(SCARDCONTEXT hContext, + UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data, DWORD* DataLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardReadCacheW(SCARDCONTEXT hContext, + UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data, DWORD* DataLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardWriteCacheA(SCARDCONTEXT hContext, + UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data, DWORD DataLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardWriteCacheW(SCARDCONTEXT hContext, + UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data, DWORD DataLen) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderIconA(SCARDCONTEXT hContext, + LPCSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderIconW(SCARDCONTEXT hContext, + LPCWSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetDeviceTypeIdA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPDWORD pdwDeviceTypeId) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetDeviceTypeIdW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPDWORD pdwDeviceTypeId) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderDeviceInstanceIdA(SCARDCONTEXT hContext, + LPCSTR szReaderName, LPSTR szDeviceInstanceId, LPDWORD pcchDeviceInstanceId) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderDeviceInstanceIdW(SCARDCONTEXT hContext, + LPCWSTR szReaderName, LPWSTR szDeviceInstanceId, LPDWORD pcchDeviceInstanceId) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListReadersWithDeviceInstanceIdA(SCARDCONTEXT hContext, + LPCSTR szDeviceInstanceId, LPSTR mszReaders, LPDWORD pcchReaders) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardListReadersWithDeviceInstanceIdW(SCARDCONTEXT hContext, + LPCWSTR szDeviceInstanceId, LPWSTR mszReaders, LPDWORD pcchReaders) +{ + return 0; +} + +WINSCARDAPI LONG WINAPI PCSC_SCardAudit(SCARDCONTEXT hContext, DWORD dwEvent) +{ + return 0; +} + +SCardApiFunctionTable PCSC_SCardApiFunctionTable = +{ + 0, /* dwVersion */ + 0, /* dwFlags */ + + PCSC_SCardEstablishContext, /* SCardEstablishContext */ + PCSC_SCardReleaseContext, /* SCardReleaseContext */ + PCSC_SCardIsValidContext, /* SCardIsValidContext */ + PCSC_SCardListReaderGroupsA, /* SCardListReaderGroupsA */ + PCSC_SCardListReaderGroupsW, /* SCardListReaderGroupsW */ + PCSC_SCardListReadersA, /* SCardListReadersA */ + PCSC_SCardListReadersW, /* SCardListReadersW */ + PCSC_SCardListCardsA, /* SCardListCardsA */ + PCSC_SCardListCardsW, /* SCardListCardsW */ + PCSC_SCardListInterfacesA, /* SCardListInterfacesA */ + PCSC_SCardListInterfacesW, /* SCardListInterfacesW */ + PCSC_SCardGetProviderIdA, /* SCardGetProviderIdA */ + PCSC_SCardGetProviderIdW, /* SCardGetProviderIdW */ + PCSC_SCardGetCardTypeProviderNameA, /* SCardGetCardTypeProviderNameA */ + PCSC_SCardGetCardTypeProviderNameW, /* SCardGetCardTypeProviderNameW */ + PCSC_SCardIntroduceReaderGroupA, /* SCardIntroduceReaderGroupA */ + PCSC_SCardIntroduceReaderGroupW, /* SCardIntroduceReaderGroupW */ + PCSC_SCardForgetReaderGroupA, /* SCardForgetReaderGroupA */ + PCSC_SCardForgetReaderGroupW, /* SCardForgetReaderGroupW */ + PCSC_SCardIntroduceReaderA, /* SCardIntroduceReaderA */ + PCSC_SCardIntroduceReaderW, /* SCardIntroduceReaderW */ + PCSC_SCardForgetReaderA, /* SCardForgetReaderA */ + PCSC_SCardForgetReaderW, /* SCardForgetReaderW */ + PCSC_SCardAddReaderToGroupA, /* SCardAddReaderToGroupA */ + PCSC_SCardAddReaderToGroupW, /* SCardAddReaderToGroupW */ + PCSC_SCardRemoveReaderFromGroupA, /* SCardRemoveReaderFromGroupA */ + PCSC_SCardRemoveReaderFromGroupW, /* SCardRemoveReaderFromGroupW */ + PCSC_SCardIntroduceCardTypeA, /* SCardIntroduceCardTypeA */ + PCSC_SCardIntroduceCardTypeW, /* SCardIntroduceCardTypeW */ + PCSC_SCardSetCardTypeProviderNameA, /* SCardSetCardTypeProviderNameA */ + PCSC_SCardSetCardTypeProviderNameW, /* SCardSetCardTypeProviderNameW */ + PCSC_SCardForgetCardTypeA, /* SCardForgetCardTypeA */ + PCSC_SCardForgetCardTypeW, /* SCardForgetCardTypeW */ + PCSC_SCardFreeMemory, /* SCardFreeMemory */ + PCSC_SCardAccessStartedEvent, /* SCardAccessStartedEvent */ + PCSC_SCardReleaseStartedEvent, /* SCardReleaseStartedEvent */ + PCSC_SCardLocateCardsA, /* SCardLocateCardsA */ + PCSC_SCardLocateCardsW, /* SCardLocateCardsW */ + PCSC_SCardLocateCardsByATRA, /* SCardLocateCardsByATRA */ + PCSC_SCardLocateCardsByATRW, /* SCardLocateCardsByATRW */ + PCSC_SCardGetStatusChangeA, /* SCardGetStatusChangeA */ + PCSC_SCardGetStatusChangeW, /* SCardGetStatusChangeW */ + PCSC_SCardCancel, /* SCardCancel */ + PCSC_SCardConnectA, /* SCardConnectA */ + PCSC_SCardConnectW, /* SCardConnectW */ + PCSC_SCardReconnect, /* SCardReconnect */ + PCSC_SCardDisconnect, /* SCardDisconnect */ + PCSC_SCardBeginTransaction, /* SCardBeginTransaction */ + PCSC_SCardEndTransaction, /* SCardEndTransaction */ + PCSC_SCardCancelTransaction, /* SCardCancelTransaction */ + PCSC_SCardState, /* SCardState */ + PCSC_SCardStatusA, /* SCardStatusA */ + PCSC_SCardStatusW, /* SCardStatusW */ + PCSC_SCardTransmit, /* SCardTransmit */ + PCSC_SCardGetTransmitCount, /* SCardGetTransmitCount */ + PCSC_SCardControl, /* SCardControl */ + PCSC_SCardGetAttrib, /* SCardGetAttrib */ + PCSC_SCardSetAttrib, /* SCardSetAttrib */ + PCSC_SCardUIDlgSelectCardA, /* SCardUIDlgSelectCardA */ + PCSC_SCardUIDlgSelectCardW, /* SCardUIDlgSelectCardW */ + PCSC_GetOpenCardNameA, /* GetOpenCardNameA */ + PCSC_GetOpenCardNameW, /* GetOpenCardNameW */ + PCSC_SCardDlgExtendedError, /* SCardDlgExtendedError */ + PCSC_SCardReadCacheA, /* SCardReadCacheA */ + PCSC_SCardReadCacheW, /* SCardReadCacheW */ + PCSC_SCardWriteCacheA, /* SCardWriteCacheA */ + PCSC_SCardWriteCacheW, /* SCardWriteCacheW */ + PCSC_SCardGetReaderIconA, /* SCardGetReaderIconA */ + PCSC_SCardGetReaderIconW, /* SCardGetReaderIconW */ + PCSC_SCardGetDeviceTypeIdA, /* SCardGetDeviceTypeIdA */ + PCSC_SCardGetDeviceTypeIdW, /* SCardGetDeviceTypeIdW */ + PCSC_SCardGetReaderDeviceInstanceIdA, /* SCardGetReaderDeviceInstanceIdA */ + PCSC_SCardGetReaderDeviceInstanceIdW, /* SCardGetReaderDeviceInstanceIdW */ + PCSC_SCardListReadersWithDeviceInstanceIdA, /* SCardListReadersWithDeviceInstanceIdA */ + PCSC_SCardListReadersWithDeviceInstanceIdW, /* SCardListReadersWithDeviceInstanceIdW */ + PCSC_SCardAudit /* SCardAudit */ +}; + +PSCardApiFunctionTable PCSC_GetSCardApiFunctionTable(void) +{ + return &PCSC_SCardApiFunctionTable; +} + +int PCSC_InitializeSCardApi(void) +{ + g_PCSCModule = LoadLibraryA("libpcsclite.so"); + + if (!g_PCSCModule) + return -1; + + g_PCSC.pfnSCardEstablishContext = GetProcAddress(g_PCSCModule, "SCardEstablishContext"); + g_PCSC.pfnSCardReleaseContext = GetProcAddress(g_PCSCModule, "SCardReleaseContext"); + g_PCSC.pfnSCardIsValidContext = GetProcAddress(g_PCSCModule, "SCardIsValidContext"); + g_PCSC.pfnSCardConnect = GetProcAddress(g_PCSCModule, "SCardConnect"); + g_PCSC.pfnSCardReconnect = GetProcAddress(g_PCSCModule, "SCardReconnect"); + g_PCSC.pfnSCardDisconnect = GetProcAddress(g_PCSCModule, "SCardDisconnect"); + g_PCSC.pfnSCardBeginTransaction = GetProcAddress(g_PCSCModule, "SCardBeginTransaction"); + g_PCSC.pfnSCardEndTransaction = GetProcAddress(g_PCSCModule, "SCardEndTransaction"); + g_PCSC.pfnSCardStatus = GetProcAddress(g_PCSCModule, "SCardStatus"); + g_PCSC.pfnSCardGetStatusChange = GetProcAddress(g_PCSCModule, "SCardGetStatusChange"); + g_PCSC.pfnSCardControl = GetProcAddress(g_PCSCModule, "SCardControl"); + g_PCSC.pfnSCardTransmit = GetProcAddress(g_PCSCModule, "SCardTransmit"); + g_PCSC.pfnSCardListReaderGroups = GetProcAddress(g_PCSCModule, "SCardListReaderGroups"); + g_PCSC.pfnSCardListReaders = GetProcAddress(g_PCSCModule, "SCardListReaders"); + g_PCSC.pfnSCardFreeMemory = GetProcAddress(g_PCSCModule, "SCardFreeMemory"); + g_PCSC.pfnSCardCancel = GetProcAddress(g_PCSCModule, "SCardCancel"); + g_PCSC.pfnSCardGetAttrib = GetProcAddress(g_PCSCModule, "SCardGetAttrib"); + g_PCSC.pfnSCardSetAttrib = GetProcAddress(g_PCSCModule, "SCardSetAttrib"); + + return 1; +} diff --git a/winpr/libwinpr/smartcard/smartcard_pcsc.h b/winpr/libwinpr/smartcard/smartcard_pcsc.h new file mode 100644 index 000000000..cea795d08 --- /dev/null +++ b/winpr/libwinpr/smartcard/smartcard_pcsc.h @@ -0,0 +1,63 @@ +/** + * WinPR: Windows Portable Runtime + * Smart Card API + * + * Copyright 2014 Marc-Andre Moreau + * + * 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_PCSC_PRIVATE_H +#define WINPR_SMARTCARD_PCSC_PRIVATE_H + +#include + +struct _PCSCFunctionTable +{ + LONG (* pfnSCardEstablishContext)(DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext); + LONG (* pfnSCardReleaseContext)(SCARDCONTEXT hContext); + LONG (* pfnSCardIsValidContext)(SCARDCONTEXT hContext); + LONG (* pfnSCardConnect)(SCARDCONTEXT hContext, + LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, + LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol); + LONG (* pfnSCardReconnect)(SCARDHANDLE hCard, + DWORD dwShareMode, DWORD dwPreferredProtocols, + DWORD dwInitialization, LPDWORD pdwActiveProtocol); + LONG (* pfnSCardDisconnect)(SCARDHANDLE hCard, DWORD dwDisposition); + LONG (* pfnSCardBeginTransaction)(SCARDHANDLE hCard); + LONG (* pfnSCardEndTransaction)(SCARDHANDLE hCard, DWORD dwDisposition); + LONG (* pfnSCardStatus)(SCARDHANDLE hCard, + LPSTR mszReaderName, LPDWORD pcchReaderLen, LPDWORD pdwState, + LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen); + LONG (* pfnSCardGetStatusChange)(SCARDCONTEXT hContext, + DWORD dwTimeout, LPSCARD_READERSTATE rgReaderStates, DWORD cReaders); + LONG (* pfnSCardControl)(SCARDHANDLE hCard, + DWORD dwControlCode, LPCVOID pbSendBuffer, DWORD cbSendLength, + LPVOID pbRecvBuffer, DWORD cbRecvLength, LPDWORD lpBytesReturned); + LONG (* pfnSCardTransmit)(SCARDHANDLE hCard, + const SCARD_IO_REQUEST* pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, + SCARD_IO_REQUEST* pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength); + LONG (* pfnSCardListReaderGroups)(SCARDCONTEXT hContext, LPSTR mszGroups, LPDWORD pcchGroups); + LONG (* pfnSCardListReaders)(SCARDCONTEXT hContext, + LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders); + LONG (* pfnSCardFreeMemory)(SCARDCONTEXT hContext, LPCVOID pvMem); + LONG (* pfnSCardCancel)(SCARDCONTEXT hContext); + LONG (* pfnSCardGetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen); + LONG (* pfnSCardSetAttrib)(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen); +}; +typedef struct _PCSCFunctionTable PCSCFunctionTable; + +int PCSC_InitializeSCardApi(void); +PSCardApiFunctionTable PCSC_GetSCardApiFunctionTable(void); + +#endif /* WINPR_SMARTCARD_PCSC_PRIVATE_H */