21#include <freerdp/config.h>
22#include <freerdp/freerdp.h>
25#include <winpr/wlog.h>
26#include <winpr/file.h>
27#include <winpr/path.h>
28#include <winpr/library.h>
29#include <winpr/smartcard.h>
30#include <winpr/collections.h>
31#include <winpr/crypto.h>
32#include <winpr/interlocked.h>
34#include <freerdp/emulate/scard/smartcard_emulate.h>
35#include "FreeRDP.ico.h"
37#include "smartcard_virtual_gids.h"
39#define MAX_CACHE_ITEM_SIZE 4096
40#define MAX_CACHE_ITEM_VALUES 4096
42#define VGIDS_DEFAULT_RETRY_COUNTER 3
50static CHAR g_ReaderNameA[] = {
'F',
'r',
'e',
'e',
'R',
'D',
'P',
' ',
'E',
51 'm',
'u',
'l',
'a',
't',
'o',
'r',
'\0',
'\0' };
52static INIT_ONCE g_ReaderNameWGuard = INIT_ONCE_STATIC_INIT;
53static WCHAR g_ReaderNameW[32] = WINPR_C_ARRAY_INIT;
54static size_t g_ReaderNameWLen = 0;
56WINPR_ATTR_MALLOC(free, 1)
57static
char* card_id_and_name_a(const
UUID* CardIdentifier, LPCSTR LookupName)
59 if (!CardIdentifier || !LookupName)
62 size_t len = strlen(LookupName) + 34;
63 char*
id = malloc(len);
67 (void)snprintf(
id, len,
"%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X\\%s",
68 CardIdentifier->Data1, CardIdentifier->Data2, CardIdentifier->Data3,
69 CardIdentifier->Data4[0], CardIdentifier->Data4[1], CardIdentifier->Data4[2],
70 CardIdentifier->Data4[3], CardIdentifier->Data4[4], CardIdentifier->Data4[5],
71 CardIdentifier->Data4[6], CardIdentifier->Data4[7], LookupName);
75WINPR_ATTR_MALLOC(free, 1)
76static
char* card_id_and_name_w(const
UUID* CardIdentifier, LPCWSTR LookupName)
79 char* tmp = ConvertWCharToUtf8Alloc(LookupName,
nullptr);
82 res = card_id_and_name_a(CardIdentifier, tmp);
88static BOOL CALLBACK g_ReaderNameWInit(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)
90 WINPR_UNUSED(InitOnce);
91 WINPR_UNUSED(Parameter);
92 WINPR_UNUSED(Context);
93 InitializeConstWCharFromUtf8(g_ReaderNameA, g_ReaderNameW, ARRAYSIZE(g_ReaderNameW));
94 g_ReaderNameWLen = _wcsnlen(g_ReaderNameW, ARRAYSIZE(g_ReaderNameW) - 2) + 2;
98struct smartcard_emulation_context
100 const rdpSettings* settings;
101 DWORD log_default_level;
103 wHashTable* contexts;
109 wHashTable* pinCounters;
115 UINT16 curRetryCounter;
117} SmartcardPinCounterEntry;
119#define MAX_EMULATED_READERS 1
129 volatile LONG semaphore;
144 DWORD dwActiveProtocol;
145 SCARDCONTEXT hContext;
148 size_t referencecount;
155 char data[MAX_CACHE_ITEM_SIZE];
159static SCardHandle* find_reader(SmartcardEmulationContext* smartcard,
const void* szReader,
162static const BYTE ATR[] = { 0x3b, 0xf7, 0x18, 0x00, 0x00, 0x80, 0x31, 0xfe, 0x45,
163 0x73, 0x66, 0x74, 0x65, 0x2d, 0x6e, 0x66, 0xc4 };
166static BOOL scard_status_transition(SCardContext* context)
168 WINPR_ASSERT(context);
170 switch (context->readerState)
176 reader->szReader = g_ReaderNameA;
177 reader->dwEventState = SCARD_STATE_PRESENT;
178 reader->cbAtr =
sizeof(ATR);
179 memcpy(reader->rgbAtr, ATR,
sizeof(ATR));
182 if (!InitOnceExecuteOnce(&g_ReaderNameWGuard, g_ReaderNameWInit,
nullptr,
nullptr))
185 reader->szReader = g_ReaderNameW;
186 reader->dwEventState = SCARD_STATE_PRESENT;
187 reader->cbAtr =
sizeof(ATR);
188 memcpy(reader->rgbAtr, ATR,
sizeof(ATR));
190 context->readerState = 42;
198static UINT32 scard_copy_strings(SCardContext* ctx,
void* dst,
size_t dstSize,
const void* src,
204 WINPR_ASSERT(srcSize <= UINT32_MAX);
205 WINPR_ASSERT(dstSize <= UINT32_MAX);
207 if (dstSize == SCARD_AUTOALLOCATE)
212 void* tmp = malloc(srcSize);
215 memcpy(tmp, src, srcSize);
216 ArrayList_Append(ctx->strings, tmp);
217 *((
void**)dst) = tmp;
218 return (UINT32)srcSize;
222 const size_t min = MIN(dstSize, srcSize);
223 memcpy(dst, src, min);
228static void waitForCancel(SCardContext* ctx)
231 while (InterlockedCompareExchange(&ctx->semaphore, 0, 0) > 0)
235static void scard_context_free(
void* context)
237 SCardContext* ctx = context;
246 ctx->canceled = TRUE;
249 HashTable_Free(ctx->cards);
250 ArrayList_Free(ctx->strings);
251 HashTable_Free(ctx->cache);
256WINPR_ATTR_MALLOC(scard_context_free, 1)
257static SCardContext* scard_context_new(
void)
259 SCardContext* ctx = calloc(1,
sizeof(SCardContext));
263 ctx->strings = ArrayList_New(FALSE);
268 wObject* obj = ArrayList_Object(ctx->strings);
270 obj->fnObjectFree = free;
273 ctx->cache = HashTable_New(FALSE);
276 if (!HashTable_SetupForStringData(ctx->cache, FALSE))
280 wObject* val = HashTable_ValueObject(ctx->cache);
285 if (!scard_status_transition(ctx))
289 scard_context_free(ctx);
293static void scard_handle_free(
void* handle)
295 SCardHandle* hdl = handle;
298 free(hdl->szReader.pv);
299 vgids_free(hdl->vgids);
304WINPR_ATTR_MALLOC(scard_handle_free, 1)
305static SCardHandle* scard_handle_new(SmartcardEmulationContext* smartcard, SCARDCONTEXT context,
306 const
void* name, BOOL unicode)
308 SCardHandle* hdl =
nullptr;
310 WINPR_ASSERT(smartcard);
312 hdl = calloc(1,
sizeof(SCardHandle));
321 size_t s = _wcslen(name);
323 hdl->szReader.pw = calloc(s + 2,
sizeof(WCHAR));
324 if (!hdl->szReader.pw)
326 memcpy(hdl->szReader.pv, name, s *
sizeof(WCHAR));
330 size_t s = strlen(name);
332 hdl->szReader.pc = calloc(s + 2,
sizeof(CHAR));
333 if (!hdl->szReader.pc)
335 memcpy(hdl->szReader.pv, name, s *
sizeof(CHAR));
338 if (!hdl->szReader.pv)
341 hdl->vgids = vgids_new(smartcard);
353 if (!vgids_init(hdl->vgids, pem, key, pin))
357 hdl->unicode = unicode;
358 hdl->hContext = context;
362 scard_handle_free(hdl);
367static LONG scard_handle_valid(SmartcardEmulationContext* smartcard, SCARDHANDLE handle)
369 WINPR_ASSERT(smartcard);
371 SCardHandle* ctx = HashTable_GetItemValue(smartcard->handles, (
const void*)handle);
373 return SCARD_E_INVALID_HANDLE;
375 return SCARD_S_SUCCESS;
379static LONG scard_reader_name_valid_a(SmartcardEmulationContext* smartcard, SCARDCONTEXT context,
382 WINPR_ASSERT(smartcard);
384 HashTable_Lock(smartcard->contexts);
385 SCardContext* ctx = HashTable_GetItemValue(smartcard->contexts, (
const void*)context);
390 LONG rc = SCARD_E_UNKNOWN_READER;
391 for (
size_t x = 0; x < MAX_EMULATED_READERS; x++)
394 if (strcmp(reader->szReader, name) == 0)
396 rc = SCARD_S_SUCCESS;
401 HashTable_Unlock(smartcard->contexts);
407static LONG scard_reader_name_valid_w(SmartcardEmulationContext* smartcard, SCARDCONTEXT context,
410 SCardContext* ctx =
nullptr;
412 WINPR_ASSERT(smartcard);
413 ctx = HashTable_GetItemValue(smartcard->contexts, (
const void*)context);
418 for (
size_t x = 0; x < MAX_EMULATED_READERS; x++)
421 if (_wcscmp(reader->szReader, name) == 0)
422 return SCARD_S_SUCCESS;
425 return SCARD_E_UNKNOWN_READER;
432LONG WINAPI Emulate_SCardEstablishContext(SmartcardEmulationContext* smartcard, DWORD dwScope,
433 LPCVOID pvReserved1, LPCVOID pvReserved2,
434 LPSCARDCONTEXT phContext)
436 LONG status = SCARD_E_NO_MEMORY;
437 SCardContext* ctx =
nullptr;
439 WINPR_ASSERT(smartcard);
441 ctx = scard_context_new();
443 WINPR_UNUSED(pvReserved1);
444 WINPR_UNUSED(pvReserved2);
446 WLog_Print(smartcard->log, smartcard->log_default_level,
447 "SCardEstablishContext { dwScope: %s (0x%08" PRIX32
")",
448 SCardGetScopeString(dwScope), dwScope);
452 SCARDCONTEXT context = WINPR_C_ARRAY_INIT;
454 if (winpr_RAND(&context,
sizeof(SCARDCONTEXT)) >= 0)
456 if (HashTable_Insert(smartcard->contexts, (
const void*)context, ctx))
458 *phContext = context;
459 status = SCARD_S_SUCCESS;
464 WLog_Print(smartcard->log, smartcard->log_default_level,
465 "SCardEstablishContext } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
466 WINPR_CXX_COMPAT_CAST(UINT32, status));
468 if (status != SCARD_S_SUCCESS)
469 scard_context_free(ctx);
475static BOOL remove_handles(
const void* key,
void* value,
void* arg)
480 const HandleCleanLoopArg* harg = arg;
481 SCardHandle* handle = value;
482 if (handle->hContext == harg->context)
484 if (!HashTable_Remove(harg->table, key))
490LONG WINAPI Emulate_SCardReleaseContext(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext)
492 LONG status = SCARD_S_SUCCESS;
494 WINPR_ASSERT(smartcard);
496 HashTable_Lock(smartcard->contexts);
497 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
499 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardReleaseContext { hContext: %p",
502 HandleCleanLoopArg arg = { .context = hContext, .table = smartcard->handles };
503 if (!HashTable_Foreach(smartcard->handles, remove_handles, &arg))
504 status = SCARD_E_INVALID_HANDLE;
507 HashTable_Remove(smartcard->contexts, (
const void*)hContext);
509 HashTable_Unlock(smartcard->contexts);
511 WLog_Print(smartcard->log, smartcard->log_default_level,
512 "SCardReleaseContext } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
513 WINPR_CXX_COMPAT_CAST(UINT32, status));
518LONG WINAPI Emulate_SCardIsValidContext(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext)
522 WINPR_ASSERT(smartcard);
524 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardIsValidContext { hContext: %p",
527 status = HashTable_Contains(smartcard->contexts, (
const void*)hContext)
529 : SCARD_E_INVALID_HANDLE;
530 if (status == SCARD_S_SUCCESS)
532 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
535 return SCARD_F_INTERNAL_ERROR;
538 WLog_Print(smartcard->log, smartcard->log_default_level,
539 "SCardIsValidContext } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
540 WINPR_CXX_COMPAT_CAST(UINT32, status));
545LONG WINAPI Emulate_SCardListReaderGroupsA(
546 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
547 LPSTR mszGroups , LPDWORD pcchGroups)
549 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
551 WLog_Print(smartcard->log, smartcard->log_default_level,
552 "SCardListReaderGroupsA { hContext: %p", (
void*)hContext);
554 WINPR_UNUSED(mszGroups);
555 WINPR_UNUSED(pcchGroups);
558 if (status == SCARD_S_SUCCESS)
559 status = SCARD_E_UNSUPPORTED_FEATURE;
561 WLog_Print(smartcard->log, smartcard->log_default_level,
562 "SCardListReaderGroupsA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
563 WINPR_CXX_COMPAT_CAST(UINT32, status));
568LONG WINAPI Emulate_SCardListReaderGroupsW(
569 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
570 LPWSTR mszGroups , LPDWORD pcchGroups)
572 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
574 WLog_Print(smartcard->log, smartcard->log_default_level,
575 "SCardListReaderGroupsW { hContext: %p", (
void*)hContext);
577 WINPR_UNUSED(mszGroups);
578 WINPR_UNUSED(pcchGroups);
581 if (status == SCARD_S_SUCCESS)
582 status = SCARD_E_UNSUPPORTED_FEATURE;
584 WLog_Print(smartcard->log, smartcard->log_default_level,
585 "SCardListReaderGroupsW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
586 WINPR_CXX_COMPAT_CAST(UINT32, status));
591LONG WINAPI Emulate_SCardListReadersA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
592 LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)
594 HashTable_Lock(smartcard->contexts);
595 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
597 status = SCARD_E_INVALID_PARAMETER;
599 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardListReadersA { hContext: %p",
602 WINPR_UNUSED(mszGroups);
604 if (SCARD_S_SUCCESS == status)
606 SCardContext* value =
607 (SCardContext*)HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
616 *pcchReaders = ARRAYSIZE(g_ReaderNameA);
619 *pcchReaders = scard_copy_strings(value, mszReaders, *pcchReaders, g_ReaderNameA,
620 sizeof(g_ReaderNameA));
624 WLog_Print(smartcard->log, smartcard->log_default_level,
625 "SCardListReadersA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
626 WINPR_CXX_COMPAT_CAST(UINT32, status));
627 HashTable_Unlock(smartcard->contexts);
631LONG WINAPI Emulate_SCardListReadersW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
632 LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders)
634 if (!InitOnceExecuteOnce(&g_ReaderNameWGuard, g_ReaderNameWInit,
nullptr,
nullptr))
635 return SCARD_E_NOT_READY;
637 HashTable_Lock(smartcard->contexts);
638 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
641 status = SCARD_E_INVALID_PARAMETER;
643 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardListReadersW { hContext: %p",
646 WINPR_UNUSED(mszGroups);
648 if (SCARD_S_SUCCESS == status)
650 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
660 WINPR_ASSERT(g_ReaderNameWLen <= UINT32_MAX);
661 *pcchReaders = (UINT32)g_ReaderNameWLen;
665 *pcchReaders = scard_copy_strings(value, mszReaders, *pcchReaders, g_ReaderNameW,
666 g_ReaderNameWLen *
sizeof(WCHAR)) /
671 WLog_Print(smartcard->log, smartcard->log_default_level,
672 "SCardListReadersW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
673 WINPR_CXX_COMPAT_CAST(UINT32, status));
674 HashTable_Unlock(smartcard->contexts);
678LONG WINAPI Emulate_SCardListCardsA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
679 LPCBYTE pbAtr, LPCGUID rgquidInterfaces,
680 DWORD cguidInterfaceCount,
684 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
686 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardListCardsA { hContext: %p",
690 WINPR_UNUSED(rgquidInterfaces);
691 WINPR_UNUSED(cguidInterfaceCount);
692 WINPR_UNUSED(mszCards);
693 WINPR_UNUSED(pcchCards);
696 if (status == SCARD_S_SUCCESS)
697 status = SCARD_E_UNSUPPORTED_FEATURE;
699 WLog_Print(smartcard->log, smartcard->log_default_level,
700 "SCardListCardsA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
701 WINPR_CXX_COMPAT_CAST(UINT32, status));
706LONG WINAPI Emulate_SCardListCardsW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
707 LPCBYTE pbAtr, LPCGUID rgquidInterfaces,
708 DWORD cguidInterfaceCount,
712 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
714 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardListCardsW { hContext: %p",
718 WINPR_UNUSED(rgquidInterfaces);
719 WINPR_UNUSED(cguidInterfaceCount);
720 WINPR_UNUSED(mszCards);
721 WINPR_UNUSED(pcchCards);
724 if (status == SCARD_S_SUCCESS)
725 status = SCARD_E_UNSUPPORTED_FEATURE;
727 WLog_Print(smartcard->log, smartcard->log_default_level,
728 "SCardListCardsW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
729 WINPR_CXX_COMPAT_CAST(UINT32, status));
734LONG WINAPI Emulate_SCardListInterfacesA(
735 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szCard,
736 LPGUID pguidInterfaces, LPDWORD pcguidInterfaces )
738 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
740 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardListInterfacesA { hContext: %p",
743 WINPR_UNUSED(szCard);
744 WINPR_UNUSED(pguidInterfaces);
745 WINPR_UNUSED(pcguidInterfaces);
748 if (status == SCARD_S_SUCCESS)
749 status = SCARD_E_UNSUPPORTED_FEATURE;
751 WLog_Print(smartcard->log, smartcard->log_default_level,
752 "SCardListInterfacesA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
753 WINPR_CXX_COMPAT_CAST(UINT32, status));
758LONG WINAPI Emulate_SCardListInterfacesW(
759 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szCard,
760 LPGUID pguidInterfaces, LPDWORD pcguidInterfaces )
762 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
764 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardListInterfacesW { hContext: %p",
767 WINPR_UNUSED(szCard);
768 WINPR_UNUSED(pguidInterfaces);
769 WINPR_UNUSED(pcguidInterfaces);
772 if (status == SCARD_S_SUCCESS)
773 status = SCARD_E_UNSUPPORTED_FEATURE;
775 WLog_Print(smartcard->log, smartcard->log_default_level,
776 "SCardListInterfacesW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
777 WINPR_CXX_COMPAT_CAST(UINT32, status));
782LONG WINAPI Emulate_SCardGetProviderIdA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
783 LPCSTR szCard, LPGUID pguidProviderId)
785 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
787 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetProviderIdA { hContext: %p",
790 WINPR_UNUSED(szCard);
791 WINPR_UNUSED(pguidProviderId);
794 if (status == SCARD_S_SUCCESS)
795 status = SCARD_E_UNSUPPORTED_FEATURE;
797 WLog_Print(smartcard->log, smartcard->log_default_level,
798 "SCardGetProviderIdA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
799 WINPR_CXX_COMPAT_CAST(UINT32, status));
804LONG WINAPI Emulate_SCardGetProviderIdW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
805 LPCWSTR szCard, LPGUID pguidProviderId)
807 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
809 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetProviderIdW { hContext: %p",
812 WINPR_UNUSED(szCard);
813 WINPR_UNUSED(pguidProviderId);
816 if (status == SCARD_S_SUCCESS)
817 status = SCARD_E_UNSUPPORTED_FEATURE;
819 WLog_Print(smartcard->log, smartcard->log_default_level,
820 "SCardGetProviderIdW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
821 WINPR_CXX_COMPAT_CAST(UINT32, status));
826LONG WINAPI Emulate_SCardGetCardTypeProviderNameA(
827 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szCardName,
828 DWORD dwProviderId, CHAR* szProvider ,
829 LPDWORD pcchProvider )
831 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
833 WLog_Print(smartcard->log, smartcard->log_default_level,
834 "SCardGetCardTypeProviderNameA { hContext: %p", (
void*)hContext);
836 WINPR_UNUSED(szCardName);
837 WINPR_UNUSED(dwProviderId);
838 WINPR_UNUSED(szProvider);
839 WINPR_UNUSED(pcchProvider);
842 if (status == SCARD_S_SUCCESS)
843 status = SCARD_E_UNSUPPORTED_FEATURE;
845 WLog_Print(smartcard->log, smartcard->log_default_level,
846 "SCardGetCardTypeProviderNameA } status: %s (0x%08" PRIX32
")",
847 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
852LONG WINAPI Emulate_SCardGetCardTypeProviderNameW(
853 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szCardName,
854 DWORD dwProviderId, WCHAR* szProvider ,
855 LPDWORD pcchProvider )
857 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
859 WLog_Print(smartcard->log, smartcard->log_default_level,
860 "SCardGetCardTypeProviderNameW { hContext: %p", (
void*)hContext);
862 WINPR_UNUSED(szCardName);
863 WINPR_UNUSED(dwProviderId);
864 WINPR_UNUSED(szProvider);
865 WINPR_UNUSED(pcchProvider);
868 if (status == SCARD_S_SUCCESS)
869 status = SCARD_E_UNSUPPORTED_FEATURE;
871 WLog_Print(smartcard->log, smartcard->log_default_level,
872 "SCardGetCardTypeProviderNameW } status: %s (0x%08" PRIX32
")",
873 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
878LONG WINAPI Emulate_SCardIntroduceReaderGroupA(SmartcardEmulationContext* smartcard,
879 SCARDCONTEXT hContext, LPCSTR szGroupName)
881 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
883 WLog_Print(smartcard->log, smartcard->log_default_level,
884 "SCardIntroduceReaderGroupA { hContext: %p", (
void*)hContext);
886 WINPR_UNUSED(szGroupName);
889 if (status == SCARD_S_SUCCESS)
890 status = SCARD_E_UNSUPPORTED_FEATURE;
892 WLog_Print(smartcard->log, smartcard->log_default_level,
893 "SCardIntroduceReaderGroupA } status: %s (0x%08" PRIX32
")",
894 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
899LONG WINAPI Emulate_SCardIntroduceReaderGroupW(SmartcardEmulationContext* smartcard,
900 SCARDCONTEXT hContext, LPCWSTR szGroupName)
902 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
904 WLog_Print(smartcard->log, smartcard->log_default_level,
905 "SCardIntroduceReaderGroupW { hContext: %p", (
void*)hContext);
907 WINPR_UNUSED(szGroupName);
910 if (status == SCARD_S_SUCCESS)
911 status = SCARD_E_UNSUPPORTED_FEATURE;
913 WLog_Print(smartcard->log, smartcard->log_default_level,
914 "SCardIntroduceReaderGroupW } status: %s (0x%08" PRIX32
")",
915 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
920LONG WINAPI Emulate_SCardForgetReaderGroupA(SmartcardEmulationContext* smartcard,
921 SCARDCONTEXT hContext, LPCSTR szGroupName)
923 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
925 WLog_Print(smartcard->log, smartcard->log_default_level,
926 "SCardForgetReaderGroupA { hContext: %p", (
void*)hContext);
928 WINPR_UNUSED(szGroupName);
931 if (status == SCARD_S_SUCCESS)
932 status = SCARD_E_UNSUPPORTED_FEATURE;
934 WLog_Print(smartcard->log, smartcard->log_default_level,
935 "SCardForgetReaderGroupA } status: %s (0x%08" PRIX32
")",
936 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
941LONG WINAPI Emulate_SCardForgetReaderGroupW(SmartcardEmulationContext* smartcard,
942 SCARDCONTEXT hContext, LPCWSTR szGroupName)
944 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
946 WLog_Print(smartcard->log, smartcard->log_default_level,
947 "SCardForgetReaderGroupW { hContext: %p", (
void*)hContext);
949 WINPR_UNUSED(szGroupName);
952 if (status == SCARD_S_SUCCESS)
953 status = SCARD_E_UNSUPPORTED_FEATURE;
955 WLog_Print(smartcard->log, smartcard->log_default_level,
956 "SCardForgetReaderGroupW } status: %s (0x%08" PRIX32
")",
957 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
962LONG WINAPI Emulate_SCardIntroduceReaderA(SmartcardEmulationContext* smartcard,
963 SCARDCONTEXT hContext, LPCSTR szReaderName,
966 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
968 if (status == SCARD_S_SUCCESS)
969 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
971 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardIntroduceReaderA { hContext: %p",
974 WINPR_UNUSED(szDeviceName);
977 if (status == SCARD_S_SUCCESS)
978 status = SCARD_E_UNSUPPORTED_FEATURE;
980 WLog_Print(smartcard->log, smartcard->log_default_level,
981 "SCardIntroduceReaderA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
982 WINPR_CXX_COMPAT_CAST(UINT32, status));
987LONG WINAPI Emulate_SCardIntroduceReaderW(SmartcardEmulationContext* smartcard,
988 SCARDCONTEXT hContext, LPCWSTR szReaderName,
989 LPCWSTR szDeviceName)
991 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
993 if (status == SCARD_S_SUCCESS)
994 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
996 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardIntroduceReaderW { hContext: %p",
999 WINPR_UNUSED(szDeviceName);
1002 if (status == SCARD_S_SUCCESS)
1003 status = SCARD_E_UNSUPPORTED_FEATURE;
1005 WLog_Print(smartcard->log, smartcard->log_default_level,
1006 "SCardIntroduceReaderW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1007 WINPR_CXX_COMPAT_CAST(UINT32, status));
1012LONG WINAPI Emulate_SCardForgetReaderA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1013 LPCSTR szReaderName)
1015 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1017 if (status == SCARD_S_SUCCESS)
1018 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
1020 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardForgetReaderA { hContext: %p",
1024 if (status == SCARD_S_SUCCESS)
1025 status = SCARD_E_UNSUPPORTED_FEATURE;
1027 WLog_Print(smartcard->log, smartcard->log_default_level,
1028 "SCardForgetReaderA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1029 WINPR_CXX_COMPAT_CAST(UINT32, status));
1034LONG WINAPI Emulate_SCardForgetReaderW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1035 LPCWSTR szReaderName)
1037 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1039 if (status == SCARD_S_SUCCESS)
1040 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
1042 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardForgetReaderW { hContext: %p",
1046 if (status == SCARD_S_SUCCESS)
1047 status = SCARD_E_UNSUPPORTED_FEATURE;
1049 WLog_Print(smartcard->log, smartcard->log_default_level,
1050 "SCardForgetReaderW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1051 WINPR_CXX_COMPAT_CAST(UINT32, status));
1056LONG WINAPI Emulate_SCardAddReaderToGroupA(SmartcardEmulationContext* smartcard,
1057 SCARDCONTEXT hContext, LPCSTR szReaderName,
1060 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1062 if (status == SCARD_S_SUCCESS)
1063 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
1065 WLog_Print(smartcard->log, smartcard->log_default_level,
1066 "SCardAddReaderToGroupA { hContext: %p", (
void*)hContext);
1068 WINPR_UNUSED(szGroupName);
1071 if (status == SCARD_S_SUCCESS)
1072 status = SCARD_E_UNSUPPORTED_FEATURE;
1074 WLog_Print(smartcard->log, smartcard->log_default_level,
1075 "SCardAddReaderToGroupA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1076 WINPR_CXX_COMPAT_CAST(UINT32, status));
1081LONG WINAPI Emulate_SCardAddReaderToGroupW(SmartcardEmulationContext* smartcard,
1082 SCARDCONTEXT hContext, LPCWSTR szReaderName,
1083 LPCWSTR szGroupName)
1085 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1087 if (status == SCARD_S_SUCCESS)
1088 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
1090 WLog_Print(smartcard->log, smartcard->log_default_level,
1091 "SCardAddReaderToGroupW { hContext: %p", (
void*)hContext);
1093 WINPR_UNUSED(szGroupName);
1096 if (status == SCARD_S_SUCCESS)
1097 status = SCARD_E_UNSUPPORTED_FEATURE;
1099 WLog_Print(smartcard->log, smartcard->log_default_level,
1100 "SCardAddReaderToGroupW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1101 WINPR_CXX_COMPAT_CAST(UINT32, status));
1106LONG WINAPI Emulate_SCardRemoveReaderFromGroupA(SmartcardEmulationContext* smartcard,
1107 SCARDCONTEXT hContext, LPCSTR szReaderName,
1110 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1112 if (status == SCARD_S_SUCCESS)
1113 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
1115 WLog_Print(smartcard->log, smartcard->log_default_level,
1116 "SCardRemoveReaderFromGroupA { hContext: %p", (
void*)hContext);
1118 WINPR_UNUSED(szGroupName);
1121 if (status == SCARD_S_SUCCESS)
1122 status = SCARD_E_UNSUPPORTED_FEATURE;
1124 WLog_Print(smartcard->log, smartcard->log_default_level,
1125 "SCardRemoveReaderFromGroupA } status: %s (0x%08" PRIX32
")",
1126 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
1131LONG WINAPI Emulate_SCardRemoveReaderFromGroupW(SmartcardEmulationContext* smartcard,
1132 SCARDCONTEXT hContext, LPCWSTR szReaderName,
1133 LPCWSTR szGroupName)
1135 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1137 if (status == SCARD_S_SUCCESS)
1138 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
1140 WLog_Print(smartcard->log, smartcard->log_default_level,
1141 "SCardRemoveReaderFromGroupW { hContext: %p", (
void*)hContext);
1143 WINPR_UNUSED(szGroupName);
1146 if (status == SCARD_S_SUCCESS)
1147 status = SCARD_E_UNSUPPORTED_FEATURE;
1149 WLog_Print(smartcard->log, smartcard->log_default_level,
1150 "SCardRemoveReaderFromGroupW } status: %s (0x%08" PRIX32
")",
1151 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
1156LONG WINAPI Emulate_SCardIntroduceCardTypeA(SmartcardEmulationContext* smartcard,
1157 SCARDCONTEXT hContext, LPCSTR szCardName,
1158 LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces,
1159 DWORD dwInterfaceCount, LPCBYTE pbAtr,
1160 LPCBYTE pbAtrMask, DWORD cbAtrLen)
1162 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1164 WLog_Print(smartcard->log, smartcard->log_default_level,
1165 "SCardIntroduceCardTypeA { hContext: %p", (
void*)hContext);
1167 WINPR_UNUSED(szCardName);
1168 WINPR_UNUSED(pguidPrimaryProvider);
1169 WINPR_UNUSED(rgguidInterfaces);
1170 WINPR_UNUSED(dwInterfaceCount);
1171 WINPR_UNUSED(pbAtr);
1172 WINPR_UNUSED(pbAtrMask);
1173 WINPR_UNUSED(cbAtrLen);
1176 if (status == SCARD_S_SUCCESS)
1177 status = SCARD_E_UNSUPPORTED_FEATURE;
1179 WLog_Print(smartcard->log, smartcard->log_default_level,
1180 "SCardIntroduceCardTypeA } status: %s (0x%08" PRIX32
")",
1181 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
1186LONG WINAPI Emulate_SCardIntroduceCardTypeW(SmartcardEmulationContext* smartcard,
1187 SCARDCONTEXT hContext, LPCWSTR szCardName,
1188 LPCGUID pguidPrimaryProvider, LPCGUID rgguidInterfaces,
1189 DWORD dwInterfaceCount, LPCBYTE pbAtr,
1190 LPCBYTE pbAtrMask, DWORD cbAtrLen)
1192 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1194 WLog_Print(smartcard->log, smartcard->log_default_level,
1195 "SCardIntroduceCardTypeW { hContext: %p", (
void*)hContext);
1197 WINPR_UNUSED(szCardName);
1198 WINPR_UNUSED(pguidPrimaryProvider);
1199 WINPR_UNUSED(rgguidInterfaces);
1200 WINPR_UNUSED(dwInterfaceCount);
1201 WINPR_UNUSED(pbAtr);
1202 WINPR_UNUSED(pbAtrMask);
1203 WINPR_UNUSED(cbAtrLen);
1206 if (status == SCARD_S_SUCCESS)
1207 status = SCARD_E_UNSUPPORTED_FEATURE;
1209 WLog_Print(smartcard->log, smartcard->log_default_level,
1210 "SCardIntroduceCardTypeW } status: %s (0x%08" PRIX32
")",
1211 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
1216LONG WINAPI Emulate_SCardSetCardTypeProviderNameA(SmartcardEmulationContext* smartcard,
1217 SCARDCONTEXT hContext, LPCSTR szCardName,
1218 DWORD dwProviderId, LPCSTR szProvider)
1220 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1222 WLog_Print(smartcard->log, smartcard->log_default_level,
1223 "SCardSetCardTypeProviderNameA { hContext: %p", (
void*)hContext);
1225 WINPR_UNUSED(szCardName);
1226 WINPR_UNUSED(dwProviderId);
1227 WINPR_UNUSED(szProvider);
1230 if (status == SCARD_S_SUCCESS)
1231 status = SCARD_E_UNSUPPORTED_FEATURE;
1233 WLog_Print(smartcard->log, smartcard->log_default_level,
1234 "SCardSetCardTypeProviderNameA } status: %s (0x%08" PRIX32
")",
1235 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
1240LONG WINAPI Emulate_SCardSetCardTypeProviderNameW(SmartcardEmulationContext* smartcard,
1241 SCARDCONTEXT hContext, LPCWSTR szCardName,
1242 DWORD dwProviderId, LPCWSTR szProvider)
1244 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1246 WLog_Print(smartcard->log, smartcard->log_default_level,
1247 "SCardSetCardTypeProviderNameA { hContext: %p", (
void*)hContext);
1249 WINPR_UNUSED(szCardName);
1250 WINPR_UNUSED(dwProviderId);
1251 WINPR_UNUSED(szProvider);
1254 if (status == SCARD_S_SUCCESS)
1255 status = SCARD_E_UNSUPPORTED_FEATURE;
1257 WLog_Print(smartcard->log, smartcard->log_default_level,
1258 "SCardSetCardTypeProviderNameW } status: %s (0x%08" PRIX32
")",
1259 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
1264LONG WINAPI Emulate_SCardForgetCardTypeA(SmartcardEmulationContext* smartcard,
1265 SCARDCONTEXT hContext, LPCSTR szCardName)
1267 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1269 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardForgetCardTypeA { hContext: %p",
1272 WINPR_UNUSED(szCardName);
1275 if (status == SCARD_S_SUCCESS)
1276 status = SCARD_E_UNSUPPORTED_FEATURE;
1278 WLog_Print(smartcard->log, smartcard->log_default_level,
1279 "SCardForgetCardTypeA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1280 WINPR_CXX_COMPAT_CAST(UINT32, status));
1285LONG WINAPI Emulate_SCardForgetCardTypeW(SmartcardEmulationContext* smartcard,
1286 SCARDCONTEXT hContext, LPCWSTR szCardName)
1288 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1290 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardForgetCardTypeW { hContext: %p",
1293 WINPR_UNUSED(szCardName);
1296 if (status == SCARD_S_SUCCESS)
1297 status = SCARD_E_UNSUPPORTED_FEATURE;
1299 WLog_Print(smartcard->log, smartcard->log_default_level,
1300 "SCardForgetCardTypeW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1301 WINPR_CXX_COMPAT_CAST(UINT32, status));
1306LONG WINAPI Emulate_SCardFreeMemory(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1309 HashTable_Lock(smartcard->contexts);
1310 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1312 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardFreeMemory { hContext: %p",
1315 if (status == SCARD_S_SUCCESS)
1317 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
1318 WINPR_ASSERT(value);
1320 ArrayList_Remove(value->strings, pvMem);
1323 WLog_Print(smartcard->log, smartcard->log_default_level,
1324 "SCardFreeMemory } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1325 WINPR_CXX_COMPAT_CAST(UINT32, status));
1326 HashTable_Unlock(smartcard->contexts);
1330HANDLE WINAPI Emulate_SCardAccessStartedEvent(SmartcardEmulationContext* smartcard)
1332 HANDLE hEvent =
nullptr;
1334 WINPR_ASSERT(smartcard);
1336 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardAccessStartedEvent {");
1339 if (winpr_RAND((
void*)&hEvent,
sizeof(hEvent)) < 0)
1341 (void)fprintf(stderr,
"winpr_RAND failed.\n");
1344 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardAccessStartedEvent } hEvent: %p",
1350void WINAPI Emulate_SCardReleaseStartedEvent(SmartcardEmulationContext* smartcard)
1352 WINPR_ASSERT(smartcard);
1354 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardReleaseStartedEvent {");
1358 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardReleaseStartedEvent }");
1361LONG WINAPI Emulate_SCardLocateCardsA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1362 LPCSTR mszCards, LPSCARD_READERSTATEA rgReaderStates,
1365 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1367 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardLocateCardsA { hContext: %p",
1370 WINPR_UNUSED(mszCards);
1371 WINPR_UNUSED(rgReaderStates);
1372 WINPR_UNUSED(cReaders);
1375 if (status == SCARD_S_SUCCESS)
1376 status = SCARD_E_UNSUPPORTED_FEATURE;
1378 WLog_Print(smartcard->log, smartcard->log_default_level,
1379 "SCardLocateCardsA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1380 WINPR_CXX_COMPAT_CAST(UINT32, status));
1385LONG WINAPI Emulate_SCardLocateCardsW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1386 LPCWSTR mszCards, LPSCARD_READERSTATEW rgReaderStates,
1389 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1391 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardLocateCardsW { hContext: %p",
1394 WINPR_UNUSED(mszCards);
1395 WINPR_UNUSED(rgReaderStates);
1396 WINPR_UNUSED(cReaders);
1399 if (status == SCARD_S_SUCCESS)
1400 status = SCARD_E_UNSUPPORTED_FEATURE;
1402 WLog_Print(smartcard->log, smartcard->log_default_level,
1403 "SCardLocateCardsW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1404 WINPR_CXX_COMPAT_CAST(UINT32, status));
1409LONG WINAPI Emulate_SCardLocateCardsByATRA(SmartcardEmulationContext* smartcard,
1410 SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
1411 DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates,
1414 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1416 WLog_Print(smartcard->log, smartcard->log_default_level,
1417 "SCardLocateCardsByATRA { hContext: %p", (
void*)hContext);
1419 WINPR_UNUSED(rgAtrMasks);
1420 WINPR_UNUSED(cAtrs);
1421 WINPR_UNUSED(rgReaderStates);
1422 WINPR_UNUSED(cReaders);
1425 if (status == SCARD_S_SUCCESS)
1426 status = SCARD_E_UNSUPPORTED_FEATURE;
1428 WLog_Print(smartcard->log, smartcard->log_default_level,
1429 "SCardLocateCardsByATRA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1430 WINPR_CXX_COMPAT_CAST(UINT32, status));
1435LONG WINAPI Emulate_SCardLocateCardsByATRW(SmartcardEmulationContext* smartcard,
1436 SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
1437 DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates,
1440 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1442 WLog_Print(smartcard->log, smartcard->log_default_level,
1443 "SCardLocateCardsByATRW { hContext: %p", (
void*)hContext);
1445 WINPR_UNUSED(rgAtrMasks);
1446 WINPR_UNUSED(cAtrs);
1447 WINPR_UNUSED(rgReaderStates);
1448 WINPR_UNUSED(cReaders);
1451 if (status == SCARD_S_SUCCESS)
1452 status = SCARD_E_UNSUPPORTED_FEATURE;
1454 WLog_Print(smartcard->log, smartcard->log_default_level,
1455 "SCardLocateCardsByATRW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1456 WINPR_CXX_COMPAT_CAST(UINT32, status));
1461LONG WINAPI Emulate_SCardGetStatusChangeA(SmartcardEmulationContext* smartcard,
1462 SCARDCONTEXT hContext, DWORD dwTimeout,
1463 LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
1465 HashTable_Lock(smartcard->contexts);
1466 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1468 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetStatusChangeA { hContext: %p",
1471 if (status == SCARD_S_SUCCESS)
1473 const DWORD diff = 100;
1474 size_t eventCount = 0;
1475 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
1476 WINPR_ASSERT(value);
1478 const LONG start = InterlockedIncrement(&value->semaphore);
1483 status = SCARD_E_TIMEOUT;
1486 const LONG rc = Emulate_SCardIsValidContext(smartcard, hContext);
1487 if (rc != SCARD_S_SUCCESS)
1492 value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
1494 for (
size_t x = 0; x < cReaders; x++)
1496 LPSCARD_READERSTATEA out = &rgReaderStates[x];
1498 for (
size_t y = 0; y < MAX_EMULATED_READERS; y++)
1500 const LPSCARD_READERSTATEA in = &value->readerStateA[y];
1501 if (out->szReader && in->szReader && (strcmp(out->szReader, in->szReader) == 0))
1503 HashTable_Lock(smartcard->handles);
1504 const SCardHandle* hdl = find_reader(smartcard, in->szReader, FALSE);
1505 out->dwEventState = in->dwEventState;
1508 out->dwEventState |= SCARD_STATE_INUSE;
1509 if (hdl->dwShareMode == SCARD_SHARE_EXCLUSIVE)
1510 out->dwEventState |= SCARD_STATE_EXCLUSIVE;
1512 HashTable_Unlock(smartcard->handles);
1513 if ((out->dwEventState & SCARD_STATE_EMPTY) !=
1514 (out->dwCurrentState & SCARD_STATE_EMPTY))
1515 out->dwEventState |= SCARD_STATE_CHANGED;
1516 if ((out->dwEventState & SCARD_STATE_PRESENT) !=
1517 (out->dwCurrentState & SCARD_STATE_PRESENT))
1518 out->dwEventState |= SCARD_STATE_CHANGED;
1520 out->cbAtr = in->cbAtr;
1521 memcpy(out->rgbAtr, in->rgbAtr, out->cbAtr);
1522 if (out->dwEventState & SCARD_STATE_CHANGED)
1527 if (value->canceled)
1529 status = SCARD_E_CANCELLED;
1532 if (eventCount != 0)
1534 status = SCARD_S_SUCCESS;
1537 HashTable_Unlock(smartcard->contexts);
1539 HashTable_Lock(smartcard->contexts);
1540 if (dwTimeout != INFINITE)
1541 dwTimeout -= MIN(dwTimeout, diff);
1542 if (freerdp_shall_disconnect_context(inst->context))
1544 status = SCARD_E_CANCELLED;
1547 }
while (dwTimeout > 0);
1548 const LONG end = InterlockedDecrement(&value->semaphore);
1549 WLog_Print(smartcard->log, smartcard->log_default_level,
1550 "[semaphore count] before: %" PRId32
", after: %" PRId32, start, end);
1553 WLog_Print(smartcard->log, smartcard->log_default_level,
1554 "SCardGetStatusChangeA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1555 WINPR_CXX_COMPAT_CAST(UINT32, status));
1556 HashTable_Unlock(smartcard->contexts);
1560LONG WINAPI Emulate_SCardGetStatusChangeW(SmartcardEmulationContext* smartcard,
1561 SCARDCONTEXT hContext, DWORD dwTimeout,
1562 LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
1564 HashTable_Lock(smartcard->contexts);
1565 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1567 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetStatusChangeW { hContext: %p",
1570 if (status == SCARD_S_SUCCESS)
1572 const DWORD diff = 100;
1573 size_t eventCount = 0;
1574 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
1575 WINPR_ASSERT(value);
1577 const LONG start = InterlockedIncrement(&value->semaphore);
1581 status = SCARD_E_TIMEOUT;
1584 const LONG rc = Emulate_SCardIsValidContext(smartcard, hContext);
1585 if (rc != SCARD_S_SUCCESS)
1590 value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
1592 for (
size_t x = 0; x < cReaders; x++)
1594 LPSCARD_READERSTATEW out = &rgReaderStates[x];
1596 for (
size_t y = 0; y < MAX_EMULATED_READERS; y++)
1598 const LPSCARD_READERSTATEW in = &value->readerStateW[y];
1599 if (out->szReader && in->szReader &&
1600 (_wcscmp(out->szReader, in->szReader) == 0))
1602 HashTable_Lock(smartcard->handles);
1603 const SCardHandle* hdl = find_reader(smartcard, in->szReader, TRUE);
1604 out->dwEventState = in->dwEventState;
1607 out->dwEventState |= SCARD_STATE_INUSE;
1608 if (hdl->dwShareMode == SCARD_SHARE_EXCLUSIVE)
1609 out->dwEventState |= SCARD_STATE_EXCLUSIVE;
1611 HashTable_Unlock(smartcard->handles);
1612 if ((out->dwEventState & SCARD_STATE_EMPTY) !=
1613 (out->dwCurrentState & SCARD_STATE_EMPTY))
1614 out->dwEventState |= SCARD_STATE_CHANGED;
1615 if ((out->dwEventState & SCARD_STATE_PRESENT) !=
1616 (out->dwCurrentState & SCARD_STATE_PRESENT))
1617 out->dwEventState |= SCARD_STATE_CHANGED;
1618 out->cbAtr = in->cbAtr;
1619 memcpy(out->rgbAtr, in->rgbAtr, out->cbAtr);
1621 if (out->dwEventState & SCARD_STATE_CHANGED)
1626 if (value->canceled)
1628 status = SCARD_E_CANCELLED;
1631 if (eventCount != 0)
1633 status = SCARD_S_SUCCESS;
1636 HashTable_Unlock(smartcard->contexts);
1638 HashTable_Lock(smartcard->contexts);
1639 if (dwTimeout != INFINITE)
1640 dwTimeout -= MIN(dwTimeout, diff);
1641 if (freerdp_shall_disconnect_context(inst->context))
1643 status = SCARD_E_CANCELLED;
1646 }
while (dwTimeout > 0);
1647 const LONG end = InterlockedDecrement(&value->semaphore);
1648 WLog_Print(smartcard->log, smartcard->log_default_level,
1649 "[semaphore count] before: %" PRId32
", after: %" PRId32, start, end);
1652 WLog_Print(smartcard->log, smartcard->log_default_level,
1653 "SCardGetStatusChangeW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1654 WINPR_CXX_COMPAT_CAST(UINT32, status));
1655 HashTable_Unlock(smartcard->contexts);
1659LONG WINAPI Emulate_SCardCancel(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext)
1661 HashTable_Lock(smartcard->contexts);
1662 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1664 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardCancel { hContext: %p",
1667 if (status == SCARD_S_SUCCESS)
1669 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
1670 WINPR_ASSERT(value);
1671 value->canceled = TRUE;
1673 waitForCancel(value);
1676 WLog_Print(smartcard->log, smartcard->log_default_level,
1677 "SCardCancel } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1678 WINPR_CXX_COMPAT_CAST(UINT32, status));
1679 HashTable_Unlock(smartcard->contexts);
1683SCardHandle* find_reader(SmartcardEmulationContext* smartcard,
const void* szReader, BOOL unicode)
1685 SCardHandle* hdl =
nullptr;
1686 ULONG_PTR* keys =
nullptr;
1688 WINPR_ASSERT(smartcard);
1689 const size_t count = HashTable_GetKeys(smartcard->handles, &keys);
1690 for (
size_t x = 0; x < count; x++)
1692 SCardHandle* cur = HashTable_GetItemValue(smartcard->handles, (
const void*)keys[x]);
1702 if (cur->unicode != unicode)
1704 if (!unicode && (strcmp(cur->szReader.pc, szReader) != 0))
1706 if (unicode && (_wcscmp(cur->szReader.pw, szReader) != 0))
1715WINPR_ATTR_MALLOC(scard_handle_free, 1)
1716static SCardHandle* reader2handle(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1717 const
void* szReader, BOOL unicode, DWORD dwShareMode,
1718 SCARDHANDLE* phCard, DWORD dwPreferredProtocols,
1719 LPDWORD pdwActiveProtocol)
1721 WINPR_ASSERT(phCard);
1722 SCardHandle* hdl =
nullptr;
1725 if (Emulate_SCardIsValidContext(smartcard, hContext) != SCARD_S_SUCCESS)
1728 hdl = scard_handle_new(smartcard, hContext, szReader, unicode);
1732 if (winpr_RAND(&hdl->card,
sizeof(hdl->card)) < 0)
1734 scard_handle_free(hdl);
1738 hdl->dwActiveProtocol = SCARD_PROTOCOL_T1;
1739 hdl->dwShareMode = dwShareMode;
1741 DWORD activeProtocol = 0;
1742 if (pdwActiveProtocol)
1744 if ((hdl->dwActiveProtocol & dwPreferredProtocols) == 0)
1746 scard_handle_free(hdl);
1751 activeProtocol = hdl->dwActiveProtocol;
1754 if (!HashTable_Insert(smartcard->handles, (
const void*)hdl->card, hdl))
1756 scard_handle_free(hdl);
1761 hdl->referencecount++;
1762 *pdwActiveProtocol = activeProtocol;
1763 *phCard = hdl->card;
1766 WLog_Print(smartcard->log, smartcard->log_default_level,
"{ %p }", (
void*)*phCard);
1770LONG WINAPI Emulate_SCardConnectA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1771 LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
1772 LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
1774 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1776 if (!phCard || !pdwActiveProtocol)
1777 status = SCARD_E_INVALID_PARAMETER;
1779 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardConnectA { hContext: %p",
1782 if (status == SCARD_S_SUCCESS)
1784 if (!reader2handle(smartcard, hContext, szReader, FALSE, dwShareMode, phCard,
1785 dwPreferredProtocols, pdwActiveProtocol))
1786 status = SCARD_E_NO_MEMORY;
1789 WLog_Print(smartcard->log, smartcard->log_default_level,
1790 "SCardConnectA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1791 WINPR_CXX_COMPAT_CAST(UINT32, status));
1796LONG WINAPI Emulate_SCardConnectW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1797 LPCWSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
1798 LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
1800 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1802 if (!phCard || !pdwActiveProtocol)
1803 status = SCARD_E_INVALID_PARAMETER;
1805 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardConnectW { hContext: %p",
1808 if (status == SCARD_S_SUCCESS)
1810 if (!reader2handle(smartcard, hContext, szReader, TRUE, dwShareMode, phCard,
1811 dwPreferredProtocols, pdwActiveProtocol))
1812 status = SCARD_E_NO_MEMORY;
1815 WLog_Print(smartcard->log, smartcard->log_default_level,
1816 "SCardConnectW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1817 WINPR_CXX_COMPAT_CAST(UINT32, status));
1822LONG WINAPI Emulate_SCardReconnect(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1823 DWORD dwShareMode, WINPR_ATTR_UNUSED DWORD dwPreferredProtocols,
1824 WINPR_ATTR_UNUSED DWORD dwInitialization,
1825 LPDWORD pdwActiveProtocol)
1827 LONG status = scard_handle_valid(smartcard, hCard);
1829 if (!pdwActiveProtocol)
1830 status = SCARD_E_INVALID_PARAMETER;
1832 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardReconnect { hCard: %p",
1835 if (status == SCARD_S_SUCCESS)
1837 HashTable_Lock(smartcard->handles);
1838 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
1842 hdl->dwShareMode = dwShareMode;
1843 hdl->transaction = FALSE;
1845 *pdwActiveProtocol = hdl->dwActiveProtocol;
1846 HashTable_Unlock(smartcard->handles);
1849 WLog_Print(smartcard->log, smartcard->log_default_level,
1850 "SCardReconnect } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1851 WINPR_CXX_COMPAT_CAST(UINT32, status));
1856LONG WINAPI Emulate_SCardDisconnect(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1857 DWORD dwDisposition)
1859 LONG status = scard_handle_valid(smartcard, hCard);
1861 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardDisconnect { hCard: %p",
1864 WINPR_UNUSED(dwDisposition);
1866 if (status == SCARD_S_SUCCESS)
1868 HashTable_Lock(smartcard->handles);
1869 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
1872 hdl->referencecount--;
1873 if (hdl->referencecount == 0)
1874 HashTable_Remove(smartcard->handles, (
const void*)hCard);
1875 HashTable_Unlock(smartcard->handles);
1878 WLog_Print(smartcard->log, smartcard->log_default_level,
1879 "SCardDisconnect } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1880 WINPR_CXX_COMPAT_CAST(UINT32, status));
1885LONG WINAPI Emulate_SCardBeginTransaction(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard)
1887 LONG status = scard_handle_valid(smartcard, hCard);
1889 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardBeginTransaction { hCard: %p",
1892 if (status == SCARD_S_SUCCESS)
1894 HashTable_Lock(smartcard->handles);
1895 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
1897 if (hdl->transaction)
1898 status = SCARD_E_INVALID_VALUE;
1900 hdl->transaction = TRUE;
1901 HashTable_Unlock(smartcard->handles);
1904 WLog_Print(smartcard->log, smartcard->log_default_level,
1905 "SCardBeginTransaction } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1906 WINPR_CXX_COMPAT_CAST(UINT32, status));
1911LONG WINAPI Emulate_SCardEndTransaction(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1912 DWORD dwDisposition)
1914 LONG status = scard_handle_valid(smartcard, hCard);
1916 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardEndTransaction { hCard: %p",
1919 WINPR_UNUSED(dwDisposition);
1921 if (status == SCARD_S_SUCCESS)
1923 HashTable_Lock(smartcard->handles);
1924 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
1926 if (!hdl->transaction)
1927 status = SCARD_E_NOT_TRANSACTED;
1929 hdl->transaction = FALSE;
1930 HashTable_Unlock(smartcard->handles);
1933 WLog_Print(smartcard->log, smartcard->log_default_level,
1934 "SCardEndTransaction } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1935 WINPR_CXX_COMPAT_CAST(UINT32, status));
1940LONG WINAPI Emulate_SCardCancelTransaction(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard)
1942 LONG status = scard_handle_valid(smartcard, hCard);
1944 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardCancelTransaction { hCard: %p",
1947 if (status == SCARD_S_SUCCESS)
1949 HashTable_Lock(smartcard->handles);
1950 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
1952 if (!hdl->transaction)
1953 status = SCARD_E_NOT_TRANSACTED;
1955 hdl->transaction = FALSE;
1956 HashTable_Unlock(smartcard->handles);
1959 WLog_Print(smartcard->log, smartcard->log_default_level,
1960 "SCardCancelTransaction } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
1961 WINPR_CXX_COMPAT_CAST(UINT32, status));
1966LONG WINAPI Emulate_SCardState(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1967 LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr,
1970 HashTable_Lock(smartcard->handles);
1971 LONG status = scard_handle_valid(smartcard, hCard);
1973 if (!pdwState || !pdwProtocol)
1974 status = SCARD_E_INVALID_PARAMETER;
1976 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardState { hCard: %p",
1979 if (status == SCARD_S_SUCCESS)
1981 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
1985 *pdwState = SCARD_SPECIFIC;
1987 *pdwProtocol = SCARD_PROTOCOL_T1;
1992 HashTable_GetItemValue(smartcard->contexts, (
const void*)hdl->hContext);
1995 for (
size_t x = 0; x < MAX_EMULATED_READERS; x++)
2001 if (_wcscmp(readerW->szReader, hdl->szReader.pw) == 0)
2003 *pcbAtrLen = scard_copy_strings(ctx, pbAtr, *pcbAtrLen, readerW->rgbAtr,
2009 if (strcmp(readerA->szReader, hdl->szReader.pc) == 0)
2011 *pcbAtrLen = scard_copy_strings(ctx, pbAtr, *pcbAtrLen, readerA->rgbAtr,
2019 WLog_Print(smartcard->log, smartcard->log_default_level,
2020 "SCardState } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2021 WINPR_CXX_COMPAT_CAST(UINT32, status));
2022 HashTable_Unlock(smartcard->handles);
2027LONG WINAPI Emulate_SCardStatusA(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2028 LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
2029 LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
2031 HashTable_Lock(smartcard->handles);
2032 LONG status = scard_handle_valid(smartcard, hCard);
2034 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardStatusA { hCard: %p",
2037 if (status == SCARD_S_SUCCESS)
2039 SCardContext* ctx =
nullptr;
2040 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
2043 ctx = HashTable_GetItemValue(smartcard->contexts, (
const void*)hdl->hContext);
2048 scard_copy_strings(ctx, mszReaderNames, *pcchReaderLen, hdl->szReader.pc,
2049 (UINT32)strlen(hdl->szReader.pc) + 2);
2052 *pdwState = SCARD_SPECIFIC;
2054 *pdwProtocol = SCARD_PROTOCOL_T1;
2058 for (
size_t x = 0; x < MAX_EMULATED_READERS; x++)
2061 if (strcmp(reader->szReader, hdl->szReader.pc) == 0)
2064 scard_copy_strings(ctx, pbAtr, *pcbAtrLen, reader->rgbAtr, reader->cbAtr);
2070 WLog_Print(smartcard->log, smartcard->log_default_level,
2071 "SCardStatusA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2072 WINPR_CXX_COMPAT_CAST(UINT32, status));
2073 HashTable_Unlock(smartcard->handles);
2078LONG WINAPI Emulate_SCardStatusW(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2079 LPWSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
2080 LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
2082 HashTable_Lock(smartcard->handles);
2083 LONG status = scard_handle_valid(smartcard, hCard);
2085 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardStatusW { hCard: %p",
2088 if (status == SCARD_S_SUCCESS)
2090 SCardContext* ctx =
nullptr;
2091 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
2094 ctx = HashTable_GetItemValue(smartcard->contexts, (
const void*)hdl->hContext);
2099 scard_copy_strings(ctx, mszReaderNames, *pcchReaderLen, hdl->szReader.pw,
2100 (UINT32)(_wcslen(hdl->szReader.pw) + 2) *
sizeof(WCHAR)) /
2104 *pdwState = SCARD_SPECIFIC;
2106 *pdwProtocol = SCARD_PROTOCOL_T1;
2110 for (
size_t x = 0; x < MAX_EMULATED_READERS; x++)
2113 if (_wcscmp(reader->szReader, hdl->szReader.pw) == 0)
2115 scard_copy_strings(ctx, pbAtr, *pcbAtrLen, reader->rgbAtr, reader->cbAtr);
2120 WLog_Print(smartcard->log, smartcard->log_default_level,
2121 "SCardStatusW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2122 WINPR_CXX_COMPAT_CAST(UINT32, status));
2123 HashTable_Unlock(smartcard->handles);
2127LONG WINAPI Emulate_SCardTransmit(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2128 LPCSCARD_IO_REQUEST pioSendPci, LPCBYTE pbSendBuffer,
2129 DWORD cbSendLength, LPSCARD_IO_REQUEST pioRecvPci,
2130 LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength)
2132 HashTable_Lock(smartcard->contexts);
2133 LONG status = scard_handle_valid(smartcard, hCard);
2135 if (!pioSendPci || !pbSendBuffer || !pbRecvBuffer || !pcbRecvLength)
2136 status = SCARD_E_INVALID_PARAMETER;
2138 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardTransmit { hCard: %p",
2141 if (status == SCARD_S_SUCCESS)
2143 BYTE* response =
nullptr;
2144 DWORD responseSize = 0;
2146 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
2149 hdl->transmitcount++;
2151 if (!vgids_process_apdu(hdl->vgids, pbSendBuffer, cbSendLength, &response, &responseSize))
2152 status = SCARD_E_NO_SMARTCARD;
2156 HashTable_GetItemValue(smartcard->contexts, (
const void*)hdl->hContext);
2160 scard_copy_strings(ctx, pbRecvBuffer, *pcbRecvLength, response, responseSize);
2165 pioRecvPci->dwProtocol = hdl->dwActiveProtocol;
2169 WLog_Print(smartcard->log, smartcard->log_default_level,
2170 "SCardTransmit } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2171 WINPR_CXX_COMPAT_CAST(UINT32, status));
2172 HashTable_Unlock(smartcard->contexts);
2176LONG WINAPI Emulate_SCardGetTransmitCount(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2177 LPDWORD pcTransmitCount)
2179 LONG status = scard_handle_valid(smartcard, hCard);
2181 if (!pcTransmitCount)
2182 status = SCARD_E_INVALID_PARAMETER;
2184 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetTransmitCount { hCard: %p",
2187 if (status == SCARD_S_SUCCESS)
2189 HashTable_Lock(smartcard->handles);
2190 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (
const void*)hCard);
2193 *pcTransmitCount = hdl->transmitcount;
2194 HashTable_Unlock(smartcard->handles);
2197 WLog_Print(smartcard->log, smartcard->log_default_level,
2198 "SCardGetTransmitCount } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2199 WINPR_CXX_COMPAT_CAST(UINT32, status));
2204LONG WINAPI Emulate_SCardControl(
2205 SmartcardEmulationContext* smartcard, SCARDHANDLE hCard, DWORD dwControlCode,
2206 LPCVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize,
2207 LPDWORD lpBytesReturned )
2209 LONG status = scard_handle_valid(smartcard, hCard);
2211 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardControl { hCard: %p",
2214 if (status == SCARD_S_SUCCESS)
2216 WINPR_UNUSED(dwControlCode);
2217 WINPR_UNUSED(lpInBuffer);
2218 WINPR_UNUSED(cbInBufferSize);
2219 WINPR_UNUSED(lpOutBuffer);
2220 WINPR_UNUSED(cbOutBufferSize);
2221 WINPR_UNUSED(lpBytesReturned);
2224 status = SCARD_E_UNSUPPORTED_FEATURE;
2227 WLog_Print(smartcard->log, smartcard->log_default_level,
2228 "SCardControl } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2229 WINPR_CXX_COMPAT_CAST(UINT32, status));
2234LONG WINAPI Emulate_SCardGetAttrib(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2237 LPDWORD pcbAttrLen )
2239 LONG status = scard_handle_valid(smartcard, hCard);
2241 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetAttrib { hCard: %p",
2244 WINPR_UNUSED(dwAttrId);
2245 WINPR_UNUSED(pbAttr);
2246 WINPR_UNUSED(pcbAttrLen);
2249 if (status == SCARD_S_SUCCESS)
2250 status = SCARD_F_INTERNAL_ERROR;
2252 WLog_Print(smartcard->log, smartcard->log_default_level,
2253 "SCardGetAttrib } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2254 WINPR_CXX_COMPAT_CAST(UINT32, status));
2259LONG WINAPI Emulate_SCardSetAttrib(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2260 DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen)
2262 LONG status = scard_handle_valid(smartcard, hCard);
2264 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardSetAttrib { hCard: %p",
2267 WINPR_UNUSED(dwAttrId);
2268 WINPR_UNUSED(pbAttr);
2269 WINPR_UNUSED(cbAttrLen);
2272 if (status == SCARD_S_SUCCESS)
2273 status = SCARD_F_INTERNAL_ERROR;
2275 WLog_Print(smartcard->log, smartcard->log_default_level,
2276 "SCardSetAttrib } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2277 WINPR_CXX_COMPAT_CAST(UINT32, status));
2282LONG WINAPI Emulate_SCardUIDlgSelectCardA(SmartcardEmulationContext* smartcard,
2283 LPOPENCARDNAMEA_EX pDlgStruc)
2287 WINPR_ASSERT(smartcard);
2289 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardUIDlgSelectCardA {");
2291 WINPR_UNUSED(pDlgStruc);
2294 status = SCARD_E_UNSUPPORTED_FEATURE;
2296 WLog_Print(smartcard->log, smartcard->log_default_level,
2297 "SCardUIDlgSelectCardA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2298 WINPR_CXX_COMPAT_CAST(UINT32, status));
2303LONG WINAPI Emulate_SCardUIDlgSelectCardW(SmartcardEmulationContext* smartcard,
2304 LPOPENCARDNAMEW_EX pDlgStruc)
2308 WINPR_ASSERT(smartcard);
2310 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardUIDlgSelectCardW {");
2312 WINPR_UNUSED(pDlgStruc);
2315 status = SCARD_E_UNSUPPORTED_FEATURE;
2317 WLog_Print(smartcard->log, smartcard->log_default_level,
2318 "SCardUIDlgSelectCardW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2319 WINPR_CXX_COMPAT_CAST(UINT32, status));
2324LONG WINAPI Emulate_GetOpenCardNameA(SmartcardEmulationContext* smartcard,
2325 LPOPENCARDNAMEA pDlgStruc)
2329 WINPR_ASSERT(smartcard);
2331 WLog_Print(smartcard->log, smartcard->log_default_level,
"GetOpenCardNameA {");
2333 WINPR_UNUSED(pDlgStruc);
2336 status = SCARD_E_UNSUPPORTED_FEATURE;
2338 WLog_Print(smartcard->log, smartcard->log_default_level,
2339 "GetOpenCardNameA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2340 WINPR_CXX_COMPAT_CAST(UINT32, status));
2345LONG WINAPI Emulate_GetOpenCardNameW(SmartcardEmulationContext* smartcard,
2346 LPOPENCARDNAMEW pDlgStruc)
2350 WINPR_ASSERT(smartcard);
2352 WLog_Print(smartcard->log, smartcard->log_default_level,
"GetOpenCardNameW {");
2354 WINPR_UNUSED(pDlgStruc);
2357 status = SCARD_E_UNSUPPORTED_FEATURE;
2359 WLog_Print(smartcard->log, smartcard->log_default_level,
2360 "GetOpenCardNameW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2361 WINPR_CXX_COMPAT_CAST(UINT32, status));
2366LONG WINAPI Emulate_SCardDlgExtendedError(SmartcardEmulationContext* smartcard)
2370 WINPR_ASSERT(smartcard);
2372 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardDlgExtendedError {");
2375 status = SCARD_E_UNSUPPORTED_FEATURE;
2377 WLog_Print(smartcard->log, smartcard->log_default_level,
2378 "SCardDlgExtendedError } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2379 WINPR_CXX_COMPAT_CAST(UINT32, status));
2384LONG WINAPI Emulate_SCardReadCacheA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2385 UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName,
2386 PBYTE Data, DWORD* DataLen)
2388 HashTable_Lock(smartcard->contexts);
2390 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2392 if (!CardIdentifier || !DataLen)
2393 status = SCARD_E_INVALID_PARAMETER;
2395 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardReadCacheA { hContext: %p",
2404 if (status == SCARD_S_SUCCESS)
2406 SCardCacheItem* data =
nullptr;
2407 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
2408 WINPR_ASSERT(value);
2410 char*
id = card_id_and_name_a(CardIdentifier, LookupName);
2412 data = HashTable_GetItemValue(value->cache,
id);
2416 status = SCARD_W_CACHE_ITEM_NOT_FOUND;
2417 else if (data->freshness != FreshnessCounter)
2418 status = SCARD_W_CACHE_ITEM_STALE;
2420 *DataLen = scard_copy_strings(value, Data, count, data->data, data->size);
2423 WLog_Print(smartcard->log, smartcard->log_default_level,
2424 "SCardReadCacheA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2425 WINPR_CXX_COMPAT_CAST(UINT32, status));
2426 HashTable_Unlock(smartcard->contexts);
2430LONG WINAPI Emulate_SCardReadCacheW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2431 UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName,
2432 PBYTE Data, DWORD* DataLen)
2434 HashTable_Lock(smartcard->contexts);
2436 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2438 if (!CardIdentifier || !DataLen)
2439 status = SCARD_E_INVALID_PARAMETER;
2441 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardReadCacheW { hContext: %p",
2450 if (status == SCARD_S_SUCCESS)
2452 SCardCacheItem* data =
nullptr;
2453 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
2454 WINPR_ASSERT(value);
2456 char*
id = card_id_and_name_w(CardIdentifier, LookupName);
2457 data = HashTable_GetItemValue(value->cache,
id);
2460 status = SCARD_W_CACHE_ITEM_NOT_FOUND;
2461 else if (data->freshness != FreshnessCounter)
2462 status = SCARD_W_CACHE_ITEM_STALE;
2464 *DataLen = scard_copy_strings(value, Data, count, data->data, data->size);
2467 WLog_Print(smartcard->log, smartcard->log_default_level,
2468 "SCardReadCacheW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2469 WINPR_CXX_COMPAT_CAST(UINT32, status));
2470 HashTable_Unlock(smartcard->contexts);
2475static LONG insert_data(wHashTable* table, DWORD FreshnessCounter,
const char* key,
2476 const PBYTE Data, DWORD DataLen)
2479 SCardCacheItem* item =
nullptr;
2481 WINPR_ASSERT(table);
2484 if (DataLen > MAX_CACHE_ITEM_SIZE)
2485 return SCARD_W_CACHE_ITEM_TOO_BIG;
2487 if (HashTable_Count(table) > MAX_CACHE_ITEM_VALUES)
2488 return SCARD_E_WRITE_TOO_MANY;
2490 item = HashTable_GetItemValue(table, key);
2493 item = calloc(1,
sizeof(SCardCacheItem));
2495 return SCARD_E_NO_MEMORY;
2497 rc = HashTable_Insert(table, key, item);
2501 return SCARD_E_NO_MEMORY;
2505 if (item->freshness > FreshnessCounter)
2506 return SCARD_W_CACHE_ITEM_STALE;
2507 item->freshness = FreshnessCounter;
2508 item->size = DataLen;
2509 memcpy(item->data, Data, DataLen);
2512 return SCARD_S_SUCCESS;
2515LONG WINAPI Emulate_SCardWriteCacheA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2516 UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName,
2517 PBYTE Data, DWORD DataLen)
2519 HashTable_Lock(smartcard->contexts);
2520 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2522 if (!CardIdentifier)
2523 status = SCARD_E_INVALID_PARAMETER;
2525 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardWriteCacheA { hContext: %p",
2528 if (status == SCARD_S_SUCCESS)
2530 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
2531 WINPR_ASSERT(value);
2533 char*
id = card_id_and_name_a(CardIdentifier, LookupName);
2535 status = SCARD_E_NO_MEMORY;
2538 status = insert_data(value->cache, FreshnessCounter,
id, Data, DataLen);
2543 WLog_Print(smartcard->log, smartcard->log_default_level,
2544 "SCardWriteCacheA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2545 WINPR_CXX_COMPAT_CAST(UINT32, status));
2546 HashTable_Unlock(smartcard->contexts);
2550LONG WINAPI Emulate_SCardWriteCacheW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2551 UUID* CardIdentifier, DWORD FreshnessCounter,
2552 LPWSTR LookupName, PBYTE Data, DWORD DataLen)
2554 HashTable_Lock(smartcard->contexts);
2555 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2557 if (!CardIdentifier)
2558 status = SCARD_E_INVALID_PARAMETER;
2560 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardWriteCacheW { hContext: %p",
2563 if (status == SCARD_S_SUCCESS)
2565 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
2566 WINPR_ASSERT(value);
2568 char*
id = card_id_and_name_w(CardIdentifier, LookupName);
2570 status = SCARD_E_NO_MEMORY;
2573 status = insert_data(value->cache, FreshnessCounter,
id, Data, DataLen);
2578 WLog_Print(smartcard->log, smartcard->log_default_level,
2579 "SCardWriteCacheW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2580 WINPR_CXX_COMPAT_CAST(UINT32, status));
2581 HashTable_Unlock(smartcard->contexts);
2585LONG WINAPI Emulate_SCardGetReaderIconA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2586 LPCSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon)
2588 HashTable_Lock(smartcard->contexts);
2589 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2591 if (!szReaderName || !pcbIcon)
2592 status = SCARD_E_INVALID_PARAMETER;
2594 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetReaderIconA { hContext: %p",
2597 if (status == SCARD_S_SUCCESS)
2598 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
2600 if (status == SCARD_S_SUCCESS)
2602 SCardContext* ctx = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
2606 *pcbIcon = scard_copy_strings(ctx, pbIcon, *pcbIcon, resources_FreeRDP_ico,
2607 resources_FreeRDP_ico_len);
2609 *pcbIcon = resources_FreeRDP_ico_len;
2612 WLog_Print(smartcard->log, smartcard->log_default_level,
2613 "SCardGetReaderIconA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2614 WINPR_CXX_COMPAT_CAST(UINT32, status));
2615 HashTable_Unlock(smartcard->contexts);
2619LONG WINAPI Emulate_SCardGetReaderIconW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2620 LPCWSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon)
2622 HashTable_Lock(smartcard->contexts);
2623 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2625 if (!szReaderName || !pcbIcon)
2626 status = SCARD_E_INVALID_PARAMETER;
2628 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetReaderIconW { hContext: %p",
2631 if (status == SCARD_S_SUCCESS)
2632 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
2634 if (status == SCARD_S_SUCCESS)
2636 SCardContext* ctx = HashTable_GetItemValue(smartcard->contexts, (
const void*)hContext);
2640 *pcbIcon = scard_copy_strings(ctx, pbIcon, *pcbIcon, resources_FreeRDP_ico,
2641 resources_FreeRDP_ico_len);
2643 *pcbIcon = resources_FreeRDP_ico_len;
2646 WLog_Print(smartcard->log, smartcard->log_default_level,
2647 "SCardGetReaderIconW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2648 WINPR_CXX_COMPAT_CAST(UINT32, status));
2649 HashTable_Unlock(smartcard->contexts);
2653LONG WINAPI Emulate_SCardGetDeviceTypeIdA(SmartcardEmulationContext* smartcard,
2654 SCARDCONTEXT hContext, LPCSTR szReaderName,
2655 LPDWORD pdwDeviceTypeId)
2657 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2659 if (!pdwDeviceTypeId)
2660 status = SCARD_E_INVALID_PARAMETER;
2662 if (status == SCARD_S_SUCCESS)
2663 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
2665 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetDeviceTypeIdA { hContext: %p",
2668 if (status == SCARD_S_SUCCESS)
2670 *pdwDeviceTypeId = SCARD_READER_TYPE_USB;
2673 WLog_Print(smartcard->log, smartcard->log_default_level,
2674 "SCardGetDeviceTypeIdA } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2675 WINPR_CXX_COMPAT_CAST(UINT32, status));
2680LONG WINAPI Emulate_SCardGetDeviceTypeIdW(SmartcardEmulationContext* smartcard,
2681 SCARDCONTEXT hContext, LPCWSTR szReaderName,
2682 LPDWORD pdwDeviceTypeId)
2684 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2686 if (!pdwDeviceTypeId)
2687 status = SCARD_E_INVALID_PARAMETER;
2689 if (status == SCARD_S_SUCCESS)
2690 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
2692 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardGetDeviceTypeIdW { hContext: %p",
2695 if (status == SCARD_S_SUCCESS)
2697 *pdwDeviceTypeId = SCARD_READER_TYPE_USB;
2700 WLog_Print(smartcard->log, smartcard->log_default_level,
2701 "SCardGetDeviceTypeIdW } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2702 WINPR_CXX_COMPAT_CAST(UINT32, status));
2707LONG WINAPI Emulate_SCardGetReaderDeviceInstanceIdA(
2708 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szReaderName,
2709 LPSTR szDeviceInstanceId ,
2710 LPDWORD pcchDeviceInstanceId )
2712 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2714 if (status == SCARD_S_SUCCESS)
2715 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
2717 WLog_Print(smartcard->log, smartcard->log_default_level,
2718 "SCardGetReaderDeviceInstanceIdA { hContext: %p", (
void*)hContext);
2720 WINPR_UNUSED(szDeviceInstanceId);
2721 WINPR_UNUSED(pcchDeviceInstanceId);
2724 if (status == SCARD_S_SUCCESS)
2725 status = SCARD_E_UNSUPPORTED_FEATURE;
2727 WLog_Print(smartcard->log, smartcard->log_default_level,
2728 "SCardGetReaderDeviceInstanceIdA } status: %s (0x%08" PRIX32
")",
2729 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
2734LONG WINAPI Emulate_SCardGetReaderDeviceInstanceIdW(
2735 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szReaderName,
2736 LPWSTR szDeviceInstanceId ,
2737 LPDWORD pcchDeviceInstanceId )
2739 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2741 if (status == SCARD_S_SUCCESS)
2742 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
2744 WLog_Print(smartcard->log, smartcard->log_default_level,
2745 "SCardGetReaderDeviceInstanceIdW { hContext: %p", (
void*)hContext);
2747 WINPR_UNUSED(szDeviceInstanceId);
2748 WINPR_UNUSED(pcchDeviceInstanceId);
2751 if (status == SCARD_S_SUCCESS)
2752 status = SCARD_E_UNSUPPORTED_FEATURE;
2754 WLog_Print(smartcard->log, smartcard->log_default_level,
2755 "SCardGetReaderDeviceInstanceIdW } status: %s (0x%08" PRIX32
")",
2756 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
2761LONG WINAPI Emulate_SCardListReadersWithDeviceInstanceIdA(
2762 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szDeviceInstanceId,
2764 LPDWORD pcchReaders )
2766 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2768 WLog_Print(smartcard->log, smartcard->log_default_level,
2769 "SCardListReadersWithDeviceInstanceIdA { hContext: %p", (
void*)hContext);
2771 WINPR_UNUSED(szDeviceInstanceId);
2772 WINPR_UNUSED(mszReaders);
2773 WINPR_UNUSED(pcchReaders);
2776 if (status == SCARD_S_SUCCESS)
2777 status = SCARD_E_UNSUPPORTED_FEATURE;
2779 WLog_Print(smartcard->log, smartcard->log_default_level,
2780 "SCardListReadersWithDeviceInstanceIdA } status: %s (0x%08" PRIX32
")",
2781 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
2786LONG WINAPI Emulate_SCardListReadersWithDeviceInstanceIdW(
2787 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szDeviceInstanceId,
2788 LPWSTR mszReaders , LPDWORD pcchReaders)
2790 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2792 WLog_Print(smartcard->log, smartcard->log_default_level,
2793 "SCardListReadersWithDeviceInstanceIdW { hContext: %p", (
void*)hContext);
2795 WINPR_UNUSED(szDeviceInstanceId);
2796 WINPR_UNUSED(mszReaders);
2797 WINPR_UNUSED(pcchReaders);
2800 if (status == SCARD_S_SUCCESS)
2801 status = SCARD_E_UNSUPPORTED_FEATURE;
2803 WLog_Print(smartcard->log, smartcard->log_default_level,
2804 "SCardListReadersWithDeviceInstanceIdW } status: %s (0x%08" PRIX32
")",
2805 SCardGetErrorString(status), WINPR_CXX_COMPAT_CAST(UINT32, status));
2810LONG WINAPI Emulate_SCardAudit(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2813 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2815 WINPR_UNUSED(dwEvent);
2817 WLog_Print(smartcard->log, smartcard->log_default_level,
"SCardAudit { hContext: %p",
2821 if (status == SCARD_S_SUCCESS)
2822 status = SCARD_E_UNSUPPORTED_FEATURE;
2824 WLog_Print(smartcard->log, smartcard->log_default_level,
2825 "SCardAudit } status: %s (0x%08" PRIX32
")", SCardGetErrorString(status),
2826 WINPR_CXX_COMPAT_CAST(UINT32, status));
2832static BOOL context_equals(
const void* pva,
const void* pvb)
2834 const SCARDCONTEXT a = (
const SCARDCONTEXT)pva;
2835 const SCARDCONTEXT b = (
const SCARDCONTEXT)pvb;
2845static BOOL handle_equals(
const void* pva,
const void* pvb)
2847 const SCARDHANDLE a = (
const SCARDHANDLE)pva;
2848 const SCARDHANDLE b = (
const SCARDHANDLE)pvb;
2857static void entry_free(
void* ptr)
2859 SmartcardPinCounterEntry* entry = ptr;
2863 winpr_zfree(entry->pin);
2867WINPR_ATTR_MALLOC(entry_free, 1)
2868static
void* entry_clone(const
void* other)
2870 const SmartcardPinCounterEntry* entry = other;
2874 SmartcardPinCounterEntry* clone = calloc(1,
sizeof(SmartcardPinCounterEntry));
2880 clone->pin = _strdup(entry->pin);
2890SmartcardEmulationContext* Emulate_New(
const rdpSettings* settings)
2892 SmartcardEmulationContext* smartcard =
nullptr;
2894 WINPR_ASSERT(settings);
2896 smartcard = calloc(1,
sizeof(SmartcardEmulationContext));
2900 smartcard->settings = settings;
2901 smartcard->log = WLog_Get(
"EmulateSCard");
2902 if (!smartcard->log)
2904 smartcard->log_default_level = WLOG_TRACE;
2906 smartcard->contexts = HashTable_New(FALSE);
2907 if (!smartcard->contexts)
2911 wObject* obj = HashTable_KeyObject(smartcard->contexts);
2913 obj->fnObjectEquals = context_equals;
2915 if (!smartcard->contexts)
2919 wObject* obj = HashTable_ValueObject(smartcard->contexts);
2921 obj->fnObjectFree = scard_context_free;
2924 smartcard->handles = HashTable_New(TRUE);
2925 if (!smartcard->handles)
2929 wObject* obj = HashTable_KeyObject(smartcard->handles);
2931 obj->fnObjectEquals = handle_equals;
2933 if (!smartcard->handles)
2937 wObject* obj = HashTable_ValueObject(smartcard->handles);
2939 obj->fnObjectFree = scard_handle_free;
2942 smartcard->pinCounters = HashTable_New(TRUE);
2943 if (!smartcard->pinCounters)
2945 else if (!HashTable_SetupForStringData(smartcard->pinCounters, FALSE))
2949 wObject* obj = HashTable_ValueObject(smartcard->pinCounters);
2951 obj->fnObjectEquals =
nullptr;
2952 obj->fnObjectFree = entry_free;
2953 obj->fnObjectNew = entry_clone;
2958 WINPR_PRAGMA_DIAG_PUSH
2959 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2960 Emulate_Free(smartcard);
2961 WINPR_PRAGMA_DIAG_POP
2965void Emulate_Free(SmartcardEmulationContext* context)
2970 HashTable_Free(context->handles);
2971 HashTable_Free(context->contexts);
2972 HashTable_Free(context->pinCounters);
2976BOOL Emulate_IsConfigured(SmartcardEmulationContext* context)
2979 vgidsContext* vgids =
nullptr;
2980 const char* pem =
nullptr;
2981 const char* key =
nullptr;
2982 const char* pin =
nullptr;
2984 WINPR_ASSERT(context);
2991 if ((context->pem == pem) && (context->key == key) && (context->pin == pin))
2992 return context->configured;
2998 vgids = vgids_new(context);
3000 rc = vgids_init(vgids, context->pem, context->key, context->pin);
3003 context->configured = rc;
3007BOOL Emulate_SetupPin(SmartcardEmulationContext* context,
const char* name,
const char* pin)
3009 WINPR_ASSERT(context);
3011 const SmartcardPinCounterEntry entry = { .curRetryCounter = VGIDS_DEFAULT_RETRY_COUNTER,
3012 .retryCounter = VGIDS_DEFAULT_RETRY_COUNTER,
3013 .pin = WINPR_CAST_CONST_PTR_AWAY(pin,
char*) };
3016 HashTable_Lock(context->pinCounters);
3017 const SmartcardPinCounterEntry* val = HashTable_GetItemValue(context->pinCounters, name);
3019 rc = HashTable_Insert(context->pinCounters, name, &entry);
3022 if (val->pin && pin)
3023 rc = strcmp(val->pin, pin) == 0;
3025 HashTable_Unlock(context->pinCounters);
3029BOOL Emulate_IsPinValid(SmartcardEmulationContext* context,
const char* name,
const char* pin,
3030 size_t bytelen, UINT16* remaining)
3032 WINPR_ASSERT(context);
3033 WINPR_ASSERT(remaining);
3038 HashTable_Lock(context->pinCounters);
3039 SmartcardPinCounterEntry* val = HashTable_GetItemValue(context->pinCounters, name);
3042 if (val->pin && pin)
3044 const size_t min = strlen(val->pin);
3046 rc = strncmp(val->pin, pin, min + 1) == 0;
3050 if (val->curRetryCounter > 0)
3051 val->curRetryCounter--;
3053 val->curRetryCounter = val->retryCounter;
3055 *remaining = val->curRetryCounter;
3058 HashTable_Unlock(context->pinCounters);
3062BOOL Emulate_IsPinBlocked(SmartcardEmulationContext* context,
const char* name)
3064 WINPR_ASSERT(context);
3067 HashTable_Lock(context->pinCounters);
3068 const SmartcardPinCounterEntry* val = HashTable_GetItemValue(context->pinCounters, name);
3070 rc = val->curRetryCounter == 0;
3071 HashTable_Unlock(context->pinCounters);
WINPR_ATTR_NODISCARD FREERDP_API const void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer settings value.
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
This struct contains function pointer to initialize/free objects.
OBJECT_FREE_FN fnObjectFree