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

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

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

revision 1414 by ossman_, Thu Jun 28 12:52:13 2007 UTC revision 1415 by ossman_, Tue Jul 3 14:08:06 2007 UTC
# Line 124  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 134  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 601  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 629  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 657  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 669  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 697  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 714  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 734  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 773  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 852  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 891  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 919  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 1035  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 1056  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 1094  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 1113  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 1132  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 1182  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 1198  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 1231  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 1244  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 1259  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)
# Line 1274  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1272  TS_SCardLocateCardsByATR(STREAM in, STRE
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 1298  TS_SCardLocateCardsByATR(STREAM in, STRE Line 1297  TS_SCardLocateCardsByATR(STREAM in, STRE
1297                                  }                                  }
1298                                  if (equal)                                  if (equal)
1299                                  {                                  {
                                         DEBUG_SCARD(("[FOUND]\n"));  
1300                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */
1301                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));
1302                                            DEBUG_SCARD(("SCARD:    \"%s\"\n",
1303                                                         rsCur->szReader ? rsCur->szReader : "NULL"));
1304                                            DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n", (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState, (unsigned) rsCur->dwEventState));
1305                                  }                                  }
1306                          }                          }
1307                  }                  }
# Line 1331  TS_SCardBeginTransaction(STREAM in, STRE Line 1332  TS_SCardBeginTransaction(STREAM in, STRE
1332          in->p += 0x30;          in->p += 0x30;
1333          in_uint32_le(in, hCard);          in_uint32_le(in, hCard);
1334          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1335          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardBeginTransaction(hcard: 0x%08x [0x%08lx])\n",
1336          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));                       (unsigned) hCard, (unsigned long) myHCard));
1337          rv = SCardBeginTransaction(myHCard);          rv = SCardBeginTransaction(myHCard);
1338          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1339          {          {
1340                  DEBUG_SCARD(("<--ERROR SCardBeginTransaction Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1341                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1342          }          }
1343          else          else
1344          {          {
1345                  DEBUG_SCARD(("<--SUCCESS SCardBeginTransaction-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1346          }          }
1347          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1348          return rv;          return rv;
# Line 1365  TS_SCardEndTransaction(STREAM in, STREAM Line 1366  TS_SCardEndTransaction(STREAM in, STREAM
1366          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));
1367          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));
1368    
1369            DEBUG_SCARD(("SCARD: SCardEndTransaction(hcard: 0x%08x [0x%08lx], disposition: 0x%08x)\n",
1370                         (unsigned) hCard, (unsigned long) myHCard, (unsigned) dwDisposition));
1371          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);
1372          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1373          {          {
1374                  DEBUG_SCARD(("<--ERROR SCardEndTransaction Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1375                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1376          }          }
1377          else          else
1378          {          {
1379                  DEBUG_SCARD(("<--SUCCESS SCardEndTransaction-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
1380          }          }
1381          outForceAlignment(out, 8);          outForceAlignment(out, 8);
1382          return rv;          return rv;
# Line 1507  TS_SCardTransmit(STREAM in, STREAM out) Line 1510  TS_SCardTransmit(STREAM in, STREAM out)
1510          else          else
1511                  pioRecvPci = NULL;                  pioRecvPci = NULL;
1512    
1513  #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  
1514    
1515          myCbRecvLength = cbRecvLength;          myCbRecvLength = cbRecvLength;
1516          myPioSendPci = SC_xmalloc(&lcHandle,          myPioSendPci = SC_xmalloc(&lcHandle,
# Line 1567  TS_SCardTransmit(STREAM in, STREAM out) Line 1542  TS_SCardTransmit(STREAM in, STREAM out)
1542          if (cbRecvLength > 448)          if (cbRecvLength > 448)
1543          {          {
1544                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);
1545                  DEBUG_SCARD(("[RECV LEN %d -> %d]\n", (unsigned int) cbRecvLength, 400));                  DEBUG_SCARD(("SCARD:    Truncated %d to %d\n", (unsigned int) cbRecvLength, 448));
1546                  cbRecvLength = 448;                  cbRecvLength = 448;
1547          }          }
1548    
# Line 1583  TS_SCardTransmit(STREAM in, STREAM out) Line 1558  TS_SCardTransmit(STREAM in, STREAM out)
1558    
1559          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1560          {          {
1561                  DEBUG_SCARD(("<--ERROR SCardTransmit Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1562                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1563          }          }
1564          else          else
1565          {          {
1566  #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  
1567  #if 0  #if 0
1568                  if ((pioRecvPci != NULL) && (pioRecvPci->cbPciLength > 0))                  if ((pioRecvPci != NULL) && (pioRecvPci->cbPciLength > 0))
1569                  {                  {
# Line 1650  TS_SCardStatus(STREAM in, STREAM out, RD Line 1615  TS_SCardStatus(STREAM in, STREAM out, RD
1615          in->p += 0x04;          in->p += 0x04;
1616          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1617    
1618          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));  
1619    
1620          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)
1621                  dwReaderLen = SCARD_MAX_MEM;                  dwReaderLen = SCARD_MAX_MEM;
# Line 1681  TS_SCardStatus(STREAM in, STREAM out, RD Line 1643  TS_SCardStatus(STREAM in, STREAM out, RD
1643    
1644          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1645          {          {
1646                  DEBUG_SCARD(("<--ERROR SCardStatus Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1647                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1648                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1649          }          }
1650          else          else
1651          {          {
1652  #ifdef WITH_DEBUG_SCARD                  int i;
1653                  DEBUG_SCARD(("<--SUCCESS SCardStatus-->\n"));  
1654                  DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));                  DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
1655                  DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));                               (unsigned) dwState, (unsigned) dwProtocol));
1656                  DEBUG_SCARD(("[Reader Name]\n"));                  DEBUG_SCARD(("SCARD:        Reader: \"%s\"\n", readerName ? readerName : "NULL"));
1657                  hexdump((unsigned char *) readerName, dwReaderLen);                  DEBUG_SCARD(("SCARD:        ATR: "));
1658                  DEBUG_SCARD(("[Atr]\n"));                  for (i = 0; i < dwAtrLen; i++)
1659                  hexdump(atr, dwAtrLen);                  {
1660  #endif                          DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
1661                    }
1662                    DEBUG_SCARD(("\n"));
1663    
1664                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
1665                          dwState = 0x00000006;                          dwState = 0x00000006;
1666                  else                  else
# Line 1765  TS_SCardState(STREAM in, STREAM out) Line 1730  TS_SCardState(STREAM in, STREAM out)
1730          in->p += 0x04;          in->p += 0x04;
1731          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
1732    
1733          DEBUG_SCARD(("[hCard 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardState(hcard: 0x%08x [0x%08lx], atr len: %d bytes)\n",
1734          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard, (int) dwAtrLen));
         DEBUG_SCARD(("[dwAtrLen %d]\n", (unsigned int) dwAtrLen));  
1735    
1736          dwReaderLen = SCARD_MAX_MEM;          dwReaderLen = SCARD_MAX_MEM;
1737          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)
# Line 1793  TS_SCardState(STREAM in, STREAM out) Line 1757  TS_SCardState(STREAM in, STREAM out)
1757    
1758          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1759          {          {
1760                  DEBUG_SCARD(("<--ERROR SCardStatus (no ScardState) Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1761                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1762                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1763          }          }
1764          else          else
1765          {          {
1766  #ifdef WITH_DEBUG_SCARD                  int i;
1767                  DEBUG_SCARD(("<--SUCCESS SCardStatus (no ScardState)-->\n"));  
1768                  DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));                  DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
1769                  DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));                               (unsigned) dwState, (unsigned) dwProtocol));
1770                  DEBUG_SCARD(("[Atr]\n"));                  DEBUG_SCARD(("SCARD:        ATR: "));
1771                  hexdump(atr, dwAtrLen);                  for (i = 0; i < dwAtrLen; i++)
1772  #endif                  {
1773                            DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
1774                    }
1775                    DEBUG_SCARD(("\n"));
1776    
1777                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
1778                          dwState = 0x00000006;                          dwState = 0x00000006;
1779                  else                  else
# Line 1859  TS_SCardListReaderGroups(STREAM in, STRE Line 1827  TS_SCardListReaderGroups(STREAM in, STRE
1827          in->p += 0x04;          in->p += 0x04;
1828          in_uint32_le(in, hContext);          in_uint32_le(in, hContext);
1829    
1830            DEBUG_SCARD(("SCARD: SCardListReaderGroups(context: 0x%08x, groups: %d)\n",
1831                         (unsigned) hContext, (int) dwGroups));
1832    
1833          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)
1834                  dwGroups = SCARD_MAX_MEM;                  dwGroups = SCARD_MAX_MEM;
1835    
# Line 1872  TS_SCardListReaderGroups(STREAM in, STRE Line 1843  TS_SCardListReaderGroups(STREAM in, STRE
1843    
1844          if (rv)          if (rv)
1845          {          {
1846                  DEBUG_SCARD(("<--ERROR SCardListReaderGroups Code=0x%.8x, %s-->\n",                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1847                               (unsigned int) rv, pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1848                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1849          }          }
1850          else          else
1851          {          {
1852                  DEBUG_SCARD(("<--SUCCESS SCardListReaderGroups-->\n"));                  int i;
1853                    char *cur;
1854    
1855                    DEBUG_SCARD(("SCARD: -> Success\n"));
1856                    for (i = 0, cur = szGroups; i < dwGroups; i++, cur += strlen(cur) + 1)
1857                    {
1858                            DEBUG_SCARD(("SCARD:    %s\n", cur));
1859                    }
1860          }          }
1861    
1862    
# Line 1915  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1893  TS_SCardGetAttrib(STREAM in, STREAM out)
1893    
1894          dwAttrId = dwAttrId & 0x0000FFFF;          dwAttrId = dwAttrId & 0x0000FFFF;
1895    
1896          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardGetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
1897          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard,
1898          DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));                       (unsigned) dwAttrId, (int) dwAttrLen));
         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));  
1899    
1900          if (dwAttrLen > MAX_BUFFER_SIZE)          if (dwAttrLen > MAX_BUFFER_SIZE)
1901                  dwAttrLen = MAX_BUFFER_SIZE;                  dwAttrLen = MAX_BUFFER_SIZE;
# Line 1944  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1921  TS_SCardGetAttrib(STREAM in, STREAM out)
1921    
1922          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)
1923          {          {
1924                  DEBUG_SCARD(("Get Attribute ATTR_VENDOR_NAME\n"));                  DEBUG_SCARD(("SCARD:    Faking attribute ATTR_VENDOR_NAME\n"));
1925                  pthread_mutex_lock(&hcardAccess);                  pthread_mutex_lock(&hcardAccess);
1926                  PSCHCardRec hcard = hcardFirst;                  PSCHCardRec hcard = hcardFirst;
1927                  while (hcard)                  while (hcard)
# Line 1964  TS_SCardGetAttrib(STREAM in, STREAM out) Line 1941  TS_SCardGetAttrib(STREAM in, STREAM out)
1941    
1942          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
1943          {          {
1944                  DEBUG_SCARD(("<--ERROR SCardGetAttrib Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
1945                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
1946                  return SC_returnCode(rv, &lcHandle, in, out);                  return SC_returnCode(rv, &lcHandle, in, out);
1947          }          }
1948          else          else
1949          {          {
1950  #ifdef WITH_DEBUG_SCARD                  DEBUG_SCARD(("SCARD: -> Success (%d bytes)\n", (int) dwAttrLen));
1951                  DEBUG_SCARD(("<--SUCCESS SCardGetAttrib-->\n"));  
                 DEBUG_SCARD(("[LENGTH %d]\n", (unsigned int) dwAttrLen));  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
                 hexdump(pbAttr, dwAttrLen);  
                 DEBUG_SCARD(("+++++++++++++++++++++\n"));  
 #endif  
1952                  out_uint32_le(out, dwAttrLen);                  out_uint32_le(out, dwAttrLen);
1953                  out_uint32_le(out, 0x00000200);                  out_uint32_le(out, 0x00000200);
1954                  out_uint32_le(out, dwAttrLen);                  out_uint32_le(out, dwAttrLen);
# Line 2016  TS_SCardSetAttrib(STREAM in, STREAM out) Line 1988  TS_SCardSetAttrib(STREAM in, STREAM out)
1988    
1989          dwAttrId = dwAttrId & 0x0000FFFF;          dwAttrId = dwAttrId & 0x0000FFFF;
1990    
1991          DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));          DEBUG_SCARD(("SCARD: SCardSetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
1992          DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));                       (unsigned) hCard, (unsigned long) myHCard,
1993          DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));                       (unsigned) dwAttrId, (int) dwAttrLen));
         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));  
1994    
1995          if (dwAttrLen > MAX_BUFFER_SIZE)          if (dwAttrLen > MAX_BUFFER_SIZE)
1996                  dwAttrLen = MAX_BUFFER_SIZE;                  dwAttrLen = MAX_BUFFER_SIZE;
# Line 2031  TS_SCardSetAttrib(STREAM in, STREAM out) Line 2002  TS_SCardSetAttrib(STREAM in, STREAM out)
2002          in_uint8a(in, pbAttr, dwAttrLen);          in_uint8a(in, pbAttr, dwAttrLen);
2003          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);
2004    
2005          if (rv)          if (rv != SCARD_S_SUCCESS)
2006          {          {
2007                  DEBUG_SCARD(("<--ERROR SCardSetAttrib Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
2008                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
2009          }          }
2010          else          else
2011          {          {
2012                  DEBUG_SCARD(("<--SUCCESS SCardSetAttrib-->\n"));                  DEBUG_SCARD(("SCARD: -> Success\n"));
2013          }          }
2014    
2015          out_uint32_le(out, 0x00000000);          out_uint32_le(out, 0x00000000);
# Line 2108  TS_SCardControl(STREAM in, STREAM out) Line 2079  TS_SCardControl(STREAM in, STREAM out)
2079          if (!pOutBuffer)          if (!pOutBuffer)
2080                  return SC_returnNoMemoryError(&lcHandle, in, out);                  return SC_returnNoMemoryError(&lcHandle, in, out);
2081    
2082  #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  
2083    
2084          sc_nBytesReturned = nBytesReturned;          sc_nBytesReturned = nBytesReturned;
2085          myHCard = scHandleToMyPCSC(hCard);          myHCard = scHandleToMyPCSC(hCard);
# Line 2134  TS_SCardControl(STREAM in, STREAM out) Line 2093  TS_SCardControl(STREAM in, STREAM out)
2093  #endif  #endif
2094          nBytesReturned = sc_nBytesReturned;          nBytesReturned = sc_nBytesReturned;
2095    
 #ifdef WITH_DEBUG_SCARD  
2096          if (rv != SCARD_S_SUCCESS)          if (rv != SCARD_S_SUCCESS)
2097          {          {
2098                  DEBUG_SCARD(("<--ERROR SCardControl Code=0x%.8x, %s-->\n", (unsigned int) rv,                  DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
2099                               pcsc_stringify_error(rv)));                               pcsc_stringify_error(rv), (unsigned int) rv));
2100          }          }
2101          else          else
2102          {          {
2103                  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"));  
2104          }          }
 #endif  
2105    
2106          out_uint32_le(out, nBytesReturned);          out_uint32_le(out, nBytesReturned);
2107          out_uint32_le(out, 0x00000004);          out_uint32_le(out, 0x00000004);
# Line 2167  TS_SCardControl(STREAM in, STREAM out) Line 2120  TS_SCardControl(STREAM in, STREAM out)
2120  static MYPCSC_DWORD  static MYPCSC_DWORD
2121  TS_SCardAccessStartedEvent(STREAM in, STREAM out)  TS_SCardAccessStartedEvent(STREAM in, STREAM out)
2122  {  {
2123            DEBUG_SCARD(("SCARD: SCardAccessStartedEvent()\n"));
2124          out_uint8s(out, 8);          out_uint8s(out, 8);
2125          return SCARD_S_SUCCESS;          return SCARD_S_SUCCESS;
2126  }  }
# Line 2178  scard_device_control(RD_NTHANDLE handle, Line 2132  scard_device_control(RD_NTHANDLE handle,
2132          SERVER_DWORD Result = 0x00000000;          SERVER_DWORD Result = 0x00000000;
2133          unsigned char *psize, *pend, *pStatusCode;          unsigned char *psize, *pend, *pStatusCode;
2134          SERVER_DWORD addToEnd = 0;          SERVER_DWORD addToEnd = 0;
 #ifdef WITH_DEBUG_SCARD  
         unsigned char *pbeg = out->p;  
2135    
         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  
2136          /* Processing request */          /* Processing request */
2137    
2138          out_uint32_le(out, 0x00081001); /* Header lines */          out_uint32_le(out, 0x00081001); /* Header lines */
# Line 2202  scard_device_control(RD_NTHANDLE handle, Line 2148  scard_device_control(RD_NTHANDLE handle,
2148                          /* SCardEstablishContext */                          /* SCardEstablishContext */
2149                  case SC_ESTABLISH_CONTEXT:                  case SC_ESTABLISH_CONTEXT:
2150                          {                          {
                                 DEBUG_SCARD(("<---SCardEstablishContext--->\n"));  
2151                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);
2152                                  break;                                  break;
2153                          }                          }
2154                          /* SCardReleaseContext */                          /* SCardReleaseContext */
2155                  case SC_RELEASE_CONTEXT:                  case SC_RELEASE_CONTEXT:
2156                          {                          {
                                 DEBUG_SCARD(("<---SCardReleaseContext--->\n"));  
2157                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);
2158                                  break;                                  break;
2159                          }                          }
2160                          /* SCardIsValidContext */                          /* SCardIsValidContext */
2161                  case SC_IS_VALID_CONTEXT:                  case SC_IS_VALID_CONTEXT:
2162                          {                          {
                                 DEBUG_SCARD(("<---SCardIsValidContext--->\n"));  
2163                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);
2164                                  break;                                  break;
2165                          }                          }
# Line 2225  scard_device_control(RD_NTHANDLE handle, Line 2168  scard_device_control(RD_NTHANDLE handle,
2168                  case SC_LIST_READERS + 4:       /* SCardListReadersW */                  case SC_LIST_READERS + 4:       /* SCardListReadersW */
2169                          {                          {
2170                                  RD_BOOL wide = request != SC_LIST_READERS;                                  RD_BOOL wide = request != SC_LIST_READERS;
                                 DEBUG_SCARD(("<---SCardListReaders---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2171                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);
2172                                  break;                                  break;
2173                          }                          }
# Line 2235  scard_device_control(RD_NTHANDLE handle, Line 2176  scard_device_control(RD_NTHANDLE handle,
2176                  case SC_CONNECT + 4:    /* SCardConnectW */                  case SC_CONNECT + 4:    /* SCardConnectW */
2177                          {                          {
2178                                  RD_BOOL wide = request != SC_CONNECT;                                  RD_BOOL wide = request != SC_CONNECT;
                                 DEBUG_SCARD(("<---SCardConnect---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2179                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);
2180                                  break;                                  break;
2181                          }                          }
2182                          /* ScardReconnect */                          /* ScardReconnect */
2183                  case SC_RECONNECT:                  case SC_RECONNECT:
2184                          {                          {
                                 DEBUG_SCARD(("<---SCardReconnect--->\n"));  
2185                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);
2186                                  break;                                  break;
2187                          }                          }
2188                          /* ScardDisconnect */                          /* ScardDisconnect */
2189                  case SC_DISCONNECT:                  case SC_DISCONNECT:
2190                          {                          {
                                 DEBUG_SCARD(("<---SCardDisconnect--->\n"));  
2191                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);
2192                                  break;                                  break;
2193                          }                          }
# Line 2259  scard_device_control(RD_NTHANDLE handle, Line 2196  scard_device_control(RD_NTHANDLE handle,
2196                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */
2197                          {                          {
2198                                  RD_BOOL wide = request != SC_GET_STATUS_CHANGE;                                  RD_BOOL wide = request != SC_GET_STATUS_CHANGE;
                                 DEBUG_SCARD(("<---SCardGetStatusChange---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2199                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);
2200                                  break;                                  break;
2201                          }                          }
2202                          /* SCardCancel */                          /* SCardCancel */
2203                  case SC_CANCEL:                  case SC_CANCEL:
2204                          {                          {
                                 DEBUG_SCARD(("<---SCardCancel--->\n"));  
2205                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);
2206                                  break;                                  break;
2207                          }                          }
# Line 2276  scard_device_control(RD_NTHANDLE handle, Line 2210  scard_device_control(RD_NTHANDLE handle,
2210                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */
2211                          {                          {
2212                                  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")));  
2213                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);
2214                                  break;                                  break;
2215                          }                          }
2216                          /* SCardBeginTransaction */                          /* SCardBeginTransaction */
2217                  case SC_BEGIN_TRANSACTION:                  case SC_BEGIN_TRANSACTION:
2218                          {                          {
                                 DEBUG_SCARD(("<---SCardBeginTransaction--->\n"));  
2219                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);
2220                                  break;                                  break;
2221                          }                          }
2222                          /* SCardBeginTransaction */                          /* SCardBeginTransaction */
2223                  case SC_END_TRANSACTION:                  case SC_END_TRANSACTION:
2224                          {                          {
                                 DEBUG_SCARD(("<---SCardEndTransaction--->\n"));  
2225                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);
2226                                  break;                                  break;
2227                          }                          }
2228                          /* ScardTransmit */                          /* ScardTransmit */
2229                  case SC_TRANSMIT:                  case SC_TRANSMIT:
2230                          {                          {
                                 DEBUG_SCARD(("<---SCardTransmit--->\n"));  
2231                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);
2232                                  break;                                  break;
2233                          }                          }
2234                          /* SCardControl */                          /* SCardControl */
2235                  case SC_CONTROL:                  case SC_CONTROL:
2236                          {                          {
                                 DEBUG_SCARD(("<---SCardControl--->\n"));  
2237                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);
2238                                  break;                                  break;
2239                          }                          }
# Line 2313  scard_device_control(RD_NTHANDLE handle, Line 2241  scard_device_control(RD_NTHANDLE handle,
2241  #ifndef WITH_PCSC120  #ifndef WITH_PCSC120
2242                  case SC_GETATTRIB:                  case SC_GETATTRIB:
2243                          {                          {
                                 DEBUG_SCARD(("<---SCardGetAttrib--->\n"));  
2244                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);
2245                                  break;                                  break;
2246                          }                          }
2247  #endif  #endif
2248                  case SC_ACCESS_STARTED_EVENT:                  case SC_ACCESS_STARTED_EVENT:
2249                          {                          {
                                 DEBUG_SCARD(("<---SCardAccessStartedEvent-->\n"));  
2250                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);
2251                                  break;                                  break;
2252                          }                          }
# Line 2328  scard_device_control(RD_NTHANDLE handle, Line 2254  scard_device_control(RD_NTHANDLE handle,
2254                  case SC_STATUS + 4:     /* SCardStatusW */                  case SC_STATUS + 4:     /* SCardStatusW */
2255                          {                          {
2256                                  RD_BOOL wide = request != SC_STATUS;                                  RD_BOOL wide = request != SC_STATUS;
                                 DEBUG_SCARD(("<---SCardStatus---> (%s)\n",  
                                              (wide) ? ("WIDE") : ("ASCII")));  
2257                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);
2258                                  break;                                  break;
2259                          }                          }
2260                  case SC_STATE:  /* SCardState */                  case SC_STATE:  /* SCardState */
2261                          {                          {
                                 DEBUG_SCARD(("<---SCardState--->"));  
2262                                  Result = (SERVER_DWORD) TS_SCardState(in, out);                                  Result = (SERVER_DWORD) TS_SCardState(in, out);
2263                                  break;                                  break;
2264                          }                          }
2265                  default:                  default:
2266                          {                          {
2267                                  DEBUG_SCARD(("<---UNSUPPORTED-FUNC--->\n"));                                  warning("SCARD: Unknown function %d\n", (int) request);
2268                                  Result = 0x80100014;                                  Result = 0x80100014;
2269                                  out_uint8s(out, 256);                                  out_uint8s(out, 256);
2270                                  break;                                  break;
# Line 2368  scard_device_control(RD_NTHANDLE handle, Line 2291  scard_device_control(RD_NTHANDLE handle,
2291                  out_uint8s(out, addToEnd);                  out_uint8s(out, addToEnd);
2292          }          }
2293    
 #ifdef WITH_DEBUG_SCARD  
         DEBUG_SCARD(("[OUTPUT DUMP]-------------------\n"));  
         hexdump(pbeg, (size_t) (out->p) - (size_t) pbeg);  
         DEBUG_SCARD(("--------------------------------\n"));  
 #endif  
