/[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

revision 1372 by jsorg71, Mon Jan 8 04:47:06 2007 UTC revision 1416 by ossman_, Tue Jul 3 14:20:04 2007 UTC
# Line 42  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    
 static struct stream out[STREAM_COUNT];  
 static int cur_stream_id = 0;  
46  static pthread_mutex_t **scard_mutex = NULL;  static pthread_mutex_t **scard_mutex = NULL;
47    
48  static uint32 curDevice = 0, curId = 0, curBytesOut = 0;  static uint32 curDevice = 0, curId = 0, curBytesOut = 0;
# Line 127  scard_enum_devices(uint32 * id, char *op Line 124  scard_enum_devices(uint32 * id, char *op
124          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
125          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
126          {          {
127                  error("[SMART CARD: PCSC service not available]\n");                  error("scard_enum_devices: PCSC service not available\n");
128                  return 0;                  return 0;
129          }          }
130          else          else
# Line 137  scard_enum_devices(uint32 * id, char *op Line 134  scard_enum_devices(uint32 * id, char *op
134    
135          if (0 != pthread_mutex_init(&queueAccess, NULL))          if (0 != pthread_mutex_init(&queueAccess, NULL))
136          {          {
137                  error("[SMART CARD: Can't initialize queue access mutex]\n");                  error("scard_enum_devices: Can't initialize queue access mutex\n");
138                  return 0;                  return 0;
139          }          }
140    
141          if (0 != pthread_mutex_init(&queueEmpty, NULL))          if (0 != pthread_mutex_init(&queueEmpty, NULL))
142          {          {
143                  error("[SMART CARD: Can't initialize queue control mutex]\n");                  error("scard_enum_devices: Can't initialize queue control mutex\n");
144                  return 0;                  return 0;
145          }          }
146    
147          if (0 != pthread_mutex_init(&hcardAccess, NULL))          if (0 != pthread_mutex_init(&hcardAccess, NULL))
148          {          {
149                  error("[SMART CARD: Can't initialize hcard list access mutex]\n");                  error("scard_enum_devices: Can't initialize hcard list access mutex\n");
150                  return 0;                  return 0;
151          }          }
152    
153          if (0 !=          if (0 !=
154              pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL))              pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL))
155          {          {
156                  error("[SMART CARD: Can't create queue handling Thread]\n");                  error("scard_enum_devices: Can't create queue handling Thread\n");
157                  return 0;                  return 0;
158          }          }
159    
# Line 604  TS_SCardEstablishContext(STREAM in, STRE Line 601  TS_SCardEstablishContext(STREAM in, STRE
601          MYPCSC_SCARDCONTEXT hContext;          MYPCSC_SCARDCONTEXT hContext;
602          /* code segment  */          /* code segment  */
603    
604          DEBUG_SCARD(("Establishing PC/SC Context... \n"));          DEBUG_SCARD(("SCARD: SCardEstablishContext()\n"));
605          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
606          if (rv)          if (rv)
607          {          {
608                  DEBUG_SCARD(("<--ERROR SCardEstablishContext Code=0x%.8x, %s]-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
609                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
610          }          }
611          else          else
612          {          {
613                  DEBUG_SCARD(("<--SUCCESS SCardEstablishContext-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (context: 0x%08x)\n", (unsigned) hContext));
614          }          }
615    
616          out_uint32_le(out, 0x00000004);          out_uint32_le(out, 0x00000004);
# Line 632  TS_SCardReleaseContext(STREAM in, STREAM Line 629  TS_SCardReleaseContext(STREAM in, STREAM
629    
630          in->p += 0x1C;          in->p += 0x1C;
631          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
632          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardReleaseContext(context: 0x%08x)\n", (unsigned) hContext));
         DEBUG_SCARD(("Releasing context... \n"));  
633          rv = SCardReleaseContext((MYPCSC_SCARDCONTEXT) hContext);          rv = SCardReleaseContext((MYPCSC_SCARDCONTEXT) hContext);
634    
635          if (rv)          if (rv)
636          {          {
637                  DEBUG_SCARD(("<--ERROR SCardReleaseContext Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
638                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
639          }          }
640          else          else
641          {          {
642                  DEBUG_SCARD(("<--SUCCESS SCardReleaseContext-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
643          }          }
644    
645          return rv;          return rv;
# Line 660  TS_SCardIsValidContext(STREAM in, STREAM Line 656  TS_SCardIsValidContext(STREAM in, STREAM
656    
657          in->p += 0x1C;          in->p += 0x1C;
658          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
659          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardIsValidContext(context: 0x%08x)\n", (unsigned) hContext));
         DEBUG_SCARD(("Checking... \n"));  
660          /* 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 */
661    
662          readers = SC_xmalloc(&lcHandle, 1024);          readers = SC_xmalloc(&lcHandle, 1024);
# Line 672  TS_SCardIsValidContext(STREAM in, STREAM Line 667  TS_SCardIsValidContext(STREAM in, STREAM
667    
668          if (rv)          if (rv)
669          {          {
670                  DEBUG_SCARD(("<--ERROR SCardListReaders (no SCardIsValidContext) Code=0x%.8x, %s-->\n", (unsigned int) rv, pcsc_stringify_error(rv)));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
671                                 pcsc_stringify_error(rv), (unsigned int) rv));
672                  rv = SCARD_E_INVALID_HANDLE;                  rv = SCARD_E_INVALID_HANDLE;
673          }          }
674          else          else
675          {          {
676                  DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
677          }          }
678    
679          outForceAlignment(out, 8);          outForceAlignment(out, 8);
# Line 700  TS_SCardListReaders(STREAM in, STREAM ou Line 696  TS_SCardListReaders(STREAM in, STREAM ou
696    
697          in->p += 0x2C;          in->p += 0x2C;
698          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
699          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardListReaders(context: 0x%08x)\n", (unsigned) hContext));
700          plen1 = out->p;          plen1 = out->p;
701          out_uint32_le(out, 0x00000000); /* Temp value for data length as 0x0 */          out_uint32_le(out, 0x00000000); /* Temp value for data length as 0x0 */
702          out_uint32_le(out, 0x01760650);          out_uint32_le(out, 0x01760650);
# Line 717  TS_SCardListReaders(STREAM in, STREAM ou Line 713  TS_SCardListReaders(STREAM in, STREAM ou
713          readers[1] = '\0';          readers[1] = '\0';
714          rv = SCardListReaders((MYPCSC_SCARDCONTEXT) hContext, NULL, readers, &cchReaders);          rv = SCardListReaders((MYPCSC_SCARDCONTEXT) hContext, NULL, readers, &cchReaders);
715          cur = readers;          cur = readers;
716          if (!rv)          if (rv != SCARD_S_SUCCESS)
717            {
718                    DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
719                                 pcsc_stringify_error(rv), (unsigned int) rv));
720            }
721            else
722          {          {
723                  int i;                  int i;
724                  PSCNameMapRec tmpMap;                  PSCNameMapRec tmpMap;
725  #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  
726                  for (i = 0, tmpMap = nameMapList; i < nameMapCount; i++, tmpMap++)                  for (i = 0, tmpMap = nameMapList; i < nameMapCount; i++, tmpMap++)
727                  {                  {
728                          dataLength += outString(out, tmpMap->alias, wide);                          dataLength += outString(out, tmpMap->alias, wide);
# Line 737  TS_SCardListReaders(STREAM in, STREAM ou Line 735  TS_SCardListReaders(STREAM in, STREAM ou
735                          while (lenSC > 0)                          while (lenSC > 0)
736                          {                          {
737                                  if (!hasAlias(cur))                                  if (!hasAlias(cur))
738                                    {
739                                            DEBUG_SCARD(("SCARD:    \"%s\"\n", cur));
740                                          dataLength += outString(out, cur, wide);                                          dataLength += outString(out, cur, wide);
741                                    }
742                                  cur = (void *) ((unsigned char *) cur + lenSC + 1);                                  cur = (void *) ((unsigned char *) cur + lenSC + 1);
743                                  lenSC = strlen(cur);                                  lenSC = strlen(cur);
744                          }                          }
# Line 776  TS_SCardConnect(STREAM in, STREAM out, R Line 777  TS_SCardConnect(STREAM in, STREAM out, R
777          in->p += 0x1C;          in->p += 0x1C;
778          in_uint32_le(in, dwShareMode);          in_uint32_le(in, dwShareMode);
779          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));  
780          inReaderName(&lcHandle, in, &szReader, wide);          inReaderName(&lcHandle, in, &szReader, wide);
         DEBUG_SCARD(("[CONNECT TO READER \"%s\"\n", (szReader != NULL) ? (szReader) : ("NULL")));  
781          in->p += 0x04;          in->p += 0x04;
782          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
783          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"));
784          rv = SCardConnect(hContext, szReader, (MYPCSC_DWORD) dwShareMode,          rv = SCardConnect(hContext, szReader, (MYPCSC_DWORD) dwShareMode,
785                            (MYPCSC_DWORD) dwPreferredProtocol, &myHCard, &dwActiveProtocol);                            (MYPCSC_DWORD) dwPreferredProtocol, &myHCard, &dwActiveProtocol);
786          hCard = scHandleToServer(myHCard);          hCard = scHandleToServer(myHCard);
         DEBUG_SCARD(("[RECEIVED HCARD 0x%016lx]\n", (unsigned long) myHCard));  
         DEBUG_SCARD(("[MANGLED  HCARD 0x%08x]\n", hCard));  
787          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
788          {          {
789                  DEBUG_SCARD(("<--ERROR SCardConnect Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
790                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
791          }          }
792          else          else
793          {          {
794                  char *szVendor = getVendor(szReader);                  char *szVendor = getVendor(szReader);
795                  DEBUG_SCARD(("<--SUCCESS ScardConnect-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (hcard: 0x%08x [0x%08lx])\n",
796                                 (unsigned) hCard, (unsigned long) myHCard));
797                  if (szVendor && (strlen(szVendor) > 0))                  if (szVendor && (strlen(szVendor) > 0))
798                  {                  {
799                          DEBUG_SCARD(("Set Attribute ATTR_VENDOR_NAME\n"));                          DEBUG_SCARD(("SCARD: Set Attribute ATTR_VENDOR_NAME\n"));
800                          pthread_mutex_lock(&hcardAccess);                          pthread_mutex_lock(&hcardAccess);
801                          PSCHCardRec hcard = xmalloc(sizeof(TSCHCardRec));                          PSCHCardRec hcard = xmalloc(sizeof(TSCHCardRec));
802                          if (hcard)                          if (hcard)
# Line 855  TS_SCardReconnect(STREAM in, STREAM out) Line 852  TS_SCardReconnect(STREAM in, STREAM out)
852          in->p += 0x04;          in->p += 0x04;
853          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
854          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
855          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));  
856          rv = SCardReconnect(myHCard, (MYPCSC_DWORD) dwShareMode, (MYPCSC_DWORD) dwPreferredProtocol,          rv = SCardReconnect(myHCard, (MYPCSC_DWORD) dwShareMode, (MYPCSC_DWORD) dwPreferredProtocol,
857                              (MYPCSC_DWORD) dwInitialization, &dwActiveProtocol);                              (MYPCSC_DWORD) dwInitialization, &dwActiveProtocol);
858          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
859          {          {
860                  DEBUG_SCARD(("<--ERROR SCardReconnect Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
861                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
862          }          }
863          else          else
864          {          {
865                  DEBUG_SCARD(("<--SUCCESS SCardReconnect-->\n"));                  DEBUG_SCARD(("SCARD: -> Success (proto: 0x%08x)\n", (unsigned) dwActiveProtocol));
866          }          }
867    
868          outForceAlignment(out, 8);          outForceAlignment(out, 8);
# Line 894  TS_SCardDisconnect(STREAM in, STREAM out Line 886  TS_SCardDisconnect(STREAM in, STREAM out
886          in->p += 0x04;          in->p += 0x04;
887          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
888    
889          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));  
890    
891          pthread_mutex_lock(&hcardAccess);          pthread_mutex_lock(&hcardAccess);
892          PSCHCardRec hcard = hcardFirst;          PSCHCardRec hcard = hcardFirst;
# Line 922  TS_SCardDisconnect(STREAM in, STREAM out Line 912  TS_SCardDisconnect(STREAM in, STREAM out
912    
913          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
914          {          {
915                  DEBUG_SCARD(("<--ERROR SCardDisconnect Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
916                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
917          }          }
918          else          else
919          {          {
920                  DEBUG_SCARD(("<--SUCCESS SCardDisconnect-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
921          }          }
922    
923          outForceAlignment(out, 8);          outForceAlignment(out, 8);
# Line 953  needStatusRecheck(MYPCSC_DWORD rv, MYPCS Line 943  needStatusRecheck(MYPCSC_DWORD rv, MYPCS
943          return recall;          return recall;
944  }  }
945    
946  static D_BOOL  static RD_BOOL
947  mappedStatus(MYPCSC_DWORD code)  mappedStatus(MYPCSC_DWORD code)
948  {  {
949          code >>= 16;          code >>= 16;
# Line 1038  TS_SCardGetStatusChange(STREAM in, STREA Line 1028  TS_SCardGetStatusChange(STREAM in, STREA
1028          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1029          in->p += 0x04;          in->p += 0x04;
1030    
1031          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardGetStatusChange(context: 0x%08x, timeout: 0x%08x, count: %d)\n",
1032          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)));  
1033    
1034          if (dwCount > 0)          if (dwCount > 0)
1035          {          {
# Line 1059  TS_SCardGetStatusChange(STREAM in, STREA Line 1047  TS_SCardGetStatusChange(STREAM in, STREA
1047                          in->p += 0x04;                          in->p += 0x04;
1048                          in_uint8a(in, cur, SERVER_SCARDSTATESIZE);                          in_uint8a(in, cur, SERVER_SCARDSTATESIZE);
1049                  }                  }
 #ifdef WITH_DEBUG_SCARD  
                 DEBUG_SCARD(("[READERS DUMP 1]------------------\n"));  
                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));  
 #endif  
   
1050    
1051                  for (i = 0, cur = rsArray, curState = stateArray;                  for (i = 0, cur = rsArray, curState = stateArray;
1052                       i < dwCount; i++, cur++, curState++)                       i < dwCount; i++, cur++, curState++)
# Line 1097  TS_SCardGetStatusChange(STREAM in, STREA Line 1080  TS_SCardGetStatusChange(STREAM in, STREA
1080    
1081                          in->p += 0x08;                          in->p += 0x08;
1082                          in_uint32_le(in, dataLength);                          in_uint32_le(in, dataLength);
                         DEBUG_SCARD(("[%d] Data Length %d]\n", (unsigned int) i, dataLength));  
1083                          inRepos(in,                          inRepos(in,
1084                                  inString(&lcHandle, in, (char **) &(cur->szReader), dataLength,                                  inString(&lcHandle, in, (char **) &(cur->szReader), dataLength,
1085                                           wide));                                           wide));
1086    
1087                          if (strcmp(cur->szReader, "\\\\?PnP?\\Notification") == 0)                          if (strcmp(cur->szReader, "\\\\?PnP?\\Notification") == 0)
1088                                  cur->dwCurrentState |= SCARD_STATE_IGNORE;                                  cur->dwCurrentState |= SCARD_STATE_IGNORE;
1089    
1090                            DEBUG_SCARD(("SCARD:    \"%s\"\n", cur->szReader ? cur->szReader : "NULL"));
1091                            DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
1092                                         (unsigned) cur->pvUserData, (unsigned) cur->dwCurrentState,
1093                                         (unsigned) cur->dwEventState));
1094                            DEBUG_SCARD(("SCARD:            current state: 0x%08x\n",
1095                                         (unsigned) *curState));
1096                  }                  }
 #ifdef WITH_DEBUG_SCARD  
                 DEBUG_SCARD(("[READERS DUMP 2]------------------\n"));  
                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));  
 #endif  
1097          }          }
1098          else          else
1099          {          {
# Line 1116  TS_SCardGetStatusChange(STREAM in, STREA Line 1101  TS_SCardGetStatusChange(STREAM in, STREA
1101                  stateArray = NULL;                  stateArray = NULL;
1102          }          }
1103    
         DEBUG_SCARD(("\nCalling SCardGetStatusChange...\n"));  
   
   
