scd: Fix ecc_oid.
[gnupg.git] / scd / command.c
index 46e0e42..1cc580a 100644 (file)
@@ -1,6 +1,6 @@
 /* command.c - SCdaemon command handler
  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
- *               2007, 2008, 2009  Free Software Foundation, Inc.
+ *               2007, 2008, 2009, 2011  Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <ctype.h>
 #include <unistd.h>
 #include <signal.h>
-#ifdef USE_GNU_PTH
-# include <pth.h>
+#ifdef USE_NPTH
+# include <npth.h>
 #endif
 
 #include "scdaemon.h"
 #include <assuan.h>
 #include <ksba.h>
 #include "app-common.h"
+#include "iso7816.h"
 #include "apdu.h" /* Required for apdu_*_reader (). */
+#include "atr.h"
 #include "exechelp.h"
 #ifdef HAVE_LIBUSB
 #include "ccid-driver.h"
 #endif
+#include "asshelp.h"
 
 /* Maximum length allowed as a PIN; used for INQUIRE NEEDPIN */
 #define MAXLEN_PIN 100
@@ -46,6 +49,9 @@
 /* Maximum allowed size of key data as used in inquiries. */
 #define MAXLEN_KEYDATA 4096
 
+/* Maximum allowed total data size for SETDATA.  */
+#define MAXLEN_SETDATA 4096
+
 /* Maximum allowed size of certificate data as used in inquiries. */
 #define MAXLEN_CERTDATA 16384
 
           int _r = (r);                                     \
           if (gpg_err_code (_r) == GPG_ERR_CARD_NOT_PRESENT \
               || gpg_err_code (_r) == GPG_ERR_CARD_REMOVED  \
+              || gpg_err_code (_r) == GPG_ERR_CARD_RESET    \
               || gpg_err_code (_r) == GPG_ERR_ENODEV )      \
-            update_card_removed ((c)->reader_slot, 1);      \
+            update_card_removed ((c)->server_local->vreader_idx, 1);      \
        } while (0)
 
-#define IS_LOCKED(c)                                                     \
-     (locked_session && locked_session != (c)->server_local              \
-      && (c)->reader_slot != -1 && locked_session->ctrl_backlink         \
-      && (c)->reader_slot == locked_session->ctrl_backlink->reader_slot)
+#define IS_LOCKED(c)                                                    \
+  (locked_session                                                       \
+   && locked_session != (c)->server_local                               \
+   && (c)->server_local->vreader_idx != -1                              \
+   && locked_session->ctrl_backlink                                     \
+   && ((c)->server_local->vreader_idx                                   \
+       == locked_session->ctrl_backlink->server_local->vreader_idx))
 
 
-/* This structure is used to keep track of open readers (slots). */
-struct slot_status_s 
+/* This structure is used to keep track of user readers.  To
+   eventually accommodate this structure for RFID cards, where more
+   than one card is used per reader, we name it virtual reader.  */
+struct vreader_s
 {
   int valid;  /* True if the other objects are valid. */
-  int slot;   /* Slot number of the reader or -1 if not open. */
+  int slot;   /* APDU slot number of the reader or -1 if not open. */
 
   int reset_failed; /* A reset failed. */
 
   int any;    /* Flag indicating whether any status check has been
                  done.  This is set once to indicate that the status
                  tracking for the slot has been initialized.  */
-  unsigned int status;  /* Last status of the slot. */
-  unsigned int changed; /* Last change counter of the slot. */
+  unsigned int status;  /* Last status of the reader. */
+  unsigned int changed; /* Last change counter of the reader. */
 };
 
 
 /* Data used to associate an Assuan context with local server data.
    This object describes the local properties of one session.  */
-struct server_local_s 
+struct server_local_s
 {
   /* We keep a list of all active sessions with the anchor at
      SESSION_LIST (see below).  This field is used for linking. */
-  struct server_local_s *next_session; 
+  struct server_local_s *next_session;
 
   /* This object is usually assigned to a CTRL object (which is
      globally visible).  While enumerating all sessions we sometimes
@@ -108,10 +120,13 @@ struct server_local_s
 #else
   int event_signal;             /* Or 0 if not used. */
 #endif
-  
+
+  /* Index into the vreader table (command.c) or -1 if not open. */
+  int vreader_idx;
+
   /* True if the card has been removed and a reset is required to
      continue operation. */
-  int card_removed;        
+  int card_removed;
 
   /* Flag indicating that the application context needs to be released
      at the next opportunity.  */
@@ -122,15 +137,13 @@ struct server_local_s
 
   /* If set to true we will be terminate ourself at the end of the
      this session.  */
-  int stopme;  
+  int stopme;
 
 };
 
 
-/* The table with information on all used slots.  FIXME: This is a
-   different slot number than the one used by the APDU layer, and
-   should be renamed.  */
-static struct slot_status_s slot_table[10];
+/* The table with information on all used virtual readers.  */
+static struct vreader_s vreader_table[10];
 
 
 /* To keep track of all running sessions, we link all active server
@@ -143,7 +156,7 @@ static struct server_local_s *locked_session;
 
 /* While doing a reset we need to make sure that the ticker does not
    call scd_update_reader_status_file while we are using it. */
-static pth_mutex_t status_file_update_lock;
+static npth_mutex_t status_file_update_lock;
 
 \f
 /*-- Local prototypes --*/
@@ -160,35 +173,52 @@ void
 initialize_module_command (void)
 {
   static int initialized;
+  int err;
 
   if (!initialized)
     {
-      if (pth_mutex_init (&status_file_update_lock))
+      err = npth_mutex_init (&status_file_update_lock, NULL);
+      if (!err)
         initialized = 1;
     }
 }
 
 
-/* Update the CARD_REMOVED element of all sessions using the reader
-   given by SLOT to VALUE.  */
+/* Helper to return the slot number for a given virtual reader index
+   VRDR.  In case on an error -1 is returned.  */
+static int
+vreader_slot (int vrdr)
+{
+  if (vrdr == -1 || !(vrdr >= 0 && vrdr < DIM(vreader_table)))
+    return -1;
+  if (!vreader_table [vrdr].valid)
+    return -1;
+  return vreader_table[vrdr].slot;
+}
+
+
+/* Update the CARD_REMOVED element of all sessions using the virtual
+   reader given by VRDR to VALUE.  */
 static void
-update_card_removed (int slot, int value)
+update_card_removed (int vrdr, int value)
 {
   struct server_local_s *sl;
 
+  if (vrdr == -1)
+    return;
+
   for (sl=session_list; sl; sl = sl->next_session)
     if (sl->ctrl_backlink
-        && sl->ctrl_backlink->reader_slot == slot)
+        && sl->ctrl_backlink->server_local->vreader_idx == vrdr)
       {
         sl->card_removed = value;
       }
   /* Let the card application layer know about the removal.  */
   if (value)
-    application_notify_card_reset (slot);
+    application_notify_card_reset (vreader_slot (vrdr));
 }
 
 
-
 /* Check whether the option NAME appears in LINE.  Returns 1 or 0. */
 static int
 has_option (const char *line, const char *name)