2294          return RD_STATUS_SUCCESS;          return RD_STATUS_SUCCESS;
2295  }  }
2296    
# Line 2516  SC_deviceControl(PSCThreadData data) Line 2434  SC_deviceControl(PSCThreadData data)
2434  static void *  static void *
2435  thread_function(PThreadListElement listElement)  thread_function(PThreadListElement listElement)
2436  {  {
 #ifdef WITH_DEBUG_SCARD  
         long sTime = 0;  
 #endif  
2437          if ((listElement != NULL) && (listElement->data != NULL))          if ((listElement != NULL) && (listElement->data != NULL))
2438          {          {
2439                  while (1)                  while (1)
2440                  {                  {
 #ifdef WITH_DEBUG_SCARD  
                         sTime = time(NULL);  
 #endif  
2441                          pthread_mutex_lock(&listElement->nodata);                          pthread_mutex_lock(&listElement->nodata);
2442                          SC_deviceControl(listElement->data);                          SC_deviceControl(listElement->data);
2443                          listElement->data = NULL;                          listElement->data = NULL;
                         DEBUG_SCARD(("[HANDLING TIME %d]\n", (int) (time(NULL) - sTime)));  
2444                          pthread_mutex_unlock(&listElement->busy);                          pthread_mutex_unlock(&listElement->busy);
2445                  }                  }
2446          }          }
# Line 2543  SC_handleRequest(PSCThreadData data) Line 2454  SC_handleRequest(PSCThreadData data)
2454          int Result = 0;          int Result = 0;
2455          PThreadListElement cur = threadList, last = threadList;          PThreadListElement cur = threadList, last = threadList;
2456    
         DEBUG_SCARD(("[THREAD COUNT %d]\n", threadCount));  
   
2457          while (cur)          while (cur)
2458          {          {
2459                  if (0 == pthread_mutex_trylock(&cur->busy))                  if (0 == pthread_mutex_trylock(&cur->busy))
Legend:
Removed from v.1414  
changed lines
  Added in v.1415
  ViewVC Help
Powered by ViewVC 1.1.26