/[rdesktop]/jpeg/rdesktop/trunk/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 /jpeg/rdesktop/trunk/scard.c

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

sourceforge.net/trunk/rdesktop/scard.c revision 1329 by stargo, Sat Nov 4 17:33:15 2006 UTC jpeg/rdesktop/trunk/scard.c revision 1507 by dpavlin, Mon Jul 20 16:45:11 2009 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>
25  #include <sys/types.h>  #include <sys/types.h>
26  #include <time.h>  #include <time.h>
27  #ifndef MAKE_PROTO  #ifndef MAKE_PROTO
28  #ifdef PCSC_OSX  #ifdef __APPLE__
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 40  Line 42 
42  #define SCARD_MAX_MEM 102400  #define SCARD_MAX_MEM 102400
43  #define SCARD_AUTOALLOCATE -1  #define SCARD_AUTOALLOCATE -1
44  #define OUT_STREAM_SIZE 4096  #define OUT_STREAM_SIZE 4096
 #define STREAM_COUNT 8  
45    
46  static struct stream out[STREAM_COUNT];  #ifdef B_ENDIAN
47  static int cur_stream_id = 0;  #define swap32(x)       ((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) | \
48                            (((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24))
49    
50    #define swap16(x)       ((((x) & 0xff) << 8) | (((x) & 0xff00) >> 8))
51    #else
52    #define swap32(x)       (x)
53    #define swap16(x)       (x)
54    #endif
55    
56  static pthread_mutex_t **scard_mutex = NULL;  static pthread_mutex_t **scard_mutex = NULL;
57    
58  static uint32 curDevice = 0, curId = 0, curBytesOut = 0;  static uint32 curDevice = 0, curId = 0, curBytesOut = 0;
# Line 52  static int nameMapCount = 0; Line 61  static int nameMapCount = 0;
61    
62  static pthread_t queueHandler;  static pthread_t queueHandler;
63  static pthread_mutex_t queueAccess;  static pthread_mutex_t queueAccess;
64  static pthread_mutex_t queueEmpty;  static pthread_cond_t queueEmpty;
65  static pthread_mutex_t hcardAccess;  static pthread_mutex_t hcardAccess;
66    
67  static PMEM_HANDLE threadListHandle = NULL;  static PMEM_HANDLE threadListHandle = NULL;
# Line 79  scardSetInfo(uint32 device, uint32 id, u Line 88  scardSetInfo(uint32 device, uint32 id, u
88    
89  #ifndef MAKE_PROTO  #ifndef MAKE_PROTO
90    
91  static NTSTATUS  static RD_NTSTATUS
92  scard_create(uint32 device_id, uint32 accessmask, uint32 sharemode, uint32 create_disposition,  scard_create(uint32 device_id, uint32 accessmask, uint32 sharemode, uint32 create_disposition,
93               uint32 flags_and_attributes, char *filename, NTHANDLE * phandle)               uint32 flags_and_attributes, char *filename, RD_NTHANDLE * phandle)
94  {  {
95          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
96  }  }
97    
98  static NTSTATUS  static RD_NTSTATUS
99  scard_close(NTHANDLE handle)  scard_close(RD_NTHANDLE handle)
100  {  {
101          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
102  }  }
103    
104  static NTSTATUS  static RD_NTSTATUS
105  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)
106  {  {
107          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
108  }  }
109    
110  static NTSTATUS  static RD_NTSTATUS
111  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)
112  {  {
113          return STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
114  }  }
115  #endif /* MAKE_PROTO */  #endif /* MAKE_PROTO */
116    
# Line 125  scard_enum_devices(uint32 * id, char *op Line 134  scard_enum_devices(uint32 * id, char *op
134          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
135          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
136          {          {
137                  error("[SMART CARD: PCSC service not available]\n");                  error("scard_enum_devices: PCSC service not available\n");
138                  return 0;                  return 0;
139          }          }
140          else          else
# Line 135  scard_enum_devices(uint32 * id, char *op Line 144  scard_enum_devices(uint32 * id, char *op
144    
145          if (0 != pthread_mutex_init(&queueAccess, NULL))          if (0 != pthread_mutex_init(&queueAccess, NULL))
146          {          {
147                  error("[SMART CARD: Can't initialize queue access mutex]\n");                  error("scard_enum_devices: Can't initialize queue access mutex\n");
148                  return 0;                  return 0;
149          }          }
150    
151          if (0 != pthread_mutex_init(&queueEmpty, NULL))          if (0 != pthread_cond_init(&queueEmpty, NULL))
152          {          {
153                  error("[SMART CARD: Can't initialize queue control mutex]\n");                  error("scard_enum_devices: Can't initialize queue control cv\n");
154                  return 0;                  return 0;
155          }          }
156    
157          if (0 != pthread_mutex_init(&hcardAccess, NULL))          if (0 != pthread_mutex_init(&hcardAccess, NULL))
158          {          {
159                  error("[SMART CARD: Can't initialize hcard list access mutex]\n");                  error("scard_enum_devices: Can't initialize hcard list access mutex\n");
160                  return 0;                  return 0;
161          }          }
162    
163          if (0 !=          if (0 !=
164              pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL))              pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL))
165          {          {
166                  error("[SMART CARD: Can't create queue handling Thread]\n");                  error("scard_enum_devices: Can't create queue handling Thread\n");
167                  return 0;                  return 0;
168          }          }
169    
# Line 489  outForceAlignment(STREAM out, unsigned i Line 498  outForceAlignment(STREAM out, unsigned i
498  }  }
499    
500  static unsigned int  static unsigned int
501  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)
502  {  {
503          unsigned int Result = (wide) ? (2 * dataLength) : (dataLength);          unsigned int Result = (wide) ? (2 * dataLength) : (dataLength);
504          PMEM_HANDLE lcHandle = NULL;          PMEM_HANDLE lcHandle = NULL;
# Line 523  inString(PMEM_HANDLE * handle, STREAM in Line 532  inString(PMEM_HANDLE * handle, STREAM in
532  }  }
533    
534  static unsigned int  static unsigned int
535  outString(STREAM out, char *source, BOOL wide)  outString(STREAM out, char *source, RD_BOOL wide)
536  {  {
537          PMEM_HANDLE lcHandle = NULL;          PMEM_HANDLE lcHandle = NULL;
538          char *reader = getAlias(source);          char *reader = getAlias(source);
# Line 557  outString(STREAM out, char *source, BOOL Line 566  outString(STREAM out, char *source, BOOL
566  }  }
567    
568  static void  static void
569  inReaderName(PMEM_HANDLE * handle, STREAM in, char **destination, BOOL wide)  inReaderName(PMEM_HANDLE * handle, STREAM in, char **destination, RD_BOOL wide)
570  {  {
571          SERVER_DWORD dataLength;          SERVER_DWORD dataLength;
572          in->p += 0x08;          in->p += 0x08;
# Line 602  TS_SCardEstablishContext(STREAM in, STRE Line 611  TS_SCardEstablishContext(STREAM in, STRE
611          MYPCSC_SCARDCONTEXT hContext;          MYPCSC_SCARDCONTEXT hContext;
612          /* code segment  */          /* code segment  */
613    
614          DEBUG_SCARD(("Establishing PC/SC Context... \n"));          DEBUG_SCARD(("SCARD: SCardEstablishContext()\n"));
615          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
616          if (rv)          if (rv)
617          {          {
618                  DEBUG_SCARD(("<--ERROR SCardEstablishContext Code=0x%.8x]-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
619                               (unsigned int) rv));                               pcsc_stringify_error(rv), (unsigned int) rv));
620          }          }
621          else          else
622          {          {
623                  DEBUG_SCARD(("<--SUCCESS SCardEstablishContext-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (context: 0x%08lx)\n", hContext));
624          }          }
625    
626          out_uint32_le(out, 0x00000004);          out_uint32_le(out, 0x00000004);
# Line 630  TS_SCardReleaseContext(STREAM in, STREAM Line 639  TS_SCardReleaseContext(STREAM in, STREAM
639    
640          in->p += 0x1C;          in->p += 0x1C;
641          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
642          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardReleaseContext(context: 0x%08x)\n", (unsigned) hContext));
         DEBUG_SCARD(("Releasing context... \n"));  
