19 |
*/ |
*/ |
20 |
|
|
21 |
#include <stdio.h> |
#include <stdio.h> |
|
#include "rdesktop.h" |
|
22 |
#include <unistd.h> |
#include <unistd.h> |
23 |
#include <fcntl.h> |
#include <fcntl.h> |
24 |
#include <strings.h> |
#include <strings.h> |
26 |
#include <time.h> |
#include <time.h> |
27 |
#ifndef MAKE_PROTO |
#ifndef MAKE_PROTO |
28 |
#ifdef PCSC_OSX |
#ifdef PCSC_OSX |
29 |
|
#include <PCSC/wintypes.h> |
30 |
#include <PCSC/pcsclite.h> |
#include <PCSC/pcsclite.h> |
31 |
#include <PCSC/winscard.h> |
#include <PCSC/winscard.h> |
32 |
#else |
#else |
33 |
|
#include <wintypes.h> |
34 |
#include <pcsclite.h> |
#include <pcsclite.h> |
35 |
#include <winscard.h> |
#include <winscard.h> |
36 |
#endif /* PCSC_OSX */ |
#endif /* PCSC_OSX */ |
37 |
|
#include "rdesktop.h" |
38 |
#include "scard.h" |
#include "scard.h" |
39 |
|
|
40 |
/* variable segment */ |
/* variable segment */ |
46 |
|
|
47 |
static struct stream out[STREAM_COUNT]; |
static struct stream out[STREAM_COUNT]; |
48 |
static int cur_stream_id = 0; |
static int cur_stream_id = 0; |
49 |
static pthread_mutex_t *tcp_sendcontrol_mutex = NULL; |
static pthread_mutex_t **scard_mutex = NULL; |
50 |
|
|
51 |
static uint32 curDevice = 0, curId = 0, curBytesOut = 0; |
static uint32 curDevice = 0, curId = 0, curBytesOut = 0; |
52 |
static PSCNameMapRec nameMapList = NULL; |
static PSCNameMapRec nameMapList = NULL; |
56 |
static pthread_mutex_t queueAccess; |
static pthread_mutex_t queueAccess; |
57 |
static pthread_mutex_t queueEmpty; |
static pthread_mutex_t queueEmpty; |
58 |
static pthread_mutex_t hcardAccess; |
static pthread_mutex_t hcardAccess; |
|
/* static pthread_mutex_t sendControl; */ |
|
59 |
|
|
60 |
static PMEM_HANDLE threadListHandle = NULL; |
static PMEM_HANDLE threadListHandle = NULL; |
61 |
static PThreadListElement threadList = NULL; |
static PThreadListElement threadList = NULL; |
81 |
|
|
82 |
#ifndef MAKE_PROTO |
#ifndef MAKE_PROTO |
83 |
|
|
84 |
static NTSTATUS |
static RD_NTSTATUS |
85 |
scard_create(uint32 device_id, uint32 accessmask, uint32 sharemode, uint32 create_disposition, |
scard_create(uint32 device_id, uint32 accessmask, uint32 sharemode, uint32 create_disposition, |
86 |
uint32 flags_and_attributes, char *filename, NTHANDLE * phandle) |
uint32 flags_and_attributes, char *filename, RD_NTHANDLE * phandle) |
87 |
{ |
{ |
88 |
return STATUS_SUCCESS; |
return RD_STATUS_SUCCESS; |
89 |
} |
} |
90 |
|
|
91 |
static NTSTATUS |
static RD_NTSTATUS |
92 |
scard_close(NTHANDLE handle) |
scard_close(RD_NTHANDLE handle) |
93 |
{ |
{ |
94 |
return STATUS_SUCCESS; |
return RD_STATUS_SUCCESS; |
95 |
} |
} |
96 |
|
|
97 |
static NTSTATUS |
static RD_NTSTATUS |
98 |
scard_read(NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result) |
scard_read(RD_NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result) |
99 |
{ |
{ |
100 |
return STATUS_SUCCESS; |
return RD_STATUS_SUCCESS; |
101 |
} |
} |
102 |
|
|
103 |
static NTSTATUS |
static RD_NTSTATUS |
104 |
scard_write(NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result) |
scard_write(RD_NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result) |
105 |
{ |
{ |
106 |
return STATUS_SUCCESS; |
return RD_STATUS_SUCCESS; |
107 |
} |
} |
108 |
#endif /* MAKE_PROTO */ |
#endif /* MAKE_PROTO */ |
109 |
|
|
153 |
return 0; |
return 0; |
154 |
} |
} |
155 |
|
|
|
#if 0 |
|
|
if (0 != pthread_mutex_init(&sendControl, NULL)) |
|
|
{ |
|
|
error("[SMART CARD: Can't initialize send control mutex]\n"); |
|
|
return 0; |
|
|
} |
|
|
#endif |
|
|
|
|
|
|
|
156 |
if (0 != |
if (0 != |
157 |
pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL)) |
pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL)) |
158 |
{ |
{ |
485 |
static void |
static void |
486 |
outForceAlignment(STREAM out, unsigned int seed) |
outForceAlignment(STREAM out, unsigned int seed) |
487 |
{ |
{ |
|
#if 0 |
|
488 |
SERVER_DWORD add = (seed - (out->p - out->data) % seed) % seed; |
SERVER_DWORD add = (seed - (out->p - out->data) % seed) % seed; |
489 |
if (add > 0) |
if (add > 0) |
490 |
out_uint8s(out, add); |
out_uint8s(out, add); |
|
#else |
|
|
out_uint8s(out, seed); |
|
|
#endif |
|
491 |
} |
} |
492 |
|
|
493 |
static unsigned int |
static unsigned int |
494 |
inString(PMEM_HANDLE * handle, STREAM in, char **destination, SERVER_DWORD dataLength, BOOL wide) |
inString(PMEM_HANDLE * handle, STREAM in, char **destination, SERVER_DWORD dataLength, RD_BOOL wide) |
495 |
{ |
{ |
496 |
unsigned int Result = (wide) ? (2 * dataLength) : (dataLength); |
unsigned int Result = (wide) ? (2 * dataLength) : (dataLength); |
497 |
PMEM_HANDLE lcHandle = NULL; |
PMEM_HANDLE lcHandle = NULL; |
525 |
} |
} |
526 |
|
|
527 |
static unsigned int |
static unsigned int |
528 |
outString(STREAM out, char *source, BOOL wide) |
outString(STREAM out, char *source, RD_BOOL wide) |
529 |
{ |
{ |
530 |
PMEM_HANDLE lcHandle = NULL; |
PMEM_HANDLE lcHandle = NULL; |
531 |
char *reader = getAlias(source); |
char *reader = getAlias(source); |
559 |
} |
} |
560 |
|
|
561 |
static void |
static void |
562 |
inReaderName(PMEM_HANDLE * handle, STREAM in, char **destination, BOOL wide) |
inReaderName(PMEM_HANDLE * handle, STREAM in, char **destination, RD_BOOL wide) |
563 |
{ |
{ |
564 |
SERVER_DWORD dataLength; |
SERVER_DWORD dataLength; |
565 |
in->p += 0x08; |
in->p += 0x08; |
608 |
rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext); |
rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext); |
609 |
if (rv) |
if (rv) |
610 |
{ |
{ |
611 |
DEBUG_SCARD(("<--ERROR SCardEstablishContext Code=0x%.8x]-->\n", |
DEBUG_SCARD(("<--ERROR SCardEstablishContext Code=0x%.8x, %s]-->\n", |
612 |
(unsigned int) rv)); |
(unsigned int) rv, pcsc_stringify_error(rv))); |
613 |
} |
} |
614 |
else |
else |
615 |
{ |
{ |
638 |
|
|
639 |
if (rv) |
if (rv) |
640 |
{ |
{ |
641 |
DEBUG_SCARD(("<--ERROR SCardReleaseContext Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardReleaseContext Code=0x%.8x, %s-->\n", (unsigned int) rv, |
642 |
|
pcsc_stringify_error(rv))); |
643 |
} |
} |
644 |
else |
else |
645 |
{ |
{ |
672 |
|
|
673 |
if (rv) |
if (rv) |
674 |
{ |
{ |
675 |
DEBUG_SCARD(("<--ERROR SCardListReaders (no SCardIsValidContext) Code=0x%.8x-->\n", |
DEBUG_SCARD(("<--ERROR SCardListReaders (no SCardIsValidContext) Code=0x%.8x, %s-->\n", (unsigned int) rv, pcsc_stringify_error(rv))); |
|
(unsigned int) rv)); |
|
676 |
rv = SCARD_E_INVALID_HANDLE; |
rv = SCARD_E_INVALID_HANDLE; |
677 |
} |
} |
678 |
else |
else |
680 |
DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n")); |
DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n")); |
681 |
} |
} |
682 |
|
|
683 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
684 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
685 |
return rv; |
return rv; |
686 |
} |
} |
687 |
|
|
688 |
|
|
689 |
static MYPCSC_DWORD |
static MYPCSC_DWORD |
690 |
TS_SCardListReaders(STREAM in, STREAM out, BOOL wide) |
TS_SCardListReaders(STREAM in, STREAM out, RD_BOOL wide) |
691 |
{ |
{ |
692 |
#define readerArraySize 1024 |
#define readerArraySize 1024 |
693 |
MYPCSC_DWORD rv; |
MYPCSC_DWORD rv; |
753 |
out_uint32_le(out, dataLength); |
out_uint32_le(out, dataLength); |
754 |
out->p = pend; |
out->p = pend; |
755 |
|
|
756 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
757 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
758 |
return rv; |
return rv; |
759 |
} |
} |
760 |
|
|
761 |
|
|
762 |
static MYPCSC_DWORD |
static MYPCSC_DWORD |
763 |
TS_SCardConnect(STREAM in, STREAM out, BOOL wide) |
TS_SCardConnect(STREAM in, STREAM out, RD_BOOL wide) |
764 |
{ |
{ |
765 |
MYPCSC_DWORD rv; |
MYPCSC_DWORD rv; |
766 |
SCARDCONTEXT hContext; |
SCARDCONTEXT hContext; |
790 |
DEBUG_SCARD(("[MANGLED HCARD 0x%08x]\n", hCard)); |
DEBUG_SCARD(("[MANGLED HCARD 0x%08x]\n", hCard)); |
791 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
792 |
{ |
{ |
793 |
DEBUG_SCARD(("<--ERROR SCardConnect Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardConnect Code=0x%.8x, %s-->\n", (unsigned int) rv, |
794 |
|
pcsc_stringify_error(rv))); |
795 |
} |
} |
796 |
else |
else |
797 |
{ |
{ |
829 |
out_uint32_le(out, 0x00000004); |
out_uint32_le(out, 0x00000004); |
830 |
out_uint32_le(out, hCard); |
out_uint32_le(out, hCard); |
831 |
|
|
832 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
833 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
834 |
return rv; |
return rv; |
835 |
} |
} |
865 |
(MYPCSC_DWORD) dwInitialization, &dwActiveProtocol); |
(MYPCSC_DWORD) dwInitialization, &dwActiveProtocol); |
866 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
867 |
{ |
{ |
868 |
DEBUG_SCARD(("<--ERROR SCardReconnect Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardReconnect Code=0x%.8x, %s-->\n", (unsigned int) rv, |
869 |
|
pcsc_stringify_error(rv))); |
870 |
} |
} |
871 |
else |
else |
872 |
{ |
{ |
873 |
DEBUG_SCARD(("<--SUCCESS SCardReconnect-->\n")); |
DEBUG_SCARD(("<--SUCCESS SCardReconnect-->\n")); |
874 |
} |
} |
875 |
|
|
876 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
877 |
out_uint32_le(out, (SERVER_DWORD) dwActiveProtocol); |
out_uint32_le(out, (SERVER_DWORD) dwActiveProtocol); |
878 |
return rv; |
return rv; |
879 |
} |
} |
922 |
|
|
923 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
924 |
{ |
{ |
925 |
DEBUG_SCARD(("<--ERROR SCardDisconnect Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardDisconnect Code=0x%.8x, %s-->\n", (unsigned int) rv, |
926 |
|
pcsc_stringify_error(rv))); |
927 |
} |
} |
928 |
else |
else |
929 |
{ |
{ |
930 |
DEBUG_SCARD(("<--SUCCESS SCardDisconnect-->\n")); |
DEBUG_SCARD(("<--SUCCESS SCardDisconnect-->\n")); |
931 |
} |
} |
932 |
|
|
933 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
934 |
return rv; |
return rv; |
935 |
} |
} |
936 |
|
|
953 |
return recall; |
return recall; |
954 |
} |
} |
955 |
|
|
956 |
static BOOL |
static D_BOOL |
957 |
mappedStatus(MYPCSC_DWORD code) |
mappedStatus(MYPCSC_DWORD code) |
958 |
{ |
{ |
959 |
code >>= 16; |
code >>= 16; |
962 |
} |
} |
963 |
|
|
964 |
static MYPCSC_DWORD |
static MYPCSC_DWORD |
965 |
incStatus(MYPCSC_DWORD code, BOOL mapped) |
incStatus(MYPCSC_DWORD code, RD_BOOL mapped) |
966 |
{ |
{ |
967 |
if (mapped || (code & SCARD_STATE_CHANGED)) |
if (mapped || (code & SCARD_STATE_CHANGED)) |
968 |
{ |
{ |
1016 |
|
|
1017 |
|
|
1018 |
static MYPCSC_DWORD |
static MYPCSC_DWORD |
1019 |
TS_SCardGetStatusChange(STREAM in, STREAM out, BOOL wide) |
TS_SCardGetStatusChange(STREAM in, STREAM out, RD_BOOL wide) |
1020 |
{ |
{ |
1021 |
MYPCSC_DWORD rv; |
MYPCSC_DWORD rv; |
1022 |
SERVER_SCARDCONTEXT hContext; |
SERVER_SCARDCONTEXT hContext; |
1028 |
long i; |
long i; |
1029 |
PMEM_HANDLE lcHandle = NULL; |
PMEM_HANDLE lcHandle = NULL; |
1030 |
#if 0 |
#if 0 |
1031 |
BOOL mapped = False; |
RD_BOOL mapped = False; |
1032 |
#endif |
#endif |
1033 |
|
|
1034 |
in->p += 0x18; |
in->p += 0x18; |
1135 |
|
|
1136 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1137 |
{ |
{ |
1138 |
DEBUG_SCARD(("<--ERROR SCardGetStatusChange Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardGetStatusChange Code=0x%.8x, %s-->\n", |
1139 |
|
(unsigned int) rv, pcsc_stringify_error(rv))); |
1140 |
} |
} |
1141 |
else |
else |
1142 |
{ |
{ |
1188 |
out_uint8p(out, (void *) ((unsigned char **) cur + 2), |
out_uint8p(out, (void *) ((unsigned char **) cur + 2), |
1189 |
sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *)); |
sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *)); |
1190 |
} |
} |
1191 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1192 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
1193 |
return rv; |
return rv; |
1194 |
} |
} |
1206 |
rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext); |
rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext); |
1207 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1208 |
{ |
{ |
1209 |
DEBUG_SCARD(("<--ERROR SCardCancel Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardCancel Code=0x%.8x, %s-->\n", (unsigned int) rv, |
1210 |
|
pcsc_stringify_error(rv))); |
1211 |
} |
} |
1212 |
else |
else |
1213 |
{ |
{ |
1214 |
DEBUG_SCARD(("<--SUCCESS SCardCancel-->\n")); |
DEBUG_SCARD(("<--SUCCESS SCardCancel-->\n")); |
1215 |
} |
} |
1216 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1217 |
return rv; |
return rv; |
1218 |
} |
} |
1219 |
|
|
1220 |
static MYPCSC_DWORD |
static MYPCSC_DWORD |
1221 |
TS_SCardLocateCardsByATR(STREAM in, STREAM out, BOOL wide) |
TS_SCardLocateCardsByATR(STREAM in, STREAM out, RD_BOOL wide) |
1222 |
{ |
{ |
1223 |
int i, j, k; |
int i, j, k; |
1224 |
MYPCSC_DWORD rv; |
MYPCSC_DWORD rv; |
1276 |
copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount); |
copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount); |
1277 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1278 |
{ |
{ |
1279 |
DEBUG_SCARD(("<--ERROR SCardGetStatusChange (no SCardLocateCardsByATR) Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardGetStatusChange (no SCardLocateCardsByATR) Code=0x%.8x, %s-->\n", (unsigned int) rv, pcsc_stringify_error(rv))); |
1280 |
} |
} |
1281 |
else |
else |
1282 |
{ |
{ |
1286 |
{ |
{ |
1287 |
for (j = 0, rsCur = rsArray; j < readerCount; j++, rsCur++) |
for (j = 0, rsCur = rsArray; j < readerCount; j++, rsCur++) |
1288 |
{ |
{ |
1289 |
BOOL equal = 1; |
RD_BOOL equal = 1; |
1290 |
for (k = 0; k < cur->cbAtr; k++) |
for (k = 0; k < cur->cbAtr; k++) |
1291 |
{ |
{ |
1292 |
/* This line check if them equal */ |
/* This line check if them equal */ |
1318 |
sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *)); |
sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *)); |
1319 |
} |
} |
1320 |
|
|
1321 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1322 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
1323 |
return rv; |
return rv; |
1324 |
} |
} |
1338 |
rv = SCardBeginTransaction(myHCard); |
rv = SCardBeginTransaction(myHCard); |
1339 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1340 |
{ |
{ |
1341 |
DEBUG_SCARD(("<--ERROR SCardBeginTransaction Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardBeginTransaction Code=0x%.8x, %s-->\n", |
1342 |
|
(unsigned int) rv, pcsc_stringify_error(rv))); |
1343 |
} |
} |
1344 |
else |
else |
1345 |
{ |
{ |
1346 |
DEBUG_SCARD(("<--SUCCESS SCardBeginTransaction-->\n")); |
DEBUG_SCARD(("<--SUCCESS SCardBeginTransaction-->\n")); |
1347 |
} |
} |
1348 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1349 |
return rv; |
return rv; |
1350 |
} |
} |
1351 |
|
|
1370 |
rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition); |
rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition); |
1371 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1372 |
{ |
{ |
1373 |
DEBUG_SCARD(("<--ERROR SCardEndTransaction Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardEndTransaction Code=0x%.8x, %s-->\n", (unsigned int) rv, |
1374 |
|
pcsc_stringify_error(rv))); |
1375 |
} |
} |
1376 |
else |
else |
1377 |
{ |
{ |
1378 |
DEBUG_SCARD(("<--SUCCESS SCardEndTransaction-->\n")); |
DEBUG_SCARD(("<--SUCCESS SCardEndTransaction-->\n")); |
1379 |
} |
} |
1380 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1381 |
return rv; |
return rv; |
1382 |
} |
} |
1383 |
|
|
1580 |
|
|
1581 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1582 |
{ |
{ |
1583 |
DEBUG_SCARD(("<--ERROR SCardTransmit Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardTransmit Code=0x%.8x, %s-->\n", (unsigned int) rv, |
1584 |
|
pcsc_stringify_error(rv))); |
1585 |
} |
} |
1586 |
else |
else |
1587 |
{ |
{ |
1621 |
|
|
1622 |
outBufferFinish(out, (char *) recvBuf, cbRecvLength); |
outBufferFinish(out, (char *) recvBuf, cbRecvLength); |
1623 |
} |
} |
1624 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1625 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
1626 |
return rv; |
return rv; |
1627 |
} |
} |
1628 |
|
|
1629 |
static MYPCSC_DWORD |
static MYPCSC_DWORD |
1630 |
TS_SCardStatus(STREAM in, STREAM out, BOOL wide) |
TS_SCardStatus(STREAM in, STREAM out, RD_BOOL wide) |
1631 |
{ |
{ |
1632 |
MYPCSC_DWORD rv; |
MYPCSC_DWORD rv; |
1633 |
SERVER_SCARDCONTEXT hCard; |
SERVER_SCARDCONTEXT hCard; |
1678 |
|
|
1679 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1680 |
{ |
{ |
1681 |
DEBUG_SCARD(("<--ERROR SCardStatus Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardStatus Code=0x%.8x, %s-->\n", (unsigned int) rv, |
1682 |
|
pcsc_stringify_error(rv))); |
1683 |
return SC_returnCode(rv, &lcHandle, in, out); |
return SC_returnCode(rv, &lcHandle, in, out); |
1684 |
} |
} |
1685 |
else |
else |
1738 |
out_uint32_le(out, dataLength); |
out_uint32_le(out, dataLength); |
1739 |
out->p = psave; |
out->p = psave; |
1740 |
} |
} |
1741 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1742 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
1743 |
return rv; |
return rv; |
1744 |
} |
} |
1790 |
|
|
1791 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1792 |
{ |
{ |
1793 |
DEBUG_SCARD(("<--ERROR SCardStatus (no ScardState) Code=0x%.8x-->\n", |
DEBUG_SCARD(("<--ERROR SCardStatus (no ScardState) Code=0x%.8x, %s-->\n", |
1794 |
(unsigned int) rv)); |
(unsigned int) rv, pcsc_stringify_error(rv))); |
1795 |
return SC_returnCode(rv, &lcHandle, in, out); |
return SC_returnCode(rv, &lcHandle, in, out); |
1796 |
} |
} |
1797 |
else |
else |
1832 |
out_uint8p(out, atr, dwAtrLen); |
out_uint8p(out, atr, dwAtrLen); |
1833 |
outRepos(out, dwAtrLen); |
outRepos(out, dwAtrLen); |
1834 |
} |
} |
1835 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1836 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
1837 |
return rv; |
return rv; |
1838 |
} |
} |
1869 |
|
|
1870 |
if (rv) |
if (rv) |
1871 |
{ |
{ |
1872 |
DEBUG_SCARD(("<--ERROR SCardListReaderGroups Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardListReaderGroups Code=0x%.8x, %s-->\n", |
1873 |
|
(unsigned int) rv, pcsc_stringify_error(rv))); |
1874 |
return SC_returnCode(rv, &lcHandle, in, out); |
return SC_returnCode(rv, &lcHandle, in, out); |
1875 |
} |
} |
1876 |
else |
else |
1886 |
outRepos(out, dwGroups); |
outRepos(out, dwGroups); |
1887 |
out_uint32_le(out, 0x00000000); |
out_uint32_le(out, 0x00000000); |
1888 |
|
|
1889 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1890 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
1891 |
return rv; |
return rv; |
1892 |
} |
} |
1961 |
|
|
1962 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
1963 |
{ |
{ |
1964 |
DEBUG_SCARD(("<--ERROR SCardGetAttrib Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardGetAttrib Code=0x%.8x, %s-->\n", (unsigned int) rv, |
1965 |
|
pcsc_stringify_error(rv))); |
1966 |
return SC_returnCode(rv, &lcHandle, in, out); |
return SC_returnCode(rv, &lcHandle, in, out); |
1967 |
} |
} |
1968 |
else |
else |
1988 |
outRepos(out, dwAttrLen); |
outRepos(out, dwAttrLen); |
1989 |
out_uint32_le(out, 0x00000000); |
out_uint32_le(out, 0x00000000); |
1990 |
} |
} |
1991 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
1992 |
return rv; |
return rv; |
1993 |
} |
} |
1994 |
|
|
2030 |
|
|
2031 |
if (rv) |
if (rv) |
2032 |
{ |
{ |
2033 |
DEBUG_SCARD(("<--ERROR SCardSetAttrib Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardSetAttrib Code=0x%.8x, %s-->\n", (unsigned int) rv, |
2034 |
|
pcsc_stringify_error(rv))); |
2035 |
} |
} |
2036 |
else |
else |
2037 |
{ |
{ |
2042 |
out_uint32_le(out, 0x00000200); |
out_uint32_le(out, 0x00000200); |
2043 |
out_uint32_le(out, 0x00000000); |
out_uint32_le(out, 0x00000000); |
2044 |
out_uint32_le(out, 0x00000000); |
out_uint32_le(out, 0x00000000); |
2045 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
2046 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
2047 |
return rv; |
return rv; |
2048 |
} |
} |
2134 |
#ifdef WITH_DEBUG_SCARD |
#ifdef WITH_DEBUG_SCARD |
2135 |
if (rv != SCARD_S_SUCCESS) |
if (rv != SCARD_S_SUCCESS) |
2136 |
{ |
{ |
2137 |
DEBUG_SCARD(("<--ERROR SCardControl Code=0x%.8x-->\n", (unsigned int) rv)); |
DEBUG_SCARD(("<--ERROR SCardControl Code=0x%.8x, %s-->\n", (unsigned int) rv, |
2138 |
|
pcsc_stringify_error(rv))); |
2139 |
} |
} |
2140 |
else |
else |
2141 |
{ |
{ |
2156 |
outRepos(out, nBytesReturned); |
outRepos(out, nBytesReturned); |
2157 |
} |
} |
2158 |
|
|
2159 |
outForceAlignment(out, 16); |
outForceAlignment(out, 8); |
2160 |
SC_xfreeallmemory(&lcHandle); |
SC_xfreeallmemory(&lcHandle); |
2161 |
return rv; |
return rv; |
2162 |
} |
} |
2169 |
} |
} |
2170 |
|
|
2171 |
|
|
2172 |
static NTSTATUS |
static RD_NTSTATUS |
2173 |
scard_device_control(NTHANDLE handle, uint32 request, STREAM in, STREAM out) |
scard_device_control(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out) |
2174 |
{ |
{ |
2175 |
SERVER_DWORD Result = 0x00000000; |
SERVER_DWORD Result = 0x00000000; |
2176 |
unsigned char *psize, *pend, *pStatusCode; |
unsigned char *psize, *pend, *pStatusCode; |
2221 |
case SC_LIST_READERS: /* SCardListReadersA */ |
case SC_LIST_READERS: /* SCardListReadersA */ |
2222 |
case SC_LIST_READERS + 4: /* SCardListReadersW */ |
case SC_LIST_READERS + 4: /* SCardListReadersW */ |
2223 |
{ |
{ |
2224 |
BOOL wide = request != SC_LIST_READERS; |
D_BOOL wide = request != SC_LIST_READERS; |
2225 |
DEBUG_SCARD(("<---SCardListReaders---> (%s)\n", |
DEBUG_SCARD(("<---SCardListReaders---> (%s)\n", |
2226 |
(wide) ? ("WIDE") : ("ASCII"))); |
(wide) ? ("WIDE") : ("ASCII"))); |
2227 |
Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide); |
Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide); |
2231 |
case SC_CONNECT: /* ScardConnectA */ |
case SC_CONNECT: /* ScardConnectA */ |
2232 |
case SC_CONNECT + 4: /* SCardConnectW */ |
case SC_CONNECT + 4: /* SCardConnectW */ |
2233 |
{ |
{ |
2234 |
BOOL wide = request != SC_CONNECT; |
RD_BOOL wide = request != SC_CONNECT; |
2235 |
DEBUG_SCARD(("<---SCardConnect---> (%s)\n", |
DEBUG_SCARD(("<---SCardConnect---> (%s)\n", |
2236 |
(wide) ? ("WIDE") : ("ASCII"))); |
(wide) ? ("WIDE") : ("ASCII"))); |
2237 |
Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide); |
Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide); |
2255 |
case SC_GET_STATUS_CHANGE: /* SCardGetStatusChangeA */ |
case SC_GET_STATUS_CHANGE: /* SCardGetStatusChangeA */ |
2256 |
case SC_GET_STATUS_CHANGE + 4: /* SCardGetStatusChangeW */ |
case SC_GET_STATUS_CHANGE + 4: /* SCardGetStatusChangeW */ |
2257 |
{ |
{ |
2258 |
BOOL wide = request != SC_GET_STATUS_CHANGE; |
RD_BOOL wide = request != SC_GET_STATUS_CHANGE; |
2259 |
DEBUG_SCARD(("<---SCardGetStatusChange---> (%s)\n", |
DEBUG_SCARD(("<---SCardGetStatusChange---> (%s)\n", |
2260 |
(wide) ? ("WIDE") : ("ASCII"))); |
(wide) ? ("WIDE") : ("ASCII"))); |
2261 |
Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide); |
Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide); |
2272 |
case SC_LOCATE_CARDS_BY_ATR: /* SCardLocateCardsByATRA */ |
case SC_LOCATE_CARDS_BY_ATR: /* SCardLocateCardsByATRA */ |
2273 |
case SC_LOCATE_CARDS_BY_ATR + 4: /* SCardLocateCardsByATRW */ |
case SC_LOCATE_CARDS_BY_ATR + 4: /* SCardLocateCardsByATRW */ |
2274 |
{ |
{ |
2275 |
BOOL wide = request != SC_LOCATE_CARDS_BY_ATR; |
RD_BOOL wide = request != SC_LOCATE_CARDS_BY_ATR; |
2276 |
DEBUG_SCARD(("<---SCardLocateCardsByATR---> (%s)\n", |
DEBUG_SCARD(("<---SCardLocateCardsByATR---> (%s)\n", |
2277 |
(wide) ? ("WIDE") : ("ASCII"))); |
(wide) ? ("WIDE") : ("ASCII"))); |
2278 |
Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide); |
Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide); |
2324 |
case SC_STATUS: /* SCardStatusA */ |
case SC_STATUS: /* SCardStatusA */ |
2325 |
case SC_STATUS + 4: /* SCardStatusW */ |
case SC_STATUS + 4: /* SCardStatusW */ |
2326 |
{ |
{ |
2327 |
BOOL wide = request != SC_STATUS; |
RD_BOOL wide = request != SC_STATUS; |
2328 |
DEBUG_SCARD(("<---SCardStatus---> (%s)\n", |
DEBUG_SCARD(("<---SCardStatus---> (%s)\n", |
2329 |
(wide) ? ("WIDE") : ("ASCII"))); |
(wide) ? ("WIDE") : ("ASCII"))); |
2330 |
Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide); |
Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide); |
2370 |
hexdump(pbeg, (size_t) (out->p) - (size_t) pbeg); |
hexdump(pbeg, (size_t) (out->p) - (size_t) pbeg); |
2371 |
DEBUG_SCARD(("--------------------------------\n")); |
DEBUG_SCARD(("--------------------------------\n")); |
2372 |
#endif |
#endif |
2373 |
return STATUS_SUCCESS; |
return RD_STATUS_SUCCESS; |
2374 |
} |
} |
2375 |
|
|
2376 |
/* Thread functions */ |
/* Thread functions */ |
2377 |
|
|
2378 |
static STREAM |
static STREAM |
2379 |
duplicateStream(PMEM_HANDLE * handle, STREAM s, uint32 buffer_size, BOOL isInputStream) |
duplicateStream(PMEM_HANDLE * handle, STREAM s, uint32 buffer_size, RD_BOOL isInputStream) |
2380 |
{ |
{ |
2381 |
STREAM d = SC_xmalloc(handle, sizeof(struct stream)); |
STREAM d = SC_xmalloc(handle, sizeof(struct stream)); |
2382 |
if (d != NULL) |
if (d != NULL) |
2425 |
} |
} |
2426 |
|
|
2427 |
static PSCThreadData |
static PSCThreadData |
2428 |
SC_addToQueue(NTHANDLE handle, uint32 request, STREAM in, STREAM out) |
SC_addToQueue(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out) |
2429 |
{ |
{ |
2430 |
PMEM_HANDLE lcHandle = NULL; |
PMEM_HANDLE lcHandle = NULL; |
2431 |
PSCThreadData data = SC_xmalloc(&lcHandle, sizeof(TSCThreadData)); |
PSCThreadData data = SC_xmalloc(&lcHandle, sizeof(TSCThreadData)); |
2505 |
size_t buffer_len = 0; |
size_t buffer_len = 0; |
2506 |
scard_device_control(data->handle, data->request, data->in, data->out); |
scard_device_control(data->handle, data->request, data->in, data->out); |
2507 |
buffer_len = (size_t) data->out->p - (size_t) data->out->data; |
buffer_len = (size_t) data->out->p - (size_t) data->out->data; |
|
#if 0 |
|
|
pthread_mutex_lock(&sendControl); |
|
|
#endif |
|
2508 |
rdpdr_send_completion(data->device, data->id, 0, buffer_len, data->out->data, buffer_len); |
rdpdr_send_completion(data->device, data->id, 0, buffer_len, data->out->data, buffer_len); |
|
#if 0 |
|
|
pthread_mutex_unlock(&sendControl); |
|
|
#endif |
|
2509 |
SC_destroyThreadData(data); |
SC_destroyThreadData(data); |
2510 |
} |
} |
2511 |
|
|
2615 |
return NULL; |
return NULL; |
2616 |
} |
} |
2617 |
|
|
2618 |
static NTSTATUS |
static RD_NTSTATUS |
2619 |
thread_wrapper(NTHANDLE handle, uint32 request, STREAM in, STREAM out) |
thread_wrapper(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out) |
2620 |
{ |
{ |
2621 |
if (SC_addToQueue(handle, request, in, out)) |
if (SC_addToQueue(handle, request, in, out)) |
2622 |
return STATUS_PENDING | 0xC0000000; |
return RD_STATUS_PENDING | 0xC0000000; |
2623 |
else |
else |
2624 |
return STATUS_NO_SUCH_FILE; |
return RD_STATUS_NO_SUCH_FILE; |
2625 |
} |
} |
2626 |
|
|
2627 |
DEVICE_FNS scard_fns = { |
DEVICE_FNS scard_fns = { |
2634 |
#endif /* MAKE_PROTO */ |
#endif /* MAKE_PROTO */ |
2635 |
|
|
2636 |
void |
void |
2637 |
scard_tcp_lock(void) |
scard_lock(int lock) |
2638 |
{ |
{ |
2639 |
if (!tcp_sendcontrol_mutex) |
if (!scard_mutex) |
2640 |
|
{ |
2641 |
|
int i; |
2642 |
|
|
2643 |
|
scard_mutex = |
2644 |
|
(pthread_mutex_t **) xmalloc(sizeof(pthread_mutex_t *) * SCARD_LOCK_LAST); |
2645 |
|
|
2646 |
|
for (i = 0; i < SCARD_LOCK_LAST; i++) |
2647 |
|
{ |
2648 |
|
scard_mutex[i] = NULL; |
2649 |
|
} |
2650 |
|
} |
2651 |
|
|
2652 |
|
if (!scard_mutex[lock]) |
2653 |
{ |
{ |
2654 |
tcp_sendcontrol_mutex = (pthread_mutex_t *) xmalloc(sizeof(pthread_mutex_t)); |
scard_mutex[lock] = (pthread_mutex_t *) xmalloc(sizeof(pthread_mutex_t)); |
2655 |
pthread_mutex_init(tcp_sendcontrol_mutex, NULL); |
pthread_mutex_init(scard_mutex[lock], NULL); |
2656 |
} |
} |
2657 |
|
|
2658 |
pthread_mutex_lock(tcp_sendcontrol_mutex); |
pthread_mutex_lock(scard_mutex[lock]); |
2659 |
} |
} |
2660 |
|
|
2661 |
void |
void |
2662 |
scard_tcp_unlock(void) |
scard_unlock(int lock) |
2663 |
{ |
{ |
2664 |
pthread_mutex_unlock(tcp_sendcontrol_mutex); |
pthread_mutex_unlock(scard_mutex[lock]); |
2665 |
} |
} |
2666 |
|
|
2667 |
STREAM |
STREAM |