wks: Take name of sendmail from configure.
[gnupg.git] / scd / ccid-driver.c
index 7d70819..f33a36c 100644 (file)
 */
 #define CCID_MAX_BUF (2048+7+10)
 
-/* CCID command timeout.  OpenPGPcard v2.1 requires timeout of 13 seconds.  */
-#define CCID_CMD_TIMEOUT (13*1000)
+/* CCID command timeout.  */
+#define CCID_CMD_TIMEOUT (5*1000)
+/* OpenPGPcard v2.1 requires huge timeout for key generation.  */
+#define CCID_CMD_TIMEOUT_LONGER (60*1000)
 
 /* Depending on how this source is used we either define our error
    output to go to stderr or to the GnuPG based logging functions.  We
@@ -216,35 +218,14 @@ enum {
 #define CCID_ERROR_CODE(buf)     (((unsigned char *)(buf))[8])
 
 
-/* A list and a table with special transport descriptions. */
-enum {
-  TRANSPORT_USB    = 0, /* Standard USB transport. */
-  TRANSPORT_CM4040 = 1  /* As used by the Cardman 4040. */
-};
-
-static struct
-{
-  char *name;  /* Device name. */
-  int  type;
-
-} transports[] = {
-  { "/dev/cmx0", TRANSPORT_CM4040 },
-  { "/dev/cmx1", TRANSPORT_CM4040 },
-  { NULL },
-};
-
-
 /* Store information on the driver's state.  A pointer to such a
    structure is used as handle for most functions. */
 struct ccid_driver_s
 {
   libusb_device_handle *idev;
-  char *rid;
-  int dev_fd;  /* -1 for USB transport or file descriptor of the
-                   transport device. */
+  unsigned int bai;
   unsigned short id_vendor;
   unsigned short id_product;
-  unsigned short bcd_device;
   int ifc_no;
   int ep_bulk_out;
   int ep_bulk_in;
@@ -263,9 +244,9 @@ struct ccid_driver_s
   unsigned int auto_param:1;
   unsigned int auto_pps:1;
   unsigned int auto_ifsd:1;
-  unsigned int powered_off:1;
   unsigned int has_pinpad:2;
   unsigned int enodev_seen:1;
+  int powered_off;
 
   time_t last_progress; /* Last time we sent progress line.  */
 
@@ -273,6 +254,9 @@ struct ccid_driver_s
      ccid_set_progress_cb.  */
   void (*progress_cb)(void *, const char *, int, int, int);
   void *progress_cb_arg;
+
+  unsigned char intr_buf[64];
+  struct libusb_transfer *transfer;
 };
 
 
@@ -283,6 +267,7 @@ static int debug_level;     /* Flag to control the debug output.
                                2 = Level 1 + T=1 protocol tracing
                                3 = Level 2 + USB/I/O tracing of SlotStatus.
                               */
