smartcard_pcsc.c

 
#include <winpr/config.h>
 
#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/assert.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")
 
#define WINSCARD_LOAD_PROC_EX(module, pcsc, _fname, _name)                   \
  do                                                                       \
  {                                                                        \
    WINPR_PRAGMA_DIAG_PUSH                                               \
    WINPR_PRAGMA_DIAG_IGNORED_PEDANTIC                                   \
    pcsc.pfn##_fname = GetProcAddressAs(module, #_name, fnPCSC##_fname); \
    WINPR_PRAGMA_DIAG_POP                                                \
  } while (0)
 
#define WINSCARD_LOAD_PROC(module, pcsc, _name) WINSCARD_LOAD_PROC_EX(module, pcsc, _name, _name)
 
//#define DISABLE_PCSC_SCARD_AUTOALLOCATE
#include "smartcard_pcsc.h"
 
#define PCSC_SCARD_PCI_T0 (&g_PCSC_rgSCardT0Pci)
#define PCSC_SCARD_PCI_T1 (&g_PCSC_rgSCardT1Pci)
#define PCSC_SCARD_PCI_RAW (&g_PCSC_rgSCardRawPci)
 
typedef PCSC_LONG (*fnPCSCSCardEstablishContext)(PCSC_DWORD dwScope, LPCVOID pvReserved1,
                                                 LPCVOID pvReserved2, LPSCARDCONTEXT phContext);
typedef PCSC_LONG (*fnPCSCSCardReleaseContext)(SCARDCONTEXT hContext);
typedef PCSC_LONG (*fnPCSCSCardIsValidContext)(SCARDCONTEXT hContext);
typedef PCSC_LONG (*fnPCSCSCardConnect)(SCARDCONTEXT hContext, LPCSTR szReader,
                                        PCSC_DWORD dwShareMode, PCSC_DWORD dwPreferredProtocols,
                                        LPSCARDHANDLE phCard, PCSC_LPDWORD pdwActiveProtocol);
typedef PCSC_LONG (*fnPCSCSCardReconnect)(SCARDHANDLE hCard, PCSC_DWORD dwShareMode,
                                          PCSC_DWORD dwPreferredProtocols,
                                          PCSC_DWORD dwInitialization,
                                          PCSC_LPDWORD pdwActiveProtocol);
typedef PCSC_LONG (*fnPCSCSCardDisconnect)(SCARDHANDLE hCard, PCSC_DWORD dwDisposition);
typedef PCSC_LONG (*fnPCSCSCardBeginTransaction)(SCARDHANDLE hCard);
typedef PCSC_LONG (*fnPCSCSCardEndTransaction)(SCARDHANDLE hCard, PCSC_DWORD dwDisposition);
typedef PCSC_LONG (*fnPCSCSCardStatus)(SCARDHANDLE hCard, LPSTR mszReaderName,
                                       PCSC_LPDWORD pcchReaderLen, PCSC_LPDWORD pdwState,
                                       PCSC_LPDWORD pdwProtocol, LPBYTE pbAtr,
                                       PCSC_LPDWORD pcbAtrLen);
typedef PCSC_LONG (*fnPCSCSCardGetStatusChange)(SCARDCONTEXT hContext, PCSC_DWORD dwTimeout,
                                                PCSC_SCARD_READERSTATE* rgReaderStates,
                                                PCSC_DWORD cReaders);
typedef PCSC_LONG (*fnPCSCSCardControl)(SCARDHANDLE hCard, PCSC_DWORD dwControlCode,
                                        LPCVOID pbSendBuffer, PCSC_DWORD cbSendLength,
                                        LPVOID pbRecvBuffer, PCSC_DWORD cbRecvLength,
                                        PCSC_LPDWORD lpBytesReturned);
typedef PCSC_LONG (*fnPCSCSCardTransmit)(SCARDHANDLE hCard, const PCSC_SCARD_IO_REQUEST* pioSendPci,
                                         LPCBYTE pbSendBuffer, PCSC_DWORD cbSendLength,
                                         PCSC_SCARD_IO_REQUEST* pioRecvPci, LPBYTE pbRecvBuffer,
                                         PCSC_LPDWORD pcbRecvLength);
typedef PCSC_LONG (*fnPCSCSCardListReaderGroups)(SCARDCONTEXT hContext, LPSTR mszGroups,
                                                 PCSC_LPDWORD pcchGroups);
typedef PCSC_LONG (*fnPCSCSCardListReaders)(SCARDCONTEXT hContext, LPCSTR mszGroups,
                                            LPSTR mszReaders, PCSC_LPDWORD pcchReaders);
typedef PCSC_LONG (*fnPCSCSCardFreeMemory)(SCARDCONTEXT hContext, LPCVOID pvMem);
typedef PCSC_LONG (*fnPCSCSCardCancel)(SCARDCONTEXT hContext);
typedef PCSC_LONG (*fnPCSCSCardGetAttrib)(SCARDHANDLE hCard, PCSC_DWORD dwAttrId, LPBYTE pbAttr,
                                          PCSC_LPDWORD pcbAttrLen);
typedef PCSC_LONG (*fnPCSCSCardSetAttrib)(SCARDHANDLE hCard, PCSC_DWORD dwAttrId, LPCBYTE pbAttr,
                                          PCSC_DWORD cbAttrLen);
 
typedef struct
{
  fnPCSCSCardEstablishContext pfnSCardEstablishContext;
  fnPCSCSCardReleaseContext pfnSCardReleaseContext;
  fnPCSCSCardIsValidContext pfnSCardIsValidContext;
  fnPCSCSCardConnect pfnSCardConnect;
  fnPCSCSCardReconnect pfnSCardReconnect;
  fnPCSCSCardDisconnect pfnSCardDisconnect;
  fnPCSCSCardBeginTransaction pfnSCardBeginTransaction;
  fnPCSCSCardEndTransaction pfnSCardEndTransaction;
  fnPCSCSCardStatus pfnSCardStatus;
  fnPCSCSCardGetStatusChange pfnSCardGetStatusChange;
  fnPCSCSCardControl pfnSCardControl;
  fnPCSCSCardTransmit pfnSCardTransmit;
  fnPCSCSCardListReaderGroups pfnSCardListReaderGroups;
  fnPCSCSCardListReaders pfnSCardListReaders;
  fnPCSCSCardFreeMemory pfnSCardFreeMemory;
  fnPCSCSCardCancel pfnSCardCancel;
  fnPCSCSCardGetAttrib pfnSCardGetAttrib;
  fnPCSCSCardSetAttrib pfnSCardSetAttrib;
} PCSCFunctionTable;
 
typedef struct
{
  DWORD len;
  DWORD freshness;
  BYTE* data;
} PCSC_CACHE_ITEM;
 
typedef struct
{
  SCARDHANDLE owner;
  CRITICAL_SECTION lock;
  SCARDCONTEXT hContext;
  DWORD dwCardHandleCount;
  BOOL isTransactionLocked;
  wHashTable* cache;
} PCSC_SCARDCONTEXT;
 
typedef struct
{
  BOOL shared;
  SCARDCONTEXT hSharedContext;
} PCSC_SCARDHANDLE;
 
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;
 
static const char SMARTCARD_PNP_NOTIFICATION_A[] = "\\\\?PnP?\\Notification";
 
static const PCSC_SCARD_IO_REQUEST g_PCSC_rgSCardT0Pci = { SCARD_PROTOCOL_T0,
                                                         sizeof(PCSC_SCARD_IO_REQUEST) };
static const PCSC_SCARD_IO_REQUEST g_PCSC_rgSCardT1Pci = { SCARD_PROTOCOL_T1,
                                                         sizeof(PCSC_SCARD_IO_REQUEST) };
static const PCSC_SCARD_IO_REQUEST g_PCSC_rgSCardRawPci = { PCSC_SCARD_PROTOCOL_RAW,
                                                          sizeof(PCSC_SCARD_IO_REQUEST) };
 
static LONG WINAPI PCSC_SCardFreeMemory_Internal(SCARDCONTEXT hContext, LPVOID pvMem);
static LONG WINAPI PCSC_SCardEstablishContext_Internal(DWORD dwScope, LPCVOID pvReserved1,
                                                       LPCVOID pvReserved2,
                                                       LPSCARDCONTEXT phContext);
static LONG WINAPI PCSC_SCardReleaseContext_Internal(SCARDCONTEXT hContext);
 