1104          myRsArray = SC_xmalloc(&lcHandle, dwCount * sizeof(MYPCSC_SCARD_READERSTATE_A));          myRsArray = SC_xmalloc(&lcHandle, dwCount * sizeof(MYPCSC_SCARD_READERSTATE_A));
1105          if (!rsArray)          if (!rsArray)
1106                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
1107          memset(myRsArray, 0, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));          memset(myRsArray, 0, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));
1108          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  
1109    
1110          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, (MYPCSC_DWORD) dwTimeout,          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, (MYPCSC_DWORD) dwTimeout,
1111                                    myRsArray, (MYPCSC_DWORD) dwCount);                                    myRsArray, (MYPCSC_DWORD) dwCount);
# Line 1135  TS_SCardGetStatusChange(STREAM in, STREA Line 1113  TS_SCardGetStatusChange(STREAM in, STREA
1113    
1114          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1115          {          {
1116                  DEBUG_SCARD(("<--ERROR SCardGetStatusChange Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1117                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1118          }          }
1119          else          else
1120          {          {
1121                  DEBUG_SCARD(("<--SUCCESS SCardGetStatusChange-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1122          }          }
1123    
 #ifdef WITH_DEBUG_SCARD  
         if (dwCount > 0)  
         {  
                 DEBUG_SCARD(("[READERS DUMP]------------------\n"));  
                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));  
         }  
 #endif  
   
1124          out_uint32_le(out, dwCount);          out_uint32_le(out, dwCount);
1125          out_uint32_le(out, 0x00084dd8);          out_uint32_le(out, 0x00084dd8);
1126          out_uint32_le(out, dwCount);          out_uint32_le(out, dwCount);
# Line 1185  TS_SCardGetStatusChange(STREAM in, STREA Line 1155  TS_SCardGetStatusChange(STREAM in, STREA
1155  #endif  #endif
1156                  cur->dwEventState = incStatus(cur->dwEventState, False);                  cur->dwEventState = incStatus(cur->dwEventState, False);
1157    
1158                    DEBUG_SCARD(("SCARD:    \"%s\"\n", cur->szReader ? cur->szReader : "NULL"));
1159                    DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
1160                                 (unsigned) cur->pvUserData, (unsigned) cur->dwCurrentState,
1161                                 (unsigned) cur->dwEventState));
1162    
1163                  out_uint8p(out, (void *) ((unsigned char **) cur + 2),                  out_uint8p(out, (void *) ((unsigned char **) cur + 2),
1164                             sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));                             sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));
1165          }          }
# Line 1201  TS_SCardCancel(STREAM in, STREAM out) Line 1176  TS_SCardCancel(STREAM in, STREAM out)
1176    
1177          in->p += 0x1C;          in->p += 0x1C;
1178          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1179          DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));          DEBUG_SCARD(("SCARD: SCardCancel(context: 0x%08x)\n", (unsigned) hContext));
         DEBUG_SCARD(("Canceling... \n"));  
