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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1319 by stargo,
Thu Nov  2 20:48:28 2006 UTC
+revision 1421 by stargo,
Tue Oct 30 13:09:37 2007 UTC
 Line 19
  */
  #include <stdio.h>
- #include "rdesktop.h"
  #include <unistd.h>
  #include <fcntl.h>
  #include <strings.h>
  #include <sys/types.h>
  #include <time.h>
  #ifndef MAKE_PROTO
- #ifdef PCSC_OSX
+ #ifdef __APPLE__
+ #include <PCSC/wintypes.h>
  #include <PCSC/pcsclite.h>
  #include <PCSC/winscard.h>
  #else
+ #include <wintypes.h>
  #include <pcsclite.h>
  #include <winscard.h>
  #endif /* PCSC_OSX */
+ #include "rdesktop.h"
  #include "scard.h"
  /* variable segment */
-Line 40
+Line 42
  #define SCARD_MAX_MEM 102400
  #define SCARD_AUTOALLOCATE -1
  #define OUT_STREAM_SIZE 4096
- #define STREAM_COUNT 8
- static struct stream out[STREAM_COUNT];
+ #ifdef B_ENDIAN
- static int cur_stream_id = 0;
+ #define swap32(x)       ((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) | \
- static pthread_mutex_t *tcp_sendcontrol_mutex = NULL;
+                         (((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24))
+ #define swap16(x)       ((((x) & 0xff) << 8) | (((x) & 0xff00) >> 8))
+ #else
+ #define swap32(x)       (x)
+ #define swap16(x)       (x)
+ #endif
+ static pthread_mutex_t **scard_mutex = NULL;
  static uint32 curDevice = 0, curId = 0, curBytesOut = 0;
  static PSCNameMapRec nameMapList = NULL;
-Line 52 
 static int nameMapCount = 0;
+Line 61 
 static int nameMapCount = 0;
  static pthread_t queueHandler;
  static pthread_mutex_t queueAccess;
- static pthread_mutex_t queueEmpty;
+ static pthread_cond_t queueEmpty;
  static pthread_mutex_t hcardAccess;
- /* static pthread_mutex_t sendControl; */
  static PMEM_HANDLE threadListHandle = NULL;
  static PThreadListElement threadList = NULL;
-Line 80 
 scardSetInfo(uint32 device, uint32 id, u
+Line 88 
 scardSetInfo(uint32 device, uint32 id, u
  #ifndef MAKE_PROTO
- static NTSTATUS
+ static RD_NTSTATUS
  scard_create(uint32 device_id, uint32 accessmask, uint32 sharemode, uint32 create_disposition,
-              uint32 flags_and_attributes, char *filename, NTHANDLE * phandle)
+              uint32 flags_and_attributes, char *filename, RD_NTHANDLE * phandle)
  {
-         return STATUS_SUCCESS;
+         return RD_STATUS_SUCCESS;
  }
- static NTSTATUS
+ static RD_NTSTATUS
- scard_close(NTHANDLE handle)
+ scard_close(RD_NTHANDLE handle)
  {
-         return STATUS_SUCCESS;
+         return RD_STATUS_SUCCESS;
  }
- static NTSTATUS
+ static RD_NTSTATUS
- scard_read(NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
+ scard_read(RD_NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
  {
-         return STATUS_SUCCESS;
+         return RD_STATUS_SUCCESS;
  }
- static NTSTATUS
+ static RD_NTSTATUS
- scard_write(NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
+ scard_write(RD_NTHANDLE handle, uint8 * data, uint32 length, uint32 offset, uint32 * result)
  {
-         return STATUS_SUCCESS;
+         return RD_STATUS_SUCCESS;
  }
  #endif /* MAKE_PROTO */
-Line 126 
 scard_enum_devices(uint32 * id, char *op
+Line 134 
 scard_enum_devices(uint32 * id, char *op
          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
          if (rv != SCARD_S_SUCCESS)
          {
-                 error("[SMART CARD: PCSC service not available]\n");
+                 error("scard_enum_devices: PCSC service not available\n");
                  return 0;
          }
          else
-Line 136 
 scard_enum_devices(uint32 * id, char *op
+Line 144 
 scard_enum_devices(uint32 * id, char *op
          if (0 != pthread_mutex_init(&queueAccess, NULL))
          {
-                 error("[SMART CARD: Can't initialize queue access mutex]\n");
+                 error("scard_enum_devices: Can't initialize queue access mutex\n");
                  return 0;
          }
-         if (0 != pthread_mutex_init(&queueEmpty, NULL))
+         if (0 != pthread_cond_init(&queueEmpty, NULL))
          {
-                 error("[SMART CARD: Can't initialize queue control mutex]\n");
+                 error("scard_enum_devices: Can't initialize queue control cv\n");
                  return 0;
          }
          if (0 != pthread_mutex_init(&hcardAccess, NULL))
          {
-                 error("[SMART CARD: Can't initialize hcard list access mutex]\n");
+                 error("scard_enum_devices: Can't initialize hcard list access mutex\n");
                  return 0;
          }
- #if 0
-         if (0 != pthread_mutex_init(&sendControl, NULL))
-         {
-                 error("[SMART CARD: Can't initialize send control mutex]\n");
-                 return 0;
-         }
- #endif
          if (0 !=
              pthread_create(&queueHandler, NULL, (void *(*)(void *)) queue_handler_function, NULL))
          {
-                 error("[SMART CARD: Can't create queue handling Thread]\n");
+                 error("scard_enum_devices: Can't create queue handling Thread\n");
                  return 0;
          }
-Line 233 
 scard_enum_devices(uint32 * id, char *op
+Line 232 
 scard_enum_devices(uint32 * id, char *op
                  }
          }
-         printf("******************************************************\n");
-         printf("* Smart Card support for RDesktop is initialized.    *\n");
-         printf("* Copyright (C) by Alexi Volkov, alexi@myrealbox.com *\n");
-         printf("******************************************************\n");
          return count;
  }
-Line 497 
 outBufferFinish(STREAM out, char *buffer
+Line 490 
 outBufferFinish(STREAM out, char *buffer
  }
  static void
- outForceAllignment(STREAM out, unsigned int seed)
+ outForceAlignment(STREAM out, unsigned int seed)
  {
          SERVER_DWORD add = (seed - (out->p - out->data) % seed) % seed;
          if (add > 0)
-         {
                  out_uint8s(out, add);
-         }
  }
  static unsigned int
- inString(PMEM_HANDLE * handle, STREAM in, char **destination, SERVER_DWORD dataLength, BOOL wide)
+ inString(PMEM_HANDLE * handle, STREAM in, char **destination, SERVER_DWORD dataLength, RD_BOOL wide)
  {
          unsigned int Result = (wide) ? (2 * dataLength) : (dataLength);
          PMEM_HANDLE lcHandle = NULL;
-Line 541 
 inString(PMEM_HANDLE * handle, STREAM in
+Line 532 
 inString(PMEM_HANDLE * handle, STREAM in
  }
  static unsigned int
- outString(STREAM out, char *source, BOOL wide)
+ outString(STREAM out, char *source, RD_BOOL wide)
  {
          PMEM_HANDLE lcHandle = NULL;
          char *reader = getAlias(source);
-Line 575 
 outString(STREAM out, char *source, BOOL
+Line 566 
 outString(STREAM out, char *source, BOOL
  }
  static void
- inReaderName(PMEM_HANDLE * handle, STREAM in, char **destination, BOOL wide)
+ inReaderName(PMEM_HANDLE * handle, STREAM in, char **destination, RD_BOOL wide)
  {
          SERVER_DWORD dataLength;
          in->p += 0x08;
-Line 620 
 TS_SCardEstablishContext(STREAM in, STRE
+Line 611 
 TS_SCardEstablishContext(STREAM in, STRE
          MYPCSC_SCARDCONTEXT hContext;
          /* code segment  */
-         DEBUG_SCARD(("Establishing PC/SC Context... \n"));
+         DEBUG_SCARD(("SCARD: SCardEstablishContext()\n"));
          rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext);
          if (rv)
          {
-                 DEBUG_SCARD(("<--ERROR SCardEstablishContext Code=0x%.8x]-->\n",
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
-                              (unsigned int) rv));
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardEstablishContext-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success (context: 0x%08lx)\n", hContext));
          }
          out_uint32_le(out, 0x00000004);
-Line 648 
 TS_SCardReleaseContext(STREAM in, STREAM
+Line 639 
 TS_SCardReleaseContext(STREAM in, STREAM
          in->p += 0x1C;
          in_uint32_le(in, hContext);
-         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));
+         DEBUG_SCARD(("SCARD: SCardReleaseContext(context: 0x%08x)\n", (unsigned) hContext));
-         DEBUG_SCARD(("Releasing context... \n"));
          rv = SCardReleaseContext((MYPCSC_SCARDCONTEXT) hContext);
          if (rv)
          {
-                 DEBUG_SCARD(("<--ERROR SCardReleaseContext Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardReleaseContext-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
          return rv;
-Line 675 
 TS_SCardIsValidContext(STREAM in, STREAM
+Line 666 
 TS_SCardIsValidContext(STREAM in, STREAM
          in->p += 0x1C;
          in_uint32_le(in, hContext);
-         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));
+         DEBUG_SCARD(("SCARD: SCardIsValidContext(context: 0x%08x)\n", (unsigned) hContext));
-         DEBUG_SCARD(("Checking... \n"));
          /* There is no realization of SCardIsValidContext in PC/SC Lite so we call SCardListReaders */
          readers = SC_xmalloc(&lcHandle, 1024);
-Line 687 
 TS_SCardIsValidContext(STREAM in, STREAM
+Line 677 
 TS_SCardIsValidContext(STREAM in, STREAM
          if (rv)
          {
-                 DEBUG_SCARD(("<--ERROR SCardListReaders (no SCardIsValidContext) Code=0x%.8x-->\n",
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
-                              (unsigned int) rv));
+                              pcsc_stringify_error(rv), (unsigned int) rv));
                  rv = SCARD_E_INVALID_HANDLE;
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardListReaders (no SCardIsValidContext)-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
  static MYPCSC_DWORD
- TS_SCardListReaders(STREAM in, STREAM out, BOOL wide)
+ TS_SCardListReaders(STREAM in, STREAM out, RD_BOOL wide)
  {
  #define readerArraySize 1024
          MYPCSC_DWORD rv;
-Line 716 
 TS_SCardListReaders(STREAM in, STREAM ou
+Line 706 
 TS_SCardListReaders(STREAM in, STREAM ou
          in->p += 0x2C;
          in_uint32_le(in, hContext);
-         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));
+         DEBUG_SCARD(("SCARD: SCardListReaders(context: 0x%08x)\n", (unsigned) hContext));
          plen1 = out->p;
          out_uint32_le(out, 0x00000000); /* Temp value for data length as 0x0 */
          out_uint32_le(out, 0x01760650);
-Line 733 
 TS_SCardListReaders(STREAM in, STREAM ou
+Line 723 
 TS_SCardListReaders(STREAM in, STREAM ou
          readers[1] = '\0';
          rv = SCardListReaders((MYPCSC_SCARDCONTEXT) hContext, NULL, readers, &cchReaders);
          cur = readers;
-         if (!rv)
+         if (rv != SCARD_S_SUCCESS)
+         {
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
+         }
+         else
          {
                  int i;
                  PSCNameMapRec tmpMap;
- #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
                  for (i = 0, tmpMap = nameMapList; i < nameMapCount; i++, tmpMap++)
                  {
                          dataLength += outString(out, tmpMap->alias, wide);
-Line 753 
 TS_SCardListReaders(STREAM in, STREAM ou
+Line 745 
 TS_SCardListReaders(STREAM in, STREAM ou
                          while (lenSC > 0)
                          {
                                  if (!hasAlias(cur))
+                                 {
+                                         DEBUG_SCARD(("SCARD:    \"%s\"\n", cur));
                                          dataLength += outString(out, cur, wide);
+                                 }
                                  cur = (void *) ((unsigned char *) cur + lenSC + 1);
                                  lenSC = strlen(cur);
                          }
-Line 769 
 TS_SCardListReaders(STREAM in, STREAM ou
+Line 764 
 TS_SCardListReaders(STREAM in, STREAM ou
          out_uint32_le(out, dataLength);
          out->p = pend;
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
  static MYPCSC_DWORD
- TS_SCardConnect(STREAM in, STREAM out, BOOL wide)
+ TS_SCardConnect(STREAM in, STREAM out, RD_BOOL wide)
  {
          MYPCSC_DWORD rv;
          SCARDCONTEXT hContext;
-Line 792 
 TS_SCardConnect(STREAM in, STREAM out, B
+Line 787 
 TS_SCardConnect(STREAM in, STREAM out, B
          in->p += 0x1C;
          in_uint32_le(in, dwShareMode);
          in_uint32_le(in, dwPreferredProtocol);
-         DEBUG_SCARD(("[SHARE %8x]\n", (unsigned int) dwShareMode));
-         DEBUG_SCARD(("[PROTO %8x]\n", (unsigned int) dwPreferredProtocol));
          inReaderName(&lcHandle, in, &szReader, wide);
-         DEBUG_SCARD(("[CONNECT TO READER \"%s\"\n", (szReader != NULL) ? (szReader) : ("NULL")));
          in->p += 0x04;
          in_uint32_le(in, hContext);
-         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"));
          rv = SCardConnect(hContext, szReader, (MYPCSC_DWORD) dwShareMode,
                            (MYPCSC_DWORD) dwPreferredProtocol, &myHCard, &dwActiveProtocol);
          hCard = scHandleToServer(myHCard);
-         DEBUG_SCARD(("[RECEIVED HCARD 0x%016lx]\n", (unsigned long) myHCard));
-         DEBUG_SCARD(("[MANGLED  HCARD 0x%08x]\n", hCard));
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardConnect Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
                  char *szVendor = getVendor(szReader);
-                 DEBUG_SCARD(("<--SUCCESS ScardConnect-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success (hcard: 0x%08x [0x%08lx])\n",
+                              (unsigned) hCard, (unsigned long) myHCard));
                  if (szVendor && (strlen(szVendor) > 0))
                  {
-                         DEBUG_SCARD(("Set Attribute ATTR_VENDOR_NAME\n"));
+                         DEBUG_SCARD(("SCARD: Set Attribute ATTR_VENDOR_NAME\n"));
                          pthread_mutex_lock(&hcardAccess);
                          PSCHCardRec hcard = xmalloc(sizeof(TSCHCardRec));
                          if (hcard)
-Line 844 
 TS_SCardConnect(STREAM in, STREAM out, B
+Line 836 
 TS_SCardConnect(STREAM in, STREAM out, B
          out_uint32_le(out, 0x00000004);
          out_uint32_le(out, hCard);
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 870 
 TS_SCardReconnect(STREAM in, STREAM out)
+Line 862 
 TS_SCardReconnect(STREAM in, STREAM out)
          in->p += 0x04;
          in_uint32_le(in, hCard);
          myHCard = scHandleToMyPCSC(hCard);
-         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));
          rv = SCardReconnect(myHCard, (MYPCSC_DWORD) dwShareMode, (MYPCSC_DWORD) dwPreferredProtocol,
                              (MYPCSC_DWORD) dwInitialization, &dwActiveProtocol);
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardReconnect Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardReconnect-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success (proto: 0x%08x)\n", (unsigned) dwActiveProtocol));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          out_uint32_le(out, (SERVER_DWORD) dwActiveProtocol);
          return rv;
  }
-Line 908 
 TS_SCardDisconnect(STREAM in, STREAM out
+Line 896 
 TS_SCardDisconnect(STREAM in, STREAM out
          in->p += 0x04;
          in_uint32_le(in, hCard);
-         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));
          pthread_mutex_lock(&hcardAccess);
          PSCHCardRec hcard = hcardFirst;
-Line 936 
 TS_SCardDisconnect(STREAM in, STREAM out
+Line 922 
 TS_SCardDisconnect(STREAM in, STREAM out
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardDisconnect Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardDisconnect-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          return rv;
  }
-Line 966 
 needStatusRecheck(MYPCSC_DWORD rv, MYPCS
+Line 953 
 needStatusRecheck(MYPCSC_DWORD rv, MYPCS
          return recall;
  }
- static BOOL
+ static RD_BOOL
  mappedStatus(MYPCSC_DWORD code)
  {
          code >>= 16;
-Line 975 
 mappedStatus(MYPCSC_DWORD code)
+Line 962 
 mappedStatus(MYPCSC_DWORD code)
  }
  static MYPCSC_DWORD
- incStatus(MYPCSC_DWORD code, BOOL mapped)
+ incStatus(MYPCSC_DWORD code, RD_BOOL mapped)
  {
          if (mapped || (code & SCARD_STATE_CHANGED))
          {
-Line 1029 
 copyReaderState_ServerToMyPCSC(SERVER_LP
+Line 1016 
 copyReaderState_ServerToMyPCSC(SERVER_LP
  static MYPCSC_DWORD
- TS_SCardGetStatusChange(STREAM in, STREAM out, BOOL wide)
+ TS_SCardGetStatusChange(STREAM in, STREAM out, RD_BOOL wide)
  {
          MYPCSC_DWORD rv;
          SERVER_SCARDCONTEXT hContext;
-Line 1041 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1028 
 TS_SCardGetStatusChange(STREAM in, STREA
          long i;
          PMEM_HANDLE lcHandle = NULL;
  #if 0
-         BOOL mapped = False;
+         RD_BOOL mapped = False;
  #endif
          in->p += 0x18;
-Line 1051 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1038 
 TS_SCardGetStatusChange(STREAM in, STREA
          in_uint32_le(in, hContext);
          in->p += 0x04;
-         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));
+         DEBUG_SCARD(("SCARD: SCardGetStatusChange(context: 0x%08x, timeout: 0x%08x, count: %d)\n",
-         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)));
          if (dwCount > 0)
          {
-Line 1072 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1057 
 TS_SCardGetStatusChange(STREAM in, STREA
                          in->p += 0x04;
                          in_uint8a(in, cur, SERVER_SCARDSTATESIZE);
                  }
- #ifdef WITH_DEBUG_SCARD
-                 DEBUG_SCARD(("[READERS DUMP 1]------------------\n"));
-                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));
- #endif
                  for (i = 0, cur = rsArray, curState = stateArray;
                       i < dwCount; i++, cur++, curState++)
                  {
                          SERVER_DWORD dataLength;
+                         /* Do endian swaps... */
+                         cur->dwCurrentState = swap32(cur->dwCurrentState);
+                         cur->dwEventState = swap32(cur->dwEventState);
+                         cur->cbAtr = swap32(cur->cbAtr);
                          /* reset Current state hign bytes; */
                          *curState = cur->dwCurrentState;
                          cur->dwCurrentState &= 0x0000FFFF;
-Line 1110 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1095 
 TS_SCardGetStatusChange(STREAM in, STREA
                          in->p += 0x08;
                          in_uint32_le(in, dataLength);
-                         DEBUG_SCARD(("[%d] Data Length %d]\n", (unsigned int) i, dataLength));
                          inRepos(in,
                                  inString(&lcHandle, in, (char **) &(cur->szReader), dataLength,
                                           wide));
                          if (strcmp(cur->szReader, "\\\\?PnP?\\Notification") == 0)
                                  cur->dwCurrentState |= SCARD_STATE_IGNORE;
+                         DEBUG_SCARD(("SCARD:    \"%s\"\n", cur->szReader ? cur->szReader : "NULL"));
+                         DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
+                                      (unsigned) cur->pvUserData, (unsigned) cur->dwCurrentState,
+                                      (unsigned) cur->dwEventState));
+                         DEBUG_SCARD(("SCARD:            current state: 0x%08x\n",
+                                      (unsigned) *curState));
                  }
- #ifdef WITH_DEBUG_SCARD
-                 DEBUG_SCARD(("[READERS DUMP 2]------------------\n"));
-                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));
- #endif
          }
          else
          {
-Line 1129 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1116 
 TS_SCardGetStatusChange(STREAM in, STREA
                  stateArray = NULL;
          }
-         DEBUG_SCARD(("\nCalling SCardGetStatusChange...\n"));
          myRsArray = SC_xmalloc(&lcHandle, dwCount * sizeof(MYPCSC_SCARD_READERSTATE_A));
          if (!rsArray)
                  return SC_returnNoMemoryError(&lcHandle, in, out);
          memset(myRsArray, 0, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));
          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
          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, (MYPCSC_DWORD) dwTimeout,
                                    myRsArray, (MYPCSC_DWORD) dwCount);
-Line 1148 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1128 
 TS_SCardGetStatusChange(STREAM in, STREA
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardGetStatusChange Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardGetStatusChange-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
-         }
- #ifdef WITH_DEBUG_SCARD
-         if (dwCount > 0)
-         {
-                 DEBUG_SCARD(("[READERS DUMP]------------------\n"));
-                 hexdump((void *) rsArray, dwCount * sizeof(SERVER_SCARD_READERSTATE_A));
          }
- #endif
          out_uint32_le(out, dwCount);
          out_uint32_le(out, 0x00084dd8);
-Line 1197 
 TS_SCardGetStatusChange(STREAM in, STREA
+Line 1170 
 TS_SCardGetStatusChange(STREAM in, STREA
  #endif
                  cur->dwEventState = incStatus(cur->dwEventState, False);
+                 DEBUG_SCARD(("SCARD:    \"%s\"\n", cur->szReader ? cur->szReader : "NULL"));
+                 DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
+                              (unsigned) cur->pvUserData, (unsigned) cur->dwCurrentState,
+                              (unsigned) cur->dwEventState));
+                 /* Do endian swaps... */
+                 cur->dwCurrentState = swap32(cur->dwCurrentState);
+                 cur->dwEventState = swap32(cur->dwEventState);
+                 cur->cbAtr = swap32(cur->cbAtr);
                  out_uint8p(out, (void *) ((unsigned char **) cur + 2),
                             sizeof(SERVER_SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 1213 
 TS_SCardCancel(STREAM in, STREAM out)
+Line 1196 
 TS_SCardCancel(STREAM in, STREAM out)
          in->p += 0x1C;
          in_uint32_le(in, hContext);
-         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));
+         DEBUG_SCARD(("SCARD: SCardCancel(context: 0x%08x)\n", (unsigned) hContext));
-         DEBUG_SCARD(("Canceling... \n"));
          rv = SCardCancel((MYPCSC_SCARDCONTEXT) hContext);
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardCancel Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardCancel-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          return rv;
  }
  static MYPCSC_DWORD
- TS_SCardLocateCardsByATR(STREAM in, STREAM out, BOOL wide)
+ TS_SCardLocateCardsByATR(STREAM in, STREAM out, RD_BOOL wide)
  {
          int i, j, k;
          MYPCSC_DWORD rv;
-Line 1245 
 TS_SCardLocateCardsByATR(STREAM in, STRE
+Line 1228 
 TS_SCardLocateCardsByATR(STREAM in, STRE
          in->p += 0x2C;
          in_uint32_le(in, hContext);
-         DEBUG_SCARD(("[CONTEXT 0x%.8x]\n", (unsigned int) hContext));
          in_uint32_le(in, atrMaskCount);
          pAtrMasks = SC_xmalloc(&lcHandle, atrMaskCount * sizeof(SCARD_ATRMASK_L));
          if (!pAtrMasks)
-Line 1258 
 TS_SCardLocateCardsByATR(STREAM in, STRE
+Line 1240 
 TS_SCardLocateCardsByATR(STREAM in, STRE
                  return SC_returnNoMemoryError(&lcHandle, in, out);
          memset(rsArray, 0, readerCount * sizeof(SCARD_READERSTATE_A));
+         DEBUG_SCARD(("SCARD: SCardLocateCardsByATR(context: 0x%08x, atrs: %d, readers: %d)\n",
+                      (unsigned) hContext, (int) atrMaskCount, (int) readerCount));
+         for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)
+         {
+                 cur->cbAtr = swap32(cur->cbAtr);
+                 DEBUG_SCARD(("SCARD:    ATR: "));
+                 for (j = 0; j < pAtrMasks->cbAtr; j++)
+                 {
+                 DEBUG_SCARD(("%02x%c",
+                                      (unsigned) (unsigned char) cur->rgbAtr[j],
+                                      (j == pAtrMasks->cbAtr - 1) ? ' ' : ':'))}
+                 DEBUG_SCARD(("\n"));
+                 DEBUG_SCARD(("SCARD:         "));
+                 for (j = 0; j < pAtrMasks->cbAtr; j++)
+                 {
+                 DEBUG_SCARD(("%02x%c",
+                                      (unsigned) (unsigned char) cur->rgbMask[j],
+                                      (j == pAtrMasks->cbAtr - 1) ? ' ' : ':'))}
+                 DEBUG_SCARD(("\n"));
+         }
          for (i = 0, rsCur = (SERVER_LPSCARD_READERSTATE_A) ((unsigned char **) rsArray + 2);
               i < readerCount; i++, rsCur++)
          {
-Line 1268 
 TS_SCardLocateCardsByATR(STREAM in, STRE
+Line 1273 
 TS_SCardLocateCardsByATR(STREAM in, STRE
          ResArray = SC_xmalloc(&lcHandle, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));
          if (!ResArray)
                  return SC_returnNoMemoryError(&lcHandle, in, out);
-         memcpy(ResArray, rsArray, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));
          for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)
          {
+                 /* Do endian swaps... */
+                 rsCur->dwCurrentState = swap32(rsCur->dwCurrentState);
+                 rsCur->dwEventState = swap32(rsCur->dwEventState);
+                 rsCur->cbAtr = swap32(rsCur->cbAtr);
                  inReaderName(&lcHandle, in, (char **) &rsCur->szReader, wide);
-                 DEBUG_SCARD(("[CHECK READER %s]\n",
+                 DEBUG_SCARD(("SCARD:    \"%s\"\n", rsCur->szReader ? rsCur->szReader : "NULL"));
-                              (rsCur->szReader) ? (rsCur->szReader) : ("NULL")));
+                 DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n",
+                              (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState,
+                              (unsigned) rsCur->dwEventState));
          }
+         memcpy(ResArray, rsArray, readerCount * sizeof(SERVER_SCARD_READERSTATE_A));
-         DEBUG_SCARD(("[CALL subfunction \"SCardGetStatusChange\"]\n"));
          /* FIXME segfault here. */
          myRsArray = SC_xmalloc(&lcHandle, readerCount * sizeof(MYPCSC_SCARD_READERSTATE_A));
          if (!myRsArray)
                  return SC_returnNoMemoryError(&lcHandle, in, out);
+         copyReaderState_ServerToMyPCSC(rsArray, myRsArray, readerCount);
          rv = SCardGetStatusChange((MYPCSC_SCARDCONTEXT) hContext, 0x00000001, myRsArray,
                                    readerCount);
          copyReaderState_MyPCSCToServer(myRsArray, rsArray, readerCount);
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardGetStatusChange (no SCardLocateCardsByATR) Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardGetStatusChange (no SCardLocateCardsByATR)-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
                  cur = pAtrMasks;
                  for (i = 0, cur = pAtrMasks; i < atrMaskCount; i++, cur++)
                  {
                          for (j = 0, rsCur = rsArray; j < readerCount; j++, rsCur++)
                          {
-                                 BOOL equal = 1;
+                                 RD_BOOL equal = 1;
                                  for (k = 0; k < cur->cbAtr; k++)
                                  {
-                                         /*  This line check if them equal */
+                                         if ((cur->rgbAtr[k] & cur->rgbMask[k]) !=
-                                         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])){ */
                                          {
                                                  equal = 0;
                                                  break;
-Line 1311 
 TS_SCardLocateCardsByATR(STREAM in, STRE
+Line 1322 
 TS_SCardLocateCardsByATR(STREAM in, STRE
                                  }
                                  if (equal)
                                  {
-                                         DEBUG_SCARD(("[FOUND]\n"));
                                          rsCur->dwEventState |= 0x00000040;      /* SCARD_STATE_ATRMATCH 0x00000040 */
                                          memcpy(ResArray + j, rsCur, sizeof(SCARD_READERSTATE_A));
+                                         DEBUG_SCARD(("SCARD:    \"%s\"\n",
+                                                      rsCur->szReader ? rsCur->szReader : "NULL"));
+                                         DEBUG_SCARD(("SCARD:        user: 0x%08x, state: 0x%08x, event: 0x%08x\n", (unsigned) rsCur->pvUserData, (unsigned) rsCur->dwCurrentState, (unsigned) rsCur->dwEventState));
                                  }
                          }
                  }
-Line 1323 
 TS_SCardLocateCardsByATR(STREAM in, STRE
+Line 1336 
 TS_SCardLocateCardsByATR(STREAM in, STRE
          out_uint32_le(out, 0x00084dd8);
          out_uint32_le(out, readerCount);
-         for (i = 0, rsCur = rsArray; i < readerCount; i++, rsCur++)
+         for (i = 0, rsCur = ResArray; i < readerCount; i++, rsCur++)
          {
+                 /* Do endian swaps... */
+                 rsCur->dwCurrentState = swap32(rsCur->dwCurrentState);
+                 rsCur->dwEventState = swap32(rsCur->dwEventState);
+                 rsCur->cbAtr = swap32(rsCur->cbAtr);
                  out_uint8p(out, (void *) ((unsigned char **) rsCur + 2),
                             sizeof(SCARD_READERSTATE_A) - 2 * sizeof(unsigned char *));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 1344 
 TS_SCardBeginTransaction(STREAM in, STRE
+Line 1362 
 TS_SCardBeginTransaction(STREAM in, STRE
          in->p += 0x30;
          in_uint32_le(in, hCard);
          myHCard = scHandleToMyPCSC(hCard);
-         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));
+         DEBUG_SCARD(("SCARD: SCardBeginTransaction(hcard: 0x%08x [0x%08lx])\n",
-         DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));
+                      (unsigned) hCard, (unsigned long) myHCard));
          rv = SCardBeginTransaction(myHCard);
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardBeginTransaction Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardBeginTransaction-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          return rv;
  }
-Line 1377 
 TS_SCardEndTransaction(STREAM in, STREAM
+Line 1396 
 TS_SCardEndTransaction(STREAM in, STREAM
          DEBUG_SCARD(("[myHCard = 0x%016lx]\n", (unsigned long) myHCard));
          DEBUG_SCARD(("[dwDisposition = 0x%.8x]\n", (unsigned int) dwDisposition));
+         DEBUG_SCARD(("SCARD: SCardEndTransaction(hcard: 0x%08x [0x%08lx], disposition: 0x%08x)\n",
+                      (unsigned) hCard, (unsigned long) myHCard, (unsigned) dwDisposition));
          rv = SCardEndTransaction(myHCard, (MYPCSC_DWORD) dwDisposition);
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardEndTransaction Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardEndTransaction-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          return rv;
  }
-Line 1398 
 copyIORequest_MyPCSCToServer(MYPCSC_LPSC
+Line 1420 
 copyIORequest_MyPCSCToServer(MYPCSC_LPSC
          size_t bytesToCopy = src->cbPciLength - sizeof(MYPCSC_SCARD_IO_REQUEST);
          srcBytes = ((unsigned char *) src + sizeof(MYPCSC_SCARD_IO_REQUEST));
          dstBytes = ((unsigned char *) dst + sizeof(SERVER_SCARD_IO_REQUEST));
-         dst->dwProtocol = src->dwProtocol;
+         dst->dwProtocol = swap32((uint32_t)src->dwProtocol);
-         dst->cbPciLength = src->cbPciLength
+         dst->cbPciLength = swap32((uint32_t)src->cbPciLength
-                 - sizeof(MYPCSC_SCARD_IO_REQUEST) + sizeof(SERVER_SCARD_IO_REQUEST);
+                 - sizeof(MYPCSC_SCARD_IO_REQUEST) + sizeof(SERVER_SCARD_IO_REQUEST));
          memcpy(dstBytes, srcBytes, bytesToCopy);
  }
-Line 1411 
 copyIORequest_ServerToMyPCSC(SERVER_LPSC
+Line 1433 
 copyIORequest_ServerToMyPCSC(SERVER_LPSC
          size_t bytesToCopy = src->cbPciLength - sizeof(SERVER_SCARD_IO_REQUEST);
          srcBytes = ((unsigned char *) src + sizeof(SERVER_SCARD_IO_REQUEST));
          dstBytes = ((unsigned char *) dst + sizeof(MYPCSC_SCARD_IO_REQUEST));
-         dst->dwProtocol = src->dwProtocol;
+         dst->dwProtocol = swap32(src->dwProtocol);
-         dst->cbPciLength = src->cbPciLength
+         dst->cbPciLength = src->cbPciLength     /* already correct endian */
                  - sizeof(SERVER_SCARD_IO_REQUEST) + sizeof(MYPCSC_SCARD_IO_REQUEST);
          memcpy(dstBytes, srcBytes, bytesToCopy);
  }
-Line 1518 
 TS_SCardTransmit(STREAM in, STREAM out)
+Line 1540 
 TS_SCardTransmit(STREAM in, STREAM out)
          else
                  pioRecvPci = NULL;
- #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
          myCbRecvLength = cbRecvLength;
          myPioSendPci = SC_xmalloc(&lcHandle,
-Line 1578 
 TS_SCardTransmit(STREAM in, STREAM out)
+Line 1572 
 TS_SCardTransmit(STREAM in, STREAM out)
          if (cbRecvLength > 448)
          {
                  warning("Card response limited from %d to 448 bytes!\n", cbRecvLength);
-                 DEBUG_SCARD(("[RECV LEN %d -> %d]\n", (unsigned int) cbRecvLength, 400));
+                 DEBUG_SCARD(("SCARD:    Truncated %d to %d\n", (unsigned int) cbRecvLength, 448));
                  cbRecvLength = 448;
          }
          if (pioRecvPci)
          {
-                 copyIORequest_MyPCSCToServer(myPioRecvPci, pioRecvPci);
+                 /*
+                  * pscs-lite mishandles this structure in some cases.
+                  * make sure we only copy it if it is valid.
+                  */
+                 if (myPioRecvPci->cbPciLength >= sizeof(MYPCSC_SCARD_IO_REQUEST))
+                         copyIORequest_MyPCSCToServer(myPioRecvPci, pioRecvPci);
          }
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardTransmit Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
- #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
  #if 0
-                 if ((pioRecvPci != NULL) && (pioRecvPci->cbPciLength > 0))
+                 if ((pioRecvPci != NULL) && (mypioRecvPci->cbPciLength > 0))
                  {
                          out_uint32_le(out, (DWORD) pioRecvPci); /* if not NULL, this 4 bytes indicates that pioRecvPci is present */
                  }
-Line 1616 
 TS_SCardTransmit(STREAM in, STREAM out)
+Line 1606 
 TS_SCardTransmit(STREAM in, STREAM out)
                  outBufferStart(out, cbRecvLength);      /* start of recvBuf output */
  #if 0
-                 if ((pioRecvPci) && (pioRecvPci->cbPciLength > 0))
+                 if ((pioRecvPci) && (mypioRecvPci->cbPciLength > 0))
                  {
-                         out_uint32_le(out, pioRecvPci->dwProtocol);
+                         out_uint32_le(out, mypioRecvPci->dwProtocol);
-                         int len = pioRecvPci->cbPciLength - sizeof(pioRecvPci);
+                         int len = mypioRecvPci->cbPciLength - sizeof(mypioRecvPci);
                          outBufferStartWithLimit(out, len, 12);
                          outBufferFinishWithLimit(out,
                                                   (char *) ((DWORD) pioRecvPci + sizeof(pioRecvPci)),
-Line 1629 
 TS_SCardTransmit(STREAM in, STREAM out)
+Line 1619 
 TS_SCardTransmit(STREAM in, STREAM out)
                  outBufferFinish(out, (char *) recvBuf, cbRecvLength);
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
  static MYPCSC_DWORD
- TS_SCardStatus(STREAM in, STREAM out, BOOL wide)
+ TS_SCardStatus(STREAM in, STREAM out, RD_BOOL wide)
  {
          MYPCSC_DWORD rv;
          SERVER_SCARDCONTEXT hCard;
-Line 1655 
 TS_SCardStatus(STREAM in, STREAM out, BO
+Line 1645 
 TS_SCardStatus(STREAM in, STREAM out, BO
          in->p += 0x04;
          myHCard = scHandleToMyPCSC(hCard);
-         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));
          if (dwReaderLen <= 0 || dwReaderLen == SCARD_AUTOALLOCATE || dwReaderLen > SCARD_MAX_MEM)
                  dwReaderLen = SCARD_MAX_MEM;
          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)
                  dwAtrLen = SCARD_MAX_MEM;
+ #if 1
+         /*
+          * Active client sometimes sends a readerlen *just* big enough
+          * SCardStatus doesn't seem to like this. This is a workaround,
+          * aka hack!
+          */
+         dwReaderLen = 200;
+ #endif
          readerName = SC_xmalloc(&lcHandle, dwReaderLen + 2);
          if (!readerName)
                  return SC_returnNoMemoryError(&lcHandle, in, out);
-Line 1686 
 TS_SCardStatus(STREAM in, STREAM out, BO
+Line 1682 
 TS_SCardStatus(STREAM in, STREAM out, BO
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardStatus Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
                  return SC_returnCode(rv, &lcHandle, in, out);
          }
          else
          {
- #ifdef WITH_DEBUG_SCARD
+                 int i;
-                 DEBUG_SCARD(("<--SUCCESS SCardStatus-->\n"));
-                 DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));
+                 DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
-                 DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));
+                              (unsigned) dwState, (unsigned) dwProtocol));
-                 DEBUG_SCARD(("[Reader Name]\n"));
+                 DEBUG_SCARD(("SCARD:        Reader: \"%s\"\n", readerName ? readerName : "NULL"));
-                 hexdump((unsigned char *) readerName, dwReaderLen);
+                 DEBUG_SCARD(("SCARD:        ATR: "));
-                 DEBUG_SCARD(("[Atr]\n"));
+                 for (i = 0; i < dwAtrLen; i++)
-                 hexdump(atr, dwAtrLen);
+                 {
- #endif
+                         DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
+                 }
+                 DEBUG_SCARD(("\n"));
                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
                          dwState = 0x00000006;
                  else
 Line 1745 
 TS_SCardStatus(STREAM in, STREAM out, BO
                  out_uint32_le(out, dataLength);
                  out->p = psave;
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
 Line 1769 
 TS_SCardState(STREAM in, STREAM out)
          in->p += 0x04;
          myHCard = scHandleToMyPCSC(hCard);
-         DEBUG_SCARD(("[hCard 0x%.8x]\n", (unsigned int) hCard));
+         DEBUG_SCARD(("SCARD: SCardState(hcard: 0x%08x [0x%08lx], atr len: %d bytes)\n",
-         DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));
+                      (unsigned) hCard, (unsigned long) myHCard, (int) dwAtrLen));
-         DEBUG_SCARD(("[dwAtrLen %d]\n", (unsigned int) dwAtrLen));
          dwReaderLen = SCARD_MAX_MEM;
          if (dwAtrLen <= 0 || dwAtrLen == SCARD_AUTOALLOCATE || dwAtrLen > SCARD_MAX_MEM)
-Line 1797 
 TS_SCardState(STREAM in, STREAM out)
+Line 1796 
 TS_SCardState(STREAM in, STREAM out)
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardStatus (no ScardState) Code=0x%.8x-->\n",
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
-                              (unsigned int) rv));
+                              pcsc_stringify_error(rv), (unsigned int) rv));
                  return SC_returnCode(rv, &lcHandle, in, out);
          }
          else
          {
- #ifdef WITH_DEBUG_SCARD
+                 int i;
-                 DEBUG_SCARD(("<--SUCCESS SCardStatus (no ScardState)-->\n"));
-                 DEBUG_SCARD(("[dwState 0x%.8x]\n", (unsigned int) dwState));
+                 DEBUG_SCARD(("SCARD: -> Success (state: 0x%08x, proto: 0x%08x)\n",
-                 DEBUG_SCARD(("[dwProtocol 0x%.8x]\n", (unsigned int) dwProtocol));
+                              (unsigned) dwState, (unsigned) dwProtocol));
-                 DEBUG_SCARD(("[Atr]\n"));
+                 DEBUG_SCARD(("SCARD:        ATR: "));
-                 hexdump(atr, dwAtrLen);
+                 for (i = 0; i < dwAtrLen; i++)
- #endif
+                 {
+                         DEBUG_SCARD(("%02x%c", atr[i], (i == dwAtrLen - 1) ? ' ' : ':'));
+                 }
+                 DEBUG_SCARD(("\n"));
                  if (dwState & (SCARD_SPECIFIC | SCARD_NEGOTIABLE))
                          dwState = 0x00000006;
                  else
-Line 1839 
 TS_SCardState(STREAM in, STREAM out)
+Line 1842 
 TS_SCardState(STREAM in, STREAM out)
                  out_uint8p(out, atr, dwAtrLen);
                  outRepos(out, dwAtrLen);
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 1863 
 TS_SCardListReaderGroups(STREAM in, STRE
+Line 1866 
 TS_SCardListReaderGroups(STREAM in, STRE
          in->p += 0x04;
          in_uint32_le(in, hContext);
+         DEBUG_SCARD(("SCARD: SCardListReaderGroups(context: 0x%08x, groups: %d)\n",
+                      (unsigned) hContext, (int) dwGroups));
          if (dwGroups <= 0 || dwGroups == SCARD_AUTOALLOCATE || dwGroups > SCARD_MAX_MEM)
                  dwGroups = SCARD_MAX_MEM;
-Line 1876 
 TS_SCardListReaderGroups(STREAM in, STRE
+Line 1882 
 TS_SCardListReaderGroups(STREAM in, STRE
          if (rv)
          {
-                 DEBUG_SCARD(("<--ERROR SCardListReaderGroups Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
                  return SC_returnCode(rv, &lcHandle, in, out);
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardListReaderGroups-->\n"));
+                 int i;
+                 char *cur;
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
+                 for (i = 0, cur = szGroups; i < dwGroups; i++, cur += strlen(cur) + 1)
+                 {
+                         DEBUG_SCARD(("SCARD:    %s\n", cur));
+                 }
          }
-Line 1892 
 TS_SCardListReaderGroups(STREAM in, STRE
+Line 1906 
 TS_SCardListReaderGroups(STREAM in, STRE
          outRepos(out, dwGroups);
          out_uint32_le(out, 0x00000000);
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 1918 
 TS_SCardGetAttrib(STREAM in, STREAM out)
+Line 1932 
 TS_SCardGetAttrib(STREAM in, STREAM out)
          dwAttrId = dwAttrId & 0x0000FFFF;
-         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));
+         DEBUG_SCARD(("SCARD: SCardGetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
-         DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));
+                      (unsigned) hCard, (unsigned long) myHCard,
-         DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));
+                      (unsigned) dwAttrId, (int) dwAttrLen));
-         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));
          if (dwAttrLen > MAX_BUFFER_SIZE)
                  dwAttrLen = MAX_BUFFER_SIZE;
-Line 1947 
 TS_SCardGetAttrib(STREAM in, STREAM out)
+Line 1960 
 TS_SCardGetAttrib(STREAM in, STREAM out)
          if (dwAttrId == 0x00000100 && rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("Get Attribute ATTR_VENDOR_NAME\n"));
+                 DEBUG_SCARD(("SCARD:    Faking attribute ATTR_VENDOR_NAME\n"));
                  pthread_mutex_lock(&hcardAccess);
                  PSCHCardRec hcard = hcardFirst;
                  while (hcard)
-Line 1967 
 TS_SCardGetAttrib(STREAM in, STREAM out)
+Line 1980 
 TS_SCardGetAttrib(STREAM in, STREAM out)
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardGetAttrib Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
                  return SC_returnCode(rv, &lcHandle, in, out);
          }
          else
          {
- #ifdef WITH_DEBUG_SCARD
+                 DEBUG_SCARD(("SCARD: -> Success (%d bytes)\n", (int) dwAttrLen));
-                 DEBUG_SCARD(("<--SUCCESS SCardGetAttrib-->\n"));
-                 DEBUG_SCARD(("[LENGTH %d]\n", (unsigned int) dwAttrLen));
-                 DEBUG_SCARD(("+++++++++++++++++++++\n"));
-                 hexdump(pbAttr, dwAttrLen);
-                 DEBUG_SCARD(("+++++++++++++++++++++\n"));
- #endif
                  out_uint32_le(out, dwAttrLen);
                  out_uint32_le(out, 0x00000200);
                  out_uint32_le(out, dwAttrLen);
-Line 1993 
 TS_SCardGetAttrib(STREAM in, STREAM out)
+Line 2002 
 TS_SCardGetAttrib(STREAM in, STREAM out)
                  outRepos(out, dwAttrLen);
                  out_uint32_le(out, 0x00000000);
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          return rv;
  }
-Line 2018 
 TS_SCardSetAttrib(STREAM in, STREAM out)
+Line 2027 
 TS_SCardSetAttrib(STREAM in, STREAM out)
          dwAttrId = dwAttrId & 0x0000FFFF;
-         DEBUG_SCARD(("[hCard = 0x%.8x]\n", (unsigned int) hCard));
+         DEBUG_SCARD(("SCARD: SCardSetAttrib(hcard: 0x%08x [0x%08lx], attrib: 0x%08x (%d bytes))\n",
-         DEBUG_SCARD(("[myHCard 0x%.8x]\n", (unsigned int) myHCard));
+                      (unsigned) hCard, (unsigned long) myHCard,
-         DEBUG_SCARD(("[dwAttrId = 0x%.8x]\n", (unsigned int) dwAttrId));
+                      (unsigned) dwAttrId, (int) dwAttrLen));
-         DEBUG_SCARD(("[dwAttrLen = 0x%.8x]\n", (unsigned int) dwAttrLen));
          if (dwAttrLen > MAX_BUFFER_SIZE)
                  dwAttrLen = MAX_BUFFER_SIZE;
-Line 2033 
 TS_SCardSetAttrib(STREAM in, STREAM out)
+Line 2041 
 TS_SCardSetAttrib(STREAM in, STREAM out)
          in_uint8a(in, pbAttr, dwAttrLen);
          rv = SCardSetAttrib(myHCard, (MYPCSC_DWORD) dwAttrId, pbAttr, (MYPCSC_DWORD) dwAttrLen);
-         if (rv)
+         if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardSetAttrib Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 DEBUG_SCARD(("<--SUCCESS SCardSetAttrib-->\n"));
+                 DEBUG_SCARD(("SCARD: -> Success\n"));
          }
          out_uint32_le(out, 0x00000000);
          out_uint32_le(out, 0x00000200);
          out_uint32_le(out, 0x00000000);
          out_uint32_le(out, 0x00000000);
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 2109 
 TS_SCardControl(STREAM in, STREAM out)
+Line 2118 
 TS_SCardControl(STREAM in, STREAM out)
          if (!pOutBuffer)
                  return SC_returnNoMemoryError(&lcHandle, in, out);
- #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
          sc_nBytesReturned = nBytesReturned;
          myHCard = scHandleToMyPCSC(hCard);
-Line 2135 
 TS_SCardControl(STREAM in, STREAM out)
+Line 2132 
 TS_SCardControl(STREAM in, STREAM out)
  #endif
          nBytesReturned = sc_nBytesReturned;
- #ifdef WITH_DEBUG_SCARD
          if (rv != SCARD_S_SUCCESS)
          {
-                 DEBUG_SCARD(("<--ERROR SCardControl Code=0x%.8x-->\n", (unsigned int) rv));
+                 DEBUG_SCARD(("SCARD: -> Failure: %s (0x%08x)\n",
+                              pcsc_stringify_error(rv), (unsigned int) rv));
          }
          else
          {
-                 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"));
          }
- #endif
          out_uint32_le(out, nBytesReturned);
          out_uint32_le(out, 0x00000004);
-Line 2159 
 TS_SCardControl(STREAM in, STREAM out)
+Line 2151 
 TS_SCardControl(STREAM in, STREAM out)
                  outRepos(out, nBytesReturned);
          }
-         outForceAllignment(out, 8);
+         outForceAlignment(out, 8);
          SC_xfreeallmemory(&lcHandle);
          return rv;
  }
-Line 2167 
 TS_SCardControl(STREAM in, STREAM out)
+Line 2159 
 TS_SCardControl(STREAM in, STREAM out)
  static MYPCSC_DWORD
  TS_SCardAccessStartedEvent(STREAM in, STREAM out)
  {
+         DEBUG_SCARD(("SCARD: SCardAccessStartedEvent()\n"));
          out_uint8s(out, 8);
          return SCARD_S_SUCCESS;
  }
- static NTSTATUS
+ static RD_NTSTATUS
- scard_device_control(NTHANDLE handle, uint32 request, STREAM in, STREAM out)
+ scard_device_control(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
  {
          SERVER_DWORD Result = 0x00000000;
          unsigned char *psize, *pend, *pStatusCode;
          SERVER_DWORD addToEnd = 0;
- #ifdef WITH_DEBUG_SCARD
-         unsigned char *pbeg = out->p;
-         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
          /* Processing request */
          out_uint32_le(out, 0x00081001); /* Header lines */
-Line 2202 
 scard_device_control(NTHANDLE handle, ui
+Line 2187 
 scard_device_control(NTHANDLE handle, ui
                          /* SCardEstablishContext */
                  case SC_ESTABLISH_CONTEXT:
                          {
-                                 DEBUG_SCARD(("<---SCardEstablishContext--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardEstablishContext(in, out);
                                  break;
                          }
                          /* SCardReleaseContext */
                  case SC_RELEASE_CONTEXT:
                          {
-                                 DEBUG_SCARD(("<---SCardReleaseContext--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardReleaseContext(in, out);
                                  break;
                          }
                          /* SCardIsValidContext */
                  case SC_IS_VALID_CONTEXT:
                          {
-                                 DEBUG_SCARD(("<---SCardIsValidContext--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardIsValidContext(in, out);
                                  break;
                          }
-Line 2224 
 scard_device_control(NTHANDLE handle, ui
+Line 2206 
 scard_device_control(NTHANDLE handle, ui
                  case SC_LIST_READERS:   /* SCardListReadersA */
                  case SC_LIST_READERS + 4:       /* SCardListReadersW */
                          {
-                                 BOOL wide = request != SC_LIST_READERS;
+                                 RD_BOOL wide = request != SC_LIST_READERS;
-                                 DEBUG_SCARD(("<---SCardListReaders---> (%s)\n",
-                                              (wide) ? ("WIDE") : ("ASCII")));
                                  Result = (SERVER_DWORD) TS_SCardListReaders(in, out, wide);
                                  break;
                          }
-Line 2234 
 scard_device_control(NTHANDLE handle, ui
+Line 2214 
 scard_device_control(NTHANDLE handle, ui
                  case SC_CONNECT:        /* ScardConnectA */
                  case SC_CONNECT + 4:    /* SCardConnectW */
                          {
-                                 BOOL wide = request != SC_CONNECT;
+                                 RD_BOOL wide = request != SC_CONNECT;
-                                 DEBUG_SCARD(("<---SCardConnect---> (%s)\n",
-                                              (wide) ? ("WIDE") : ("ASCII")));
                                  Result = (SERVER_DWORD) TS_SCardConnect(in, out, wide);
                                  break;
                          }
                          /* ScardReconnect */
                  case SC_RECONNECT:
                          {
-                                 DEBUG_SCARD(("<---SCardReconnect--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardReconnect(in, out);
                                  break;
                          }
                          /* ScardDisconnect */
                  case SC_DISCONNECT:
                          {
-                                 DEBUG_SCARD(("<---SCardDisconnect--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardDisconnect(in, out);
                                  break;
                          }
-Line 2258 
 scard_device_control(NTHANDLE handle, ui
+Line 2234 
 scard_device_control(NTHANDLE handle, ui
                  case SC_GET_STATUS_CHANGE:      /* SCardGetStatusChangeA */
                  case SC_GET_STATUS_CHANGE + 4:  /* SCardGetStatusChangeW */
                          {
-                                 BOOL wide = request != SC_GET_STATUS_CHANGE;
+                                 RD_BOOL wide = request != SC_GET_STATUS_CHANGE;
-                                 DEBUG_SCARD(("<---SCardGetStatusChange---> (%s)\n",
-                                              (wide) ? ("WIDE") : ("ASCII")));
                                  Result = (SERVER_DWORD) TS_SCardGetStatusChange(in, out, wide);
                                  break;
                          }
                          /* SCardCancel */
                  case SC_CANCEL:
                          {
-                                 DEBUG_SCARD(("<---SCardCancel--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardCancel(in, out);
                                  break;
                          }
-Line 2275 
 scard_device_control(NTHANDLE handle, ui
+Line 2248 
 scard_device_control(NTHANDLE handle, ui
                  case SC_LOCATE_CARDS_BY_ATR:    /* SCardLocateCardsByATRA */
                  case SC_LOCATE_CARDS_BY_ATR + 4:        /* SCardLocateCardsByATRW */
                          {
-                                 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")));
                                  Result = (SERVER_DWORD) TS_SCardLocateCardsByATR(in, out, wide);
                                  break;
                          }
                          /* SCardBeginTransaction */
                  case SC_BEGIN_TRANSACTION:
                          {
-                                 DEBUG_SCARD(("<---SCardBeginTransaction--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardBeginTransaction(in, out);
                                  break;
                          }
                          /* SCardBeginTransaction */
                  case SC_END_TRANSACTION:
                          {
-                                 DEBUG_SCARD(("<---SCardEndTransaction--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardEndTransaction(in, out);
                                  break;
                          }
                          /* ScardTransmit */
                  case SC_TRANSMIT:
                          {
-                                 DEBUG_SCARD(("<---SCardTransmit--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardTransmit(in, out);
                                  break;
                          }
                          /* SCardControl */
                  case SC_CONTROL:
                          {
-                                 DEBUG_SCARD(("<---SCardControl--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardControl(in, out);
                                  break;
                          }
-Line 2313 
 scard_device_control(NTHANDLE handle, ui
+Line 2280 
 scard_device_control(NTHANDLE handle, ui
  #ifndef WITH_PCSC120
                  case SC_GETATTRIB:
                          {
-                                 DEBUG_SCARD(("<---SCardGetAttrib--->\n"));
                                  Result = (SERVER_DWORD) TS_SCardGetAttrib(in, out);
                                  break;
                          }
  #endif
                  case SC_ACCESS_STARTED_EVENT:
                          {
-                                 DEBUG_SCARD(("<---SCardAccessStartedEvent-->\n"));
                                  Result = (SERVER_DWORD) TS_SCardAccessStartedEvent(in, out);
                                  break;
                          }
                  case SC_STATUS: /* SCardStatusA */
                  case SC_STATUS + 4:     /* SCardStatusW */
                          {
-                                 BOOL wide = request != SC_STATUS;
+                                 RD_BOOL wide = request != SC_STATUS;
-                                 DEBUG_SCARD(("<---SCardStatus---> (%s)\n",
-                                              (wide) ? ("WIDE") : ("ASCII")));
                                  Result = (SERVER_DWORD) TS_SCardStatus(in, out, wide);
                                  break;
                          }
                  case SC_STATE:  /* SCardState */
                          {
-                                 DEBUG_SCARD(("<---SCardState--->"));
                                  Result = (SERVER_DWORD) TS_SCardState(in, out);
                                  break;
                          }
                  default:
                          {
-                                 DEBUG_SCARD(("<---UNSUPPORTED-FUNC--->\n"));
+                                 warning("SCARD: Unknown function %d\n", (int) request);
                                  Result = 0x80100014;
                                  out_uint8s(out, 256);
                                  break;
-Line 2368 
 scard_device_control(NTHANDLE handle, ui
+Line 2330 
 scard_device_control(NTHANDLE handle, ui
                  out_uint8s(out, addToEnd);
          }
- #ifdef WITH_DEBUG_SCARD
+         return RD_STATUS_SUCCESS;
-         DEBUG_SCARD(("[OUTPUT DUMP]-------------------\n"));
-         hexdump(pbeg, (size_t) (out->p) - (size_t) pbeg);
-         DEBUG_SCARD(("--------------------------------\n"));
- #endif
-         return STATUS_SUCCESS;
  }
  /* Thread functions */
  static STREAM
- duplicateStream(PMEM_HANDLE * handle, STREAM s, uint32 buffer_size, BOOL isInputStream)
+ duplicateStream(PMEM_HANDLE * handle, STREAM s, uint32 buffer_size, RD_BOOL isInputStream)
  {
          STREAM d = SC_xmalloc(handle, sizeof(struct stream));
          if (d != NULL)
-Line 2428 
 freeStream(PMEM_HANDLE * handle, STREAM
+Line 2385 
 freeStream(PMEM_HANDLE * handle, STREAM
  }
  static PSCThreadData
- SC_addToQueue(NTHANDLE handle, uint32 request, STREAM in, STREAM out)
+ SC_addToQueue(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
  {
          PMEM_HANDLE lcHandle = NULL;
          PSCThreadData data = SC_xmalloc(&lcHandle, sizeof(TSCThreadData));
-Line 2466 
 SC_addToQueue(NTHANDLE handle, uint32 re
+Line 2423 
 SC_addToQueue(NTHANDLE handle, uint32 re
                  if (!queueFirst)
                          queueFirst = data;
-                 pthread_mutex_unlock(&queueEmpty);
+                 pthread_cond_broadcast(&queueEmpty);
                  pthread_mutex_unlock(&queueAccess);
          }
          return data;
-Line 2486 
 static PSCThreadData
+Line 2443 
 static PSCThreadData
  SC_getNextInQueue()
  {
          PSCThreadData Result = NULL;
          pthread_mutex_lock(&queueAccess);
-         if (queueFirst != NULL)
+         while (queueFirst == NULL)
+                 pthread_cond_wait(&queueEmpty, &queueAccess);
+         Result = queueFirst;
+         queueFirst = queueFirst->next;
+         if (!queueFirst)
          {
-                 Result = queueFirst;
+                 queueLast = NULL;
-                 queueFirst = queueFirst->next;
-                 if (!queueFirst)
-                 {
-                         queueLast = NULL;
-                         pthread_mutex_trylock(&queueEmpty);
-                 }
-                 Result->next = NULL;
          }
+         Result->next = NULL;
          pthread_mutex_unlock(&queueAccess);
          return Result;
  }
-Line 2508 
 SC_deviceControl(PSCThreadData data)
+Line 2468 
 SC_deviceControl(PSCThreadData data)
          size_t buffer_len = 0;
          scard_device_control(data->handle, data->request, data->in, data->out);
          buffer_len = (size_t) data->out->p - (size_t) data->out->data;
- #if 0
-         pthread_mutex_lock(&sendControl);
- #endif
          rdpdr_send_completion(data->device, data->id, 0, buffer_len, data->out->data, buffer_len);
- #if 0
-         pthread_mutex_unlock(&sendControl);
- #endif
          SC_destroyThreadData(data);
  }
-Line 2522 
 SC_deviceControl(PSCThreadData data)
+Line 2476 
 SC_deviceControl(PSCThreadData data)
  static void *
  thread_function(PThreadListElement listElement)
  {
- #ifdef WITH_DEBUG_SCARD
+         pthread_mutex_lock(&listElement->busy);
-         long sTime = 0;
+         while (1)
- #endif
-         if ((listElement != NULL) && (listElement->data != NULL))
          {
-                 while (1)
+                 while (listElement->data == NULL)
-                 {
+                         pthread_cond_wait(&listElement->nodata,
- #ifdef WITH_DEBUG_SCARD
+                             &listElement->busy);
-                         sTime = time(NULL);
- #endif
+                 SC_deviceControl(listElement->data);
-                         pthread_mutex_lock(&listElement->nodata);
+                 listElement->data = NULL;
-                         SC_deviceControl(listElement->data);
-                         listElement->data = NULL;
-                         DEBUG_SCARD(("[HANDLING TIME %d]\n", (int) (time(NULL) - sTime)));
-                         pthread_mutex_unlock(&listElement->busy);
-                 }
          }
+         pthread_mutex_unlock(&listElement->busy);
          pthread_exit(NULL);
          return NULL;
  }
-Line 2547 
 static void
+Line 2496 
 static void
  SC_handleRequest(PSCThreadData data)
  {
          int Result = 0;
-         PThreadListElement cur = threadList, last = threadList;
+         PThreadListElement cur;
-         DEBUG_SCARD(("[THREAD COUNT %d]\n", threadCount));
-         while (cur)
+         for (cur = threadList; cur != NULL; cur = cur->next) {
-         {
+                 if (cur->data == NULL) {
-                 if (0 == pthread_mutex_trylock(&cur->busy))
+                         pthread_mutex_lock(&cur->busy);
-                 {
+                         /* double check with lock held.... */
+                         if (cur->data != NULL) {
+                                 pthread_mutex_unlock(&cur->busy);
+                                 continue;
+                         }
+                         /* Wake up thread */
                          cur->data = data;
-                         pthread_mutex_unlock(&cur->nodata);
+                         pthread_cond_broadcast(&cur->nodata);
+                         pthread_mutex_unlock(&cur->busy);
                          return;
                  }
-                 else
-                 {
-                         last = cur;
-                         cur = cur->next;
-                 }
          }
          cur = SC_xmalloc(&threadListHandle, sizeof(TThreadListElement));
-Line 2572 
 SC_handleRequest(PSCThreadData data)
+Line 2521 
 SC_handleRequest(PSCThreadData data)
          threadCount++;
-         cur->next = NULL;
          pthread_mutex_init(&cur->busy, NULL);
-         pthread_mutex_init(&cur->nodata, NULL);
+         pthread_cond_init(&cur->nodata, NULL);
-         pthread_mutex_trylock(&cur->busy);
          cur->data = data;
-         pthread_mutex_unlock(&cur->nodata);
          Result = pthread_create(&cur->thread, NULL, (void *(*)(void *)) thread_function, cur);
          if (0 != Result)
-Line 2587 
 SC_handleRequest(PSCThreadData data)
+Line 2533 
 SC_handleRequest(PSCThreadData data)
                  SC_destroyThreadData(data);
                  data = NULL;
          }
-         else if (last)
+         cur->next = threadList;
-                 last->next = cur;
+         threadList = cur;
-         else
-                 threadList = cur;
  }
  static void *
-Line 2600 
 queue_handler_function(void *data)
+Line 2544 
 queue_handler_function(void *data)
          while (1)
          {
                  cur_data = SC_getNextInQueue();
-                 if (cur_data != NULL)
+                 switch (cur_data->request)
                  {
-                         switch (cur_data->request)
+                         case SC_ESTABLISH_CONTEXT:
-                         {
+                         case SC_RELEASE_CONTEXT:
-                                 case SC_ESTABLISH_CONTEXT:
+                                 {
-                                 case SC_RELEASE_CONTEXT:
+                                         SC_deviceControl(cur_data);
-                                         {
+                                         break;
-                                                 SC_deviceControl(cur_data);
+                                 }
-                                                 break;
+                         default:
-                                         }
+                                 {
-                                 default:
+                                         SC_handleRequest(cur_data);
-                                         {
+                                         break;
-                                                 SC_handleRequest(cur_data);
+                                 }
-                                                 break;
-                                         }
-                         }
-                         cur_data = NULL;
                  }
-                 else
-                         pthread_mutex_lock(&queueEmpty);
          }
          return NULL;
  }
- static NTSTATUS
+ static RD_NTSTATUS
- thread_wrapper(NTHANDLE handle, uint32 request, STREAM in, STREAM out)
+ thread_wrapper(RD_NTHANDLE handle, uint32 request, STREAM in, STREAM out)
  {
          if (SC_addToQueue(handle, request, in, out))
-                 return STATUS_PENDING | 0xC0000000;
+                 return RD_STATUS_PENDING | 0xC0000000;
          else
-                 return STATUS_NO_SUCH_FILE;
+                 return RD_STATUS_NO_SUCH_FILE;
  }
  DEVICE_FNS scard_fns = {
-Line 2643 
 DEVICE_FNS scard_fns = {
+Line 2581 
 DEVICE_FNS scard_fns = {
  #endif /* MAKE_PROTO */
  void
- scard_tcp_lock(void)
+ scard_lock(int lock)
  {
-         if (!tcp_sendcontrol_mutex)
+         if (!scard_mutex)
          {
-                 tcp_sendcontrol_mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
+                 int i;
-                 pthread_mutex_init(tcp_sendcontrol_mutex, NULL);
-         }
-         pthread_mutex_lock(tcp_sendcontrol_mutex);
- }
- void
- scard_tcp_unlock(void)
- {
-         pthread_mutex_unlock(tcp_sendcontrol_mutex);
- }
- STREAM
- scard_tcp_init(void)
- {
-         STREAM result = NULL;
-         result = &out[cur_stream_id];
+                 scard_mutex =
-         cur_stream_id = (cur_stream_id + 1) % STREAM_COUNT;
+                         (pthread_mutex_t **) xmalloc(sizeof(pthread_mutex_t *) * SCARD_LOCK_LAST);
-         return result;
+                 for (i = 0; i < SCARD_LOCK_LAST; i++)
- }
+                 {
+                         scard_mutex[i] = NULL;
- void
+                 }
- scard_tcp_connect(void)
+         }
- {
-         int i;
-         for (i = 0; i < STREAM_COUNT; i++)
+         if (!scard_mutex[lock])
          {
-                 out[i].size = 4096;
+                 scard_mutex[lock] = (pthread_mutex_t *) xmalloc(sizeof(pthread_mutex_t));
-                 out[i].data = (uint8 *) xmalloc(out[i].size);
+                 pthread_mutex_init(scard_mutex[lock], NULL);
          }
+         pthread_mutex_lock(scard_mutex[lock]);
  }
  void
- scard_tcp_reset_state(void)
+ scard_unlock(int lock)
  {
-         int i;
+         pthread_mutex_unlock(scard_mutex[lock]);
-         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.1319
 


changed lines


 
Added in v.1421
 Legend:



Removed from v.1319
 


changed lines


 
Added in v.1421
-Removed from v.1319
+Added in v.1421

	ViewVC Help
Powered by ViewVC 1.1.26