643          rv = SCardReleaseContext((MYPCSC_SCARDCONTEXT) hContext);          rv = SCardReleaseContext((MYPCSC_SCARDCONTEXT) hContext);
644    
645          if (rv)          if (rv)
646          {          {
647                  DEBUG_SCARD(("<--ERROR SCardReleaseContext Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
648                                 pcsc_stringify_error(rv), (unsigned int) rv));
649          }          }
650          else          else
651          {          {
652                  DEBUG_SCARD(("<--SUCCESS SCardReleaseContext-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
653          }          }
654    
655          return rv;          return rv;
# Line 657  TS_SCardIsValidContext(STREAM in, STREAM Line 666  TS_SCardIsValidContext(STREAM in, STREAM
666    
667          in->p += 0x1C;          in->p += 0x1C;
668          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
669          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardIsValidContext(context: 0x%08x)\n", (unsigned) hContext));
         DEBUG_SCARD(("Checking... \n"));  
670          /* There is no realization of SCardIsValidContext in PC/SC Lite so we call SCardListReaders */          /* There is no realization of SCardIsValidContext in PC/SC Lite so we call SCardListReaders */
671    
672          readers = SC_xmalloc(&lcHandle, 1024);          readers = SC_xmalloc(&lcHandle, 1024);
# Line 669  TS_SCardIsValidContext(STREAM in, STREAM Line 677  TS_SCardIsValidContext(STREAM in, STREAM
677    
678          if (rv)          if (rv)
679          {          {
680                  DEBUG_SCARD(("<--ERROR SCardListReaders (no SCardIsValidContext) Code=0x%.8x-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
681                               (unsigned int) rv));                               pcsc_stringify_error(rv), (unsigned int) rv));
682                  rv = SCARD_E_INVALID_HANDLE;                  rv = SCARD_E_INVALID_HANDLE;
683          }          }
684          else          else
685          {          {
686                  DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
687          }          }
688    
689          outForceAlignment(out, 8);          outForceAlignment(out, 8);
# Line 685  TS_SCardIsValidContext(STREAM in, STREAM Line 693  TS_SCardIsValidContext(STREAM in, STREAM
693    
694    
695  static MYPCSC_DWORD  static MYPCSC_DWORD
696  TS_SCardListReaders(STREAM in, STREAM out, BOOL wide)  TS_SCardListReaders(STREAM in, STREAM out, RD_BOOL wide)
697  {  {
698  #define readerArraySize 1024  #define readerArraySize 1024
699          MYPCSC_DWORD rv;          MYPCSC_DWORD rv;
# Line 698  TS_SCardListReaders(STREAM in, STREAM ou Line 706  TS_SCardListReaders(STREAM in, STREAM ou
706    
707          in->p += 0x2C;          in->p += 0x2C;
708          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
709          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardListReaders(context: 0x%08x)\n", (unsigned) hContext));
710          plen1 = out->p;          plen1 = out->p;
711          out_uint32_le(out, 0x00000000); /* Temp value for data length as 0x0 */          out_uint32_le(out, 0x00000000); /* Temp value for data length as 0x0 */
712          out_uint32_le(out, 0x01760650);          out_uint32_le(out, 0x01760650);
# Line 715  TS_SCardListReaders(STREAM in, STREAM ou Line 723  TS_SCardListReaders(STREAM in, STREAM ou
723          readers[1] = '\0';          readers[1] = '\0';
724          rv = SCardListReaders((MYPCSC_SCARDCONTEXT) hContext, NULL, readers, &cchReaders);          rv = SCardListReaders((MYPCSC_SCARDCONTEXT) hContext, NULL, readers, &cchReaders);
725          cur = readers;          cur = readers;
726          if (!rv)          if (rv != SCARD_S_SUCCESS)
727            {
728                    DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
729                                 pcsc_stringify_error(rv), (unsigned int) rv));
730            }
731            else
732          {          {
733                  int i;                  int i;
734                  PSCNameMapRec tmpMap;                  PSCNameMapRec tmpMap;
735  #ifdef WITH_DEBUG_SCARD                  DEBUG_SCARD(("SCARD: -> Success\n"));
                 DEBUG_SCARD(("[CALL RESULT of SCardListReaders 0x%.8x]\n", (unsigned int) rv));  
                 hexdump((void *) readers, cchReaders);  
 #endif  
736                  for (i = 0, tmpMap = nameMapList; i < nameMapCount; i++, tmpMap++)                  for (i = 0, tmpMap = nameMapList; i < nameMapCount; i++, tmpMap++)
737                  {                  {
738                          dataLength += outString(out, tmpMap->alias, wide);                          dataLength += outString(out, tmpMap->alias, wide);
# Line 735  TS_SCardListReaders(STREAM in, STREAM ou Line 745  TS_SCardListReaders(STREAM in, STREAM ou
745                          while (lenSC > 0)                          while (lenSC > 0)
746                          {                          {
747                                  if (!hasAlias(cur))                                  if (!hasAlias(cur))
748                                    {
749                                            DEBUG_SCARD(("SCARD:    \"%s\"\n", cur));
750                                          dataLength += outString(out, cur, wide);                                          dataLength += outString(out, cur, wide);
751                                    }
752                                  cur = (void *) ((unsigned char *) cur + lenSC + 1);                                  cur = (void *) ((unsigned char *) cur + lenSC + 1);
753                                  lenSC = strlen(cur);                                  lenSC = strlen(cur);
754                          }                          }
# Line 758  TS_SCardListReaders(STREAM in, STREAM ou Line 771  TS_SCardListReaders(STREAM in, STREAM ou
771    
772    
773  static MYPCSC_DWORD  static MYPCSC_DWORD
774  TS_SCardConnect(STREAM in, STREAM out, BOOL wide)  TS_SCardConnect(STREAM in, STREAM out, RD_BOOL wide)
775  {  {
776          MYPCSC_DWORD rv;          MYPCSC_DWORD rv;
777          SCARDCONTEXT hContext;          SCARDCONTEXT hContext;
# Line 774  TS_SCardConnect(STREAM in, STREAM out, B Line 787  TS_SCardConnect(STREAM in, STREAM out, B
787          in->p += 0x1C;          in->p += 0x1C;
788          in_uint32_le(in, dwShareMode);          in_uint32_le(in, dwShareMode);
789          in_uint32_le(in, dwPreferredProtocol);          in_uint32_le(in, dwPreferredProtocol);
         DEBUG_SCARD(("[SHARE %8x]\n", (unsigned int) dwShareMode));  
         DEBUG_SCARD(("[PROTO %8x]\n", (unsigned int) dwPreferredProtocol));  
790          inReaderName(&lcHandle, in, &szReader, wide);          inReaderName(&lcHandle, in, &szReader, wide);
         DEBUG_SCARD(("[CONNECT TO READER \"%s\"\n", (szReader != NULL) ? (szReader) : ("NULL")));  
791          in->p += 0x04;          in->p += 0x04;
792          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
793          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardConnect(context: 0x%08x, share: 0x%08x, proto: 0x%08x, reader: \"%s\")\n", (unsigned) hContext, (unsigned) dwShareMode, (unsigned) dwPreferredProtocol, szReader ? szReader : "NULL"));
794          rv = SCardConnect(hContext, szReader, (MYPCSC_DWORD) dwShareMode,          rv = SCardConnect(hContext, szReader, (MYPCSC_DWORD) dwShareMode,
795                            (MYPCSC_DWORD) dwPreferredProtocol, &myHCard, &dwActiveProtocol);                            (MYPCSC_DWORD) dwPreferredProtocol, &myHCard, &dwActiveProtocol);
796          hCard = scHandleToServer(myHCard);          hCard = scHandleToServer(myHCard);
         DEBUG_SCARD(("[RECEIVED HCARD 0x%016lx]\n", (unsigned long) myHCard));  
         DEBUG_SCARD(("[MANGLED  HCARD 0x%08x]\n", hCard));  
797          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
798          {          {
799                  DEBUG_SCARD(("<--ERROR SCardConnect Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
800                                 pcsc_stringify_error(rv), (unsigned int) rv));
801          }          }
802          else          else
803          {          {
804                  char *szVendor = getVendor(szReader);                  char *szVendor = getVendor(szReader);
805                  DEBUG_SCARD(("<--SUCCESS ScardConnect-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (hcard: 0x%08x [0x%08lx])\n",
806                                 (unsigned) hCard, (unsigned long) myHCard));
807                  if (szVendor && (strlen(szVendor) > 0))                  if (szVendor && (strlen(szVendor) > 0))
808                  {                  {
809                          DEBUG_SCARD(("Set Attribute ATTR_VENDOR_NAME\n"));                          DEBUG_SCARD(("SCARD: Set Attribute ATTR_VENDOR_NAME\n"));
810                          pthread_mutex_lock(&hcardAccess);                          pthread_mutex_lock(&hcardAccess);
811                          PSCHCardRec hcard = xmalloc(sizeof(TSCHCardRec));                          PSCHCardRec hcard = xmalloc(sizeof(TSCHCardRec));
812                          if (hcard)                          if (hcard)
# Line 852  TS_SCardReconnect(STREAM in, STREAM out) Line 862  TS_SCardReconnect(STREAM in, STREAM out)
862          in->p += 0x04;          in->p += 0x04;
863          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
864          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
865          DEBUG_SCARD(("[SHARE = 0x%.8x]\n", (unsigned int) dwShareMode));          DEBUG_SCARD(("SCARD: SCardReconnect(context: 0x%08x, hcard: 0x%08x [0x%08lx], share: 0x%08x, proto: 0x%08x, init: 0x%08x)\n", (unsigned) hContext, (unsigned) hCard, (unsigned long) myHCard, (unsigned) dwShareMode, (unsigned) dwPreferredProtocol, (unsigned) dwInitialization));
         DEBUG_SCARD(("[PROTO = 0x%.8x]\n", (unsigned int) dwPreferredProtocol));  
         DEBUG_SCARD(("[INIT  = 0x%.8x]\n", (unsigned int) dwInitialization));  
         DEBUG_SCARD(("[hContext = 0x%.8x]\n", (unsigned int) hContext));  
         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));  
         DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));  
866          rv = SCardReconnect(myHCard, (MYPCSC_DWORD) dwShareMode, (MYPCSC_DWORD) dwPreferredProtocol,          rv = SCardReconnect(myHCard, (MYPCSC_DWORD) dwShareMode, (MYPCSC_DWORD) dwPreferredProtocol,
867                              (MYPCSC_DWORD) dwInitialization, &dwActiveProtocol);                              (MYPCSC_DWORD) dwInitialization, &dwActiveProtocol);
868          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
869          {          {
870                  DEBUG_SCARD(("<--ERROR SCardReconnect Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
871                                 pcsc_stringify_error(rv), (unsigned int) rv));
872          }          }
873          else          else
874          {          {
875                  DEBUG_SCARD(("<--SUCCESS SCardReconnect-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (proto: 0x%08x)\n", (unsigned) dwActiveProtocol));
876          }          }
877    
878          outForceAlignment(out, 8);          outForceAlignment(out, 8);
# Line 890  TS_SCardDisconnect(STREAM in, STREAM out Line 896  TS_SCardDisconnect(STREAM in, STREAM out
896          in->p += 0x04;          in->p += 0x04;
897          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
898    
899          DEBUG_SCARD(("[hContext = 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardDisconnect(context: 0x%08x, hcard: 0x%08x, disposition: 0x%08x)\n", (unsigned) hContext, (unsigned) hCard, (unsigned) dwDisposition));
         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));  
         DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));  
900    
901          pthread_mutex_lock(&hcardAccess);          pthread_mutex_lock(&hcardAccess);
902          PSCHCardRec hcard = hcardFirst;          PSCHCardRec hcard = hcardFirst;
# Line 918  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(("SCARD: -> Failure: %s (0x%08x)\n",
926                                 pcsc_stringify_error(rv), (unsigned int) rv));
927          }          }
928          else          else
929          {          {
930                  DEBUG_SCARD(("<--SUCCESS SCardDisconnect-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
931          }          }
932    
933          outForceAlignment(out, 8);          outForceAlignment(out, 8);
# Line 948  needStatusRecheck(MYPCSC_DWORD rv, MYPCS Line 953  needStatusRecheck(MYPCSC_DWORD rv, MYPCS
953          return recall;          return recall;
954  }  }
955    
956  static BOOL  static RD_BOOL
957  mappedStatus(MYPCSC_DWORD code)  mappedStatus(MYPCSC_DWORD code)
958  {  {
959          code >>= 16;          code >>= 16;
# Line 957  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 1011  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 1023  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 1033  TS_SCardGetStatusChange(STREAM in, STREA Line 1038  TS_SCardGetStatusChange(STREAM in, STREA
1038          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1039          in->p += 0x04;          in->p += 0x04;
1040    
1041          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardGetStatusChange(context: 0x%08x, timeout: 0x%08x, count: %d)\n",
1042          DEBUG_SCARD(("[dwTimeout 0x%.8x]\n", (unsigned int) dwTimeout));                       (unsigned) hContext, (unsigned) dwTimeout, (int) dwCount));
         DEBUG_SCARD(("[COUNT %d]\n", (unsigned int) dwCount));  
         DEBUG_SCARD(("[TYPE SIZE %d]\n", (unsigned int) sizeof(SERVER_SCARD_READERSTATE_A)));  