static LONG PCSC_SCard_LogError(const char* what)
{
  WLog_WARN(TAG, "Missing function pointer %s=NULL", what);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG PCSC_MapErrorCodeToWinSCard(PCSC_LONG errorCode)
{
  if (errorCode != SCARD_S_SUCCESS)
  {
    if (errorCode == SCARD_E_UNEXPECTED)
      errorCode = SCARD_E_UNSUPPORTED_FEATURE;
  }
 
  return (LONG)errorCode;
}
 
static DWORD PCSC_ConvertCardStateToWinSCard(DWORD dwCardState, PCSC_LONG status)
{
  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(PCSC_DWORD dwProtocols)
{
  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 (DWORD)dwProtocols;
}
 
static DWORD PCSC_ConvertProtocolsFromWinSCard(DWORD dwProtocols)
{
  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 = NULL;
 
  if (!g_CardContexts)
    return NULL;
 
  pContext = (PCSC_SCARDCONTEXT*)ListDictionary_GetItemValue(g_CardContexts, (void*)hContext);
 
  if (!pContext)
    return NULL;
 
  return pContext;
}
 
static void pcsc_cache_item_free(void* ptr)
{
  PCSC_CACHE_ITEM* data = ptr;
  if (data)
    free(data->data);
  free(data);
}
 
static PCSC_SCARDCONTEXT* PCSC_EstablishCardContext(SCARDCONTEXT hContext)
{
  PCSC_SCARDCONTEXT* pContext = NULL;
  pContext = (PCSC_SCARDCONTEXT*)calloc(1, sizeof(PCSC_SCARDCONTEXT));
 
  if (!pContext)
    return NULL;
 
  pContext->hContext = hContext;
 
  if (!InitializeCriticalSectionAndSpinCount(&(pContext->lock), 4000))
    goto error_spinlock;
 
  pContext->cache = HashTable_New(FALSE);
  if (!pContext->cache)
    goto errors;
  if (!HashTable_SetupForStringData(pContext->cache, FALSE))
    goto errors;
  {
    wObject* obj = HashTable_ValueObject(pContext->cache);
    obj->fnObjectFree = pcsc_cache_item_free;
  }
 
  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:
  HashTable_Free(pContext->cache);
  DeleteCriticalSection(&(pContext->lock));
error_spinlock:
  free(pContext);
  return NULL;
}
 
static void PCSC_ReleaseCardContext(SCARDCONTEXT hContext)
{
  PCSC_SCARDCONTEXT* pContext = NULL;
  pContext = PCSC_GetCardContextData(hContext);
 
  if (!pContext)
  {
    WLog_ERR(TAG, "PCSC_ReleaseCardContext: null pContext!");
    return;
  }
 
  DeleteCriticalSection(&(pContext->lock));
  HashTable_Free(pContext->cache);
  free(pContext);
 
  if (!g_CardContexts)
    return;
 
  ListDictionary_Remove(g_CardContexts, (void*)hContext);
}
 
static BOOL PCSC_LockCardContext(SCARDCONTEXT hContext)
{
  PCSC_SCARDCONTEXT* pContext = NULL;
  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 = NULL;
  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 = NULL;
 
  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 = NULL;
  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 = NULL;
  PCSC_SCARDCONTEXT* pContext = NULL;
  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 = NULL;
  PCSC_SCARDCONTEXT* pContext = NULL;
  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_Take(g_MemoryBlocks, pvMem);
}
 
static 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 */
  PCSC_LONG status = SCARD_S_SUCCESS;
 
  if (!g_PCSC.pfnSCardEstablishContext)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardEstablishContext");
 
  status =
      g_PCSC.pfnSCardEstablishContext(SCARD_SCOPE_SYSTEM, pvReserved1, pvReserved2, phContext);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1,
                                              LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
{
  LONG status = 0;
 
  status = PCSC_SCardEstablishContext_Internal(dwScope, pvReserved1, pvReserved2, phContext);
 
  if (status == SCARD_S_SUCCESS)
    PCSC_EstablishCardContext(*phContext);
 
  return status;
}
 
static LONG WINAPI PCSC_SCardReleaseContext_Internal(SCARDCONTEXT hContext)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
 
  if (!g_PCSC.pfnSCardReleaseContext)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardReleaseContext");
 
  if (!hContext)
  {
    WLog_ERR(TAG, "SCardReleaseContext: null hContext");
    return PCSC_MapErrorCodeToWinSCard(status);
  }
 
  status = g_PCSC.pfnSCardReleaseContext(hContext);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static 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;
}
 
static LONG WINAPI PCSC_SCardIsValidContext(SCARDCONTEXT hContext)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
 
  if (!g_PCSC.pfnSCardIsValidContext)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardIsValidContext");
 
  status = g_PCSC.pfnSCardIsValidContext(hContext);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardListReaderGroups_Internal(SCARDCONTEXT hContext, LPSTR mszGroups,
                                                       LPDWORD pcchGroups)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  BOOL pcchGroupsAlloc = FALSE;
  PCSC_DWORD pcsc_cchGroups = 0;
 
  if (!pcchGroups)
    return SCARD_E_INVALID_PARAMETER;
 
  if (!g_PCSC.pfnSCardListReaderGroups)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardListReaderGroups");
 
  if (*pcchGroups == SCARD_AUTOALLOCATE)
    pcchGroupsAlloc = TRUE;
 
  pcsc_cchGroups = pcchGroupsAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD)*pcchGroups;
 
  if (pcchGroupsAlloc && !g_SCardAutoAllocate)
  {
    pcsc_cchGroups = 0;
    status = g_PCSC.pfnSCardListReaderGroups(hContext, NULL, &pcsc_cchGroups);
 
    if (status == SCARD_S_SUCCESS)
    {
      LPSTR tmp = calloc(1, pcsc_cchGroups);
 
      if (!tmp)
        return SCARD_E_NO_MEMORY;
 
      status = g_PCSC.pfnSCardListReaderGroups(hContext, tmp, &pcsc_cchGroups);
 
      if (status != SCARD_S_SUCCESS)
      {
        free(tmp);
        tmp = NULL;
      }
      else
        PCSC_AddMemoryBlock(hContext, tmp);
 
      *(LPSTR*)mszGroups = tmp;
    }
  }
  else
  {
    status = g_PCSC.pfnSCardListReaderGroups(hContext, mszGroups, &pcsc_cchGroups);
  }
 
  *pcchGroups = (DWORD)pcsc_cchGroups;
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardListReaderGroupsA(SCARDCONTEXT hContext, LPSTR mszGroups,
                                               LPDWORD pcchGroups)
{
  LONG status = SCARD_S_SUCCESS;
 
  if (!g_PCSC.pfnSCardListReaderGroups)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardListReaderGroups");
 
  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;
}
 
static 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 PCSC_SCard_LogError("g_PCSC.pfnSCardListReaderGroups");
 
  if (!PCSC_LockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  status = PCSC_SCardListReaderGroups_Internal(hContext, (LPSTR)&mszGroupsA, pcchGroups);
 
  if (status == SCARD_S_SUCCESS)
  {
    size_t size = 0;
    WCHAR* str = ConvertMszUtf8NToWCharAlloc(*pMszGroupsA, *pcchGroups, &size);
    if (!str)
      return SCARD_E_NO_MEMORY;
    *(WCHAR**)mszGroups = str;
    *pcchGroups = (DWORD)size;
    PCSC_AddMemoryBlock(hContext, str);
    PCSC_SCardFreeMemory_Internal(hContext, *pMszGroupsA);
  }
 
  if (!PCSC_UnlockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  return status;
}
 
static LONG WINAPI PCSC_SCardListReaders_Internal(SCARDCONTEXT hContext, LPCSTR mszGroups,
                                                  LPSTR mszReaders, LPDWORD pcchReaders)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  BOOL pcchReadersAlloc = FALSE;
  PCSC_DWORD pcsc_cchReaders = 0;
  if (!pcchReaders)
    return SCARD_E_INVALID_PARAMETER;
 
  if (!g_PCSC.pfnSCardListReaders)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardListReaders");
 
  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 = g_PCSC.pfnSCardListReaders(hContext, mszGroups, NULL, &pcsc_cchReaders);
 
    if (status == SCARD_S_SUCCESS)
    {
      char* tmp = calloc(1, pcsc_cchReaders);
 
      if (!tmp)
        return SCARD_E_NO_MEMORY;
 
      status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, tmp, &pcsc_cchReaders);
 
      if (status != SCARD_S_SUCCESS)
      {
        free(tmp);
        tmp = NULL;
      }
      else
        PCSC_AddMemoryBlock(hContext, tmp);
 
      *(char**)mszReaders = tmp;
    }
  }
  else
  {
    status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, mszReaders, &pcsc_cchReaders);
  }
 
  *pcchReaders = (DWORD)pcsc_cchReaders;
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static 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 PCSC_SCard_LogError("g_PCSC.pfnSCardListReaders");
 
  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;
}
 
static LONG WINAPI PCSC_SCardListReadersW(SCARDCONTEXT hContext, LPCWSTR mszGroups,
                                          LPWSTR mszReaders, LPDWORD pcchReaders)
{
  LPSTR mszGroupsA = NULL;
  LPSTR mszReadersA = NULL;
  LONG status = SCARD_S_SUCCESS;
  BOOL nullCardContext = FALSE;
 
  if (!g_PCSC.pfnSCardListReaders)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardListReaders");
 
  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)
  {
    mszGroupsA = ConvertWCharToUtf8Alloc(mszGroups, NULL);
    if (!mszGroups)
      return SCARD_E_NO_MEMORY;
  }
 
  union
  {
    LPSTR* ppc;
    LPSTR pc;
  } cnv;
  cnv.ppc = &mszReadersA;
 
  status = PCSC_SCardListReaders_Internal(hContext, mszGroupsA, cnv.pc, pcchReaders);
  if (status == SCARD_S_SUCCESS)
  {
    size_t size = 0;
    WCHAR* str = ConvertMszUtf8NToWCharAlloc(mszReadersA, *pcchReaders, &size);
    PCSC_SCardFreeMemory_Internal(hContext, mszReadersA);
    if (!str || (size > UINT32_MAX))
    {
      free(mszGroupsA);
      return SCARD_E_NO_MEMORY;
    }
    *(LPWSTR*)mszReaders = str;
    *pcchReaders = (DWORD)size;
    PCSC_AddMemoryBlock(hContext, str);
  }
 
  free(mszGroupsA);
 
  if (!PCSC_UnlockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  if (nullCardContext)
  {
    status = PCSC_SCardReleaseContext(hContext);
  }
 
  return status;
}
 
typedef struct
{
  BYTE atr[64];
  size_t atrLen;
  const char* cardName;
} PcscKnownAtr;
 
static PcscKnownAtr knownAtrs[] = {
  /* Yubico YubiKey 5 NFC (PKI) */
  { { 0x3B, 0xFD, 0x13, 0x00, 0x00, 0x81, 0x31, 0xFE, 0x15, 0x80, 0x73, 0xC0,
      0x21, 0xC0, 0x57, 0x59, 0x75, 0x62, 0x69, 0x4B, 0x65, 0x79, 0x40 },
    23,
    "NIST SP 800-73 [PIV]" },
  /* PIVKey C910 PKI Smart Card (eID) */
  { { 0x3B, 0xFC, 0x18, 0x00, 0x00, 0x81, 0x31, 0x80, 0x45, 0x90, 0x67,
      0x46, 0x4A, 0x00, 0x64, 0x16, 0x06, 0xF2, 0x72, 0x7E, 0x00, 0xE0 },
    22,
    "PIVKey Feitian (E0)" }
};
 
#ifndef ARRAY_LENGTH
#define ARRAY_LENGTH(a) (sizeof(a) / sizeof(a)[0])
#endif
 
static const char* findCardByAtr(LPCBYTE pbAtr)
{
  for (size_t i = 0; i < ARRAY_LENGTH(knownAtrs); i++)
  {
    if (memcmp(knownAtrs[i].atr, pbAtr, knownAtrs[i].atrLen) == 0)
      return knownAtrs[i].cardName;
  }
 
  return NULL;
}
 