@@ -252,7 +282,7 @@ hex_to_buffer (const char *string, size_t *r_length)
     return NULL;
   for (s=string, n=0; *s; s++)
     {
-      if (spacep (s) || *s == ':') 
+      if (spacep (s) || *s == ':')
         continue;
       if (hexdigitp (s) && hexdigitp (s+1))
         {
@@ -274,9 +304,11 @@ hex_to_buffer (const char *string, size_t *r_length)
 static void
 do_reset (ctrl_t ctrl, int send_reset)
 {
-  int slot = ctrl->reader_slot;
+  int vrdr = ctrl->server_local->vreader_idx;
+  int slot;
+  int err;
 
-  if (!(slot == -1 || (slot >= 0 && slot < DIM(slot_table))))
+  if (!(vrdr == -1 || (vrdr >= 0 && vrdr < DIM(vreader_table))))
     BUG ();
 
   /* If there is an active application, release it.  Tell all other
@@ -289,10 +321,10 @@ do_reset (ctrl_t ctrl, int send_reset)
       if (send_reset)
         {
           struct server_local_s *sl;
-          
+
           for (sl=session_list; sl; sl = sl->next_session)
             if (sl->ctrl_backlink
-                && sl->ctrl_backlink->reader_slot == slot)
+                && sl->ctrl_backlink->server_local->vreader_idx == vrdr)
               {
                 sl->app_ctx_marked_for_release = 1;
               }
@@ -301,13 +333,22 @@ do_reset (ctrl_t ctrl, int send_reset)
 
   /* If we want a real reset for the card, send the reset APDU and
      tell the application layer about it.  */
+  slot = vreader_slot (vrdr);
   if (slot != -1 && send_reset && !IS_LOCKED (ctrl) )
     {
-      if (apdu_reset (slot)) 
+      application_notify_card_reset (slot);
+      switch (apdu_reset (slot))
         {
-          slot_table[slot].reset_failed = 1;
+        case 0:
+          break;
+        case SW_HOST_NO_CARD:
+        case SW_HOST_CARD_INACTIVE:
+          break;
+        default:
+         apdu_close_reader (slot);
+          vreader_table[vrdr].slot = slot = -1;
+          break;
         }
-      application_notify_card_reset (slot);
     }
 
   /* If we hold a lock, unlock now. */
@@ -320,28 +361,31 @@ do_reset (ctrl_t ctrl, int send_reset)
   /* Reset the card removed flag for the current reader.  We need to
      take the lock here so that the ticker thread won't concurrently
      try to update the file.  Calling update_reader_status_file is
-     required to get hold of the new status of the card in the slot
+     required to get hold of the new status of the card in the vreader
      table.  */
-  if (!pth_mutex_acquire (&status_file_update_lock, 0, NULL))
+  err = npth_mutex_lock (&status_file_update_lock);
+  if (err)
     {
-      log_error ("failed to acquire status_fle_update lock\n");
-      ctrl->reader_slot = -1;
+      log_error ("failed to acquire status_file_update lock\n");
+      ctrl->server_local->vreader_idx = -1;
       return;
     }
   update_reader_status_file (0);  /* Update slot status table.  */
-  update_card_removed (slot, 0);  /* Clear card_removed flag.  */
-  if (!pth_mutex_release (&status_file_update_lock))
-    log_error ("failed to release status_file_update lock\n");
+  update_card_removed (vrdr, 0);  /* Clear card_removed flag.  */
+  err = npth_mutex_unlock (&status_file_update_lock);
+  if (err)
+    log_error ("failed to release status_file_update lock: %s\n",
+              strerror (err));
 
   /* Do this last, so that the update_card_removed above does its job.  */
-  ctrl->reader_slot = -1;
+  ctrl->server_local->vreader_idx = -1;
 }
 
 \f
 static gpg_error_t
 reset_notify (assuan_context_t ctx, char *line)
 {
-  ctrl_t ctrl = assuan_get_pointer (ctx); 
+  ctrl_t ctrl = assuan_get_pointer (ctx);
 
   (void) line;
 
@@ -374,40 +418,50 @@ option_handler (assuan_context_t ctx, const char *key, const char *value)
 }
 
 
-/* Return the slot of the current reader or open the reader if no
-   other sessions are using a reader.  Note, that we currently support
+/* Return the index of the current reader or open the reader if no
+   other sessions are using that reader.  If it is not possible to
+   open the reader -1 is returned.  Note, that we currently support
    only one reader but most of the code (except for this function)
    should be able to cope with several readers.  */
 static int
-get_reader_slot (void)
+get_current_reader (void)
 {
-  struct slot_status_s *ss;
+  struct vreader_s *vr;
 
-  ss = &slot_table[0]; /* One reader for now. */
+  /* We only support one reader for now.  */
+  vr = &vreader_table[0];
 
-  /* Initialize the item if needed. */
-  if (!ss->valid)
+  /* Initialize the vreader item if not yet done. */
+  if (!vr->valid)
     {
-      ss->slot = -1;
-      ss->valid = 1;
+      vr->slot = -1;
+      vr->valid = 1;
     }
 
   /* Try to open the reader. */
-  if (ss->slot == -1)
-    ss->slot = apdu_open_reader (opt.reader_port);
+  if (vr->slot == -1)
+    {
+      vr->slot = apdu_open_reader (opt.reader_port);
 
-  /* Return the slot_table index.  */
-  return 0;
+      /* If we still don't have a slot, we have no readers.
+        Invalidate for now until a reader is attached. */
+      if (vr->slot == -1)
+       {
+         vr->valid = 0;
+       }
+    }
+
+  /* Return the vreader index or -1.  */
+  return vr->valid ? 0 : -1;
 }
 
-/* If the card has not yet been opened, do it.  Note that this
-   function returns an Assuan error, so don't map the error a second
-   time.  */
+
+/* If the card has not yet been opened, do it.  */
 static gpg_error_t
 open_card (ctrl_t ctrl, const char *apptype)
 {
   gpg_error_t err;
-  int slot;
+  int vrdr;
 
   /* If we ever got a card not present error code, return that.  Only
      the SERIALNO command and a reset are able to clear from that
@@ -432,21 +486,25 @@ open_card (ctrl_t ctrl, const char *apptype)
      need to check that the client didn't requested a specific
      application different from the one in use before we continue. */
   if (ctrl->app_ctx)
-    return check_application_conflict (ctrl, apptype);
+    {
+      return check_application_conflict
+        (ctrl, vreader_slot (ctrl->server_local->vreader_idx), apptype);
+    }
 
-  /* Setup the slot and select the application.  */
-  if (ctrl->reader_slot != -1)
-    slot = ctrl->reader_slot;
+  /* Setup the vreader and select the application.  */
+  if (ctrl->server_local->vreader_idx != -1)
+    vrdr = ctrl->server_local->vreader_idx;
   else
-    slot = get_reader_slot ();
-  ctrl->reader_slot = slot;
-  if (slot == -1)
+    vrdr = get_current_reader ();
+  ctrl->server_local->vreader_idx = vrdr;
+  if (vrdr == -1)
     err = gpg_error (GPG_ERR_CARD);
   else
     {
       /* Fixme: We should move the apdu_connect call to
          select_application.  */
       int sw;
+      int slot = vreader_slot (vrdr);
 
       ctrl->server_local->disconnect_allowed = 0;
       sw = apdu_connect (slot);
@@ -454,6 +512,8 @@ open_card (ctrl_t ctrl, const char *apptype)
         {
           if (sw == SW_HOST_NO_CARD)
             err = gpg_error (GPG_ERR_CARD_NOT_PRESENT);
+          else if (sw == SW_HOST_CARD_INACTIVE)
+            err = gpg_error (GPG_ERR_CARD_RESET);
           else
             err = gpg_error (GPG_ERR_CARD);
        }
@@ -466,35 +526,36 @@ open_card (ctrl_t ctrl, const char *apptype)
 }
 
 
-/* SERIALNO [APPTYPE] 
-
-   Return the serial number of the card using a status reponse.  This
-   function should be used to check for the presence of a card.
-
-   If APPTYPE is given, an application of that type is selected and an
-   error is returned if the application is not supported or available.
-   The default is to auto-select the application using a hardwired
-   preference system.  Note, that a future extension to this function
-   may allow to specify a list and order of applications to try.
-
-   This function is special in that it can be used to reset the card.
-   Most other functions will return an error when a card change has
-   been detected and the use of this function is therefore required.
-
-   Background: We want to keep the client clear of handling card
-   changes between operations; i.e. the client can assume that all
-   operations are done on the same card unless he calls this function.
- */
+static const char hlp_serialno[] =
+  "SERIALNO [<apptype>]\n"
+  "\n"
+  "Return the serial number of the card using a status reponse.  This\n"
+  "function should be used to check for the presence of a card.\n"
+  "\n"
+  "If APPTYPE is given, an application of that type is selected and an\n"
+  "error is returned if the application is not supported or available.\n"
+  "The default is to auto-select the application using a hardwired\n"
+  "preference system.  Note, that a future extension to this function\n"
+  "may allow to specify a list and order of applications to try.\n"
+  "\n"
+  "This function is special in that it can be used to reset the card.\n"
+  "Most other functions will return an error when a card change has\n"
+  "been detected and the use of this function is therefore required.\n"
+  "\n"
+  "Background: We want to keep the client clear of handling card\n"
+  "changes between operations; i.e. the client can assume that all\n"
+  "operations are done on the same card unless he calls this function.";
 static gpg_error_t
 cmd_serialno (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc = 0;
-  char *serial_and_stamp;
   char *serial;
   time_t stamp;
+  int retries = 0;
 
   /* Clear the remove flag so that the open_card is able to reread it.  */
+ retry:
   if (ctrl->server_local->card_removed)
     {
       if ( IS_LOCKED (ctrl) )
@@ -503,95 +564,93 @@ cmd_serialno (assuan_context_t ctx, char *line)
     }
 
   if ((rc = open_card (ctrl, *line? line:NULL)))
-    return rc;
+    {
+      /* In case of an inactive card, retry once.  */
+      if (gpg_err_code (rc) == GPG_ERR_CARD_RESET && retries++ < 1)
+        goto retry;
+      return rc;
+    }
 
   rc = app_get_serial_and_stamp (ctrl->app_ctx, &serial, &stamp);
   if (rc)
     return rc;
 
-  rc = estream_asprintf (&serial_and_stamp, "%s %lu",
-                         serial, (unsigned long)stamp);
+  rc = print_assuan_status (ctx, "SERIALNO", "%s %lu",
+                            serial, (unsigned long)stamp);
   xfree (serial);
-  if (rc < 0)
-    return out_of_core ();
-  rc = 0;
-  assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
-  xfree (serial_and_stamp);
-  return 0;
+  return rc;
 }
 
 
-
-
-/* LEARN [--force] [--keypairinfo]
-
-   Learn all useful information of the currently inserted card.  When
-   used without the force options, the command might do an INQUIRE
-   like this:
-
-      INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>
-
-   The client should just send an "END" if the processing should go on
-   or a "CANCEL" to force the function to terminate with a Cancel
-   error message.  
-
-   With the option --keypairinfo only KEYPARIINFO lstatus lines are
-   returned.
-
-   The response of this command is a list of status lines formatted as
-   this:
-
-     S APPTYPE <apptype>
-
-   This returns the type of the application, currently the strings:
-
-       P15     = PKCS-15 structure used
-       DINSIG  = DIN SIG
-       OPENPGP = OpenPGP card
-       NKS     = NetKey card
-
-   are implemented.  These strings are aliases for the AID
-
-     S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>
-
-   If there is no certificate yet stored on the card a single "X" is
-   returned as the keygrip.  In addition to the keypair info, information
-   about all certificates stored on the card is also returned:
-
-     S CERTINFO <certtype> <hexstring_with_id>
-
-   Where CERTTYPE is a number indicating the type of certificate:
-      0   := Unknown
-      100 := Regular X.509 cert
-      101 := Trusted X.509 cert
-      102 := Useful X.509 cert
-      110 := Root CA cert in a special format (e.g. DINSIG)
-      111 := Root CA cert as standard X509 cert.
-
-   For certain cards, more information will be returned:
-
-     S KEY-FPR <no> <hexstring>
-
-   For OpenPGP cards this returns the stored fingerprints of the
-   keys. This can be used check whether a key is available on the
-   card.  NO may be 1, 2 or 3.
-
-     S CA-FPR <no> <hexstring>
-
-   Similar to above, these are the fingerprints of keys assumed to be
-   ultimately trusted.
-
-     S DISP-NAME <name_of_card_holder>
-
-   The name of the card holder as stored on the card; percent
-   escaping takes place, spaces are encoded as '+'
-
-     S PUBKEY-URL <url>
-
-   The URL to be used for locating the entire public key.
-     
-   Note, that this function may even be used on a locked card.
-*/
+static const char hlp_learn[] =
+  "LEARN [--force] [--keypairinfo]\n"
+  "\n"
+  "Learn all useful information of the currently inserted card.  When\n"
+  "used without the force options, the command might do an INQUIRE\n"
+  "like this:\n"
+  "\n"
+  "   INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>\n"
+  "\n"
+  "The client should just send an \"END\" if the processing should go on\n"
+  "or a \"CANCEL\" to force the function to terminate with a Cancel\n"
+  "error message.\n"
+  "\n"
+  "With the option --keypairinfo only KEYPARIINFO lstatus lines are\n"
+  "returned.\n"
+  "\n"
+  "The response of this command is a list of status lines formatted as\n"
+  "this:\n"
+  "\n"
+  "  S APPTYPE <apptype>\n"
+  "\n"
+  "This returns the type of the application, currently the strings:\n"
+  "\n"
+  "    P15     = PKCS-15 structure used\n"
+  "    DINSIG  = DIN SIG\n"
+  "    OPENPGP = OpenPGP card\n"
+  "    NKS     = NetKey card\n"
+  "\n"
+  "are implemented.  These strings are aliases for the AID\n"
+  "\n"
+  "  S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>\n"
+  "\n"
+  "If there is no certificate yet stored on the card a single 'X' is\n"
+  "returned as the keygrip.  In addition to the keypair info, information\n"
+  "about all certificates stored on the card is also returned:\n"
+  "\n"
+  "  S CERTINFO <certtype> <hexstring_with_id>\n"
+  "\n"
+  "Where CERTTYPE is a number indicating the type of certificate:\n"
+  "   0   := Unknown\n"
+  "   100 := Regular X.509 cert\n"
+  "   101 := Trusted X.509 cert\n"
+  "   102 := Useful X.509 cert\n"
+  "   110 := Root CA cert in a special format (e.g. DINSIG)\n"
+  "   111 := Root CA cert as standard X509 cert.\n"
+  "\n"
+  "For certain cards, more information will be returned:\n"
+  "\n"
+  "  S KEY-FPR <no> <hexstring>\n"
+  "\n"
+  "For OpenPGP cards this returns the stored fingerprints of the\n"
+  "keys. This can be used check whether a key is available on the\n"
+  "card.  NO may be 1, 2 or 3.\n"
+  "\n"
+  "  S CA-FPR <no> <hexstring>\n"
+  "\n"
+  "Similar to above, these are the fingerprints of keys assumed to be\n"
+  "ultimately trusted.\n"
+  "\n"
+  "  S DISP-NAME <name_of_card_holder>\n"
+  "\n"
+  "The name of the card holder as stored on the card; percent\n"
+  "escaping takes place, spaces are encoded as '+'\n"
+  "\n"
+  "  S PUBKEY-URL <url>\n"
+  "\n"
+  "The URL to be used for locating the entire public key.\n"
+  "  \n"
+  "Note, that this function may even be used on a locked card.";
 static gpg_error_t
 cmd_learn (assuan_context_t ctx, char *line)
 {
@@ -608,47 +667,47 @@ cmd_learn (assuan_context_t ctx, char *line)
      knows about this card */
   if (!only_keypairinfo)
     {
-      char *serial_and_stamp;
       char *serial;
       time_t stamp;
-      
+
       rc = app_get_serial_and_stamp (ctrl->app_ctx, &serial, &stamp);
       if (rc)
         return rc;
-      rc = estream_asprintf (&serial_and_stamp, "%s %lu",
-                             serial, (unsigned long)stamp);
-      xfree (serial);
+
+      rc = print_assuan_status (ctx, "SERIALNO", "%s %lu",
+                                serial, (unsigned long)stamp);
       if (rc < 0)
-        return out_of_core ();
-      rc = 0;
-      assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
-      
+        {
+          xfree (serial);
+          return out_of_core ();
+        }
+
       if (!has_option (line, "--force"))
         {
           char *command;
-          
-          rc = estream_asprintf (&command, "KNOWNCARDP %s", serial_and_stamp);
+
+          rc = gpgrt_asprintf (&command, "KNOWNCARDP %s %lu",
+                               serial, (unsigned long)stamp);
           if (rc < 0)
             {
-              xfree (serial_and_stamp);
+              xfree (serial);
               return out_of_core ();
             }
-          rc = 0;
-          rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
+          rc = assuan_inquire (ctx, command, NULL, NULL, 0);
           xfree (command);
           if (rc)
             {
               if (gpg_err_code (rc) != GPG_ERR_ASS_CANCELED)
                 log_error ("inquire KNOWNCARDP failed: %s\n",
                            gpg_strerror (rc));
-              xfree (serial_and_stamp);
-              return rc; 
+              xfree (serial);
+              return rc;
             }
           /* Not canceled, so we have to proceeed.  */
         }
-      xfree (serial_and_stamp);
+      xfree (serial);
     }
-  
+
   /* Let the application print out its collection of useful status
      information. */
   if (!rc)
@@ -660,10 +719,10 @@ cmd_learn (assuan_context_t ctx, char *line)
 
 
 \f
-/* READCERT <hexified_certid>|<keyid>
-
-   Note, that this function may even be used on a locked card.
- */
+static const char hlp_readcert[] =
+  "READCERT <hexified_certid>|<keyid>\n"
+  "\n"
+  "Note, that this function may even be used on a locked card.";
 static gpg_error_t
 cmd_readcert (assuan_context_t ctx, char *line)
 {
@@ -694,13 +753,13 @@ cmd_readcert (assuan_context_t ctx, char *line)
 }
 
 
-/* READKEY <keyid>
-
-   Return the public key for the given cert or key ID as an standard
-   S-Expression.
-
-   Note, that this function may even be used on a locked card.
-  */
+static const char hlp_readkey[] =
+  "READKEY <keyid>\n"
+  "\n"
+  "Return the public key for the given cert or key ID as a standard\n"
+  "S-expression.\n"
+  "\n"
+  "Note, that this function may even be used on a locked card.";
 static gpg_error_t
 cmd_readkey (assuan_context_t ctx, char *line)
 {
@@ -732,7 +791,7 @@ cmd_readkey (assuan_context_t ctx, char *line)
 
   if (gpg_err_code (rc) != GPG_ERR_UNSUPPORTED_OPERATION)
     log_error ("app_readkey failed: %s\n", gpg_strerror (rc));
-  else  
+  else
     {
       rc = app_readcert (ctrl->app_ctx, line, &cert, &ncert);
       if (rc)
@@ -742,13 +801,11 @@ cmd_readkey (assuan_context_t ctx, char *line)
   line = NULL;
   if (rc)
     goto leave;
-      
+
   rc = ksba_cert_new (&kc);
   if (rc)
-    {
-      xfree (cert);
-      goto leave;
-    }
+    goto leave;
+
   rc = ksba_cert_init_from_mem (kc, cert, ncert);
   if (rc)
     {
@@ -777,19 +834,25 @@ cmd_readkey (assuan_context_t ctx, char *line)
 
 
 \f
-
-/* SETDATA <hexstring> 
-
-   The client should use this command to tell us the data he want to
-   sign.  */
+static const char hlp_setdata[] =
+  "SETDATA [--append] <hexstring>\n"
+  "\n"
+  "The client should use this command to tell us the data he want to sign.\n"
+  "With the option --append, the data is appended to the data set by a\n"
+  "previous SETDATA command.";
 static gpg_error_t
 cmd_setdata (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
-  int n;
+  int append;
+  int n, i, off;
   char *p;
   unsigned char *buf;
 
+  append = (ctrl->in_data.value && has_option (line, "--append"));
+
+  line = skip_options (line);
+
   if (locked_session && locked_session != ctrl->server_local)
     return gpg_error (GPG_ERR_LOCKED);
 
@@ -803,21 +866,37 @@ cmd_setdata (assuan_context_t ctx, char *line)
   if ((n&1))
     return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
   n /= 2;
-  buf = xtrymalloc (n);
+  if (append)
+    {
+      if (ctrl->in_data.valuelen + n > MAXLEN_SETDATA)
+        return set_error (GPG_ERR_TOO_LARGE,
+                          "limit on total size of data reached");
+      buf = xtrymalloc (ctrl->in_data.valuelen + n);
+    }
+  else
+    buf = xtrymalloc (n);
   if (!buf)
     return out_of_core ();
 
+  if (append)
+    {
+      memcpy (buf, ctrl->in_data.value, ctrl->in_data.valuelen);
+      off = ctrl->in_data.valuelen;
+    }
+  else
+    off = 0;
+  for (p=line, i=0; i < n; p += 2, i++)
+    buf[off+i] = xtoi_2 (p);
+
   xfree (ctrl->in_data.value);
   ctrl->in_data.value = buf;
-  ctrl->in_data.valuelen = n;
-  for (p=line, n=0; n < ctrl->in_data.valuelen; p += 2, n++)
-    buf[n] = xtoi_2 (p);
+  ctrl->in_data.valuelen = off+n;
   return 0;
 }
 
 
 
-static gpg_error_t 
+static gpg_error_t
 pin_cb (void *opaque, const char *info, char **retstr)
 {
   assuan_context_t ctx = opaque;
@@ -828,23 +907,23 @@ pin_cb (void *opaque, const char *info, char **retstr)
 
   if (!retstr)
     {
-      /* We prompt for keypad entry.  To make sure that the popup has
+      /* We prompt for pinpad entry.  To make sure that the popup has
          been show we use an inquire and not just a status message.
          We ignore any value returned.  */
       if (info)
         {
-          log_debug ("prompting for keypad entry '%s'\n", info);
-          rc = estream_asprintf (&command, "POPUPKEYPADPROMPT %s", info);
+          log_debug ("prompting for pinpad entry '%s'\n", info);
+          rc = gpgrt_asprintf (&command, "POPUPPINPADPROMPT %s", info);
           if (rc < 0)
             return gpg_error (gpg_err_code_from_errno (errno));
-          rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN); 
-          xfree (command);  
+          rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN);
+          xfree (command);
         }
       else
         {
-          log_debug ("dismiss keypad entry prompt\n");
-          rc = assuan_inquire (ctx, "DISMISSKEYPADPROMPT",
-                               &value, &valuelen, MAXLEN_PIN); 
+          log_debug ("dismiss pinpad entry prompt\n");
+          rc = assuan_inquire (ctx, "DISMISSPINPADPROMPT",
+                               &value, &valuelen, MAXLEN_PIN);
         }
       if (!rc)
         xfree (value);
@@ -854,14 +933,14 @@ pin_cb (void *opaque, const char *info, char **retstr)
   *retstr = NULL;
   log_debug ("asking for PIN '%s'\n", info);
 
-  rc = estream_asprintf (&command, "NEEDPIN %s", info);
+  rc = gpgrt_asprintf (&command, "NEEDPIN %s", info);
   if (rc < 0)
     return gpg_error (gpg_err_code_from_errno (errno));
 
   /* Fixme: Write an inquire function which returns the result in
      secure memory and check all further handling of the PIN. */
-  rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN); 
-  xfree (command);  
+  rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN);
+  xfree (command);
   if (rc)
     return rc;
 
@@ -876,11 +955,10 @@ pin_cb (void *opaque, const char *info, char **retstr)
 }
 
 
-/* PKSIGN [--hash=[rmd160|sha{1,224,256,384,512}|md5]] <hexified_id>
-
-   The --hash option is optional; the default is SHA1.
-
- */
+static const char hlp_pksign[] =
+  "PKSIGN [--hash=[rmd160|sha{1,224,256,384,512}|md5]] <hexified_id>\n"
+  "\n"
+  "The --hash option is optional; the default is SHA1.";
 static gpg_error_t
 cmd_pksign (assuan_context_t ctx, char *line)
 {
@@ -906,7 +984,7 @@ cmd_pksign (assuan_context_t ctx, char *line)
   else if (has_option (line, "--hash=md5"))
     hash_algo = GCRY_MD_MD5;
   else if (!strstr (line, "--"))
-    hash_algo = GCRY_MD_SHA1; 
+    hash_algo = GCRY_MD_SHA1;
   else
     return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
 
@@ -924,7 +1002,7 @@ cmd_pksign (assuan_context_t ctx, char *line)
   keyidstr = xtrystrdup (line);
   if (!keyidstr)
     return out_of_core ();
-  
+
   rc = app_sign (ctrl->app_ctx,
                  keyidstr, hash_algo,
                  pin_cb, ctx,
@@ -948,9 +1026,9 @@ cmd_pksign (assuan_context_t ctx, char *line)
   return rc;
 }
 
-/* PKAUTH <hexified_id>
 
- */
+static const char hlp_pkauth[] =
+  "PKAUTH <hexified_id>";
 static gpg_error_t
 cmd_pkauth (assuan_context_t ctx, char *line)
 {
@@ -975,7 +1053,7 @@ cmd_pkauth (assuan_context_t ctx, char *line)
   keyidstr = xtrystrdup (line);
   if (!keyidstr)
     return out_of_core ();
-  
+
   rc = app_auth (ctrl->app_ctx,
                  keyidstr,
                  pin_cb, ctx,
@@ -998,9 +1076,9 @@ cmd_pkauth (assuan_context_t ctx, char *line)
   return rc;
 }
 
-/* PKDECRYPT <hexified_id>
 
- */
+static const char hlp_pkdecrypt[] =
+  "PKDECRYPT <hexified_id>";
 static gpg_error_t
 cmd_pkdecrypt (assuan_context_t ctx, char *line)
 {
@@ -1009,6 +1087,7 @@ cmd_pkdecrypt (assuan_context_t ctx, char *line)
   unsigned char *outdata;
   size_t outdatalen;
   char *keyidstr;
+  unsigned int infoflags;
 
   if ( IS_LOCKED (ctrl) )
     return gpg_error (GPG_ERR_LOCKED);
@@ -1020,10 +1099,10 @@ cmd_pkdecrypt (assuan_context_t ctx, char *line)
   if (!keyidstr)
     return out_of_core ();
   rc = app_decipher (ctrl->app_ctx,
-                     keyidstr, 
+                     keyidstr,
                      pin_cb, ctx,
                      ctrl->in_data.value, ctrl->in_data.valuelen,
-                     &outdata, &outdatalen);
+                     &outdata, &outdatalen, &infoflags);
 
   xfree (keyidstr);
   if (rc)
@@ -1032,6 +1111,13 @@ cmd_pkdecrypt (assuan_context_t ctx, char *line)
     }
   else
     {
+      /* If the card driver told us that there is no padding, send a
+         status line.  If there is a padding it is assumed that the
+         caller knows what padding is used.  It would have been better
+         to always send that information but for backward
+         compatibility we can't do that.  */
+      if ((infoflags & APP_DECIPHER_INFO_NOPAD))
+        send_status_direct (ctrl, "PADDING", "0");
       rc = assuan_send_data (ctx, outdata, outdatalen);
       xfree (outdata);
       if (rc)
@@ -1043,18 +1129,18 @@ cmd_pkdecrypt (assuan_context_t ctx, char *line)
 }
 
 
-/* GETATTR <name>
-
-   This command is used to retrieve data from a smartcard.  The
-   allowed names depend on the currently selected smartcard
-   application.  NAME must be percent and '+' escaped.  The value is
-   returned through status message, see the LEARN command for details.
-
-   However, the current implementation assumes that Name is not escaped;
-   this works as long as noone uses arbitrary escaping. 
-   Note, that this function may even be used on a locked card.
-*/
+static const char hlp_getattr[] =
+  "GETATTR <name>\n"
+  "\n"
+  "This command is used to retrieve data from a smartcard.  The\n"
+  "allowed names depend on the currently selected smartcard\n"
+  "application.  NAME must be percent and '+' escaped.  The value is\n"
+  "returned through status message, see the LEARN command for details.\n"
+  "\n"
+  "However, the current implementation assumes that Name is not escaped;\n"
+  "this works as long as noone uses arbitrary escaping. \n"
+  "\n"
+  "Note, that this function may even be used on a locked card.";
 static gpg_error_t
 cmd_getattr (assuan_context_t ctx, char *line)
 {
@@ -1082,18 +1168,19 @@ cmd_getattr (assuan_context_t ctx, char *line)
 }
 
 
-/* SETATTR <name> <value> 
-
-   This command is used to store data on a a smartcard.  The allowed
-   names and values are depend on the currently selected smartcard
-   application.  NAME and VALUE must be percent and '+' escaped.
-
-   However, the current implementation assumes that NAME is not
-   escaped; this works as long as noone uses arbitrary escaping.
-   A PIN will be requested for most NAMEs.  See the corresponding
-   setattr function of the actually used application (app-*.c) for
-   details.  */
+static const char hlp_setattr[] =
+  "SETATTR <name> <value> \n"
+  "\n"
+  "This command is used to store data on a a smartcard.  The allowed\n"
+  "names and values are depend on the currently selected smartcard\n"
+  "application.  NAME and VALUE must be percent and '+' escaped.\n"
+  "\n"
+  "However, the current implementation assumes that NAME is not\n"
+  "escaped; this works as long as noone uses arbitrary escaping.\n"
+  "\n"
+  "A PIN will be requested for most NAMEs.  See the corresponding\n"
+  "setattr function of the actually used application (app-*.c) for\n"
+  "details.";
 static gpg_error_t
 cmd_setattr (assuan_context_t ctx, char *orig_line)
 {
@@ -1134,17 +1221,17 @@ cmd_setattr (assuan_context_t ctx, char *orig_line)
 }
 
 
-
-/* WRITECERT <hexified_certid>
-
-   This command is used to store a certifciate on a smartcard.  The
-   allowed certids depend on the currently selected smartcard
-   application. The actual certifciate is requested using the inquiry
-   "CERTDATA" and needs to be provided in its raw (e.g. DER) form.
-
-   In almost all cases a a PIN will be requested.  See the related
-   writecert function of the actually used application (app-*.c) for
-   details.  */
+static const char hlp_writecert[] =
+  "WRITECERT <hexified_certid>\n"
+  "\n"
+  "This command is used to store a certifciate on a smartcard.  The\n"
+  "allowed certids depend on the currently selected smartcard\n"
+  "application. The actual certifciate is requested using the inquiry\n"
+  "\"CERTDATA\" and needs to be provided in its raw (e.g. DER) form.\n"
+  "\n"
+  "In almost all cases a a PIN will be requested.  See the related\n"
+  "writecert function of the actually used application (app-*.c) for\n"
+  "details.";
 static gpg_error_t
 cmd_writecert (assuan_context_t ctx, char *line)
 {
@@ -1186,7 +1273,7 @@ cmd_writecert (assuan_context_t ctx, char *line)
     }
 
   /* Write the certificate to the card. */
-  rc = app_writecert (ctrl->app_ctx, ctrl, certid, 
+  rc = app_writecert (ctrl->app_ctx, ctrl, certid,
                       pin_cb, ctx, certdata, certdatalen);
   xfree (certid);
   xfree (certdata);
@@ -1196,20 +1283,20 @@ cmd_writecert (assuan_context_t ctx, char *line)
 }
 
 
-
-/* WRITEKEY [--force] <keyid> 
-
-   This command is used to store a secret key on a a smartcard.  The
-   allowed keyids depend on the currently selected smartcard
-   application. The actual keydata is requested using the inquiry
-   "KEYDATA" and need to be provided without any protection.  With
-   --force set an existing key under this KEYID will get overwritten.
-   The keydata is expected to be the usual canonical encoded
-   S-expression.
-
-   A PIN will be requested for most NAMEs.  See the corresponding
-   writekey function of the actually used application (app-*.c) for
-   details.  */
+static const char hlp_writekey[] =
+  "WRITEKEY [--force] <keyid> \n"
+  "\n"
+  "This command is used to store a secret key on a a smartcard.  The\n"
+  "allowed keyids depend on the currently selected smartcard\n"
+  "application. The actual keydata is requested using the inquiry\n"
+  "\"KEYDATA\" and need to be provided without any protection.  With\n"
+  "--force set an existing key under this KEYID will get overwritten.\n"
+  "The keydata is expected to be the usual canonical encoded\n"
+  "S-expression.\n"
+  "\n"
+  "A PIN will be requested for most NAMEs.  See the corresponding\n"
+  "writekey function of the actually used application (app-*.c) for\n"
+  "details.";
 static gpg_error_t
 cmd_writekey (assuan_context_t ctx, char *line)
 {
@@ -1263,29 +1350,31 @@ cmd_writekey (assuan_context_t ctx, char *line)
 }
 
 
-
-/* GENKEY [--force] [--timestamp=<isodate>] <no>
-
-   Generate a key on-card identified by NO, which is application
-   specific.  Return values are application specific.  For OpenPGP
-   cards 2 status lines are returned:
-
-     S KEY-FPR  <hexstring>
-     S KEY-CREATED-AT <seconds_since_epoch>
-     S KEY-DATA [p|n] <hexdata>
-     
-   --force is required to overwrite an already existing key.  The
-   KEY-CREATED-AT is required for further processing because it is
-   part of the hashed key material for the fingerprint.
-
-   If --timestamp is given an OpenPGP key will be created using this
-   value.  The value needs to be in ISO Format; e.g.
-   "--timestamp=20030316T120000" and after 1970-01-01 00:00:00.
-
-   The public part of the key can also later be retrieved using the
-   READKEY command.
-
- */
+static const char hlp_genkey[] =
+  "GENKEY [--force] [--timestamp=<isodate>] <no>\n"
+  "\n"
+  "Generate a key on-card identified by NO, which is application\n"
+  "specific.  Return values are application specific.  For OpenPGP\n"
+  "cards 3 status lines are returned:\n"
+  "\n"
+  "  S KEY-FPR  <hexstring>\n"
+  "  S KEY-CREATED-AT <seconds_since_epoch>\n"
+  "  S KEY-DATA [-|p|n] <hexdata>\n"
+  "\n"
+  "  'p' and 'n' are the names of the RSA parameters; '-' is used to\n"
+  "  indicate that HEXDATA is the first chunk of a parameter given\n"
+  "  by the next KEY-DATA.\n"
+  "\n"
+  "--force is required to overwrite an already existing key.  The\n"
+  "KEY-CREATED-AT is required for further processing because it is\n"
+  "part of the hashed key material for the fingerprint.\n"
+  "\n"
+  "If --timestamp is given an OpenPGP key will be created using this\n"
+  "value.  The value needs to be in ISO Format; e.g.\n"
+  "\"--timestamp=20030316T120000\" and after 1970-01-01 00:00:00.\n"
+  "\n"
+  "The public part of the key can also later be retrieved using the\n"
+  "READKEY command.";
 static gpg_error_t
 cmd_genkey (assuan_context_t ctx, char *line)
 {
@@ -1339,12 +1428,14 @@ cmd_genkey (assuan_context_t ctx, char *line)
 }
 
 
-/* RANDOM <nbytes>
-
-   Get NBYTES of random from the card and send them back as data. 
-
-   Note, that this function may be even be used on a locked card.
-*/
+static const char hlp_random[] =
+  "RANDOM <nbytes>\n"
+  "\n"
+  "Get NBYTES of random from the card and send them back as data.\n"
+  "This usually involves EEPROM write on the card and thus excessive\n"
+  "use of this command may destroy the card.\n"
+  "\n"
+  "Note, that this function may be even be used on a locked card.";
 static gpg_error_t
 cmd_random (assuan_context_t ctx, char *line)
 {
@@ -1354,7 +1445,8 @@ cmd_random (assuan_context_t ctx, char *line)
   unsigned char *buffer;
 
   if (!*line)
-    return set_error (GPG_ERR_ASS_PARAMETER, "number of requested bytes missing");
+    return set_error (GPG_ERR_ASS_PARAMETER,
+                      "number of requested bytes missing");
   nbytes = strtoul (line, NULL, 0);
 
   if ((rc = open_card (ctrl, NULL)))
@@ -1380,13 +1472,15 @@ cmd_random (assuan_context_t ctx, char *line)
   return rc;
 }
 
+
 \f
-/* PASSWD [--reset] [--nullpin] <chvno>
-  
-   Change the PIN or, if --reset is given, reset the retry counter of
-   the card holder verfication vector CHVNO.  The option --nullpin is
-   used for TCOS cards to set the initial PIN.  The format of CHVNO
-   depends on the card application.  */
+static const char hlp_passwd[] =
+  "PASSWD [--reset] [--nullpin] <chvno>\n"
+  "\n"
+  "Change the PIN or, if --reset is given, reset the retry counter of\n"
+  "the card holder verfication vector CHVNO.  The option --nullpin is\n"
+  "used for TCOS cards to set the initial PIN.  The format of CHVNO\n"
+  "depends on the card application.";
 static gpg_error_t
 cmd_passwd (assuan_context_t ctx, char *line)
 {
@@ -1417,7 +1511,7 @@ cmd_passwd (assuan_context_t ctx, char *line)
 
   if (!ctrl->app_ctx)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  
+
   chvnostr = xtrystrdup (chvnostr);
   if (!chvnostr)
     return out_of_core ();
@@ -1431,39 +1525,38 @@ cmd_passwd (assuan_context_t ctx, char *line)
 }
 
 
-/* CHECKPIN <idstr>
-
-   Perform a VERIFY operation without doing anything else.  This may
-   be used to initialize a the PIN cache earlier to long lasting
-   operations.  Its use is highly application dependent.
-
-   For OpenPGP:
-
-      Perform a simple verify operation for CHV1 and CHV2, so that
-      further operations won't ask for CHV2 and it is possible to do a
-      cheap check on the PIN: If there is something wrong with the PIN
-      entry system, only the regular CHV will get blocked and not the
-      dangerous CHV3.  IDSTR is the usual card's serial number in hex
-      notation; an optional fingerprint part will get ignored.  There
-      is however a special mode if the IDSTR is sffixed with the
-      literal string "[CHV3]": In this case the Admin PIN is checked
-      if and only if the retry counter is still at 3.
-
-   For Netkey:
-
-      Any of the valid PIN Ids may be used.  These are the strings:
-
-        PW1.CH       - Global password 1
-        PW2.CH       - Global password 2
-        PW1.CH.SIG   - SigG password 1
-        PW2.CH.SIG   - SigG password 2
-
-      For a definitive list, see the implementation in app-nks.c.
-      Note that we call a PW2.* PIN a "PUK" despite that since TCOS
-      3.0 they are technically alternative PINs used to mutally
-      unblock each other.
-
- */
+static const char hlp_checkpin[] =
+  "CHECKPIN <idstr>\n"
+  "\n"
+  "Perform a VERIFY operation without doing anything else.  This may\n"
+  "be used to initialize a the PIN cache earlier to long lasting\n"
+  "operations.  Its use is highly application dependent.\n"
+  "\n"
+  "For OpenPGP:\n"
+  "\n"
+  "   Perform a simple verify operation for CHV1 and CHV2, so that\n"
+  "   further operations won't ask for CHV2 and it is possible to do a\n"
+  "   cheap check on the PIN: If there is something wrong with the PIN\n"
+  "   entry system, only the regular CHV will get blocked and not the\n"
+  "   dangerous CHV3.  IDSTR is the usual card's serial number in hex\n"
+  "   notation; an optional fingerprint part will get ignored.  There\n"
+  "   is however a special mode if the IDSTR is sffixed with the\n"
+  "   literal string \"[CHV3]\": In this case the Admin PIN is checked\n"
+  "   if and only if the retry counter is still at 3.\n"
+  "\n"
+  "For Netkey:\n"
+  "\n"
+  "   Any of the valid PIN Ids may be used.  These are the strings:\n"
+  "\n"
+  "     PW1.CH       - Global password 1\n"
+  "     PW2.CH       - Global password 2\n"
+  "     PW1.CH.SIG   - SigG password 1\n"
+  "     PW2.CH.SIG   - SigG password 2\n"
+  "\n"
+  "   For a definitive list, see the implementation in app-nks.c.\n"
+  "   Note that we call a PW2.* PIN a \"PUK\" despite that since TCOS\n"
+  "   3.0 they are technically alternative PINs used to mutally\n"
+  "   unblock each other.";
 static gpg_error_t
 cmd_checkpin (assuan_context_t ctx, char *line)
 {
@@ -1486,7 +1579,7 @@ cmd_checkpin (assuan_context_t ctx, char *line)
   idstr = xtrystrdup (line);
   if (!idstr)
     return out_of_core ();
-  
+
   rc = app_check_pin (ctrl->app_ctx, idstr, pin_cb, ctx);
   xfree (idstr);
   if (rc)
@@ -1497,16 +1590,16 @@ cmd_checkpin (assuan_context_t ctx, char *line)
 }
 
 
-/* LOCK [--wait]
-
-   Grant exclusive card access to this session.  Note that there is
-   no lock counter used and a second lock from the same session will
-   be ignored.  A single unlock (or RESET) unlocks the session.
-   Return GPG_ERR_LOCKED if another session has locked the reader.
-
-   If the option --wait is given the command will wait until a
-   lock has been released.
- */
+static const char hlp_lock[] =
+  "LOCK [--wait]\n"
+  "\n"
+  "Grant exclusive card access to this session.  Note that there is\n"
+  "no lock counter used and a second lock from the same session will\n"
+  "be ignored.  A single unlock (or RESET) unlocks the session.\n"
+  "Return GPG_ERR_LOCKED if another session has locked the reader.\n"
+  "\n"
+  "If the option --wait is given the command will wait until a\n"
+  "lock has been released.";
 static gpg_error_t
 cmd_lock (assuan_context_t ctx, char *line)
 {
@@ -1522,29 +1615,29 @@ cmd_lock (assuan_context_t ctx, char *line)
   else
     locked_session = ctrl->server_local;
 
-#ifdef USE_GNU_PTH
+#ifdef USE_NPTH
   if (rc && has_option (line, "--wait"))
     {
       rc = 0;
-      pth_sleep (1); /* Better implement an event mechanism. However,
-                        for card operations this should be
-                        sufficient. */
+      npth_sleep (1); /* Better implement an event mechanism. However,
+                        for card operations this should be
+                        sufficient. */
       /* FIXME: Need to check that the connection is still alive.
          This can be done by issuing status messages. */
       goto retry;
     }
-#endif /*USE_GNU_PTH*/
-  
+#endif /*USE_NPTH*/
+
   if (rc)
     log_error ("cmd_lock failed: %s\n", gpg_strerror (rc));
   return rc;
 }
 
 
-/* UNLOCK
-
-   Release exclusive card access.
- */
+static const char hlp_unlock[] =
+  "UNLOCK\n"
+  "\n"
+  "Release exclusive card access.";
 static gpg_error_t
 cmd_unlock (assuan_context_t ctx, char *line)
 {
@@ -1569,34 +1662,33 @@ cmd_unlock (assuan_context_t ctx, char *line)
 }
 
 
-/* GETINFO <what>
-
-   Multi purpose command to return certain information.  
-   Supported values of WHAT are:
-
-   version     - Return the version of the program.
-   pid         - Return the process id of the server.
-
-   socket_name - Return the name of the socket.
-
-   status - Return the status of the current slot (in the future, may
-   also return the status of all slots).  The status is a list of
-   one-character flags.  The following flags are currently defined:
-     'u'  Usable card present.  This is the normal state during operation.
-     'r'  Card removed.  A reset is necessary.
-   These flags are exclusive.
-
-   reader_list - Return a list of detected card readers.  Does
-                 currently only work with the internal CCID driver.
-
-   deny_admin  - Returns OK if admin commands are not allowed or
-                 GPG_ERR_GENERAL if admin commands are allowed.
-
-   app_list    - Return a list of supported applications.  One
-                 application per line, fields delimited by colons,
-                 first field is the name.
-*/
-
+static const char hlp_getinfo[] =
+  "GETINFO <what>\n"
+  "\n"
+  "Multi purpose command to return certain information.  \n"
+  "Supported values of WHAT are:\n"
+  "\n"
+  "version     - Return the version of the program.\n"
+  "pid         - Return the process id of the server.\n"
+  "\n"
+  "socket_name - Return the name of the socket.\n"
+  "\n"
+  "status - Return the status of the current reader (in the future, may\n"
+  "also return the status of all readers).  The status is a list of\n"
+  "one-character flags.  The following flags are currently defined:\n"
+  "  'u'  Usable card present.  This is the normal state during operation.\n"
+  "  'r'  Card removed.  A reset is necessary.\n"
+  "These flags are exclusive.\n"
+  "\n"
+  "reader_list - Return a list of detected card readers.  Does\n"
+  "              currently only work with the internal CCID driver.\n"
+  "\n"
+  "deny_admin  - Returns OK if admin commands are not allowed or\n"
+  "              GPG_ERR_GENERAL if admin commands are allowed.\n"
+  "\n"
+  "app_list    - Return a list of supported applications.  One\n"
+  "              application per line, fields delimited by colons,\n"
+  "              first field is the name.";
 static gpg_error_t
 cmd_getinfo (assuan_context_t ctx, char *line)
 {
@@ -1626,22 +1718,18 @@ cmd_getinfo (assuan_context_t ctx, char *line)
   else if (!strcmp (line, "status"))
     {
       ctrl_t ctrl = assuan_get_pointer (ctx);
-      int slot = ctrl->reader_slot;
+      int vrdr = ctrl->server_local->vreader_idx;
       char flag = 'r';
 
-      if (!ctrl->server_local->card_removed && slot != -1)
+      if (!ctrl->server_local->card_removed && vrdr != -1)
        {
-         struct slot_status_s *ss;
-         
-         if (!(slot >= 0 && slot < DIM(slot_table)))
-           BUG ();
+         struct vreader_s *vr;
 
-         ss = &slot_table[slot];
-
-         if (!ss->valid)
+         if (!(vrdr >= 0 && vrdr < DIM(vreader_table)))
            BUG ();
 
-         if (ss->any && (ss->status & 1))
+         vr = &vreader_table[vrdr];
+         if (vr->valid && vr->any && (vr->status & 1))
            flag = 'u';
        }
       rc = assuan_send_data (ctx, &flag, 1);
@@ -1653,7 +1741,7 @@ cmd_getinfo (assuan_context_t ctx, char *line)
 #else
       char *s = NULL;
 #endif
-      
+
       if (s)
         rc = assuan_send_data (ctx, s, strlen (s));
       else
@@ -1677,17 +1765,16 @@ cmd_getinfo (assuan_context_t ctx, char *line)
 }
 
 
-/* RESTART
-
-   Restart the current connection; this is a kind of warm reset.  It
-   deletes the context used by this connection but does not send a
-   RESET to the card.  Thus the card itself won't get reset. 
-
-   This is used by gpg-agent to reuse a primary pipe connection and
-   may be used by clients to backup from a conflict in the serial
-   command; i.e. to select another application. 
-*/
-
+static const char hlp_restart[] =
+  "RESTART\n"
+  "\n"
+  "Restart the current connection; this is a kind of warm reset.  It\n"
+  "deletes the context used by this connection but does not send a\n"
+  "RESET to the card.  Thus the card itself won't get reset. \n"
+  "\n"
+  "This is used by gpg-agent to reuse a primary pipe connection and\n"
+  "may be used by clients to backup from a conflict in the serial\n"
+  "command; i.e. to select another application.";
 static gpg_error_t
 cmd_restart (assuan_context_t ctx, char *line)
 {
@@ -1709,43 +1796,43 @@ cmd_restart (assuan_context_t ctx, char *line)
 }
 
 
-/* DISCONNECT
-
-   Disconnect the card if it is not any longer used by other
-   connections and the backend supports a disconnect operation. 
- */
+static const char hlp_disconnect[] =
+  "DISCONNECT\n"
+  "\n"
+  "Disconnect the card if it is not any longer used by other\n"
+  "connections and the backend supports a disconnect operation.";
 static gpg_error_t
 cmd_disconnect (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
 
   (void)line;
-  
+
   ctrl->server_local->disconnect_allowed = 1;
   return 0;
 }
 
 
 
-/* APDU [--atr] [--more] [--exlen[=N]] [hexstring]
-
-   Send an APDU to the current reader.  This command bypasses the high
-   level functions and sends the data directly to the card.  HEXSTRING
-   is expected to be a proper APDU.  If HEXSTRING is not given no
-   commands are set to the card but the command will implictly check
-   whether the card is ready for use. 
-
-   Using the option "--atr" returns the ATR of the card as a status
-   message before any data like this:
-     S CARD-ATR 3BFA1300FF813180450031C173C00100009000B1
-
-   Using the option --more handles the card status word MORE_DATA
-   (61xx) and concatenates all reponses to one block.
-
-   Using the option "--exlen" the returned APDU may use extended
-   length up to N bytes.  If N is not given a default value is used
-   (currently 4096).
- */
+static const char hlp_apdu[] =
+  "APDU [--[dump-]atr] [--more] [--exlen[=N]] [hexstring]\n"
+  "\n"
+  "Send an APDU to the current reader.  This command bypasses the high\n"
+  "level functions and sends the data directly to the card.  HEXSTRING\n"
+  "is expected to be a proper APDU.  If HEXSTRING is not given no\n"
+  "commands are set to the card but the command will implictly check\n"
+  "whether the card is ready for use. \n"
+  "\n"
+  "Using the option \"--atr\" returns the ATR of the card as a status\n"
+  "message before any data like this:\n"
+  "  S CARD-ATR 3BFA1300FF813180450031C173C00100009000B1\n"
+  "\n"
+  "Using the option --more handles the card status word MORE_DATA\n"
+  "(61xx) and concatenates all reponses to one block.\n"
+  "\n"
+  "Using the option \"--exlen\" the returned APDU may use extended\n"
+  "length up to N bytes.  If N is not given a default value is used\n"
+  "(currently 4096).";
 static gpg_error_t
 cmd_apdu (assuan_context_t ctx, char *line)
 {
@@ -1757,8 +1844,12 @@ cmd_apdu (assuan_context_t ctx, char *line)
   int handle_more;
   const char *s;
   size_t exlen;
+  int slot;
 
-  with_atr = has_option (line, "--atr");
+  if (has_option (line, "--dump-atr"))
+    with_atr = 2;
+  else
+    with_atr = has_option (line, "--atr");
   handle_more = has_option (line, "--more");
 
   if ((s=has_option_name (line, "--exlen")))
@@ -1779,21 +1870,46 @@ cmd_apdu (assuan_context_t ctx, char *line)
   if ((rc = open_card (ctrl, NULL)))
     return rc;
 
+  slot = vreader_slot (ctrl->server_local->vreader_idx);
+
   if (with_atr)
     {
       unsigned char *atr;
       size_t atrlen;
       char hexbuf[400];
-      
-      atr = apdu_get_atr (ctrl->reader_slot, &atrlen);
+
+      atr = apdu_get_atr (slot, &atrlen);
       if (!atr || atrlen > sizeof hexbuf - 2 )
         {
           rc = gpg_error (GPG_ERR_INV_CARD);
           goto leave;
         }
-      bin2hex (atr, atrlen, hexbuf);
+      if (with_atr == 2)
+        {
+          char *string, *p, *pend;
+
+          string = atr_dump (atr, atrlen);
+          if (string)
+            {
+              for (rc=0, p=string; !rc && (pend = strchr (p, '\n')); p = pend+1)
+                {
+                  rc = assuan_send_data (ctx, p, pend - p + 1);
+                  if (!rc)
+                    rc = assuan_send_data (ctx, NULL, 0);
+                }
+              if (!rc && *p)
+                rc = assuan_send_data (ctx, p, strlen (p));
+              es_free (string);
+              if (rc)
+                goto leave;
+            }
+        }
+      else
+        {
+          bin2hex (atr, atrlen, hexbuf);
+          send_status_info (ctrl, "CARD-ATR", hexbuf, strlen (hexbuf), NULL, 0);
+        }
       xfree (atr);
-      send_status_info (ctrl, "CARD-ATR", hexbuf, strlen (hexbuf), NULL, 0);
     }
 
   apdu = hex_to_buffer (line, &apdulen);
@@ -1807,7 +1923,7 @@ cmd_apdu (assuan_context_t ctx, char *line)
       unsigned char *result = NULL;
       size_t resultlen;
 
-      rc = apdu_send_direct (ctrl->reader_slot, exlen,
+      rc = apdu_send_direct (slot, exlen,
                              apdu, apdulen, handle_more,
                              &result, &resultlen);
       if (rc)
@@ -1826,7 +1942,10 @@ cmd_apdu (assuan_context_t ctx, char *line)
 }
 
 
-/* KILLSCD - Commit suicide. */
+static const char hlp_killscd[] =
+  "KILLSCD\n"
+  "\n"
+  "Commit suicide.";
 static gpg_error_t
 cmd_killscd (assuan_context_t ctx, char *line)
 {
@@ -1835,7 +1954,8 @@ cmd_killscd (assuan_context_t ctx, char *line)
   (void)line;
 
   ctrl->server_local->stopme = 1;
-  return gpg_error (GPG_ERR_EOF);
+  assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
+  return 0;
 }
 
 
@@ -1847,42 +1967,44 @@ register_commands (assuan_context_t ctx)
   static struct {
     const char *name;
     assuan_handler_t handler;
+    const char * const help;
   } table[] = {
-    { "SERIALNO",     cmd_serialno },
-    { "LEARN",        cmd_learn },
-    { "READCERT",     cmd_readcert },
-    { "READKEY",      cmd_readkey },
-    { "SETDATA",      cmd_setdata },
-    { "PKSIGN",       cmd_pksign },
-    { "PKAUTH",       cmd_pkauth },
-    { "PKDECRYPT",    cmd_pkdecrypt },
-    { "INPUT",        NULL }, 
-    { "OUTPUT",       NULL }, 
-    { "GETATTR",      cmd_getattr },
-    { "SETATTR",      cmd_setattr },
-    { "WRITECERT",    cmd_writecert },
-    { "WRITEKEY",     cmd_writekey },
-    { "GENKEY",       cmd_genkey },
-    { "RANDOM",       cmd_random },
-    { "PASSWD",       cmd_passwd },
-    { "CHECKPIN",     cmd_checkpin },
-    { "LOCK",         cmd_lock },
-    { "UNLOCK",       cmd_unlock },
-    { "GETINFO",      cmd_getinfo },
-    { "RESTART",      cmd_restart },
-    { "DISCONNECT",   cmd_disconnect },
-    { "APDU",         cmd_apdu },
-    { "KILLSCD",      cmd_killscd },
+    { "SERIALNO",     cmd_serialno, hlp_serialno },
+    { "LEARN",        cmd_learn,    hlp_learn },
+    { "READCERT",     cmd_readcert, hlp_readcert },
+    { "READKEY",      cmd_readkey,  hlp_readkey },
+    { "SETDATA",      cmd_setdata,  hlp_setdata },
+    { "PKSIGN",       cmd_pksign,   hlp_pksign },
+    { "PKAUTH",       cmd_pkauth,   hlp_pkauth },
+    { "PKDECRYPT",    cmd_pkdecrypt,hlp_pkdecrypt },
+    { "INPUT",        NULL },
+    { "OUTPUT",       NULL },
+    { "GETATTR",      cmd_getattr,  hlp_getattr },
+    { "SETATTR",      cmd_setattr,  hlp_setattr },
+    { "WRITECERT",    cmd_writecert,hlp_writecert },
+    { "WRITEKEY",     cmd_writekey, hlp_writekey },
+    { "GENKEY",       cmd_genkey,   hlp_genkey },
+    { "RANDOM",       cmd_random,   hlp_random },
+    { "PASSWD",       cmd_passwd,   hlp_passwd },
+    { "CHECKPIN",     cmd_checkpin, hlp_checkpin },
+    { "LOCK",         cmd_lock,     hlp_lock },
+    { "UNLOCK",       cmd_unlock,   hlp_unlock },
+    { "GETINFO",      cmd_getinfo,  hlp_getinfo },
+    { "RESTART",      cmd_restart,  hlp_restart },
+    { "DISCONNECT",   cmd_disconnect,hlp_disconnect },
+    { "APDU",         cmd_apdu,     hlp_apdu },
+    { "KILLSCD",      cmd_killscd,  hlp_killscd },
     { NULL }
   };
   int i, rc;
 
   for (i=0; table[i].name; i++)
     {
-      rc = assuan_register_command (ctx, table[i].name, table[i].handler, NULL);
+      rc = assuan_register_command (ctx, table[i].name, table[i].handler,
+                                    table[i].help);
       if (rc)
         return rc;
-    } 
+    }
   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
 
   assuan_register_reset_notify (ctx, reset_notify);
@@ -1900,7 +2022,7 @@ scd_command_handler (ctrl_t ctrl, int fd)
   int rc;
   assuan_context_t ctx = NULL;
   int stopme;
-  
+
   rc = assuan_new (&ctx);
   if (rc)
     {
@@ -1911,15 +2033,16 @@ scd_command_handler (ctrl_t ctrl, int fd)
 
   if (fd == -1)
     {
-      int filedes[2];
+      assuan_fd_t filedes[2];
 
-      filedes[0] = 0;
-      filedes[1] = 1;
+      filedes[0] = assuan_fdopen (0);
+      filedes[1] = assuan_fdopen (1);
       rc = assuan_init_pipe_server (ctx, filedes);
     }
   else
     {
-      rc = assuan_init_socket_server_ext (ctx, INT2FD(fd), 2);
+      rc = assuan_init_socket_server (ctx, INT2FD(fd),
+                                     ASSUAN_SOCKET_SERVER_ACCEPTED);
     }
   if (rc)
     {
@@ -1943,15 +2066,13 @@ scd_command_handler (ctrl_t ctrl, int fd)
   session_list = ctrl->server_local;
   ctrl->server_local->ctrl_backlink = ctrl;
   ctrl->server_local->assuan_ctx = ctx;
-
-  if (DBG_ASSUAN)
-    assuan_set_log_stream (ctx, log_get_stream ());
+  ctrl->server_local->vreader_idx = -1;
 
   /* We open the reader right at startup so that the ticker is able to
      update the status file. */
-  if (ctrl->reader_slot == -1)
+  if (ctrl->server_local->vreader_idx == -1)
     {
-      ctrl->reader_slot = get_reader_slot ();
+      ctrl->server_local->vreader_idx = get_current_reader ();
     }
 
   /* Command processing loop. */
@@ -1967,7 +2088,7 @@ scd_command_handler (ctrl_t ctrl, int fd)
           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
           break;
         }
-      
+
       rc = assuan_process (ctx);
       if (rc)
         {
@@ -1977,7 +2098,7 @@ scd_command_handler (ctrl_t ctrl, int fd)
     }
 
   /* Cleanup.  We don't send an explicit reset to the card.  */
-  do_reset (ctrl, 0); 
+  do_reset (ctrl, 0);
 
   /* Release the server object.  */
   if (session_list == ctrl->server_local)
@@ -1985,7 +2106,7 @@ scd_command_handler (ctrl_t ctrl, int fd)
   else
     {
       struct server_local_s *sl;
-      
+
       for (sl=session_list; sl->next_session; sl = sl->next_session)
         if (sl->next_session == ctrl->server_local)
           break;
@@ -2020,10 +2141,10 @@ send_status_info (ctrl_t ctrl, const char *keyword, ...)
   char buf[950], *p;
   size_t n;
   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
-  
+
   va_start (arg_ptr, keyword);
 
-  p = buf; 
+  p = buf;
   n = 0;
   while ( (value = va_arg (arg_ptr, const unsigned char *)) )
     {
@@ -2073,17 +2194,17 @@ static void
 send_client_notifications (void)
 {
   struct {
-    pid_t pid; 
+    pid_t pid;
 #ifdef HAVE_W32_SYSTEM
     HANDLE handle;
 #else
-    int signo; 
+    int signo;
 #endif
   } killed[50];
   int killidx = 0;
   int kidx;
   struct server_local_s *sl;
-  
+
   for (sl=session_list; sl; sl = sl->next_session)
     {
       if (sl->event_signal && sl->assuan_ctx)
@@ -2091,9 +2212,9 @@ send_client_notifications (void)
           pid_t pid = assuan_get_pid (sl->assuan_ctx);
 #ifdef HAVE_W32_SYSTEM
           HANDLE handle = (void *)sl->event_signal;
-          
+
           for (kidx=0; kidx < killidx; kidx++)
-            if (killed[kidx].pid == pid 
+            if (killed[kidx].pid == pid
                 && killed[kidx].handle == handle)
               break;
           if (kidx < killidx)
@@ -2115,11 +2236,11 @@ send_client_notifications (void)
             }
 #else /*!HAVE_W32_SYSTEM*/
           int signo = sl->event_signal;
-          
+
           if (pid != (pid_t)(-1) && pid && signo > 0)
             {
               for (kidx=0; kidx < killidx; kidx++)
-                if (killed[kidx].pid == pid 
+                if (killed[kidx].pid == pid
                     && killed[kidx].signo == signo)
                   break;
               if (kidx < killidx)
@@ -2153,52 +2274,50 @@ update_reader_status_file (int set_card_removed_flag)
   int idx;
   unsigned int status, changed;
 
-  /* Make sure that the reader has been opened.  Like get_reader_slot,
-     this part of the code assumes that there is only one reader.  */
-  if (!slot_table[0].valid)
-    (void)get_reader_slot ();
-
   /* Note, that we only try to get the status, because it does not
      make sense to wait here for a operation to complete.  If we are
      busy working with a card, delays in the status file update should
      be acceptable. */
-  for (idx=0; idx < DIM(slot_table); idx++)
+  for (idx=0; idx < DIM(vreader_table); idx++)
     {
-      struct slot_status_s *ss = slot_table + idx;
+      struct vreader_s *vr = vreader_table + idx;
       struct server_local_s *sl;
       int sw_apdu;
 
-      if (!ss->valid || ss->slot == -1)
+      if (!vr->valid || vr->slot == -1)
         continue; /* Not valid or reader not yet open. */
-      
-      sw_apdu = apdu_get_status (ss->slot, 0, &status, &changed);
+
+      sw_apdu = apdu_get_status (vr->slot, 0, &status, &changed);
       if (sw_apdu == SW_HOST_NO_READER)
         {
           /* Most likely the _reader_ has been unplugged.  */
+          application_notify_card_reset (vr->slot);
+         apdu_close_reader (vr->slot);
+          vr->slot = -1;
           status = 0;
-          changed = ss->changed;
+          changed = vr->changed;
         }
       else if (sw_apdu)
         {
           /* Get status failed.  Ignore that.  */
-          continue; 
+          continue;
         }
 
-      if (!ss->any || ss->status != status || ss->changed != changed )
+      if (!vr->any || vr->status != status || vr->changed != changed )
         {
           char *fname;
           char templ[50];
           FILE *fp;
 
-          log_info ("updating slot %d status: 0x%04X->0x%04X (%u->%u)\n",
-                    ss->slot, ss->status, status, ss->changed, changed);
-          ss->status = status;
-          ss->changed = changed;
+          log_info ("updating reader %d (%d) status: 0x%04X->0x%04X (%u->%u)\n",
+                    idx, vr->slot, vr->status, status, vr->changed, changed);
+          vr->status = status;
+          vr->changed = changed;
 
-         /* FIXME: Should this be IDX instead of ss->slot?  This
+         /* FIXME: Should this be IDX instead of vr->slot?  This
             depends on how client sessions will associate the reader
             status with their session.  */
-          snprintf (templ, sizeof templ, "reader_%d.status", ss->slot);
+          snprintf (templ, sizeof templ, "reader_%d.status", vr->slot);
           fname = make_filename (opt.homedir, templ, NULL );
           fp = fopen (fname, "w");
           if (fp)
@@ -2210,41 +2329,41 @@ update_reader_status_file (int set_card_removed_flag)
               fclose (fp);
             }
           xfree (fname);
-            
+
           /* If a status script is executable, run it. */
           {
             const char *args[9], *envs[2];
             char numbuf1[30], numbuf2[30], numbuf3[30];
             char *homestr, *envstr;
             gpg_error_t err;
-            
+
             homestr = make_filename (opt.homedir, NULL);
-            if (estream_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
+            if (gpgrt_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
               log_error ("out of core while building environment\n");
             else
               {
                 envs[0] = envstr;
                 envs[1] = NULL;
 
-                sprintf (numbuf1, "%d", ss->slot);
-                sprintf (numbuf2, "0x%04X", ss->status);
+                sprintf (numbuf1, "%d", vr->slot);
+                sprintf (numbuf2, "0x%04X", vr->status);
                 sprintf (numbuf3, "0x%04X", status);
                 args[0] = "--reader-port";
-                args[1] = numbuf1; 
+                args[1] = numbuf1;
                 args[2] = "--old-code";
-                args[3] = numbuf2;  
+                args[3] = numbuf2;
                 args[4] = "--new-code";
-                args[5] = numbuf3; 
+                args[5] = numbuf3;
                 args[6] = "--status";
                 args[7] = ((status & 1)? "USABLE":
                            (status & 4)? "ACTIVE":
                            (status & 2)? "PRESENT": "NOCARD");
-                args[8] = NULL;  
+                args[8] = NULL;
 
                 fname = make_filename (opt.homedir, "scd-event", NULL);
                 err = gnupg_spawn_process_detached (fname, args, envs);
                 if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
-                  log_error ("failed to run event handler `%s': %s\n",
+                  log_error ("failed to run event handler '%s': %s\n",
                              fname, gpg_strerror (err));
                 xfree (fname);
                 xfree (envstr);
@@ -2252,33 +2371,32 @@ update_reader_status_file (int set_card_removed_flag)
             xfree (homestr);
           }
 
-          /* Set the card removed flag for all current sessions.  We
-             will set this on any card change because a reset or
-             SERIALNO request must be done in any case.  */
-          if (ss->any && set_card_removed_flag)
+          /* Set the card removed flag for all current sessions.  */
+          if (vr->any && vr->status == 0 && set_card_removed_flag)
             update_card_removed (idx, 1);
-          
-          ss->any = 1;
+
+          vr->any = 1;
 
           /* Send a signal to all clients who applied for it.  */
           send_client_notifications ();
         }
-      
+
       /* Check whether a disconnect is pending.  */
       if (opt.card_timeout)
         {
           for (sl=session_list; sl; sl = sl->next_session)
             if (!sl->disconnect_allowed)
-              break; 
+              break;
           if (session_list && !sl)
             {
               /* FIXME: Use a real timeout.  */
               /* At least one connection and all allow a disconnect.  */
-              log_info ("disconnecting card in slot %d\n", ss->slot);
-              apdu_disconnect (ss->slot);
+              log_info ("disconnecting card in reader %d (%d)\n",
+                        idx, vr->slot);
+              apdu_disconnect (vr->slot);
             }
         }
-      
+
     }
 }
 
@@ -2288,9 +2406,13 @@ update_reader_status_file (int set_card_removed_flag)
 void
 scd_update_reader_status_file (void)
 {
-  if (!pth_mutex_acquire (&status_file_update_lock, 1, NULL))
+  int err;
+  err = npth_mutex_lock (&status_file_update_lock);
+  if (err)
     return; /* locked - give up. */
   update_reader_status_file (1);
-  if (!pth_mutex_release (&status_file_update_lock))
-    log_error ("failed to release status_file_update lock\n");
+  err = npth_mutex_unlock (&status_file_update_lock);
+  if (err)
+    log_error ("failed to release status_file_update lock: %s\n",
+              strerror (err));
 }