/**

 * WinPR: Windows Portable Runtime

 * Smart Card API

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 *

 * 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

#ifndef _WIN32

#ifdef __APPLE__

#include <sys/types.h>

#include <sys/param.h>

#include <sys/sysctl.h>

#include <string.h>

#include <ctype.h>

#include <errno.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <winpr/crt.h>

#include <winpr/synch.h>

#include <winpr/library.h>

#include <winpr/smartcard.h>

#include <winpr/collections.h>

#include <winpr/environment.h>

#include "smartcard_pcsc.h"

#include "../log.h"

#define TAG WINPR_TAG("smartcard")

/**

 * PC/SC transactions:

 * http://developersblog.wwpass.com/?p=180

 */

/**

 * Smart Card Logon on Windows Vista:

 * http://blogs.msdn.com/b/shivaram/archive/2007/02/26/smart-card-logon-on-windows-vista.aspx

 */

/**

 * The Smart Card Cryptographic Service Provider Cookbook:

 * http://msdn.microsoft.com/en-us/library/ms953432.aspx

 *

 * SCARDCONTEXT

 *

 * The context is a communication channel with the smart card resource manager and

 * all calls to the resource manager must go through this link.

 *

 * All functions that take a context as a parameter or a card handle as parameter,

 * which is indirectly associated with a particular context, may be blocking calls.

 * Examples of these are SCardGetStatusChange and SCardBeginTransaction, which takes

 * a card handle as a parameter. If such a function blocks then all operations wanting

 * to use the context are blocked as well. So, it is recommended that a CSP using

 * monitoring establishes at least two contexts with the resource manager; one for

 * monitoring (with SCardGetStatusChange) and one for other operations.

 *

 * If multiple cards are present, it is recommended that a separate context or pair

 * of contexts be established for each card to prevent operations on one card from

 * blocking operations on another.

 *

 * Example one

 *

 * The example below shows what can happen if a CSP using SCardGetStatusChange for

 * monitoring does not establish two contexts with the resource manager.

 * The context becomes unusable until SCardGetStatusChange unblocks.

 *

 * In this example, there is one process running called P1.

 * P1 calls SCardEstablishContext, which returns the context hCtx.

 * P1 calls SCardConnect (with the hCtx context) which returns a handle to the card, hCard.

 * P1 calls SCardGetStatusChange (with the hCtx context) which blocks because

 * there are no status changes to report.

 * Until the thread running SCardGetStatusChange unblocks, another thread in P1 trying to

 * perform an operation using the context hCtx (or the card hCard) will also be blocked.

 *

 * Example two

 *

 * The example below shows how transaction control ensures that operations meant to be

 * performed without interruption can do so safely within a transaction.

 *

 * In this example, there are two different processes running; P1 and P2.

 * P1 calls SCardEstablishContext, which returns the context hCtx1.

 * P2 calls SCardEstablishContext, which returns the context hCtx2.

 * P1 calls SCardConnect (with the hCtx1 context) which returns a handle to the card, hCard1.

 * P2 calls SCardConnect (with the hCtx2 context) which returns a handle to the same card, hCard2.

 * P1 calls SCardBeginTransaction (with the hCard 1 context).

 * Until P1 calls SCardEndTransaction (with the hCard1 context),

 * any operation using hCard2 will be blocked.

 * Once an operation using hCard2 is blocked and until it's returning,

 * any operation using hCtx2 (and hCard2) will also be blocked.

 */

//#define DISABLE_PCSC_SCARD_AUTOALLOCATE

typedef struct _PCSC_SCARDCONTEXT PCSC_SCARDCONTEXT;

typedef struct _PCSC_SCARDHANDLE PCSC_SCARDHANDLE;

struct _PCSC_SCARDCONTEXT

{

	SCARDHANDLE owner;

	CRITICAL_SECTION lock;

	SCARDCONTEXT hContext;

	DWORD dwCardHandleCount;