1043    
1044          if (dwCount > 0)          if (dwCount > 0)
1045          {          {
# Line 1054  TS_SCardGetStatusChange(STREAM in, STREA Line 1057  TS_SCardGetStatusChange(STREAM in, STREA
1057                          in->p += 0x04;                          in->p += 0x04;
1058                          in_uint8a(in, cur, SERVER_SCARDSTATESIZE);                          in_uint8a(in, cur, SERVER_SCARDSTATESIZE);
1059                  }                  }
 #ifdef WITH_DEBUG_SCARD  
                 DEBUG_SCARD(("[READERS DUMP 1]------------------\n"));  
                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));  
 #endif  
   
1060    
1061                  for (i = 0, cur = rsArray, curState = stateArray;                  for (i = 0, cur = rsArray, curState = stateArray;
1062                       i < dwCount; i++, cur++, curState++)                       i < dwCount; i++, cur++, curState++)
1063                  {                  {
1064                          SERVER_DWORD dataLength;                          SERVER_DWORD dataLength;
1065    
1066                            /* Do endian swaps... */
1067                            cur->dwCurrentState = swap32(cur->dwCurrentState);
1068                            cur->dwEventState = swap32(cur->dwEventState);
1069                            cur->cbAtr = swap32(cur->cbAtr);
1070    
1071                          /* reset Current state hign bytes; */                          /* reset Current state hign bytes; */
1072                          *curState = cur->dwCurrentState;                          *curState = cur->dwCurrentState;
1073                          cur->dwCurrentState &= 0x0000FFFF;                          cur->dwCurrentState &= 0x0000FFFF;
# Line 1092  TS_SCardGetStatusChange(STREAM in, STREA Line 1095  TS_SCardGetStatusChange(STREAM in, STREA
1095    
1096                          in->p += 0x08;                          in->p += 0x08;
1097                          in_uint32_le(in, dataLength);                          in_uint32_le(in, dataLength);
                         DEBUG_SCARD(("[%d] Data Length %d]\n", (unsigned int) i, dataLength));  
1098                          inRepos(in,                          inRepos(in,
1099                                  inString(&lcHandle, in, (char **) &(cur->szReader), dataLength,                                  inString(&lcHandle, in, (char **) &(cur->szReader), dataLength,
1100                                           wide));                                           wide));
1101    
1102                          if (strcmp(cur->szReader, "\\\\?PnP?\\Notification") == 0)                          if (strcmp(cur->szReader, "\\\\?PnP?\\Notification") == 0)
1103                                  cur->dwCurrentState |= SCARD_STATE_IGNORE;                                  cur->dwCurrentState |= SCARD_STATE_IGNORE;
1104    
1105                            DEBUG_SCARD(("SCARD:    \"%s\"\n", cur->szReader ? cur->szReader : "NULL"));
1106                            DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
1107                                         (unsigned) cur->pvUserData, (unsigned) cur->dwCurrentState,
1108                                         (unsigned) cur->dwEventState));
1109                            DEBUG_SCARD(("SCARD:            current state: 0x%08x\n",
1110                                         (unsigned) *curState));
1111                  }                  }
 #ifdef WITH_DEBUG_SCARD  
                 DEBUG_SCARD(("[READERS DUMP 2]------------------\n"));  
                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));  
 #endif  
1112          }          }
1113          else          else
1114          {          {
# Line 1111  TS_SCardGetStatusChange(STREAM in, STREA Line 1116  TS_SCardGetStatusChange(STREAM in, STREA
1116                  stateArray = NULL;                  stateArray = NULL;
1117          }          }
1118    
         DEBUG_SCARD(("\nCalling SCardGetStatusChange...\n"));  
   
   
1119          myRsArray = SC_xmalloc(&lcHandle, dwCount * sizeof(MYPCSC_SCARD_READERSTATE_A));          myRsArray = SC_xmalloc(&lcHandle, dwCount * sizeof(MYPCSC_SCARD_READERSTATE_A));
1120          if (!rsArray)          if (!rsArray)
1121                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
1122          memset(myRsArray, 0, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));          memset(myRsArray, 0, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));
1123          copyReaderState_ServerToMyPCSC(rsArray, myRsArray, (SERVER_DWORD) dwCount);          copyReaderState_ServerToMyPCSC(rsArray, myRsArray, (SERVER_DWORD) dwCount);
 #ifdef WITH_DEBUG_SCARD  
         DEBUG_SCARD(("[TRANSLATION OF READERS]--------------------\n"));  
         hexdump((void *) myRsArray, dwCount * sizeof(MYPCSC_SCARD_READERSTATE_A));  
 #endif  
1124    
1125          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, (MYPCSC_DWORD) dwTimeout,          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, (MYPCSC_DWORD) dwTimeout,
1126                                    myRsArray, (MYPCSC_DWORD) dwCount);                                    myRsArray, (MYPCSC_DWORD) dwCount);
# Line 1130  TS_SCardGetStatusChange(STREAM in, STREA Line 1128  TS_SCardGetStatusChange(STREAM in, STREA
1128    
1129          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1130          {          {
1131                  DEBUG_SCARD(("<--ERROR SCardGetStatusChange Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1132                                 pcsc_stringify_error(rv), (unsigned int) rv));
1133          }          }
1134          else          else
1135          {          {
1136                  DEBUG_SCARD(("<--SUCCESS SCardGetStatusChange-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1137          }          }
1138    
 #ifdef WITH_DEBUG_SCARD  
         if (dwCount > 0)  
         {  
                 DEBUG_SCARD(("[READERS DUMP]------------------\n"));  
                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));  
         }  
 #endif  
   
1139          out_uint32_le(out, dwCount);          out_uint32_le(out, dwCount);
1140          out_uint32_le(out, 0x00084dd8);          out_uint32_le(out, 0x00084dd8);
1141          out_uint32_le(out, dwCount);          out_uint32_le(out, dwCount);
# Line 1179  TS_SCardGetStatusChange(STREAM in, STREA Line 1170  TS_SCardGetStatusChange(STREAM in, STREA
1170  #endif  #endif
1171                  cur->dwEventState = incStatus(cur->dwEventState, False);                  cur->dwEventState = incStatus(cur->dwEventState, False);
1172    
1173                    DEBUG_SCARD(("SCARD:    \"%s\"\n", cur->szReader ? cur->szReader : "NULL"));
1174                    DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
1175                                 (unsigned) cur->pvUserData, (unsigned) cur->dwCurrentState,
1176                                 (unsigned) cur->dwEventState));
1177    
1178                    /* Do endian swaps... */
1179                    cur->dwCurrentState = swap32(cur->dwCurrentState);
1180                    cur->dwEventState = swap32(cur->dwEventState);
1181                    cur->cbAtr = swap32(cur->cbAtr);
1182    
1183                  out_uint8p(out, (void *) ((unsigned char **) cur + 2),                  out_uint8p(out, (void *) ((unsigned char **) cur + 2),
1184                             sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));                             sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));
1185          }          }
# Line 1195  TS_SCardCancel(STREAM in, STREAM out) Line 1196  TS_SCardCancel(STREAM in, STREAM out)
1196    
1197          in->p += 0x1C;          in->p += 0x1C;
1198          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1199          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardCancel(context: 0x%08x)\n", (unsigned) hContext));
         DEBUG_SCARD(("Canceling... \n"));  