+static int ccid_usb_thread_is_alive;
 
 
 static unsigned int compute_edc (const unsigned char *data, size_t datalen,
@@ -325,20 +310,6 @@ set_msg_len (unsigned char *msg, unsigned int length)
 
 
 static void
-my_sleep (int seconds)
-{
-#ifdef USE_NPTH
-  npth_sleep (seconds);
-#else
-# ifdef HAVE_W32_SYSTEM
-  Sleep (seconds*1000);
-# else
-  sleep (seconds);
-# endif
-#endif
-}
-
-static void
 print_progress (ccid_driver_t handle)
 {
   time_t ct = time (NULL);
@@ -712,31 +683,6 @@ print_r2p_unknown (const unsigned char *msg, size_t msglen)
 }
 
 
-/* Given a handle used for special transport prepare it for use.  In
-   particular setup all information in way that resembles what
-   parse_cccid_descriptor does. */
-static void
-prepare_special_transport (ccid_driver_t handle)
-{
-  assert (!handle->id_vendor);
-
-  handle->nonnull_nad = 0;
-  handle->auto_ifsd = 0;
-  handle->max_ifsd = 32;
-  handle->max_ccid_msglen = CCID_MAX_BUF;
-  handle->has_pinpad = 0;
-  handle->apdu_level = 0;
-  switch (handle->id_product)
-    {
-    case TRANSPORT_CM4040:
-      DEBUGOUT ("setting up transport for CardMan 4040\n");
-      handle->apdu_level = 1;
-      break;
-
-    default: assert (!"transport not defined");
-    }
-}
-
 /* Parse a CCID descriptor, optionally print all available features
    and test whether this reader is usable by this driver.  Returns 0
    if it is usable.
@@ -744,14 +690,13 @@ prepare_special_transport (ccid_driver_t handle)
    Note, that this code is based on the one in lsusb.c of the
    usb-utils package, I wrote on 2003-09-01. -wk. */
 static int
-parse_ccid_descriptor (ccid_driver_t handle,
+parse_ccid_descriptor (ccid_driver_t handle, unsigned short bcd_device,
                        const unsigned char *buf, size_t buflen)
 {
   unsigned int i;
   unsigned int us;
   int have_t1 = 0, have_tpdu=0;
 
-
   handle->nonnull_nad = 0;
   handle->auto_ifsd = 0;
   handle->max_ifsd = 32;
@@ -761,7 +706,7 @@ parse_ccid_descriptor (ccid_driver_t handle,
   handle->auto_param = 0;
   handle->auto_pps = 0;
   DEBUGOUT_3 ("idVendor: %04X  idProduct: %04X  bcdDevice: %04X\n",
-              handle->id_vendor, handle->id_product, handle->bcd_device);
+              handle->id_vendor, handle->id_product, bcd_device);
   if (buflen < 54 || buf[0] < 54)
     {
       DEBUGOUT ("CCID device descriptor is too short\n");
@@ -959,16 +904,16 @@ parse_ccid_descriptor (ccid_driver_t handle,
      The
          0x5117 - SCR 3320 USB ID-000 reader
      seems to be very slow but enabling this workaround boosts the
-     performance to a more or less acceptable level (tested by David).
+     performance to a more or less acceptable level (tested by David).
 
   */
   if (handle->id_vendor == VENDOR_SCM
       && handle->max_ifsd > 48
-      && (  (handle->id_product == SCM_SCR331   && handle->bcd_device < 0x0516)
-          ||(handle->id_product == SCM_SCR331DI && handle->bcd_device < 0x0620)
-          ||(handle->id_product == SCM_SCR335   && handle->bcd_device < 0x0514)
-          ||(handle->id_product == SCM_SPR532   && handle->bcd_device < 0x0504)
-          ||(handle->id_product == SCM_SCR3320  && handle->bcd_device < 0x0522)
+      && (  (handle->id_product == SCM_SCR331   && bcd_device < 0x0516)
+          ||(handle->id_product == SCM_SCR331DI && bcd_device < 0x0620)
+          ||(handle->id_product == SCM_SCR335   && bcd_device < 0x0514)
+          ||(handle->id_product == SCM_SPR532   && bcd_device < 0x0504)
+          ||(handle->id_product == SCM_SCR3320  && bcd_device < 0x0522)
           ))
     {
       DEBUGOUT ("enabling workaround for buggy SCM readers\n");
@@ -1006,19 +951,31 @@ get_escaped_usb_string (libusb_device_handle *idev, int idx,
   /* First get the list of supported languages and use the first one.
      If we do don't find it we try to use English.  Note that this is
      all in a 2 bute Unicode encoding using little endian. */
+#ifdef USE_NPTH
+  npth_unprotect ();
+#endif
   rc = libusb_control_transfer (idev, LIBUSB_ENDPOINT_IN,
                                 LIBUSB_REQUEST_GET_DESCRIPTOR,
                                 (LIBUSB_DT_STRING << 8), 0,
                                 (char*)buf, sizeof buf, 1000 /* ms timeout */);
+#ifdef USE_NPTH
+  npth_protect ();
+#endif
   if (rc < 4)
     langid = 0x0409; /* English.  */
   else
     langid = (buf[3] << 8) | buf[2];
 
+#ifdef USE_NPTH
+  npth_unprotect ();
+#endif
   rc = libusb_control_transfer (idev, LIBUSB_ENDPOINT_IN,
                                 LIBUSB_REQUEST_GET_DESCRIPTOR,
                                 (LIBUSB_DT_STRING << 8) + idx, langid,
                                 (char*)buf, sizeof buf, 1000 /* ms timeout */);
+#ifdef USE_NPTH
+  npth_protect ();
+#endif
   if (rc < 2 || buf[1] != LIBUSB_DT_STRING)
     return NULL; /* Error or not a string. */
   len = buf[0];
@@ -1102,8 +1059,9 @@ find_endpoint (const struct libusb_interface_descriptor *ifcdesc, int mode)
                    == LIBUSB_TRANSFER_TYPE_INTERRUPT)
                && (ep->bEndpointAddress & 0x80))
         return ep->bEndpointAddress;
-      else if (((ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
-                == LIBUSB_TRANSFER_TYPE_BULK)
+      else if ((mode == 0 || mode == 1)
+               && ((ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
+                   == LIBUSB_TRANSFER_TYPE_BULK)
                && (ep->bEndpointAddress & 0x80) == want_bulk_in)
         return ep->bEndpointAddress;
     }
@@ -1112,373 +1070,136 @@ find_endpoint (const struct libusb_interface_descriptor *ifcdesc, int mode)
 }
 
 
-/* Helper for scan_or_find_devices. This function returns true if a
+/* Helper for scan_devices. This function returns true if a
    requested device has been found or the caller should stop scanning
    for other reasons. */
-static int
-scan_or_find_usb_device (int scan_mode,
-                         int readerno, int *count, char **rid_list,
-                         const char *readerid,
-                         struct libusb_device *dev,
-                         char **r_rid,
-                         struct libusb_device_descriptor *desc,
-                         libusb_device_handle **r_idev,
-                         unsigned char **ifcdesc_extra,
-                         size_t *ifcdesc_extra_len,
-                         int *interface_number,
-                         int *ep_bulk_out, int *ep_bulk_in, int *ep_intr)
-{
-  int cfg_no;
+static void
+scan_usb_device (int *count, char **rid_list, struct libusb_device *dev)
+{
   int ifc_no;
   int set_no;
   const struct libusb_interface_descriptor *ifcdesc;
   char *rid;
   libusb_device_handle *idev = NULL;
   int err;
+  struct libusb_config_descriptor *config;
+  struct libusb_device_descriptor desc;
+  char *p;
 
-  err = libusb_get_device_descriptor (dev, desc);
-  if (err < 0)
-    return 0;
-
-  *r_idev = NULL;
-
-  for (cfg_no=0; cfg_no < desc->bNumConfigurations; cfg_no++)
-    {
-      struct libusb_config_descriptor *config;
+  err = libusb_get_device_descriptor (dev, &desc);
+  if (err)
+    return;
 
-      err = libusb_get_config_descriptor (dev, cfg_no, &config);
-      if (err < 0)
-        {
-          if (err == LIBUSB_ERROR_NO_MEM)
-            return 0;
-          continue;
-        }
+  err = libusb_get_active_config_descriptor (dev, &config);
+  if (err)
+    return;
 
-      for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
-        {
-          for (set_no=0; set_no < config->interface[ifc_no].num_altsetting;
-               set_no++)
-            {
-              ifcdesc = (config->interface[ifc_no].altsetting + set_no);
-              /* The second condition is for older SCM SPR 532 who did
-                 not know about the assigned CCID class.  The third
-                 condition does the same for a Cherry SmartTerminal
-                 ST-2000.  Instead of trying to interpret the strings
-                 we simply check the product ID. */
-              if (ifcdesc && ifcdesc->extra
-                  && ((ifcdesc->bInterfaceClass == 11
-                       && ifcdesc->bInterfaceSubClass == 0
-                       && ifcdesc->bInterfaceProtocol == 0)
-                      || (ifcdesc->bInterfaceClass == 255
-                          && desc->idVendor == VENDOR_SCM
-                          && desc->idProduct == SCM_SPR532)
-                      || (ifcdesc->bInterfaceClass == 255
-                          && desc->idVendor == VENDOR_CHERRY
-                          && desc->idProduct == CHERRY_ST2000)))
-                {
-                  ++*count;
-                  if (!scan_mode
-                      && ((readerno > 0 && readerno != *count - 1)))
-                    continue;
-
-                  err = libusb_open (dev, &idev);
-                  if (err < 0)
-                    {
-                      DEBUGOUT_1 ("usb_open failed: %s\n",
-                                  libusb_error_name (err));
-                      continue; /* with next setting. */
-                    }
-
-                  rid = make_reader_id (idev, desc->idVendor, desc->idProduct,
-                                        desc->iSerialNumber);
-                  if (!rid)
-                    {
-                      libusb_free_config_descriptor (config);
-                      return 0;
-                    }
-
-                  if (!scan_mode && readerno == -1 && readerid
-                      && strncmp (rid, readerid, strlen (readerid)))
-                    continue;
-
-                  if (scan_mode)
-                    {
-                      char *p;
-
-                      /* We are collecting infos about all
-                         available CCID readers.  Store them and
-                         continue. */
-                      DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n",
-                                  *count, rid );
-                      p = malloc ((*rid_list? strlen (*rid_list):0) + 1
-                                  + strlen (rid) + 1);
-                      if (p)
-                        {
-                          *p = 0;
-                          if (*rid_list)
-                            {
-                              strcat (p, *rid_list);
-                              free (*rid_list);
-                            }
-                          strcat (p, rid);
-                          strcat (p, "\n");
-                          *rid_list = p;
-                        }
-                      else /* Out of memory. */
-                        {
-                          libusb_free_config_descriptor (config);
-                          free (rid);
-                          return 0;
-                        }
-                    }
-                  else
-                    {
-                      /* We found the requested reader. */
-                      if (ifcdesc_extra && ifcdesc_extra_len)
-                        {
-                          *ifcdesc_extra = malloc (ifcdesc
-                                                   ->extra_length);
-                          if (!*ifcdesc_extra)
-                            {
-                              libusb_close (idev);
-                              free (rid);
-                              libusb_free_config_descriptor (config);
-                              return 1; /* Out of core. */
-                            }
-                          memcpy (*ifcdesc_extra, ifcdesc->extra,
-                                  ifcdesc->extra_length);
-                          *ifcdesc_extra_len = ifcdesc->extra_length;
-                        }
-
-                      if (interface_number)
-                        *interface_number = (ifcdesc->bInterfaceNumber);
-
-                      if (ep_bulk_out)
-                        *ep_bulk_out = find_endpoint (ifcdesc, 0);
-                      if (ep_bulk_in)
-                        *ep_bulk_in = find_endpoint (ifcdesc, 1);
-                      if (ep_intr)
-                        *ep_intr = find_endpoint (ifcdesc, 2);
-
-                      if (r_rid)
-                        {
-                          *r_rid = rid;
-                          rid = NULL;
-                        }
-                      else
-                        free (rid);
-
-                      *r_idev = idev;
-                      libusb_free_config_descriptor (config);
-                      return 1; /* Found requested device. */
-                    }
-
-                  free (rid);
-                  libusb_close (idev);
-                  idev = NULL;
-                }
-            }
-        }
+  for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
+    for (set_no=0; set_no < config->interface[ifc_no].num_altsetting; set_no++)
+      {
+        ifcdesc = (config->interface[ifc_no].altsetting + set_no);
+        /* The second condition is for older SCM SPR 532 who did
+           not know about the assigned CCID class.  The third
+           condition does the same for a Cherry SmartTerminal
+           ST-2000.  Instead of trying to interpret the strings
+           we simply check the product ID. */
+        if (ifcdesc && ifcdesc->extra
+            && ((ifcdesc->bInterfaceClass == 11
+                 && ifcdesc->bInterfaceSubClass == 0
+                 && ifcdesc->bInterfaceProtocol == 0)
+                || (ifcdesc->bInterfaceClass == 255
+                    && desc.idVendor == VENDOR_SCM
+                    && desc.idProduct == SCM_SPR532)
+                || (ifcdesc->bInterfaceClass == 255
+                    && desc.idVendor == VENDOR_CHERRY
+                    && desc.idProduct == CHERRY_ST2000)))
+          {
+            ++*count;
+
+            err = libusb_open (dev, &idev);
+            if (err)
+              {
+                DEBUGOUT_1 ("usb_open failed: %s\n", libusb_error_name (err));
+                continue; /* with next setting. */
+              }
+
+            rid = make_reader_id (idev, desc.idVendor, desc.idProduct,
+                                  desc.iSerialNumber);
+            if (!rid)
+              {
+                libusb_free_config_descriptor (config);
+                return;
+              }
+
+            /* We are collecting infos about all available CCID
+               readers.  Store them and continue.  */
+            DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", *count, rid);
+            p = malloc ((*rid_list? strlen (*rid_list):0) + 1
+                        + strlen (rid) + 1);
+            if (p)
+              {
+                *p = 0;
+                if (*rid_list)
+                  {
+                    strcat (p, *rid_list);
+                    free (*rid_list);
+                  }
+                strcat (p, rid);
+                strcat (p, "\n");
+                *rid_list = p;
+              }
+            else /* Out of memory. */
+              {
+                libusb_free_config_descriptor (config);
+                free (rid);
+                return;
+              }
 
-      libusb_free_config_descriptor (config);
-    }
+            free (rid);
+            libusb_close (idev);
+            idev = NULL;
+          }
+      }
 
-  return 0;
+  libusb_free_config_descriptor (config);
 }
 
-/* Combination function to either scan all CCID devices or to find and
-   open one specific device.
+/* Scan all CCID devices.
 
    The function returns 0 if a reader has been found or when a scan
    returned without error.
 
-   With READERNO = -1 and READERID is NULL, scan mode is used and
    R_RID should be the address where to store the list of reader_ids
    we found.  If on return this list is empty, no CCID device has been
    found; otherwise it points to an allocated linked list of reader
-   IDs.  Note that in this mode the function always returns NULL.
-
-   With READERNO >= 0 or READERID is not NULL find mode is used.  This
-   uses the same algorithm as the scan mode but stops and returns at
-   the entry number READERNO and return the handle for the the opened
-   USB device. If R_RID is not NULL it will receive the reader ID of
-   that device.  If R_DEV is not NULL it will the device pointer of
-   that device.  If IFCDESC_EXTRA is NOT NULL it will receive a
-   malloced copy of the interfaces "extra: data filed;
-   IFCDESC_EXTRA_LEN receive the length of this field.  If there is
-   no reader with number READERNO or that reader is not usable by our
-   implementation NULL will be returned.  The caller must close a
-   returned USB device handle and free (if not passed as NULL) the
-   returned reader ID info as well as the IFCDESC_EXTRA.  On error
-   NULL will get stored at R_RID, R_DEV, IFCDESC_EXTRA and
-   IFCDESC_EXTRA_LEN.  With READERID being -1 the function stops if
-   the READERID was found.
-
-   If R_FD is not -1 on return the device is not using USB for
-   transport but the device associated with that file descriptor.  In
-   this case INTERFACE will receive the transport type and the other
-   USB specific return values are not used; the return value is
-   (void*)(1).
-
-   Note that the first entry of the returned reader ID list in scan mode
-   corresponds with a READERNO of 0 in find mode.
+   IDs.
 */
 static int
-scan_or_find_devices (int readerno, const char *readerid,
-                      char **r_rid,
-                      struct libusb_device_descriptor *r_desc,
-                      unsigned char **ifcdesc_extra,
-                      size_t *ifcdesc_extra_len,
-                      int *interface_number,
-                      int *ep_bulk_out, int *ep_bulk_in, int *ep_intr,
-                      libusb_device_handle **r_idev,
-                      int *r_fd)
+scan_devices (char **r_rid)
 {
   char *rid_list = NULL;
   int count = 0;
   libusb_device **dev_list = NULL;
   libusb_device *dev;
-  libusb_device_handle *idev = NULL;
-  int scan_mode = (readerno == -1 && !readerid);
   int i;
   ssize_t n;
-  struct libusb_device_descriptor desc;
 
   /* Set return values to a default. */
   if (r_rid)
     *r_rid = NULL;
-  if (ifcdesc_extra)
-    *ifcdesc_extra = NULL;
-  if (ifcdesc_extra_len)
-    *ifcdesc_extra_len = 0;
-  if (interface_number)
-    *interface_number = 0;
-  if (r_idev)
-    *r_idev = NULL;
-  if (r_fd)
-    *r_fd = -1;
-
-  /* See whether we want scan or find mode. */
-  if (scan_mode)
-    {
-      assert (r_rid);
-    }
 
   n = libusb_get_device_list (NULL, &dev_list);
 
   for (i = 0; i < n; i++)
     {
       dev = dev_list[i];
-      if (scan_or_find_usb_device (scan_mode, readerno, &count, &rid_list,
-                                   readerid,
-                                   dev,
-                                   r_rid,
-                                   &desc,
-                                   &idev,
-                                   ifcdesc_extra,
-                                   ifcdesc_extra_len,
-                                   interface_number,
-                                   ep_bulk_out, ep_bulk_in, ep_intr))
-        {
-          libusb_free_device_list (dev_list, 1);
-          /* Found requested device or out of core. */
-          if (!idev)
-            {
-              free (rid_list);
-              return -1; /* error */
-            }
-          *r_idev = idev;
-          if (r_desc)
-            memcpy (r_desc, &desc, sizeof (struct libusb_device_descriptor));
-          return 0;
-        }
+      scan_usb_device (&count, &rid_list, dev);
     }
 
   libusb_free_device_list (dev_list, 1);
 
-  /* Now check whether there are any devices with special transport types. */
-  for (i=0; transports[i].name; i++)
-    {
-      int fd;
-      char *rid, *p;
-
-      fd = open (transports[i].name, O_RDWR);
-      if (fd == -1 && scan_mode && errno == EBUSY)
-        {
-          /* Ignore this error in scan mode because it indicates that
-             the device exists but is already open (most likely by us)
-             and thus in general suitable as a reader.  */
-        }
-      else if (fd == -1)
-        {
-          DEBUGOUT_2 ("failed to open '%s': %s\n",
-                     transports[i].name, strerror (errno));
-          continue;
-        }
-
-      rid = malloc (strlen (transports[i].name) + 30 + 10);
-      if (!rid)
-        {
-          if (fd != -1)
-            close (fd);
-          free (rid_list);
-          return -1; /* Error. */
-        }
-      sprintf (rid, "0000:%04X:%s:0", transports[i].type, transports[i].name);
-      if (scan_mode)
-        {
-          DEBUGOUT_2 ("found CCID reader %d (ID=%s)\n", count, rid);
-          p = malloc ((rid_list? strlen (rid_list):0) + 1 + strlen (rid) + 1);
-          if (!p)
-            {
-              if (fd != -1)
-                close (fd);
-              free (rid_list);
-              free (rid);
-              return -1; /* Error. */
-            }
-          *p = 0;
-          if (rid_list)
-            {
-              strcat (p, rid_list);
-              free (rid_list);
-            }
-          strcat (p, rid);
-          strcat (p, "\n");
-          rid_list = p;
-          ++count;
-        }
-      else if (!readerno ||
-               (readerno < 0 && readerid && !strcmp (readerid, rid)))
-        {
-          /* Found requested device. */
-          if (interface_number)
-            *interface_number = transports[i].type;
-          if (r_rid)
-            *r_rid = rid;
-          else
-            free (rid);
-          if (r_fd)
-            *r_fd = fd;
-          return 0; /* Okay, found device */
-        }
-      else /* This is not yet the reader we want. */
-        {
-          if (readerno >= 0)
-            --readerno;
-        }
-      free (rid);
-      if (fd != -1)
-        close (fd);
-    }
-
-  if (scan_mode)
-    {
-      *r_rid = rid_list;
-      return 0;
-    }
-  else
-    return -1;
+  *r_rid = rid_list;
+  return 0;
 }
 
 
@@ -1507,12 +1228,16 @@ ccid_get_reader_list (void)
 
   if (!initialized_usb)
     {
-      libusb_init (NULL);
+      int rc;
+      if ((rc = libusb_init (NULL)))
+        {
+          DEBUGOUT_1 ("usb_init failed: %s.\n", libusb_error_name (rc));
+          return NULL;
+        }
       initialized_usb = 1;
     }
 
-  if (scan_or_find_devices (-1, NULL, &reader_list, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL))
+  if (scan_devices (&reader_list))
     return NULL; /* Error. */
   return reader_list;
 }
@@ -1545,110 +1270,393 @@ ccid_vendor_specific_init (ccid_driver_t handle)
 }
 
 
-/* Open the reader with the internal number READERNO and return a
-   pointer to be used as handle in HANDLE.  Returns 0 on success. */
-int
-ccid_open_reader (ccid_driver_t *handle, const char *readerid,
-                  const char **rdrname_p)
-{
-  int rc = 0;
-  libusb_device_handle *idev = NULL;
-  int dev_fd = -1;
-  char *rid = NULL;
-  unsigned char *ifcdesc_extra = NULL;
+#define MAX_DEVICE 4 /* See MAX_READER in apdu.c.  */
+
+struct ccid_dev_table {
+  int n;                        /* Index to ccid_usb_dev_list */
+  int interface_number;
+  int setting_number;
+  unsigned char *ifcdesc_extra;
+  int ep_bulk_out;
+  int ep_bulk_in;
+  int ep_intr;
   size_t ifcdesc_extra_len;
-  int readerno;
-  int ifc_no, ep_bulk_out, ep_bulk_in, ep_intr;
-  struct libusb_device_descriptor desc;
+};
 
-  *handle = NULL;
+static libusb_device **ccid_usb_dev_list;
+static struct ccid_dev_table ccid_dev_table[MAX_DEVICE];
+
+gpg_error_t
+ccid_dev_scan (int *idx_max_p, struct ccid_dev_table **t_p)
+{
+  ssize_t n;
+  libusb_device *dev;
+  int i;
+  int ifc_no;
+  int set_no;
+  int idx = 0;
+  int err = 0;
+
+  *idx_max_p = 0;
+  *t_p = NULL;
 
   if (!initialized_usb)
     {
-      libusb_init (NULL);
+      int rc;
+      if ((rc = libusb_init (NULL)))
+        {
+          DEBUGOUT_1 ("usb_init failed: %s.\n", libusb_error_name (rc));
+          return gpg_error (GPG_ERR_ENODEV);
+        }
       initialized_usb = 1;
     }
 
-  /* See whether we want to use the reader ID string or a reader
-     number. A readerno of -1 indicates that the reader ID string is
-     to be used. */
-  if (readerid && strchr (readerid, ':'))
-    readerno = -1; /* We want to use the readerid.  */
-  else if (readerid)
+  n = libusb_get_device_list (NULL, &ccid_usb_dev_list);
+  for (i = 0; i < n; i++)
     {
-      readerno = atoi (readerid);
-      if (readerno < 0)
+      struct libusb_config_descriptor *config;
+      struct libusb_device_descriptor desc;
+
+      dev = ccid_usb_dev_list[i];
+
+      if (libusb_get_device_descriptor (dev, &desc))
+        continue;
+
+      if (libusb_get_active_config_descriptor (dev, &config))
+        continue;
+
+      for (ifc_no=0; ifc_no < config->bNumInterfaces; ifc_no++)
+        for (set_no=0; set_no < config->interface[ifc_no].num_altsetting;
+             set_no++)
+          {
+            const struct libusb_interface_descriptor *ifcdesc;
+
+            ifcdesc = &config->interface[ifc_no].altsetting[set_no];
+            /* The second condition is for older SCM SPR 532 who did
+               not know about the assigned CCID class.  The third
+               condition does the same for a Cherry SmartTerminal
+               ST-2000.  Instead of trying to interpret the strings
+               we simply check the product ID. */
+            if (ifcdesc && ifcdesc->extra
+                && ((ifcdesc->bInterfaceClass == 11
+                     && ifcdesc->bInterfaceSubClass == 0
+                     && ifcdesc->bInterfaceProtocol == 0)
+                    || (ifcdesc->bInterfaceClass == 255
+                        && desc.idVendor == VENDOR_SCM
+                        && desc.idProduct == SCM_SPR532)
+                    || (ifcdesc->bInterfaceClass == 255
+                        && desc.idVendor == VENDOR_CHERRY
+                        && desc.idProduct == CHERRY_ST2000)))
+              {
+                /* Found a reader.  */
+                unsigned char *ifcdesc_extra;
+
+                ifcdesc_extra = malloc (ifcdesc->extra_length);
+                if (!ifcdesc_extra)
+                  {
+                    err = gpg_error_from_syserror ();
+                    libusb_free_config_descriptor (config);
+                    goto scan_finish;
+                  }
+                memcpy (ifcdesc_extra, ifcdesc->extra, ifcdesc->extra_length);
+
+                ccid_dev_table[idx].n = i;
+                ccid_dev_table[idx].interface_number = ifc_no;
+                ccid_dev_table[idx].setting_number = set_no;
+                ccid_dev_table[idx].ifcdesc_extra = ifcdesc_extra;
+                ccid_dev_table[idx].ifcdesc_extra_len = ifcdesc->extra_length;
+                ccid_dev_table[idx].ep_bulk_out = find_endpoint (ifcdesc, 0);
+                ccid_dev_table[idx].ep_bulk_in = find_endpoint (ifcdesc, 1);
+                ccid_dev_table[idx].ep_intr = find_endpoint (ifcdesc, 2);
+
+                idx++;
+                if (idx >= MAX_DEVICE)
+                  {
+                    libusb_free_config_descriptor (config);
+                    err = 0;
+                    goto scan_finish;
+                  }
+              }
+          }
+
+      libusb_free_config_descriptor (config);
+    }
+
+ scan_finish:
+
+  if (err)
+    {
+      for (i = 0; i < idx; i++)
         {
-          DEBUGOUT ("no CCID readers found\n");
-          rc = CCID_DRIVER_ERR_NO_READER;
-          goto leave;
+          free (ccid_dev_table[idx].ifcdesc_extra);
+          ccid_dev_table[idx].n = 0;
+          ccid_dev_table[idx].interface_number = 0;
+          ccid_dev_table[idx].setting_number = 0;
+          ccid_dev_table[idx].ifcdesc_extra = NULL;
+          ccid_dev_table[idx].ifcdesc_extra_len = 0;
+          ccid_dev_table[idx].ep_bulk_out = 0;
+          ccid_dev_table[idx].ep_bulk_in = 0;
+          ccid_dev_table[idx].ep_intr = 0;
         }
+      libusb_free_device_list (ccid_usb_dev_list, 1);
+      ccid_usb_dev_list = NULL;
     }
   else
-    readerno = 0;  /* Default. */
-
-  if (scan_or_find_devices (readerno, readerid, &rid, &desc,
-                            &ifcdesc_extra, &ifcdesc_extra_len,
-                            &ifc_no, &ep_bulk_out, &ep_bulk_in, &ep_intr,
-                            &idev, &dev_fd) )
     {
-      if (readerno == -1)
-        DEBUGOUT_1 ("no CCID reader with ID %s\n", readerid );
+      *idx_max_p = idx;
+      if (idx)
+        *t_p = ccid_dev_table;
       else
-        DEBUGOUT_1 ("no CCID reader with number %d\n", readerno );
-      rc = CCID_DRIVER_ERR_NO_READER;
-      goto leave;
+        *t_p = NULL;
     }
 
-  /* Okay, this is a CCID reader. */
-  *handle = calloc (1, sizeof **handle);
-  if (!*handle)
+  return err;
+}
+
+void
+ccid_dev_scan_finish (struct ccid_dev_table *tbl, int max)
+{
+  int i;
+
+  for (i = 0; i < max; i++)
     {
-      DEBUGOUT ("out of memory\n");
-      rc = CCID_DRIVER_ERR_OUT_OF_CORE;
-      goto leave;
+      free (tbl[i].ifcdesc_extra);
+      tbl[i].n = 0;
+      tbl[i].interface_number = 0;
+      tbl[i].setting_number = 0;
+      tbl[i].ifcdesc_extra = NULL;
+      tbl[i].ifcdesc_extra_len = 0;
+      tbl[i].ep_bulk_out = 0;
+      tbl[i].ep_bulk_in = 0;
+      tbl[i].ep_intr = 0;
     }
-  (*handle)->rid = rid;
-  if (idev) /* Regular USB transport. */
+  libusb_free_device_list (ccid_usb_dev_list, 1);
+  ccid_usb_dev_list = NULL;
+}
+
+unsigned int
+ccid_get_BAI (int idx, struct ccid_dev_table *tbl)
+{
+  int n;
+  int bus, addr, intf;
+  unsigned int bai;
+  libusb_device *dev;
+
+  n = tbl[idx].n;
+  dev = ccid_usb_dev_list[n];
+
+  bus = libusb_get_bus_number (dev);
+  addr = libusb_get_device_address (dev);
+  intf = tbl[idx].interface_number;
+  bai = (bus << 16) | (addr << 8) | intf;
+
+  return bai;
+}
+
+int
+ccid_compare_BAI (ccid_driver_t handle, unsigned int bai)
+{
+  return handle->bai == bai;
+}
+
+
+static void
+intr_cb (struct libusb_transfer *transfer)
+{
+  ccid_driver_t handle = transfer->user_data;
+
+  DEBUGOUT_1 ("CCID: interrupt callback %d\n", transfer->status);
+
+  if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT
+      || transfer->status == LIBUSB_TRANSFER_NO_DEVICE)
     {
-      (*handle)->idev = idev;
-      (*handle)->dev_fd = -1;
-      (*handle)->id_vendor = desc.idVendor;
-      (*handle)->id_product = desc.idProduct;
-      (*handle)->bcd_device = desc.bcdDevice;
-      (*handle)->ifc_no = ifc_no;
-      (*handle)->ep_bulk_out = ep_bulk_out;
-      (*handle)->ep_bulk_in = ep_bulk_in;
-      (*handle)->ep_intr = ep_intr;
+      int err;
+
+    submit_again:
+      /* Submit the URB again to keep watching the INTERRUPT transfer.  */
+      err = libusb_submit_transfer (transfer);
+      if (err == LIBUSB_ERROR_NO_DEVICE)
+        goto device_removed;
+
+      DEBUGOUT_1 ("CCID submit transfer again %d\n", err);
     }
-  else if (dev_fd != -1) /* Device transport. */
+  else if (transfer->status == LIBUSB_TRANSFER_COMPLETED)
     {
-      (*handle)->idev = NULL;
-      (*handle)->dev_fd = dev_fd;
-      (*handle)->id_vendor = 0;  /* Magic vendor for special transport. */
-      (*handle)->id_product = ifc_no; /* Transport type */
-      prepare_special_transport (*handle);
+      if (transfer->actual_length == 2
+          && transfer->buffer[0] == 0x50
+          && (transfer->buffer[1] & 1) == 0)
+        {
+          DEBUGOUT ("CCID: card removed\n");
+          handle->powered_off = 1;
+          scd_kick_the_loop ();
+        }
+      else
+        {
+          /* Event other than card removal.  */
+          goto submit_again;
+        }
     }
+  else if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
+    handle->powered_off = 1;
   else
     {
-      assert (!"no transport"); /* Bug. */
+    device_removed:
+      DEBUGOUT ("CCID: device removed\n");
+      handle->powered_off = 1;
+      scd_kick_the_loop ();
     }
+}
 
-  DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n",  readerno, rid );
+static void
+ccid_setup_intr  (ccid_driver_t handle)
+{
+  struct libusb_transfer *transfer;
+  int err;
 
-  if (idev)
+  transfer = libusb_alloc_transfer (0);
+  handle->transfer = transfer;
+  libusb_fill_interrupt_transfer (transfer, handle->idev, handle->ep_intr,
+                                  handle->intr_buf, sizeof (handle->intr_buf),
+                                  intr_cb, handle, 0);
+  err = libusb_submit_transfer (transfer);
+  DEBUGOUT_2 ("CCID submit transfer (%x): %d", handle->ep_intr, err);
+}
+
+
+static void *
+ccid_usb_thread (void *arg)
+{
+  libusb_context *ctx = arg;
+
+  while (ccid_usb_thread_is_alive)
     {
-      if (parse_ccid_descriptor (*handle, ifcdesc_extra, ifcdesc_extra_len))
+#ifdef USE_NPTH
+      npth_unprotect ();
+#endif
+      libusb_handle_events_completed (ctx, NULL);
+#ifdef USE_NPTH
+      npth_protect ();
+#endif
+    }
+
+  return NULL;
+}
+
+
+static int
+ccid_open_usb_reader (const char *spec_reader_name,
+                      int idx, struct ccid_dev_table *ccid_table,
+                      ccid_driver_t *handle, char **rdrname_p)
+{
+  libusb_device *dev;
+  libusb_device_handle *idev = NULL;
+  char *rid = NULL;
+  int rc = 0;
+  int ifc_no, set_no;
+  struct libusb_device_descriptor desc;
+  int n;
+  int bus, addr;
+  unsigned int bai;
+
+  n = ccid_table[idx].n;
+  ifc_no = ccid_table[idx].interface_number;
+  set_no = ccid_table[idx].setting_number;
+
+  dev = ccid_usb_dev_list[n];
+  bus = libusb_get_bus_number (dev);
+  addr = libusb_get_device_address (dev);
+  bai = (bus << 16) | (addr << 8) | ifc_no;
+
+  rc = libusb_open (dev, &idev);
+  if (rc)
+    {
+      DEBUGOUT_1 ("usb_open failed: %s\n", libusb_error_name (rc));
+      free (*handle);
+      *handle = NULL;
+      return rc;
+    }
+
+  if (ccid_usb_thread_is_alive++ == 0)
+    {
+      npth_t thread;
+      npth_attr_t tattr;
+      int err;
+
+      err = npth_attr_init (&tattr);
+      if (err)
         {
-          DEBUGOUT ("device not supported\n");
-          rc = CCID_DRIVER_ERR_NO_READER;
-          goto leave;
+          DEBUGOUT_1 ("npth_attr_init failed: %s\n", strerror (err));
+          free (*handle);
+          *handle = NULL;
+          return err;
+        }
+
+      npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
+      err = npth_create (&thread, &tattr, ccid_usb_thread, NULL);
+      if (err)
+        {
+          DEBUGOUT_1 ("npth_create failed: %s\n", strerror (err));
+          free (*handle);
+          *handle = NULL;
+          return err;
         }
 
-      rc = libusb_claim_interface (idev, ifc_no);
-      if (rc < 0)
+      npth_attr_destroy (&tattr);
+    }
+
+  rc = libusb_get_device_descriptor (dev, &desc);
+  if (rc)
+    {
+      DEBUGOUT ("get_device_descripor failed\n");
+      goto leave;
+    }
+
+  rid = make_reader_id (idev, desc.idVendor, desc.idProduct,
+                        desc.iSerialNumber);
+
+  /* Check to see if reader name matches the spec.  */
+  if (spec_reader_name
+      && strncmp (rid, spec_reader_name, strlen (spec_reader_name)))
+    {
+      DEBUGOUT ("device not matched\n");
+      rc = CCID_DRIVER_ERR_NO_READER;
+      goto leave;
+    }
+
+  (*handle)->id_vendor = desc.idVendor;
+  (*handle)->id_product = desc.idProduct;
+  (*handle)->idev = idev;
+  (*handle)->bai = bai;
+  (*handle)->ifc_no = ifc_no;
+  (*handle)->ep_bulk_out = ccid_table[idx].ep_bulk_out;
+  (*handle)->ep_bulk_in = ccid_table[idx].ep_bulk_in;
+  (*handle)->ep_intr = ccid_table[idx].ep_intr;
+
+  DEBUGOUT_2 ("using CCID reader %d (ID=%s)\n", idx, rid);
+
+  if (parse_ccid_descriptor (*handle, desc.bcdDevice,
+                             ccid_table[idx].ifcdesc_extra,
+                             ccid_table[idx].ifcdesc_extra_len))
+    {
+      DEBUGOUT ("device not supported\n");
+      rc = CCID_DRIVER_ERR_NO_READER;
+      goto leave;
+    }
+
+  rc = libusb_claim_interface (idev, ifc_no);
+  if (rc)
+    {
+      DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
+      rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
+      goto leave;
+    }
+
+  if (set_no != 0)
+    {
+      rc = libusb_set_interface_alt_setting (idev, ifc_no, set_no);
+      if (rc)
         {
-          DEBUGOUT_1 ("usb_claim_interface failed: %d\n", rc);
+          DEBUGOUT_1 ("usb_set_interface_alt_setting failed: %d\n", rc);
           rc = CCID_DRIVER_ERR_CARD_IO_ERROR;
           goto leave;
         }
@@ -1657,24 +1665,72 @@ ccid_open_reader (ccid_driver_t *handle, const char *readerid,
   rc = ccid_vendor_specific_init (*handle);
 
  leave:
-  free (ifcdesc_extra);
   if (rc)
     {
+      --ccid_usb_thread_is_alive;
       free (rid);
-      if (idev)
-        libusb_close (idev);
-      if (dev_fd != -1)
-        close (dev_fd);
+      libusb_close (idev);
       free (*handle);
       *handle = NULL;
     }
   else
-    if (rdrname_p)
-      *rdrname_p = (*handle)->rid;
+    {
+      if (rdrname_p)
+        *rdrname_p = rid;
+      else
+        free (rid);
+    }
 
   return rc;
 }
 
+/* Open the reader with the internal number READERNO and return a
+   pointer to be used as handle in HANDLE.  Returns 0 on success. */
+int
+ccid_open_reader (const char *spec_reader_name, int idx,
+                  struct ccid_dev_table *ccid_table,
+                  ccid_driver_t *handle, char **rdrname_p)
+{
+  *handle = calloc (1, sizeof **handle);
+  if (!*handle)
+    {
+      DEBUGOUT ("out of memory\n");
+      return CCID_DRIVER_ERR_OUT_OF_CORE;
+    }
+
+  return ccid_open_usb_reader (spec_reader_name, idx, ccid_table,
+                               handle, rdrname_p);
+}
+
+
+int
+ccid_require_get_status (ccid_driver_t handle)
+{
+  /* When a card reader supports interrupt transfer to check the
+     status of card, it is possible to submit only an interrupt
+     transfer, and no check is required by application layer.  USB can
+     detect removal of a card and can detect removal of a reader.
+  */
+  if (handle->ep_intr >= 0)
+    return 0;
+
+  /* Libusb actually detects the removal of USB device in use.
+     However, there is no good API to handle the removal (yet),
+     cleanly and with good portability.
+
+     There is libusb_set_pollfd_notifiers function, but it doesn't
+     offer libusb_device_handle* data to its callback.  So, when it
+     watches multiple devices, there is no way to know which device is
+     removed.
+
+     Once, we will have a good programming interface of libusb, we can
+     list tokens (with no interrupt transfer support, but always with
+     card inserted) here to return 0, so that scdaemon can submit
+     minimum packet on wire.
+  */
+  return 1;
+}
+
 
 static void
 do_close_reader (ccid_driver_t handle)
@@ -1699,19 +1755,36 @@ do_close_reader (ccid_driver_t handle)
       if (!rc)
         bulk_in (handle, msg, sizeof msg, &msglen, RDR_to_PC_SlotStatus,
                  seqno, 2000, 0);
-      handle->powered_off = 1;
     }
-  if (handle->idev)
-    {
-      libusb_release_interface (handle->idev, handle->ifc_no);
-      libusb_close (handle->idev);
-      handle->idev = NULL;
-    }
-  if (handle->dev_fd != -1)
+
+  if (handle->transfer)
     {
-      close (handle->dev_fd);
-      handle->dev_fd = -1;
+      if (!handle->powered_off)
+        {
+          DEBUGOUT ("libusb_cancel_transfer\n");
+
+          rc = libusb_cancel_transfer (handle->transfer);
+          if (rc != LIBUSB_ERROR_NOT_FOUND)
+            while (!handle->powered_off)
+              {
+                DEBUGOUT ("libusb_handle_events_completed\n");
+#ifdef USE_NPTH
+                npth_unprotect ();
+#endif
+                libusb_handle_events_completed (NULL, &handle->powered_off);
+#ifdef USE_NPTH
+                npth_protect ();
+#endif
+              }
+        }
+
+      libusb_free_transfer (handle->transfer);
+      handle->transfer = NULL;
     }
+  libusb_release_interface (handle->idev, handle->ifc_no);
+  --ccid_usb_thread_is_alive;
+  libusb_close (handle->idev);
+  handle->idev = NULL;
 }
 
 
@@ -1720,7 +1793,7 @@ ccid_set_progress_cb (ccid_driver_t handle,
                       void (*cb)(void *, const char *, int, int, int),
                       void *cb_arg)
 {
-  if (!handle || !handle->rid)
+  if (!handle)
     return CCID_DRIVER_ERR_INV_VALUE;
 
   handle->progress_cb = cb;
@@ -1733,11 +1806,10 @@ ccid_set_progress_cb (ccid_driver_t handle,
 int
 ccid_close_reader (ccid_driver_t handle)
 {
-  if (!handle || (!handle->idev && handle->dev_fd == -1))
+  if (!handle)
     return 0;
 
   do_close_reader (handle);
-  free (handle->rid);
   free (handle);
   return 0;
 }
@@ -1752,31 +1824,6 @@ ccid_check_card_presence (ccid_driver_t handle)
 }
 
 
-/* Write NBYTES of BUF to file descriptor FD. */
-static int
-writen (int fd, const void *buf, size_t nbytes)
-{
-  size_t nleft = nbytes;
-  int nwritten;
-
-  while (nleft > 0)
-    {
-      nwritten = write (fd, buf, nleft);
-      if (nwritten < 0)
-        {
-          if (errno == EINTR)
-            nwritten = 0;
-          else
-            return -1;
-        }
-      nleft -= nwritten;
-      buf = (const char*)buf + nwritten;
-    }
-
-  return 0;
-}
-
-
 /* Write a MSG of length MSGLEN to the designated bulk out endpoint.
    Returns 0 on success. */
 static int
@@ -1784,6 +1831,7 @@ bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
           int no_debug)
 {
   int rc;
+  int transferred;
 
   /* No need to continue and clutter the log with USB write error
      messages after we got the first ENODEV.  */
@@ -1842,36 +1890,29 @@ bulk_out (ccid_driver_t handle, unsigned char *msg, size_t msglen,
         }
     }
 
-  if (handle->idev)
-    {
-      int transferred;
-
-      rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
-                                 (char*)msg, msglen, &transferred,
-                                 5000 /* ms timeout */);
-      if (rc == 0 && transferred == msglen)
-        return 0;
+#ifdef USE_NPTH
+  npth_unprotect ();
+#endif
+  rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
+                             (char*)msg, msglen, &transferred,
+                             5000 /* ms timeout */);
+#ifdef USE_NPTH
+  npth_protect ();
+#endif
+  if (rc == 0 && transferred == msglen)
+    return 0;
 
-      if (rc < 0)
+  if (rc)
+    {
+      DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
+      if (rc == LIBUSB_ERROR_NO_DEVICE)
         {
-          DEBUGOUT_1 ("usb_bulk_write error: %s\n", libusb_error_name (rc));
-          if (rc == LIBUSB_ERROR_NO_DEVICE)
-            {
-              handle->enodev_seen = 1;
-              return CCID_DRIVER_ERR_NO_READER;
-            }
+          handle->enodev_seen = 1;
+          return CCID_DRIVER_ERR_NO_READER;
         }
     }
-  else
-    {
-      rc = writen (handle->dev_fd, msg, msglen);
-      if (!rc)
-        return 0;
-      DEBUGOUT_2 ("writen to %d failed: %s\n",
-                  handle->dev_fd, strerror (errno));
 
-    }
-  return CCID_DRIVER_ERR_CARD_IO_ERROR;
+  return 0;
 }
 
 
@@ -1889,49 +1930,34 @@ bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
 {
   int rc;
   int msglen;
-  int eagain_retries = 0;
 
   /* Fixme: The next line for the current Valgrind without support
      for USB IOCTLs. */
   memset (buffer, 0, length);
  retry:
-  if (handle->idev)
-    {
-      rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
-                                 (char*)buffer, length, &msglen, timeout);
-      if (rc < 0)
-        {
-          DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
-          if (rc == LIBUSB_ERROR_NO_DEVICE)
-            {
-              handle->enodev_seen = 1;
-              return CCID_DRIVER_ERR_NO_READER;
-            }
 
-          return CCID_DRIVER_ERR_CARD_IO_ERROR;
-        }
-      if (msglen < 0)
-        return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
-      *nread = msglen;
-    }
-  else
+#ifdef USE_NPTH
+  npth_unprotect ();
+#endif
+  rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
+                             (char*)buffer, length, &msglen, timeout);
+#ifdef USE_NPTH
+  npth_protect ();
+#endif
+  if (rc)
     {
-      rc = read (handle->dev_fd, buffer, length);
-      if (rc < 0)
+      DEBUGOUT_1 ("usb_bulk_read error: %s\n", libusb_error_name (rc));
+      if (rc == LIBUSB_ERROR_NO_DEVICE)
         {
-          rc = errno;
-          DEBUGOUT_2 ("read from %d failed: %s\n",
-                      handle->dev_fd, strerror (rc));
-          if (rc == EAGAIN && eagain_retries++ < 5)
-            {
-              my_sleep (1);
-              goto retry;
-            }
-          return CCID_DRIVER_ERR_CARD_IO_ERROR;
+          handle->enodev_seen = 1;
+          return CCID_DRIVER_ERR_NO_READER;
         }
-      *nread = msglen = rc;
+
+      return CCID_DRIVER_ERR_CARD_IO_ERROR;
     }
-  eagain_retries = 0;
+  if (msglen < 0)
+    return CCID_DRIVER_ERR_INV_VALUE;  /* Faulty libusb.  */
+  *nread = msglen;
 
   if (msglen < 10)
     {
@@ -1964,7 +1990,7 @@ bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
       goto retry;
     }
 
-  if (buffer[0] != expected_type)
+  if (buffer[0] != expected_type && buffer[0] != RDR_to_PC_SlotStatus)
     {
       DEBUGOUT_1 ("unexpected bulk-in msg type (%02x)\n", buffer[0]);
       abort_cmd (handle, seqno);
@@ -2004,11 +2030,30 @@ bulk_in (ccid_driver_t handle, unsigned char *buffer, size_t length,
   switch ((buffer[7] & 0x03))
     {
     case 0: /* no error */ break;
-    case 1: return CCID_DRIVER_ERR_CARD_INACTIVE;
-    case 2: return CCID_DRIVER_ERR_NO_CARD;
+    case 1: rc = CCID_DRIVER_ERR_CARD_INACTIVE; break;
+    case 2: rc = CCID_DRIVER_ERR_NO_CARD; break;
     case 3: /* RFU */ break;
     }
-  return 0;
+
+  if (rc)
+    {
+      /*
+       * Communication failure by device side.
+       * Possibly, it was forcibly suspended and resumed.
+       *
+       * Only detect this kind of failure when interrupt transfer is
+       * not supported.  For card reader with interrupt transfer
+       * support removal is detected by intr_cb.
+       */
+      if (handle->ep_intr < 0)
+        {
+          DEBUGOUT ("CCID: card inactive/removed\n");
+          handle->powered_off = 1;
+          scd_kick_the_loop ();
+        }
+    }
+
+  return rc;
 }
 
 
@@ -2022,17 +2067,14 @@ abort_cmd (ccid_driver_t handle, int seqno)
   unsigned char msg[100];
   int msglen;
 
-  if (!handle->idev)
-    {
-      /* I don't know how to send an abort to non-USB devices.  */
-      rc = CCID_DRIVER_ERR_NOT_SUPPORTED;
-    }
-
   seqno &= 0xff;
   DEBUGOUT_1 ("sending abort sequence for seqno %d\n", seqno);
   /* Send the abort command to the control pipe.  Note that we don't
      need to keep track of sent abort commands because there should
      never be another thread using the same slot concurrently.  */
+#ifdef USE_NPTH
+  npth_unprotect ();
+#endif
   rc = libusb_control_transfer (handle->idev,
                                 0x21,/* bmRequestType: host-to-device,
                                         class specific, to interface.  */
@@ -2041,7 +2083,10 @@ abort_cmd (ccid_driver_t handle, int seqno)
                                 handle->ifc_no,
                                 dummybuf, 0,
                                 1000 /* ms timeout */);
-  if (rc < 0)
+#ifdef USE_NPTH
+  npth_protect ();
+#endif
+  if (rc)
     {
       DEBUGOUT_1 ("usb_control_msg error: %s\n", libusb_error_name (rc));
       return CCID_DRIVER_ERR_CARD_IO_ERROR;
@@ -2065,22 +2110,34 @@ abort_cmd (ccid_driver_t handle, int seqno)
       msglen = 10;
       set_msg_len (msg, 0);
 
+#ifdef USE_NPTH
+      npth_unprotect ();
+#endif
       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_out,
                                  (char*)msg, msglen, &transferred,
                                  5000 /* ms timeout */);
+#ifdef USE_NPTH
+      npth_protect ();
+#endif
       if (rc == 0 && transferred == msglen)
         rc = 0;
-      else if (rc < 0)
+      else if (rc)
         DEBUGOUT_1 ("usb_bulk_write error in abort_cmd: %s\n",
                     libusb_error_name (rc));
 
       if (rc)
         return rc;
 
+#ifdef USE_NPTH
+      npth_unprotect ();
+#endif
       rc = libusb_bulk_transfer (handle->idev, handle->ep_bulk_in,
                                  (char*)msg, sizeof msg, &msglen,
                                  5000 /*ms timeout*/);
-      if (rc < 0)
+#ifdef USE_NPTH
+      npth_protect ();
+#endif
+      if (rc)
         {
           DEBUGOUT_1 ("usb_bulk_read error in abort_cmd: %s\n",
                       libusb_error_name (rc));
@@ -2162,7 +2219,8 @@ send_escape_cmd (ccid_driver_t handle,
           else
             {
               memcpy (result, msg, msglen);
-              *resultlen = msglen;
+              if (resultlen)
+                *resultlen = msglen;
               rc = 0;
             }
         }
@@ -2194,18 +2252,13 @@ ccid_poll (ccid_driver_t handle)
   int msglen;
   int i, j;
 
-  if (handle->idev)
-    {
-      rc = libusb_bulk_transfer (handle->idev, handle->ep_intr,
-                                 (char*)msg, sizeof msg, &msglen,
-                                 0 /* ms timeout */ );
-      if (rc == LIBUSB_ERROR_TIMEOUT)
-        return 0;
-    }
-  else
+  rc = libusb_interrupt_transfer (handle->idev, handle->ep_intr,
+                                  (char*)msg, sizeof msg, &msglen,
+                                  0 /* ms timeout */ );
+  if (rc == LIBUSB_ERROR_TIMEOUT)
     return 0;
 
-  if (rc < 0)
+  if (rc)
     {
       DEBUGOUT_1 ("usb_intr_read error: %s\n", libusb_error_name (rc));
       return CCID_DRIVER_ERR_CARD_IO_ERROR;
@@ -2244,7 +2297,7 @@ ccid_poll (ccid_driver_t handle)
 /* Note that this function won't return the error codes NO_CARD or
    CARD_INACTIVE */
 int
-ccid_slot_status (ccid_driver_t handle, int *statusbits)
+ccid_slot_status (ccid_driver_t handle, int *statusbits, int on_wire)
 {
   int rc;
   unsigned char msg[100];
@@ -2252,6 +2305,24 @@ ccid_slot_status (ccid_driver_t handle, int *statusbits)
   unsigned char seqno;
   int retries = 0;
 
+  if (handle->powered_off)
+    return CCID_DRIVER_ERR_NO_READER;
+
+  /* If the card (with its lower-level driver) doesn't require
+     GET_STATUS on wire (because it supports INTERRUPT transfer for
+     status change, or it's a token which has a card always inserted),
+     no need to send on wire.  */
+  if (!on_wire && !ccid_require_get_status (handle))
+    {
+      /* Setup interrupt transfer at the initial call of slot_status
+         with ON_WIRE == 0 */
+      if (handle->transfer == NULL && handle->ep_intr >= 0)
+        ccid_setup_intr (handle);
+
+      *statusbits = 0;
+      return 0;
+    }
+
  retry:
   msg[0] = PC_to_RDR_GetSlotStatus;
   msg[5] = 0; /* slot */
@@ -2274,16 +2345,21 @@ ccid_slot_status (ccid_driver_t handle, int *statusbits)
       if (!retries)
         {
           DEBUGOUT ("USB: CALLING USB_CLEAR_HALT\n");
+#ifdef USE_NPTH
+          npth_unprotect ();
+#endif
           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
           libusb_clear_halt (handle->idev, handle->ep_bulk_out);
+#ifdef USE_NPTH
+          npth_protect ();
+#endif
         }
       else
           DEBUGOUT ("USB: RETRYING bulk_in AGAIN\n");
       retries++;
       goto retry;
     }
-  if (rc && rc != CCID_DRIVER_ERR_NO_CARD
-      && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
+  if (rc && rc != CCID_DRIVER_ERR_NO_CARD && rc != CCID_DRIVER_ERR_CARD_INACTIVE)
     return rc;
   *statusbits = (msg[7] & 3);
 
@@ -2463,12 +2539,20 @@ ccid_get_atr (ccid_driver_t handle,
   };
 
   /* First check whether a card is available.  */
-  rc = ccid_slot_status (handle, &statusbits);
+  rc = ccid_slot_status (handle, &statusbits, 1);
   if (rc)
     return rc;
   if (statusbits == 2)
     return CCID_DRIVER_ERR_NO_CARD;
 
+  /*
+   * In the first invocation of ccid_slot_status, card reader may
+   * return CCID_DRIVER_ERR_CARD_INACTIVE and handle->powered_off may
+   * become 1.  Because inactive card is no problem (we are turning it
+   * ON here), clear the flag.
+   */
+  handle->powered_off = 0;
+
   /* For an inactive and also for an active card, issue the PowerOn
      command to get the ATR.  */
  again:
@@ -2901,6 +2985,7 @@ ccid_transceive (ccid_driver_t handle,
   int retries = 0;
   int resyncing = 0;
   int nad_byte;
+  int wait_more = 0;
 
   if (!nresp)
     nresp = &dummy_nresp;
@@ -2914,11 +2999,10 @@ ccid_transceive (ccid_driver_t handle,
          but the Windows driver does it this way.  Tested using a
          CM6121.  This method works also for the Cherry XX44
          keyboards; however there are problems with the
-         ccid_tranceive_secure which leads to a loss of sync on the
+         ccid_transceive_secure which leads to a loss of sync on the
          CCID level.  If Cherry wants to make their keyboard work
          again, they should hand over some docs. */
-      if ((handle->id_vendor == VENDOR_OMNIKEY
-           || (!handle->idev && handle->id_product == TRANSPORT_CM4040))
+      if ((handle->id_vendor == VENDOR_OMNIKEY)
           && handle->apdu_level < 2
           && is_exlen_apdu (apdu_buf, apdu_buflen))
         via_escape = 1;
@@ -3010,8 +3094,8 @@ ccid_transceive (ccid_driver_t handle,
 
       msg = recv_buffer;
       rc = bulk_in (handle, msg, sizeof recv_buffer, &msglen,
-                    via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock,
-                    seqno, CCID_CMD_TIMEOUT, 0);
+                    via_escape? RDR_to_PC_Escape : RDR_to_PC_DataBlock, seqno,
+                    wait_more? CCID_CMD_TIMEOUT_LONGER: CCID_CMD_TIMEOUT, 0);
       if (rc)
         return rc;
 
@@ -3021,7 +3105,13 @@ ccid_transceive (ccid_driver_t handle,
 
       if (tpdulen < 4)
         {
+#ifdef USE_NPTH
+          npth_unprotect ();
+#endif
           libusb_clear_halt (handle->idev, handle->ep_bulk_in);
+#ifdef USE_NPTH
+          npth_protect ();
+#endif
           return CCID_DRIVER_ERR_ABORTED;
         }
 
@@ -3179,6 +3269,11 @@ ccid_transceive (ccid_driver_t handle,
             {
               /* Wait time extension request. */
               unsigned char bwi = tpdu[3];
+
+              /* Check if it's unsual value which can't be expressed in ATR.  */
+              if (bwi > 15)
+                wait_more = 1;
+
               msg = send_buffer;
               tpdu = msg + hdrlen;
               tpdu[0] = nad_byte;
@@ -3455,7 +3550,13 @@ ccid_transceive_secure (ccid_driver_t handle,
 
   if (tpdulen < 4)
     {
+#ifdef USE_NPTH
+      npth_unprotect ();
+#endif
       libusb_clear_halt (handle->idev, handle->ep_bulk_in);
+#ifdef USE_NPTH
+      npth_protect ();
+#endif
       return CCID_DRIVER_ERR_ABORTED;
     }
   if (debug_level > 1)
@@ -3493,9 +3594,7 @@ ccid_transceive_secure (ccid_driver_t handle,
             }
 
           memcpy (resp, p, n);
-          resp += n;
           *nresp += n;
-          maxresplen -= n;
         }
 
       if (!(tpdu[1] & 0x20))
@@ -3665,7 +3764,7 @@ main (int argc, char **argv)
   if (!no_poll)
     ccid_poll (ccid);
   fputs ("getting slot status ...\n", stderr);
-  rc = ccid_slot_status (ccid, &slotstat);
+  rc = ccid_slot_status (ccid, &slotstat, 1);
   if (rc)
     {
       print_error (rc);