	BOOL isTransactionLocked;

};

struct _PCSC_SCARDHANDLE

{

	BOOL shared;

	SCARDCONTEXT hSharedContext;

};

static HMODULE g_PCSCModule = NULL;

static PCSCFunctionTable g_PCSC = { 0 };

static HANDLE g_StartedEvent = NULL;

static int g_StartedEventRefCount = 0;

static BOOL g_SCardAutoAllocate = FALSE;

static BOOL g_PnP_Notification = TRUE;

#ifdef __MACOSX__

static unsigned int OSXVersion = 0;

#endif

static wListDictionary* g_CardHandles = NULL;

static wListDictionary* g_CardContexts = NULL;

static wListDictionary* g_MemoryBlocks = NULL;

char SMARTCARD_PNP_NOTIFICATION_A[] = "\\\\?PnP?\\Notification";

const PCSC_SCARD_IO_REQUEST g_PCSC_rgSCardT0Pci = { SCARD_PROTOCOL_T0, sizeof(PCSC_SCARD_IO_REQUEST) };

const PCSC_SCARD_IO_REQUEST g_PCSC_rgSCardT1Pci = { SCARD_PROTOCOL_T1, sizeof(PCSC_SCARD_IO_REQUEST) };

const PCSC_SCARD_IO_REQUEST g_PCSC_rgSCardRawPci = { PCSC_SCARD_PROTOCOL_RAW, sizeof(PCSC_SCARD_IO_REQUEST) };

WINSCARDAPI LONG WINAPI PCSC_SCardFreeMemory_Internal(SCARDCONTEXT hContext, LPCVOID pvMem);

WINSCARDAPI LONG WINAPI PCSC_SCardEstablishContext_Internal(DWORD dwScope,

        LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext);

WINSCARDAPI LONG WINAPI PCSC_SCardReleaseContext_Internal(SCARDCONTEXT hContext);

static LONG PCSC_MapErrorCodeToWinSCard(LONG errorCode)

{

	/**

	 * pcsc-lite returns SCARD_E_UNEXPECTED when it

	 * should return SCARD_E_UNSUPPORTED_FEATURE.

	 *

	 * Additionally, the pcsc-lite headers incorrectly

	 * define SCARD_E_UNSUPPORTED_FEATURE to 0x8010001F,

	 * when the real value should be 0x80100022.

	 */

	if (errorCode == SCARD_E_UNEXPECTED)

		errorCode = SCARD_E_UNSUPPORTED_FEATURE;

	return errorCode;

}

static DWORD PCSC_ConvertCardStateToWinSCard(DWORD dwCardState, LONG status)

{

	/**

	 * pcsc-lite's SCardStatus returns a bit-field, not an enumerated value.

	 *

	 *         State             WinSCard           pcsc-lite

	 *

	 *      SCARD_UNKNOWN           0                0x0001

	 *      SCARD_ABSENT            1                0x0002

	 *      SCARD_PRESENT           2                0x0004

	 *      SCARD_SWALLOWED         3                0x0008

	 *      SCARD_POWERED           4                0x0010

	 *      SCARD_NEGOTIABLE        5                0x0020

	 *      SCARD_SPECIFIC          6                0x0040

	 *

	 * pcsc-lite also never sets SCARD_SPECIFIC,

	 * which is expected by some windows applications.

	 */

	if (status == SCARD_S_SUCCESS)

	{

		if ((dwCardState & PCSC_SCARD_NEGOTIABLE) || (dwCardState & PCSC_SCARD_SPECIFIC))

			return SCARD_SPECIFIC;

	}

	if (dwCardState & PCSC_SCARD_POWERED)

		return SCARD_POWERED;

	if (dwCardState & PCSC_SCARD_NEGOTIABLE)

		return SCARD_NEGOTIABLE;

	if (dwCardState & PCSC_SCARD_SPECIFIC)

		return SCARD_SPECIFIC;

	if (dwCardState & PCSC_SCARD_ABSENT)

		return SCARD_ABSENT;

	if (dwCardState & PCSC_SCARD_PRESENT)

		return SCARD_PRESENT;

	if (dwCardState & PCSC_SCARD_SWALLOWED)

		return SCARD_SWALLOWED;

	if (dwCardState & PCSC_SCARD_UNKNOWN)

		return SCARD_UNKNOWN;

	return SCARD_UNKNOWN;

}