1200          rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext);          rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext);
1201          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1202          {          {
1203                  DEBUG_SCARD(("<--ERROR SCardCancel Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1204                                 pcsc_stringify_error(rv), (unsigned int) rv));
1205          }          }
1206          else          else
1207          {          {
1208                  DEBUG_SCARD(("<--SUCCESS SCardCancel-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1209          }          }
1210          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1211          return rv;          return rv;
1212  }  }
1213    
1214  static MYPCSC_DWORD  static MYPCSC_DWORD
1215  TS_SCardLocateCardsByATR(STREAM in, STREAM out, BOOL wide)  TS_SCardLocateCardsByATR(STREAM in, STREAM out, RD_BOOL wide)
1216  {  {
1217          int i, j, k;          int i, j, k;
1218          MYPCSC_DWORD rv;          MYPCSC_DWORD rv;
# Line 1227  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1228  TS_SCardLocateCardsByATR(STREAM in, STRE
1228    
1229          in->p += 0x2C;          in->p += 0x2C;
1230          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));  
1231          in_uint32_le(in, atrMaskCount);          in_uint32_le(in, atrMaskCount);
1232          pAtrMasks = SC_xmalloc(&lcHandle, atrMaskCount * sizeof(SCARD_ATRMASK_L));          pAtrMasks = SC_xmalloc(&lcHandle, atrMaskCount * sizeof(SCARD_ATRMASK_L));
1233          if (!pAtrMasks)          if (!pAtrMasks)
# Line 1240  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1240  TS_SCardLocateCardsByATR(STREAM in, STRE
1240                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
1241          memset(rsArray, 0, readerCount * sizeof(SCARD_READERSTATE_A));          memset(rsArray, 0, readerCount * sizeof(SCARD_READERSTATE_A));
1242    
1243            DEBUG_SCARD(("SCARD: SCardLocateCardsByATR(context: 0x%08x, atrs: %d, readers: %d)\n",
1244                         (unsigned) hContext, (int) atrMaskCount, (int) readerCount));
1245    
1246            for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)
1247            {
1248                    cur->cbAtr = swap32(cur->cbAtr);
1249    
1250                    DEBUG_SCARD(("SCARD:    ATR: "));
1251                    for (j = 0; j < pAtrMasks->cbAtr; j++)
1252                    {
1253                    DEBUG_SCARD(("%02x%c",
1254                                         (unsigned) (unsigned char) cur->rgbAtr[j],
1255                                         (j == pAtrMasks->cbAtr - 1) ? ' ' : ':'))}
1256                    DEBUG_SCARD(("\n"));
1257                    DEBUG_SCARD(("SCARD:         "));
1258                    for (j = 0; j < pAtrMasks->cbAtr; j++)
1259                    {
1260                    DEBUG_SCARD(("%02x%c",
1261                                         (unsigned) (unsigned char) cur->rgbMask[j],
1262                                         (j == pAtrMasks->cbAtr - 1) ? ' ' : ':'))}
1263                    DEBUG_SCARD(("\n"));
1264            }
1265    
1266          for (i = 0, rsCur = (SERVER_LPSCARD_READERSTATE_A) ((unsigned char **) rsArray + 2);          for (i = 0, rsCur = (SERVER_LPSCARD_READERSTATE_A) ((unsigned char **) rsArray + 2);
1267               i < readerCount; i++, rsCur++)               i < readerCount; i++, rsCur++)
1268          {          {
# Line 1250  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1273  TS_SCardLocateCardsByATR(STREAM in, STRE
1273          ResArray = SC_xmalloc(&lcHandle, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));          ResArray = SC_xmalloc(&lcHandle, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));
1274          if (!ResArray)          if (!ResArray)
1275                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
         memcpy(ResArray, rsArray, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));  
1276    
1277          for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)          for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)
1278          {          {
1279                    /* Do endian swaps... */
1280                    rsCur->dwCurrentState = swap32(rsCur->dwCurrentState);
1281                    rsCur->dwEventState = swap32(rsCur->dwEventState);
1282                    rsCur->cbAtr = swap32(rsCur->cbAtr);
1283    
1284                  inReaderName(&lcHandle, in, (char **) &rsCur->szReader, wide);                  inReaderName(&lcHandle, in, (char **) &rsCur->szReader, wide);
1285                  DEBUG_SCARD(("[CHECK READER %s]\n",                  DEBUG_SCARD(("SCARD:    \"%s\"\n", rsCur->szReader ? rsCur->szReader : "NULL"));
1286                               (rsCur->szReader) ? (rsCur->szReader) : ("NULL")));                  DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
1287                                 (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState,
1288                                 (unsigned) rsCur->dwEventState));
1289          }          }
1290            memcpy(ResArray, rsArray, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));
1291    
         DEBUG_SCARD(("[CALL subfunction \"SCardGetStatusChange\"]\n"));  
1292          /* FIXME segfault here. */          /* FIXME segfault here. */
1293          myRsArray = SC_xmalloc(&lcHandle, readerCount * sizeof(MYPCSC_SCARD_READERSTATE_A));          myRsArray = SC_xmalloc(&lcHandle, readerCount * sizeof(MYPCSC_SCARD_READERSTATE_A));
1294          if (!myRsArray)          if (!myRsArray)
1295                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
1296            copyReaderState_ServerToMyPCSC(rsArray, myRsArray, readerCount);
1297          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, 0x00000001, myRsArray,          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, 0x00000001, myRsArray,
1298                                    readerCount);                                    readerCount);
1299          copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount);          copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount);
1300          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1301          {          {
1302                  DEBUG_SCARD(("<--ERROR SCardGetStatusChange (no SCardLocateCardsByATR) Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1303                                 pcsc_stringify_error(rv), (unsigned int) rv));
1304          }          }
1305          else          else
1306          {          {
1307                  DEBUG_SCARD(("<--SUCCESS SCardGetStatusChange (no SCardLocateCardsByATR)-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1308                  cur = pAtrMasks;                  cur = pAtrMasks;
1309                  for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)                  for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)
1310                  {                  {
1311                          for (j = 0, rsCur = rsArray; j < readerCount; j++, rsCur++)                          for (j = 0, rsCur = rsArray; j < readerCount; j++, rsCur++)
1312                          {                          {
1313                                  BOOL equal = 1;                                  RD_BOOL equal = 1;
1314                                  for (k = 0; k < cur->cbAtr; k++)                                  for (k = 0; k < cur->cbAtr; k++)
1315                                  {                                  {
1316                                          /*  This line check if them equal */                                          if ((cur->rgbAtr[k] & cur->rgbMask[k]) !=
1317                                          if (cur->rgbAtr[k] != rsCur->rgbAtr[k])                                              (rsCur->rgbAtr[k] & cur->rgbMask[k]))
                                                 /*  Next Line was make to search with mask (some strange behavours with applications which use eToken SmartCards) */  
                                                 /*  if((cur->rgbAtr[k]&cur->rgbMask[k])!=(rsCur->rgbAtr[k]&cur->rgbMask[k])){ */  
1318                                          {                                          {
1319                                                  equal = 0;                                                  equal = 0;
1320                                                  break;                                                  break;
# Line 1293  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1322  TS_SCardLocateCardsByATR(STREAM in, STRE
1322                                  }                                  }
1323                                  if (equal)                                  if (equal)
1324                                  {                                  {
                                         DEBUG_SCARD(("[FOUND]\n"));  
1325                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */
1326                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));
1327                                            DEBUG_SCARD(("SCARD:    \"%s\"\n",
1328                                                         rsCur->szReader ? rsCur->szReader : "NULL"));
1329                                            DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n", (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState, (unsigned) rsCur->dwEventState));
1330                                  }                                  }
1331                          }                          }
1332                  }                  }
# Line 1305  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1336  TS_SCardLocateCardsByATR(STREAM in, STRE
1336          out_uint32_le(out, 0x00084dd8);          out_uint32_le(out, 0x00084dd8);
1337          out_uint32_le(out, readerCount);          out_uint32_le(out, readerCount);
1338    
1339          for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)          for (i = 0, rsCur = ResArray; i < readerCount; i++, rsCur++)
1340          {          {
1341                    /* Do endian swaps... */
1342                    rsCur->dwCurrentState = swap32(rsCur->dwCurrentState);
1343                    rsCur->dwEventState = swap32(rsCur->dwEventState);
1344                    rsCur->cbAtr = swap32(rsCur->cbAtr);
1345    
1346                  out_uint8p(out, (void *) ((unsigned char **) rsCur + 2),                  out_uint8p(out, (void *) ((unsigned char **) rsCur + 2),
1347                             sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));                             sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));
1348          }          }
# Line 1326  TS_SCardBeginTransaction(STREAM in, STRE Line 1362  TS_SCardBeginTransaction(STREAM in, STRE
1362          in->p += 0x30;          in->p += 0x30;
1363          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
1364          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1365          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardBeginTransaction(hcard: 0x%08x [0x%08lx])\n",
1366          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));                       (unsigned) hCard, (unsigned long) myHCard));
1367          rv = SCardBeginTransaction(myHCard);          rv = SCardBeginTransaction(myHCard);
1368          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1369          {          {
1370                  DEBUG_SCARD(("<--ERROR SCardBeginTransaction Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1371                                 pcsc_stringify_error(rv), (unsigned int) rv));
1372          }          }
1373          else          else
1374          {          {
1375                  DEBUG_SCARD(("<--SUCCESS SCardBeginTransaction-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1376          }          }
1377          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1378          return rv;          return rv;
# Line 1359  TS_SCardEndTransaction(STREAM in, STREAM Line 1396  TS_SCardEndTransaction(STREAM in, STREAM
1396          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));
1397          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));
1398    
1399            DEBUG_SCARD(("SCARD: SCardEndTransaction(hcard: 0x%08x [0x%08lx], disposition: 0x%08x)\n",
1400                         (unsigned) hCard, (unsigned long) myHCard, (unsigned) dwDisposition));
1401          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);
1402          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1403          {          {
1404                  DEBUG_SCARD(("<--ERROR SCardEndTransaction Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1405                                 pcsc_stringify_error(rv), (unsigned int) rv));
1406          }          }
1407          else          else
1408          {          {
1409                  DEBUG_SCARD(("<--SUCCESS SCardEndTransaction-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1410          }          }
1411          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1412          return rv;          return rv;
# Line 1380  copyIORequest_MyPCSCToServer(MYPCSC_LPSC Line 1420  copyIORequest_MyPCSCToServer(MYPCSC_LPSC
1420          size_t bytesToCopy = src->cbPciLength - sizeof(MYPCSC_SCARD_IO_REQUEST);          size_t bytesToCopy = src->cbPciLength - sizeof(MYPCSC_SCARD_IO_REQUEST);
1421          srcBytes = ((unsigned char *) src + sizeof(MYPCSC_SCARD_IO_REQUEST));          srcBytes = ((unsigned char *) src + sizeof(MYPCSC_SCARD_IO_REQUEST));
1422          dstBytes = ((unsigned char *) dst + sizeof(SERVER_SCARD_IO_REQUEST));          dstBytes = ((unsigned char *) dst + sizeof(SERVER_SCARD_IO_REQUEST));
1423          dst->dwProtocol = src->dwProtocol;          dst->dwProtocol = swap32((uint32_t) src->dwProtocol);
1424          dst->cbPciLength = src->cbPciLength          dst->cbPciLength = swap32((uint32_t) src->cbPciLength
1425                  - sizeof(MYPCSC_SCARD_IO_REQUEST) + sizeof(SERVER_SCARD_IO_REQUEST);                                    - sizeof(MYPCSC_SCARD_IO_REQUEST) +
1426                                      sizeof(SERVER_SCARD_IO_REQUEST));
1427          memcpy(dstBytes, srcBytes, bytesToCopy);          memcpy(dstBytes, srcBytes, bytesToCopy);
1428  }  }
1429    
# Line 1393  copyIORequest_ServerToMyPCSC(SERVER_LPSC Line 1434  copyIORequest_ServerToMyPCSC(SERVER_LPSC
1434          size_t bytesToCopy = src->cbPciLength - sizeof(SERVER_SCARD_IO_REQUEST);          size_t bytesToCopy = src->cbPciLength - sizeof(SERVER_SCARD_IO_REQUEST);
1435          srcBytes = ((unsigned char *) src + sizeof(SERVER_SCARD_IO_REQUEST));          srcBytes = ((unsigned char *) src + sizeof(SERVER_SCARD_IO_REQUEST));
1436          dstBytes = ((unsigned char *) dst + sizeof(MYPCSC_SCARD_IO_REQUEST));          dstBytes = ((unsigned char *) dst + sizeof(MYPCSC_SCARD_IO_REQUEST));
1437          dst->dwProtocol = src->dwProtocol;          dst->dwProtocol = swap32(src->dwProtocol);
1438          dst->cbPciLength = src->cbPciLength          dst->cbPciLength = src->cbPciLength     /* already correct endian */
1439                  - sizeof(SERVER_SCARD_IO_REQUEST) + sizeof(MYPCSC_SCARD_IO_REQUEST);                  - sizeof(SERVER_SCARD_IO_REQUEST) + sizeof(MYPCSC_SCARD_IO_REQUEST);
1440          memcpy(dstBytes, srcBytes, bytesToCopy);          memcpy(dstBytes, srcBytes, bytesToCopy);
1441  }  }
# Line 1500  TS_SCardTransmit(STREAM in, STREAM out) Line 1541  TS_SCardTransmit(STREAM in, STREAM out)
1541          else          else
1542                  pioRecvPci = NULL;                  pioRecvPci = NULL;
1543    
1544  #ifdef WITH_DEBUG_SCARD          DEBUG_SCARD(("SCARD: SCardTransmit(hcard: 0x%08x [0x%08lx], send: %d bytes, recv: %d bytes)\n", (unsigned) hCard, (unsigned long) myHCard, (int) cbSendLength, (int) cbRecvLength));
         DEBUG_SCARD(("++++++++++\n"));  
         DEBUG_SCARD(("[SEND LEN = %d]\n", (unsigned int) cbSendLength));  
         DEBUG_SCARD(("[RECV LEN = %d]\n", (unsigned int) cbRecvLength));  
         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));  
         DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));  
         DEBUG_SCARD(("[pioSendPci]\n"));  
         if (pioSendPci == NULL)  
         {  
                 DEBUG_SCARD(("NULL\n"));  
         }  
         else  
         {  
                 hexdump((void *) pioSendPci, pioSendPci->cbPciLength);  
         }  
   
         DEBUG_SCARD(("[pioRecvPci]\n"));  
         if (pioRecvPci == NULL)  
         {  
                 DEBUG_SCARD(("NULL\n"));  
         }  
         else  
         {  
                 hexdump((void *) pioRecvPci, pioRecvPci->cbPciLength);  
         }  
         DEBUG_SCARD(("[sendBuf]\n"));  
         hexdump(sendBuf, cbSendLength);  
         DEBUG_SCARD(("++++++++++\n"));  
 #endif  
