2037 lines
50 KiB
C
2037 lines
50 KiB
C
/**
|
|
* WinPR: Windows Portable Runtime
|
|
* Smart Card API
|
|
*
|
|
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
|
|
#include <winpr/crt.h>
|
|
#include <winpr/synch.h>
|
|
#include <winpr/library.h>
|
|
#include <winpr/smartcard.h>
|
|
#include <winpr/collections.h>
|
|
|
|
#include "smartcard_pcsc.h"
|
|
|
|
//#define DISABLE_PCSC_SCARD_AUTOALLOCATE
|
|
|
|
struct _PCSC_SCARDCONTEXT
|
|
{
|
|
SCARDCONTEXT hContext;
|
|
SCARDHANDLE hCard;
|
|
CRITICAL_SECTION lock;
|
|
};
|
|
typedef struct _PCSC_SCARDCONTEXT PCSC_SCARDCONTEXT;
|
|
|
|
struct _PCSC_READER
|
|
{
|
|
char* namePCSC;
|
|
char* nameWinSCard;
|
|
};
|
|
typedef struct _PCSC_READER PCSC_READER;
|
|
|
|
static HMODULE g_PCSCModule = NULL;
|
|
static PCSCFunctionTable g_PCSC = { 0 };
|
|
|
|
static BOOL g_SCardAutoAllocate = FALSE;
|
|
|
|
static wArrayList* g_Readers = NULL;
|
|
static wListDictionary* g_CardHandles = NULL;
|
|
static wListDictionary* g_CardContexts = NULL;
|
|
static wListDictionary* g_MemoryBlocks = NULL;
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardFreeMemory_Internal(SCARDCONTEXT hContext, LPCVOID pvMem);
|
|
|
|
LONG PCSC_MapErrorCodeToWinSCard(LONG errorCode)
|
|
{
|
|
/**
|
|
* pcsc-lite returns SCARD_E_UNEXPECTED when it
|
|
* should return SCARD_E_UNSUPPORTED_FEATURE.
|
|
*
|
|
* Additionally, the pcsc-lite headers incorrectly
|
|
* define SCARD_E_UNSUPPORTED_FEATURE to 0x8010001F,
|
|
* when the real value should be 0x80100022.
|
|
*/
|
|
|
|
if (errorCode == SCARD_E_UNEXPECTED)
|
|
errorCode = SCARD_E_UNSUPPORTED_FEATURE;
|
|
|
|
return errorCode;
|
|
}
|
|
|
|
DWORD PCSC_ConvertCardStateToWinSCard(DWORD dwCardState, LONG status)
|
|
{
|
|
/**
|
|
* pcsc-lite's SCardStatus returns a bit-field, not an enumerated value.
|
|
*
|
|
* State WinSCard pcsc-lite
|
|
*
|
|
* SCARD_UNKNOWN 0 0x0001
|
|
* SCARD_ABSENT 1 0x0002
|
|
* SCARD_PRESENT 2 0x0004
|
|
* SCARD_SWALLOWED 3 0x0008
|
|
* SCARD_POWERED 4 0x0010
|
|
* SCARD_NEGOTIABLE 5 0x0020
|
|
* SCARD_SPECIFIC 6 0x0040
|
|
*
|
|
* pcsc-lite also never sets SCARD_SPECIFIC,
|
|
* which is expected by some windows applications.
|
|
*/
|
|
|
|
if (status == SCARD_S_SUCCESS)
|
|
{
|
|
if ((dwCardState & PCSC_SCARD_NEGOTIABLE) || (dwCardState & PCSC_SCARD_SPECIFIC))
|
|
return SCARD_SPECIFIC;
|
|
}
|
|
|
|
if (dwCardState & PCSC_SCARD_POWERED)
|
|
return SCARD_POWERED;
|
|
if (dwCardState & PCSC_SCARD_NEGOTIABLE)
|
|
return SCARD_NEGOTIABLE;
|
|
if (dwCardState & PCSC_SCARD_SPECIFIC)
|
|
return SCARD_SPECIFIC;
|
|
if (dwCardState & PCSC_SCARD_ABSENT)
|
|
return SCARD_ABSENT;
|
|
if (dwCardState & PCSC_SCARD_PRESENT)
|
|
return SCARD_PRESENT;
|
|
if (dwCardState & PCSC_SCARD_SWALLOWED)
|
|
return SCARD_SWALLOWED;
|
|
if (dwCardState & PCSC_SCARD_UNKNOWN)
|
|
return SCARD_UNKNOWN;
|
|
|
|
return SCARD_UNKNOWN;
|
|
}
|
|
|
|
DWORD PCSC_ConvertProtocolsToWinSCard(DWORD dwProtocols)
|
|
{
|
|
/**
|
|
* pcsc-lite uses a different value for SCARD_PROTOCOL_RAW,
|
|
* and also has SCARD_PROTOCOL_T15 which is not in WinSCard.
|
|
*/
|
|
|
|
if (dwProtocols & PCSC_SCARD_PROTOCOL_RAW)
|
|
{
|
|
dwProtocols &= ~PCSC_SCARD_PROTOCOL_RAW;
|
|
dwProtocols |= SCARD_PROTOCOL_RAW;
|
|
}
|
|
|
|
if (dwProtocols & PCSC_SCARD_PROTOCOL_T15)
|
|
{
|
|
dwProtocols &= ~PCSC_SCARD_PROTOCOL_T15;
|
|
}
|
|
|
|
return dwProtocols;
|
|
}
|
|
|
|
DWORD PCSC_ConvertProtocolsFromWinSCard(DWORD dwProtocols)
|
|
{
|
|
/**
|
|
* pcsc-lite uses a different value for SCARD_PROTOCOL_RAW,
|
|
* and it does not define WinSCard's SCARD_PROTOCOL_DEFAULT.
|
|
*/
|
|
|
|
if (dwProtocols & SCARD_PROTOCOL_RAW)
|
|
{
|
|
dwProtocols &= ~SCARD_PROTOCOL_RAW;
|
|
dwProtocols |= PCSC_SCARD_PROTOCOL_RAW;
|
|
}
|
|
|
|
if (dwProtocols & SCARD_PROTOCOL_DEFAULT)
|
|
{
|
|
dwProtocols &= ~SCARD_PROTOCOL_DEFAULT;
|
|
}
|
|
|
|
return dwProtocols;
|
|
}
|
|
|
|
void PCSC_ReaderAliasFree(PCSC_READER* reader)
|
|
{
|
|
if (!reader)
|
|
return;
|
|
|
|
free(reader->namePCSC);
|
|
free(reader->nameWinSCard);
|
|
}
|
|
|
|
PCSC_SCARDCONTEXT* PCSC_GetCardContextData(SCARDCONTEXT hContext)
|
|
{
|
|
PCSC_SCARDCONTEXT* pContext;
|
|
|
|
if (!g_CardContexts)
|
|
return 0;
|
|
|
|
pContext = (PCSC_SCARDCONTEXT*) ListDictionary_GetItemValue(g_CardContexts, (void*) hContext);
|
|
|
|
if (!pContext)
|
|
return 0;
|
|
|
|
return pContext;
|
|
}
|
|
|
|
PCSC_SCARDCONTEXT* PCSC_EstablishCardContext(SCARDCONTEXT hContext)
|
|
{
|
|
PCSC_SCARDCONTEXT* pContext;
|
|
|
|
pContext = (PCSC_SCARDCONTEXT*) calloc(1, sizeof(PCSC_SCARDCONTEXT));
|
|
|
|
if (!pContext)
|
|
return NULL;
|
|
|
|
pContext->hContext = hContext;
|
|
|
|
InitializeCriticalSectionAndSpinCount(&(pContext->lock), 4000);
|
|
|
|
if (!g_CardContexts)
|
|
g_CardContexts = ListDictionary_New(TRUE);
|
|
|
|
if (!g_Readers)
|
|
{
|
|
g_Readers = ArrayList_New(TRUE);
|
|
ArrayList_Object(g_Readers)->fnObjectFree = (OBJECT_FREE_FN) PCSC_ReaderAliasFree;
|
|
}
|
|
|
|
ListDictionary_Add(g_CardContexts, (void*) hContext, (void*) pContext);
|
|
|
|
return pContext;
|
|
}
|
|
|
|
void PCSC_ReleaseCardContext(SCARDCONTEXT hContext)
|
|
{
|
|
PCSC_SCARDCONTEXT* pContext;
|
|
|
|
pContext = PCSC_GetCardContextData(hContext);
|
|
|
|
if (!pContext)
|
|
return;
|
|
|
|
DeleteCriticalSection(&(pContext->lock));
|
|
|
|
free(pContext);
|
|
|
|
if (!g_CardContexts)
|
|
return;
|
|
|
|
ListDictionary_Remove(g_CardContexts, (void*) hContext);
|
|
}
|
|
|
|
void PCSC_LockCardContext(SCARDCONTEXT hContext)
|
|
{
|
|
PCSC_SCARDCONTEXT* pContext;
|
|
|
|
pContext = PCSC_GetCardContextData(hContext);
|
|
|
|
if (!pContext)
|
|
{
|
|
fprintf(stderr, "PCSC_LockCardContext: invalid context (%p)\n", (void*) hContext);
|
|
return;
|
|
}
|
|
|
|
EnterCriticalSection(&(pContext->lock));
|
|
}
|
|
|
|
void PCSC_UnlockCardContext(SCARDCONTEXT hContext)
|
|
{
|
|
PCSC_SCARDCONTEXT* pContext;
|
|
|
|
pContext = PCSC_GetCardContextData(hContext);
|
|
|
|
if (!pContext)
|
|
{
|
|
fprintf(stderr, "PCSC_UnlockCardContext: invalid context (%p)\n", (void*) hContext);
|
|
return;
|
|
}
|
|
|
|
LeaveCriticalSection(&(pContext->lock));
|
|
}
|
|
|
|
char* PCSC_GetReaderNameFromAlias(char* nameWinSCard)
|
|
{
|
|
int index;
|
|
int count;
|
|
PCSC_READER* reader;
|
|
char* namePCSC = NULL;
|
|
|
|
ArrayList_Lock(g_Readers);
|
|
|
|
count = ArrayList_Count(g_Readers);
|
|
|
|
for (index = 0; index < count; index++)
|
|
{
|
|
reader = ArrayList_GetItem(g_Readers, index);
|
|
|
|
if (strcmp(nameWinSCard, reader->nameWinSCard) == 0)
|
|
{
|
|
namePCSC = reader->namePCSC;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ArrayList_Unlock(g_Readers);
|
|
|
|
return namePCSC;
|
|
}
|
|
|
|
BOOL PCSC_AddReaderNameAlias(char* namePCSC, char* nameWinSCard)
|
|
{
|
|
PCSC_READER* reader;
|
|
|
|
if (PCSC_GetReaderNameFromAlias(nameWinSCard))
|
|
return TRUE;
|
|
|
|
reader = (PCSC_READER*) calloc(1, sizeof(PCSC_READER));
|
|
|
|
if (!reader)
|
|
return FALSE;
|
|
|
|
reader->namePCSC = _strdup(namePCSC);
|
|
reader->nameWinSCard = _strdup(nameWinSCard);
|
|
|
|
ArrayList_Add(g_Readers, reader);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
char* PCSC_ConvertReaderNameToWinSCard(const char* name)
|
|
{
|
|
int slot;
|
|
int index;
|
|
int size;
|
|
int length;
|
|
char* nameWinSCard;
|
|
char *na1, *na2 = NULL;
|
|
char *if1, *if2 = NULL;
|
|
char *se1, *se2 = NULL;
|
|
char *in1, *in2 = NULL;
|
|
char *sl1, *sl2 = NULL;
|
|
|
|
/**
|
|
* pcsc-lite reader name format:
|
|
*
|
|
* name [interface] (serial) index slot
|
|
* Athena IDProtect Key v2 [Main Interface] 00 00
|
|
*
|
|
* name: Athena IDProtect Key v2
|
|
* interface: Main Interface
|
|
* serial: N/A
|
|
* index: 00
|
|
* slot: 00
|
|
*
|
|
* the serial component is optional
|
|
* the index is a two digit zero-padded integer
|
|
* the slot is a two digit zero-padded integer
|
|
*/
|
|
|
|
length = strlen(name);
|
|
|
|
if (length < 10)
|
|
return NULL;
|
|
|
|
na1 = (char*) name;
|
|
na2 = (char*) &name[length - 7];
|
|
|
|
if1 = strchr(name, '[');
|
|
|
|
if (if1)
|
|
if2 = strchr(if1 + 1, ']');
|
|
|
|
se1 = strchr(name, '(');
|
|
|
|
if (se1)
|
|
se2 = strchr(se1 + 1, ')');
|
|
|
|
in1 = (char*) &name[length - 5];
|
|
in2 = (char*) &name[length - 4];
|
|
|
|
sl1 = (char*) &name[length - 2];
|
|
sl2 = (char*) &name[length - 1];
|
|
|
|
if (!(if1 && if2))
|
|
return NULL;
|
|
|
|
if (!(isdigit(*in1) && isdigit(*in2)))
|
|
return NULL;
|
|
|
|
if (!(isdigit(*sl1) && isdigit(*sl2)))
|
|
return NULL;
|
|
|
|
na2 = if1 - 1;
|
|
|
|
while ((*na2 == ' ') && (na2 > na1))
|
|
na2--;
|
|
na2++;
|
|
|
|
index = ((*in1 - 0x30) * 10) + (*in2 - 0x30);
|
|
slot = ((*sl1 - 0x30) * 10) + (*sl2 - 0x30);
|
|
|
|
length = (na2 - na1);
|
|
size = length + 16;
|
|
|
|
nameWinSCard = (char*) malloc(size);
|
|
|
|
if (!nameWinSCard)
|
|
return NULL;
|
|
|
|
sprintf_s(nameWinSCard, size, "%.*s %d", length, na1, index);
|
|
|
|
return nameWinSCard;
|
|
}
|
|
|
|
char* PCSC_ConvertReaderNamesToWinSCard(const char* names)
|
|
{
|
|
char *p, *q;
|
|
int plen, qlen;
|
|
int count = 0;
|
|
int total = 0;
|
|
char* nameWinSCard;
|
|
char* namesWinSCard;
|
|
|
|
p = (char*) names;
|
|
plen = strlen(p);
|
|
|
|
while (plen > 0)
|
|
{
|
|
p += plen + 1;
|
|
total += plen + 1;
|
|
plen = strlen(p);
|
|
count++;
|
|
}
|
|
total++;
|
|
|
|
namesWinSCard = (char*) malloc(total * 2);
|
|
|
|
if (!namesWinSCard)
|
|
return NULL;
|
|
|
|
q = namesWinSCard;
|
|
|
|
p = (char*) names;
|
|
plen = strlen(p);
|
|
|
|
while (plen > 0)
|
|
{
|
|
nameWinSCard = PCSC_ConvertReaderNameToWinSCard(p);
|
|
|
|
if (nameWinSCard)
|
|
{
|
|
PCSC_AddReaderNameAlias(p, nameWinSCard);
|
|
|
|
qlen = strlen(nameWinSCard);
|
|
CopyMemory(q, nameWinSCard, qlen);
|
|
free(nameWinSCard);
|
|
}
|
|
else
|
|
{
|
|
qlen = strlen(p);
|
|
CopyMemory(q, p, qlen);
|
|
}
|
|
|
|
p += plen + 1;
|
|
|
|
q += qlen;
|
|
*q = '\0';
|
|
q++;
|
|
|
|
plen = strlen(p);
|
|
}
|
|
|
|
*q = '\0';
|
|
q++;
|
|
|
|
return namesWinSCard;
|
|
}
|
|
|
|
char* PCSC_ConvertReaderNamesFromWinSCard(const char* names)
|
|
{
|
|
char *p, *q;
|
|
int plen, qlen;
|
|
int count = 0;
|
|
int total = 0;
|
|
char* namePCSC;
|
|
char* namesPCSC;
|
|
|
|
p = (char*) names;
|
|
plen = strlen(p);
|
|
|
|
while (plen > 0)
|
|
{
|
|
p += plen + 1;
|
|
total += plen + 1;
|
|
plen = strlen(p);
|
|
count++;
|
|
}
|
|
total++;
|
|
|
|
namesPCSC = (char*) malloc(total);
|
|
|
|
if (!namesPCSC)
|
|
return NULL;
|
|
|
|
q = namesPCSC;
|
|
|
|
p = (char*) names;
|
|
plen = strlen(p);
|
|
|
|
while (plen > 0)
|
|
{
|
|
namePCSC = PCSC_GetReaderNameFromAlias(p);
|
|
|
|
if (!namePCSC)
|
|
namePCSC = p;
|
|
|
|
qlen = strlen(namePCSC);
|
|
CopyMemory(q, namePCSC, qlen);
|
|
|
|
p += plen + 1;
|
|
|
|
q += qlen;
|
|
*q = '\0';
|
|
q++;
|
|
|
|
plen = strlen(p);
|
|
}
|
|
|
|
*q = '\0';
|
|
q++;
|
|
|
|
return namesPCSC;
|
|
}
|
|
|
|
size_t PCSC_MultiStringLengthA(const char* msz)
|
|
{
|
|
char* p = (char*) msz;
|
|
|
|
if (!p)
|
|
return 0;
|
|
|
|
while ((p[0] != 0) && (p[1] != 0))
|
|
p++;
|
|
|
|
return (p - msz) + 1;
|
|
}
|
|
|
|
size_t PCSC_MultiStringLengthW(const WCHAR* msz)
|
|
{
|
|
WCHAR* p = (WCHAR*) msz;
|
|
|
|
if (!p)
|
|
return 0;
|
|
|
|
while ((p[0] != 0) && (p[1] != 0))
|
|
p++;
|
|
|
|
return (p - msz) + 1;
|
|
}
|
|
|
|
void PCSC_AddCardHandle(SCARDCONTEXT hContext, SCARDHANDLE hCard)
|
|
{
|
|
if (!g_CardHandles)
|
|
g_CardHandles = ListDictionary_New(TRUE);
|
|
|
|
ListDictionary_Add(g_CardHandles, (void*) hCard, (void*) hContext);
|
|
}
|
|
|
|
void* PCSC_RemoveCardHandle(SCARDHANDLE hCard)
|
|
{
|
|
if (!g_CardHandles)
|
|
return NULL;
|
|
|
|
return ListDictionary_Remove(g_CardHandles, (void*) hCard);
|
|
}
|
|
|
|
SCARDCONTEXT PCSC_GetCardContextFromHandle(SCARDHANDLE hCard)
|
|
{
|
|
SCARDCONTEXT hContext;
|
|
|
|
if (!g_CardHandles)
|
|
return 0;
|
|
|
|
hContext = (SCARDCONTEXT) ListDictionary_GetItemValue(g_CardHandles, (void*) hCard);
|
|
|
|
return hContext;
|
|
}
|
|
|
|
void PCSC_AddMemoryBlock(SCARDCONTEXT hContext, void* pvMem)
|
|
{
|
|
if (!g_MemoryBlocks)
|
|
g_MemoryBlocks = ListDictionary_New(TRUE);
|
|
|
|
ListDictionary_Add(g_MemoryBlocks, pvMem, (void*) hContext);
|
|
}
|
|
|
|
void* PCSC_RemoveMemoryBlock(SCARDCONTEXT hContext, void* pvMem)
|
|
{
|
|
if (!g_MemoryBlocks)
|
|
return NULL;
|
|
|
|
return ListDictionary_Remove(g_MemoryBlocks, pvMem);
|
|
}
|
|
|
|
void* PCSC_SCardAllocMemory(SCARDCONTEXT hContext, size_t size)
|
|
{
|
|
void* pvMem;
|
|
|
|
pvMem = malloc(size);
|
|
|
|
if (!pvMem)
|
|
return NULL;
|
|
|
|
PCSC_AddMemoryBlock(hContext, pvMem);
|
|
|
|
return pvMem;
|
|
}
|
|
|
|
/**
|
|
* Standard Windows Smart Card API (PCSC)
|
|
*/
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardEstablishContext(DWORD dwScope,
|
|
LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardEstablishContext)
|
|
{
|
|
dwScope = SCARD_SCOPE_SYSTEM; /* this is the only scope supported by pcsc-lite */
|
|
|
|
status = g_PCSC.pfnSCardEstablishContext(dwScope, pvReserved1, pvReserved2, phContext);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
if (!status)
|
|
PCSC_EstablishCardContext(*phContext);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardReleaseContext(SCARDCONTEXT hContext)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardReleaseContext)
|
|
{
|
|
status = g_PCSC.pfnSCardReleaseContext(hContext);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
if (!status)
|
|
PCSC_ReleaseCardContext(hContext);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIsValidContext(SCARDCONTEXT hContext)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardIsValidContext)
|
|
{
|
|
status = g_PCSC.pfnSCardIsValidContext(hContext);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsA(SCARDCONTEXT hContext,
|
|
LPSTR mszGroups, LPDWORD pcchGroups)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardListReaderGroups)
|
|
{
|
|
status = g_PCSC.pfnSCardListReaderGroups(hContext, mszGroups, pcchGroups);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReaderGroupsW(SCARDCONTEXT hContext,
|
|
LPWSTR mszGroups, LPDWORD pcchGroups)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardListReaderGroups)
|
|
{
|
|
mszGroups = NULL;
|
|
pcchGroups = 0;
|
|
|
|
/* FIXME: unicode conversion */
|
|
|
|
status = g_PCSC.pfnSCardListReaderGroups(hContext, (LPSTR) mszGroups, pcchGroups);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReaders_Internal(SCARDCONTEXT hContext,
|
|
LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardListReaders)
|
|
{
|
|
BOOL pcchReadersWrapAlloc = FALSE;
|
|
LPSTR* pMszReaders = (LPSTR*) mszReaders;
|
|
|
|
mszGroups = NULL; /* mszGroups is not supported by pcsc-lite */
|
|
|
|
if ((*pcchReaders == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate)
|
|
pcchReadersWrapAlloc = TRUE;
|
|
|
|
if (pcchReadersWrapAlloc)
|
|
{
|
|
*pcchReaders = 0;
|
|
|
|
status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, NULL, pcchReaders);
|
|
|
|
if (!status)
|
|
{
|
|
*pMszReaders = calloc(1, *pcchReaders);
|
|
|
|
if (!*pMszReaders)
|
|
return SCARD_E_NO_MEMORY;
|
|
|
|
status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, *pMszReaders, pcchReaders);
|
|
|
|
if (status)
|
|
free(*pMszReaders);
|
|
else
|
|
PCSC_AddMemoryBlock(hContext, *pMszReaders);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = g_PCSC.pfnSCardListReaders(hContext, mszGroups, mszReaders, pcchReaders);
|
|
}
|
|
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReadersA(SCARDCONTEXT hContext,
|
|
LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardListReaders)
|
|
{
|
|
char* mszReadersWinSCard = NULL;
|
|
LPSTR* pMszReaders = (LPSTR*) mszReaders;
|
|
|
|
status = PCSC_SCardListReaders_Internal(hContext, mszGroups, mszReaders, pcchReaders);
|
|
|
|
if (!status)
|
|
{
|
|
mszReadersWinSCard = PCSC_ConvertReaderNamesToWinSCard(*pMszReaders);
|
|
|
|
if (mszReadersWinSCard)
|
|
{
|
|
PCSC_SCardFreeMemory_Internal(hContext, *pMszReaders);
|
|
|
|
*pMszReaders = mszReadersWinSCard;
|
|
*pcchReaders = PCSC_MultiStringLengthA(*pMszReaders) + 2;
|
|
PCSC_AddMemoryBlock(hContext, *pMszReaders);
|
|
}
|
|
}
|
|
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReadersW(SCARDCONTEXT hContext,
|
|
LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardListReaders)
|
|
{
|
|
LPSTR mszGroupsA = NULL;
|
|
LPSTR mszReadersA = NULL;
|
|
char* mszReadersWinSCard = NULL;
|
|
LPSTR* pMszReadersA = &mszReadersA;
|
|
|
|
mszGroups = NULL; /* mszGroups is not supported by pcsc-lite */
|
|
|
|
if (mszGroups)
|
|
ConvertFromUnicode(CP_UTF8, 0, mszGroups, -1, (char**) &mszGroupsA, 0, NULL, NULL);
|
|
|
|
status = PCSC_SCardListReaders_Internal(hContext, mszGroupsA, (LPTSTR) &mszReadersA, pcchReaders);
|
|
|
|
if (!status)
|
|
{
|
|
mszReadersWinSCard = PCSC_ConvertReaderNamesToWinSCard(mszReadersA);
|
|
|
|
if (mszReadersWinSCard)
|
|
{
|
|
PCSC_SCardFreeMemory_Internal(hContext, *pMszReadersA);
|
|
|
|
*pMszReadersA = mszReadersWinSCard;
|
|
*pcchReaders = PCSC_MultiStringLengthA(*pMszReadersA) + 2;
|
|
PCSC_AddMemoryBlock(hContext, *pMszReadersA);
|
|
}
|
|
|
|
*pcchReaders = ConvertToUnicode(CP_UTF8, 0, *pMszReadersA, *pcchReaders, (WCHAR**) mszReaders, 0);
|
|
PCSC_AddMemoryBlock(hContext, mszReaders);
|
|
|
|
PCSC_SCardFreeMemory_Internal(hContext, *pMszReadersA);
|
|
}
|
|
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
free(mszGroupsA);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListCardsA(SCARDCONTEXT hContext,
|
|
LPCBYTE pbAtr, LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount, CHAR* mszCards, LPDWORD pcchCards)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListCardsW(SCARDCONTEXT hContext,
|
|
LPCBYTE pbAtr, LPCGUID rgquidInterfaces, DWORD cguidInterfaceCount, WCHAR* mszCards, LPDWORD pcchCards)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListInterfacesA(SCARDCONTEXT hContext,
|
|
LPCSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListInterfacesW(SCARDCONTEXT hContext,
|
|
LPCWSTR szCard, LPGUID pguidInterfaces, LPDWORD pcguidInterfaces)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetProviderIdA(SCARDCONTEXT hContext,
|
|
LPCSTR szCard, LPGUID pguidProviderId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetProviderIdW(SCARDCONTEXT hContext,
|
|
LPCWSTR szCard, LPGUID pguidProviderId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetCardTypeProviderNameA(SCARDCONTEXT hContext,
|
|
LPCSTR szCardName, DWORD dwProviderId, CHAR* szProvider, LPDWORD pcchProvider)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetCardTypeProviderNameW(SCARDCONTEXT hContext,
|
|
LPCWSTR szCardName, DWORD dwProviderId, WCHAR* szProvider, LPDWORD pcchProvider)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderGroupA(SCARDCONTEXT hContext, LPCSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderGroupW(SCARDCONTEXT hContext, LPCWSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderA(SCARDCONTEXT hContext,
|
|
LPCSTR szReaderName, LPCSTR szDeviceName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceReaderW(SCARDCONTEXT hContext,
|
|
LPCWSTR szReaderName, LPCWSTR szDeviceName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderA(SCARDCONTEXT hContext, LPCSTR szReaderName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardForgetReaderW(SCARDCONTEXT hContext, LPCWSTR szReaderName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardAddReaderToGroupA(SCARDCONTEXT hContext,
|
|
LPCSTR szReaderName, LPCSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardAddReaderToGroupW(SCARDCONTEXT hContext,
|
|
LPCWSTR szReaderName, LPCWSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardRemoveReaderFromGroupA(SCARDCONTEXT hContext,
|
|
LPCSTR szReaderName, LPCSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardRemoveReaderFromGroupW(SCARDCONTEXT hContext,
|
|
LPCWSTR szReaderName, LPCWSTR szGroupName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceCardTypeA(SCARDCONTEXT hContext,
|
|
LPCSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces,
|
|
DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardIntroduceCardTypeW(SCARDCONTEXT hContext,
|
|
LPCWSTR szCardName, LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces,
|
|
DWORD dwInterfaceCount, LPCBYTE pbAtr, LPCBYTE pbAtrMask, DWORD cbAtrLen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardSetCardTypeProviderNameA(SCARDCONTEXT hContext,
|
|
LPCSTR szCardName, DWORD dwProviderId, LPCSTR szProvider)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardSetCardTypeProviderNameW(SCARDCONTEXT hContext,
|
|
LPCWSTR szCardName, DWORD dwProviderId, LPCWSTR szProvider)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardForgetCardTypeA(SCARDCONTEXT hContext, LPCSTR szCardName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardForgetCardTypeW(SCARDCONTEXT hContext, LPCWSTR szCardName)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardFreeMemory_Internal(SCARDCONTEXT hContext, LPCVOID pvMem)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (PCSC_RemoveMemoryBlock(hContext, (void*) pvMem))
|
|
{
|
|
free((void*) pvMem);
|
|
status = SCARD_S_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
if (g_PCSC.pfnSCardFreeMemory)
|
|
{
|
|
status = g_PCSC.pfnSCardFreeMemory(hContext, pvMem);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardFreeMemory(SCARDCONTEXT hContext, LPCVOID pvMem)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
status = PCSC_SCardFreeMemory_Internal(hContext, pvMem);
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI HANDLE WINAPI PCSC_SCardAccessStartedEvent(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI void WINAPI PCSC_SCardReleaseStartedEvent(void)
|
|
{
|
|
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsA(SCARDCONTEXT hContext,
|
|
LPCSTR mszCards, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsW(SCARDCONTEXT hContext,
|
|
LPCWSTR mszCards, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsByATRA(SCARDCONTEXT hContext,
|
|
LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardLocateCardsByATRW(SCARDCONTEXT hContext,
|
|
LPSCARD_ATRMASK rgAtrMasks, DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChange_Internal(SCARDCONTEXT hContext,
|
|
DWORD dwTimeout, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardGetStatusChange)
|
|
{
|
|
DWORD index;
|
|
DWORD dwEventState;
|
|
BOOL stateChanged = FALSE;
|
|
LPSCARD_READERSTATEA states;
|
|
|
|
states = (LPSCARD_READERSTATEA) calloc(cReaders, sizeof(SCARD_READERSTATEA));
|
|
|
|
if (!states)
|
|
return SCARD_E_NO_MEMORY;
|
|
|
|
for (index = 0; index < cReaders; index++)
|
|
{
|
|
states[index].szReader = PCSC_GetReaderNameFromAlias((char*) rgReaderStates[index].szReader);
|
|
|
|
if (!states[index].szReader)
|
|
states[index].szReader = rgReaderStates[index].szReader;
|
|
|
|
states[index].pvUserData = rgReaderStates[index].pvUserData;
|
|
states[index].dwCurrentState = rgReaderStates[index].dwCurrentState;
|
|
states[index].dwEventState = rgReaderStates[index].dwEventState;
|
|
states[index].cbAtr = rgReaderStates[index].cbAtr;
|
|
CopyMemory(&(states[index].rgbAtr), &(rgReaderStates[index].rgbAtr), 36);
|
|
}
|
|
|
|
/**
|
|
* pcsc-lite interprets dwTimeout value 0 as INFINITE, use value 1 as a workaround
|
|
*/
|
|
|
|
status = g_PCSC.pfnSCardGetStatusChange(hContext, dwTimeout ? dwTimeout : 1, states, cReaders);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
for (index = 0; index < cReaders; index++)
|
|
{
|
|
rgReaderStates[index].pvUserData = states[index].pvUserData;
|
|
rgReaderStates[index].dwCurrentState = states[index].dwCurrentState;
|
|
rgReaderStates[index].cbAtr = states[index].cbAtr;
|
|
CopyMemory(&(rgReaderStates[index].rgbAtr), &(states[index].rgbAtr), 36);
|
|
|
|
/* pcsc-lite puts an event count in the higher bits of dwEventState */
|
|
states[index].dwEventState &= 0xFFFF;
|
|
|
|
dwEventState = states[index].dwEventState & ~SCARD_STATE_CHANGED;
|
|
|
|
if (dwEventState != rgReaderStates[index].dwCurrentState)
|
|
{
|
|
rgReaderStates[index].dwEventState = states[index].dwEventState;
|
|
|
|
if (dwEventState & SCARD_STATE_PRESENT)
|
|
{
|
|
if (!(dwEventState & SCARD_STATE_EXCLUSIVE))
|
|
rgReaderStates[index].dwEventState |= SCARD_STATE_INUSE;
|
|
}
|
|
|
|
stateChanged = TRUE;
|
|
}
|
|
else
|
|
{
|
|
rgReaderStates[index].dwEventState = dwEventState;
|
|
}
|
|
|
|
if (rgReaderStates[index].dwCurrentState & SCARD_STATE_IGNORE)
|
|
rgReaderStates[index].dwEventState = SCARD_STATE_IGNORE;
|
|
}
|
|
|
|
if ((status == SCARD_S_SUCCESS) && !stateChanged)
|
|
status = SCARD_E_TIMEOUT;
|
|
else if ((status == SCARD_E_TIMEOUT) && stateChanged)
|
|
return SCARD_S_SUCCESS;
|
|
|
|
free(states);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChangeA(SCARDCONTEXT hContext,
|
|
DWORD dwTimeout, LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardGetStatusChange)
|
|
{
|
|
status = PCSC_SCardGetStatusChange_Internal(hContext, dwTimeout, rgReaderStates, cReaders);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetStatusChangeW(SCARDCONTEXT hContext,
|
|
DWORD dwTimeout, LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardGetStatusChange)
|
|
{
|
|
DWORD index;
|
|
LPSCARD_READERSTATEA states;
|
|
|
|
states = (LPSCARD_READERSTATEA) calloc(cReaders, sizeof(SCARD_READERSTATEA));
|
|
|
|
if (!states)
|
|
{
|
|
PCSC_UnlockCardContext(hContext);
|
|
return SCARD_E_NO_MEMORY;
|
|
}
|
|
|
|
for (index = 0; index < cReaders; index++)
|
|
{
|
|
states[index].szReader = NULL;
|
|
|
|
ConvertFromUnicode(CP_UTF8, 0, rgReaderStates[index].szReader, -1,
|
|
(char**) &states[index].szReader, 0, NULL, NULL);
|
|
|
|
states[index].pvUserData = rgReaderStates[index].pvUserData;
|
|
states[index].dwCurrentState = rgReaderStates[index].dwCurrentState;
|
|
states[index].dwEventState = rgReaderStates[index].dwEventState;
|
|
states[index].cbAtr = rgReaderStates[index].cbAtr;
|
|
CopyMemory(&(states[index].rgbAtr), &(rgReaderStates[index].rgbAtr), 36);
|
|
}
|
|
|
|
status = PCSC_SCardGetStatusChange_Internal(hContext, dwTimeout, states, cReaders);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
for (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);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardCancel(SCARDCONTEXT hContext)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardCancel)
|
|
{
|
|
status = g_PCSC.pfnSCardCancel(hContext);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardConnect_Internal(SCARDCONTEXT hContext,
|
|
LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
|
|
LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardConnect)
|
|
{
|
|
char* szReaderPCSC;
|
|
|
|
szReaderPCSC = PCSC_GetReaderNameFromAlias((char*) szReader);
|
|
|
|
if (!szReaderPCSC)
|
|
szReaderPCSC = (char*) szReader;
|
|
|
|
dwPreferredProtocols = PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols);
|
|
|
|
status = g_PCSC.pfnSCardConnect(hContext, szReaderPCSC,
|
|
dwShareMode, dwPreferredProtocols, phCard, pdwActiveProtocol);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
if (status == SCARD_S_SUCCESS)
|
|
{
|
|
PCSC_AddCardHandle(hContext, *phCard);
|
|
*pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwActiveProtocol);
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardConnectA(SCARDCONTEXT hContext,
|
|
LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
|
|
LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardConnect)
|
|
{
|
|
status = PCSC_SCardConnect_Internal(hContext, szReader, dwShareMode,
|
|
dwPreferredProtocols, phCard, pdwActiveProtocol);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardConnectW(SCARDCONTEXT hContext,
|
|
LPCWSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
|
|
LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
PCSC_LockCardContext(hContext);
|
|
|
|
if (g_PCSC.pfnSCardConnect)
|
|
{
|
|
LONG status;
|
|
LPSTR szReaderA = NULL;
|
|
|
|
if (szReader)
|
|
ConvertFromUnicode(CP_UTF8, 0, szReader, -1, &szReaderA, 0, NULL, NULL);
|
|
|
|
status = PCSC_SCardConnect_Internal(hContext, szReaderA, dwShareMode,
|
|
dwPreferredProtocols, phCard, pdwActiveProtocol);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
free(szReaderA);
|
|
}
|
|
|
|
PCSC_UnlockCardContext(hContext);
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardReconnect(SCARDHANDLE hCard,
|
|
DWORD dwShareMode, DWORD dwPreferredProtocols, DWORD dwInitialization, LPDWORD pdwActiveProtocol)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardReconnect)
|
|
{
|
|
dwPreferredProtocols = PCSC_ConvertProtocolsFromWinSCard(dwPreferredProtocols);
|
|
|
|
status = g_PCSC.pfnSCardReconnect(hCard, dwShareMode,
|
|
dwPreferredProtocols, dwInitialization, pdwActiveProtocol);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
*pdwActiveProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwActiveProtocol);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardDisconnect)
|
|
{
|
|
status = g_PCSC.pfnSCardDisconnect(hCard, dwDisposition);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
if (status == SCARD_S_SUCCESS)
|
|
PCSC_RemoveCardHandle(hCard);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardBeginTransaction(SCARDHANDLE hCard)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardBeginTransaction)
|
|
{
|
|
status = g_PCSC.pfnSCardBeginTransaction(hCard);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardEndTransaction)
|
|
{
|
|
status = g_PCSC.pfnSCardEndTransaction(hCard, dwDisposition);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardCancelTransaction(SCARDHANDLE hCard)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardState(SCARDHANDLE hCard,
|
|
LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardStatus)
|
|
{
|
|
SCARDCONTEXT hContext = 0;
|
|
LPSTR mszReaderNames = NULL;
|
|
DWORD cchReaderLen = SCARD_AUTOALLOCATE;
|
|
|
|
status = g_PCSC.pfnSCardStatus(hCard, (LPSTR) &mszReaderNames, &cchReaderLen,
|
|
pdwState, pdwProtocol, pbAtr, pcbAtrLen);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
if (mszReaderNames)
|
|
{
|
|
hContext = PCSC_GetCardContextFromHandle(hCard);
|
|
PCSC_SCardFreeMemory_Internal(hContext, mszReaderNames);
|
|
}
|
|
|
|
*pdwProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwProtocol);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardStatus_Internal(SCARDHANDLE hCard,
|
|
LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
|
|
LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardStatus)
|
|
{
|
|
SCARDCONTEXT hContext;
|
|
char* mszReaderNamesPCSC = NULL;
|
|
BOOL pcbAtrLenWrapAlloc = FALSE;
|
|
BOOL pcchReaderLenWrapAlloc = FALSE;
|
|
LPBYTE* pPbAtr = (LPBYTE*) pbAtr;
|
|
LPSTR* pMszReaderNames = (LPSTR*) mszReaderNames;
|
|
|
|
hContext = PCSC_GetCardContextFromHandle(hCard);
|
|
|
|
if ((*pcbAtrLen == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate)
|
|
pcbAtrLenWrapAlloc = TRUE;
|
|
|
|
if ((*pcchReaderLen == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate)
|
|
pcchReaderLenWrapAlloc = TRUE;
|
|
|
|
if (pcbAtrLenWrapAlloc || pcchReaderLenWrapAlloc)
|
|
{
|
|
if (pcbAtrLenWrapAlloc)
|
|
*pcbAtrLen = 0;
|
|
|
|
if (pcchReaderLenWrapAlloc)
|
|
*pcchReaderLen = 0;
|
|
|
|
status = g_PCSC.pfnSCardStatus(hCard,
|
|
mszReaderNames, pcchReaderLen,
|
|
pdwState, pdwProtocol, (pcchReaderLenWrapAlloc) ? NULL : pbAtr, pcbAtrLen);
|
|
|
|
if (!status)
|
|
{
|
|
if (pcbAtrLenWrapAlloc)
|
|
{
|
|
*pPbAtr = (BYTE*) calloc(1, *pcbAtrLen);
|
|
|
|
if (!*pPbAtr)
|
|
return SCARD_E_NO_MEMORY;
|
|
}
|
|
|
|
if (pcchReaderLenWrapAlloc)
|
|
{
|
|
*pMszReaderNames = (LPSTR) calloc(1, *pcchReaderLen);
|
|
|
|
if (!*pMszReaderNames)
|
|
return SCARD_E_NO_MEMORY;
|
|
}
|
|
|
|
status = g_PCSC.pfnSCardStatus(hCard,
|
|
(pcchReaderLenWrapAlloc) ? *pMszReaderNames : mszReaderNames, pcchReaderLen,
|
|
pdwState, pdwProtocol, (pcbAtrLenWrapAlloc) ? *pPbAtr : pbAtr, pcbAtrLen);
|
|
|
|
if (status)
|
|
{
|
|
if (pcbAtrLenWrapAlloc)
|
|
free(*pPbAtr);
|
|
|
|
if (pcchReaderLenWrapAlloc)
|
|
free(*pMszReaderNames);
|
|
}
|
|
else
|
|
{
|
|
if (pcbAtrLenWrapAlloc)
|
|
PCSC_AddMemoryBlock(hContext, *pPbAtr);
|
|
|
|
if (pcchReaderLenWrapAlloc)
|
|
PCSC_AddMemoryBlock(hContext, *pMszReaderNames);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = g_PCSC.pfnSCardStatus(hCard, mszReaderNames, pcchReaderLen,
|
|
pdwState, pdwProtocol, pbAtr, pcbAtrLen);
|
|
}
|
|
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
|
|
mszReaderNamesPCSC = PCSC_ConvertReaderNamesToWinSCard(*pMszReaderNames);
|
|
|
|
if (mszReaderNamesPCSC)
|
|
{
|
|
PCSC_SCardFreeMemory_Internal(hContext, *pMszReaderNames);
|
|
|
|
*pMszReaderNames = mszReaderNamesPCSC;
|
|
*pcchReaderLen = PCSC_MultiStringLengthA(*pMszReaderNames) + 2;
|
|
PCSC_AddMemoryBlock(hContext, *pMszReaderNames);
|
|
}
|
|
|
|
*pdwState &= 0xFFFF;
|
|
*pdwState = PCSC_ConvertCardStateToWinSCard(*pdwState, status);
|
|
|
|
*pdwProtocol = PCSC_ConvertProtocolsToWinSCard(*pdwProtocol);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardStatusA(SCARDHANDLE hCard,
|
|
LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
|
|
LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardStatus)
|
|
{
|
|
status = PCSC_SCardStatus_Internal(hCard, mszReaderNames, pcchReaderLen, pdwState, pdwProtocol, pbAtr, pcbAtrLen);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardStatusW(SCARDHANDLE hCard,
|
|
LPWSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
|
|
LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardStatus)
|
|
{
|
|
SCARDCONTEXT hContext = 0;
|
|
LPSTR mszReaderNamesA = NULL;
|
|
|
|
hContext = PCSC_GetCardContextFromHandle(hCard);
|
|
|
|
status = PCSC_SCardStatus_Internal(hCard, (LPSTR) &mszReaderNamesA, pcchReaderLen, pdwState, pdwProtocol, pbAtr, pcbAtrLen);
|
|
|
|
if (mszReaderNamesA)
|
|
{
|
|
*pcchReaderLen = ConvertToUnicode(CP_UTF8, 0, mszReaderNamesA, *pcchReaderLen, (WCHAR**) mszReaderNames, 0);
|
|
PCSC_AddMemoryBlock(hContext, mszReaderNames);
|
|
|
|
PCSC_SCardFreeMemory_Internal(hContext, mszReaderNamesA);
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardTransmit(SCARDHANDLE hCard,
|
|
LPCSCARD_IO_REQUEST pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength,
|
|
LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardTransmit)
|
|
{
|
|
if (!pioSendPci)
|
|
{
|
|
DWORD dwState = 0;
|
|
DWORD cbAtrLen = 0;
|
|
DWORD dwProtocol = 0;
|
|
DWORD cchReaderLen = 0;
|
|
|
|
/**
|
|
* pcsc-lite cannot have a null pioSendPci parameter, unlike WinSCard.
|
|
* Query the current protocol and use default SCARD_IO_REQUEST for it.
|
|
*/
|
|
|
|
status = SCardStatusA(hCard, NULL, &cchReaderLen, &dwState, &dwProtocol, NULL, &cbAtrLen);
|
|
|
|
if (status == SCARD_S_SUCCESS)
|
|
{
|
|
if (dwProtocol == SCARD_PROTOCOL_T0)
|
|
pioSendPci = SCARD_PCI_T0;
|
|
else if (dwProtocol == SCARD_PROTOCOL_T1)
|
|
pioSendPci = SCARD_PCI_T1;
|
|
else if (dwProtocol == SCARD_PROTOCOL_RAW)
|
|
pioSendPci = SCARD_PCI_RAW;
|
|
}
|
|
}
|
|
|
|
status = g_PCSC.pfnSCardTransmit(hCard, pioSendPci, pbSendBuffer,
|
|
cbSendLength, pioRecvPci, pbRecvBuffer, pcbRecvLength);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetTransmitCount(SCARDHANDLE hCard, LPDWORD pcTransmitCount)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardControl(SCARDHANDLE hCard,
|
|
DWORD dwControlCode, LPCVOID lpInBuffer, DWORD cbInBufferSize,
|
|
LPVOID lpOutBuffer, DWORD cbOutBufferSize, LPDWORD lpBytesReturned)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardControl)
|
|
{
|
|
status = g_PCSC.pfnSCardControl(hCard,
|
|
dwControlCode, lpInBuffer, cbInBufferSize,
|
|
lpOutBuffer, cbOutBufferSize, lpBytesReturned);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib_Internal(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardGetAttrib)
|
|
{
|
|
SCARDCONTEXT hContext = 0;
|
|
BOOL pcbAttrLenWrapAlloc = FALSE;
|
|
LPBYTE* pPbAttr = (LPBYTE*) pbAttr;
|
|
|
|
if ((*pcbAttrLen == SCARD_AUTOALLOCATE) && !g_SCardAutoAllocate)
|
|
pcbAttrLenWrapAlloc = TRUE;
|
|
|
|
if (pcbAttrLenWrapAlloc)
|
|
{
|
|
*pcbAttrLen = 0;
|
|
|
|
status = g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, NULL, pcbAttrLen);
|
|
|
|
if (!status)
|
|
{
|
|
*pPbAttr = (BYTE*) calloc(1, *pcbAttrLen);
|
|
|
|
if (!*pPbAttr)
|
|
return SCARD_E_NO_MEMORY;
|
|
|
|
status = g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, *pPbAttr, pcbAttrLen);
|
|
|
|
if (status)
|
|
{
|
|
free(*pPbAttr);
|
|
}
|
|
else
|
|
{
|
|
hContext = PCSC_GetCardContextFromHandle(hCard);
|
|
PCSC_AddMemoryBlock(hContext, *pPbAttr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = g_PCSC.pfnSCardGetAttrib(hCard, dwAttrId, pbAttr, pcbAttrLen);
|
|
}
|
|
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPBYTE pbAttr, LPDWORD pcbAttrLen)
|
|
{
|
|
DWORD cbAttrLen;
|
|
SCARDCONTEXT hContext;
|
|
BOOL attrAutoAlloc = FALSE;
|
|
LONG status = SCARD_S_SUCCESS;
|
|
LPBYTE* pPbAttr = (LPBYTE*) pbAttr;
|
|
|
|
cbAttrLen = *pcbAttrLen;
|
|
|
|
if (*pcbAttrLen == SCARD_AUTOALLOCATE)
|
|
attrAutoAlloc = TRUE;
|
|
|
|
hContext = PCSC_GetCardContextFromHandle(hCard);
|
|
|
|
status = PCSC_SCardGetAttrib_Internal(hCard, dwAttrId, pbAttr, pcbAttrLen);
|
|
|
|
if (status == SCARD_S_SUCCESS)
|
|
{
|
|
if (dwAttrId == SCARD_ATTR_VENDOR_NAME)
|
|
{
|
|
/**
|
|
* pcsc-lite adds a null terminator to the vendor name,
|
|
* while WinSCard doesn't. Strip the null terminator.
|
|
*/
|
|
|
|
if (attrAutoAlloc)
|
|
*pcbAttrLen = strlen((char*) *pPbAttr);
|
|
else
|
|
*pcbAttrLen = strlen((char*) pbAttr);
|
|
}
|
|
}
|
|
else if (status == SCARD_E_UNSUPPORTED_FEATURE)
|
|
{
|
|
if (dwAttrId == SCARD_ATTR_DEVICE_FRIENDLY_NAME_A)
|
|
{
|
|
WCHAR* pbAttrW = NULL;
|
|
|
|
*pcbAttrLen = SCARD_AUTOALLOCATE;
|
|
|
|
status = PCSC_SCardGetAttrib_Internal(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME_W,
|
|
(LPBYTE) &pbAttrW, pcbAttrLen);
|
|
|
|
if (status)
|
|
{
|
|
int length;
|
|
char* pbAttrA = NULL;
|
|
|
|
length = ConvertFromUnicode(CP_UTF8, 0, (WCHAR*) pbAttrW,
|
|
*pcbAttrLen, (char**) &pbAttrA, 0, NULL, NULL);
|
|
|
|
PCSC_SCardFreeMemory_Internal(hContext, pbAttrW);
|
|
|
|
if (attrAutoAlloc)
|
|
{
|
|
PCSC_AddMemoryBlock(hContext, pbAttrA);
|
|
*pPbAttr = (BYTE*) pbAttrA;
|
|
*pcbAttrLen = length;
|
|
}
|
|
else
|
|
{
|
|
if (length > cbAttrLen)
|
|
{
|
|
free(pbAttrA);
|
|
return SCARD_E_INSUFFICIENT_BUFFER;
|
|
}
|
|
else
|
|
{
|
|
CopyMemory(pbAttr, (BYTE*) pbAttrA, length);
|
|
*pcbAttrLen = length;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (dwAttrId == SCARD_ATTR_DEVICE_FRIENDLY_NAME_W)
|
|
{
|
|
char* pbAttrA = NULL;
|
|
|
|
*pcbAttrLen = SCARD_AUTOALLOCATE;
|
|
|
|
status = PCSC_SCardGetAttrib_Internal(hCard, SCARD_ATTR_DEVICE_FRIENDLY_NAME_A,
|
|
(LPBYTE) &pbAttrA, pcbAttrLen);
|
|
|
|
if (status)
|
|
{
|
|
int length;
|
|
WCHAR* pbAttrW = NULL;
|
|
|
|
length = ConvertToUnicode(CP_UTF8, 0, (char*) pbAttr, *pcbAttrLen, &pbAttrW, 0);
|
|
|
|
PCSC_SCardFreeMemory_Internal(hContext, pbAttrA);
|
|
|
|
if (attrAutoAlloc)
|
|
{
|
|
PCSC_AddMemoryBlock(hContext, pbAttrW);
|
|
*pPbAttr = (BYTE*) pbAttrW;
|
|
*pcbAttrLen = length;
|
|
}
|
|
else
|
|
{
|
|
if (length > cbAttrLen)
|
|
{
|
|
free(pbAttrW);
|
|
return SCARD_E_INSUFFICIENT_BUFFER;
|
|
}
|
|
else
|
|
{
|
|
CopyMemory(pbAttr, (BYTE*) pbAttrW, length);
|
|
*pcbAttrLen = length;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen)
|
|
{
|
|
LONG status = SCARD_S_SUCCESS;
|
|
|
|
if (g_PCSC.pfnSCardSetAttrib)
|
|
{
|
|
status = g_PCSC.pfnSCardSetAttrib(hCard, dwAttrId, pbAttr, cbAttrLen);
|
|
status = PCSC_MapErrorCodeToWinSCard(status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardUIDlgSelectCardA(LPOPENCARDNAMEA_EX pDlgStruc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardUIDlgSelectCardW(LPOPENCARDNAMEW_EX pDlgStruc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_GetOpenCardNameA(LPOPENCARDNAMEA pDlgStruc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_GetOpenCardNameW(LPOPENCARDNAMEW pDlgStruc)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardDlgExtendedError(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardReadCacheA(SCARDCONTEXT hContext,
|
|
UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data, DWORD* DataLen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardReadCacheW(SCARDCONTEXT hContext,
|
|
UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data, DWORD* DataLen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardWriteCacheA(SCARDCONTEXT hContext,
|
|
UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName, PBYTE Data, DWORD DataLen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardWriteCacheW(SCARDCONTEXT hContext,
|
|
UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName, PBYTE Data, DWORD DataLen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderIconA(SCARDCONTEXT hContext,
|
|
LPCSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderIconW(SCARDCONTEXT hContext,
|
|
LPCWSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetDeviceTypeIdA(SCARDCONTEXT hContext, LPCSTR szReaderName, LPDWORD pdwDeviceTypeId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetDeviceTypeIdW(SCARDCONTEXT hContext, LPCWSTR szReaderName, LPDWORD pdwDeviceTypeId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderDeviceInstanceIdA(SCARDCONTEXT hContext,
|
|
LPCSTR szReaderName, LPSTR szDeviceInstanceId, LPDWORD pcchDeviceInstanceId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardGetReaderDeviceInstanceIdW(SCARDCONTEXT hContext,
|
|
LPCWSTR szReaderName, LPWSTR szDeviceInstanceId, LPDWORD pcchDeviceInstanceId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReadersWithDeviceInstanceIdA(SCARDCONTEXT hContext,
|
|
LPCSTR szDeviceInstanceId, LPSTR mszReaders, LPDWORD pcchReaders)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardListReadersWithDeviceInstanceIdW(SCARDCONTEXT hContext,
|
|
LPCWSTR szDeviceInstanceId, LPWSTR mszReaders, LPDWORD pcchReaders)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
WINSCARDAPI LONG WINAPI PCSC_SCardAudit(SCARDCONTEXT hContext, DWORD dwEvent)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
SCardApiFunctionTable PCSC_SCardApiFunctionTable =
|
|
{
|
|
0, /* dwVersion */
|
|
0, /* dwFlags */
|
|
|
|
PCSC_SCardEstablishContext, /* SCardEstablishContext */
|
|
PCSC_SCardReleaseContext, /* SCardReleaseContext */
|
|
PCSC_SCardIsValidContext, /* SCardIsValidContext */
|
|
PCSC_SCardListReaderGroupsA, /* SCardListReaderGroupsA */
|
|
PCSC_SCardListReaderGroupsW, /* SCardListReaderGroupsW */
|
|
PCSC_SCardListReadersA, /* SCardListReadersA */
|
|
PCSC_SCardListReadersW, /* SCardListReadersW */
|
|
PCSC_SCardListCardsA, /* SCardListCardsA */
|
|
PCSC_SCardListCardsW, /* SCardListCardsW */
|
|
PCSC_SCardListInterfacesA, /* SCardListInterfacesA */
|
|
PCSC_SCardListInterfacesW, /* SCardListInterfacesW */
|
|
PCSC_SCardGetProviderIdA, /* SCardGetProviderIdA */
|
|
PCSC_SCardGetProviderIdW, /* SCardGetProviderIdW */
|
|
PCSC_SCardGetCardTypeProviderNameA, /* SCardGetCardTypeProviderNameA */
|
|
PCSC_SCardGetCardTypeProviderNameW, /* SCardGetCardTypeProviderNameW */
|
|
PCSC_SCardIntroduceReaderGroupA, /* SCardIntroduceReaderGroupA */
|
|
PCSC_SCardIntroduceReaderGroupW, /* SCardIntroduceReaderGroupW */
|
|
PCSC_SCardForgetReaderGroupA, /* SCardForgetReaderGroupA */
|
|
PCSC_SCardForgetReaderGroupW, /* SCardForgetReaderGroupW */
|
|
PCSC_SCardIntroduceReaderA, /* SCardIntroduceReaderA */
|
|
PCSC_SCardIntroduceReaderW, /* SCardIntroduceReaderW */
|
|
PCSC_SCardForgetReaderA, /* SCardForgetReaderA */
|
|
PCSC_SCardForgetReaderW, /* SCardForgetReaderW */
|
|
PCSC_SCardAddReaderToGroupA, /* SCardAddReaderToGroupA */
|
|
PCSC_SCardAddReaderToGroupW, /* SCardAddReaderToGroupW */
|
|
PCSC_SCardRemoveReaderFromGroupA, /* SCardRemoveReaderFromGroupA */
|
|
PCSC_SCardRemoveReaderFromGroupW, /* SCardRemoveReaderFromGroupW */
|
|
PCSC_SCardIntroduceCardTypeA, /* SCardIntroduceCardTypeA */
|
|
PCSC_SCardIntroduceCardTypeW, /* SCardIntroduceCardTypeW */
|
|
PCSC_SCardSetCardTypeProviderNameA, /* SCardSetCardTypeProviderNameA */
|
|
PCSC_SCardSetCardTypeProviderNameW, /* SCardSetCardTypeProviderNameW */
|
|
PCSC_SCardForgetCardTypeA, /* SCardForgetCardTypeA */
|
|
PCSC_SCardForgetCardTypeW, /* SCardForgetCardTypeW */
|
|
PCSC_SCardFreeMemory, /* SCardFreeMemory */
|
|
PCSC_SCardAccessStartedEvent, /* SCardAccessStartedEvent */
|
|
PCSC_SCardReleaseStartedEvent, /* SCardReleaseStartedEvent */
|
|
PCSC_SCardLocateCardsA, /* SCardLocateCardsA */
|
|
PCSC_SCardLocateCardsW, /* SCardLocateCardsW */
|
|
PCSC_SCardLocateCardsByATRA, /* SCardLocateCardsByATRA */
|
|
PCSC_SCardLocateCardsByATRW, /* SCardLocateCardsByATRW */
|
|
PCSC_SCardGetStatusChangeA, /* SCardGetStatusChangeA */
|
|
PCSC_SCardGetStatusChangeW, /* SCardGetStatusChangeW */
|
|
PCSC_SCardCancel, /* SCardCancel */
|
|
PCSC_SCardConnectA, /* SCardConnectA */
|
|
PCSC_SCardConnectW, /* SCardConnectW */
|
|
PCSC_SCardReconnect, /* SCardReconnect */
|
|
PCSC_SCardDisconnect, /* SCardDisconnect */
|
|
PCSC_SCardBeginTransaction, /* SCardBeginTransaction */
|
|
PCSC_SCardEndTransaction, /* SCardEndTransaction */
|
|
PCSC_SCardCancelTransaction, /* SCardCancelTransaction */
|
|
PCSC_SCardState, /* SCardState */
|
|
PCSC_SCardStatusA, /* SCardStatusA */
|
|
PCSC_SCardStatusW, /* SCardStatusW */
|
|
PCSC_SCardTransmit, /* SCardTransmit */
|
|
PCSC_SCardGetTransmitCount, /* SCardGetTransmitCount */
|
|
PCSC_SCardControl, /* SCardControl */
|
|
PCSC_SCardGetAttrib, /* SCardGetAttrib */
|
|
PCSC_SCardSetAttrib, /* SCardSetAttrib */
|
|
PCSC_SCardUIDlgSelectCardA, /* SCardUIDlgSelectCardA */
|
|
PCSC_SCardUIDlgSelectCardW, /* SCardUIDlgSelectCardW */
|
|
PCSC_GetOpenCardNameA, /* GetOpenCardNameA */
|
|
PCSC_GetOpenCardNameW, /* GetOpenCardNameW */
|
|
PCSC_SCardDlgExtendedError, /* SCardDlgExtendedError */
|
|
PCSC_SCardReadCacheA, /* SCardReadCacheA */
|
|
PCSC_SCardReadCacheW, /* SCardReadCacheW */
|
|
PCSC_SCardWriteCacheA, /* SCardWriteCacheA */
|
|
PCSC_SCardWriteCacheW, /* SCardWriteCacheW */
|
|
PCSC_SCardGetReaderIconA, /* SCardGetReaderIconA */
|
|
PCSC_SCardGetReaderIconW, /* SCardGetReaderIconW */
|
|
PCSC_SCardGetDeviceTypeIdA, /* SCardGetDeviceTypeIdA */
|
|
PCSC_SCardGetDeviceTypeIdW, /* SCardGetDeviceTypeIdW */
|
|
PCSC_SCardGetReaderDeviceInstanceIdA, /* SCardGetReaderDeviceInstanceIdA */
|
|
PCSC_SCardGetReaderDeviceInstanceIdW, /* SCardGetReaderDeviceInstanceIdW */
|
|
PCSC_SCardListReadersWithDeviceInstanceIdA, /* SCardListReadersWithDeviceInstanceIdA */
|
|
PCSC_SCardListReadersWithDeviceInstanceIdW, /* SCardListReadersWithDeviceInstanceIdW */
|
|
PCSC_SCardAudit /* SCardAudit */
|
|
};
|
|
|
|
PSCardApiFunctionTable PCSC_GetSCardApiFunctionTable(void)
|
|
{
|
|
return &PCSC_SCardApiFunctionTable;
|
|
}
|
|
|
|
extern PCSCFunctionTable g_PCSC_Link;
|
|
extern int PCSC_InitializeSCardApi_Link(void);
|
|
|
|
int PCSC_InitializeSCardApi(void)
|
|
{
|
|
#if 0
|
|
if (PCSC_InitializeSCardApi_Link() >= 0)
|
|
{
|
|
g_PCSC.pfnSCardEstablishContext = g_PCSC_Link.pfnSCardEstablishContext;
|
|
g_PCSC.pfnSCardReleaseContext = g_PCSC_Link.pfnSCardReleaseContext;
|
|
g_PCSC.pfnSCardIsValidContext = g_PCSC_Link.pfnSCardIsValidContext;
|
|
g_PCSC.pfnSCardConnect = g_PCSC_Link.pfnSCardConnect;
|
|
g_PCSC.pfnSCardReconnect = g_PCSC_Link.pfnSCardReconnect;
|
|
g_PCSC.pfnSCardDisconnect = g_PCSC_Link.pfnSCardDisconnect;
|
|
g_PCSC.pfnSCardBeginTransaction = g_PCSC_Link.pfnSCardBeginTransaction;
|
|
g_PCSC.pfnSCardEndTransaction = g_PCSC_Link.pfnSCardEndTransaction;
|
|
g_PCSC.pfnSCardStatus = g_PCSC_Link.pfnSCardStatus;
|
|
g_PCSC.pfnSCardGetStatusChange = g_PCSC_Link.pfnSCardGetStatusChange;
|
|
g_PCSC.pfnSCardControl = g_PCSC_Link.pfnSCardControl;
|
|
g_PCSC.pfnSCardTransmit = g_PCSC_Link.pfnSCardTransmit;
|
|
g_PCSC.pfnSCardListReaderGroups = g_PCSC_Link.pfnSCardListReaderGroups;
|
|
g_PCSC.pfnSCardListReaders = g_PCSC_Link.pfnSCardListReaders;
|
|
g_PCSC.pfnSCardFreeMemory = g_PCSC_Link.pfnSCardFreeMemory;
|
|
g_PCSC.pfnSCardCancel = g_PCSC_Link.pfnSCardCancel;
|
|
g_PCSC.pfnSCardGetAttrib = g_PCSC_Link.pfnSCardGetAttrib;
|
|
g_PCSC.pfnSCardSetAttrib = g_PCSC_Link.pfnSCardSetAttrib;
|
|
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
#ifdef __MACOSX__
|
|
g_PCSCModule = LoadLibraryA("/System/Library/Frameworks/PCSC.framework/PCSC");
|
|
#else
|
|
g_PCSCModule = LoadLibraryA("libpcsclite.so");
|
|
#endif
|
|
|
|
if (!g_PCSCModule)
|
|
return -1;
|
|
|
|
g_PCSC.pfnSCardEstablishContext = (void*) GetProcAddress(g_PCSCModule, "SCardEstablishContext");
|
|
g_PCSC.pfnSCardReleaseContext = (void*) GetProcAddress(g_PCSCModule, "SCardReleaseContext");
|
|
g_PCSC.pfnSCardIsValidContext = (void*) GetProcAddress(g_PCSCModule, "SCardIsValidContext");
|
|
g_PCSC.pfnSCardConnect = (void*) GetProcAddress(g_PCSCModule, "SCardConnect");
|
|
g_PCSC.pfnSCardReconnect = (void*) GetProcAddress(g_PCSCModule, "SCardReconnect");
|
|
g_PCSC.pfnSCardDisconnect = (void*) GetProcAddress(g_PCSCModule, "SCardDisconnect");
|
|
g_PCSC.pfnSCardBeginTransaction = (void*) GetProcAddress(g_PCSCModule, "SCardBeginTransaction");
|
|
g_PCSC.pfnSCardEndTransaction = (void*) GetProcAddress(g_PCSCModule, "SCardEndTransaction");
|
|
g_PCSC.pfnSCardStatus = (void*) GetProcAddress(g_PCSCModule, "SCardStatus");
|
|
g_PCSC.pfnSCardGetStatusChange = (void*) GetProcAddress(g_PCSCModule, "SCardGetStatusChange");
|
|
g_PCSC.pfnSCardControl = (void*) GetProcAddress(g_PCSCModule, "SCardControl");
|
|
g_PCSC.pfnSCardTransmit = (void*) GetProcAddress(g_PCSCModule, "SCardTransmit");
|
|
g_PCSC.pfnSCardListReaderGroups = (void*) GetProcAddress(g_PCSCModule, "SCardListReaderGroups");
|
|
g_PCSC.pfnSCardListReaders = (void*) GetProcAddress(g_PCSCModule, "SCardListReaders");
|
|
g_PCSC.pfnSCardCancel = (void*) GetProcAddress(g_PCSCModule, "SCardCancel");
|
|
g_PCSC.pfnSCardGetAttrib = (void*) GetProcAddress(g_PCSCModule, "SCardGetAttrib");
|
|
g_PCSC.pfnSCardSetAttrib = (void*) GetProcAddress(g_PCSCModule, "SCardSetAttrib");
|
|
|
|
g_PCSC.pfnSCardFreeMemory = NULL;
|
|
|
|
#ifndef __MACOSX__
|
|
g_PCSC.pfnSCardFreeMemory = (void*) GetProcAddress(g_PCSCModule, "SCardFreeMemory");
|
|
#endif
|
|
|
|
if (g_PCSC.pfnSCardFreeMemory)
|
|
g_SCardAutoAllocate = TRUE;
|
|
|
|
#ifdef DISABLE_PCSC_SCARD_AUTOALLOCATE
|
|
g_PCSC.pfnSCardFreeMemory = NULL;
|
|
g_SCardAutoAllocate = FALSE;
|
|
#endif
|
|
|
|
return 1;
|
|
}
|