static DWORD PCSC_ConvertProtocolsToWinSCard(DWORD dwProtocols)

{

	/**

	 * pcsc-lite uses a different value for SCARD_PROTOCOL_RAW,

	 * and also has SCARD_PROTOCOL_T15 which is not in WinSCard.

	 */

	if (dwProtocols & PCSC_SCARD_PROTOCOL_RAW)

	{

		dwProtocols &= ~PCSC_SCARD_PROTOCOL_RAW;

		dwProtocols |= SCARD_PROTOCOL_RAW;

	}

	if (dwProtocols & PCSC_SCARD_PROTOCOL_T15)

	{

		dwProtocols &= ~PCSC_SCARD_PROTOCOL_T15;

	}

	return dwProtocols;

}

static DWORD PCSC_ConvertProtocolsFromWinSCard(DWORD dwProtocols)

{

	/**

	 * pcsc-lite uses a different value for SCARD_PROTOCOL_RAW,

	 * and it does not define WinSCard's SCARD_PROTOCOL_DEFAULT.

	 */

	if (dwProtocols & SCARD_PROTOCOL_RAW)

	{

		dwProtocols &= ~SCARD_PROTOCOL_RAW;

		dwProtocols |= PCSC_SCARD_PROTOCOL_RAW;

	}

	if (dwProtocols & SCARD_PROTOCOL_DEFAULT)

	{

		dwProtocols &= ~SCARD_PROTOCOL_DEFAULT;

	}

	if (dwProtocols == SCARD_PROTOCOL_UNDEFINED)

	{

		dwProtocols = SCARD_PROTOCOL_Tx;

	}

	return dwProtocols;

}

static PCSC_SCARDCONTEXT* PCSC_GetCardContextData(SCARDCONTEXT hContext)

{

	PCSC_SCARDCONTEXT* pContext;

	if (!g_CardContexts)

		return NULL;

	pContext = (PCSC_SCARDCONTEXT*) ListDictionary_GetItemValue(g_CardContexts, (void*) hContext);

	if (!pContext)

		return NULL;

	return pContext;

}

static PCSC_SCARDCONTEXT* PCSC_EstablishCardContext(SCARDCONTEXT hContext)

{

	PCSC_SCARDCONTEXT* pContext;

	pContext = (PCSC_SCARDCONTEXT*) calloc(1, sizeof(PCSC_SCARDCONTEXT));

	if (!pContext)

		return NULL;

	pContext->hContext = hContext;

	if (!InitializeCriticalSectionAndSpinCount(&(pContext->lock), 4000))

		goto error_spinlock;

	if (!g_CardContexts)

	{

		g_CardContexts = ListDictionary_New(TRUE);

		if (!g_CardContexts)

			goto errors;

	}

	if (!ListDictionary_Add(g_CardContexts, (void*) hContext, (void*) pContext))

		goto errors;

	return pContext;

errors:

	DeleteCriticalSection(&(pContext->lock));

error_spinlock:

	free(pContext);

	return NULL;

}

static void PCSC_ReleaseCardContext(SCARDCONTEXT hContext)

{

	PCSC_SCARDCONTEXT* pContext;

	pContext = PCSC_GetCardContextData(hContext);

	if (!pContext)

	{

		WLog_ERR(TAG, "PCSC_ReleaseCardContext: null pContext!");

		return;

	}

	DeleteCriticalSection(&(pContext->lock));

	free(pContext);

	if (!g_CardContexts)

		return;

	ListDictionary_Remove(g_CardContexts, (void*) hContext);

}