1545    
1546          myCbRecvLength = cbRecvLength;          myCbRecvLength = cbRecvLength;
1547          myPioSendPci = SC_xmalloc(&lcHandle,          myPioSendPci = SC_xmalloc(&lcHandle,
# Line 1560  TS_SCardTransmit(STREAM in, STREAM out) Line 1573  TS_SCardTransmit(STREAM in, STREAM out)
1573          if (cbRecvLength > 448)          if (cbRecvLength > 448)
1574          {          {
1575                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);
1576                  DEBUG_SCARD(("[RECV LEN %d -> %d]\n", (unsigned int) cbRecvLength, 400));                  DEBUG_SCARD(("SCARD:    Truncated %d to %d\n", (unsigned int) cbRecvLength, 448));
1577                  cbRecvLength = 448;                  cbRecvLength = 448;
1578          }          }
1579    
1580          if (pioRecvPci)          if (pioRecvPci)
1581          {          {
1582                  copyIORequest_MyPCSCToServer(myPioRecvPci, pioRecvPci);                  /*
1583                     * pscs-lite mishandles this structure in some cases.
1584                     * make sure we only copy it if it is valid.
1585                     */
1586                    if (myPioRecvPci->cbPciLength >= sizeof(MYPCSC_SCARD_IO_REQUEST))
1587                            copyIORequest_MyPCSCToServer(myPioRecvPci, pioRecvPci);
1588          }          }
1589    
1590          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1591          {          {
1592                  DEBUG_SCARD(("<--ERROR SCardTransmit Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1593                                 pcsc_stringify_error(rv), (unsigned int) rv));
1594          }          }
1595          else          else
1596          {          {
1597  #ifdef WITH_DEBUG_SCARD                  DEBUG_SCARD(("SCARD: -> Success (%d bytes)\n", (int) cbRecvLength));
                 DEBUG_SCARD(("<--SUCCESS SCardTransmit-->\n"));  
                 DEBUG_SCARD(("RESULT %d\n", (unsigned int) cbRecvLength));  
                 hexdump(recvBuf, cbRecvLength);  
                 if (myPioRecvPci)  
                 {  
                         DEBUG_SCARD(("--- myPioRecvPci ---\n"));  
                         hexdump((void *) myPioRecvPci, myPioRecvPci->cbPciLength);  
                 }  
                 DEBUG_SCARD(("------------------\n"));  
 #endif  
1598  #if 0  #if 0
1599                  if ((pioRecvPci != NULL) && (pioRecvPci->cbPciLength > 0))                  if ((pioRecvPci != NULL) && (mypioRecvPci->cbPciLength > 0))
1600                  {                  {
1601                          out_uint32_le(out, (DWORD) pioRecvPci); /* if not NULL, this 4 bytes indicates that pioRecvPci is present */                          out_uint32_le(out, (DWORD) pioRecvPci); /* if not NULL, this 4 bytes indicates that pioRecvPci is present */
1602                  }                  }
# Line 1598  TS_SCardTransmit(STREAM in, STREAM out) Line 1607  TS_SCardTransmit(STREAM in, STREAM out)
1607                  outBufferStart(out, cbRecvLength);      /* start of recvBuf output */                  outBufferStart(out, cbRecvLength);      /* start of recvBuf output */
1608    
1609  #if 0  #if 0
1610                  if ((pioRecvPci) && (pioRecvPci->cbPciLength > 0))                  if ((pioRecvPci) && (mypioRecvPci->cbPciLength > 0))
1611                  {                  {
1612                          out_uint32_le(out, pioRecvPci->dwProtocol);                          out_uint32_le(out, mypioRecvPci->dwProtocol);
1613                          int len = pioRecvPci->cbPciLength - sizeof(pioRecvPci);                          int len = mypioRecvPci->cbPciLength - sizeof(mypioRecvPci);
1614                          outBufferStartWithLimit(out, len, 12);                          outBufferStartWithLimit(out, len, 12);
1615                          outBufferFinishWithLimit(out,                          outBufferFinishWithLimit(out,
1616                                                   (char *) ((DWORD) pioRecvPci + sizeof(pioRecvPci)),                                                   (char *) ((DWORD) pioRecvPci + sizeof(pioRecvPci)),
# Line 1617  TS_SCardTransmit(STREAM in, STREAM out) Line 1626  TS_SCardTransmit(STREAM in, STREAM out)
1626  }  }
1627    
1628  static MYPCSC_DWORD  static MYPCSC_DWORD
1629  TS_SCardStatus(STREAM in, STREAM out, BOOL wide)  TS_SCardStatus(STREAM in, STREAM out, RD_BOOL wide)
1630  {  {
1631          MYPCSC_DWORD rv;          MYPCSC_DWORD rv;
1632          SERVER_SCARDCONTEXT hCard;          SERVER_SCARDCONTEXT hCard;
# Line 1637  TS_SCardStatus(STREAM in, STREAM out, BO Line 1646  TS_SCardStatus(STREAM in, STREAM out, BO
1646          in->p += 0x04;          in->p += 0x04;
1647          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1648    
1649          DEBUG_SCARD(("[hCard 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardStatus(hcard: 0x%08x [0x%08lx], reader len: %d bytes, atr len: %d bytes)\n", (unsigned) hCard, (unsigned long) myHCard, (int) dwReaderLen, (int) dwAtrLen));
         DEBUG_SCARD(("[myHCard 0x%016lx]\n", (unsigned long) myHCard));  
         DEBUG_SCARD(("[dwReaderLen %d]\n", (unsigned int) dwReaderLen));  
         DEBUG_SCARD(("[dwAtrLen %d]\n", (unsigned int) dwAtrLen));  
1650    
1651          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)
1652                  dwReaderLen = SCARD_MAX_MEM;                  dwReaderLen = SCARD_MAX_MEM;
1653          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)
1654                  dwAtrLen = SCARD_MAX_MEM;                  dwAtrLen = SCARD_MAX_MEM;
1655    
1656    #if 1
1657            /*
1658             * Active client sometimes sends a readerlen *just* big enough
1659             * SCardStatus doesn't seem to like this. This is a workaround,
1660             * aka hack!
1661             */
1662            dwReaderLen = 200;
1663    #endif
1664    
1665          readerName = SC_xmalloc(&lcHandle, dwReaderLen + 2);          readerName = SC_xmalloc(&lcHandle, dwReaderLen + 2);
1666          if (!readerName)          if (!readerName)
1667                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
# Line 1668  TS_SCardStatus(STREAM in, STREAM out, BO Line 1683  TS_SCardStatus(STREAM in, STREAM out, BO
1683    
1684          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1685          {          {
1686                  DEBUG_SCARD(("<--ERROR SCardStatus Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1687                                 pcsc_stringify_error(rv), (unsigned int) rv));
1688                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1689          }          }
1690          else          else
1691          {          {
1692  #ifdef WITH_DEBUG_SCARD                  int i;
1693                  DEBUG_SCARD(("<--SUCCESS SCardStatus-->\n"));  
1694                  DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));                  DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
1695                  DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));                               (unsigned) dwState, (unsigned) dwProtocol));
1696                  DEBUG_SCARD(("[Reader Name]\n"));                  DEBUG_SCARD(("SCARD:        Reader: \"%s\"\n", readerName ? readerName : "NULL"));
1697                  hexdump((unsigned char *) readerName, dwReaderLen);                  DEBUG_SCARD(("SCARD:        ATR: "));
1698                  DEBUG_SCARD(("[Atr]\n"));                  for (i = 0; i < dwAtrLen; i++)
1699                  hexdump(atr, dwAtrLen);                  {
1700  #endif                          DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
1701                    }
1702                    DEBUG_SCARD(("\n"));
1703    
1704                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
1705                          dwState = 0x00000006;                          dwState = 0x00000006;
1706                  else                  else
# Line 1751  TS_SCardState(STREAM in, STREAM out) Line 1770  TS_SCardState(STREAM in, STREAM out)
1770          in->p += 0x04;          in->p += 0x04;
1771          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1772    
1773          DEBUG_SCARD(("[hCard 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardState(hcard: 0x%08x [0x%08lx], atr len: %d bytes)\n",
1774          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard, (int) dwAtrLen));
         DEBUG_SCARD(("[dwAtrLen %d]\n", (unsigned int) dwAtrLen));  
1775    
1776          dwReaderLen = SCARD_MAX_MEM;          dwReaderLen = SCARD_MAX_MEM;
1777          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)
# Line 1779  TS_SCardState(STREAM in, STREAM out) Line 1797  TS_SCardState(STREAM in, STREAM out)
1797    
1798          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1799          {          {
1800                  DEBUG_SCARD(("<--ERROR SCardStatus (no ScardState) Code=0x%.8x-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1801                               (unsigned int) rv));                               pcsc_stringify_error(rv), (unsigned int) rv));
1802                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1803          }          }
1804          else          else
1805          {          {
1806  #ifdef WITH_DEBUG_SCARD                  int i;
1807                  DEBUG_SCARD(("<--SUCCESS SCardStatus (no ScardState)-->\n"));  
1808                  DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));                  DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
1809                  DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));                               (unsigned) dwState, (unsigned) dwProtocol));
1810                  DEBUG_SCARD(("[Atr]\n"));                  DEBUG_SCARD(("SCARD:        ATR: "));
1811                  hexdump(atr, dwAtrLen);                  for (i = 0; i < dwAtrLen; i++)
1812  #endif                  {
1813                            DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
1814                    }
1815                    DEBUG_SCARD(("\n"));
1816    
1817                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
1818                          dwState = 0x00000006;                          dwState = 0x00000006;
1819                  else                  else
# Line 1845  TS_SCardListReaderGroups(STREAM in, STRE Line 1867  TS_SCardListReaderGroups(STREAM in, STRE
1867          in->p += 0x04;          in->p += 0x04;
1868          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1869    
1870            DEBUG_SCARD(("SCARD: SCardListReaderGroups(context: 0x%08x, groups: %d)\n",
1871                         (unsigned) hContext, (int) dwGroups));
1872    
1873          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)
1874                  dwGroups = SCARD_MAX_MEM;                  dwGroups = SCARD_MAX_MEM;
1875    
# Line 1858  TS_SCardListReaderGroups(STREAM in, STRE Line 1883  TS_SCardListReaderGroups(STREAM in, STRE
1883    
1884          if (rv)          if (rv)
1885          {          {
1886                  DEBUG_SCARD(("<--ERROR SCardListReaderGroups Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1887                                 pcsc_stringify_error(rv), (unsigned int) rv));
1888                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1889          }          }
1890          else          else
1891          {          {
1892                  DEBUG_SCARD(("<--SUCCESS SCardListReaderGroups-->\n"));                  int i;
1893                    char *cur;
1894    
1895                    DEBUG_SCARD(("SCARD: -> Success\n"));
1896                    for (i = 0, cur = szGroups; i < dwGroups; i++, cur += strlen(cur) + 1)
1897                    {
1898                            DEBUG_SCARD(("SCARD:    %s\n", cur));
1899                    }
1900          }          }
1901    
1902    
# Line 1900  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1933  TS_SCardGetAttrib(STREAM in, STREAM out)
1933    
1934          dwAttrId = dwAttrId & 0x0000FFFF;          dwAttrId = dwAttrId & 0x0000FFFF;
1935    
1936          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardGetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
1937          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard,
1938          DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));                       (unsigned) dwAttrId, (int) dwAttrLen));
         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));  