static LONG WINAPI PCSC_SCardListCardsA(SCARDCONTEXT hContext, LPCBYTE pbAtr,
                                        LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount,
                                        CHAR* mszCards, LPDWORD pcchCards)
{
  const char* cardName = NULL;
  DWORD outputLen = 1;
  CHAR* output = NULL;
  BOOL autoAllocate = 0;
 
  if (!pbAtr || rgquidInterfaces || cguidInterfaceCount)
    return SCARD_E_UNSUPPORTED_FEATURE;
 
  if (!pcchCards)
    return SCARD_E_INVALID_PARAMETER;
 
  autoAllocate = (*pcchCards == SCARD_AUTOALLOCATE);
 
  cardName = findCardByAtr(pbAtr);
  if (cardName)
    outputLen += strlen(cardName) + 1;
 
  *pcchCards = outputLen;
  if (autoAllocate)
  {
    output = malloc(outputLen);
    if (!output)
      return SCARD_E_NO_MEMORY;
 
    *((LPSTR*)mszCards) = output;
  }
  else
  {
    if (!mszCards)
      return SCARD_S_SUCCESS;
 
    if (*pcchCards < outputLen)
      return SCARD_E_INSUFFICIENT_BUFFER;
 
    output = mszCards;
  }
 
  if (cardName)
  {
    size_t toCopy = strlen(cardName) + 1;
    memcpy(output, cardName, toCopy);
    output += toCopy;
  }
 
  *output = '\0';
 
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardListCardsW(SCARDCONTEXT hContext, LPCBYTE pbAtr,
                                        LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount,
                                        WCHAR* mszCards, LPDWORD pcchCards)
{
  const char* cardName = NULL;
  DWORD outputLen = 1;
  WCHAR* output = NULL;
  BOOL autoAllocate = 0;
 
  if (!pbAtr || rgquidInterfaces || cguidInterfaceCount)
    return SCARD_E_UNSUPPORTED_FEATURE;
 
  if (!pcchCards)
    return SCARD_E_INVALID_PARAMETER;
 
  autoAllocate = (*pcchCards == SCARD_AUTOALLOCATE);
 
  cardName = findCardByAtr(pbAtr);
  if (cardName)
    outputLen += strlen(cardName) + 1;
 
  *pcchCards = outputLen;
  if (autoAllocate)
  {
    output = calloc(outputLen, sizeof(WCHAR));
    if (!output)
      return SCARD_E_NO_MEMORY;
 
    *((LPWSTR*)mszCards) = output;
  }
  else
  {
    if (!mszCards)
      return SCARD_S_SUCCESS;
 
    if (*pcchCards < outputLen)
      return SCARD_E_INSUFFICIENT_BUFFER;
 
    output = mszCards;
  }
 
  if (cardName)
  {
    size_t toCopy = strlen(cardName) + 1;
    if (ConvertUtf8ToWChar(cardName, output, toCopy) < 0)
      return SCARD_F_INTERNAL_ERROR;
    output += toCopy;
  }
 
  *output = 0;
 
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI
PCSC_SCardListInterfacesA(SCARDCONTEXT hContext, LPCSTR szCard, LPGUID pguidInterfaces,
                          LPDWORD pcguidInterfaces /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCard);
  WINPR_UNUSED(pguidInterfaces);
  WINPR_UNUSED(pcguidInterfaces);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI
PCSC_SCardListInterfacesW(SCARDCONTEXT hContext, LPCWSTR szCard, LPGUID pguidInterfaces,
                          LPDWORD pcguidInterfaces /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCard);
  WINPR_UNUSED(pguidInterfaces);
  WINPR_UNUSED(pcguidInterfaces);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetProviderIdA(SCARDCONTEXT hContext, LPCSTR szCard,
                                            LPGUID pguidProviderId)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCard);
  WINPR_UNUSED(pguidProviderId);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetProviderIdW(SCARDCONTEXT hContext, LPCWSTR szCard,
                                            LPGUID pguidProviderId)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCard);
  WINPR_UNUSED(pguidProviderId);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetCardTypeProviderNameA(
    SCARDCONTEXT hContext, LPCSTR szCardName, DWORD dwProviderId,
    CHAR* szProvider /* NOLINT(readability-non-const-parameter) */,
    LPDWORD pcchProvider /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  WINPR_UNUSED(dwProviderId);
  WINPR_UNUSED(szProvider);
  WINPR_UNUSED(pcchProvider);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetCardTypeProviderNameW(
    SCARDCONTEXT hContext, LPCWSTR szCardName, DWORD dwProviderId,
    WCHAR* szProvider /* NOLINT(readability-non-const-parameter) */,
    LPDWORD pcchProvider /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  WINPR_UNUSED(dwProviderId);
  WINPR_UNUSED(szProvider);
  WINPR_UNUSED(pcchProvider);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardIntroduceReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardIntroduceReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardForgetReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardForgetReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardIntroduceReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                              LPCSTR szDeviceName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szDeviceName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardIntroduceReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                              LPCWSTR szDeviceName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szDeviceName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardForgetReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardForgetReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardAddReaderToGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                               LPCSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardAddReaderToGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                               LPCWSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardRemoveReaderFromGroupA(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                                    LPCSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardRemoveReaderFromGroupW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                                    LPCWSTR szGroupName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szGroupName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardIntroduceCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName,
                                                LPCGUID pguidPrimaryProvider,
                                                LPCGUID rgguidInterfaces, DWORD dwInterfaceCount,
                                                LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  WINPR_UNUSED(pguidPrimaryProvider);
  WINPR_UNUSED(rgguidInterfaces);
  WINPR_UNUSED(dwInterfaceCount);
  WINPR_UNUSED(pbAtr);
  WINPR_UNUSED(pbAtrMask);
  WINPR_UNUSED(cbAtrLen);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardIntroduceCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName,
                                                LPCGUID pguidPrimaryProvider,
                                                LPCGUID rgguidInterfaces, DWORD dwInterfaceCount,
                                                LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  WINPR_UNUSED(pguidPrimaryProvider);
  WINPR_UNUSED(rgguidInterfaces);
  WINPR_UNUSED(dwInterfaceCount);
  WINPR_UNUSED(pbAtr);
  WINPR_UNUSED(pbAtrMask);
  WINPR_UNUSED(cbAtrLen);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardSetCardTypeProviderNameA(SCARDCONTEXT hContext, LPCSTR szCardName,
                                                      DWORD dwProviderId, LPCSTR szProvider)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  WINPR_UNUSED(dwProviderId);
  WINPR_UNUSED(szProvider);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardSetCardTypeProviderNameW(SCARDCONTEXT hContext, LPCWSTR szCardName,
                                                      DWORD dwProviderId, LPCWSTR szProvider)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  WINPR_UNUSED(dwProviderId);
  WINPR_UNUSED(szProvider);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardForgetCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardForgetCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szCardName);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardFreeMemory_Internal(SCARDCONTEXT hContext, LPVOID pvMem)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
 
  if (PCSC_RemoveMemoryBlock(hContext, pvMem))
  {
    free((void*)pvMem);
    status = SCARD_S_SUCCESS;
  }
  else
  {
    if (g_PCSC.pfnSCardFreeMemory)
    {
      status = g_PCSC.pfnSCardFreeMemory(hContext, pvMem);
    }
  }
 
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardFreeMemory(SCARDCONTEXT hContext, LPVOID pvMem)
{
  LONG status = SCARD_S_SUCCESS;
 
  if (hContext)
  {
    if (!PCSC_LockCardContext(hContext))
      return SCARD_E_INVALID_HANDLE;
  }
 
  status = PCSC_SCardFreeMemory_Internal(hContext, pvMem);
 
  if (hContext)
  {
    if (!PCSC_UnlockCardContext(hContext))
      return SCARD_E_INVALID_HANDLE;
  }
 
  return status;
}
 
static HANDLE WINAPI PCSC_SCardAccessStartedEvent(void)
{
  LONG status = 0;
  SCARDCONTEXT hContext = 0;
 
  status = PCSC_SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
 
  if (status != SCARD_S_SUCCESS)
    return NULL;
 
  status = PCSC_SCardReleaseContext(hContext);
 
  if (status != SCARD_S_SUCCESS)
    return NULL;
 
  if (!g_StartedEvent)
  {
    if (!(g_StartedEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
      return NULL;
 
    if (!SetEvent(g_StartedEvent))
    {
      (void)CloseHandle(g_StartedEvent);
      return NULL;
    }
  }
 
  g_StartedEventRefCount++;
  return g_StartedEvent;
}
 
static void WINAPI PCSC_SCardReleaseStartedEvent(void)
{
  g_StartedEventRefCount--;
 
  if (g_StartedEventRefCount == 0)
  {
    if (g_StartedEvent)
    {
      (void)CloseHandle(g_StartedEvent);
      g_StartedEvent = NULL;
    }
  }
}
 
static LONG WINAPI PCSC_SCardLocateCardsA(SCARDCONTEXT hContext, LPCSTR mszCards,
                                          LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(mszCards);
  WINPR_UNUSED(rgReaderStates);
  WINPR_UNUSED(cReaders);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardLocateCardsW(SCARDCONTEXT hContext, LPCWSTR mszCards,
                                          LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(mszCards);
  WINPR_UNUSED(rgReaderStates);
  WINPR_UNUSED(cReaders);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardLocateCardsByATRA(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
                                               DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates,
                                               DWORD cReaders)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(rgAtrMasks);
  WINPR_UNUSED(cAtrs);
  WINPR_UNUSED(rgReaderStates);
  WINPR_UNUSED(cReaders);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardLocateCardsByATRW(SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
                                               DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates,
                                               DWORD cReaders)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(rgAtrMasks);
  WINPR_UNUSED(cAtrs);
  WINPR_UNUSED(rgReaderStates);
  WINPR_UNUSED(cReaders);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetStatusChange_Internal(SCARDCONTEXT hContext, DWORD dwTimeout,
                                                      LPSCARD_READERSTATEA rgReaderStates,
                                                      DWORD cReaders)
{
  INT64* map = NULL;
  PCSC_DWORD cMappedReaders = 0;
  PCSC_SCARD_READERSTATE* states = NULL;
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_DWORD pcsc_dwTimeout = (PCSC_DWORD)dwTimeout;
  PCSC_DWORD pcsc_cReaders = (PCSC_DWORD)cReaders;
 
  if (!g_PCSC.pfnSCardGetStatusChange)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardGetStatusChange");
 
  if (!cReaders)
    return SCARD_S_SUCCESS;
 
  /* pcsc-lite interprets value 0 as INFINITE, work around the problem by using value 1 */
  pcsc_dwTimeout = pcsc_dwTimeout ? pcsc_dwTimeout : 1;
  map = (INT64*)calloc(pcsc_cReaders, sizeof(INT64));
 
  if (!map)
    return SCARD_E_NO_MEMORY;
 
  states = (PCSC_SCARD_READERSTATE*)calloc(pcsc_cReaders, sizeof(PCSC_SCARD_READERSTATE));
 
  if (!states)
  {
    free(map);
    return SCARD_E_NO_MEMORY;
  }
 
  PCSC_DWORD j = 0;
  for (PCSC_DWORD i = 0; i < pcsc_cReaders; i++)
  {
    if (!g_PnP_Notification)
    {
      LPSCARD_READERSTATEA reader = &rgReaderStates[i];
      if (!reader->szReader)
        continue;
      if (0 == _stricmp(reader->szReader, SMARTCARD_PNP_NOTIFICATION_A))
      {
        map[i] = -1; /* unmapped */
        continue;
      }
    }
 
    map[i] = (INT64)j;
    states[j].szReader = rgReaderStates[i].szReader;
    states[j].dwCurrentState = rgReaderStates[i].dwCurrentState;
    states[j].pvUserData = rgReaderStates[i].pvUserData;
    states[j].dwEventState = rgReaderStates[i].dwEventState;
    states[j].cbAtr = rgReaderStates[i].cbAtr;
    CopyMemory(&(states[j].rgbAtr), &(rgReaderStates[i].rgbAtr), PCSC_MAX_ATR_SIZE);
    j++;
  }
 
  cMappedReaders = j;
 
  if (cMappedReaders > 0)
  {
    status = g_PCSC.pfnSCardGetStatusChange(hContext, pcsc_dwTimeout, states, cMappedReaders);
  }
  else
  {
    status = SCARD_S_SUCCESS;
  }
 
  for (PCSC_DWORD i = 0; i < pcsc_cReaders; i++)
  {
    if (map[i] < 0)
      continue; /* unmapped */
 
    PCSC_DWORD k = (PCSC_DWORD)map[i];
    rgReaderStates[i].dwCurrentState = (DWORD)states[k].dwCurrentState;
    rgReaderStates[i].cbAtr = (DWORD)states[k].cbAtr;
    CopyMemory(&(rgReaderStates[i].rgbAtr), &(states[k].rgbAtr), PCSC_MAX_ATR_SIZE);
    rgReaderStates[i].dwEventState = (DWORD)states[k].dwEventState;
  }
 
  free(map);
  free(states);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardGetStatusChangeA(SCARDCONTEXT hContext, DWORD dwTimeout,
                                              LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
{
  LONG status = SCARD_S_SUCCESS;
 
  if (!PCSC_LockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  status = PCSC_SCardGetStatusChange_Internal(hContext, dwTimeout, rgReaderStates, cReaders);
 
  if (!PCSC_UnlockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  return status;
}
 
static LONG WINAPI PCSC_SCardGetStatusChangeW(SCARDCONTEXT hContext, DWORD dwTimeout,
                                              LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
{
  LPSCARD_READERSTATEA states = NULL;
  LONG status = SCARD_S_SUCCESS;
 
  if (!g_PCSC.pfnSCardGetStatusChange)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardGetStatusChange");
 
  if (!PCSC_LockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  states = (LPSCARD_READERSTATEA)calloc(cReaders, sizeof(SCARD_READERSTATEA));
 
  if (!states)
  {
    (void)PCSC_UnlockCardContext(hContext);
    return SCARD_E_NO_MEMORY;
  }
 
  for (DWORD index = 0; index < cReaders; index++)
  {
    const LPSCARD_READERSTATEW curReader = &rgReaderStates[index];
    LPSCARD_READERSTATEA cur = &states[index];
 
    cur->szReader = ConvertWCharToUtf8Alloc(curReader->szReader, NULL);
    cur->pvUserData = curReader->pvUserData;
    cur->dwCurrentState = curReader->dwCurrentState;
    cur->dwEventState = curReader->dwEventState;
    cur->cbAtr = curReader->cbAtr;
    CopyMemory(&(cur->rgbAtr), &(curReader->rgbAtr), ARRAYSIZE(cur->rgbAtr));
  }
 
  status = PCSC_SCardGetStatusChange_Internal(hContext, dwTimeout, states, cReaders);
 
  for (DWORD index = 0; index < cReaders; index++)
  {
    free((void*)states[index].szReader);
    rgReaderStates[index].pvUserData = states[index].pvUserData;
    rgReaderStates[index].dwCurrentState = states[index].dwCurrentState;
    rgReaderStates[index].dwEventState = states[index].dwEventState;
    rgReaderStates[index].cbAtr = states[index].cbAtr;
    CopyMemory(&(rgReaderStates[index].rgbAtr), &(states[index].rgbAtr), 36);
  }
 
  free(states);
 
  if (!PCSC_UnlockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  return status;
}
 
static LONG WINAPI PCSC_SCardCancel(SCARDCONTEXT hContext)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
 
  if (!g_PCSC.pfnSCardCancel)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardCancel");
 
  status = g_PCSC.pfnSCardCancel(hContext);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardConnect_Internal(SCARDCONTEXT hContext, LPCSTR szReader,
                                              DWORD dwShareMode, DWORD dwPreferredProtocols,
                                              LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
{
  BOOL shared = 0;
  const char* szReaderPCSC = NULL;
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_DWORD pcsc_dwShareMode = (PCSC_DWORD)dwShareMode;
  PCSC_DWORD pcsc_dwPreferredProtocols = 0;
  PCSC_DWORD pcsc_dwActiveProtocol = 0;
 
  if (!g_PCSC.pfnSCardConnect)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardConnect");
 
  shared = (dwShareMode == SCARD_SHARE_DIRECT) ? TRUE : FALSE;
  PCSC_WaitForCardAccess(hContext, 0, shared);
  szReaderPCSC = szReader;
 
  if (pcsc_dwShareMode == SCARD_SHARE_DIRECT && dwPreferredProtocols == SCARD_PROTOCOL_UNDEFINED)
    pcsc_dwPreferredProtocols = SCARD_PROTOCOL_UNDEFINED;
  else
    pcsc_dwPreferredProtocols =
        (PCSC_DWORD)PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols);
 
  status = g_PCSC.pfnSCardConnect(hContext, szReaderPCSC, pcsc_dwShareMode,
                                  pcsc_dwPreferredProtocols, phCard, &pcsc_dwActiveProtocol);
 
  if (status == SCARD_S_SUCCESS)
  {
    pCard = PCSC_ConnectCardHandle(hContext, *phCard);
    *pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD)pcsc_dwActiveProtocol);
    pCard->shared = shared;
 
    // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ListDictionary_Add takes ownership of pCard
    PCSC_WaitForCardAccess(hContext, pCard->hSharedContext, shared);
  }
 
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardConnectA(SCARDCONTEXT hContext, LPCSTR szReader, DWORD dwShareMode,
                                      DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
                                      LPDWORD pdwActiveProtocol)
{
  LONG status = SCARD_S_SUCCESS;
 
  if (!PCSC_LockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  status = PCSC_SCardConnect_Internal(hContext, szReader, dwShareMode, dwPreferredProtocols,
                                      phCard, pdwActiveProtocol);
 
  if (!PCSC_UnlockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  return status;
}
 
static LONG WINAPI PCSC_SCardConnectW(SCARDCONTEXT hContext, LPCWSTR szReader, DWORD dwShareMode,
                                      DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
                                      LPDWORD pdwActiveProtocol)
{
  LPSTR szReaderA = NULL;
  LONG status = SCARD_S_SUCCESS;
 
  if (!PCSC_LockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  if (szReader)
  {
    szReaderA = ConvertWCharToUtf8Alloc(szReader, NULL);
    if (!szReaderA)
      return SCARD_E_INSUFFICIENT_BUFFER;
  }
 
  status = PCSC_SCardConnect_Internal(hContext, szReaderA, dwShareMode, dwPreferredProtocols,
                                      phCard, pdwActiveProtocol);
  free(szReaderA);
 
  if (!PCSC_UnlockCardContext(hContext))
    return SCARD_E_INVALID_HANDLE;
 
  return status;
}
 
static LONG WINAPI PCSC_SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
                                       DWORD dwPreferredProtocols, DWORD dwInitialization,
                                       LPDWORD pdwActiveProtocol)
{
  BOOL shared = 0;
  PCSC_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 PCSC_SCard_LogError("g_PCSC.pfnSCardReconnect");
 
  shared = (dwShareMode == SCARD_SHARE_DIRECT) ? TRUE : FALSE;
  PCSC_WaitForCardAccess(0, hCard, shared);
  pcsc_dwPreferredProtocols = (PCSC_DWORD)PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols);
  status = g_PCSC.pfnSCardReconnect(hCard, pcsc_dwShareMode, pcsc_dwPreferredProtocols,
                                    pcsc_dwInitialization, &pcsc_dwActiveProtocol);
 
  *pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD)pcsc_dwActiveProtocol);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_DWORD pcsc_dwDisposition = (PCSC_DWORD)dwDisposition;
 
  if (!g_PCSC.pfnSCardDisconnect)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardDisconnect");
 
  status = g_PCSC.pfnSCardDisconnect(hCard, pcsc_dwDisposition);
 
  if (status == SCARD_S_SUCCESS)
  {
    PCSC_DisconnectCardHandle(hCard);
  }
 
  PCSC_ReleaseCardAccess(0, hCard);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardBeginTransaction(SCARDHANDLE hCard)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_SCARDCONTEXT* pContext = NULL;
 
  if (!g_PCSC.pfnSCardBeginTransaction)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardBeginTransaction");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_HANDLE;
 
  pContext = PCSC_GetCardContextData(pCard->hSharedContext);
 
  if (!pContext)
    return SCARD_E_INVALID_HANDLE;
 
  if (pContext->isTransactionLocked)
    return SCARD_S_SUCCESS; /* disable nested transactions */
 
  status = g_PCSC.pfnSCardBeginTransaction(hCard);
 
  pContext->isTransactionLocked = TRUE;
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_SCARDCONTEXT* pContext = NULL;
  PCSC_DWORD pcsc_dwDisposition = (PCSC_DWORD)dwDisposition;
 
  if (!g_PCSC.pfnSCardEndTransaction)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardEndTransaction");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_HANDLE;
 
  pContext = PCSC_GetCardContextData(pCard->hSharedContext);
 
  if (!pContext)
    return SCARD_E_INVALID_HANDLE;
 
  PCSC_ReleaseCardAccess(0, hCard);
 
  if (!pContext->isTransactionLocked)
    return SCARD_S_SUCCESS; /* disable nested transactions */
 
  status = g_PCSC.pfnSCardEndTransaction(hCard, pcsc_dwDisposition);
 
  pContext->isTransactionLocked = FALSE;
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardCancelTransaction(SCARDHANDLE hCard)
{
  WINPR_UNUSED(hCard);
  return SCARD_S_SUCCESS;
}
 
/*
 * PCSC returns a string but Windows SCardStatus requires the return to be a multi string.
 * Therefore extra length checks and additional buffer allocation is required
 */
static LONG WINAPI PCSC_SCardStatus_Internal(SCARDHANDLE hCard, LPSTR mszReaderNames,
                                             LPDWORD pcchReaderLen, LPDWORD pdwState,
                                             LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen,
                                             BOOL unicode)
{
  PCSC_SCARDHANDLE* pCard = NULL;
  SCARDCONTEXT hContext = 0;
  PCSC_LONG status = 0;
  PCSC_DWORD pcsc_cchReaderLen = 0;
  PCSC_DWORD pcsc_cbAtrLen = 0;
  PCSC_DWORD pcsc_dwState = 0;
  PCSC_DWORD pcsc_dwProtocol = 0;
  BOOL allocateReader = FALSE;
  BOOL allocateAtr = FALSE;
  LPSTR readerNames = mszReaderNames;
  LPBYTE atr = pbAtr;
  LPSTR tReader = NULL;
  LPBYTE tATR = NULL;
 
  if (!g_PCSC.pfnSCardStatus)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardStatus");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
  hContext = PCSC_GetCardContextFromHandle(hCard);
 
  if (!hContext)
    return SCARD_E_INVALID_VALUE;
 
  status =
      g_PCSC.pfnSCardStatus(hCard, NULL, &pcsc_cchReaderLen, NULL, NULL, NULL, &pcsc_cbAtrLen);
 
  if (status != STATUS_SUCCESS)
    return PCSC_MapErrorCodeToWinSCard(status);
 
  pcsc_cchReaderLen++;
 
  if (unicode)
    pcsc_cchReaderLen *= 2;
 
  if (pcchReaderLen)
  {
    if (*pcchReaderLen == SCARD_AUTOALLOCATE)
      allocateReader = TRUE;
    else if (mszReaderNames && (*pcchReaderLen < pcsc_cchReaderLen))
      return SCARD_E_INSUFFICIENT_BUFFER;
    else
      pcsc_cchReaderLen = *pcchReaderLen;
  }
 
  if (pcbAtrLen)
  {
    if (*pcbAtrLen == SCARD_AUTOALLOCATE)
      allocateAtr = TRUE;
    else if (pbAtr && (*pcbAtrLen < pcsc_cbAtrLen))
      return SCARD_E_INSUFFICIENT_BUFFER;
    else
      pcsc_cbAtrLen = *pcbAtrLen;
  }
 
  if (allocateReader && pcsc_cchReaderLen > 0 && mszReaderNames)
  {
#ifdef __MACOSX__
 
    if (OSXVersion == 0x10100000)
      pcsc_cchReaderLen++;
 
#endif
    tReader = calloc(sizeof(CHAR), pcsc_cchReaderLen + 1);
 
    if (!tReader)
    {
      status = ERROR_NOT_ENOUGH_MEMORY;
      goto out_fail;
    }
 
    readerNames = tReader;
  }
 
  if (allocateAtr && pcsc_cbAtrLen > 0 && pbAtr)
  {
    tATR = calloc(1, pcsc_cbAtrLen);
 
    if (!tATR)
    {
      status = ERROR_NOT_ENOUGH_MEMORY;
      goto out_fail;
    }
 
    atr = tATR;
  }
 
  status = g_PCSC.pfnSCardStatus(hCard, readerNames, &pcsc_cchReaderLen, &pcsc_dwState,
                                 &pcsc_dwProtocol, atr, &pcsc_cbAtrLen);
 
  if (status != STATUS_SUCCESS)
    goto out_fail;
 
  if (tATR)
  {
    PCSC_AddMemoryBlock(hContext, tATR);
    *(BYTE**)pbAtr = tATR;
  }
 
  if (tReader)
  {
    if (unicode)
    {
      size_t size = 0;
      WCHAR* tmp = ConvertMszUtf8NToWCharAlloc(tReader, pcsc_cchReaderLen + 1, &size);
 
      if (tmp == NULL)
      {
        status = ERROR_NOT_ENOUGH_MEMORY;
        goto out_fail;
      }
 
      free(tReader);
 
      PCSC_AddMemoryBlock(hContext, tmp);
      *(WCHAR**)mszReaderNames = tmp;
    }
    else
    {
      tReader[pcsc_cchReaderLen - 1] = '\0';
      PCSC_AddMemoryBlock(hContext, tReader);
      *(char**)mszReaderNames = tReader;
    }
  }
 
  pcsc_dwState &= 0xFFFF;
 
  if (pdwState)
    *pdwState = PCSC_ConvertCardStateToWinSCard((DWORD)pcsc_dwState, status);
 
  if (pdwProtocol)
    *pdwProtocol = PCSC_ConvertProtocolsToWinSCard((DWORD)pcsc_dwProtocol);
 
  if (pcbAtrLen)
    *pcbAtrLen = (DWORD)pcsc_cbAtrLen;
 
  if (pcchReaderLen)
  {
    WINPR_ASSERT(pcsc_cchReaderLen < UINT32_MAX);
    *pcchReaderLen = (DWORD)pcsc_cchReaderLen + 1u;
  }
 
  return (LONG)status;
out_fail:
  free(tReader);
  free(tATR);
  return (LONG)status;
}
 
static LONG WINAPI PCSC_SCardState(SCARDHANDLE hCard, LPDWORD pdwState, LPDWORD pdwProtocol,
                                   LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
  DWORD cchReaderLen = 0;
  SCARDCONTEXT hContext = 0;
  LPSTR mszReaderNames = NULL;
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  DWORD pcsc_dwState = 0;
  DWORD pcsc_dwProtocol = 0;
  DWORD pcsc_cbAtrLen = 0;
 
  if (pcbAtrLen)
    pcsc_cbAtrLen = (DWORD)*pcbAtrLen;
 
  if (!g_PCSC.pfnSCardStatus)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardStatus");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
  hContext = PCSC_GetCardContextFromHandle(hCard);
 
  if (!hContext)
    return SCARD_E_INVALID_VALUE;
 
  cchReaderLen = SCARD_AUTOALLOCATE;
  status = PCSC_SCardStatus_Internal(hCard, (LPSTR)&mszReaderNames, &cchReaderLen, &pcsc_dwState,
                                     &pcsc_dwProtocol, pbAtr, &pcsc_cbAtrLen, FALSE);
 
  if (mszReaderNames)
    PCSC_SCardFreeMemory_Internal(hContext, mszReaderNames);
 
  *pdwState = pcsc_dwState;
  *pdwProtocol = PCSC_ConvertProtocolsToWinSCard(pcsc_dwProtocol);
  if (pcbAtrLen)
    *pcbAtrLen = pcsc_cbAtrLen;
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardStatusA(SCARDHANDLE hCard, LPSTR mszReaderNames, LPDWORD pcchReaderLen,
                                     LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr,
                                     LPDWORD pcbAtrLen)
{
 
  return PCSC_SCardStatus_Internal(hCard, mszReaderNames, pcchReaderLen, pdwState, pdwProtocol,
                                   pbAtr, pcbAtrLen, FALSE);
}
 
static LONG WINAPI PCSC_SCardStatusW(SCARDHANDLE hCard, LPWSTR mszReaderNames,
                                     LPDWORD pcchReaderLen, LPDWORD pdwState, LPDWORD pdwProtocol,
                                     LPBYTE pbAtr, LPDWORD pcbAtrLen)
{
 
  return PCSC_SCardStatus_Internal(hCard, (LPSTR)mszReaderNames, pcchReaderLen, pdwState,
                                   pdwProtocol, pbAtr, pcbAtrLen, TRUE);
}
 
static LONG WINAPI PCSC_SCardTransmit(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci,
                                      LPCBYTE pbSendBuffer, DWORD cbSendLength,
                                      LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer,
                                      LPDWORD pcbRecvLength)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_DWORD cbExtraBytes = 0;
  BYTE* pbExtraBytes = NULL;
  BYTE* pcsc_pbExtraBytes = NULL;
  PCSC_DWORD pcsc_cbSendLength = (PCSC_DWORD)cbSendLength;
  PCSC_DWORD pcsc_cbRecvLength = 0;
  union
  {
    const PCSC_SCARD_IO_REQUEST* pcs;
    PCSC_SCARD_IO_REQUEST* ps;
    LPSCARD_IO_REQUEST lps;
    LPCSCARD_IO_REQUEST lpcs;
    BYTE* pb;
  } sendPci, recvPci, inRecvPci, inSendPci;
 
  sendPci.ps = NULL;
  recvPci.ps = NULL;
  inRecvPci.lps = pioRecvPci;
  inSendPci.lpcs = pioSendPci;
 
  if (!g_PCSC.pfnSCardTransmit)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardTransmit");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
 
  if (!pcbRecvLength)
    return SCARD_E_INVALID_PARAMETER;
 
  if (*pcbRecvLength == SCARD_AUTOALLOCATE)
    return SCARD_E_INVALID_PARAMETER;
 
  pcsc_cbRecvLength = (PCSC_DWORD)*pcbRecvLength;
 
  if (!inSendPci.lpcs)
  {
    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);
 
    if (status == SCARD_S_SUCCESS)
    {
      if (dwProtocol == SCARD_PROTOCOL_T0)
        sendPci.pcs = PCSC_SCARD_PCI_T0;
      else if (dwProtocol == SCARD_PROTOCOL_T1)
        sendPci.pcs = PCSC_SCARD_PCI_T1;
      else if (dwProtocol == PCSC_SCARD_PROTOCOL_RAW)
        sendPci.pcs = PCSC_SCARD_PCI_RAW;
    }
  }
  else
  {
    cbExtraBytes = inSendPci.lpcs->cbPciLength - sizeof(SCARD_IO_REQUEST);
    sendPci.ps = (PCSC_SCARD_IO_REQUEST*)malloc(sizeof(PCSC_SCARD_IO_REQUEST) + cbExtraBytes);
 
    if (!sendPci.ps)
      return SCARD_E_NO_MEMORY;
 
    sendPci.ps->dwProtocol = (PCSC_DWORD)inSendPci.lpcs->dwProtocol;
    sendPci.ps->cbPciLength = sizeof(PCSC_SCARD_IO_REQUEST) + cbExtraBytes;
    pbExtraBytes = &(inSendPci.pb)[sizeof(SCARD_IO_REQUEST)];
    pcsc_pbExtraBytes = &(sendPci.pb)[sizeof(PCSC_SCARD_IO_REQUEST)];
    CopyMemory(pcsc_pbExtraBytes, pbExtraBytes, cbExtraBytes);
  }
 
  if (inRecvPci.lps)
  {
    cbExtraBytes = inRecvPci.lps->cbPciLength - sizeof(SCARD_IO_REQUEST);
    recvPci.ps = (PCSC_SCARD_IO_REQUEST*)malloc(sizeof(PCSC_SCARD_IO_REQUEST) + cbExtraBytes);
 
    if (!recvPci.ps)
    {
      if (inSendPci.lpcs)
        free(sendPci.ps);
 
      return SCARD_E_NO_MEMORY;
    }
 
    recvPci.ps->dwProtocol = (PCSC_DWORD)inRecvPci.lps->dwProtocol;
    recvPci.ps->cbPciLength = sizeof(PCSC_SCARD_IO_REQUEST) + cbExtraBytes;
    pbExtraBytes = &(inRecvPci.pb)[sizeof(SCARD_IO_REQUEST)];
    pcsc_pbExtraBytes = &(recvPci.pb)[sizeof(PCSC_SCARD_IO_REQUEST)];
    CopyMemory(pcsc_pbExtraBytes, pbExtraBytes, cbExtraBytes);
  }
 
  status = g_PCSC.pfnSCardTransmit(hCard, sendPci.ps, pbSendBuffer, pcsc_cbSendLength, recvPci.ps,
                                   pbRecvBuffer, &pcsc_cbRecvLength);
 
  *pcbRecvLength = (DWORD)pcsc_cbRecvLength;
 
  if (inSendPci.lpcs)
    free(sendPci.ps); /* pcsc_pioSendPci is dynamically allocated only when pioSendPci is
                              non null */
 
  if (inRecvPci.lps)
  {
    cbExtraBytes = inRecvPci.lps->cbPciLength - sizeof(SCARD_IO_REQUEST);
    pbExtraBytes = &(inRecvPci.pb)[sizeof(SCARD_IO_REQUEST)];
    pcsc_pbExtraBytes = &(recvPci.pb)[sizeof(PCSC_SCARD_IO_REQUEST)];
    CopyMemory(pbExtraBytes, pcsc_pbExtraBytes, cbExtraBytes); /* copy extra bytes */
    free(recvPci.ps); /* pcsc_pioRecvPci is dynamically allocated only when pioRecvPci is
                              non null */
  }
 
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
// NOLINTNEXTLINE(readability-non-const-parameter)
static LONG WINAPI PCSC_SCardGetTransmitCount(SCARDHANDLE hCard, LPDWORD pcTransmitCount)
{
  WINPR_UNUSED(pcTransmitCount);
  PCSC_SCARDHANDLE* pCard = NULL;
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardControl(SCARDHANDLE hCard, DWORD dwControlCode, LPCVOID lpInBuffer,
                                     DWORD cbInBufferSize, LPVOID lpOutBuffer,
                                     DWORD cbOutBufferSize, LPDWORD lpBytesReturned)
{
  DWORD IoCtlFunction = 0;
  DWORD IoCtlDeviceType = 0;
  BOOL getFeatureRequest = FALSE;
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_DWORD pcsc_dwControlCode = 0;
  PCSC_DWORD pcsc_cbInBufferSize = (PCSC_DWORD)cbInBufferSize;
  PCSC_DWORD pcsc_cbOutBufferSize = (PCSC_DWORD)cbOutBufferSize;
  PCSC_DWORD pcsc_BytesReturned = 0;
 
  if (!g_PCSC.pfnSCardControl)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardControl");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
  IoCtlFunction = FUNCTION_FROM_CTL_CODE(dwControlCode);
  IoCtlDeviceType = DEVICE_TYPE_FROM_CTL_CODE(dwControlCode);
 
  if (dwControlCode == IOCTL_SMARTCARD_GET_FEATURE_REQUEST)
    getFeatureRequest = TRUE;
 
  if (IoCtlDeviceType == FILE_DEVICE_SMARTCARD)
    dwControlCode = PCSC_SCARD_CTL_CODE(IoCtlFunction);
 
  pcsc_dwControlCode = (PCSC_DWORD)dwControlCode;
  status = g_PCSC.pfnSCardControl(hCard, pcsc_dwControlCode, lpInBuffer, pcsc_cbInBufferSize,
                                  lpOutBuffer, pcsc_cbOutBufferSize, &pcsc_BytesReturned);
 
  *lpBytesReturned = (DWORD)pcsc_BytesReturned;
 
  if (getFeatureRequest)
  {
    UINT32 count = 0;
    PCSC_TLV_STRUCTURE* tlv = (PCSC_TLV_STRUCTURE*)lpOutBuffer;
 
    if ((*lpBytesReturned % sizeof(PCSC_TLV_STRUCTURE)) != 0)
      return SCARD_E_UNEXPECTED;
 
    count = *lpBytesReturned / sizeof(PCSC_TLV_STRUCTURE);
 
    for (DWORD index = 0; index < count; index++)
    {
      if (tlv[index].length != 4)
        return SCARD_E_UNEXPECTED;
    }
  }
 
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardGetAttrib_Internal(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,
                                                LPDWORD pcbAttrLen)
{
  SCARDCONTEXT hContext = 0;
  BOOL pcbAttrLenAlloc = FALSE;
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_DWORD pcsc_dwAttrId = (PCSC_DWORD)dwAttrId;
  PCSC_DWORD pcsc_cbAttrLen = 0;
 
  if (!g_PCSC.pfnSCardGetAttrib)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardGetAttrib");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
  hContext = PCSC_GetCardContextFromHandle(hCard);
 
  if (!hContext)
    return SCARD_E_INVALID_HANDLE;
 
  if (!pcbAttrLen)
    return SCARD_E_INVALID_PARAMETER;
 
  if (*pcbAttrLen == SCARD_AUTOALLOCATE)
  {
    if (!pbAttr)
      return SCARD_E_INVALID_PARAMETER;
    pcbAttrLenAlloc = TRUE;
  }
 
  pcsc_cbAttrLen = pcbAttrLenAlloc ? PCSC_SCARD_AUTOALLOCATE : (PCSC_DWORD)*pcbAttrLen;
 
  if (pcbAttrLenAlloc && !g_SCardAutoAllocate)
  {
    pcsc_cbAttrLen = 0;
    status = g_PCSC.pfnSCardGetAttrib(hCard, pcsc_dwAttrId, NULL, &pcsc_cbAttrLen);
 
    if (status == SCARD_S_SUCCESS)
    {
      BYTE* tmp = (BYTE*)calloc(1, pcsc_cbAttrLen);
 
      if (!tmp)
        return SCARD_E_NO_MEMORY;
 
      status = g_PCSC.pfnSCardGetAttrib(hCard, pcsc_dwAttrId, tmp, &pcsc_cbAttrLen);
 
      if (status != SCARD_S_SUCCESS)
      {
        free(tmp);
        tmp = NULL;
      }
      else
        PCSC_AddMemoryBlock(hContext, tmp);
      *(BYTE**)pbAttr = tmp;
    }
  }
  else
  {
    status = g_PCSC.pfnSCardGetAttrib(hCard, pcsc_dwAttrId, pbAttr, &pcsc_cbAttrLen);
  }
 
  if (status == SCARD_S_SUCCESS)
    *pcbAttrLen = (DWORD)pcsc_cbAttrLen;
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardGetAttrib_FriendlyName(SCARDHANDLE hCard, DWORD dwAttrId,
                                                    LPBYTE pbAttr, LPDWORD pcbAttrLen)
{
  size_t length = 0;
  char* namePCSC = NULL;
  char* pbAttrA = NULL;
  DWORD cbAttrLen = 0;
  WCHAR* pbAttrW = NULL;
  SCARDCONTEXT hContext = 0;
  LONG status = SCARD_S_SUCCESS;
 
  hContext = PCSC_GetCardContextFromHandle(hCard);
 
  if (!hContext)
    return SCARD_E_INVALID_HANDLE;
 
  if (!pcbAttrLen)
    return SCARD_E_INVALID_PARAMETER;
  cbAttrLen = *pcbAttrLen;
  *pcbAttrLen = SCARD_AUTOALLOCATE;
  status = PCSC_SCardGetAttrib_Internal(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME_A,
                                        (LPBYTE)&pbAttrA, pcbAttrLen);
 
  if (status != SCARD_S_SUCCESS)
  {
    *pcbAttrLen = SCARD_AUTOALLOCATE;
    status = PCSC_SCardGetAttrib_Internal(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME_W,
                                          (LPBYTE)&pbAttrW, pcbAttrLen);
 
    if (status != SCARD_S_SUCCESS)
      return status;
 
    namePCSC = ConvertMszWCharNToUtf8Alloc(pbAttrW, *pcbAttrLen, NULL);
    PCSC_SCardFreeMemory_Internal(hContext, pbAttrW);
  }
  else
  {
    namePCSC = _strdup(pbAttrA);
 
    if (!namePCSC)
      return SCARD_E_NO_MEMORY;
 
    PCSC_SCardFreeMemory_Internal(hContext, pbAttrA);
  }
 
  length = strlen(namePCSC);
 
  if (dwAttrId == SCARD_ATTR_DEVICE_FRIENDLY_NAME_W)
  {
    size_t size = 0;
    WCHAR* friendlyNameW = ConvertUtf8ToWCharAlloc(namePCSC, &size);
    /* length here includes null terminator */
 
    if (!friendlyNameW)
      status = SCARD_E_NO_MEMORY;
    else
    {
      length = size;
 
      if (cbAttrLen == SCARD_AUTOALLOCATE)
      {
        WINPR_ASSERT(length <= UINT32_MAX / sizeof(WCHAR));
        *(WCHAR**)pbAttr = friendlyNameW;
        *pcbAttrLen = (UINT32)length * sizeof(WCHAR);
        PCSC_AddMemoryBlock(hContext, friendlyNameW);
      }
      else
      {
        if ((length * 2) > cbAttrLen)
          status = SCARD_E_INSUFFICIENT_BUFFER;
        else
        {
          WINPR_ASSERT(length <= UINT32_MAX / sizeof(WCHAR));
          CopyMemory(pbAttr, (BYTE*)friendlyNameW, (length * sizeof(WCHAR)));
          *pcbAttrLen = (UINT32)length * sizeof(WCHAR);
        }
        free(friendlyNameW);
      }
    }
    free(namePCSC);
  }
  else
  {
    if (cbAttrLen == SCARD_AUTOALLOCATE)
    {
      *(CHAR**)pbAttr = namePCSC;
      WINPR_ASSERT(length <= UINT32_MAX);
      *pcbAttrLen = (UINT32)length;
      PCSC_AddMemoryBlock(hContext, namePCSC);
    }
    else
    {
      if ((length + 1) > cbAttrLen)
        status = SCARD_E_INSUFFICIENT_BUFFER;
      else
      {
        CopyMemory(pbAttr, namePCSC, length + 1);
        WINPR_ASSERT(length <= UINT32_MAX);
        *pcbAttrLen = (UINT32)length;
      }
      free(namePCSC);
    }
  }
 
  return status;
}
 
static LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr,
                                       LPDWORD pcbAttrLen)
{
  DWORD cbAttrLen = 0;
  SCARDCONTEXT hContext = 0;
  BOOL pcbAttrLenAlloc = FALSE;
  LONG status = SCARD_S_SUCCESS;
 
  if (NULL == pcbAttrLen)
    return SCARD_E_INVALID_PARAMETER;
 
  cbAttrLen = *pcbAttrLen;
 
  if (*pcbAttrLen == SCARD_AUTOALLOCATE)
  {
    if (NULL == pbAttr)
      return SCARD_E_INVALID_PARAMETER;
 
    pcbAttrLenAlloc = TRUE;
    *(BYTE**)pbAttr = NULL;
  }
  else
  {
    if (*pcbAttrLen > PCSC_MAX_BUFFER_SIZE)
      *pcbAttrLen = PCSC_MAX_BUFFER_SIZE;
  }
 
  hContext = PCSC_GetCardContextFromHandle(hCard);
 
  if (!hContext)
    return SCARD_E_INVALID_HANDLE;
 
  if ((dwAttrId == SCARD_ATTR_DEVICE_FRIENDLY_NAME_A) ||
      (dwAttrId == SCARD_ATTR_DEVICE_FRIENDLY_NAME_W))
  {
    status = PCSC_SCardGetAttrib_FriendlyName(hCard, dwAttrId, pbAttr, pcbAttrLen);
    return status;
  }
 
  status = PCSC_SCardGetAttrib_Internal(hCard, dwAttrId, pbAttr, pcbAttrLen);
 
  if (status == SCARD_S_SUCCESS)
  {
    if (dwAttrId == SCARD_ATTR_VENDOR_NAME)
    {
      if (pbAttr)
      {
        const char* vendorName = NULL;
 
        if (pcbAttrLenAlloc)
          vendorName = (char*)*(BYTE**)pbAttr;
        else
          vendorName = (char*)pbAttr;
 
        if (vendorName)
        {
          size_t len = strnlen(vendorName, *pcbAttrLen);
          WINPR_ASSERT(len <= UINT32_MAX);
          *pcbAttrLen = (DWORD)len;
        }
        else
          *pcbAttrLen = 0;
      }
    }
  }
  else
  {
 
    if (dwAttrId == SCARD_ATTR_CURRENT_PROTOCOL_TYPE)
    {
      if (!pcbAttrLenAlloc)
      {
        PCSC_DWORD dwState = 0;
        PCSC_DWORD cbAtrLen = 0;
        PCSC_DWORD dwProtocol = 0;
        PCSC_DWORD cchReaderLen = 0;
        status = (LONG)g_PCSC.pfnSCardStatus(hCard, NULL, &cchReaderLen, &dwState,
                                             &dwProtocol, NULL, &cbAtrLen);
 
        if (status == SCARD_S_SUCCESS)
        {
          if (cbAttrLen < sizeof(DWORD))
            return SCARD_E_INSUFFICIENT_BUFFER;
 
          *(DWORD*)pbAttr = PCSC_ConvertProtocolsToWinSCard(dwProtocol);
          *pcbAttrLen = sizeof(DWORD);
        }
      }
    }
    else if (dwAttrId == SCARD_ATTR_CHANNEL_ID)
    {
      if (!pcbAttrLenAlloc)
      {
        UINT32 channelType = 0x20; /* USB */
        UINT32 channelNumber = 0;
 
        if (cbAttrLen < sizeof(DWORD))
          return SCARD_E_INSUFFICIENT_BUFFER;
 
        status = SCARD_S_SUCCESS;
        *(DWORD*)pbAttr = (channelType << 16u) | channelNumber;
        *pcbAttrLen = sizeof(DWORD);
      }
    }
    else if (dwAttrId == SCARD_ATTR_VENDOR_IFD_TYPE)
    {
    }
    else if (dwAttrId == SCARD_ATTR_DEFAULT_CLK)
    {
    }
    else if (dwAttrId == SCARD_ATTR_DEFAULT_DATA_RATE)
    {
    }
    else if (dwAttrId == SCARD_ATTR_MAX_CLK)
    {
    }
    else if (dwAttrId == SCARD_ATTR_MAX_DATA_RATE)
    {
    }
    else if (dwAttrId == SCARD_ATTR_MAX_IFSD)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CHARACTERISTICS)
    {
    }
    else if (dwAttrId == SCARD_ATTR_DEVICE_SYSTEM_NAME_A)
    {
    }
    else if (dwAttrId == SCARD_ATTR_DEVICE_UNIT)
    {
    }
    else if (dwAttrId == SCARD_ATTR_POWER_MGMT_SUPPORT)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_CLK)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_F)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_D)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_N)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_CWT)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_BWT)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_IFSC)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_EBC_ENCODING)
    {
    }
    else if (dwAttrId == SCARD_ATTR_CURRENT_IFSD)
    {
    }
    else if (dwAttrId == SCARD_ATTR_ICC_TYPE_PER_ATR)
    {
    }
  }
 
  return status;
}
 
static LONG WINAPI PCSC_SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr,
                                       DWORD cbAttrLen)
{
  PCSC_LONG status = SCARD_S_SUCCESS;
  PCSC_SCARDHANDLE* pCard = NULL;
  PCSC_DWORD pcsc_dwAttrId = (PCSC_DWORD)dwAttrId;
  PCSC_DWORD pcsc_cbAttrLen = (PCSC_DWORD)cbAttrLen;
 
  if (!g_PCSC.pfnSCardSetAttrib)
    return PCSC_SCard_LogError("g_PCSC.pfnSCardSetAttrib");
 
  pCard = PCSC_GetCardHandleData(hCard);
 
  if (!pCard)
    return SCARD_E_INVALID_VALUE;
 
  PCSC_WaitForCardAccess(0, hCard, pCard->shared);
  status = g_PCSC.pfnSCardSetAttrib(hCard, pcsc_dwAttrId, pbAttr, pcsc_cbAttrLen);
  return PCSC_MapErrorCodeToWinSCard(status);
}
 
static LONG WINAPI PCSC_SCardUIDlgSelectCardA(LPOPENCARDNAMEA_EX pDlgStruc)
{
  WINPR_UNUSED(pDlgStruc);
 
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardUIDlgSelectCardW(LPOPENCARDNAMEW_EX pDlgStruc)
{
  WINPR_UNUSED(pDlgStruc);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_GetOpenCardNameA(LPOPENCARDNAMEA pDlgStruc)
{
  WINPR_UNUSED(pDlgStruc);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_GetOpenCardNameW(LPOPENCARDNAMEW pDlgStruc)
{
  WINPR_UNUSED(pDlgStruc);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardDlgExtendedError(void)
{
 
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static char* card_id_and_name_a(const UUID* CardIdentifier, LPCSTR LookupName)
{
  WINPR_ASSERT(CardIdentifier);
  WINPR_ASSERT(LookupName);
 
  size_t len = strlen(LookupName) + 34;
  char* id = malloc(len);
  if (!id)
    return NULL;
 
  (void)snprintf(id, len, "%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X\\%s",
                 CardIdentifier->Data1, CardIdentifier->Data2, CardIdentifier->Data3,
                 CardIdentifier->Data4[0], CardIdentifier->Data4[1], CardIdentifier->Data4[2],
                 CardIdentifier->Data4[3], CardIdentifier->Data4[4], CardIdentifier->Data4[5],
                 CardIdentifier->Data4[6], CardIdentifier->Data4[7], LookupName);
  return id;
}
 
static char* card_id_and_name_w(const UUID* CardIdentifier, LPCWSTR LookupName)
{
  char* res = NULL;
  char* tmp = ConvertWCharToUtf8Alloc(LookupName, NULL);
  if (!tmp)
    return NULL;
  res = card_id_and_name_a(CardIdentifier, tmp);
  free(tmp);
  return res;
}
 
static LONG WINAPI PCSC_SCardReadCacheA(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                        DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data,
                                        DWORD* DataLen)
{
  PCSC_CACHE_ITEM* data = NULL;
  PCSC_SCARDCONTEXT* ctx = PCSC_GetCardContextData(hContext);
  if (!ctx)
    return SCARD_E_INVALID_HANDLE;
 
  char* id = card_id_and_name_a(CardIdentifier, LookupName);
 
  data = HashTable_GetItemValue(ctx->cache, id);
  free(id);
  if (!data)
  {
    *DataLen = 0;
    return SCARD_W_CACHE_ITEM_NOT_FOUND;
  }
 
  if (FreshnessCounter != data->freshness)
  {
    *DataLen = 0;
    return SCARD_W_CACHE_ITEM_STALE;
  }
 
  if (*DataLen == SCARD_AUTOALLOCATE)
  {
    BYTE* mem = calloc(1, data->len);
    if (!mem)
      return SCARD_E_NO_MEMORY;
 
    if (!PCSC_AddMemoryBlock(hContext, mem))
    {
      free(mem);
      return SCARD_E_NO_MEMORY;
    }
 
    memcpy(mem, data->data, data->len);
    *(BYTE**)Data = mem;
  }
  else
    memcpy(Data, data->data, data->len);
  *DataLen = data->len;
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardReadCacheW(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                        DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data,
                                        DWORD* DataLen)
{
  PCSC_CACHE_ITEM* data = NULL;
  PCSC_SCARDCONTEXT* ctx = PCSC_GetCardContextData(hContext);
  if (!ctx)
    return SCARD_E_INVALID_HANDLE;
 
  char* id = card_id_and_name_w(CardIdentifier, LookupName);
 
  data = HashTable_GetItemValue(ctx->cache, id);
  free(id);
 
  if (!data)
  {
    *DataLen = 0;
    return SCARD_W_CACHE_ITEM_NOT_FOUND;
  }
 
  if (FreshnessCounter != data->freshness)
  {
    *DataLen = 0;
    return SCARD_W_CACHE_ITEM_STALE;
  }
 
  if (*DataLen == SCARD_AUTOALLOCATE)
  {
    BYTE* mem = calloc(1, data->len);
    if (!mem)
      return SCARD_E_NO_MEMORY;
 
    if (!PCSC_AddMemoryBlock(hContext, mem))
    {
      free(mem);
      return SCARD_E_NO_MEMORY;
    }
 
    memcpy(mem, data->data, data->len);
    *(BYTE**)Data = mem;
  }
  else
    memcpy(Data, data->data, data->len);
  *DataLen = data->len;
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardWriteCacheA(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                         DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data,
                                         DWORD DataLen)
{
  PCSC_CACHE_ITEM* data = NULL;
  PCSC_SCARDCONTEXT* ctx = PCSC_GetCardContextData(hContext);
  char* id = NULL;
 
  if (!ctx)
    return SCARD_E_FILE_NOT_FOUND;
 
  id = card_id_and_name_a(CardIdentifier, LookupName);
 
  if (!id)
    return SCARD_E_NO_MEMORY;
 
  data = malloc(sizeof(PCSC_CACHE_ITEM));
  if (!data)
  {
    free(id);
    return SCARD_E_NO_MEMORY;
  }
  data->data = calloc(DataLen, 1);
  if (!data->data)
  {
    free(id);
    free(data);
    return SCARD_E_NO_MEMORY;
  }
  data->len = DataLen;
  data->freshness = FreshnessCounter;
  memcpy(data->data, Data, data->len);
 
  HashTable_Remove(ctx->cache, id);
  const BOOL rc = HashTable_Insert(ctx->cache, id, data);
  free(id);
 
  if (!rc)
  {
    pcsc_cache_item_free(data);
    return SCARD_E_NO_MEMORY;
  }
 
  // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert owns data
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardWriteCacheW(SCARDCONTEXT hContext, UUID* CardIdentifier,
                                         DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data,
                                         DWORD DataLen)
{
  PCSC_CACHE_ITEM* data = NULL;
  PCSC_SCARDCONTEXT* ctx = PCSC_GetCardContextData(hContext);
  char* id = NULL;
  if (!ctx)
    return SCARD_E_FILE_NOT_FOUND;
 
  id = card_id_and_name_w(CardIdentifier, LookupName);
 
  if (!id)
    return SCARD_E_NO_MEMORY;
 
  data = malloc(sizeof(PCSC_CACHE_ITEM));
  if (!data)
  {
    free(id);
    return SCARD_E_NO_MEMORY;
  }
  data->data = malloc(DataLen);
  if (!data->data)
  {
    free(id);
    free(data);
    return SCARD_E_NO_MEMORY;
  }
  data->len = DataLen;
  data->freshness = FreshnessCounter;
  memcpy(data->data, Data, data->len);
 
  HashTable_Remove(ctx->cache, id);
  const BOOL rc = HashTable_Insert(ctx->cache, id, data);
  free(id);
 
  if (!rc)
  {
    pcsc_cache_item_free(data);
    return SCARD_E_NO_MEMORY;
  }
 
  // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert owns data
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI
PCSC_SCardGetReaderIconA(SCARDCONTEXT hContext, LPCSTR szReaderName,
                         LPBYTE pbIcon /* NOLINT(readability-non-const-parameter) */,
                         LPDWORD pcbIcon /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(pbIcon);
  WINPR_UNUSED(pcbIcon);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI
PCSC_SCardGetReaderIconW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                         LPBYTE pbIcon /* NOLINT(readability-non-const-parameter) */,
                         LPDWORD pcbIcon /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(pbIcon);
  WINPR_UNUSED(pcbIcon);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetDeviceTypeIdA(SCARDCONTEXT hContext, LPCSTR szReaderName,
                                              LPDWORD pdwDeviceTypeId)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(pdwDeviceTypeId);
  if (pdwDeviceTypeId)
    *pdwDeviceTypeId = SCARD_READER_TYPE_USB;
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardGetDeviceTypeIdW(SCARDCONTEXT hContext, LPCWSTR szReaderName,
                                              LPDWORD pdwDeviceTypeId)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  if (pdwDeviceTypeId)
    *pdwDeviceTypeId = SCARD_READER_TYPE_USB;
  return SCARD_S_SUCCESS;
}
 
static LONG WINAPI PCSC_SCardGetReaderDeviceInstanceIdA(
    SCARDCONTEXT hContext, LPCSTR szReaderName,
    LPSTR szDeviceInstanceId /* NOLINT(readability-non-const-parameter) */,
    LPDWORD pcchDeviceInstanceId /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szDeviceInstanceId);
  WINPR_UNUSED(pcchDeviceInstanceId);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardGetReaderDeviceInstanceIdW(
    SCARDCONTEXT hContext, LPCWSTR szReaderName,
    LPWSTR szDeviceInstanceId /* NOLINT(readability-non-const-parameter) */,
    LPDWORD pcchDeviceInstanceId /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szReaderName);
  WINPR_UNUSED(szDeviceInstanceId);
  WINPR_UNUSED(pcchDeviceInstanceId);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardListReadersWithDeviceInstanceIdA(
    SCARDCONTEXT hContext, LPCSTR szDeviceInstanceId,
    LPSTR mszReaders /* NOLINT(readability-non-const-parameter) */,
    LPDWORD pcchReaders /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szDeviceInstanceId);
  WINPR_UNUSED(mszReaders);
  WINPR_UNUSED(pcchReaders);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardListReadersWithDeviceInstanceIdW(
    SCARDCONTEXT hContext, LPCWSTR szDeviceInstanceId,
    LPWSTR mszReaders /* NOLINT(readability-non-const-parameter) */,
    LPDWORD pcchReaders /* NOLINT(readability-non-const-parameter) */)
{
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(szDeviceInstanceId);
  WINPR_UNUSED(mszReaders);
  WINPR_UNUSED(pcchReaders);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
static LONG WINAPI PCSC_SCardAudit(SCARDCONTEXT hContext, DWORD dwEvent)
{
 
  WINPR_UNUSED(hContext);
  WINPR_UNUSED(dwEvent);
  return SCARD_E_UNSUPPORTED_FEATURE;
}
 
#ifdef __MACOSX__
unsigned int determineMacOSXVersion(void)
{
  int mib[2];
  size_t len = 0;
  char* kernelVersion = NULL;
  char* tok = NULL;
  unsigned int version = 0;
  long majorVersion = 0;
  long minorVersion = 0;
  long patchVersion = 0;
  int count = 0;
  char* context = NULL;
  mib[0] = CTL_KERN;
  mib[1] = KERN_OSRELEASE;
 
  if (sysctl(mib, 2, NULL, &len, NULL, 0) != 0)
    return 0;
 
  kernelVersion = calloc(len, sizeof(char));
 
  if (!kernelVersion)
    return 0;
 
  if (sysctl(mib, 2, kernelVersion, &len, NULL, 0) != 0)
  {
    free(kernelVersion);
    return 0;
  }
 
  tok = strtok_s(kernelVersion, ".", &context);
  errno = 0;
 
  while (tok)
  {
    switch (count)
    {
      case 0:
        majorVersion = strtol(tok, NULL, 0);
 
        if (errno != 0)
          goto fail;
 
        break;
 
      case 1:
        minorVersion = strtol(tok, NULL, 0);
 
        if (errno != 0)
          goto fail;
 
        break;
 
      case 2:
        patchVersion = strtol(tok, NULL, 0);
 
        if (errno != 0)
          goto fail;
 
        break;
    }
 
    tok = strtok_s(NULL, ".", &context);
    count++;
  }
 
  if (majorVersion < 5)
  {
    if (minorVersion < 4)
      version = 0x10000000;
    else
      version = 0x10010000;
  }
  else
  {
    switch (majorVersion)
    {
      case 5:
        version = 0x10010000;
        break;
 
      case 6:
        version = 0x10020000;
        break;
 
      case 7:
        version = 0x10030000;
        break;
 
      case 8:
        version = 0x10040000;
        break;
 
      case 9:
        version = 0x10050000;
        break;
 
      case 10:
        version = 0x10060000;
        break;
 
      case 11:
        version = 0x10070000;
        break;
 
      case 12:
        version = 0x10080000;
        break;
 
      case 13:
        version = 0x10090000;
        break;
 
      default:
        version = 0x10100000;
        break;
    }
 
    version |= (minorVersion << 8) | (patchVersion);
  }
 
fail:
  free(kernelVersion);
  return version;
}
#endif
 
static const SCardApiFunctionTable PCSC_SCardApiFunctionTable = {
  0, /* dwVersion */
  0, /* dwFlags */
 
  PCSC_SCardEstablishContext,                 /* SCardEstablishContext */
  PCSC_SCardReleaseContext,                   /* SCardReleaseContext */
  PCSC_SCardIsValidContext,                   /* SCardIsValidContext */
  PCSC_SCardListReaderGroupsA,                /* SCardListReaderGroupsA */
  PCSC_SCardListReaderGroupsW,                /* SCardListReaderGroupsW */
  PCSC_SCardListReadersA,                     /* SCardListReadersA */
  PCSC_SCardListReadersW,                     /* SCardListReadersW */
  PCSC_SCardListCardsA,                       /* SCardListCardsA */
  PCSC_SCardListCardsW,                       /* SCardListCardsW */
  PCSC_SCardListInterfacesA,                  /* SCardListInterfacesA */
  PCSC_SCardListInterfacesW,                  /* SCardListInterfacesW */
  PCSC_SCardGetProviderIdA,                   /* SCardGetProviderIdA */
  PCSC_SCardGetProviderIdW,                   /* SCardGetProviderIdW */
  PCSC_SCardGetCardTypeProviderNameA,         /* SCardGetCardTypeProviderNameA */
  PCSC_SCardGetCardTypeProviderNameW,         /* SCardGetCardTypeProviderNameW */
  PCSC_SCardIntroduceReaderGroupA,            /* SCardIntroduceReaderGroupA */
  PCSC_SCardIntroduceReaderGroupW,            /* SCardIntroduceReaderGroupW */
  PCSC_SCardForgetReaderGroupA,               /* SCardForgetReaderGroupA */
  PCSC_SCardForgetReaderGroupW,               /* SCardForgetReaderGroupW */
  PCSC_SCardIntroduceReaderA,                 /* SCardIntroduceReaderA */
  PCSC_SCardIntroduceReaderW,                 /* SCardIntroduceReaderW */
  PCSC_SCardForgetReaderA,                    /* SCardForgetReaderA */
  PCSC_SCardForgetReaderW,                    /* SCardForgetReaderW */
  PCSC_SCardAddReaderToGroupA,                /* SCardAddReaderToGroupA */
  PCSC_SCardAddReaderToGroupW,                /* SCardAddReaderToGroupW */
  PCSC_SCardRemoveReaderFromGroupA,           /* SCardRemoveReaderFromGroupA */
  PCSC_SCardRemoveReaderFromGroupW,           /* SCardRemoveReaderFromGroupW */
  PCSC_SCardIntroduceCardTypeA,               /* SCardIntroduceCardTypeA */
  PCSC_SCardIntroduceCardTypeW,               /* SCardIntroduceCardTypeW */
  PCSC_SCardSetCardTypeProviderNameA,         /* SCardSetCardTypeProviderNameA */
  PCSC_SCardSetCardTypeProviderNameW,         /* SCardSetCardTypeProviderNameW */
  PCSC_SCardForgetCardTypeA,                  /* SCardForgetCardTypeA */
  PCSC_SCardForgetCardTypeW,                  /* SCardForgetCardTypeW */
  PCSC_SCardFreeMemory,                       /* SCardFreeMemory */
  PCSC_SCardAccessStartedEvent,               /* SCardAccessStartedEvent */
  PCSC_SCardReleaseStartedEvent,              /* SCardReleaseStartedEvent */
  PCSC_SCardLocateCardsA,                     /* SCardLocateCardsA */
  PCSC_SCardLocateCardsW,                     /* SCardLocateCardsW */
  PCSC_SCardLocateCardsByATRA,                /* SCardLocateCardsByATRA */
  PCSC_SCardLocateCardsByATRW,                /* SCardLocateCardsByATRW */
  PCSC_SCardGetStatusChangeA,                 /* SCardGetStatusChangeA */
  PCSC_SCardGetStatusChangeW,                 /* SCardGetStatusChangeW */
  PCSC_SCardCancel,                           /* SCardCancel */
  PCSC_SCardConnectA,                         /* SCardConnectA */
  PCSC_SCardConnectW,                         /* SCardConnectW */
  PCSC_SCardReconnect,                        /* SCardReconnect */
  PCSC_SCardDisconnect,                       /* SCardDisconnect */
  PCSC_SCardBeginTransaction,                 /* SCardBeginTransaction */
  PCSC_SCardEndTransaction,                   /* SCardEndTransaction */
  PCSC_SCardCancelTransaction,                /* SCardCancelTransaction */
  PCSC_SCardState,                            /* SCardState */
  PCSC_SCardStatusA,                          /* SCardStatusA */
  PCSC_SCardStatusW,                          /* SCardStatusW */
  PCSC_SCardTransmit,                         /* SCardTransmit */
  PCSC_SCardGetTransmitCount,                 /* SCardGetTransmitCount */
  PCSC_SCardControl,                          /* SCardControl */
  PCSC_SCardGetAttrib,                        /* SCardGetAttrib */
  PCSC_SCardSetAttrib,                        /* SCardSetAttrib */
  PCSC_SCardUIDlgSelectCardA,                 /* SCardUIDlgSelectCardA */
  PCSC_SCardUIDlgSelectCardW,                 /* SCardUIDlgSelectCardW */
  PCSC_GetOpenCardNameA,                      /* GetOpenCardNameA */
  PCSC_GetOpenCardNameW,                      /* GetOpenCardNameW */
  PCSC_SCardDlgExtendedError,                 /* SCardDlgExtendedError */
  PCSC_SCardReadCacheA,                       /* SCardReadCacheA */
  PCSC_SCardReadCacheW,                       /* SCardReadCacheW */
  PCSC_SCardWriteCacheA,                      /* SCardWriteCacheA */
  PCSC_SCardWriteCacheW,                      /* SCardWriteCacheW */
  PCSC_SCardGetReaderIconA,                   /* SCardGetReaderIconA */
  PCSC_SCardGetReaderIconW,                   /* SCardGetReaderIconW */
  PCSC_SCardGetDeviceTypeIdA,                 /* SCardGetDeviceTypeIdA */
  PCSC_SCardGetDeviceTypeIdW,                 /* SCardGetDeviceTypeIdW */
  PCSC_SCardGetReaderDeviceInstanceIdA,       /* SCardGetReaderDeviceInstanceIdA */
  PCSC_SCardGetReaderDeviceInstanceIdW,       /* SCardGetReaderDeviceInstanceIdW */
  PCSC_SCardListReadersWithDeviceInstanceIdA, /* SCardListReadersWithDeviceInstanceIdA */
  PCSC_SCardListReadersWithDeviceInstanceIdW, /* SCardListReadersWithDeviceInstanceIdW */
  PCSC_SCardAudit                             /* SCardAudit */
};
 
const SCardApiFunctionTable* PCSC_GetSCardApiFunctionTable(void)
{
  return &PCSC_SCardApiFunctionTable;
}
 
int PCSC_InitializeSCardApi(void)
{
  /* Disable pcsc-lite's (poor) blocking so we can handle it ourselves */
  SetEnvironmentVariableA("PCSCLITE_NO_BLOCKING", "1");
#ifdef __MACOSX__
  g_PCSCModule = LoadLibraryX("/System/Library/Frameworks/PCSC.framework/PCSC");
  OSXVersion = determineMacOSXVersion();
 
  if (OSXVersion == 0)
    return -1;
 
#else
  g_PCSCModule = LoadLibraryA("libpcsclite.so.1");
 
  if (!g_PCSCModule)
    g_PCSCModule = LoadLibraryA("libpcsclite.so");
 
#endif
 
  if (!g_PCSCModule)
    return -1;
 
    /* symbols defined in winpr/smartcard.h, might pose an issue with the GetProcAddress macro
     * below. therefore undefine them here */
#undef SCardListReaderGroups
#undef SCardListReaders
#undef SCardListCards
#undef SCardListInterfaces
#undef SCardGetProviderId
#undef SCardGetCardTypeProviderName
#undef SCardIntroduceReaderGroup
#undef SCardForgetReaderGroup
#undef SCardIntroduceReader
#undef SCardForgetReader
#undef SCardAddReaderToGroup
#undef SCardRemoveReaderFromGroup
#undef SCardIntroduceCardType
#undef SCardSetCardTypeProviderName
#undef SCardForgetCardType
#undef SCardLocateCards
#undef SCardLocateCardsByATR
#undef SCardGetStatusChange
#undef SCardConnect
#undef SCardStatus
#undef SCardUIDlgSelectCard
#undef GetOpenCardName
#undef SCardReadCache
#undef SCardWriteCache
#undef SCardGetReaderIcon
#undef SCardGetDeviceTypeId
#undef SCardGetReaderDeviceInstanceId
#undef SCardListReadersWithDeviceInstanceId
 
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardEstablishContext);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardReleaseContext);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardIsValidContext);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardConnect);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardReconnect);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardDisconnect);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardBeginTransaction);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardEndTransaction);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardStatus);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardGetStatusChange);
 
#ifdef __MACOSX__
 
  if (OSXVersion >= 0x10050600)
  {
    WINSCARD_LOAD_PROC_EX(g_PCSCModule, g_PCSC, SCardControl, SCardControl132);
  }
  else
  {
    WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardControl);
  }
#else
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardControl);
#endif
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardTransmit);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardListReaderGroups);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardListReaders);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardCancel);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardGetAttrib);
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardSetAttrib);
  g_PCSC.pfnSCardFreeMemory = NULL;
#ifndef __APPLE__
  WINSCARD_LOAD_PROC(g_PCSCModule, g_PCSC, SCardFreeMemory);
#endif
 
  if (g_PCSC.pfnSCardFreeMemory)
    g_SCardAutoAllocate = TRUE;
 
#ifdef DISABLE_PCSC_SCARD_AUTOALLOCATE
  g_PCSC.pfnSCardFreeMemory = NULL;
  g_SCardAutoAllocate = FALSE;
#endif
#ifdef __APPLE__
  g_PnP_Notification = FALSE;
#endif
  return 1;
}
 
#endif