static BOOL PCSC_LockCardContext(SCARDCONTEXT hContext)

{

	PCSC_SCARDCONTEXT* pContext;

	pContext = PCSC_GetCardContextData(hContext);

	if (!pContext)

	{

		WLog_ERR(TAG, "PCSC_LockCardContext: invalid context (%p)", (void*) hContext);

		return FALSE;

	}

	EnterCriticalSection(&(pContext->lock));

	return TRUE;

}

static BOOL PCSC_UnlockCardContext(SCARDCONTEXT hContext)

{

	PCSC_SCARDCONTEXT* pContext;

	pContext = PCSC_GetCardContextData(hContext);

	if (!pContext)

	{

		WLog_ERR(TAG, "PCSC_UnlockCardContext: invalid context (%p)", (void*) hContext);

		return FALSE;

	}

	LeaveCriticalSection(&(pContext->lock));

	return TRUE;

}

static PCSC_SCARDHANDLE* PCSC_GetCardHandleData(SCARDHANDLE hCard)

{

	PCSC_SCARDHANDLE* pCard;

	if (!g_CardHandles)

		return NULL;

	pCard = (PCSC_SCARDHANDLE*) ListDictionary_GetItemValue(g_CardHandles, (void*) hCard);

	if (!pCard)

		return NULL;

	return pCard;

}

static SCARDCONTEXT PCSC_GetCardContextFromHandle(SCARDHANDLE hCard)

{

	PCSC_SCARDHANDLE* pCard;

	pCard = PCSC_GetCardHandleData(hCard);

	if (!pCard)

		return 0;

	return pCard->hSharedContext;

}

static BOOL PCSC_WaitForCardAccess(SCARDCONTEXT hContext, SCARDHANDLE hCard, BOOL shared)

{

	BOOL status = TRUE;

	PCSC_SCARDHANDLE* pCard = NULL;

	PCSC_SCARDCONTEXT* pContext = NULL;

	if (!hCard)

	{

		/* SCardConnect */

		pContext = PCSC_GetCardContextData(hContext);

		if (!pContext)

			return FALSE;

		if (!pContext->owner)

			return TRUE;

		/* wait for card ownership */

		return TRUE;

	}

	pCard = PCSC_GetCardHandleData(hCard);

	if (!pCard)

		return FALSE;

	shared = pCard->shared;

	hContext = pCard->hSharedContext;

	pContext = PCSC_GetCardContextData(hContext);

	if (!pContext)

		return FALSE;

	if (!pContext->owner)

	{

		/* card is not owned */

		if (!shared)

			pContext->owner = hCard;

		return TRUE;

	}

	if (pContext->owner == hCard)

	{

		/* already card owner */

	}

	else

	{

		/* wait for card ownership */

	}

	return status;

}

static BOOL PCSC_ReleaseCardAccess(SCARDCONTEXT hContext, SCARDHANDLE hCard)

{

	PCSC_SCARDHANDLE* pCard = NULL;

	PCSC_SCARDCONTEXT* pContext = NULL;

	if (!hCard)

	{

		/* release current owner */

		pContext = PCSC_GetCardContextData(hContext);

		if (!pContext)

			return FALSE;

		hCard = pContext->owner;

		if (!hCard)

			return TRUE;

		pCard = PCSC_GetCardHandleData(hCard);

		if (!pCard)

			return FALSE;

		/* release card ownership */

		pContext->owner = 0;

		return TRUE;

	}

	pCard = PCSC_GetCardHandleData(hCard);

	if (!pCard)

		return FALSE;

	hContext = pCard->hSharedContext;

	pContext = PCSC_GetCardContextData(hContext);

	if (!pContext)

		return FALSE;

	if (pContext->owner == hCard)

	{

		/* release card ownership */

		pContext->owner = 0;

	}

	return TRUE;

}