1939    
1940          if (dwAttrLen > MAX_BUFFER_SIZE)          if (dwAttrLen > MAX_BUFFER_SIZE)
1941                  dwAttrLen = MAX_BUFFER_SIZE;                  dwAttrLen = MAX_BUFFER_SIZE;
# Line 1929  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1961  TS_SCardGetAttrib(STREAM in, STREAM out)
1961    
1962          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)
1963          {          {
1964                  DEBUG_SCARD(("Get Attribute ATTR_VENDOR_NAME\n"));                  DEBUG_SCARD(("SCARD:    Faking attribute ATTR_VENDOR_NAME\n"));
1965                  pthread_mutex_lock(&hcardAccess);                  pthread_mutex_lock(&hcardAccess);
1966                  PSCHCardRec hcard = hcardFirst;                  PSCHCardRec hcard = hcardFirst;
1967                  while (hcard)                  while (hcard)
# Line 1949  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1981  TS_SCardGetAttrib(STREAM in, STREAM out)
1981    
1982          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1983          {          {
1984                  DEBUG_SCARD(("<--ERROR SCardGetAttrib Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1985                                 pcsc_stringify_error(rv), (unsigned int) rv));
1986                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1987          }          }
1988          else          else
1989          {          {
1990  #ifdef WITH_DEBUG_SCARD                  DEBUG_SCARD(("SCARD: -> Success (%d bytes)\n", (int) dwAttrLen));
1991                  DEBUG_SCARD(("<--SUCCESS SCardGetAttrib-->\n"));  
                 DEBUG_SCARD(("[LENGTH %d]\n", (unsigned int) dwAttrLen));  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
                 hexdump(pbAttr, dwAttrLen);  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
 #endif  
1992                  out_uint32_le(out, dwAttrLen);                  out_uint32_le(out, dwAttrLen);
1993                  out_uint32_le(out, 0x00000200);                  out_uint32_le(out, 0x00000200);
1994                  out_uint32_le(out, dwAttrLen);                  out_uint32_le(out, dwAttrLen);
# Line 2000  TS_SCardSetAttrib(STREAM in, STREAM out) Line 2028  TS_SCardSetAttrib(STREAM in, STREAM out)
2028    
2029          dwAttrId = dwAttrId & 0x0000FFFF;          dwAttrId = dwAttrId & 0x0000FFFF;
2030    
2031          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardSetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
2032          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard,
2033          DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));                       (unsigned) dwAttrId, (int) dwAttrLen));
         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));  
2034    
2035          if (dwAttrLen > MAX_BUFFER_SIZE)          if (dwAttrLen > MAX_BUFFER_SIZE)
2036                  dwAttrLen = MAX_BUFFER_SIZE;                  dwAttrLen = MAX_BUFFER_SIZE;
# Line 2015  TS_SCardSetAttrib(STREAM in, STREAM out) Line 2042  TS_SCardSetAttrib(STREAM in, STREAM out)
2042          in_uint8a(in, pbAttr, dwAttrLen);          in_uint8a(in, pbAttr, dwAttrLen);
2043          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);
2044    
2045          if (rv)          if (rv != SCARD_S_SUCCESS)
2046          {          {
2047                  DEBUG_SCARD(("<--ERROR SCardSetAttrib Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
2048                                 pcsc_stringify_error(rv), (unsigned int) rv));
2049          }          }
2050          else          else
2051          {          {
2052                  DEBUG_SCARD(("<--SUCCESS SCardSetAttrib-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
2053          }          }
2054    
2055          out_uint32_le(out, 0x00000000);          out_uint32_le(out, 0x00000000);
# Line 2091  TS_SCardControl(STREAM in, STREAM out) Line 2119  TS_SCardControl(STREAM in, STREAM out)
2119          if (!pOutBuffer)          if (!pOutBuffer)
2120                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
2121    
2122  #ifdef WITH_DEBUG_SCARD          DEBUG_SCARD(("SCARD: SCardControl(context: 0x%08x, hcard: 0x%08x, code: 0x%08x, in: %d bytes, out: %d bytes)\n", (unsigned) hContext, (unsigned) hCard, (unsigned) dwControlCode, (int) nInBufferSize, (int) nOutBufferSize));
         DEBUG_SCARD(("[hContext = 0x%.8x]\n", (unsigned int) hContext));  
         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));  
         DEBUG_SCARD(("[dwControlCode = 0x%.8x]\n", (unsigned int) dwControlCode));  
         DEBUG_SCARD(("[nInBufferSize  = %d]\n", (unsigned int) nInBufferSize));  
         DEBUG_SCARD(("[nOutBufferSize  = %d]\n", (unsigned int) nOutBufferSize));  
         if (nInBufferSize > 0)  
         {  
                 DEBUG_SCARD(("[In buffer]\n"));  
                 hexdump((unsigned char *) pInBuffer, nInBufferSize);  
         }  
         DEBUG_SCARD(("---> Calling SCardControl\n"));  
 #endif  
2123    
2124          sc_nBytesReturned = nBytesReturned;          sc_nBytesReturned = nBytesReturned;
2125          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
# Line 2117  TS_SCardControl(STREAM in, STREAM out) Line 2133  TS_SCardControl(STREAM in, STREAM out)
2133  #endif  #endif
2134          nBytesReturned = sc_nBytesReturned;          nBytesReturned = sc_nBytesReturned;
2135    
 #ifdef WITH_DEBUG_SCARD  
2136          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
2137          {          {
2138                  DEBUG_SCARD(("<--ERROR SCardControl Code=0x%.8x-->\n", (unsigned int) rv));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
2139                                 pcsc_stringify_error(rv), (unsigned int) rv));
2140          }          }
2141          else          else
2142          {          {
2143                  DEBUG_SCARD(("<--SUCCESS SCardControl-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (out: %d bytes)\n", (int) nBytesReturned));
                 DEBUG_SCARD(("[LENGTH %d]\n", (unsigned int) nBytesReturned));  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
                 hexdump((unsigned char *) pOutBuffer, nBytesReturned);  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
2144          }          }
 #endif  
