/[rdesktop]/sourceforge.net/trunk/rdesktop/scard.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/rdesktop/scard.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1320 by stargo, Thu Nov 2 21:32:56 2006 UTC revision 1372 by jsorg71, Mon Jan 8 04:47:06 2007 UTC
# Line 19  Line 19 
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>
# Line 27  Line 26 
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 */
# Line 44  Line 46 
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;
# Line 54  static pthread_t queueHandler; Line 56  static pthread_t queueHandler;
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;
# Line 80  scardSetInfo(uint32 device, uint32 id, u Line 81  scardSetInfo(uint32 device, uint32 id, u
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    
# Line 152  scard_enum_devices(uint32 * id, char *op Line 153  scard_enum_devices(uint32 * id, char *op
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          {          {
# Line 233  scard_enum_devices(uint32 * id, char *op Line 225  scard_enum_devices(uint32 * id, char *op
225                  }                  }
226          }          }
227    
   
         printf("******************************************************\n");  
         printf("* Smart Card support for RDesktop is initialized.    *\n");  
         printf("* Copyright (C) by Alexi Volkov, alexi@myrealbox.com *\n");  
         printf("******************************************************\n");  
   
228          return count;          return count;
229  }  }
230    
# Line 497  outBufferFinish(STREAM out, char *buffer Line 483  outBufferFinish(STREAM out, char *buffer
483  }  }
484    
485  static void  static void
486  outForceAllignment(STREAM out, unsigned int seed)  outForceAlignment(STREAM out, unsigned int seed)
487  {  {
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);
         }  
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;
# Line 541  inString(PMEM_HANDLE * handle, STREAM in Line 525  inString(PMEM_HANDLE * handle, STREAM in
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);
# Line 575  outString(STREAM out, char *source, BOOL Line 559  outString(STREAM out, char *source, BOOL
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;
# Line 624  TS_SCardEstablishContext(STREAM in, STRE Line 608  TS_SCardEstablishContext(STREAM in, STRE
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          {          {
# Line 654  TS_SCardReleaseContext(STREAM in, STREAM Line 638  TS_SCardReleaseContext(STREAM in, STREAM
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          {          {
# Line 687  TS_SCardIsValidContext(STREAM in, STREAM Line 672  TS_SCardIsValidContext(STREAM in, STREAM
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
# Line 696  TS_SCardIsValidContext(STREAM in, STREAM Line 680  TS_SCardIsValidContext(STREAM in, STREAM
680                  DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n"));                  DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n"));
681          }          }
682    
683          outForceAllignment(out, 8);          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;
# Line 769  TS_SCardListReaders(STREAM in, STREAM ou Line 753  TS_SCardListReaders(STREAM in, STREAM ou
753          out_uint32_le(out, dataLength);          out_uint32_le(out, dataLength);
754          out->p = pend;          out->p = pend;
755    
756          outForceAllignment(out, 8);          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;
# Line 806  TS_SCardConnect(STREAM in, STREAM out, B Line 790  TS_SCardConnect(STREAM in, STREAM out, B
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          {          {
# Line 844  TS_SCardConnect(STREAM in, STREAM out, B Line 829  TS_SCardConnect(STREAM in, STREAM out, B
829          out_uint32_le(out, 0x00000004);          out_uint32_le(out, 0x00000004);
830          out_uint32_le(out, hCard);          out_uint32_le(out, hCard);
831    
832          outForceAllignment(out, 8);          outForceAlignment(out, 8);
833          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
834          return rv;          return rv;
835  }  }
# Line 880  TS_SCardReconnect(STREAM in, STREAM out) Line 865  TS_SCardReconnect(STREAM in, STREAM out)
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          outForceAllignment(out, 8);          outForceAlignment(out, 8);
877          out_uint32_le(out, (SERVER_DWORD) dwActiveProtocol);          out_uint32_le(out, (SERVER_DWORD) dwActiveProtocol);
878          return rv;          return rv;
879  }  }
# Line 936  TS_SCardDisconnect(STREAM in, STREAM out Line 922  TS_SCardDisconnect(STREAM in, STREAM out
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          outForceAllignment(out, 8);          outForceAlignment(out, 8);
934          return rv;          return rv;
935  }  }
936    
# Line 966  needStatusRecheck(MYPCSC_DWORD rv, MYPCS Line 953  needStatusRecheck(MYPCSC_DWORD rv, MYPCS
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;
# Line 975  mappedStatus(MYPCSC_DWORD code) Line 962  mappedStatus(MYPCSC_DWORD code)
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          {          {
# Line 1029  copyReaderState_ServerToMyPCSC(SERVER_LP Line 1016  copyReaderState_ServerToMyPCSC(SERVER_LP
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;
# Line 1041  TS_SCardGetStatusChange(STREAM in, STREA Line 1028  TS_SCardGetStatusChange(STREAM in, STREA
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;
# Line 1148  TS_SCardGetStatusChange(STREAM in, STREA Line 1135  TS_SCardGetStatusChange(STREAM in, STREA
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          {          {
# Line 1200  TS_SCardGetStatusChange(STREAM in, STREA Line 1188  TS_SCardGetStatusChange(STREAM in, STREA
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          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1192          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
1193          return rv;          return rv;
1194  }  }
# Line 1218  TS_SCardCancel(STREAM in, STREAM out) Line 1206  TS_SCardCancel(STREAM in, STREAM out)
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          outForceAllignment(out, 8);          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;
# Line 1287  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1276  TS_SCardLocateCardsByATR(STREAM in, STRE
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          {          {
# Line 1297  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1286  TS_SCardLocateCardsByATR(STREAM in, STRE
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 */
# Line 1329  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1318  TS_SCardLocateCardsByATR(STREAM in, STRE
1318                             sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));                             sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));
1319          }          }
1320    
1321          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1322          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
1323          return rv;          return rv;
1324  }  }
# Line 1349  TS_SCardBeginTransaction(STREAM in, STRE Line 1338  TS_SCardBeginTransaction(STREAM in, STRE
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          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1349          return rv;          return rv;
1350  }  }
1351    
# Line 1380  TS_SCardEndTransaction(STREAM in, STREAM Line 1370  TS_SCardEndTransaction(STREAM in, STREAM
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          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1381          return rv;          return rv;
1382  }  }
1383    
# Line 1589  TS_SCardTransmit(STREAM in, STREAM out) Line 1580  TS_SCardTransmit(STREAM in, STREAM out)
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          {          {
# Line 1629  TS_SCardTransmit(STREAM in, STREAM out) Line 1621  TS_SCardTransmit(STREAM in, STREAM out)
1621    
1622                  outBufferFinish(out, (char *) recvBuf, cbRecvLength);                  outBufferFinish(out, (char *) recvBuf, cbRecvLength);
1623          }          }
1624          outForceAllignment(out, 8);          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;
# Line 1686  TS_SCardStatus(STREAM in, STREAM out, BO Line 1678  TS_SCardStatus(STREAM in, STREAM out, BO
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
# Line 1745  TS_SCardStatus(STREAM in, STREAM out, BO Line 1738  TS_SCardStatus(STREAM in, STREAM out, BO
1738                  out_uint32_le(out, dataLength);                  out_uint32_le(out, dataLength);
1739                  out->p = psave;                  out->p = psave;
1740          }          }
1741          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1742          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
1743          return rv;          return rv;
1744  }  }
# Line 1797  TS_SCardState(STREAM in, STREAM out) Line 1790  TS_SCardState(STREAM in, STREAM out)
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
# Line 1839  TS_SCardState(STREAM in, STREAM out) Line 1832  TS_SCardState(STREAM in, STREAM out)
1832                  out_uint8p(out, atr, dwAtrLen);                  out_uint8p(out, atr, dwAtrLen);
1833                  outRepos(out, dwAtrLen);                  outRepos(out, dwAtrLen);
1834          }          }
1835          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1836          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
1837          return rv;          return rv;
1838  }  }
# Line 1876  TS_SCardListReaderGroups(STREAM in, STRE Line 1869  TS_SCardListReaderGroups(STREAM in, STRE
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
# Line 1892  TS_SCardListReaderGroups(STREAM in, STRE Line 1886  TS_SCardListReaderGroups(STREAM in, STRE
1886          outRepos(out, dwGroups);          outRepos(out, dwGroups);
1887          out_uint32_le(out, 0x00000000);          out_uint32_le(out, 0x00000000);
1888    
1889          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1890          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
1891          return rv;          return rv;
1892  }  }
# Line 1967  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1961  TS_SCardGetAttrib(STREAM in, STREAM out)
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
# Line 1993  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1988  TS_SCardGetAttrib(STREAM in, STREAM out)
1988                  outRepos(out, dwAttrLen);                  outRepos(out, dwAttrLen);
1989                  out_uint32_le(out, 0x00000000);                  out_uint32_le(out, 0x00000000);
1990          }          }
1991          outForceAllignment(out, 8);          outForceAlignment(out, 8);
1992          return rv;          return rv;
1993  }  }
1994    
# Line 2035  TS_SCardSetAttrib(STREAM in, STREAM out) Line 2030  TS_SCardSetAttrib(STREAM in, STREAM out)
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          {          {
# Line 2046  TS_SCardSetAttrib(STREAM in, STREAM out) Line 2042  TS_SCardSetAttrib(STREAM in, STREAM out)
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          outForceAllignment(out, 8);          outForceAlignment(out, 8);
2046          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
2047          return rv;          return rv;
2048  }  }
# Line 2138  TS_SCardControl(STREAM in, STREAM out) Line 2134  TS_SCardControl(STREAM in, STREAM out)
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          {          {
# Line 2159  TS_SCardControl(STREAM in, STREAM out) Line 2156  TS_SCardControl(STREAM in, STREAM out)
2156                  outRepos(out, nBytesReturned);                  outRepos(out, nBytesReturned);
2157          }          }
2158    
2159          outForceAllignment(out, 8);          outForceAlignment(out, 8);
2160          SC_xfreeallmemory(&lcHandle);          SC_xfreeallmemory(&lcHandle);
2161          return rv;          return rv;
2162  }  }
# Line 2172  TS_SCardAccessStartedEvent(STREAM in, ST Line 2169  TS_SCardAccessStartedEvent(STREAM in, ST
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;
# Line 2224  scard_device_control(NTHANDLE handle, ui Line 2221  scard_device_control(NTHANDLE handle, ui
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);
# Line 2234  scard_device_control(NTHANDLE handle, ui Line 2231  scard_device_control(NTHANDLE handle, ui
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);
# Line 2258  scard_device_control(NTHANDLE handle, ui Line 2255  scard_device_control(NTHANDLE handle, ui
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);
# Line 2275  scard_device_control(NTHANDLE handle, ui Line 2272  scard_device_control(NTHANDLE handle, ui
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);
# Line 2327  scard_device_control(NTHANDLE handle, ui Line 2324  scard_device_control(NTHANDLE handle, ui
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);
# Line 2373  scard_device_control(NTHANDLE handle, ui Line 2370  scard_device_control(NTHANDLE handle, ui
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)
# Line 2428  freeStream(PMEM_HANDLE * handle, STREAM Line 2425  freeStream(PMEM_HANDLE * handle, STREAM
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));
# Line 2508  SC_deviceControl(PSCThreadData data) Line 2505  SC_deviceControl(PSCThreadData data)
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    
# Line 2624  queue_handler_function(void *data) Line 2615  queue_handler_function(void *data)
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 = {
# Line 2643  DEVICE_FNS scard_fns = { Line 2634  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
Legend:
Removed from v.1320  
changed lines
  Added in v.1372
  ViewVC Help
Powered by ViewVC 1.1.26