static PCSC_SCARDHANDLE* PCSC_ConnectCardHandle(SCARDCONTEXT hSharedContext, SCARDHANDLE hCard)

{

	PCSC_SCARDHANDLE* pCard;

	PCSC_SCARDCONTEXT* pContext;

	pContext = PCSC_GetCardContextData(hSharedContext);

	if (!pContext)

	{

		WLog_ERR(TAG, "PCSC_ConnectCardHandle: null pContext!");

		return NULL;

	}

	pCard = (PCSC_SCARDHANDLE*) calloc(1, sizeof(PCSC_SCARDHANDLE));

	if (!pCard)

		return NULL;

	pCard->hSharedContext = hSharedContext;

	if (!g_CardHandles)

	{

		g_CardHandles = ListDictionary_New(TRUE);

		if (!g_CardHandles)

			goto error;

	}

	if (!ListDictionary_Add(g_CardHandles, (void*) hCard, (void*) pCard))

		goto error;

	pContext->dwCardHandleCount++;

	return pCard;

error:

	free(pCard);

	return NULL;

}

static void PCSC_DisconnectCardHandle(SCARDHANDLE hCard)

{

	PCSC_SCARDHANDLE* pCard;

	PCSC_SCARDCONTEXT* pContext;

	pCard = PCSC_GetCardHandleData(hCard);

	if (!pCard)

		return;

	pContext = PCSC_GetCardContextData(pCard->hSharedContext);

	free(pCard);

	if (!g_CardHandles)

		return;

	ListDictionary_Remove(g_CardHandles, (void*) hCard);

	if (!pContext)

	{

		WLog_ERR(TAG, "PCSC_DisconnectCardHandle: null pContext!");

		return;

	}

	pContext->dwCardHandleCount--;

}

static BOOL PCSC_AddMemoryBlock(SCARDCONTEXT hContext, void* pvMem)

{

	if (!g_MemoryBlocks)

	{

		g_MemoryBlocks = ListDictionary_New(TRUE);

		if (!g_MemoryBlocks)

			return FALSE;

	}

	return ListDictionary_Add(g_MemoryBlocks, pvMem, (void*) hContext);

}

static void* PCSC_RemoveMemoryBlock(SCARDCONTEXT hContext, void* pvMem)

{

	WINPR_UNUSED(hContext);

	if (!g_MemoryBlocks)

		return NULL;

	return ListDictionary_Remove(g_MemoryBlocks, pvMem);

}

/**

 * Standard Windows Smart Card API (PCSC)

 */

WINSCARDAPI LONG WINAPI PCSC_SCardEstablishContext_Internal(DWORD dwScope,

        LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext)