1180          rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext);          rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext);
1181          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1182          {          {
1183                  DEBUG_SCARD(("<--ERROR SCardCancel Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1184                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1185          }          }
1186          else          else
1187          {          {
1188                  DEBUG_SCARD(("<--SUCCESS SCardCancel-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1189          }          }
1190          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1191          return rv;          return rv;
# Line 1234  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1208  TS_SCardLocateCardsByATR(STREAM in, STRE
1208    
1209          in->p += 0x2C;          in->p += 0x2C;
1210          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));  
1211          in_uint32_le(in, atrMaskCount);          in_uint32_le(in, atrMaskCount);
1212          pAtrMasks = SC_xmalloc(&lcHandle, atrMaskCount * sizeof(SCARD_ATRMASK_L));          pAtrMasks = SC_xmalloc(&lcHandle, atrMaskCount * sizeof(SCARD_ATRMASK_L));
1213          if (!pAtrMasks)          if (!pAtrMasks)
# Line 1247  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1220  TS_SCardLocateCardsByATR(STREAM in, STRE
1220                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
1221          memset(rsArray, 0, readerCount * sizeof(SCARD_READERSTATE_A));          memset(rsArray, 0, readerCount * sizeof(SCARD_READERSTATE_A));
1222    
1223            DEBUG_SCARD(("SCARD: SCardLocateCardsByATR(context: 0x%08x, atrs: %d, readers: %d)\n",
1224                         (unsigned) hContext, (int) atrMaskCount, (int) readerCount));
1225    
1226            for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)
1227            {
1228                    DEBUG_SCARD(("SCARD:    ATR: "));
1229                    for (j = 0; j < pAtrMasks->cbAtr; j++)
1230                    {
1231                    DEBUG_SCARD(("%02x%c",
1232                                         (unsigned) (unsigned char) cur->rgbAtr[j],
1233                                         (j == pAtrMasks->cbAtr - 1) ? ' ' : ':'))}
1234                    DEBUG_SCARD(("\n"));
1235                    DEBUG_SCARD(("SCARD:         "));
1236                    for (j = 0; j < pAtrMasks->cbAtr; j++)
1237                    {
1238                    DEBUG_SCARD(("%02x%c",
1239                                         (unsigned) (unsigned char) cur->rgbMask[j],
1240                                         (j == pAtrMasks->cbAtr - 1) ? ' ' : ':'))}
1241                    DEBUG_SCARD(("\n"));
1242            }
1243    
1244          for (i = 0, rsCur = (SERVER_LPSCARD_READERSTATE_A) ((unsigned char **) rsArray + 2);          for (i = 0, rsCur = (SERVER_LPSCARD_READERSTATE_A) ((unsigned char **) rsArray + 2);
1245               i < readerCount; i++, rsCur++)               i < readerCount; i++, rsCur++)
1246          {          {
# Line 1262  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1256  TS_SCardLocateCardsByATR(STREAM in, STRE
1256          for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)          for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)
1257          {          {
1258                  inReaderName(&lcHandle, in, (char **) &rsCur->szReader, wide);                  inReaderName(&lcHandle, in, (char **) &rsCur->szReader, wide);
1259                  DEBUG_SCARD(("[CHECK READER %s]\n",                  DEBUG_SCARD(("SCARD:    \"%s\"\n", rsCur->szReader ? rsCur->szReader : "NULL"));
1260                               (rsCur->szReader) ? (rsCur->szReader) : ("NULL")));                  DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
1261                                 (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState,
1262                                 (unsigned) rsCur->dwEventState));
1263          }          }
1264    
         DEBUG_SCARD(("[CALL subfunction \"SCardGetStatusChange\"]\n"));  
1265          /* FIXME segfault here. */          /* FIXME segfault here. */
1266          myRsArray = SC_xmalloc(&lcHandle, readerCount * sizeof(MYPCSC_SCARD_READERSTATE_A));          myRsArray = SC_xmalloc(&lcHandle, readerCount * sizeof(MYPCSC_SCARD_READERSTATE_A));
1267          if (!myRsArray)          if (!myRsArray)
1268                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
1269            copyReaderState_ServerToMyPCSC(rsArray, myRsArray, readerCount);
1270          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, 0x00000001, myRsArray,          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, 0x00000001, myRsArray,
1271                                    readerCount);                                    readerCount);
1272          copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount);          copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount);
1273          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1274          {          {
1275                  DEBUG_SCARD(("<--ERROR SCardGetStatusChange (no SCardLocateCardsByATR) Code=0x%.8x, %s-->\n", (unsigned int) rv, pcsc_stringify_error(rv)));                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1276                                 pcsc_stringify_error(rv), (unsigned int) rv));
1277          }          }
1278          else          else
1279          {          {
1280                  DEBUG_SCARD(("<--SUCCESS SCardGetStatusChange (no SCardLocateCardsByATR)-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1281                  cur = pAtrMasks;                  cur = pAtrMasks;
1282                  for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)                  for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)
1283                  {                  {
# Line 1289  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1286  TS_SCardLocateCardsByATR(STREAM in, STRE
1286                                  RD_BOOL equal = 1;                                  RD_BOOL equal = 1;
1287                                  for (k = 0; k < cur->cbAtr; k++)                                  for (k = 0; k < cur->cbAtr; k++)
1288                                  {                                  {
1289                                          /*  This line check if them equal */                                          if ((cur->rgbAtr[k] & cur->rgbMask[k]) !=
1290                                          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])){ */  
1291                                          {                                          {
1292                                                  equal = 0;                                                  equal = 0;
1293                                                  break;                                                  break;
# Line 1300  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1295  TS_SCardLocateCardsByATR(STREAM in, STRE
1295                                  }                                  }
1296                                  if (equal)                                  if (equal)
1297                                  {                                  {
                                         DEBUG_SCARD(("[FOUND]\n"));  
1298                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */
1299                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));
1300                                            DEBUG_SCARD(("SCARD:    \"%s\"\n",
1301                                                         rsCur->szReader ? rsCur->szReader : "NULL"));
1302                                            DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n", (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState, (unsigned) rsCur->dwEventState));
1303                                  }                                  }
1304                          }                          }
1305                  }                  }
# Line 1333  TS_SCardBeginTransaction(STREAM in, STRE Line 1330  TS_SCardBeginTransaction(STREAM in, STRE
1330          in->p += 0x30;          in->p += 0x30;
1331          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
1332          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1333          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardBeginTransaction(hcard: 0x%08x [0x%08lx])\n",
1334          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));                       (unsigned) hCard, (unsigned long) myHCard));
1335          rv = SCardBeginTransaction(myHCard);          rv = SCardBeginTransaction(myHCard);
1336          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1337          {          {
1338                  DEBUG_SCARD(("<--ERROR SCardBeginTransaction Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1339                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1340          }          }
1341          else          else
1342          {          {
1343                  DEBUG_SCARD(("<--SUCCESS SCardBeginTransaction-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1344          }          }
1345          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1346          return rv;          return rv;
# Line 1367  TS_SCardEndTransaction(STREAM in, STREAM Line 1364  TS_SCardEndTransaction(STREAM in, STREAM
1364          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));
1365          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));
1366    
1367            DEBUG_SCARD(("SCARD: SCardEndTransaction(hcard: 0x%08x [0x%08lx], disposition: 0x%08x)\n",
1368                         (unsigned) hCard, (unsigned long) myHCard, (unsigned) dwDisposition));
1369          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);
1370          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1371          {          {
1372                  DEBUG_SCARD(("<--ERROR SCardEndTransaction Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1373                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1374          }          }
1375          else          else
1376          {          {
1377                  DEBUG_SCARD(("<--SUCCESS SCardEndTransaction-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1378          }          }
1379          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1380          return rv;          return rv;
# Line 1509  TS_SCardTransmit(STREAM in, STREAM out) Line 1508  TS_SCardTransmit(STREAM in, STREAM out)
1508          else          else
1509                  pioRecvPci = NULL;                  pioRecvPci = NULL;
1510    
1511  #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  
1512    
1513          myCbRecvLength = cbRecvLength;          myCbRecvLength = cbRecvLength;
1514          myPioSendPci = SC_xmalloc(&lcHandle,          myPioSendPci = SC_xmalloc(&lcHandle,
# Line 1569  TS_SCardTransmit(STREAM in, STREAM out) Line 1540  TS_SCardTransmit(STREAM in, STREAM out)
1540          if (cbRecvLength > 448)          if (cbRecvLength > 448)
1541          {          {
1542                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);
1543                  DEBUG_SCARD(("[RECV LEN %d -> %d]\n", (unsigned int) cbRecvLength, 400));                  DEBUG_SCARD(("SCARD:    Truncated %d to %d\n", (unsigned int) cbRecvLength, 448));
1544                  cbRecvLength = 448;                  cbRecvLength = 448;
1545          }          }
1546    
1547          if (pioRecvPci)          if (pioRecvPci)
1548          {          {
1549                  copyIORequest_MyPCSCToServer(myPioRecvPci, pioRecvPci);                  /*
1550                     * pscs-lite mishandles this structure in some cases.
1551                     * make sure we only copy it if it is valid.
1552                     */
1553                    if (myPioRecvPci->cbPciLength >= sizeof(MYPCSC_SCARD_IO_REQUEST))
1554                            copyIORequest_MyPCSCToServer(myPioRecvPci, pioRecvPci);
1555          }          }
1556    
1557          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1558          {          {
1559                  DEBUG_SCARD(("<--ERROR SCardTransmit Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1560                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1561          }          }
1562          else          else
1563          {          {
1564  #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  
1565  #if 0  #if 0
1566                  if ((pioRecvPci != NULL) && (pioRecvPci->cbPciLength > 0))                  if ((pioRecvPci != NULL) && (pioRecvPci->cbPciLength > 0))
1567                  {                  {
# Line 1647  TS_SCardStatus(STREAM in, STREAM out, RD Line 1613  TS_SCardStatus(STREAM in, STREAM out, RD
1613          in->p += 0x04;          in->p += 0x04;
1614          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1615    
1616          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));  
1617    
1618          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)
1619                  dwReaderLen = SCARD_MAX_MEM;                  dwReaderLen = SCARD_MAX_MEM;
# Line 1678  TS_SCardStatus(STREAM in, STREAM out, RD Line 1641  TS_SCardStatus(STREAM in, STREAM out, RD
1641    
1642          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1643          {          {
1644                  DEBUG_SCARD(("<--ERROR SCardStatus Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1645                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1646                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1647          }          }
1648          else          else
1649          {          {
1650  #ifdef WITH_DEBUG_SCARD                  int i;
1651                  DEBUG_SCARD(("<--SUCCESS SCardStatus-->\n"));  
1652                  DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));                  DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
1653                  DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));                               (unsigned) dwState, (unsigned) dwProtocol));
1654                  DEBUG_SCARD(("[Reader Name]\n"));                  DEBUG_SCARD(("SCARD:        Reader: \"%s\"\n", readerName ? readerName : "NULL"));
1655                  hexdump((unsigned char *) readerName, dwReaderLen);                  DEBUG_SCARD(("SCARD:        ATR: "));
1656                  DEBUG_SCARD(("[Atr]\n"));                  for (i = 0; i < dwAtrLen; i++)
1657                  hexdump(atr, dwAtrLen);                  {
1658  #endif                          DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
1659                    }
1660                    DEBUG_SCARD(("\n"));
1661    
1662                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
1663                          dwState = 0x00000006;                          dwState = 0x00000006;
1664                  else                  else
# Line 1762  TS_SCardState(STREAM in, STREAM out) Line 1728  TS_SCardState(STREAM in, STREAM out)
1728          in->p += 0x04;          in->p += 0x04;
1729          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1730    
1731          DEBUG_SCARD(("[hCard 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardState(hcard: 0x%08x [0x%08lx], atr len: %d bytes)\n",
1732          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard, (int) dwAtrLen));
         DEBUG_SCARD(("[dwAtrLen %d]\n", (unsigned int) dwAtrLen));  
1733    
1734          dwReaderLen = SCARD_MAX_MEM;          dwReaderLen = SCARD_MAX_MEM;
1735          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)
# Line 1790  TS_SCardState(STREAM in, STREAM out) Line 1755  TS_SCardState(STREAM in, STREAM out)
1755    
1756          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1757          {          {
1758                  DEBUG_SCARD(("<--ERROR SCardStatus (no ScardState) Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1759                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1760                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1761          }          }
1762          else          else
1763          {          {
1764  #ifdef WITH_DEBUG_SCARD                  int i;
1765                  DEBUG_SCARD(("<--SUCCESS SCardStatus (no ScardState)-->\n"));  
1766                  DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));                  DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
1767                  DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));                               (unsigned) dwState, (unsigned) dwProtocol));
1768                  DEBUG_SCARD(("[Atr]\n"));                  DEBUG_SCARD(("SCARD:        ATR: "));
1769                  hexdump(atr, dwAtrLen);                  for (i = 0; i < dwAtrLen; i++)
1770  #endif                  {
1771                            DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
1772                    }
1773                    DEBUG_SCARD(("\n"));
1774    
1775                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
1776                          dwState = 0x00000006;                          dwState = 0x00000006;
1777                  else                  else
# Line 1856  TS_SCardListReaderGroups(STREAM in, STRE Line 1825  TS_SCardListReaderGroups(STREAM in, STRE
1825          in->p += 0x04;          in->p += 0x04;
1826          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1827    
1828            DEBUG_SCARD(("SCARD: SCardListReaderGroups(context: 0x%08x, groups: %d)\n",
1829                         (unsigned) hContext, (int) dwGroups));
1830    
1831          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)
1832                  dwGroups = SCARD_MAX_MEM;                  dwGroups = SCARD_MAX_MEM;
1833    
# Line 1869  TS_SCardListReaderGroups(STREAM in, STRE Line 1841  TS_SCardListReaderGroups(STREAM in, STRE
1841    
1842          if (rv)          if (rv)
1843          {          {
1844                  DEBUG_SCARD(("<--ERROR SCardListReaderGroups Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1845                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1846                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1847          }          }
1848          else          else
1849          {          {
1850                  DEBUG_SCARD(("<--SUCCESS SCardListReaderGroups-->\n"));                  int i;
1851                    char *cur;
1852    
1853                    DEBUG_SCARD(("SCARD: -> Success\n"));
1854                    for (i = 0, cur = szGroups; i < dwGroups; i++, cur += strlen(cur) + 1)
1855                    {
1856                            DEBUG_SCARD(("SCARD:    %s\n", cur));
1857                    }
1858          }          }
1859    
1860    
# Line 1912  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1891  TS_SCardGetAttrib(STREAM in, STREAM out)
1891    
1892          dwAttrId = dwAttrId & 0x0000FFFF;          dwAttrId = dwAttrId & 0x0000FFFF;
1893    
1894          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardGetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
1895          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard,
1896          DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));                       (unsigned) dwAttrId, (int) dwAttrLen));
         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));  
1897    
1898          if (dwAttrLen > MAX_BUFFER_SIZE)          if (dwAttrLen > MAX_BUFFER_SIZE)
1899                  dwAttrLen = MAX_BUFFER_SIZE;                  dwAttrLen = MAX_BUFFER_SIZE;
# Line 1941  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1919  TS_SCardGetAttrib(STREAM in, STREAM out)
1919    
1920          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)
1921          {          {
1922                  DEBUG_SCARD(("Get Attribute ATTR_VENDOR_NAME\n"));                  DEBUG_SCARD(("SCARD:    Faking attribute ATTR_VENDOR_NAME\n"));
1923                  pthread_mutex_lock(&hcardAccess);                  pthread_mutex_lock(&hcardAccess);
1924                  PSCHCardRec hcard = hcardFirst;                  PSCHCardRec hcard = hcardFirst;
1925                  while (hcard)                  while (hcard)
# Line 1961  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1939  TS_SCardGetAttrib(STREAM in, STREAM out)
1939    
1940          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1941          {          {
1942                  DEBUG_SCARD(("<--ERROR SCardGetAttrib Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1943                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1944                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1945          }          }
1946          else          else
1947          {          {
1948  #ifdef WITH_DEBUG_SCARD                  DEBUG_SCARD(("SCARD: -> Success (%d bytes)\n", (int) dwAttrLen));
1949                  DEBUG_SCARD(("<--SUCCESS SCardGetAttrib-->\n"));  
                 DEBUG_SCARD(("[LENGTH %d]\n", (unsigned int) dwAttrLen));  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
                 hexdump(pbAttr, dwAttrLen);  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
 #endif  
1950                  out_uint32_le(out, dwAttrLen);                  out_uint32_le(out, dwAttrLen);
1951                  out_uint32_le(out, 0x00000200);                  out_uint32_le(out, 0x00000200);
1952                  out_uint32_le(out, dwAttrLen);                  out_uint32_le(out, dwAttrLen);
# Line 2013  TS_SCardSetAttrib(STREAM in, STREAM out) Line 1986  TS_SCardSetAttrib(STREAM in, STREAM out)
1986    
1987          dwAttrId = dwAttrId & 0x0000FFFF;          dwAttrId = dwAttrId & 0x0000FFFF;
1988    
1989          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardSetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
1990          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard,
1991          DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));                       (unsigned) dwAttrId, (int) dwAttrLen));
         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));  
1992    
1993          if (dwAttrLen > MAX_BUFFER_SIZE)          if (dwAttrLen > MAX_BUFFER_SIZE)
1994                  dwAttrLen = MAX_BUFFER_SIZE;                  dwAttrLen = MAX_BUFFER_SIZE;
# Line 2028  TS_SCardSetAttrib(STREAM in, STREAM out) Line 2000  TS_SCardSetAttrib(STREAM in, STREAM out)
2000          in_uint8a(in, pbAttr, dwAttrLen);          in_uint8a(in, pbAttr, dwAttrLen);
2001          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);
2002    
2003          if (rv)          if (rv != SCARD_S_SUCCESS)
2004          {          {
2005                  DEBUG_SCARD(("<--ERROR SCardSetAttrib Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
2006                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
2007          }          }
2008          else          else
2009          {          {
2010                  DEBUG_SCARD(("<--SUCCESS SCardSetAttrib-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
2011          }          }
2012    
2013          out_uint32_le(out, 0x00000000);          out_uint32_le(out, 0x00000000);
# Line 2105  TS_SCardControl(STREAM in, STREAM out) Line 2077  TS_SCardControl(STREAM in, STREAM out)
2077          if (!pOutBuffer)          if (!pOutBuffer)
2078                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
2079    
2080  #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  
2081    
2082          sc_nBytesReturned = nBytesReturned;          sc_nBytesReturned = nBytesReturned;
2083          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
# Line 2131  TS_SCardControl(STREAM in, STREAM out) Line 2091  TS_SCardControl(STREAM in, STREAM out)
2091  #endif  #endif
2092          nBytesReturned = sc_nBytesReturned;          nBytesReturned = sc_nBytesReturned;
2093    
 #ifdef WITH_DEBUG_SCARD  
2094          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
2095          {          {
2096                  DEBUG_SCARD(("<--ERROR SCardControl Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
2097                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
2098          }          }
2099          else          else
2100          {          {
2101                  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"));  
2102          }          }
 #endif  
2103    
2104          out_uint32_le(out, nBytesReturned);          out_uint32_le(out, nBytesReturned);
2105          out_uint32_le(out, 0x00000004);          out_uint32_le(out, 0x00000004);
# Line 2164  TS_SCardControl(STREAM in, STREAM out) Line 2118  TS_SCardControl(STREAM in, STREAM out)
2118  static MYPCSC_DWORD  static MYPCSC_DWORD
2119  TS_SCardAccessStartedEvent(STREAM in, STREAM out)  TS_SCardAccessStartedEvent(STREAM in, STREAM out)
2120  {  {
2121            DEBUG_SCARD(("SCARD: SCardAccessStartedEvent()\n"));
2122          out_uint8s(out, 8);          out_uint8s(out, 8);
2123          return SCARD_S_SUCCESS;          return SCARD_S_SUCCESS;
2124  }  }
# Line 2175  scard_device_control(RD_NTHANDLE handle, Line 2130  scard_device_control(RD_NTHANDLE handle,
2130          SERVER_DWORD Result = 0x00000000;          SERVER_DWORD Result = 0x00000000;
2131          unsigned char *psize, *pend, *pStatusCode;          unsigned char *psize, *pend, *pStatusCode;
2132          SERVER_DWORD addToEnd = 0;          SERVER_DWORD addToEnd = 0;
 #ifdef WITH_DEBUG_SCARD  
         unsigned char *pbeg = out->p;  
2133    
         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  
2134          /* Processing request */          /* Processing request */
2135    
2136          out_uint32_le(out, 0x00081001); /* Header lines */          out_uint32_le(out, 0x00081001); /* Header lines */
# Line 2199  scard_device_control(RD_NTHANDLE handle, Line 2146  scard_device_control(RD_NTHANDLE handle,
2146                          /* SCardEstablishContext */                          /* SCardEstablishContext */
2147                  case SC_ESTABLISH_CONTEXT:                  case SC_ESTABLISH_CONTEXT:
2148                          {                          {
                                 DEBUG_SCARD(("<---SCardEstablishContext--->\n"));  
2149                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);
2150                                  break;                                  break;
2151                          }                          }
2152                          /* SCardReleaseContext */                          /* SCardReleaseContext */
2153                  case SC_RELEASE_CONTEXT:                  case SC_RELEASE_CONTEXT:
2154                          {                          {
                                 DEBUG_SCARD(("<---SCardReleaseContext--->\n"));  
2155                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);
2156                                  break;                                  break;
2157                          }                          }
2158                          /* SCardIsValidContext */                          /* SCardIsValidContext */
2159                  case SC_IS_VALID_CONTEXT:                  case SC_IS_VALID_CONTEXT:
2160                          {                          {
                                 DEBUG_SCARD(("<---SCardIsValidContext--->\n"));  
2161                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);
2162                                  break;                                  break;
2163                          }                          }
# Line 2221  scard_device_control(RD_NTHANDLE handle, Line 2165  scard_device_control(RD_NTHANDLE handle,
2165                  case SC_LIST_READERS:   /* SCardListReadersA */                  case SC_LIST_READERS:   /* SCardListReadersA */
2166                  case SC_LIST_READERS + 4:       /* SCardListReadersW */                  case SC_LIST_READERS + 4:       /* SCardListReadersW */
2167                          {                          {
2168                                  D_BOOL wide = request != SC_LIST_READERS;                                  RD_BOOL wide = request != SC_LIST_READERS;
                                 DEBUG_SCARD(("<---SCardListReaders---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2169                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);
2170                                  break;                                  break;
2171                          }                          }
# Line 2232  scard_device_control(RD_NTHANDLE handle, Line 2174  scard_device_control(RD_NTHANDLE handle,
2174                  case SC_CONNECT + 4:    /* SCardConnectW */                  case SC_CONNECT + 4:    /* SCardConnectW */
2175                          {                          {
2176                                  RD_BOOL wide = request != SC_CONNECT;                                  RD_BOOL wide = request != SC_CONNECT;
                                 DEBUG_SCARD(("<---SCardConnect---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2177                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);
2178                                  break;                                  break;
2179                          }                          }
2180                          /* ScardReconnect */                          /* ScardReconnect */
2181                  case SC_RECONNECT:                  case SC_RECONNECT:
2182                          {                          {
                                 DEBUG_SCARD(("<---SCardReconnect--->\n"));  
2183                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);
2184                                  break;                                  break;
2185                          }                          }
2186                          /* ScardDisconnect */                          /* ScardDisconnect */
2187                  case SC_DISCONNECT:                  case SC_DISCONNECT:
2188                          {                          {
                                 DEBUG_SCARD(("<---SCardDisconnect--->\n"));  
2189                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);
2190                                  break;                                  break;
2191                          }                          }
# Line 2256  scard_device_control(RD_NTHANDLE handle, Line 2194  scard_device_control(RD_NTHANDLE handle,
2194                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */
2195                          {                          {
2196                                  RD_BOOL wide = request != SC_GET_STATUS_CHANGE;                                  RD_BOOL wide = request != SC_GET_STATUS_CHANGE;
                                 DEBUG_SCARD(("<---SCardGetStatusChange---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2197                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);
2198                                  break;                                  break;
2199                          }                          }
2200                          /* SCardCancel */                          /* SCardCancel */
2201                  case SC_CANCEL:                  case SC_CANCEL:
2202                          {                          {
                                 DEBUG_SCARD(("<---SCardCancel--->\n"));  
2203                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);
2204                                  break;                                  break;
2205                          }                          }
# Line 2273  scard_device_control(RD_NTHANDLE handle, Line 2208  scard_device_control(RD_NTHANDLE handle,
2208                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */
2209                          {                          {
2210                                  RD_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")));  
2211                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);
2212                                  break;                                  break;
2213                          }                          }
2214                          /* SCardBeginTransaction */                          /* SCardBeginTransaction */
2215                  case SC_BEGIN_TRANSACTION:                  case SC_BEGIN_TRANSACTION:
2216                          {                          {
                                 DEBUG_SCARD(("<---SCardBeginTransaction--->\n"));  
2217                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);
2218                                  break;                                  break;
2219                          }                          }
2220                          /* SCardBeginTransaction */                          /* SCardBeginTransaction */
2221                  case SC_END_TRANSACTION:                  case SC_END_TRANSACTION:
2222                          {                          {
                                 DEBUG_SCARD(("<---SCardEndTransaction--->\n"));  
2223                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);
2224                                  break;                                  break;
2225                          }                          }
2226                          /* ScardTransmit */                          /* ScardTransmit */
2227                  case SC_TRANSMIT:                  case SC_TRANSMIT:
2228                          {                          {
                                 DEBUG_SCARD(("<---SCardTransmit--->\n"));  
2229                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);
2230                                  break;                                  break;
2231                          }                          }
2232                          /* SCardControl */                          /* SCardControl */
2233                  case SC_CONTROL:                  case SC_CONTROL:
2234                          {                          {
                                 DEBUG_SCARD(("<---SCardControl--->\n"));  
2235                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);
2236                                  break;                                  break;
2237                          }                          }
# Line 2310  scard_device_control(RD_NTHANDLE handle, Line 2239  scard_device_control(RD_NTHANDLE handle,
2239  #ifndef WITH_PCSC120  #ifndef WITH_PCSC120
2240                  case SC_GETATTRIB:                  case SC_GETATTRIB:
2241                          {                          {
                                 DEBUG_SCARD(("<---SCardGetAttrib--->\n"));  
2242                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);
2243                                  break;                                  break;
2244                          }                          }
2245  #endif  #endif
2246                  case SC_ACCESS_STARTED_EVENT:                  case SC_ACCESS_STARTED_EVENT:
2247                          {                          {
                                 DEBUG_SCARD(("<---SCardAccessStartedEvent-->\n"));  
2248                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);
2249                                  break;                                  break;
2250                          }                          }
# Line 2325  scard_device_control(RD_NTHANDLE handle, Line 2252  scard_device_control(RD_NTHANDLE handle,
2252                  case SC_STATUS + 4:     /* SCardStatusW */                  case SC_STATUS + 4:     /* SCardStatusW */
2253                          {                          {
2254                                  RD_BOOL wide = request != SC_STATUS;                                  RD_BOOL wide = request != SC_STATUS;
                                 DEBUG_SCARD(("<---SCardStatus---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2255                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);
2256                                  break;                                  break;
2257                          }                          }
2258                  case SC_STATE:  /* SCardState */                  case SC_STATE:  /* SCardState */
2259                          {                          {
                                 DEBUG_SCARD(("<---SCardState--->"));  
2260                                  Result = (SERVER_DWORD) TS_SCardState(in, out);                                  Result = (SERVER_DWORD) TS_SCardState(in, out);
2261                                  break;                                  break;
2262                          }                          }
2263                  default:                  default:
2264                          {                          {
2265                                  DEBUG_SCARD(("<---UNSUPPORTED-FUNC--->\n"));                                  warning("SCARD: Unknown function %d\n", (int) request);
2266                                  Result = 0x80100014;                                  Result = 0x80100014;
2267                                  out_uint8s(out, 256);                                  out_uint8s(out, 256);
2268                                  break;                                  break;
# Line 2365  scard_device_control(RD_NTHANDLE handle, Line 2289  scard_device_control(RD_NTHANDLE handle,
2289                  out_uint8s(out, addToEnd);                  out_uint8s(out, addToEnd);
2290          }          }
2291    
 #ifdef WITH_DEBUG_SCARD  
         DEBUG_SCARD(("[OUTPUT DUMP]-------------------\n"));  
         hexdump(pbeg, (size_t) (out->p) - (size_t) pbeg);  
         DEBUG_SCARD(("--------------------------------\n"));  
 #endif  
2292          return RD_STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
2293  }  }
2294    
# Line 2513  SC_deviceControl(PSCThreadData data) Line 2432  SC_deviceControl(PSCThreadData data)
2432  static void *  static void *
2433  thread_function(PThreadListElement listElement)  thread_function(PThreadListElement listElement)
2434  {  {
 #ifdef WITH_DEBUG_SCARD  
         long sTime = 0;  
 #endif  
2435          if ((listElement != NULL) && (listElement->data != NULL))          if ((listElement != NULL) && (listElement->data != NULL))
2436          {          {
2437                  while (1)                  while (1)
2438                  {                  {
 #ifdef WITH_DEBUG_SCARD  
                         sTime = time(NULL);  
 #endif  
2439                          pthread_mutex_lock(&listElement->nodata);                          pthread_mutex_lock(&listElement->nodata);
2440                          SC_deviceControl(listElement->data);                          SC_deviceControl(listElement->data);
2441                          listElement->data = NULL;                          listElement->data = NULL;
                         DEBUG_SCARD(("[HANDLING TIME %d]\n", (int) (time(NULL) - sTime)));  
2442                          pthread_mutex_unlock(&listElement->busy);                          pthread_mutex_unlock(&listElement->busy);
2443                  }                  }
2444          }          }
# Line 2540  SC_handleRequest(PSCThreadData data) Line 2452  SC_handleRequest(PSCThreadData data)
2452          int Result = 0;          int Result = 0;
2453          PThreadListElement cur = threadList, last = threadList;          PThreadListElement cur = threadList, last = threadList;
2454    
         DEBUG_SCARD(("[THREAD COUNT %d]\n", threadCount));  
   
2455          while (cur)          while (cur)
2456          {          {
2457                  if (0 == pthread_mutex_trylock(&cur->busy))                  if (0 == pthread_mutex_trylock(&cur->busy))
# Line 2663  scard_unlock(int lock) Line 2573  scard_unlock(int lock)
2573  {  {
2574          pthread_mutex_unlock(scard_mutex[lock]);          pthread_mutex_unlock(scard_mutex[lock]);
2575  }  }
   
 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.1372  
changed lines
  Added in v.1416
  ViewVC Help
Powered by ViewVC 1.1.26