diff --git a/channels/smartcard/client/CMakeLists.txt b/channels/smartcard/client/CMakeLists.txt index c7c2507f3..d7aaa8a69 100644 --- a/channels/smartcard/client/CMakeLists.txt +++ b/channels/smartcard/client/CMakeLists.txt @@ -36,7 +36,7 @@ set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS MONOLITHIC ${MONOLITHIC_BUILD} MODULE winpr - MODULES winpr-crt winpr-smartcard winpr-synch winpr-thread winpr-interlocked winpr-utils) + MODULES winpr-crt winpr-smartcard winpr-synch winpr-thread winpr-interlocked winpr-environment winpr-utils) target_link_libraries(${MODULE_NAME} ${${MODULE_PREFIX}_LIBS}) diff --git a/channels/smartcard/client/smartcard_main.c b/channels/smartcard/client/smartcard_main.c index abc823822..5a694b4a3 100644 --- a/channels/smartcard/client/smartcard_main.c +++ b/channels/smartcard/client/smartcard_main.c @@ -29,12 +29,39 @@ #include #include +#include #include #include "smartcard_main.h" -#define SMARTCARD_ASYNC_IRP 1 +static BOOL g_SmartCardAsync = TRUE; + +int smartcard_environment_init() +{ + DWORD nSize; + char* envSmartCardAsync; + + nSize = GetEnvironmentVariableA("FREERDP_SMARTCARD_ASYNC", NULL, 0); + + if (nSize) + { + envSmartCardAsync = (LPSTR) malloc(nSize); + nSize = GetEnvironmentVariableA("FREERDP_SMARTCARD_ASYNC", envSmartCardAsync, nSize); + + if (envSmartCardAsync) + { + if (_stricmp(envSmartCardAsync, "0") == 0) + g_SmartCardAsync = FALSE; + else + g_SmartCardAsync = TRUE; + + free(envSmartCardAsync); + } + } + + return 0; +} static void smartcard_free(DEVICE* device) { @@ -129,28 +156,29 @@ void smartcard_process_irp(SMARTCARD_DEVICE* smartcard, IRP* irp) if (!ioControlCode) return; -#ifdef SMARTCARD_ASYNC_IRP - asyncIrp = TRUE; - - switch (ioControlCode) + if (g_SmartCardAsync) { - case SCARD_IOCTL_ESTABLISHCONTEXT: - case SCARD_IOCTL_RELEASECONTEXT: - case SCARD_IOCTL_ISVALIDCONTEXT: - case SCARD_IOCTL_ACCESSSTARTEDEVENT: - case SCARD_IOCTL_RELEASESTARTEDEVENT: - asyncIrp = FALSE; - break; + asyncIrp = TRUE; - case SCARD_IOCTL_TRANSMIT: - case SCARD_IOCTL_STATUSA: - case SCARD_IOCTL_STATUSW: - case SCARD_IOCTL_GETSTATUSCHANGEA: - case SCARD_IOCTL_GETSTATUSCHANGEW: - asyncIrp = TRUE; - break; + switch (ioControlCode) + { + case SCARD_IOCTL_ESTABLISHCONTEXT: + case SCARD_IOCTL_RELEASECONTEXT: + case SCARD_IOCTL_ISVALIDCONTEXT: + case SCARD_IOCTL_ACCESSSTARTEDEVENT: + case SCARD_IOCTL_RELEASESTARTEDEVENT: + asyncIrp = FALSE; + break; + + case SCARD_IOCTL_TRANSMIT: + case SCARD_IOCTL_STATUSA: + case SCARD_IOCTL_STATUSW: + case SCARD_IOCTL_GETSTATUSCHANGEA: + case SCARD_IOCTL_GETSTATUSCHANGEW: + asyncIrp = TRUE; + break; + } } -#endif if (!asyncIrp) { @@ -221,6 +249,8 @@ int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints) name = device->Name; path = device->Path; + smartcard_environment_init(); + smartcard = (SMARTCARD_DEVICE*) calloc(1, sizeof(SMARTCARD_DEVICE)); if (!smartcard) @@ -255,7 +285,7 @@ int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints) smartcard->log = WLog_Get("com.freerdp.channel.smartcard.client"); - //WLog_SetLogLevel(smartcard->log, WLOG_DEBUG); + WLog_SetLogLevel(smartcard->log, WLOG_DEBUG); smartcard->IrpQueue = MessageQueue_New(NULL); smartcard->OutstandingIrps = ListDictionary_New(TRUE); diff --git a/winpr/libwinpr/smartcard/smartcard_pcsc.c b/winpr/libwinpr/smartcard/smartcard_pcsc.c index dfc38f818..54cb474b8 100644 --- a/winpr/libwinpr/smartcard/smartcard_pcsc.c +++ b/winpr/libwinpr/smartcard/smartcard_pcsc.c @@ -653,13 +653,14 @@ WINSCARDAPI LONG WINAPI PCSC_SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwScope = (PCSC_DWORD) dwScope; if (!g_PCSC.pfnSCardEstablishContext) return SCARD_E_NO_SERVICE; - dwScope = SCARD_SCOPE_SYSTEM; /* this is the only scope supported by pcsc-lite */ + pcsc_dwScope = SCARD_SCOPE_SYSTEM; /* this is the only scope supported by pcsc-lite */ - status = g_PCSC.pfnSCardEstablishContext(dwScope, pvReserved1, pvReserved2, phContext); + status = (LONG) g_PCSC.pfnSCardEstablishContext(pcsc_dwScope, pvReserved1, pvReserved2, phContext); status = PCSC_MapErrorCodeToWinSCard(status); if (!status) @@ -675,7 +676,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardReleaseContext(SCARDCONTEXT hContext) if (!g_PCSC.pfnSCardReleaseContext) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardReleaseContext(hContext); + status = (LONG) g_PCSC.pfnSCardReleaseContext(hContext); status = PCSC_MapErrorCodeToWinSCard(status); if (!status) @@ -691,7 +692,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardIsValidContext(SCARDCONTEXT hContext) if (!g_PCSC.pfnSCardIsValidContext) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardIsValidContext(hContext); + status = (LONG) g_PCSC.pfnSCardIsValidContext(hContext); status = PCSC_MapErrorCodeToWinSCard(status); return status; @@ -701,6 +702,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsA(SCARDCONTEXT hContext, LPSTR mszGroups, LPDWORD pcchGroups) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_cchGroups = (PCSC_DWORD) *pcchGroups; if (!g_PCSC.pfnSCardListReaderGroups) return SCARD_E_NO_SERVICE; @@ -708,9 +710,11 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsA(SCARDCONTEXT hContext, if (!PCSC_LockCardContext(hContext)) return SCARD_E_INVALID_HANDLE; - status = g_PCSC.pfnSCardListReaderGroups(hContext, mszGroups, pcchGroups); + status = (LONG) g_PCSC.pfnSCardListReaderGroups(hContext, mszGroups, &pcsc_cchGroups); status = PCSC_MapErrorCodeToWinSCard(status); + *pcchGroups = (DWORD) pcsc_cchGroups; + if (!PCSC_UnlockCardContext(hContext)) return SCARD_E_INVALID_HANDLE; @@ -721,6 +725,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsW(SCARDCONTEXT hContext, LPWSTR mszGroups, LPDWORD pcchGroups) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_cchGroups = (PCSC_DWORD) *pcchGroups; if (!g_PCSC.pfnSCardListReaderGroups) return SCARD_E_NO_SERVICE; @@ -733,9 +738,11 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsW(SCARDCONTEXT hContext, /* FIXME: unicode conversion */ - status = g_PCSC.pfnSCardListReaderGroups(hContext, (LPSTR) mszGroups, pcchGroups); + status = (LONG) g_PCSC.pfnSCardListReaderGroups(hContext, (LPSTR) mszGroups, &pcsc_cchGroups); status = PCSC_MapErrorCodeToWinSCard(status); + *pcchGroups = (DWORD) pcsc_cchGroups; + if (!PCSC_UnlockCardContext(hContext)) return SCARD_E_INVALID_HANDLE; @@ -747,31 +754,37 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReaders_Internal(SCARDCONTEXT hContext, { LONG status = SCARD_S_SUCCESS; char* mszReadersWinSCard = NULL; - BOOL pcchReadersWrapAlloc = FALSE; + BOOL pcchReadersAlloc = FALSE; LPSTR* pMszReaders = (LPSTR*) mszReaders; + PCSC_DWORD pcsc_cchReaders = 0; + + if (!pcchReaders) + return SCARD_E_INVALID_PARAMETER; if (!g_PCSC.pfnSCardListReaders) return SCARD_E_NO_SERVICE; mszGroups = NULL; /* mszGroups is not supported by pcsc-lite */ - if ((*pcchReaders == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate) - pcchReadersWrapAlloc = TRUE; + if (*pcchReaders == SCARD_AUTOALLOCATE) + pcchReadersAlloc = TRUE; - if (pcchReadersWrapAlloc) + pcsc_cchReaders = pcchReadersAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD) *pcchReaders; + + if (pcchReadersAlloc && !g_SCardAutoAllocate) { - *pcchReaders = 0; + pcsc_cchReaders = 0; - status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, NULL, pcchReaders); + status = (LONG) g_PCSC.pfnSCardListReaders(hContext, mszGroups, NULL, &pcsc_cchReaders); if (status == SCARD_S_SUCCESS) { - *pMszReaders = calloc(1, *pcchReaders); + *pMszReaders = calloc(1, pcsc_cchReaders); if (!*pMszReaders) return SCARD_E_NO_MEMORY; - status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, *pMszReaders, pcchReaders); + status = (LONG) g_PCSC.pfnSCardListReaders(hContext, mszGroups, *pMszReaders, &pcsc_cchReaders); if (status != SCARD_S_SUCCESS) free(*pMszReaders); @@ -781,11 +794,13 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReaders_Internal(SCARDCONTEXT hContext, } else { - status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, mszReaders, pcchReaders); + status = (LONG) g_PCSC.pfnSCardListReaders(hContext, NULL, mszReaders, &pcsc_cchReaders); } status = PCSC_MapErrorCodeToWinSCard(status); + *pcchReaders = (DWORD) pcsc_cchReaders; + if (status == SCARD_S_SUCCESS) { mszReadersWinSCard = PCSC_ConvertReaderNamesToWinSCard(*pMszReaders, pcchReaders); @@ -840,7 +855,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardListReadersW(SCARDCONTEXT hContext, if (mszGroups) ConvertFromUnicode(CP_UTF8, 0, mszGroups, -1, (char**) &mszGroupsA, 0, NULL, NULL); - status = PCSC_SCardListReaders_Internal(hContext, mszGroupsA, (LPTSTR) &mszReadersA, pcchReaders); + status = PCSC_SCardListReaders_Internal(hContext, mszGroupsA, (LPSTR) &mszReadersA, pcchReaders); if (status == SCARD_S_SUCCESS) { @@ -1021,7 +1036,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardFreeMemory_Internal(SCARDCONTEXT hContext, LPC { if (g_PCSC.pfnSCardFreeMemory) { - status = g_PCSC.pfnSCardFreeMemory(hContext, pvMem); + status = (LONG) g_PCSC.pfnSCardFreeMemory(hContext, pvMem); status = PCSC_MapErrorCodeToWinSCard(status); } } @@ -1084,10 +1099,12 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChange_Internal(SCARDCONTEXT hContext int i, j; int* map; DWORD dwEventState; - DWORD cMappedReaders; + PCSC_DWORD cMappedReaders; BOOL stateChanged = FALSE; PCSC_SCARD_READERSTATE* states; LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwTimeout = (PCSC_DWORD) dwTimeout; + PCSC_DWORD pcsc_cReaders = (PCSC_DWORD) cReaders; if (!g_PCSC.pfnSCardGetStatusChange) return SCARD_E_NO_SERVICE; @@ -1106,17 +1123,17 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChange_Internal(SCARDCONTEXT hContext * we have to filter rgReaderStates to exclude the special PnP reader name. */ - map = (int*) calloc(cReaders, sizeof(int)); + map = (int*) calloc(pcsc_cReaders, sizeof(int)); if (!map) return SCARD_E_NO_MEMORY; - states = (PCSC_SCARD_READERSTATE*) calloc(cReaders, sizeof(PCSC_SCARD_READERSTATE)); + states = (PCSC_SCARD_READERSTATE*) calloc(pcsc_cReaders, sizeof(PCSC_SCARD_READERSTATE)); if (!states) return SCARD_E_NO_MEMORY; - for (i = j = 0; i < cReaders; i++) + for (i = j = 0; i < pcsc_cReaders; i++) { if (!g_PnP_Notification) { @@ -1150,7 +1167,10 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChange_Internal(SCARDCONTEXT hContext if (cMappedReaders > 0) { - status = g_PCSC.pfnSCardGetStatusChange(hContext, dwTimeout ? dwTimeout : 1, states, cMappedReaders); + status = (LONG) g_PCSC.pfnSCardGetStatusChange(hContext, + pcsc_dwTimeout ? pcsc_dwTimeout : 1, + states, cMappedReaders); + status = PCSC_MapErrorCodeToWinSCard(status); } else @@ -1158,7 +1178,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChange_Internal(SCARDCONTEXT hContext status = SCARD_S_SUCCESS; } - for (i = 0; i < cReaders; i++) + for (i = 0; i < pcsc_cReaders; i++) { if (map[i] < 0) continue; /* unmapped */ @@ -1283,7 +1303,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardCancel(SCARDCONTEXT hContext) if (!g_PCSC.pfnSCardCancel) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardCancel(hContext); + status = (LONG) g_PCSC.pfnSCardCancel(hContext); status = PCSC_MapErrorCodeToWinSCard(status); return status; @@ -1295,6 +1315,9 @@ WINSCARDAPI LONG WINAPI PCSC_SCardConnect_Internal(SCARDCONTEXT hContext, { char* szReaderPCSC; LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwShareMode = (PCSC_DWORD) dwShareMode; + PCSC_DWORD pcsc_dwPreferredProtocols = 0; + PCSC_DWORD pcsc_dwActiveProtocol = 0; if (!g_PCSC.pfnSCardConnect) return SCARD_E_NO_SERVICE; @@ -1304,16 +1327,16 @@ WINSCARDAPI LONG WINAPI PCSC_SCardConnect_Internal(SCARDCONTEXT hContext, if (!szReaderPCSC) szReaderPCSC = (char*) szReader; - dwPreferredProtocols = PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols); + pcsc_dwPreferredProtocols = (PCSC_DWORD) PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols); - status = g_PCSC.pfnSCardConnect(hContext, szReaderPCSC, - dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol); + status = (LONG) g_PCSC.pfnSCardConnect(hContext, szReaderPCSC, + pcsc_dwShareMode, pcsc_dwPreferredProtocols, phCard, &pcsc_dwActiveProtocol); status = PCSC_MapErrorCodeToWinSCard(status); if (status == SCARD_S_SUCCESS) { PCSC_AddCardHandle(hContext, *phCard); - *pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwActiveProtocol); + *pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD) pcsc_dwActiveProtocol); } return status; @@ -1365,17 +1388,21 @@ WINSCARDAPI LONG WINAPI PCSC_SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode, DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwShareMode = (PCSC_DWORD) dwShareMode; + PCSC_DWORD pcsc_dwPreferredProtocols = 0; + PCSC_DWORD pcsc_dwInitialization = (PCSC_DWORD) dwInitialization; + PCSC_DWORD pcsc_dwActiveProtocol = 0; if (!g_PCSC.pfnSCardReconnect) return SCARD_E_NO_SERVICE; - dwPreferredProtocols = PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols); + pcsc_dwPreferredProtocols = (PCSC_DWORD) PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols); - status = g_PCSC.pfnSCardReconnect(hCard, dwShareMode, - dwPreferredProtocols, dwInitialization, pdwActiveProtocol); + status = (LONG) g_PCSC.pfnSCardReconnect(hCard, pcsc_dwShareMode, + pcsc_dwPreferredProtocols, pcsc_dwInitialization, &pcsc_dwActiveProtocol); status = PCSC_MapErrorCodeToWinSCard(status); - *pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwActiveProtocol); + *pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD) pcsc_dwActiveProtocol); return status; } @@ -1383,11 +1410,12 @@ WINSCARDAPI LONG WINAPI PCSC_SCardReconnect(SCARDHANDLE hCard, WINSCARDAPI LONG WINAPI PCSC_SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwDisposition = (PCSC_DWORD) dwDisposition; if (!g_PCSC.pfnSCardDisconnect) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardDisconnect(hCard, dwDisposition); + status = (LONG) g_PCSC.pfnSCardDisconnect(hCard, pcsc_dwDisposition); status = PCSC_MapErrorCodeToWinSCard(status); if (status == SCARD_S_SUCCESS) @@ -1403,7 +1431,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardBeginTransaction(SCARDHANDLE hCard) if (!g_PCSC.pfnSCardBeginTransaction) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardBeginTransaction(hCard); + status = (LONG) g_PCSC.pfnSCardBeginTransaction(hCard); status = PCSC_MapErrorCodeToWinSCard(status); return status; @@ -1412,11 +1440,12 @@ WINSCARDAPI LONG WINAPI PCSC_SCardBeginTransaction(SCARDHANDLE hCard) WINSCARDAPI LONG WINAPI PCSC_SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwDisposition = (PCSC_DWORD) dwDisposition; if (!g_PCSC.pfnSCardEndTransaction) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardEndTransaction(hCard, dwDisposition); + status = (LONG) g_PCSC.pfnSCardEndTransaction(hCard, pcsc_dwDisposition); status = PCSC_MapErrorCodeToWinSCard(status); return status; @@ -1430,10 +1459,13 @@ WINSCARDAPI LONG WINAPI PCSC_SCardCancelTransaction(SCARDHANDLE hCard) WINSCARDAPI LONG WINAPI PCSC_SCardState(SCARDHANDLE hCard, LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen) { - DWORD cchReaderLen; + PCSC_DWORD cchReaderLen; SCARDCONTEXT hContext = 0; LPSTR mszReaderNames = NULL; LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwState = 0; + PCSC_DWORD pcsc_dwProtocol = 0; + PCSC_DWORD pcsc_cbAtrLen = (PCSC_DWORD) *pcbAtrLen; if (!g_PCSC.pfnSCardStatus) return SCARD_E_NO_SERVICE; @@ -1445,14 +1477,16 @@ WINSCARDAPI LONG WINAPI PCSC_SCardState(SCARDHANDLE hCard, cchReaderLen = SCARD_AUTOALLOCATE; - status = g_PCSC.pfnSCardStatus(hCard, (LPSTR) &mszReaderNames, &cchReaderLen, - pdwState, pdwProtocol, pbAtr, pcbAtrLen); + status = (LONG) g_PCSC.pfnSCardStatus(hCard, (LPSTR) &mszReaderNames, &cchReaderLen, + &pcsc_dwState, &pcsc_dwProtocol, pbAtr, &pcsc_cbAtrLen); status = PCSC_MapErrorCodeToWinSCard(status); if (mszReaderNames) PCSC_SCardFreeMemory_Internal(hContext, mszReaderNames); - *pdwProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwProtocol); + *pdwState = (DWORD) pcsc_dwState; + *pdwProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD) pcsc_dwProtocol); + *pcbAtrLen = (DWORD) pcsc_cbAtrLen; return status; } @@ -1463,71 +1497,79 @@ WINSCARDAPI LONG WINAPI PCSC_SCardStatus_Internal(SCARDHANDLE hCard, { SCARDCONTEXT hContext; char* mszReaderNamesWinSCard = NULL; - BOOL pcbAtrLenWrapAlloc = FALSE; - BOOL pcchReaderLenWrapAlloc = FALSE; + BOOL pcbAtrLenAlloc = FALSE; + BOOL pcchReaderLenAlloc = FALSE; LPBYTE* pPbAtr = (LPBYTE*) pbAtr; LPSTR* pMszReaderNames = (LPSTR*) mszReaderNames; LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_cchReaderLen = 0; + PCSC_DWORD pcsc_dwState = 0; + PCSC_DWORD pcsc_dwProtocol = 0; + PCSC_DWORD pcsc_cbAtrLen = 0; if (!g_PCSC.pfnSCardStatus) return SCARD_E_NO_SERVICE; hContext = PCSC_GetCardContextFromHandle(hCard); - if (!hContext) + if (!hContext || !pcchReaderLen || !pdwState || !pdwProtocol || !pcbAtrLen) return SCARD_E_INVALID_VALUE; - if ((*pcchReaderLen == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate) - pcchReaderLenWrapAlloc = TRUE; + if (*pcchReaderLen == SCARD_AUTOALLOCATE) + pcchReaderLenAlloc = TRUE; - if ((*pcbAtrLen == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate) - pcbAtrLenWrapAlloc = TRUE; + pcsc_cchReaderLen = pcchReaderLenAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD) *pcchReaderLen; - if (pcchReaderLenWrapAlloc || pcbAtrLenWrapAlloc) + if (*pcbAtrLen == SCARD_AUTOALLOCATE) + pcbAtrLenAlloc = TRUE; + + pcsc_cbAtrLen = pcbAtrLenAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD) *pcbAtrLen; + + if ((pcchReaderLenAlloc || pcbAtrLenAlloc) && !g_SCardAutoAllocate) { - if (pcchReaderLenWrapAlloc) - *pcchReaderLen = 0; + if (pcchReaderLenAlloc) + pcsc_cchReaderLen = 0; - if (pcbAtrLenWrapAlloc) - *pcbAtrLen = 0; + if (pcbAtrLenAlloc) + pcsc_cbAtrLen = 0; - status = g_PCSC.pfnSCardStatus(hCard, - (pcchReaderLenWrapAlloc) ? NULL : mszReaderNames, pcchReaderLen, - pdwState, pdwProtocol, - (pcbAtrLenWrapAlloc) ? NULL : pbAtr, pcbAtrLen); + status = (LONG) g_PCSC.pfnSCardStatus(hCard, + (pcchReaderLenAlloc) ? NULL : mszReaderNames, &pcsc_cchReaderLen, + &pcsc_dwState, &pcsc_dwProtocol, + (pcbAtrLenAlloc) ? NULL : pbAtr, &pcsc_cbAtrLen); if (status == SCARD_S_SUCCESS) { - if (pcchReaderLenWrapAlloc) + if (pcchReaderLenAlloc) { - *pMszReaderNames = (LPSTR) calloc(1, *pcchReaderLen); + *pMszReaderNames = (LPSTR) calloc(1, pcsc_cchReaderLen); if (!*pMszReaderNames) return SCARD_E_NO_MEMORY; } - if (pcbAtrLenWrapAlloc) + if (pcbAtrLenAlloc) { - *pPbAtr = (BYTE*) calloc(1, *pcbAtrLen); + *pPbAtr = (BYTE*) calloc(1, pcsc_cbAtrLen); if (!*pPbAtr) return SCARD_E_NO_MEMORY; } - status = g_PCSC.pfnSCardStatus(hCard, - *pMszReaderNames, pcchReaderLen, - pdwState, pdwProtocol, - pbAtr, pcbAtrLen); + status = (LONG) g_PCSC.pfnSCardStatus(hCard, + *pMszReaderNames, &pcsc_cchReaderLen, + &pcsc_dwState, &pcsc_dwProtocol, + pbAtr, &pcsc_cbAtrLen); if (status != SCARD_S_SUCCESS) { - if (pcchReaderLenWrapAlloc) + if (pcchReaderLenAlloc) { free(*pMszReaderNames); *pMszReaderNames = NULL; } - if (pcbAtrLenWrapAlloc) + if (pcbAtrLenAlloc) { free(*pPbAtr); *pPbAtr = NULL; @@ -1535,22 +1577,24 @@ WINSCARDAPI LONG WINAPI PCSC_SCardStatus_Internal(SCARDHANDLE hCard, } else { - if (pcchReaderLenWrapAlloc) + if (pcchReaderLenAlloc) PCSC_AddMemoryBlock(hContext, *pMszReaderNames); - if (pcbAtrLenWrapAlloc) + if (pcbAtrLenAlloc) PCSC_AddMemoryBlock(hContext, *pPbAtr); } } } else { - status = g_PCSC.pfnSCardStatus(hCard, mszReaderNames, pcchReaderLen, - pdwState, pdwProtocol, pbAtr, pcbAtrLen); + status = (LONG) g_PCSC.pfnSCardStatus(hCard, mszReaderNames, &pcsc_cchReaderLen, + &pcsc_dwState, &pcsc_dwProtocol, pbAtr, &pcsc_cbAtrLen); } status = PCSC_MapErrorCodeToWinSCard(status); + *pcchReaderLen = (DWORD) pcsc_cchReaderLen; + mszReaderNamesWinSCard = PCSC_ConvertReaderNamesToWinSCard(*pMszReaderNames, pcchReaderLen); if (mszReaderNamesWinSCard) @@ -1561,10 +1605,12 @@ WINSCARDAPI LONG WINAPI PCSC_SCardStatus_Internal(SCARDHANDLE hCard, PCSC_AddMemoryBlock(hContext, *pMszReaderNames); } - *pdwState &= 0xFFFF; - *pdwState = PCSC_ConvertCardStateToWinSCard(*pdwState, status); + pcsc_dwState &= 0xFFFF; + *pdwState = PCSC_ConvertCardStateToWinSCard((DWORD) pcsc_dwState, status); - *pdwProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwProtocol); + *pdwProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD) pcsc_dwProtocol); + + *pcbAtrLen = (DWORD) pcsc_cbAtrLen; return status; } @@ -1614,23 +1660,25 @@ WINSCARDAPI LONG WINAPI PCSC_SCardTransmit(SCARDHANDLE hCard, LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_cbSendLength = (PCSC_DWORD) cbSendLength; + PCSC_DWORD pcsc_cbRecvLength = (PCSC_DWORD) *pcbRecvLength; if (!g_PCSC.pfnSCardTransmit) return SCARD_E_NO_SERVICE; if (!pioSendPci) { - DWORD dwState = 0; - DWORD cbAtrLen = 0; - DWORD dwProtocol = 0; - DWORD cchReaderLen = 0; + PCSC_DWORD dwState = 0; + PCSC_DWORD cbAtrLen = 0; + PCSC_DWORD dwProtocol = 0; + PCSC_DWORD cchReaderLen = 0; /** * pcsc-lite cannot have a null pioSendPci parameter, unlike WinSCard. * Query the current protocol and use default SCARD_IO_REQUEST for it. */ - status = g_PCSC.pfnSCardStatus(hCard, NULL, &cchReaderLen, &dwState, &dwProtocol, NULL, &cbAtrLen); + status = (LONG) g_PCSC.pfnSCardStatus(hCard, NULL, &cchReaderLen, &dwState, &dwProtocol, NULL, &cbAtrLen); if (status == SCARD_S_SUCCESS) { @@ -1643,10 +1691,12 @@ WINSCARDAPI LONG WINAPI PCSC_SCardTransmit(SCARDHANDLE hCard, } } - status = g_PCSC.pfnSCardTransmit(hCard, pioSendPci, pbSendBuffer, - cbSendLength, pioRecvPci, pbRecvBuffer, pcbRecvLength); + status = (LONG) g_PCSC.pfnSCardTransmit(hCard, pioSendPci, pbSendBuffer, + pcsc_cbSendLength, pioRecvPci, pbRecvBuffer, &pcsc_cbRecvLength); status = PCSC_MapErrorCodeToWinSCard(status); + *pcbRecvLength = (DWORD) pcsc_cbRecvLength; + return status; } @@ -1660,50 +1710,63 @@ WINSCARDAPI LONG WINAPI PCSC_SCardControl(SCARDHANDLE hCard, LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwControlCode = (PCSC_DWORD) dwControlCode; + PCSC_DWORD pcsc_cbInBufferSize = (PCSC_DWORD) cbInBufferSize; + PCSC_DWORD pcsc_cbOutBufferSize = (PCSC_DWORD) cbOutBufferSize; + PCSC_DWORD pcsc_BytesReturned = 0; if (!g_PCSC.pfnSCardControl) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardControl(hCard, - dwControlCode, lpInBuffer, cbInBufferSize, - lpOutBuffer, cbOutBufferSize, lpBytesReturned); + status = (LONG) g_PCSC.pfnSCardControl(hCard, + pcsc_dwControlCode, lpInBuffer, pcsc_cbInBufferSize, + lpOutBuffer, pcsc_cbOutBufferSize, &pcsc_BytesReturned); status = PCSC_MapErrorCodeToWinSCard(status); + *lpBytesReturned = (DWORD) pcsc_BytesReturned; + return status; } WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib_Internal(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen) { SCARDCONTEXT hContext = 0; - BOOL pcbAttrLenWrapAlloc = FALSE; + BOOL pcbAttrLenAlloc = FALSE; LPBYTE* pPbAttr = (LPBYTE*) pbAttr; LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwAttrId = (PCSC_DWORD) dwAttrId; + PCSC_DWORD pcsc_cbAttrLen = 0; if (!g_PCSC.pfnSCardGetAttrib) return SCARD_E_NO_SERVICE; - if ((*pcbAttrLen == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate) - pcbAttrLenWrapAlloc = TRUE; - hContext = PCSC_GetCardContextFromHandle(hCard); if (!hContext) - return SCARD_E_INVALID_VALUE; + return SCARD_E_INVALID_HANDLE; - if (pcbAttrLenWrapAlloc) + if (!pbAttr || !pcbAttrLen) + return SCARD_E_INVALID_PARAMETER; + + if (*pcbAttrLen == SCARD_AUTOALLOCATE) + pcbAttrLenAlloc = TRUE; + + pcsc_cbAttrLen = pcbAttrLenAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD) *pcbAttrLen; + + if (pcbAttrLenAlloc && !g_SCardAutoAllocate) { - *pcbAttrLen = 0; + pcsc_cbAttrLen = 0; - status = g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, NULL, pcbAttrLen); + status = (LONG) g_PCSC.pfnSCardGetAttrib(hCard, pcsc_dwAttrId, NULL, &pcsc_cbAttrLen); if (status == SCARD_S_SUCCESS) { - *pPbAttr = (BYTE*) calloc(1, *pcbAttrLen); + *pPbAttr = (BYTE*) calloc(1, pcsc_cbAttrLen); if (!*pPbAttr) return SCARD_E_NO_MEMORY; - status = g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, *pPbAttr, pcbAttrLen); + status = (LONG) g_PCSC.pfnSCardGetAttrib(hCard, pcsc_dwAttrId, *pPbAttr, &pcsc_cbAttrLen); if (status != SCARD_S_SUCCESS) free(*pPbAttr); @@ -1713,11 +1776,13 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib_Internal(SCARDHANDLE hCard, DWORD dw } else { - status = g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, pbAttr, pcbAttrLen); + status = (LONG) g_PCSC.pfnSCardGetAttrib(hCard, pcsc_dwAttrId, pbAttr, &pcsc_cbAttrLen); } status = PCSC_MapErrorCodeToWinSCard(status); + *pcbAttrLen = (DWORD) pcsc_cbAttrLen; + return status; } @@ -1725,14 +1790,14 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, L { DWORD cbAttrLen; SCARDCONTEXT hContext; - BOOL attrAutoAlloc = FALSE; + BOOL pcbAttrLenAlloc = FALSE; LONG status = SCARD_S_SUCCESS; LPBYTE* pPbAttr = (LPBYTE*) pbAttr; cbAttrLen = *pcbAttrLen; if (*pcbAttrLen == SCARD_AUTOALLOCATE) - attrAutoAlloc = TRUE; + pcbAttrLenAlloc = TRUE; /** * pcsc-lite returns SCARD_E_INSUFFICIENT_BUFFER if the given @@ -1755,7 +1820,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, L * while WinSCard doesn't. Strip the null terminator. */ - if (attrAutoAlloc) + if (pcbAttrLenAlloc) *pcbAttrLen = strlen((char*) *pPbAttr); else *pcbAttrLen = strlen((char*) pbAttr); @@ -1782,7 +1847,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, L PCSC_SCardFreeMemory_Internal(hContext, pbAttrW); - if (attrAutoAlloc) + if (pcbAttrLenAlloc) { PCSC_AddMemoryBlock(hContext, pbAttrA); *pPbAttr = (BYTE*) pbAttrA; @@ -1821,7 +1886,7 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, L PCSC_SCardFreeMemory_Internal(hContext, pbAttrA); - if (attrAutoAlloc) + if (pcbAttrLenAlloc) { PCSC_AddMemoryBlock(hContext, pbAttrW); *pPbAttr = (BYTE*) pbAttrW; @@ -1844,12 +1909,12 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, L } else if (dwAttrId == SCARD_ATTR_CURRENT_PROTOCOL_TYPE) { - DWORD dwState = 0; - DWORD cbAtrLen = 0; - DWORD dwProtocol = 0; - DWORD cchReaderLen = 0; + PCSC_DWORD dwState = 0; + PCSC_DWORD cbAtrLen = 0; + PCSC_DWORD dwProtocol = 0; + PCSC_DWORD cchReaderLen = 0; - status = g_PCSC.pfnSCardStatus(hCard, NULL, &cchReaderLen, &dwState, &dwProtocol, NULL, &cbAtrLen); + status = (LONG) g_PCSC.pfnSCardStatus(hCard, NULL, &cchReaderLen, &dwState, &dwProtocol, NULL, &cbAtrLen); if (status == SCARD_S_SUCCESS) { @@ -1953,11 +2018,13 @@ WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, L WINSCARDAPI LONG WINAPI PCSC_SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen) { LONG status = SCARD_S_SUCCESS; + PCSC_DWORD pcsc_dwAttrId = (PCSC_DWORD) dwAttrId; + PCSC_DWORD pcsc_cbAttrLen = (PCSC_DWORD) cbAttrLen; if (!g_PCSC.pfnSCardSetAttrib) return SCARD_E_NO_SERVICE; - status = g_PCSC.pfnSCardSetAttrib(hCard, dwAttrId, pbAttr, cbAttrLen); + status = (LONG) g_PCSC.pfnSCardSetAttrib(hCard, pcsc_dwAttrId, pbAttr, pcsc_cbAttrLen); status = PCSC_MapErrorCodeToWinSCard(status); return status; diff --git a/winpr/libwinpr/smartcard/smartcard_pcsc.h b/winpr/libwinpr/smartcard/smartcard_pcsc.h index 5ff24e7c7..d9f922963 100644 --- a/winpr/libwinpr/smartcard/smartcard_pcsc.h +++ b/winpr/libwinpr/smartcard/smartcard_pcsc.h @@ -25,6 +25,34 @@ #include #include +/** + * On Windows, DWORD and ULONG are defined to unsigned long. + * However, 64-bit Windows uses the LLP64 model which defines + * unsigned long as a 4-byte type, while most non-Windows + * systems use the LP64 model where unsigned long is 8 bytes. + * + * WinPR correctly defines DWORD and ULONG to be 4-byte types + * regardless of LLP64/LP64, but this has the side effect of + * breaking compatibility with the broken pcsc-lite types. + * + * To make matters worse, pcsc-lite correctly defines + * the data types on OS X, but not on other platforms. + */ + +#ifdef __APPLE__ +typedef unsigned int PCSC_DWORD; +typedef PCSC_DWORD *PCSC_PDWORD, *PCSC_LPDWORD; +typedef unsigned int PCSC_ULONG; +typedef PCSC_ULONG *PCSC_PULONG; +typedef int PCSC_LONG; +#else +typedef unsigned long PCSC_DWORD; +typedef PCSC_DWORD *PCSC_PDWORD, *PCSC_LPDWORD; +typedef unsigned long PCSC_ULONG; +typedef PCSC_ULONG *PCSC_PULONG; +typedef long PCSC_LONG; +#endif + #define PCSC_SCARD_UNKNOWN 0x0001 #define PCSC_SCARD_ABSENT 0x0002 #define PCSC_SCARD_PRESENT 0x0004 @@ -41,49 +69,59 @@ #define PCSC_MAX_ATR_SIZE 33 +#define PCSC_SCARD_AUTOALLOCATE (PCSC_DWORD)(-1) + typedef struct { LPCSTR szReader; LPVOID pvUserData; - DWORD dwCurrentState; - DWORD dwEventState; - DWORD cbAtr; + PCSC_DWORD dwCurrentState; + PCSC_DWORD dwEventState; + PCSC_DWORD cbAtr; BYTE rgbAtr[PCSC_MAX_ATR_SIZE]; /* WinSCard: 36, PCSC: 33 */ } PCSC_SCARD_READERSTATE; +typedef struct _PCSC_SCARD_IO_REQUEST +{ + PCSC_DWORD dwProtocol; + PCSC_DWORD cbPciLength; +} PCSC_SCARD_IO_REQUEST, *PCSC_PSCARD_IO_REQUEST, *PCSC_LPSCARD_IO_REQUEST; +typedef const PCSC_SCARD_IO_REQUEST *PCSC_LPCSCARD_IO_REQUEST; + 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, PCSC_SCARD_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); + PCSC_LONG (* pfnSCardEstablishContext)(PCSC_DWORD dwScope, + LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext); + PCSC_LONG (* pfnSCardReleaseContext)(SCARDCONTEXT hContext); + PCSC_LONG (* pfnSCardIsValidContext)(SCARDCONTEXT hContext); + PCSC_LONG (* pfnSCardConnect)(SCARDCONTEXT hContext, + LPCSTR szReader, PCSC_DWORD dwShareMode, PCSC_DWORD dwPreferredProtocols, + LPSCARDHANDLE phCard, PCSC_LPDWORD pdwActiveProtocol); + PCSC_LONG (* pfnSCardReconnect)(SCARDHANDLE hCard, + PCSC_DWORD dwShareMode, PCSC_DWORD dwPreferredProtocols, + PCSC_DWORD dwInitialization, PCSC_LPDWORD pdwActiveProtocol); + PCSC_LONG (* pfnSCardDisconnect)(SCARDHANDLE hCard, PCSC_DWORD dwDisposition); + PCSC_LONG (* pfnSCardBeginTransaction)(SCARDHANDLE hCard); + PCSC_LONG (* pfnSCardEndTransaction)(SCARDHANDLE hCard, PCSC_DWORD dwDisposition); + PCSC_LONG (* pfnSCardStatus)(SCARDHANDLE hCard, + LPSTR mszReaderName, PCSC_LPDWORD pcchReaderLen, PCSC_LPDWORD pdwState, + PCSC_LPDWORD pdwProtocol, LPBYTE pbAtr, PCSC_LPDWORD pcbAtrLen); + PCSC_LONG (* pfnSCardGetStatusChange)(SCARDCONTEXT hContext, + PCSC_DWORD dwTimeout, PCSC_SCARD_READERSTATE* rgReaderStates, PCSC_DWORD cReaders); + PCSC_LONG (* pfnSCardControl)(SCARDHANDLE hCard, + PCSC_DWORD dwControlCode, LPCVOID pbSendBuffer, PCSC_DWORD cbSendLength, + LPVOID pbRecvBuffer, PCSC_DWORD cbRecvLength, PCSC_LPDWORD lpBytesReturned); + PCSC_LONG (* pfnSCardTransmit)(SCARDHANDLE hCard, + const SCARD_IO_REQUEST* pioSendPci, LPCBYTE pbSendBuffer, PCSC_DWORD cbSendLength, + SCARD_IO_REQUEST* pioRecvPci, LPBYTE pbRecvBuffer, PCSC_LPDWORD pcbRecvLength); + PCSC_LONG (* pfnSCardListReaderGroups)(SCARDCONTEXT hContext, LPSTR mszGroups, PCSC_LPDWORD pcchGroups); + PCSC_LONG (* pfnSCardListReaders)(SCARDCONTEXT hContext, + LPCSTR mszGroups, LPSTR mszReaders, PCSC_LPDWORD pcchReaders); + PCSC_LONG (* pfnSCardFreeMemory)(SCARDCONTEXT hContext, LPCVOID pvMem); + PCSC_LONG (* pfnSCardCancel)(SCARDCONTEXT hContext); + PCSC_LONG (* pfnSCardGetAttrib)(SCARDHANDLE hCard, PCSC_DWORD dwAttrId, LPBYTE pbAttr, PCSC_LPDWORD pcbAttrLen); + PCSC_LONG (* pfnSCardSetAttrib)(SCARDHANDLE hCard, PCSC_DWORD dwAttrId, LPCBYTE pbAttr, PCSC_DWORD cbAttrLen); }; typedef struct _PCSCFunctionTable PCSCFunctionTable; diff --git a/winpr/libwinpr/smartcard/test/TestSmartCardListReaders.c b/winpr/libwinpr/smartcard/test/TestSmartCardListReaders.c index 53bfcfad4..fde44b5b4 100644 --- a/winpr/libwinpr/smartcard/test/TestSmartCardListReaders.c +++ b/winpr/libwinpr/smartcard/test/TestSmartCardListReaders.c @@ -5,9 +5,9 @@ int TestSmartCardListReaders(int argc, char* argv[]) { LONG lStatus; - LPTSTR pReader; + LPSTR pReader; SCARDCONTEXT hSC; - LPSTR pmszReaders = NULL; + LPSTR mszReaders = NULL; DWORD cchReaders = SCARD_AUTOALLOCATE; lStatus = SCardEstablishContext(SCARD_SCOPE_USER, NULL, NULL, &hSC); @@ -19,8 +19,7 @@ int TestSmartCardListReaders(int argc, char* argv[]) return 0; } -#if 0 - lStatus = SCardListReadersA(hSC, NULL, (LPSTR) &pmszReaders, &cchReaders); + lStatus = SCardListReadersA(hSC, NULL, (LPSTR) &mszReaders, &cchReaders); if (lStatus != SCARD_S_SUCCESS) { @@ -31,7 +30,7 @@ int TestSmartCardListReaders(int argc, char* argv[]) } else { - pReader = pmszReaders; + pReader = mszReaders; while (*pReader) { @@ -39,12 +38,11 @@ int TestSmartCardListReaders(int argc, char* argv[]) pReader = pReader + strlen((CHAR*) pReader) + 1; } - lStatus = SCardFreeMemory(hSC, pmszReaders); + lStatus = SCardFreeMemory(hSC, mszReaders); if (lStatus != SCARD_S_SUCCESS) printf("Failed SCardFreeMemory\n"); } -#endif SCardReleaseContext(hSC);