{

	WINPR_UNUSED(dwScope); /* SCARD_SCOPE_SYSTEM is the only scope supported by pcsc-lite */

	LONG status = SCARD_S_SUCCESS;

	if (!g_PCSC.pfnSCardEstablishContext)

		return SCARD_E_NO_SERVICE;

	status = (LONG) g_PCSC.pfnSCardEstablishContext(SCARD_SCOPE_SYSTEM, pvReserved1, pvReserved2,

	         phContext);

	status = PCSC_MapErrorCodeToWinSCard(status);

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardEstablishContext(DWORD dwScope,

        LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext)

{

	LONG status;

	status = PCSC_SCardEstablishContext_Internal(dwScope, pvReserved1, pvReserved2, phContext);

	if (status == SCARD_S_SUCCESS)

		PCSC_EstablishCardContext(*phContext);

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardReleaseContext_Internal(SCARDCONTEXT hContext)

{

	LONG status = SCARD_S_SUCCESS;

	if (!g_PCSC.pfnSCardReleaseContext)

		return SCARD_E_NO_SERVICE;

	if (!hContext)

	{

		WLog_ERR(TAG, "SCardReleaseContext: null hContext");

		return status;

	}

	status = (LONG) g_PCSC.pfnSCardReleaseContext(hContext);

	status = PCSC_MapErrorCodeToWinSCard(status);

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardReleaseContext(SCARDCONTEXT hContext)

{

	LONG status = SCARD_S_SUCCESS;

	status = PCSC_SCardReleaseContext_Internal(hContext);

	if (status != SCARD_S_SUCCESS)

		PCSC_ReleaseCardContext(hContext);

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardIsValidContext(SCARDCONTEXT hContext)

{

	LONG status = SCARD_S_SUCCESS;

	if (!g_PCSC.pfnSCardIsValidContext)

		return SCARD_E_NO_SERVICE;

	status = (LONG) g_PCSC.pfnSCardIsValidContext(hContext);

	status = PCSC_MapErrorCodeToWinSCard(status);

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroups_Internal(SCARDCONTEXT hContext,

        LPSTR mszGroups, LPDWORD pcchGroups)

{

	LONG status = SCARD_S_SUCCESS;

	BOOL pcchGroupsAlloc = FALSE;

	LPSTR* pMszGroups = (LPSTR*) mszGroups;

	PCSC_DWORD pcsc_cchGroups = 0;

	if (!pcchGroups)

		return SCARD_E_INVALID_PARAMETER;

	if (!g_PCSC.pfnSCardListReaderGroups)

		return SCARD_E_NO_SERVICE;

	if (*pcchGroups == SCARD_AUTOALLOCATE)

		pcchGroupsAlloc = TRUE;

	pcsc_cchGroups = pcchGroupsAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD) * pcchGroups;

	if (pcchGroupsAlloc && !g_SCardAutoAllocate)

	{

		pcsc_cchGroups = 0;

		status = (LONG) g_PCSC.pfnSCardListReaderGroups(hContext, NULL, &pcsc_cchGroups);

		if (status == SCARD_S_SUCCESS)

		{

			*pMszGroups = calloc(1, pcsc_cchGroups);

			if (!*pMszGroups)

				return SCARD_E_NO_MEMORY;

			status = (LONG) g_PCSC.pfnSCardListReaderGroups(hContext, *pMszGroups, &pcsc_cchGroups);

			if (status != SCARD_S_SUCCESS)

				free(*pMszGroups);

			else

				PCSC_AddMemoryBlock(hContext, *pMszGroups);

		}

	}

	else

	{

		status = (LONG) g_PCSC.pfnSCardListReaderGroups(hContext, mszGroups, &pcsc_cchGroups);

	}

	status = PCSC_MapErrorCodeToWinSCard(status);

	*pcchGroups = (DWORD) pcsc_cchGroups;

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsA(SCARDCONTEXT hContext,

        LPSTR mszGroups, LPDWORD pcchGroups)

{

	LONG status = SCARD_S_SUCCESS;

	if (!g_PCSC.pfnSCardListReaderGroups)

		return SCARD_E_NO_SERVICE;

	if (!PCSC_LockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	status = PCSC_SCardListReaderGroups_Internal(hContext, mszGroups, pcchGroups);

	if (!PCSC_UnlockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsW(SCARDCONTEXT hContext,

        LPWSTR mszGroups, LPDWORD pcchGroups)

{

	LPSTR mszGroupsA = NULL;

	LPSTR* pMszGroupsA = &mszGroupsA;

	LONG status = SCARD_S_SUCCESS;

	if (!g_PCSC.pfnSCardListReaderGroups)

		return SCARD_E_NO_SERVICE;

	if (!PCSC_LockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	status = PCSC_SCardListReaderGroups_Internal(hContext, (LPSTR) &mszGroupsA, pcchGroups);

	if (status == SCARD_S_SUCCESS)

	{

		*pcchGroups = ConvertToUnicode(CP_UTF8, 0, *pMszGroupsA, *pcchGroups, (WCHAR**) mszGroups, 0);

		PCSC_AddMemoryBlock(hContext, mszGroups);

		PCSC_SCardFreeMemory_Internal(hContext, *pMszGroupsA);

	}

	if (!PCSC_UnlockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardListReaders_Internal(SCARDCONTEXT hContext,

        LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)

{

	LONG status = SCARD_S_SUCCESS;

	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)

		pcchReadersAlloc = TRUE;

	pcsc_cchReaders = pcchReadersAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD) * pcchReaders;

	if (pcchReadersAlloc && !g_SCardAutoAllocate)

	{

		pcsc_cchReaders = 0;

		status = (LONG) g_PCSC.pfnSCardListReaders(hContext, mszGroups, NULL, &pcsc_cchReaders);

		if (status == SCARD_S_SUCCESS)

		{

			*pMszReaders = calloc(1, pcsc_cchReaders);

			if (!*pMszReaders)

				return SCARD_E_NO_MEMORY;

			status = (LONG) g_PCSC.pfnSCardListReaders(hContext, mszGroups, *pMszReaders, &pcsc_cchReaders);

			if (status != SCARD_S_SUCCESS)

				free(*pMszReaders);

			else

				PCSC_AddMemoryBlock(hContext, *pMszReaders);

		}

	}

	else

	{

		status = (LONG) g_PCSC.pfnSCardListReaders(hContext, mszGroups, mszReaders, &pcsc_cchReaders);

	}

	status = PCSC_MapErrorCodeToWinSCard(status);

	*pcchReaders = (DWORD) pcsc_cchReaders;

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardListReadersA(SCARDCONTEXT hContext,

        LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)

{

	BOOL nullCardContext = FALSE;

	LONG status = SCARD_S_SUCCESS;

	if (!g_PCSC.pfnSCardListReaders)

		return SCARD_E_NO_SERVICE;

	if (!hContext)

	{

		status = PCSC_SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);

		if (status != SCARD_S_SUCCESS)

			return status;

		nullCardContext = TRUE;

	}

	if (!PCSC_LockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	status = PCSC_SCardListReaders_Internal(hContext, mszGroups, mszReaders, pcchReaders);

	if (!PCSC_UnlockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	if (nullCardContext)

	{

		status = PCSC_SCardReleaseContext(hContext);

	}

	return status;

}

WINSCARDAPI LONG WINAPI PCSC_SCardListReadersW(SCARDCONTEXT hContext,

        LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders)

{

	LPSTR mszGroupsA = NULL;

	LPSTR mszReadersA = NULL;

	LPSTR* pMszReadersA = &mszReadersA;

	LONG status = SCARD_S_SUCCESS;

	BOOL nullCardContext = FALSE;

	if (!g_PCSC.pfnSCardListReaders)

		return SCARD_E_NO_SERVICE;

	if (!hContext)

	{

		status = PCSC_SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);

		if (status != SCARD_S_SUCCESS)

			return status;

		nullCardContext = TRUE;

	}

	if (!PCSC_LockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;

	mszGroups = NULL; /* mszGroups is not supported by pcsc-lite */

	if (mszGroups)

		ConvertFromUnicode(CP_UTF8, 0, mszGroups, -1, (char**) &mszGroupsA, 0, NULL, NULL);

	status = PCSC_SCardListReaders_Internal(hContext, mszGroupsA, (LPSTR) &mszReadersA, pcchReaders);

	if (status == SCARD_S_SUCCESS)

	{

		*pcchReaders = ConvertToUnicode(CP_UTF8, 0, *pMszReadersA, *pcchReaders, (WCHAR**) mszReaders, 0);

		PCSC_AddMemoryBlock(hContext, mszReaders);

		PCSC_SCardFreeMemory_Internal(hContext, *pMszReadersA);

	}

	free(mszGroupsA);

	if (!PCSC_UnlockCardContext(hContext))

		return SCARD_E_INVALID_HANDLE;