FreeRDP
Loading...
Searching...
No Matches
smartcard_emulate.c
1
20
21#include <freerdp/config.h>
22#include <freerdp/freerdp.h>
23
24#include <winpr/crt.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>
33
34#include <freerdp/emulate/scard/smartcard_emulate.h>
35#include "FreeRDP.ico.h"
36
37#include "smartcard_virtual_gids.h"
38
39#define MAX_CACHE_ITEM_SIZE 4096
40#define MAX_CACHE_ITEM_VALUES 4096
41
42#define VGIDS_DEFAULT_RETRY_COUNTER 3
43
44typedef struct
45{
46 SCARDCONTEXT context;
47 wHashTable* table;
48} HandleCleanLoopArg;
49
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;
55
56WINPR_ATTR_MALLOC(free, 1)
57static char* card_id_and_name_a(const UUID* CardIdentifier, LPCSTR LookupName)
58{
59 if (!CardIdentifier || !LookupName)
60 return nullptr;
61
62 size_t len = strlen(LookupName) + 34;
63 char* id = malloc(len);
64 if (!id)
65 return nullptr;
66
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);
72 return id;
73}
74
75WINPR_ATTR_MALLOC(free, 1)
76static char* card_id_and_name_w(const UUID* CardIdentifier, LPCWSTR LookupName)
77{
78 char* res = nullptr;
79 char* tmp = ConvertWCharToUtf8Alloc(LookupName, nullptr);
80 if (!tmp)
81 return nullptr;
82 res = card_id_and_name_a(CardIdentifier, tmp);
83 free(tmp);
84 return res;
85}
86
87WINPR_ATTR_NODISCARD
88static BOOL CALLBACK g_ReaderNameWInit(PINIT_ONCE InitOnce, PVOID Parameter, PVOID* Context)
89{
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;
95 return TRUE;
96}
97
98struct smartcard_emulation_context
99{
100 const rdpSettings* settings;
101 DWORD log_default_level;
102 wLog* log;
103 wHashTable* contexts;
104 wHashTable* handles;
105 BOOL configured;
106 const char* pem;
107 const char* key;
108 const char* pin;
109 wHashTable* pinCounters;
110};
111
112typedef struct
113{
114 char* pin;
115 UINT16 curRetryCounter;
116 UINT16 retryCounter;
117} SmartcardPinCounterEntry;
118
119#define MAX_EMULATED_READERS 1
120typedef struct
121{
122 ULONG readerState;
123 SCARD_READERSTATEA readerStateA[MAX_EMULATED_READERS];
124 SCARD_READERSTATEW readerStateW[MAX_EMULATED_READERS];
125 wHashTable* cards;
126 wArrayList* strings;
127 wHashTable* cache;
128 BOOL canceled;
129 volatile LONG semaphore;
130} SCardContext;
131
132typedef struct
133{
134 union
135 {
136 void* pv;
137 CHAR* pc;
138 WCHAR* pw;
139 } szReader;
140 BOOL unicode;
141 BOOL transaction;
142 DWORD transmitcount;
143 DWORD dwShareMode;
144 DWORD dwActiveProtocol;
145 SCARDCONTEXT hContext;
146 SCARDHANDLE card;
147 vgidsContext* vgids;
148 size_t referencecount;
149} SCardHandle;
150
151typedef struct
152{
153 DWORD freshness;
154 DWORD size;
155 char data[MAX_CACHE_ITEM_SIZE];
156} SCardCacheItem;
157
158WINPR_ATTR_NODISCARD
159static SCardHandle* find_reader(SmartcardEmulationContext* smartcard, const void* szReader,
160 BOOL unicode);
161
162static const BYTE ATR[] = { 0x3b, 0xf7, 0x18, 0x00, 0x00, 0x80, 0x31, 0xfe, 0x45,
163 0x73, 0x66, 0x74, 0x65, 0x2d, 0x6e, 0x66, 0xc4 };
164
165WINPR_ATTR_NODISCARD
166static BOOL scard_status_transition(SCardContext* context)
167{
168 WINPR_ASSERT(context);
169
170 switch (context->readerState)
171 {
172 default:
173 case 0:
174 {
175 SCARD_READERSTATEA* reader = &context->readerStateA[0];
176 reader->szReader = g_ReaderNameA;
177 reader->dwEventState = SCARD_STATE_PRESENT;
178 reader->cbAtr = sizeof(ATR);
179 memcpy(reader->rgbAtr, ATR, sizeof(ATR));
180 }
181 {
182 if (!InitOnceExecuteOnce(&g_ReaderNameWGuard, g_ReaderNameWInit, nullptr, nullptr))
183 return FALSE;
184 SCARD_READERSTATEW* reader = &context->readerStateW[0];
185 reader->szReader = g_ReaderNameW;
186 reader->dwEventState = SCARD_STATE_PRESENT;
187 reader->cbAtr = sizeof(ATR);
188 memcpy(reader->rgbAtr, ATR, sizeof(ATR));
189 }
190 context->readerState = 42;
191 break;
192 }
193
194 return TRUE;
195}
196
197WINPR_ATTR_NODISCARD
198static UINT32 scard_copy_strings(SCardContext* ctx, void* dst, size_t dstSize, const void* src,
199 size_t srcSize)
200{
201 WINPR_ASSERT(ctx);
202 WINPR_ASSERT(dst);
203
204 WINPR_ASSERT(srcSize <= UINT32_MAX);
205 WINPR_ASSERT(dstSize <= UINT32_MAX);
206
207 if (dstSize == SCARD_AUTOALLOCATE)
208 {
209 if (srcSize == 0)
210 return 0;
211
212 void* tmp = malloc(srcSize);
213 if (!tmp)
214 return 0;
215 memcpy(tmp, src, srcSize);
216 ArrayList_Append(ctx->strings, tmp);
217 *((void**)dst) = tmp;
218 return (UINT32)srcSize;
219 }
220 else
221 {
222 const size_t min = MIN(dstSize, srcSize);
223 memcpy(dst, src, min);
224 return (UINT32)min;
225 }
226}
227
228static void waitForCancel(SCardContext* ctx)
229{
230 WINPR_ASSERT(ctx);
231 while (InterlockedCompareExchange(&ctx->semaphore, 0, 0) > 0)
232 Sleep(10);
233}
234
235static void scard_context_free(void* context)
236{
237 SCardContext* ctx = context;
238 if (ctx)
239 {
240 /* HACK: There might be long running calls in background still active.
241 * Emulation does ~100ms polling loops to check if we're still ok, so do a 2 * 100ms delay
242 * to ensure such calls are terminated.
243 *
244 * See Emulate_SCardGetStatusChangeA and Emulate_SCardGetStatusChangeW
245 */
246 ctx->canceled = TRUE;
247 waitForCancel(ctx);
248
249 HashTable_Free(ctx->cards);
250 ArrayList_Free(ctx->strings);
251 HashTable_Free(ctx->cache);
252 }
253 free(ctx);
254}
255
256WINPR_ATTR_MALLOC(scard_context_free, 1)
257static SCardContext* scard_context_new(void)
258{
259 SCardContext* ctx = calloc(1, sizeof(SCardContext));
260 if (!ctx)
261 return nullptr;
262
263 ctx->strings = ArrayList_New(FALSE);
264 if (!ctx->strings)
265 goto fail;
266 else
267 {
268 wObject* obj = ArrayList_Object(ctx->strings);
269 WINPR_ASSERT(obj);
270 obj->fnObjectFree = free;
271 }
272
273 ctx->cache = HashTable_New(FALSE);
274 if (!ctx->cache)
275 goto fail;
276 if (!HashTable_SetupForStringData(ctx->cache, FALSE))
277 goto fail;
278 else
279 {
280 wObject* val = HashTable_ValueObject(ctx->cache);
281 WINPR_ASSERT(val);
282 val->fnObjectFree = free;
283 }
284
285 if (!scard_status_transition(ctx))
286 goto fail;
287 return ctx;
288fail:
289 scard_context_free(ctx);
290 return nullptr;
291}
292
293static void scard_handle_free(void* handle)
294{
295 SCardHandle* hdl = handle;
296 if (hdl)
297 {
298 free(hdl->szReader.pv);
299 vgids_free(hdl->vgids);
300 }
301 free(hdl);
302}
303
304WINPR_ATTR_MALLOC(scard_handle_free, 1)
305static SCardHandle* scard_handle_new(SmartcardEmulationContext* smartcard, SCARDCONTEXT context,
306 const void* name, BOOL unicode)
307{
308 SCardHandle* hdl = nullptr;
309
310 WINPR_ASSERT(smartcard);
311
312 hdl = calloc(1, sizeof(SCardHandle));
313 if (!hdl)
314 goto fail;
315
316 /* ATTENTION: Do not use _strdup or _wcsdup!
317 * These strings are required to be double nullptr terminated!
318 */
319 if (unicode)
320 {
321 size_t s = _wcslen(name);
322
323 hdl->szReader.pw = calloc(s + 2, sizeof(WCHAR));
324 if (!hdl->szReader.pw)
325 goto fail;
326 memcpy(hdl->szReader.pv, name, s * sizeof(WCHAR));
327 }
328 else
329 {
330 size_t s = strlen(name);
331
332 hdl->szReader.pc = calloc(s + 2, sizeof(CHAR));
333 if (!hdl->szReader.pc)
334 goto fail;
335 memcpy(hdl->szReader.pv, name, s * sizeof(CHAR));
336 }
337
338 if (!hdl->szReader.pv)
339 goto fail;
340
341 hdl->vgids = vgids_new(smartcard);
342 if (!hdl->vgids)
343 goto fail;
344
345 {
346 const char* pem =
347 freerdp_settings_get_string(smartcard->settings, FreeRDP_SmartcardCertificate);
348 const char* key =
349 freerdp_settings_get_string(smartcard->settings, FreeRDP_SmartcardPrivateKey);
350
351 const char* pin = freerdp_settings_get_string(smartcard->settings, FreeRDP_Password);
352
353 if (!vgids_init(hdl->vgids, pem, key, pin))
354 goto fail;
355 }
356
357 hdl->unicode = unicode;
358 hdl->hContext = context;
359 return hdl;
360
361fail:
362 scard_handle_free(hdl);
363 return nullptr;
364}
365
366WINPR_ATTR_NODISCARD
367static LONG scard_handle_valid(SmartcardEmulationContext* smartcard, SCARDHANDLE handle)
368{
369 WINPR_ASSERT(smartcard);
370
371 SCardHandle* ctx = HashTable_GetItemValue(smartcard->handles, (const void*)handle);
372 if (!ctx)
373 return SCARD_E_INVALID_HANDLE;
374
375 return SCARD_S_SUCCESS;
376}
377
378WINPR_ATTR_NODISCARD
379static LONG scard_reader_name_valid_a(SmartcardEmulationContext* smartcard, SCARDCONTEXT context,
380 const char* name)
381{
382 WINPR_ASSERT(smartcard);
383
384 HashTable_Lock(smartcard->contexts);
385 SCardContext* ctx = HashTable_GetItemValue(smartcard->contexts, (const void*)context);
386
387 WINPR_ASSERT(name);
388 WINPR_ASSERT(ctx);
389
390 LONG rc = SCARD_E_UNKNOWN_READER;
391 for (size_t x = 0; x < MAX_EMULATED_READERS; x++)
392 {
393 const SCARD_READERSTATEA* reader = &ctx->readerStateA[x];
394 if (strcmp(reader->szReader, name) == 0)
395 {
396 rc = SCARD_S_SUCCESS;
397 break;
398 }
399 }
400
401 HashTable_Unlock(smartcard->contexts);
402
403 return rc;
404}
405
406WINPR_ATTR_NODISCARD
407static LONG scard_reader_name_valid_w(SmartcardEmulationContext* smartcard, SCARDCONTEXT context,
408 const WCHAR* name)
409{
410 SCardContext* ctx = nullptr;
411
412 WINPR_ASSERT(smartcard);
413 ctx = HashTable_GetItemValue(smartcard->contexts, (const void*)context);
414
415 WINPR_ASSERT(name);
416 WINPR_ASSERT(ctx);
417
418 for (size_t x = 0; x < MAX_EMULATED_READERS; x++)
419 {
420 const SCARD_READERSTATEW* reader = &ctx->readerStateW[x];
421 if (_wcscmp(reader->szReader, name) == 0)
422 return SCARD_S_SUCCESS;
423 }
424
425 return SCARD_E_UNKNOWN_READER;
426}
427
431
432LONG WINAPI Emulate_SCardEstablishContext(SmartcardEmulationContext* smartcard, DWORD dwScope,
433 LPCVOID pvReserved1, LPCVOID pvReserved2,
434 LPSCARDCONTEXT phContext)
435{
436 LONG status = SCARD_E_NO_MEMORY;
437 SCardContext* ctx = nullptr;
438
439 WINPR_ASSERT(smartcard);
440
441 ctx = scard_context_new();
442
443 WINPR_UNUSED(pvReserved1);
444 WINPR_UNUSED(pvReserved2);
445
446 WLog_Print(smartcard->log, smartcard->log_default_level,
447 "SCardEstablishContext { dwScope: %s (0x%08" PRIX32 ")",
448 SCardGetScopeString(dwScope), dwScope);
449
450 if (ctx)
451 {
452 SCARDCONTEXT context = WINPR_C_ARRAY_INIT;
453
454 if (winpr_RAND(&context, sizeof(SCARDCONTEXT)) >= 0)
455 {
456 if (HashTable_Insert(smartcard->contexts, (const void*)context, ctx))
457 {
458 *phContext = context;
459 status = SCARD_S_SUCCESS;
460 }
461 }
462 }
463
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));
467
468 if (status != SCARD_S_SUCCESS)
469 scard_context_free(ctx);
470 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of ctx
471 return status;
472}
473
474WINPR_ATTR_NODISCARD
475static BOOL remove_handles(const void* key, void* value, void* arg)
476{
477 WINPR_ASSERT(arg);
478 WINPR_ASSERT(value);
479
480 const HandleCleanLoopArg* harg = arg;
481 SCardHandle* handle = value;
482 if (handle->hContext == harg->context)
483 {
484 if (!HashTable_Remove(harg->table, key))
485 return FALSE;
486 }
487 return TRUE;
488}
489
490LONG WINAPI Emulate_SCardReleaseContext(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext)
491{
492 LONG status = SCARD_S_SUCCESS;
493
494 WINPR_ASSERT(smartcard);
495
496 HashTable_Lock(smartcard->contexts);
497 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
498
499 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardReleaseContext { hContext: %p",
500 (void*)hContext);
501
502 HandleCleanLoopArg arg = { .context = hContext, .table = smartcard->handles };
503 if (!HashTable_Foreach(smartcard->handles, remove_handles, &arg))
504 status = SCARD_E_INVALID_HANDLE;
505
506 if (value)
507 HashTable_Remove(smartcard->contexts, (const void*)hContext);
508
509 HashTable_Unlock(smartcard->contexts);
510
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));
514
515 return status;
516}
517
518LONG WINAPI Emulate_SCardIsValidContext(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext)
519{
520 LONG status = 0;
521
522 WINPR_ASSERT(smartcard);
523
524 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardIsValidContext { hContext: %p",
525 (void*)hContext);
526
527 status = HashTable_Contains(smartcard->contexts, (const void*)hContext)
528 ? SCARD_S_SUCCESS
529 : SCARD_E_INVALID_HANDLE;
530 if (status == SCARD_S_SUCCESS)
531 {
532 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
533 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
534 if (!value)
535 return SCARD_F_INTERNAL_ERROR;
536 }
537
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));
541
542 return status;
543}
544
545LONG WINAPI Emulate_SCardListReaderGroupsA(
546 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
547 LPSTR mszGroups /* NOLINT(readability-non-const-parameter) */, LPDWORD pcchGroups)
548{
549 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
550
551 WLog_Print(smartcard->log, smartcard->log_default_level,
552 "SCardListReaderGroupsA { hContext: %p", (void*)hContext);
553
554 WINPR_UNUSED(mszGroups);
555 WINPR_UNUSED(pcchGroups);
556
557 /* Not required, return not supported */
558 if (status == SCARD_S_SUCCESS)
559 status = SCARD_E_UNSUPPORTED_FEATURE;
560
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));
564
565 return status;
566}
567
568LONG WINAPI Emulate_SCardListReaderGroupsW(
569 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
570 LPWSTR mszGroups /* NOLINT(readability-non-const-parameter) */, LPDWORD pcchGroups)
571{
572 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
573
574 WLog_Print(smartcard->log, smartcard->log_default_level,
575 "SCardListReaderGroupsW { hContext: %p", (void*)hContext);
576
577 WINPR_UNUSED(mszGroups);
578 WINPR_UNUSED(pcchGroups);
579
580 /* Not required, return not supported */
581 if (status == SCARD_S_SUCCESS)
582 status = SCARD_E_UNSUPPORTED_FEATURE;
583
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));
587
588 return status;
589}
590
591LONG WINAPI Emulate_SCardListReadersA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
592 LPCSTR mszGroups, LPSTR mszReaders, LPDWORD pcchReaders)
593{
594 HashTable_Lock(smartcard->contexts);
595 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
596 if (!pcchReaders)
597 status = SCARD_E_INVALID_PARAMETER;
598
599 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardListReadersA { hContext: %p",
600 (void*)hContext);
601
602 WINPR_UNUSED(mszGroups); /* Not required */
603
604 if (SCARD_S_SUCCESS == status)
605 {
606 SCardContext* value =
607 (SCardContext*)HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
608 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
609
610 // TODO: If emulator not ready return SCARD_E_NO_READERS_AVAILABLE
611
612 // TODO: argument mszGrous
613
614 /* Return length only */
615 if (!mszReaders)
616 *pcchReaders = ARRAYSIZE(g_ReaderNameA);
617 else
618 {
619 *pcchReaders = scard_copy_strings(value, mszReaders, *pcchReaders, g_ReaderNameA,
620 sizeof(g_ReaderNameA));
621 }
622 }
623
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);
628 return status;
629}
630
631LONG WINAPI Emulate_SCardListReadersW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
632 LPCWSTR mszGroups, LPWSTR mszReaders, LPDWORD pcchReaders)
633{
634 if (!InitOnceExecuteOnce(&g_ReaderNameWGuard, g_ReaderNameWInit, nullptr, nullptr))
635 return SCARD_E_NOT_READY;
636
637 HashTable_Lock(smartcard->contexts);
638 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
639
640 if (!pcchReaders)
641 status = SCARD_E_INVALID_PARAMETER;
642
643 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardListReadersW { hContext: %p",
644 (void*)hContext);
645
646 WINPR_UNUSED(mszGroups); /* Not required */
647
648 if (SCARD_S_SUCCESS == status)
649 {
650 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
651 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
652
653 // TODO: If emulator not ready return SCARD_E_NO_READERS_AVAILABLE
654
655 // TODO: argument mszGrous
656
657 /* Return length only */
658 if (!mszReaders)
659 {
660 WINPR_ASSERT(g_ReaderNameWLen <= UINT32_MAX);
661 *pcchReaders = (UINT32)g_ReaderNameWLen;
662 }
663 else
664 {
665 *pcchReaders = scard_copy_strings(value, mszReaders, *pcchReaders, g_ReaderNameW,
666 g_ReaderNameWLen * sizeof(WCHAR)) /
667 sizeof(WCHAR);
668 }
669 }
670
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);
675 return status;
676}
677
678LONG WINAPI Emulate_SCardListCardsA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
679 LPCBYTE pbAtr, LPCGUID rgquidInterfaces,
680 DWORD cguidInterfaceCount,
681 CHAR* mszCards /* NOLINT(readability-non-const-parameter) */,
682 LPDWORD pcchCards /* NOLINT(readability-non-const-parameter) */)
683{
684 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
685
686 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardListCardsA { hContext: %p",
687 (void*)hContext);
688
689 WINPR_UNUSED(pbAtr);
690 WINPR_UNUSED(rgquidInterfaces);
691 WINPR_UNUSED(cguidInterfaceCount);
692 WINPR_UNUSED(mszCards);
693 WINPR_UNUSED(pcchCards);
694
695 /* Not required, return not supported */
696 if (status == SCARD_S_SUCCESS)
697 status = SCARD_E_UNSUPPORTED_FEATURE;
698
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));
702
703 return status;
704}
705
706LONG WINAPI Emulate_SCardListCardsW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
707 LPCBYTE pbAtr, LPCGUID rgquidInterfaces,
708 DWORD cguidInterfaceCount,
709 WCHAR* mszCards /* NOLINT(readability-non-const-parameter) */,
710 LPDWORD pcchCards /* NOLINT(readability-non-const-parameter) */)
711{
712 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
713
714 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardListCardsW { hContext: %p",
715 (void*)hContext);
716
717 WINPR_UNUSED(pbAtr);
718 WINPR_UNUSED(rgquidInterfaces);
719 WINPR_UNUSED(cguidInterfaceCount);
720 WINPR_UNUSED(mszCards);
721 WINPR_UNUSED(pcchCards);
722
723 /* Not required, return not supported */
724 if (status == SCARD_S_SUCCESS)
725 status = SCARD_E_UNSUPPORTED_FEATURE;
726
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));
730
731 return status;
732}
733
734LONG WINAPI Emulate_SCardListInterfacesA(
735 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szCard,
736 LPGUID pguidInterfaces, LPDWORD pcguidInterfaces /* NOLINT(readability-non-const-parameter) */)
737{
738 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
739
740 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardListInterfacesA { hContext: %p",
741 (void*)hContext);
742
743 WINPR_UNUSED(szCard);
744 WINPR_UNUSED(pguidInterfaces);
745 WINPR_UNUSED(pcguidInterfaces);
746
747 /* Not required, return not supported */
748 if (status == SCARD_S_SUCCESS)
749 status = SCARD_E_UNSUPPORTED_FEATURE;
750
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));
754
755 return status;
756}
757
758LONG WINAPI Emulate_SCardListInterfacesW(
759 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szCard,
760 LPGUID pguidInterfaces, LPDWORD pcguidInterfaces /* NOLINT(readability-non-const-parameter) */)
761{
762 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
763
764 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardListInterfacesW { hContext: %p",
765 (void*)hContext);
766
767 WINPR_UNUSED(szCard);
768 WINPR_UNUSED(pguidInterfaces);
769 WINPR_UNUSED(pcguidInterfaces);
770
771 /* Not required, return not supported */
772 if (status == SCARD_S_SUCCESS)
773 status = SCARD_E_UNSUPPORTED_FEATURE;
774
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));
778
779 return status;
780}
781
782LONG WINAPI Emulate_SCardGetProviderIdA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
783 LPCSTR szCard, LPGUID pguidProviderId)
784{
785 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
786
787 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetProviderIdA { hContext: %p",
788 (void*)hContext);
789
790 WINPR_UNUSED(szCard);
791 WINPR_UNUSED(pguidProviderId);
792
793 /* Not required, return not supported */
794 if (status == SCARD_S_SUCCESS)
795 status = SCARD_E_UNSUPPORTED_FEATURE;
796
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));
800
801 return status;
802}
803
804LONG WINAPI Emulate_SCardGetProviderIdW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
805 LPCWSTR szCard, LPGUID pguidProviderId)
806{
807 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
808
809 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetProviderIdW { hContext: %p",
810 (void*)hContext);
811
812 WINPR_UNUSED(szCard);
813 WINPR_UNUSED(pguidProviderId);
814
815 /* Not required, return not supported */
816 if (status == SCARD_S_SUCCESS)
817 status = SCARD_E_UNSUPPORTED_FEATURE;
818
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));
822
823 return status;
824}
825
826LONG WINAPI Emulate_SCardGetCardTypeProviderNameA(
827 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szCardName,
828 DWORD dwProviderId, CHAR* szProvider /* NOLINT(readability-non-const-parameter) */,
829 LPDWORD pcchProvider /* NOLINT(readability-non-const-parameter) */)
830{
831 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
832
833 WLog_Print(smartcard->log, smartcard->log_default_level,
834 "SCardGetCardTypeProviderNameA { hContext: %p", (void*)hContext);
835
836 WINPR_UNUSED(szCardName);
837 WINPR_UNUSED(dwProviderId);
838 WINPR_UNUSED(szProvider);
839 WINPR_UNUSED(pcchProvider);
840
841 /* Not required, return not supported */
842 if (status == SCARD_S_SUCCESS)
843 status = SCARD_E_UNSUPPORTED_FEATURE;
844
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));
848
849 return status;
850}
851
852LONG WINAPI Emulate_SCardGetCardTypeProviderNameW(
853 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szCardName,
854 DWORD dwProviderId, WCHAR* szProvider /* NOLINT(readability-non-const-parameter) */,
855 LPDWORD pcchProvider /* NOLINT(readability-non-const-parameter) */)
856{
857 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
858
859 WLog_Print(smartcard->log, smartcard->log_default_level,
860 "SCardGetCardTypeProviderNameW { hContext: %p", (void*)hContext);
861
862 WINPR_UNUSED(szCardName);
863 WINPR_UNUSED(dwProviderId);
864 WINPR_UNUSED(szProvider);
865 WINPR_UNUSED(pcchProvider);
866
867 /* Not required, return not supported */
868 if (status == SCARD_S_SUCCESS)
869 status = SCARD_E_UNSUPPORTED_FEATURE;
870
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));
874
875 return status;
876}
877
878LONG WINAPI Emulate_SCardIntroduceReaderGroupA(SmartcardEmulationContext* smartcard,
879 SCARDCONTEXT hContext, LPCSTR szGroupName)
880{
881 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
882
883 WLog_Print(smartcard->log, smartcard->log_default_level,
884 "SCardIntroduceReaderGroupA { hContext: %p", (void*)hContext);
885
886 WINPR_UNUSED(szGroupName);
887
888 /* Not required, return not supported */
889 if (status == SCARD_S_SUCCESS)
890 status = SCARD_E_UNSUPPORTED_FEATURE;
891
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));
895
896 return status;
897}
898
899LONG WINAPI Emulate_SCardIntroduceReaderGroupW(SmartcardEmulationContext* smartcard,
900 SCARDCONTEXT hContext, LPCWSTR szGroupName)
901{
902 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
903
904 WLog_Print(smartcard->log, smartcard->log_default_level,
905 "SCardIntroduceReaderGroupW { hContext: %p", (void*)hContext);
906
907 WINPR_UNUSED(szGroupName);
908
909 /* Not required, return not supported */
910 if (status == SCARD_S_SUCCESS)
911 status = SCARD_E_UNSUPPORTED_FEATURE;
912
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));
916
917 return status;
918}
919
920LONG WINAPI Emulate_SCardForgetReaderGroupA(SmartcardEmulationContext* smartcard,
921 SCARDCONTEXT hContext, LPCSTR szGroupName)
922{
923 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
924
925 WLog_Print(smartcard->log, smartcard->log_default_level,
926 "SCardForgetReaderGroupA { hContext: %p", (void*)hContext);
927
928 WINPR_UNUSED(szGroupName);
929
930 /* Not required, return not supported */
931 if (status == SCARD_S_SUCCESS)
932 status = SCARD_E_UNSUPPORTED_FEATURE;
933
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));
937
938 return status;
939}
940
941LONG WINAPI Emulate_SCardForgetReaderGroupW(SmartcardEmulationContext* smartcard,
942 SCARDCONTEXT hContext, LPCWSTR szGroupName)
943{
944 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
945
946 WLog_Print(smartcard->log, smartcard->log_default_level,
947 "SCardForgetReaderGroupW { hContext: %p", (void*)hContext);
948
949 WINPR_UNUSED(szGroupName);
950
951 /* Not required, return not supported */
952 if (status == SCARD_S_SUCCESS)
953 status = SCARD_E_UNSUPPORTED_FEATURE;
954
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));
958
959 return status;
960}
961
962LONG WINAPI Emulate_SCardIntroduceReaderA(SmartcardEmulationContext* smartcard,
963 SCARDCONTEXT hContext, LPCSTR szReaderName,
964 LPCSTR szDeviceName)
965{
966 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
967
968 if (status == SCARD_S_SUCCESS)
969 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
970
971 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardIntroduceReaderA { hContext: %p",
972 (void*)hContext);
973
974 WINPR_UNUSED(szDeviceName);
975
976 /* Not required, return not supported */
977 if (status == SCARD_S_SUCCESS)
978 status = SCARD_E_UNSUPPORTED_FEATURE;
979
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));
983
984 return status;
985}
986
987LONG WINAPI Emulate_SCardIntroduceReaderW(SmartcardEmulationContext* smartcard,
988 SCARDCONTEXT hContext, LPCWSTR szReaderName,
989 LPCWSTR szDeviceName)
990{
991 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
992
993 if (status == SCARD_S_SUCCESS)
994 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
995
996 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardIntroduceReaderW { hContext: %p",
997 (void*)hContext);
998
999 WINPR_UNUSED(szDeviceName);
1000
1001 /* Not required, return not supported */
1002 if (status == SCARD_S_SUCCESS)
1003 status = SCARD_E_UNSUPPORTED_FEATURE;
1004
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));
1008
1009 return status;
1010}
1011
1012LONG WINAPI Emulate_SCardForgetReaderA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1013 LPCSTR szReaderName)
1014{
1015 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1016
1017 if (status == SCARD_S_SUCCESS)
1018 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
1019
1020 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardForgetReaderA { hContext: %p",
1021 (void*)hContext);
1022
1023 /* Not required, return not supported */
1024 if (status == SCARD_S_SUCCESS)
1025 status = SCARD_E_UNSUPPORTED_FEATURE;
1026
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));
1030
1031 return status;
1032}
1033
1034LONG WINAPI Emulate_SCardForgetReaderW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1035 LPCWSTR szReaderName)
1036{
1037 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1038
1039 if (status == SCARD_S_SUCCESS)
1040 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
1041
1042 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardForgetReaderW { hContext: %p",
1043 (void*)hContext);
1044
1045 /* Not required, return not supported */
1046 if (status == SCARD_S_SUCCESS)
1047 status = SCARD_E_UNSUPPORTED_FEATURE;
1048
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));
1052
1053 return status;
1054}
1055
1056LONG WINAPI Emulate_SCardAddReaderToGroupA(SmartcardEmulationContext* smartcard,
1057 SCARDCONTEXT hContext, LPCSTR szReaderName,
1058 LPCSTR szGroupName)
1059{
1060 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1061
1062 if (status == SCARD_S_SUCCESS)
1063 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
1064
1065 WLog_Print(smartcard->log, smartcard->log_default_level,
1066 "SCardAddReaderToGroupA { hContext: %p", (void*)hContext);
1067
1068 WINPR_UNUSED(szGroupName);
1069
1070 /* Not required, return not supported */
1071 if (status == SCARD_S_SUCCESS)
1072 status = SCARD_E_UNSUPPORTED_FEATURE;
1073
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));
1077
1078 return status;
1079}
1080
1081LONG WINAPI Emulate_SCardAddReaderToGroupW(SmartcardEmulationContext* smartcard,
1082 SCARDCONTEXT hContext, LPCWSTR szReaderName,
1083 LPCWSTR szGroupName)
1084{
1085 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1086
1087 if (status == SCARD_S_SUCCESS)
1088 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
1089
1090 WLog_Print(smartcard->log, smartcard->log_default_level,
1091 "SCardAddReaderToGroupW { hContext: %p", (void*)hContext);
1092
1093 WINPR_UNUSED(szGroupName);
1094
1095 /* Not required, return not supported */
1096 if (status == SCARD_S_SUCCESS)
1097 status = SCARD_E_UNSUPPORTED_FEATURE;
1098
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));
1102
1103 return status;
1104}
1105
1106LONG WINAPI Emulate_SCardRemoveReaderFromGroupA(SmartcardEmulationContext* smartcard,
1107 SCARDCONTEXT hContext, LPCSTR szReaderName,
1108 LPCSTR szGroupName)
1109{
1110 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1111
1112 if (status == SCARD_S_SUCCESS)
1113 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
1114
1115 WLog_Print(smartcard->log, smartcard->log_default_level,
1116 "SCardRemoveReaderFromGroupA { hContext: %p", (void*)hContext);
1117
1118 WINPR_UNUSED(szGroupName);
1119
1120 /* Not required, return not supported */
1121 if (status == SCARD_S_SUCCESS)
1122 status = SCARD_E_UNSUPPORTED_FEATURE;
1123
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));
1127
1128 return status;
1129}
1130
1131LONG WINAPI Emulate_SCardRemoveReaderFromGroupW(SmartcardEmulationContext* smartcard,
1132 SCARDCONTEXT hContext, LPCWSTR szReaderName,
1133 LPCWSTR szGroupName)
1134{
1135 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1136
1137 if (status == SCARD_S_SUCCESS)
1138 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
1139
1140 WLog_Print(smartcard->log, smartcard->log_default_level,
1141 "SCardRemoveReaderFromGroupW { hContext: %p", (void*)hContext);
1142
1143 WINPR_UNUSED(szGroupName);
1144
1145 /* Not required, return not supported */
1146 if (status == SCARD_S_SUCCESS)
1147 status = SCARD_E_UNSUPPORTED_FEATURE;
1148
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));
1152
1153 return status;
1154}
1155
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)
1161{
1162 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1163
1164 WLog_Print(smartcard->log, smartcard->log_default_level,
1165 "SCardIntroduceCardTypeA { hContext: %p", (void*)hContext);
1166
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);
1174
1175 /* Not required, return not supported */
1176 if (status == SCARD_S_SUCCESS)
1177 status = SCARD_E_UNSUPPORTED_FEATURE;
1178
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));
1182
1183 return status;
1184}
1185
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)
1191{
1192 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1193
1194 WLog_Print(smartcard->log, smartcard->log_default_level,
1195 "SCardIntroduceCardTypeW { hContext: %p", (void*)hContext);
1196
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);
1204
1205 /* Not required, return not supported */
1206 if (status == SCARD_S_SUCCESS)
1207 status = SCARD_E_UNSUPPORTED_FEATURE;
1208
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));
1212
1213 return status;
1214}
1215
1216LONG WINAPI Emulate_SCardSetCardTypeProviderNameA(SmartcardEmulationContext* smartcard,
1217 SCARDCONTEXT hContext, LPCSTR szCardName,
1218 DWORD dwProviderId, LPCSTR szProvider)
1219{
1220 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1221
1222 WLog_Print(smartcard->log, smartcard->log_default_level,
1223 "SCardSetCardTypeProviderNameA { hContext: %p", (void*)hContext);
1224
1225 WINPR_UNUSED(szCardName);
1226 WINPR_UNUSED(dwProviderId);
1227 WINPR_UNUSED(szProvider);
1228
1229 /* Not required, return not supported */
1230 if (status == SCARD_S_SUCCESS)
1231 status = SCARD_E_UNSUPPORTED_FEATURE;
1232
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));
1236
1237 return status;
1238}
1239
1240LONG WINAPI Emulate_SCardSetCardTypeProviderNameW(SmartcardEmulationContext* smartcard,
1241 SCARDCONTEXT hContext, LPCWSTR szCardName,
1242 DWORD dwProviderId, LPCWSTR szProvider)
1243{
1244 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1245
1246 WLog_Print(smartcard->log, smartcard->log_default_level,
1247 "SCardSetCardTypeProviderNameA { hContext: %p", (void*)hContext);
1248
1249 WINPR_UNUSED(szCardName);
1250 WINPR_UNUSED(dwProviderId);
1251 WINPR_UNUSED(szProvider);
1252
1253 /* Not required, return not supported */
1254 if (status == SCARD_S_SUCCESS)
1255 status = SCARD_E_UNSUPPORTED_FEATURE;
1256
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));
1260
1261 return status;
1262}
1263
1264LONG WINAPI Emulate_SCardForgetCardTypeA(SmartcardEmulationContext* smartcard,
1265 SCARDCONTEXT hContext, LPCSTR szCardName)
1266{
1267 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1268
1269 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardForgetCardTypeA { hContext: %p",
1270 (void*)hContext);
1271
1272 WINPR_UNUSED(szCardName);
1273
1274 /* Not required, return not supported */
1275 if (status == SCARD_S_SUCCESS)
1276 status = SCARD_E_UNSUPPORTED_FEATURE;
1277
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));
1281
1282 return status;
1283}
1284
1285LONG WINAPI Emulate_SCardForgetCardTypeW(SmartcardEmulationContext* smartcard,
1286 SCARDCONTEXT hContext, LPCWSTR szCardName)
1287{
1288 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1289
1290 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardForgetCardTypeW { hContext: %p",
1291 (void*)hContext);
1292
1293 WINPR_UNUSED(szCardName);
1294
1295 /* Not required, return not supported */
1296 if (status == SCARD_S_SUCCESS)
1297 status = SCARD_E_UNSUPPORTED_FEATURE;
1298
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));
1302
1303 return status;
1304}
1305
1306LONG WINAPI Emulate_SCardFreeMemory(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1307 LPVOID pvMem)
1308{
1309 HashTable_Lock(smartcard->contexts);
1310 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1311
1312 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardFreeMemory { hContext: %p",
1313 (void*)hContext);
1314
1315 if (status == SCARD_S_SUCCESS)
1316 {
1317 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
1318 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
1319
1320 ArrayList_Remove(value->strings, pvMem);
1321 }
1322
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);
1327 return status;
1328}
1329
1330HANDLE WINAPI Emulate_SCardAccessStartedEvent(SmartcardEmulationContext* smartcard)
1331{
1332 HANDLE hEvent = nullptr;
1333
1334 WINPR_ASSERT(smartcard);
1335
1336 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardAccessStartedEvent {");
1337
1338 /* Not required, return random */
1339 if (winpr_RAND((void*)&hEvent, sizeof(hEvent)) < 0)
1340 {
1341 (void)fprintf(stderr, "winpr_RAND failed.\n");
1342 }
1343
1344 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardAccessStartedEvent } hEvent: %p",
1345 hEvent);
1346
1347 return hEvent;
1348}
1349
1350void WINAPI Emulate_SCardReleaseStartedEvent(SmartcardEmulationContext* smartcard)
1351{
1352 WINPR_ASSERT(smartcard);
1353
1354 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardReleaseStartedEvent {");
1355
1356 /* Not required, return not supported */
1357
1358 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardReleaseStartedEvent }");
1359}
1360
1361LONG WINAPI Emulate_SCardLocateCardsA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1362 LPCSTR mszCards, LPSCARD_READERSTATEA rgReaderStates,
1363 DWORD cReaders)
1364{
1365 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1366
1367 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardLocateCardsA { hContext: %p",
1368 (void*)hContext);
1369
1370 WINPR_UNUSED(mszCards);
1371 WINPR_UNUSED(rgReaderStates);
1372 WINPR_UNUSED(cReaders);
1373
1374 /* Not required, return not supported */
1375 if (status == SCARD_S_SUCCESS)
1376 status = SCARD_E_UNSUPPORTED_FEATURE;
1377
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));
1381
1382 return status;
1383}
1384
1385LONG WINAPI Emulate_SCardLocateCardsW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1386 LPCWSTR mszCards, LPSCARD_READERSTATEW rgReaderStates,
1387 DWORD cReaders)
1388{
1389 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1390
1391 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardLocateCardsW { hContext: %p",
1392 (void*)hContext);
1393
1394 WINPR_UNUSED(mszCards);
1395 WINPR_UNUSED(rgReaderStates);
1396 WINPR_UNUSED(cReaders);
1397
1398 /* Not required, return not supported */
1399 if (status == SCARD_S_SUCCESS)
1400 status = SCARD_E_UNSUPPORTED_FEATURE;
1401
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));
1405
1406 return status;
1407}
1408
1409LONG WINAPI Emulate_SCardLocateCardsByATRA(SmartcardEmulationContext* smartcard,
1410 SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
1411 DWORD cAtrs, LPSCARD_READERSTATEA rgReaderStates,
1412 DWORD cReaders)
1413{
1414 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1415
1416 WLog_Print(smartcard->log, smartcard->log_default_level,
1417 "SCardLocateCardsByATRA { hContext: %p", (void*)hContext);
1418
1419 WINPR_UNUSED(rgAtrMasks);
1420 WINPR_UNUSED(cAtrs);
1421 WINPR_UNUSED(rgReaderStates);
1422 WINPR_UNUSED(cReaders);
1423
1424 /* Not required, return not supported */
1425 if (status == SCARD_S_SUCCESS)
1426 status = SCARD_E_UNSUPPORTED_FEATURE;
1427
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));
1431
1432 return status;
1433}
1434
1435LONG WINAPI Emulate_SCardLocateCardsByATRW(SmartcardEmulationContext* smartcard,
1436 SCARDCONTEXT hContext, LPSCARD_ATRMASK rgAtrMasks,
1437 DWORD cAtrs, LPSCARD_READERSTATEW rgReaderStates,
1438 DWORD cReaders)
1439{
1440 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1441
1442 WLog_Print(smartcard->log, smartcard->log_default_level,
1443 "SCardLocateCardsByATRW { hContext: %p", (void*)hContext);
1444
1445 WINPR_UNUSED(rgAtrMasks);
1446 WINPR_UNUSED(cAtrs);
1447 WINPR_UNUSED(rgReaderStates);
1448 WINPR_UNUSED(cReaders);
1449
1450 /* Not required, return not supported */
1451 if (status == SCARD_S_SUCCESS)
1452 status = SCARD_E_UNSUPPORTED_FEATURE;
1453
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));
1457
1458 return status;
1459}
1460
1461LONG WINAPI Emulate_SCardGetStatusChangeA(SmartcardEmulationContext* smartcard,
1462 SCARDCONTEXT hContext, DWORD dwTimeout,
1463 LPSCARD_READERSTATEA rgReaderStates, DWORD cReaders)
1464{
1465 HashTable_Lock(smartcard->contexts);
1466 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1467
1468 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetStatusChangeA { hContext: %p",
1469 (void*)hContext);
1470
1471 if (status == SCARD_S_SUCCESS)
1472 {
1473 const DWORD diff = 100;
1474 size_t eventCount = 0;
1475 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
1476 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
1477
1478 const LONG start = InterlockedIncrement(&value->semaphore);
1479
1480 const freerdp* inst = freerdp_settings_get_pointer(smartcard->settings, FreeRDP_instance);
1481 WINPR_ASSERT(inst);
1482
1483 status = SCARD_E_TIMEOUT;
1484 do
1485 {
1486 const LONG rc = Emulate_SCardIsValidContext(smartcard, hContext);
1487 if (rc != SCARD_S_SUCCESS)
1488 {
1489 status = rc;
1490 break;
1491 }
1492 value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
1493
1494 for (size_t x = 0; x < cReaders; x++)
1495 {
1496 LPSCARD_READERSTATEA out = &rgReaderStates[x];
1497
1498 for (size_t y = 0; y < MAX_EMULATED_READERS; y++)
1499 {
1500 const LPSCARD_READERSTATEA in = &value->readerStateA[y];
1501 if (out->szReader && in->szReader && (strcmp(out->szReader, in->szReader) == 0))
1502 {
1503 HashTable_Lock(smartcard->handles);
1504 const SCardHandle* hdl = find_reader(smartcard, in->szReader, FALSE);
1505 out->dwEventState = in->dwEventState;
1506 if (hdl)
1507 {
1508 out->dwEventState |= SCARD_STATE_INUSE;
1509 if (hdl->dwShareMode == SCARD_SHARE_EXCLUSIVE)
1510 out->dwEventState |= SCARD_STATE_EXCLUSIVE;
1511 }
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;
1519
1520 out->cbAtr = in->cbAtr;
1521 memcpy(out->rgbAtr, in->rgbAtr, out->cbAtr);
1522 if (out->dwEventState & SCARD_STATE_CHANGED)
1523 eventCount++;
1524 }
1525 }
1526 }
1527 if (value->canceled)
1528 {
1529 status = SCARD_E_CANCELLED;
1530 break;
1531 }
1532 if (eventCount != 0)
1533 {
1534 status = SCARD_S_SUCCESS;
1535 break;
1536 }
1537 HashTable_Unlock(smartcard->contexts);
1538 Sleep(diff);
1539 HashTable_Lock(smartcard->contexts);
1540 if (dwTimeout != INFINITE)
1541 dwTimeout -= MIN(dwTimeout, diff);
1542 if (freerdp_shall_disconnect_context(inst->context))
1543 {
1544 status = SCARD_E_CANCELLED;
1545 break;
1546 }
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);
1551 }
1552
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);
1557 return status;
1558}
1559
1560LONG WINAPI Emulate_SCardGetStatusChangeW(SmartcardEmulationContext* smartcard,
1561 SCARDCONTEXT hContext, DWORD dwTimeout,
1562 LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders)
1563{
1564 HashTable_Lock(smartcard->contexts);
1565 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1566
1567 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetStatusChangeW { hContext: %p",
1568 (void*)hContext);
1569
1570 if (status == SCARD_S_SUCCESS)
1571 {
1572 const DWORD diff = 100;
1573 size_t eventCount = 0;
1574 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
1575 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
1576
1577 const LONG start = InterlockedIncrement(&value->semaphore);
1578 const freerdp* inst = freerdp_settings_get_pointer(smartcard->settings, FreeRDP_instance);
1579 WINPR_ASSERT(inst);
1580
1581 status = SCARD_E_TIMEOUT;
1582 do
1583 {
1584 const LONG rc = Emulate_SCardIsValidContext(smartcard, hContext);
1585 if (rc != SCARD_S_SUCCESS)
1586 {
1587 status = rc;
1588 break;
1589 }
1590 value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
1591
1592 for (size_t x = 0; x < cReaders; x++)
1593 {
1594 LPSCARD_READERSTATEW out = &rgReaderStates[x];
1595
1596 for (size_t y = 0; y < MAX_EMULATED_READERS; y++)
1597 {
1598 const LPSCARD_READERSTATEW in = &value->readerStateW[y];
1599 if (out->szReader && in->szReader &&
1600 (_wcscmp(out->szReader, in->szReader) == 0))
1601 {
1602 HashTable_Lock(smartcard->handles);
1603 const SCardHandle* hdl = find_reader(smartcard, in->szReader, TRUE);
1604 out->dwEventState = in->dwEventState;
1605 if (hdl)
1606 {
1607 out->dwEventState |= SCARD_STATE_INUSE;
1608 if (hdl->dwShareMode == SCARD_SHARE_EXCLUSIVE)
1609 out->dwEventState |= SCARD_STATE_EXCLUSIVE;
1610 }
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);
1620
1621 if (out->dwEventState & SCARD_STATE_CHANGED)
1622 eventCount++;
1623 }
1624 }
1625 }
1626 if (value->canceled)
1627 {
1628 status = SCARD_E_CANCELLED;
1629 break;
1630 }
1631 if (eventCount != 0)
1632 {
1633 status = SCARD_S_SUCCESS;
1634 break;
1635 }
1636 HashTable_Unlock(smartcard->contexts);
1637 Sleep(diff);
1638 HashTable_Lock(smartcard->contexts);
1639 if (dwTimeout != INFINITE)
1640 dwTimeout -= MIN(dwTimeout, diff);
1641 if (freerdp_shall_disconnect_context(inst->context))
1642 {
1643 status = SCARD_E_CANCELLED;
1644 break;
1645 }
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);
1650 }
1651
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);
1656 return status;
1657}
1658
1659LONG WINAPI Emulate_SCardCancel(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext)
1660{
1661 HashTable_Lock(smartcard->contexts);
1662 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1663
1664 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardCancel { hContext: %p",
1665 (void*)hContext);
1666
1667 if (status == SCARD_S_SUCCESS)
1668 {
1669 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
1670 WINPR_ASSERT(value);
1671 value->canceled = TRUE;
1672
1673 waitForCancel(value);
1674 }
1675
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);
1680 return status;
1681}
1682
1683SCardHandle* find_reader(SmartcardEmulationContext* smartcard, const void* szReader, BOOL unicode)
1684{
1685 SCardHandle* hdl = nullptr;
1686 ULONG_PTR* keys = nullptr;
1687
1688 WINPR_ASSERT(smartcard);
1689 const size_t count = HashTable_GetKeys(smartcard->handles, &keys);
1690 for (size_t x = 0; x < count; x++)
1691 {
1692 SCardHandle* cur = HashTable_GetItemValue(smartcard->handles, (const void*)keys[x]);
1693
1694 /* HashTable_GetKeys returns a snapshot taken under the lock, and each lookup here takes
1695 * the lock again. A handle disconnected in between -- by the smartcard worker or by
1696 * channel teardown -- is simply gone by now, which is not an invariant violation: skip
1697 * it rather than assert, since WINPR_ASSERT aborts the process and the race only fires
1698 * sometimes. */
1699 if (!cur)
1700 continue;
1701
1702 if (cur->unicode != unicode)
1703 continue;
1704 if (!unicode && (strcmp(cur->szReader.pc, szReader) != 0))
1705 continue;
1706 if (unicode && (_wcscmp(cur->szReader.pw, szReader) != 0))
1707 continue;
1708 hdl = cur;
1709 break;
1710 }
1711 free(keys);
1712 return hdl;
1713}
1714
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)
1720{
1721 WINPR_ASSERT(phCard);
1722 SCardHandle* hdl = nullptr;
1723
1724 *phCard = 0;
1725 if (Emulate_SCardIsValidContext(smartcard, hContext) != SCARD_S_SUCCESS)
1726 goto fail;
1727
1728 hdl = scard_handle_new(smartcard, hContext, szReader, unicode);
1729 if (!hdl)
1730 goto fail;
1731
1732 if (winpr_RAND(&hdl->card, sizeof(hdl->card)) < 0)
1733 {
1734 scard_handle_free(hdl);
1735 hdl = nullptr;
1736 goto fail;
1737 }
1738 hdl->dwActiveProtocol = SCARD_PROTOCOL_T1;
1739 hdl->dwShareMode = dwShareMode;
1740
1741 DWORD activeProtocol = 0;
1742 if (pdwActiveProtocol)
1743 {
1744 if ((hdl->dwActiveProtocol & dwPreferredProtocols) == 0)
1745 {
1746 scard_handle_free(hdl);
1747 hdl = nullptr;
1748 goto fail;
1749 }
1750 else
1751 activeProtocol = hdl->dwActiveProtocol;
1752 }
1753
1754 if (!HashTable_Insert(smartcard->handles, (const void*)hdl->card, hdl))
1755 {
1756 scard_handle_free(hdl);
1757 hdl = nullptr;
1758 goto fail;
1759 }
1760
1761 hdl->referencecount++;
1762 *pdwActiveProtocol = activeProtocol;
1763 *phCard = hdl->card;
1764
1765fail:
1766 WLog_Print(smartcard->log, smartcard->log_default_level, "{ %p }", (void*)*phCard);
1767 return hdl;
1768}
1769
1770LONG WINAPI Emulate_SCardConnectA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1771 LPCSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
1772 LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
1773{
1774 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1775
1776 if (!phCard || !pdwActiveProtocol)
1777 status = SCARD_E_INVALID_PARAMETER;
1778
1779 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardConnectA { hContext: %p",
1780 (void*)hContext);
1781
1782 if (status == SCARD_S_SUCCESS)
1783 {
1784 if (!reader2handle(smartcard, hContext, szReader, FALSE, dwShareMode, phCard,
1785 dwPreferredProtocols, pdwActiveProtocol))
1786 status = SCARD_E_NO_MEMORY;
1787 }
1788
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));
1792
1793 return status;
1794}
1795
1796LONG WINAPI Emulate_SCardConnectW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
1797 LPCWSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols,
1798 LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol)
1799{
1800 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
1801
1802 if (!phCard || !pdwActiveProtocol)
1803 status = SCARD_E_INVALID_PARAMETER;
1804
1805 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardConnectW { hContext: %p",
1806 (void*)hContext);
1807
1808 if (status == SCARD_S_SUCCESS)
1809 {
1810 if (!reader2handle(smartcard, hContext, szReader, TRUE, dwShareMode, phCard,
1811 dwPreferredProtocols, pdwActiveProtocol))
1812 status = SCARD_E_NO_MEMORY;
1813 }
1814
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));
1818
1819 return status;
1820}
1821
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)
1826{
1827 LONG status = scard_handle_valid(smartcard, hCard);
1828
1829 if (!pdwActiveProtocol)
1830 status = SCARD_E_INVALID_PARAMETER;
1831
1832 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardReconnect { hCard: %p",
1833 (void*)hCard);
1834
1835 if (status == SCARD_S_SUCCESS)
1836 {
1837 HashTable_Lock(smartcard->handles);
1838 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
1839 WINPR_ASSERT(hdl);
1840
1841 // TODO: Implement
1842 hdl->dwShareMode = dwShareMode;
1843 hdl->transaction = FALSE;
1844
1845 *pdwActiveProtocol = hdl->dwActiveProtocol;
1846 HashTable_Unlock(smartcard->handles);
1847 }
1848
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));
1852
1853 return status;
1854}
1855
1856LONG WINAPI Emulate_SCardDisconnect(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1857 DWORD dwDisposition)
1858{
1859 LONG status = scard_handle_valid(smartcard, hCard);
1860
1861 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardDisconnect { hCard: %p",
1862 (void*)hCard);
1863
1864 WINPR_UNUSED(dwDisposition); /* We just ignore this. All return values are static anyway */
1865
1866 if (status == SCARD_S_SUCCESS)
1867 {
1868 HashTable_Lock(smartcard->handles);
1869 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
1870 WINPR_ASSERT(hdl);
1871
1872 hdl->referencecount--;
1873 if (hdl->referencecount == 0)
1874 HashTable_Remove(smartcard->handles, (const void*)hCard);
1875 HashTable_Unlock(smartcard->handles);
1876 }
1877
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));
1881
1882 return status;
1883}
1884
1885LONG WINAPI Emulate_SCardBeginTransaction(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard)
1886{
1887 LONG status = scard_handle_valid(smartcard, hCard);
1888
1889 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardBeginTransaction { hCard: %p",
1890 (void*)hCard);
1891
1892 if (status == SCARD_S_SUCCESS)
1893 {
1894 HashTable_Lock(smartcard->handles);
1895 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
1896 WINPR_ASSERT(hdl);
1897 if (hdl->transaction)
1898 status = SCARD_E_INVALID_VALUE;
1899 else
1900 hdl->transaction = TRUE;
1901 HashTable_Unlock(smartcard->handles);
1902 }
1903
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));
1907
1908 return status;
1909}
1910
1911LONG WINAPI Emulate_SCardEndTransaction(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1912 DWORD dwDisposition)
1913{
1914 LONG status = scard_handle_valid(smartcard, hCard);
1915
1916 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardEndTransaction { hCard: %p",
1917 (void*)hCard);
1918
1919 WINPR_UNUSED(dwDisposition); /* We just ignore this. All return values are static anyway */
1920
1921 if (status == SCARD_S_SUCCESS)
1922 {
1923 HashTable_Lock(smartcard->handles);
1924 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
1925 WINPR_ASSERT(hdl);
1926 if (!hdl->transaction)
1927 status = SCARD_E_NOT_TRANSACTED;
1928 else
1929 hdl->transaction = FALSE;
1930 HashTable_Unlock(smartcard->handles);
1931 }
1932
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));
1936
1937 return status;
1938}
1939
1940LONG WINAPI Emulate_SCardCancelTransaction(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard)
1941{
1942 LONG status = scard_handle_valid(smartcard, hCard);
1943
1944 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardCancelTransaction { hCard: %p",
1945 (void*)hCard);
1946
1947 if (status == SCARD_S_SUCCESS)
1948 {
1949 HashTable_Lock(smartcard->handles);
1950 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
1951 WINPR_ASSERT(hdl);
1952 if (!hdl->transaction)
1953 status = SCARD_E_NOT_TRANSACTED;
1954 else
1955 hdl->transaction = FALSE;
1956 HashTable_Unlock(smartcard->handles);
1957 }
1958
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));
1962
1963 return status;
1964}
1965
1966LONG WINAPI Emulate_SCardState(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
1967 LPDWORD pdwState, LPDWORD pdwProtocol, LPBYTE pbAtr,
1968 LPDWORD pcbAtrLen)
1969{
1970 HashTable_Lock(smartcard->handles);
1971 LONG status = scard_handle_valid(smartcard, hCard);
1972
1973 if (!pdwState || !pdwProtocol)
1974 status = SCARD_E_INVALID_PARAMETER;
1975
1976 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardState { hCard: %p",
1977 (void*)hCard);
1978
1979 if (status == SCARD_S_SUCCESS)
1980 {
1981 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
1982 WINPR_ASSERT(hdl);
1983
1984 if (pdwState)
1985 *pdwState = SCARD_SPECIFIC;
1986 if (pdwProtocol)
1987 *pdwProtocol = SCARD_PROTOCOL_T1;
1988
1989 if (pcbAtrLen)
1990 {
1991 SCardContext* ctx =
1992 HashTable_GetItemValue(smartcard->contexts, (const void*)hdl->hContext);
1993 WINPR_ASSERT(ctx);
1994
1995 for (size_t x = 0; x < MAX_EMULATED_READERS; x++)
1996 {
1997 const SCARD_READERSTATEA* readerA = &ctx->readerStateA[x];
1998 const SCARD_READERSTATEW* readerW = &ctx->readerStateW[x];
1999 if (hdl->unicode)
2000 {
2001 if (_wcscmp(readerW->szReader, hdl->szReader.pw) == 0)
2002 {
2003 *pcbAtrLen = scard_copy_strings(ctx, pbAtr, *pcbAtrLen, readerW->rgbAtr,
2004 readerW->cbAtr);
2005 }
2006 }
2007 else
2008 {
2009 if (strcmp(readerA->szReader, hdl->szReader.pc) == 0)
2010 {
2011 *pcbAtrLen = scard_copy_strings(ctx, pbAtr, *pcbAtrLen, readerA->rgbAtr,
2012 readerA->cbAtr);
2013 }
2014 }
2015 }
2016 }
2017 }
2018
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);
2023
2024 return status;
2025}
2026
2027LONG WINAPI Emulate_SCardStatusA(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2028 LPSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
2029 LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
2030{
2031 HashTable_Lock(smartcard->handles);
2032 LONG status = scard_handle_valid(smartcard, hCard);
2033
2034 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardStatusA { hCard: %p",
2035 (void*)hCard);
2036
2037 if (status == SCARD_S_SUCCESS)
2038 {
2039 SCardContext* ctx = nullptr;
2040 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
2041 WINPR_ASSERT(hdl);
2042
2043 ctx = HashTable_GetItemValue(smartcard->contexts, (const void*)hdl->hContext);
2044 WINPR_ASSERT(ctx);
2045
2046 if (pcchReaderLen)
2047 *pcchReaderLen =
2048 scard_copy_strings(ctx, mszReaderNames, *pcchReaderLen, hdl->szReader.pc,
2049 (UINT32)strlen(hdl->szReader.pc) + 2);
2050
2051 if (pdwState)
2052 *pdwState = SCARD_SPECIFIC;
2053 if (pdwProtocol)
2054 *pdwProtocol = SCARD_PROTOCOL_T1;
2055
2056 if (pcbAtrLen)
2057 {
2058 for (size_t x = 0; x < MAX_EMULATED_READERS; x++)
2059 {
2060 const SCARD_READERSTATEA* reader = &ctx->readerStateA[x];
2061 if (strcmp(reader->szReader, hdl->szReader.pc) == 0)
2062 {
2063 *pcbAtrLen =
2064 scard_copy_strings(ctx, pbAtr, *pcbAtrLen, reader->rgbAtr, reader->cbAtr);
2065 }
2066 }
2067 }
2068 }
2069
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);
2074
2075 return status;
2076}
2077
2078LONG WINAPI Emulate_SCardStatusW(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2079 LPWSTR mszReaderNames, LPDWORD pcchReaderLen, LPDWORD pdwState,
2080 LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
2081{
2082 HashTable_Lock(smartcard->handles);
2083 LONG status = scard_handle_valid(smartcard, hCard);
2084
2085 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardStatusW { hCard: %p",
2086 (void*)hCard);
2087
2088 if (status == SCARD_S_SUCCESS)
2089 {
2090 SCardContext* ctx = nullptr;
2091 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
2092 WINPR_ASSERT(hdl);
2093
2094 ctx = HashTable_GetItemValue(smartcard->contexts, (const void*)hdl->hContext);
2095 WINPR_ASSERT(ctx);
2096
2097 if (pcchReaderLen)
2098 *pcchReaderLen =
2099 scard_copy_strings(ctx, mszReaderNames, *pcchReaderLen, hdl->szReader.pw,
2100 (UINT32)(_wcslen(hdl->szReader.pw) + 2) * sizeof(WCHAR)) /
2101 sizeof(WCHAR);
2102
2103 if (pdwState)
2104 *pdwState = SCARD_SPECIFIC;
2105 if (pdwProtocol)
2106 *pdwProtocol = SCARD_PROTOCOL_T1;
2107
2108 if (pcbAtrLen)
2109 {
2110 for (size_t x = 0; x < MAX_EMULATED_READERS; x++)
2111 {
2112 const SCARD_READERSTATEW* reader = &ctx->readerStateW[x];
2113 if (_wcscmp(reader->szReader, hdl->szReader.pw) == 0)
2114 *pcbAtrLen =
2115 scard_copy_strings(ctx, pbAtr, *pcbAtrLen, reader->rgbAtr, reader->cbAtr);
2116 }
2117 }
2118 }
2119
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);
2124 return status;
2125}
2126
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)
2131{
2132 HashTable_Lock(smartcard->contexts);
2133 LONG status = scard_handle_valid(smartcard, hCard);
2134
2135 if (!pioSendPci || !pbSendBuffer || !pbRecvBuffer || !pcbRecvLength)
2136 status = SCARD_E_INVALID_PARAMETER;
2137
2138 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardTransmit { hCard: %p",
2139 (void*)hCard);
2140
2141 if (status == SCARD_S_SUCCESS)
2142 {
2143 BYTE* response = nullptr;
2144 DWORD responseSize = 0;
2145
2146 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
2147 WINPR_ASSERT(hdl);
2148
2149 hdl->transmitcount++;
2150
2151 if (!vgids_process_apdu(hdl->vgids, pbSendBuffer, cbSendLength, &response, &responseSize))
2152 status = SCARD_E_NO_SMARTCARD;
2153 else
2154 {
2155 SCardContext* ctx =
2156 HashTable_GetItemValue(smartcard->contexts, (const void*)hdl->hContext);
2157 WINPR_ASSERT(ctx);
2158
2159 *pcbRecvLength =
2160 scard_copy_strings(ctx, pbRecvBuffer, *pcbRecvLength, response, responseSize);
2161 free(response);
2162
2163 /* Required */
2164 if (pioRecvPci)
2165 pioRecvPci->dwProtocol = hdl->dwActiveProtocol;
2166 }
2167 }
2168
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);
2173 return status;
2174}
2175
2176LONG WINAPI Emulate_SCardGetTransmitCount(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2177 LPDWORD pcTransmitCount)
2178{
2179 LONG status = scard_handle_valid(smartcard, hCard);
2180
2181 if (!pcTransmitCount)
2182 status = SCARD_E_INVALID_PARAMETER;
2183
2184 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetTransmitCount { hCard: %p",
2185 (void*)hCard);
2186
2187 if (status == SCARD_S_SUCCESS)
2188 {
2189 HashTable_Lock(smartcard->handles);
2190 SCardHandle* hdl = HashTable_GetItemValue(smartcard->handles, (const void*)hCard);
2191 WINPR_ASSERT(hdl);
2192
2193 *pcTransmitCount = hdl->transmitcount;
2194 HashTable_Unlock(smartcard->handles);
2195 }
2196
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));
2200
2201 return status;
2202}
2203
2204LONG WINAPI Emulate_SCardControl(
2205 SmartcardEmulationContext* smartcard, SCARDHANDLE hCard, DWORD dwControlCode,
2206 LPCVOID lpInBuffer, DWORD cbInBufferSize, LPVOID lpOutBuffer, DWORD cbOutBufferSize,
2207 LPDWORD lpBytesReturned /* NOLINT(readability-non-const-parameter) */)
2208{
2209 LONG status = scard_handle_valid(smartcard, hCard);
2210
2211 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardControl { hCard: %p",
2212 (void*)hCard);
2213
2214 if (status == SCARD_S_SUCCESS)
2215 {
2216 WINPR_UNUSED(dwControlCode);
2217 WINPR_UNUSED(lpInBuffer);
2218 WINPR_UNUSED(cbInBufferSize);
2219 WINPR_UNUSED(lpOutBuffer);
2220 WINPR_UNUSED(cbOutBufferSize);
2221 WINPR_UNUSED(lpBytesReturned);
2222
2223 /* Not required, return not supported */
2224 status = SCARD_E_UNSUPPORTED_FEATURE;
2225 }
2226
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));
2230
2231 return status;
2232}
2233
2234LONG WINAPI Emulate_SCardGetAttrib(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2235 DWORD dwAttrId,
2236 LPBYTE pbAttr /* NOLINT(readability-non-const-parameter) */,
2237 LPDWORD pcbAttrLen /* NOLINT(readability-non-const-parameter) */)
2238{
2239 LONG status = scard_handle_valid(smartcard, hCard);
2240
2241 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetAttrib { hCard: %p",
2242 (void*)hCard);
2243
2244 WINPR_UNUSED(dwAttrId);
2245 WINPR_UNUSED(pbAttr);
2246 WINPR_UNUSED(pcbAttrLen);
2247
2248 /* Not required, return not supported */
2249 if (status == SCARD_S_SUCCESS)
2250 status = SCARD_F_INTERNAL_ERROR;
2251
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));
2255
2256 return status;
2257}
2258
2259LONG WINAPI Emulate_SCardSetAttrib(SmartcardEmulationContext* smartcard, SCARDHANDLE hCard,
2260 DWORD dwAttrId, LPCBYTE pbAttr, DWORD cbAttrLen)
2261{
2262 LONG status = scard_handle_valid(smartcard, hCard);
2263
2264 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardSetAttrib { hCard: %p",
2265 (void*)hCard);
2266
2267 WINPR_UNUSED(dwAttrId);
2268 WINPR_UNUSED(pbAttr);
2269 WINPR_UNUSED(cbAttrLen);
2270
2271 /* Not required, return not supported */
2272 if (status == SCARD_S_SUCCESS)
2273 status = SCARD_F_INTERNAL_ERROR;
2274
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));
2278
2279 return status;
2280}
2281
2282LONG WINAPI Emulate_SCardUIDlgSelectCardA(SmartcardEmulationContext* smartcard,
2283 LPOPENCARDNAMEA_EX pDlgStruc)
2284{
2285 LONG status = 0;
2286
2287 WINPR_ASSERT(smartcard);
2288
2289 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardUIDlgSelectCardA {");
2290
2291 WINPR_UNUSED(pDlgStruc);
2292
2293 /* Not required, return not supported */
2294 status = SCARD_E_UNSUPPORTED_FEATURE;
2295
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));
2299
2300 return status;
2301}
2302
2303LONG WINAPI Emulate_SCardUIDlgSelectCardW(SmartcardEmulationContext* smartcard,
2304 LPOPENCARDNAMEW_EX pDlgStruc)
2305{
2306 LONG status = 0;
2307
2308 WINPR_ASSERT(smartcard);
2309
2310 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardUIDlgSelectCardW {");
2311
2312 WINPR_UNUSED(pDlgStruc);
2313
2314 /* Not required, return not supported */
2315 status = SCARD_E_UNSUPPORTED_FEATURE;
2316
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));
2320
2321 return status;
2322}
2323
2324LONG WINAPI Emulate_GetOpenCardNameA(SmartcardEmulationContext* smartcard,
2325 LPOPENCARDNAMEA pDlgStruc)
2326{
2327 LONG status = 0;
2328
2329 WINPR_ASSERT(smartcard);
2330
2331 WLog_Print(smartcard->log, smartcard->log_default_level, "GetOpenCardNameA {");
2332
2333 WINPR_UNUSED(pDlgStruc);
2334
2335 /* Not required, return not supported */
2336 status = SCARD_E_UNSUPPORTED_FEATURE;
2337
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));
2341
2342 return status;
2343}
2344
2345LONG WINAPI Emulate_GetOpenCardNameW(SmartcardEmulationContext* smartcard,
2346 LPOPENCARDNAMEW pDlgStruc)
2347{
2348 LONG status = 0;
2349
2350 WINPR_ASSERT(smartcard);
2351
2352 WLog_Print(smartcard->log, smartcard->log_default_level, "GetOpenCardNameW {");
2353
2354 WINPR_UNUSED(pDlgStruc);
2355
2356 /* Not required, return not supported */
2357 status = SCARD_E_UNSUPPORTED_FEATURE;
2358
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));
2362
2363 return status;
2364}
2365
2366LONG WINAPI Emulate_SCardDlgExtendedError(SmartcardEmulationContext* smartcard)
2367{
2368 LONG status = 0;
2369
2370 WINPR_ASSERT(smartcard);
2371
2372 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardDlgExtendedError {");
2373
2374 /* Not required, return not supported */
2375 status = SCARD_E_UNSUPPORTED_FEATURE;
2376
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));
2380
2381 return status;
2382}
2383
2384LONG WINAPI Emulate_SCardReadCacheA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2385 UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName,
2386 PBYTE Data, DWORD* DataLen)
2387{
2388 HashTable_Lock(smartcard->contexts);
2389 DWORD count = 0;
2390 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2391
2392 if (!CardIdentifier || !DataLen)
2393 status = SCARD_E_INVALID_PARAMETER;
2394
2395 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardReadCacheA { hContext: %p",
2396 (void*)hContext);
2397
2398 if (DataLen)
2399 {
2400 count = *DataLen;
2401 *DataLen = 0;
2402 }
2403
2404 if (status == SCARD_S_SUCCESS)
2405 {
2406 SCardCacheItem* data = nullptr;
2407 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
2408 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
2409
2410 char* id = card_id_and_name_a(CardIdentifier, LookupName);
2411 if (id)
2412 data = HashTable_GetItemValue(value->cache, id);
2413 free(id);
2414
2415 if (!data)
2416 status = SCARD_W_CACHE_ITEM_NOT_FOUND;
2417 else if (data->freshness != FreshnessCounter)
2418 status = SCARD_W_CACHE_ITEM_STALE;
2419 else
2420 *DataLen = scard_copy_strings(value, Data, count, data->data, data->size);
2421 }
2422
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);
2427 return status;
2428}
2429
2430LONG WINAPI Emulate_SCardReadCacheW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2431 UUID* CardIdentifier, DWORD FreshnessCounter, LPWSTR LookupName,
2432 PBYTE Data, DWORD* DataLen)
2433{
2434 HashTable_Lock(smartcard->contexts);
2435 DWORD count = 0;
2436 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2437
2438 if (!CardIdentifier || !DataLen)
2439 status = SCARD_E_INVALID_PARAMETER;
2440
2441 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardReadCacheW { hContext: %p",
2442 (void*)hContext);
2443
2444 if (DataLen)
2445 {
2446 count = *DataLen;
2447 *DataLen = 0;
2448 }
2449
2450 if (status == SCARD_S_SUCCESS)
2451 {
2452 SCardCacheItem* data = nullptr;
2453 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
2454 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
2455
2456 char* id = card_id_and_name_w(CardIdentifier, LookupName);
2457 data = HashTable_GetItemValue(value->cache, id);
2458 free(id);
2459 if (!data)
2460 status = SCARD_W_CACHE_ITEM_NOT_FOUND;
2461 else if (data->freshness != FreshnessCounter)
2462 status = SCARD_W_CACHE_ITEM_STALE;
2463 else
2464 *DataLen = scard_copy_strings(value, Data, count, data->data, data->size);
2465 }
2466
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);
2471 return status;
2472}
2473
2474WINPR_ATTR_NODISCARD
2475static LONG insert_data(wHashTable* table, DWORD FreshnessCounter, const char* key,
2476 const PBYTE Data, DWORD DataLen)
2477{
2478 BOOL rc = 0;
2479 SCardCacheItem* item = nullptr;
2480
2481 WINPR_ASSERT(table);
2482 WINPR_ASSERT(key);
2483
2484 if (DataLen > MAX_CACHE_ITEM_SIZE)
2485 return SCARD_W_CACHE_ITEM_TOO_BIG;
2486
2487 if (HashTable_Count(table) > MAX_CACHE_ITEM_VALUES)
2488 return SCARD_E_WRITE_TOO_MANY;
2489
2490 item = HashTable_GetItemValue(table, key);
2491 if (!item)
2492 {
2493 item = calloc(1, sizeof(SCardCacheItem));
2494 if (!item)
2495 return SCARD_E_NO_MEMORY;
2496
2497 rc = HashTable_Insert(table, key, item);
2498 if (!rc)
2499 {
2500 free(item);
2501 return SCARD_E_NO_MEMORY;
2502 }
2503 }
2504
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);
2510
2511 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of item
2512 return SCARD_S_SUCCESS;
2513}
2514
2515LONG WINAPI Emulate_SCardWriteCacheA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2516 UUID* CardIdentifier, DWORD FreshnessCounter, LPSTR LookupName,
2517 PBYTE Data, DWORD DataLen)
2518{
2519 HashTable_Lock(smartcard->contexts);
2520 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2521
2522 if (!CardIdentifier)
2523 status = SCARD_E_INVALID_PARAMETER;
2524
2525 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardWriteCacheA { hContext: %p",
2526 (void*)hContext);
2527
2528 if (status == SCARD_S_SUCCESS)
2529 {
2530 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
2531 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
2532
2533 char* id = card_id_and_name_a(CardIdentifier, LookupName);
2534 if (!id)
2535 status = SCARD_E_NO_MEMORY;
2536 else
2537 {
2538 status = insert_data(value->cache, FreshnessCounter, id, Data, DataLen);
2539 free(id);
2540 }
2541 }
2542
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);
2547 return status;
2548}
2549
2550LONG WINAPI Emulate_SCardWriteCacheW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2551 UUID* CardIdentifier, DWORD FreshnessCounter,
2552 LPWSTR LookupName, PBYTE Data, DWORD DataLen)
2553{
2554 HashTable_Lock(smartcard->contexts);
2555 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2556
2557 if (!CardIdentifier)
2558 status = SCARD_E_INVALID_PARAMETER;
2559
2560 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardWriteCacheW { hContext: %p",
2561 (void*)hContext);
2562
2563 if (status == SCARD_S_SUCCESS)
2564 {
2565 SCardContext* value = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
2566 WINPR_ASSERT(value); /* Must be valid after Emulate_SCardIsValidContext */
2567
2568 char* id = card_id_and_name_w(CardIdentifier, LookupName);
2569 if (!id)
2570 status = SCARD_E_NO_MEMORY;
2571 else
2572 {
2573 status = insert_data(value->cache, FreshnessCounter, id, Data, DataLen);
2574 free(id);
2575 }
2576 }
2577
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);
2582 return status;
2583}
2584
2585LONG WINAPI Emulate_SCardGetReaderIconA(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2586 LPCSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon)
2587{
2588 HashTable_Lock(smartcard->contexts);
2589 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2590
2591 if (!szReaderName || !pcbIcon)
2592 status = SCARD_E_INVALID_PARAMETER;
2593
2594 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetReaderIconA { hContext: %p",
2595 (void*)hContext);
2596
2597 if (status == SCARD_S_SUCCESS)
2598 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
2599
2600 if (status == SCARD_S_SUCCESS)
2601 {
2602 SCardContext* ctx = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
2603 WINPR_ASSERT(ctx);
2604
2605 if (pbIcon)
2606 *pcbIcon = scard_copy_strings(ctx, pbIcon, *pcbIcon, resources_FreeRDP_ico,
2607 resources_FreeRDP_ico_len);
2608 else
2609 *pcbIcon = resources_FreeRDP_ico_len;
2610 }
2611
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);
2616 return status;
2617}
2618
2619LONG WINAPI Emulate_SCardGetReaderIconW(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2620 LPCWSTR szReaderName, LPBYTE pbIcon, LPDWORD pcbIcon)
2621{
2622 HashTable_Lock(smartcard->contexts);
2623 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2624
2625 if (!szReaderName || !pcbIcon)
2626 status = SCARD_E_INVALID_PARAMETER;
2627
2628 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetReaderIconW { hContext: %p",
2629 (void*)hContext);
2630
2631 if (status == SCARD_S_SUCCESS)
2632 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
2633
2634 if (status == SCARD_S_SUCCESS)
2635 {
2636 SCardContext* ctx = HashTable_GetItemValue(smartcard->contexts, (const void*)hContext);
2637 WINPR_ASSERT(ctx);
2638
2639 if (pbIcon)
2640 *pcbIcon = scard_copy_strings(ctx, pbIcon, *pcbIcon, resources_FreeRDP_ico,
2641 resources_FreeRDP_ico_len);
2642 else
2643 *pcbIcon = resources_FreeRDP_ico_len;
2644 }
2645
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);
2650 return status;
2651}
2652
2653LONG WINAPI Emulate_SCardGetDeviceTypeIdA(SmartcardEmulationContext* smartcard,
2654 SCARDCONTEXT hContext, LPCSTR szReaderName,
2655 LPDWORD pdwDeviceTypeId)
2656{
2657 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2658
2659 if (!pdwDeviceTypeId)
2660 status = SCARD_E_INVALID_PARAMETER;
2661
2662 if (status == SCARD_S_SUCCESS)
2663 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
2664
2665 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetDeviceTypeIdA { hContext: %p",
2666 (void*)hContext);
2667
2668 if (status == SCARD_S_SUCCESS)
2669 {
2670 *pdwDeviceTypeId = SCARD_READER_TYPE_USB; // SCARD_READER_TYPE_TPM
2671 }
2672
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));
2676
2677 return status;
2678}
2679
2680LONG WINAPI Emulate_SCardGetDeviceTypeIdW(SmartcardEmulationContext* smartcard,
2681 SCARDCONTEXT hContext, LPCWSTR szReaderName,
2682 LPDWORD pdwDeviceTypeId)
2683{
2684 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2685
2686 if (!pdwDeviceTypeId)
2687 status = SCARD_E_INVALID_PARAMETER;
2688
2689 if (status == SCARD_S_SUCCESS)
2690 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
2691
2692 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardGetDeviceTypeIdW { hContext: %p",
2693 (void*)hContext);
2694
2695 if (status == SCARD_S_SUCCESS)
2696 {
2697 *pdwDeviceTypeId = SCARD_READER_TYPE_USB; // SCARD_READER_TYPE_TPM
2698 }
2699
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));
2703
2704 return status;
2705}
2706
2707LONG WINAPI Emulate_SCardGetReaderDeviceInstanceIdA(
2708 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szReaderName,
2709 LPSTR szDeviceInstanceId /* NOLINT(readability-non-const-parameter) */,
2710 LPDWORD pcchDeviceInstanceId /* NOLINT(readability-non-const-parameter) */)
2711{
2712 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2713
2714 if (status == SCARD_S_SUCCESS)
2715 status = scard_reader_name_valid_a(smartcard, hContext, szReaderName);
2716
2717 WLog_Print(smartcard->log, smartcard->log_default_level,
2718 "SCardGetReaderDeviceInstanceIdA { hContext: %p", (void*)hContext);
2719
2720 WINPR_UNUSED(szDeviceInstanceId);
2721 WINPR_UNUSED(pcchDeviceInstanceId);
2722
2723 /* Not required, return not supported */
2724 if (status == SCARD_S_SUCCESS)
2725 status = SCARD_E_UNSUPPORTED_FEATURE;
2726
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));
2730
2731 return status;
2732}
2733
2734LONG WINAPI Emulate_SCardGetReaderDeviceInstanceIdW(
2735 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szReaderName,
2736 LPWSTR szDeviceInstanceId /* NOLINT(readability-non-const-parameter) */,
2737 LPDWORD pcchDeviceInstanceId /* NOLINT(readability-non-const-parameter) */)
2738{
2739 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2740
2741 if (status == SCARD_S_SUCCESS)
2742 status = scard_reader_name_valid_w(smartcard, hContext, szReaderName);
2743
2744 WLog_Print(smartcard->log, smartcard->log_default_level,
2745 "SCardGetReaderDeviceInstanceIdW { hContext: %p", (void*)hContext);
2746
2747 WINPR_UNUSED(szDeviceInstanceId);
2748 WINPR_UNUSED(pcchDeviceInstanceId);
2749
2750 /* Not required, return not supported */
2751 if (status == SCARD_S_SUCCESS)
2752 status = SCARD_E_UNSUPPORTED_FEATURE;
2753
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));
2757
2758 return status;
2759}
2760
2761LONG WINAPI Emulate_SCardListReadersWithDeviceInstanceIdA(
2762 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCSTR szDeviceInstanceId,
2763 LPSTR mszReaders /* NOLINT(readability-non-const-parameter) */,
2764 LPDWORD pcchReaders /* NOLINT(readability-non-const-parameter) */)
2765{
2766 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2767
2768 WLog_Print(smartcard->log, smartcard->log_default_level,
2769 "SCardListReadersWithDeviceInstanceIdA { hContext: %p", (void*)hContext);
2770
2771 WINPR_UNUSED(szDeviceInstanceId);
2772 WINPR_UNUSED(mszReaders);
2773 WINPR_UNUSED(pcchReaders);
2774
2775 /* Not required, return not supported */
2776 if (status == SCARD_S_SUCCESS)
2777 status = SCARD_E_UNSUPPORTED_FEATURE;
2778
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));
2782
2783 return status;
2784}
2785
2786LONG WINAPI Emulate_SCardListReadersWithDeviceInstanceIdW(
2787 SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext, LPCWSTR szDeviceInstanceId,
2788 LPWSTR mszReaders /* NOLINT(readability-non-const-parameter) */, LPDWORD pcchReaders)
2789{
2790 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2791
2792 WLog_Print(smartcard->log, smartcard->log_default_level,
2793 "SCardListReadersWithDeviceInstanceIdW { hContext: %p", (void*)hContext);
2794
2795 WINPR_UNUSED(szDeviceInstanceId);
2796 WINPR_UNUSED(mszReaders);
2797 WINPR_UNUSED(pcchReaders);
2798
2799 /* Not required, return not supported */
2800 if (status == SCARD_S_SUCCESS)
2801 status = SCARD_E_UNSUPPORTED_FEATURE;
2802
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));
2806
2807 return status;
2808}
2809
2810LONG WINAPI Emulate_SCardAudit(SmartcardEmulationContext* smartcard, SCARDCONTEXT hContext,
2811 DWORD dwEvent)
2812{
2813 LONG status = Emulate_SCardIsValidContext(smartcard, hContext);
2814
2815 WINPR_UNUSED(dwEvent);
2816
2817 WLog_Print(smartcard->log, smartcard->log_default_level, "SCardAudit { hContext: %p",
2818 (void*)hContext);
2819
2820 // TODO: Implement
2821 if (status == SCARD_S_SUCCESS)
2822 status = SCARD_E_UNSUPPORTED_FEATURE;
2823
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));
2827
2828 return status;
2829}
2830
2831WINPR_ATTR_NODISCARD
2832static BOOL context_equals(const void* pva, const void* pvb)
2833{
2834 const SCARDCONTEXT a = (const SCARDCONTEXT)pva;
2835 const SCARDCONTEXT b = (const SCARDCONTEXT)pvb;
2836 if (!a && !b)
2837 return TRUE;
2838 if (!a || !b)
2839 return FALSE;
2840
2841 return a == b;
2842}
2843
2844WINPR_ATTR_NODISCARD
2845static BOOL handle_equals(const void* pva, const void* pvb)
2846{
2847 const SCARDHANDLE a = (const SCARDHANDLE)pva;
2848 const SCARDHANDLE b = (const SCARDHANDLE)pvb;
2849 if (!a && !b)
2850 return TRUE;
2851 if (!a || !b)
2852 return FALSE;
2853
2854 return a == b;
2855}
2856
2857static void entry_free(void* ptr)
2858{
2859 SmartcardPinCounterEntry* entry = ptr;
2860 if (!entry)
2861 return;
2862
2863 winpr_zfree(entry->pin);
2864 free(entry);
2865}
2866
2867WINPR_ATTR_MALLOC(entry_free, 1)
2868static void* entry_clone(const void* other)
2869{
2870 const SmartcardPinCounterEntry* entry = other;
2871 if (!entry)
2872 return nullptr;
2873
2874 SmartcardPinCounterEntry* clone = calloc(1, sizeof(SmartcardPinCounterEntry));
2875 if (!clone)
2876 return nullptr;
2877 *clone = *entry;
2878 if (entry->pin)
2879 {
2880 clone->pin = _strdup(entry->pin);
2881 if (!clone->pin)
2882 {
2883 entry_free(clone);
2884 return nullptr;
2885 }
2886 }
2887 return clone;
2888}
2889
2890SmartcardEmulationContext* Emulate_New(const rdpSettings* settings)
2891{
2892 SmartcardEmulationContext* smartcard = nullptr;
2893
2894 WINPR_ASSERT(settings);
2895
2896 smartcard = calloc(1, sizeof(SmartcardEmulationContext));
2897 if (!smartcard)
2898 goto fail;
2899
2900 smartcard->settings = settings;
2901 smartcard->log = WLog_Get("EmulateSCard");
2902 if (!smartcard->log)
2903 goto fail;
2904 smartcard->log_default_level = WLOG_TRACE;
2905
2906 smartcard->contexts = HashTable_New(FALSE);
2907 if (!smartcard->contexts)
2908 goto fail;
2909 else
2910 {
2911 wObject* obj = HashTable_KeyObject(smartcard->contexts);
2912 WINPR_ASSERT(obj);
2913 obj->fnObjectEquals = context_equals;
2914 }
2915 if (!smartcard->contexts)
2916 goto fail;
2917 else
2918 {
2919 wObject* obj = HashTable_ValueObject(smartcard->contexts);
2920 WINPR_ASSERT(obj);
2921 obj->fnObjectFree = scard_context_free;
2922 }
2923
2924 smartcard->handles = HashTable_New(TRUE);
2925 if (!smartcard->handles)
2926 goto fail;
2927 else
2928 {
2929 wObject* obj = HashTable_KeyObject(smartcard->handles);
2930 WINPR_ASSERT(obj);
2931 obj->fnObjectEquals = handle_equals;
2932 }
2933 if (!smartcard->handles)
2934 goto fail;
2935 else
2936 {
2937 wObject* obj = HashTable_ValueObject(smartcard->handles);
2938 WINPR_ASSERT(obj);
2939 obj->fnObjectFree = scard_handle_free;
2940 }
2941
2942 smartcard->pinCounters = HashTable_New(TRUE);
2943 if (!smartcard->pinCounters)
2944 goto fail;
2945 else if (!HashTable_SetupForStringData(smartcard->pinCounters, FALSE))
2946 goto fail;
2947 else
2948 {
2949 wObject* obj = HashTable_ValueObject(smartcard->pinCounters);
2950 WINPR_ASSERT(obj);
2951 obj->fnObjectEquals = nullptr;
2952 obj->fnObjectFree = entry_free;
2953 obj->fnObjectNew = entry_clone;
2954 }
2955 return smartcard;
2956
2957fail:
2958 WINPR_PRAGMA_DIAG_PUSH
2959 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2960 Emulate_Free(smartcard);
2961 WINPR_PRAGMA_DIAG_POP
2962 return nullptr;
2963}
2964
2965void Emulate_Free(SmartcardEmulationContext* context)
2966{
2967 if (!context)
2968 return;
2969
2970 HashTable_Free(context->handles);
2971 HashTable_Free(context->contexts);
2972 HashTable_Free(context->pinCounters);
2973 free(context);
2974}
2975
2976BOOL Emulate_IsConfigured(SmartcardEmulationContext* context)
2977{
2978 BOOL rc = FALSE;
2979 vgidsContext* vgids = nullptr;
2980 const char* pem = nullptr;
2981 const char* key = nullptr;
2982 const char* pin = nullptr;
2983
2984 WINPR_ASSERT(context);
2985
2986 pem = freerdp_settings_get_string(context->settings, FreeRDP_SmartcardCertificate);
2987 key = freerdp_settings_get_string(context->settings, FreeRDP_SmartcardPrivateKey);
2988 pin = freerdp_settings_get_string(context->settings, FreeRDP_Password);
2989
2990 /* Cache result only, if no initialization arguments changed. */
2991 if ((context->pem == pem) && (context->key == key) && (context->pin == pin))
2992 return context->configured;
2993
2994 context->pem = pem;
2995 context->key = key;
2996 context->pin = pin;
2997
2998 vgids = vgids_new(context);
2999 if (vgids)
3000 rc = vgids_init(vgids, context->pem, context->key, context->pin);
3001 vgids_free(vgids);
3002
3003 context->configured = rc;
3004 return rc;
3005}
3006
3007BOOL Emulate_SetupPin(SmartcardEmulationContext* context, const char* name, const char* pin)
3008{
3009 WINPR_ASSERT(context);
3010
3011 const SmartcardPinCounterEntry entry = { .curRetryCounter = VGIDS_DEFAULT_RETRY_COUNTER,
3012 .retryCounter = VGIDS_DEFAULT_RETRY_COUNTER,
3013 .pin = WINPR_CAST_CONST_PTR_AWAY(pin, char*) };
3014
3015 BOOL rc = FALSE;
3016 HashTable_Lock(context->pinCounters);
3017 const SmartcardPinCounterEntry* val = HashTable_GetItemValue(context->pinCounters, name);
3018 if (!val)
3019 rc = HashTable_Insert(context->pinCounters, name, &entry);
3020 else
3021 {
3022 if (val->pin && pin)
3023 rc = strcmp(val->pin, pin) == 0;
3024 }
3025 HashTable_Unlock(context->pinCounters);
3026 return rc;
3027}
3028
3029BOOL Emulate_IsPinValid(SmartcardEmulationContext* context, const char* name, const char* pin,
3030 size_t bytelen, UINT16* remaining)
3031{
3032 WINPR_ASSERT(context);
3033 WINPR_ASSERT(remaining);
3034
3035 *remaining = 0;
3036
3037 BOOL rc = FALSE;
3038 HashTable_Lock(context->pinCounters);
3039 SmartcardPinCounterEntry* val = HashTable_GetItemValue(context->pinCounters, name);
3040 if (val)
3041 {
3042 if (val->pin && pin)
3043 {
3044 const size_t min = strlen(val->pin);
3045 if (bytelen >= min)
3046 rc = strncmp(val->pin, pin, min + 1) == 0;
3047 }
3048 if (!rc)
3049 {
3050 if (val->curRetryCounter > 0)
3051 val->curRetryCounter--;
3052 else
3053 val->curRetryCounter = val->retryCounter;
3054 }
3055 *remaining = val->curRetryCounter;
3056 }
3057
3058 HashTable_Unlock(context->pinCounters);
3059 return rc;
3060}
3061
3062BOOL Emulate_IsPinBlocked(SmartcardEmulationContext* context, const char* name)
3063{
3064 WINPR_ASSERT(context);
3065
3066 BOOL rc = FALSE;
3067 HashTable_Lock(context->pinCounters);
3068 const SmartcardPinCounterEntry* val = HashTable_GetItemValue(context->pinCounters, name);
3069 if (val)
3070 rc = val->curRetryCounter == 0;
3071 HashTable_Unlock(context->pinCounters);
3072 return rc;
3073}
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.
Definition wtypes.h:263
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59