libwinpr-smartcard: fix PCSC incompatible type definitions

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})
 

channels/smartcard/client/smartcard_main.c

@@ -29,12 +29,39 @@
 
 #include <winpr/crt.h>
 #include <winpr/smartcard.h>
+#include <winpr/environment.h>
 
 #include <freerdp/channels/rdpdr.h>
 
 #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);

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;

winpr/libwinpr/smartcard/smartcard_pcsc.h

@@ -25,6 +25,34 @@
 #include <winpr/platform.h>
 #include <winpr/smartcard.h>
 
+/**
+ * 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;
 

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);