2145    
2146          out_uint32_le(out, nBytesReturned);          out_uint32_le(out, nBytesReturned);
2147          out_uint32_le(out, 0x00000004);          out_uint32_le(out, 0x00000004);
# Line 2149  TS_SCardControl(STREAM in, STREAM out) Line 2160  TS_SCardControl(STREAM in, STREAM out)
2160  static MYPCSC_DWORD  static MYPCSC_DWORD
2161  TS_SCardAccessStartedEvent(STREAM in, STREAM out)  TS_SCardAccessStartedEvent(STREAM in, STREAM out)
2162  {  {
2163            DEBUG_SCARD(("SCARD: SCardAccessStartedEvent()\n"));
2164          out_uint8s(out, 8);          out_uint8s(out, 8);
2165          return SCARD_S_SUCCESS;          return SCARD_S_SUCCESS;
2166  }  }
2167    
2168    
2169  static NTSTATUS  static RD_NTSTATUS
2170  scard_device_control(NTHANDLE handle, uint32 request, STREAM in, STREAM out)  scard_device_control(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
2171  {  {
2172          SERVER_DWORD Result = 0x00000000;          SERVER_DWORD Result = 0x00000000;
2173          unsigned char *psize, *pend, *pStatusCode;          unsigned char *psize, *pend, *pStatusCode;
2174          SERVER_DWORD addToEnd = 0;          SERVER_DWORD addToEnd = 0;
 #ifdef WITH_DEBUG_SCARD  
         unsigned char *pbeg = out->p;  
2175    
         DEBUG_SCARD(("--------------------------------\n"));  
         DEBUG_SCARD(("[NTHANDLE %08X]\n", handle));  
         DEBUG_SCARD(("[REQUEST %08X]\n", request));  
         DEBUG_SCARD(("[INPUT DUMP]--------------------\n"));  
         hexdump(in->p, in->end - in->p);  
 #endif  
2176          /* Processing request */          /* Processing request */
2177    
2178          out_uint32_le(out, 0x00081001); /* Header lines */          out_uint32_le(out, 0x00081001); /* Header lines */
# Line 2184  scard_device_control(NTHANDLE handle, ui Line 2188  scard_device_control(NTHANDLE handle, ui
2188                          /* SCardEstablishContext */                          /* SCardEstablishContext */
2189                  case SC_ESTABLISH_CONTEXT:                  case SC_ESTABLISH_CONTEXT:
2190                          {                          {
                                 DEBUG_SCARD(("<---SCardEstablishContext--->\n"));  
2191                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);
2192                                  break;                                  break;
2193                          }                          }
2194                          /* SCardReleaseContext */                          /* SCardReleaseContext */
2195                  case SC_RELEASE_CONTEXT:                  case SC_RELEASE_CONTEXT:
2196                          {                          {
                                 DEBUG_SCARD(("<---SCardReleaseContext--->\n"));  
2197                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);
2198                                  break;                                  break;
2199                          }                          }
2200                          /* SCardIsValidContext */                          /* SCardIsValidContext */
2201                  case SC_IS_VALID_CONTEXT:                  case SC_IS_VALID_CONTEXT:
2202                          {                          {
                                 DEBUG_SCARD(("<---SCardIsValidContext--->\n"));  
2203                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);
2204                                  break;                                  break;
2205                          }                          }
# Line 2206  scard_device_control(NTHANDLE handle, ui Line 2207  scard_device_control(NTHANDLE handle, ui
2207                  case SC_LIST_READERS:   /* SCardListReadersA */                  case SC_LIST_READERS:   /* SCardListReadersA */
2208                  case SC_LIST_READERS + 4:       /* SCardListReadersW */                  case SC_LIST_READERS + 4:       /* SCardListReadersW */
2209                          {                          {
2210                                  BOOL wide = request != SC_LIST_READERS;                                  RD_BOOL wide = request != SC_LIST_READERS;
                                 DEBUG_SCARD(("<---SCardListReaders---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2211                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);
2212                                  break;                                  break;
2213                          }                          }
# Line 2216  scard_device_control(NTHANDLE handle, ui Line 2215  scard_device_control(NTHANDLE handle, ui
2215                  case SC_CONNECT:        /* ScardConnectA */                  case SC_CONNECT:        /* ScardConnectA */
2216                  case SC_CONNECT + 4:    /* SCardConnectW */                  case SC_CONNECT + 4:    /* SCardConnectW */
2217                          {                          {
2218                                  BOOL wide = request != SC_CONNECT;                                  RD_BOOL wide = request != SC_CONNECT;
                                 DEBUG_SCARD(("<---SCardConnect---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2219                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);
2220                                  break;                                  break;
2221                          }                          }
2222                          /* ScardReconnect */                          /* ScardReconnect */
2223                  case SC_RECONNECT:                  case SC_RECONNECT:
2224                          {                          {
                                 DEBUG_SCARD(("<---SCardReconnect--->\n"));  
2225                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);
2226                                  break;                                  break;
2227                          }                          }
2228                          /* ScardDisconnect */                          /* ScardDisconnect */
2229                  case SC_DISCONNECT:                  case SC_DISCONNECT:
2230                          {                          {
                                 DEBUG_SCARD(("<---SCardDisconnect--->\n"));  
2231                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);
2232                                  break;                                  break;
2233                          }                          }
# Line 2240  scard_device_control(NTHANDLE handle, ui Line 2235  scard_device_control(NTHANDLE handle, ui
2235                  case SC_GET_STATUS_CHANGE:      /* SCardGetStatusChangeA */                  case SC_GET_STATUS_CHANGE:      /* SCardGetStatusChangeA */
2236                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */
2237                          {                          {
2238                                  BOOL wide = request != SC_GET_STATUS_CHANGE;                                  RD_BOOL wide = request != SC_GET_STATUS_CHANGE;
                                 DEBUG_SCARD(("<---SCardGetStatusChange---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2239                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);
2240                                  break;                                  break;
2241                          }                          }
2242                          /* SCardCancel */                          /* SCardCancel */
2243                  case SC_CANCEL:                  case SC_CANCEL:
2244                          {                          {
                                 DEBUG_SCARD(("<---SCardCancel--->\n"));  
2245                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);
2246                                  break;                                  break;
2247                          }                          }
# Line 2257  scard_device_control(NTHANDLE handle, ui Line 2249  scard_device_control(NTHANDLE handle, ui
2249                  case SC_LOCATE_CARDS_BY_ATR:    /* SCardLocateCardsByATRA */                  case SC_LOCATE_CARDS_BY_ATR:    /* SCardLocateCardsByATRA */
2250                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */
2251                          {                          {
2252                                  BOOL wide = request != SC_LOCATE_CARDS_BY_ATR;                                  RD_BOOL wide = request != SC_LOCATE_CARDS_BY_ATR;
                                 DEBUG_SCARD(("<---SCardLocateCardsByATR---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2253                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);
2254                                  break;                                  break;
2255                          }                          }
2256                          /* SCardBeginTransaction */                          /* SCardBeginTransaction */
2257                  case SC_BEGIN_TRANSACTION:                  case SC_BEGIN_TRANSACTION:
2258                          {                          {
                                 DEBUG_SCARD(("<---SCardBeginTransaction--->\n"));  
2259                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);
2260                                  break;                                  break;
2261                          }                          }
2262                          /* SCardBeginTransaction */                          /* SCardBeginTransaction */
2263                  case SC_END_TRANSACTION:                  case SC_END_TRANSACTION:
2264                          {                          {
                                 DEBUG_SCARD(("<---SCardEndTransaction--->\n"));  
2265                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);
2266                                  break;                                  break;
2267                          }                          }
2268                          /* ScardTransmit */                          /* ScardTransmit */
2269                  case SC_TRANSMIT:                  case SC_TRANSMIT:
2270                          {                          {
                                 DEBUG_SCARD(("<---SCardTransmit--->\n"));  
2271                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);
2272                                  break;                                  break;
2273                          }                          }
2274                          /* SCardControl */                          /* SCardControl */
2275                  case SC_CONTROL:                  case SC_CONTROL:
2276                          {                          {
                                 DEBUG_SCARD(("<---SCardControl--->\n"));  
2277                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);
2278                                  break;                                  break;
2279                          }                          }
# Line 2295  scard_device_control(NTHANDLE handle, ui Line 2281  scard_device_control(NTHANDLE handle, ui
2281  #ifndef WITH_PCSC120  #ifndef WITH_PCSC120
2282                  case SC_GETATTRIB:                  case SC_GETATTRIB:
2283                          {                          {
                                 DEBUG_SCARD(("<---SCardGetAttrib--->\n"));  
2284                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);
2285                                  break;                                  break;
2286                          }                          }
2287  #endif  #endif
2288                  case SC_ACCESS_STARTED_EVENT:                  case SC_ACCESS_STARTED_EVENT:
2289                          {                          {
                                 DEBUG_SCARD(("<---SCardAccessStartedEvent-->\n"));  
2290                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);
2291                                  break;                                  break;
2292                          }                          }
2293                  case SC_STATUS: /* SCardStatusA */                  case SC_STATUS: /* SCardStatusA */
2294                  case SC_STATUS + 4:     /* SCardStatusW */                  case SC_STATUS + 4:     /* SCardStatusW */
2295                          {                          {
2296                                  BOOL wide = request != SC_STATUS;                                  RD_BOOL wide = request != SC_STATUS;
                                 DEBUG_SCARD(("<---SCardStatus---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2297                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);
2298                                  break;                                  break;
2299                          }                          }
2300                  case SC_STATE:  /* SCardState */                  case SC_STATE:  /* SCardState */
2301                          {                          {
                                 DEBUG_SCARD(("<---SCardState--->"));  
2302                                  Result = (SERVER_DWORD) TS_SCardState(in, out);                                  Result = (SERVER_DWORD) TS_SCardState(in, out);
2303                                  break;                                  break;
2304                          }                          }
2305                  default:                  default:
2306                          {                          {
2307                                  DEBUG_SCARD(("<---UNSUPPORTED-FUNC--->\n"));                                  warning("SCARD: Unknown function %d\n", (int) request);
2308                                  Result = 0x80100014;                                  Result = 0x80100014;
2309                                  out_uint8s(out, 256);                                  out_uint8s(out, 256);
2310                                  break;                                  break;
# Line 2350  scard_device_control(NTHANDLE handle, ui Line 2331  scard_device_control(NTHANDLE handle, ui
2331                  out_uint8s(out, addToEnd);                  out_uint8s(out, addToEnd);
2332          }          }
2333    
2334  #ifdef WITH_DEBUG_SCARD          return RD_STATUS_SUCCESS;
         DEBUG_SCARD(("[OUTPUT DUMP]-------------------\n"));  
         hexdump(pbeg, (size_t) (out->p) - (size_t) pbeg);  
         DEBUG_SCARD(("--------------------------------\n"));  
 #endif  
         return STATUS_SUCCESS;  
2335  }  }
2336    
2337  /* Thread functions */  /* Thread functions */
2338    
2339  static STREAM  static STREAM
2340  duplicateStream(PMEM_HANDLE * handle, STREAM s, uint32 buffer_size, BOOL isInputStream)  duplicateStream(PMEM_HANDLE * handle, STREAM s, uint32 buffer_size, RD_BOOL isInputStream)
2341  {  {
2342          STREAM d = SC_xmalloc(handle, sizeof(struct stream));          STREAM d = SC_xmalloc(handle, sizeof(struct stream));
2343          if (d != NULL)          if (d != NULL)
# Line 2410  freeStream(PMEM_HANDLE * handle, STREAM Line 2386  freeStream(PMEM_HANDLE * handle, STREAM
2386  }  }
2387    
2388  static PSCThreadData  static PSCThreadData
2389  SC_addToQueue(NTHANDLE handle, uint32 request, STREAM in, STREAM out)  SC_addToQueue(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
2390  {  {
2391          PMEM_HANDLE lcHandle = NULL;          PMEM_HANDLE lcHandle = NULL;
2392          PSCThreadData data = SC_xmalloc(&lcHandle, sizeof(TSCThreadData));          PSCThreadData data = SC_xmalloc(&lcHandle, sizeof(TSCThreadData));
# Line 2448  SC_addToQueue(NTHANDLE handle, uint32 re Line 2424  SC_addToQueue(NTHANDLE handle, uint32 re
2424                  if (!queueFirst)                  if (!queueFirst)
2425                          queueFirst = data;                          queueFirst = data;
2426    
2427                  pthread_mutex_unlock(&queueEmpty);                  pthread_cond_broadcast(&queueEmpty);
2428                  pthread_mutex_unlock(&queueAccess);                  pthread_mutex_unlock(&queueAccess);
2429          }          }
2430          return data;          return data;
# Line 2468  static PSCThreadData Line 2444  static PSCThreadData
2444  SC_getNextInQueue()  SC_getNextInQueue()
2445  {  {
2446          PSCThreadData Result = NULL;          PSCThreadData Result = NULL;
2447    
2448          pthread_mutex_lock(&queueAccess);          pthread_mutex_lock(&queueAccess);
2449          if (queueFirst != NULL)  
2450            while (queueFirst == NULL)
2451                    pthread_cond_wait(&queueEmpty, &queueAccess);
2452    
2453            Result = queueFirst;
2454            queueFirst = queueFirst->next;
2455            if (!queueFirst)
2456          {          {
2457                  Result = queueFirst;                  queueLast = NULL;
                 queueFirst = queueFirst->next;  
                 if (!queueFirst)  
                 {  
                         queueLast = NULL;  
                         pthread_mutex_trylock(&queueEmpty);  
                 }  
                 Result->next = NULL;  
2458          }          }
2459            Result->next = NULL;
2460    
2461          pthread_mutex_unlock(&queueAccess);          pthread_mutex_unlock(&queueAccess);
2462    
2463          return Result;          return Result;
2464  }  }
2465    
# Line 2498  SC_deviceControl(PSCThreadData data) Line 2477  SC_deviceControl(PSCThreadData data)
2477  static void *  static void *
2478  thread_function(PThreadListElement listElement)  thread_function(PThreadListElement listElement)
2479  {  {
2480  #ifdef WITH_DEBUG_SCARD          pthread_mutex_lock(&listElement->busy);
2481          long sTime = 0;          while (1)
 #endif  
         if ((listElement != NULL) && (listElement->data != NULL))  
2482          {          {
2483                  while (1)                  while (listElement->data == NULL)
2484                  {                          pthread_cond_wait(&listElement->nodata, &listElement->busy);
2485  #ifdef WITH_DEBUG_SCARD  
2486                          sTime = time(NULL);                  SC_deviceControl(listElement->data);
2487  #endif                  listElement->data = NULL;
                         pthread_mutex_lock(&listElement->nodata);  
                         SC_deviceControl(listElement->data);  
                         listElement->data = NULL;  
                         DEBUG_SCARD(("[HANDLING TIME %d]\n", (int) (time(NULL) - sTime)));  
                         pthread_mutex_unlock(&listElement->busy);  
                 }  
2488          }          }
2489            pthread_mutex_unlock(&listElement->busy);
2490    
2491          pthread_exit(NULL);          pthread_exit(NULL);
2492          return NULL;          return NULL;
2493  }  }
# Line 2523  static void Line 2496  static void
2496  SC_handleRequest(PSCThreadData data)  SC_handleRequest(PSCThreadData data)
2497  {  {
2498          int Result = 0;          int Result = 0;
2499          PThreadListElement cur = threadList, last = threadList;          PThreadListElement cur;
   
         DEBUG_SCARD(("[THREAD COUNT %d]\n", threadCount));  
2500    
2501          while (cur)          for (cur = threadList; cur != NULL; cur = cur->next)
2502          {          {
2503                  if (0 == pthread_mutex_trylock(&cur->busy))                  if (cur->data == NULL)
2504                  {                  {
2505                            pthread_mutex_lock(&cur->busy);
2506                            /* double check with lock held.... */
2507                            if (cur->data != NULL)
2508                            {
2509                                    pthread_mutex_unlock(&cur->busy);
2510                                    continue;
2511                            }
2512    
2513                            /* Wake up thread */
2514                          cur->data = data;                          cur->data = data;
2515                          pthread_mutex_unlock(&cur->nodata);                          pthread_cond_broadcast(&cur->nodata);
2516                            pthread_mutex_unlock(&cur->busy);
2517                          return;                          return;
2518                  }                  }
                 else  
                 {  
                         last = cur;  
                         cur = cur->next;  
                 }  
2519          }          }
2520    
2521          cur = SC_xmalloc(&threadListHandle, sizeof(TThreadListElement));          cur = SC_xmalloc(&threadListHandle, sizeof(TThreadListElement));
# Line 2548  SC_handleRequest(PSCThreadData data) Line 2524  SC_handleRequest(PSCThreadData data)
2524    
2525          threadCount++;          threadCount++;
2526    
         cur->next = NULL;  
2527          pthread_mutex_init(&cur->busy, NULL);          pthread_mutex_init(&cur->busy, NULL);
2528          pthread_mutex_init(&cur->nodata, NULL);          pthread_cond_init(&cur->nodata, NULL);
         pthread_mutex_trylock(&cur->busy);  
2529          cur->data = data;          cur->data = data;
         pthread_mutex_unlock(&cur->nodata);  
2530    
2531          Result = pthread_create(&cur->thread, NULL, (void *(*)(void *)) thread_function, cur);          Result = pthread_create(&cur->thread, NULL, (void *(*)(void *)) thread_function, cur);
2532          if (0 != Result)          if (0 != Result)
# Line 2563  SC_handleRequest(PSCThreadData data) Line 2536  SC_handleRequest(PSCThreadData data)
2536                  SC_destroyThreadData(data);                  SC_destroyThreadData(data);
2537                  data = NULL;                  data = NULL;
2538          }          }
2539          else if (last)          cur->next = threadList;
2540                  last->next = cur;          threadList = cur;
         else  
                 threadList = cur;  
2541  }  }
2542    
2543  static void *  static void *
# Line 2576  queue_handler_function(void *data) Line 2547  queue_handler_function(void *data)
2547          while (1)          while (1)
2548          {          {
2549                  cur_data = SC_getNextInQueue();                  cur_data = SC_getNextInQueue();
2550                  if (cur_data != NULL)                  switch (cur_data->request)
2551                  {                  {
2552                          switch (cur_data->request)                          case SC_ESTABLISH_CONTEXT:
2553                          {                          case SC_RELEASE_CONTEXT:
2554                                  case SC_ESTABLISH_CONTEXT:                                  {
2555                                  case SC_RELEASE_CONTEXT:                                          SC_deviceControl(cur_data);
2556                                          {                                          break;
2557                                                  SC_deviceControl(cur_data);                                  }
2558                                                  break;                          default:
2559                                          }                                  {
2560                                  default:                                          SC_handleRequest(cur_data);
2561                                          {                                          break;
2562                                                  SC_handleRequest(cur_data);                                  }
                                                 break;  
                                         }  
                         }  
                         cur_data = NULL;  
2563                  }                  }
                 else  
                         pthread_mutex_lock(&queueEmpty);  
2564          }          }
2565          return NULL;          return NULL;
2566  }  }
2567    
2568  static NTSTATUS  static RD_NTSTATUS
2569  thread_wrapper(NTHANDLE handle, uint32 request, STREAM in, STREAM out)  thread_wrapper(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
2570  {  {
2571          if (SC_addToQueue(handle, request, in, out))          if (SC_addToQueue(handle, request, in, out))
2572                  return STATUS_PENDING | 0xC0000000;                  return RD_STATUS_PENDING | 0xC0000000;
2573          else          else
2574                  return STATUS_NO_SUCH_FILE;                  return RD_STATUS_NO_SUCH_FILE;
2575  }  }
2576    
2577  DEVICE_FNS scard_fns = {  DEVICE_FNS scard_fns = {
# Line 2648  scard_unlock(int lock) Line 2613  scard_unlock(int lock)
2613  {  {
2614          pthread_mutex_unlock(scard_mutex[lock]);          pthread_mutex_unlock(scard_mutex[lock]);
2615  }  }
   
 STREAM  
 scard_tcp_init(void)  
 {  
         STREAM result = NULL;  
   
         result = &out[cur_stream_id];  
         cur_stream_id = (cur_stream_id + 1) % STREAM_COUNT;  
   
         return result;  
 }  
   
 void  
 scard_tcp_connect(void)  
 {  
         int i;  
   
         for (i = 0; i < STREAM_COUNT; i++)  
         {  
                 out[i].size = 4096;  
                 out[i].data = (uint8 *) xmalloc(out[i].size);  
         }  
 }  
   
 void  
 scard_tcp_reset_state(void)  
 {  
         int i;  
         struct stream *p;  
   
         for (i = 0, p = out; i < STREAM_COUNT; i++, p++)  
         {  
                 if (p->data != NULL)  
                         xfree(p->data);  
                 p->p = NULL;  
                 p->end = NULL;  
                 p->data = NULL;  
                 p->size = 0;  
                 p->iso_hdr = NULL;  
                 p->mcs_hdr = NULL;  
                 p->sec_hdr = NULL;  
                 p->rdp_hdr = NULL;  
                 p->channel_hdr = NULL;  
         }  
 }  
Legend:
Removed from v.1329  
changed lines
  Added in v.1507
  ViewVC Help
Powered by ViewVC 1.1.26