scd: Fix an action after card removal.
[gnupg.git] / scd / app.c
index 857f9e1..55b8edd 100644 (file)
--- a/scd/app.c
+++ b/scd/app.c
@@ -5,7 +5,7 @@
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -14,8 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
+#include <npth.h>
 
 #include "scdaemon.h"
 #include "app-common.h"
-#include "apdu.h"
 #include "iso7816.h"
+#include "apdu.h"
 #include "tlv.h"
 
+/* This table is used to keep track of locks on a per reader base.
+   The index into the table is the slot number of the reader.  The
+   mutex will be initialized on demand (one of the advantages of a
+   userland threading system). */
+static struct
+{
+  int initialized;
+  npth_mutex_t lock;
+  app_t app;        /* Application context in use or NULL. */
+} lock_table[10];
+
+
+
+static void deallocate_app (app_t app);
+
+
+\f
+static void
+print_progress_line (void *opaque, const char *what, int pc, int cur, int tot)
+{
+  ctrl_t ctrl = opaque;
+  char line[100];
+
+  if (ctrl)
+    {
+      snprintf (line, sizeof line, "%s %c %d %d", what, pc, cur, tot);
+      send_status_direct (ctrl, "PROGRESS", line);
+    }
+}
+
+
+/* Lock the reader SLOT.  This function shall be used right before
+   calling any of the actual application functions to serialize access
+   to the reader.  We do this always even if the reader is not
+   actually used.  This allows an actual connection to assume that it
+   never shares a reader (while performing one command).  Returns 0 on
+   success; only then the unlock_reader function must be called after
+   returning from the handler. */
+static gpg_error_t
+lock_reader (int slot, ctrl_t ctrl)
+{
+  int res;
+
+  if (slot < 0 || slot >= DIM (lock_table))
+    return gpg_error (slot<0? GPG_ERR_INV_VALUE : GPG_ERR_RESOURCE_LIMIT);
+
+  if (!lock_table[slot].initialized)
+    {
+      res = npth_mutex_init (&lock_table[slot].lock, NULL);
+      if (res)
+        {
+          log_error ("error initializing mutex: %s\n", strerror (res));
+          return gpg_error_from_errno (res);
+        }
+      lock_table[slot].initialized = 1;
+      lock_table[slot].app = NULL;
+    }
+
+  res = npth_mutex_lock (&lock_table[slot].lock);
+  if (res)
+    {
+      log_error ("failed to acquire APP lock for slot %d: %s\n",
+                 slot, strerror (res));
+      return gpg_error_from_errno (res);
+    }
+
+  apdu_set_progress_cb (slot, print_progress_line, ctrl);
+
+  return 0;
+}
+
+/* Release a lock on the reader.  See lock_reader(). */
+static void
+unlock_reader (int slot)
+{
+  int res;
+
+  if (slot < 0 || slot >= DIM (lock_table)
+      || !lock_table[slot].initialized)
+    log_bug ("unlock_reader called for invalid slot %d\n", slot);
+
+  apdu_set_progress_cb (slot, NULL, NULL);
+
+  res = npth_mutex_unlock (&lock_table[slot].lock);
+  if (res)
+    log_error ("failed to release APP lock for slot %d: %s\n",
+               slot, strerror (res));
+}
+
+
+/* This function may be called to print information pertaining to the
+   current state of this module to the log. */
+void
+app_dump_state (void)
+{
+  int slot;
+
+  for (slot=0; slot < DIM (lock_table); slot++)
+    if (lock_table[slot].initialized)
+      {
+        log_info ("app_dump_state: slot=%d", slot);
+        if (lock_table[slot].app)
+          {
+            log_printf (" app=%p", lock_table[slot].app);
+            if (lock_table[slot].app->apptype)
+              log_printf (" type='%s'", lock_table[slot].app->apptype);
+          }
+        log_printf ("\n");
+      }
+}
 
 /* Check wether the application NAME is allowed.  This does not mean
    we have support for it though.  */
@@ -46,6 +155,78 @@ is_app_allowed (const char *name)
 }
 
 
+/* This may be called to tell this module about a removed or resetted card. */
+void
+application_notify_card_reset (int slot)
+{
+  if (slot < 0 || slot >= DIM (lock_table))
+    return;
+
+  /* FIXME: We are ignoring any error value here.  */
+  lock_reader (slot, NULL);
+
+  /* Release the APP, as it's not reusable any more.  */
+  if (lock_table[slot].app)
+    {
+      if (lock_table[slot].app->ref_count)
+        log_bug ("trying to release active context\n");
+
+      deallocate_app (lock_table[slot].app);
+      lock_table[slot].app = NULL;
+      log_debug ("application has been released\n");
+    }
+
+  unlock_reader (slot);
+}
+
+
+/*
+ * This function is called with lock held.
+ */
+static gpg_error_t
+check_conflict (int slot, const char *name)
+{
+  app_t app = lock_table[slot].app;
+
+  if (!app || !name || (app->apptype && !ascii_strcasecmp (app->apptype, name)))
+    return 0;
+
+  if (!app->ref_count)
+    {
+      lock_table[slot].app = NULL;
+      deallocate_app (app);
+      return 0;
+    }
+  else
+    {
+      log_info ("application '%s' in use by reader %d - can't switch\n",
+                app->apptype? app->apptype : "<null>", slot);
+      return gpg_error (GPG_ERR_CONFLICT);
+    }
+}
+
+/* This function is used by the serialno command to check for an
+   application conflict which may appear if the serialno command is
+   used to request a specific application and the connection has
+   already done a select_application. */
+gpg_error_t
+check_application_conflict (ctrl_t ctrl, int slot, const char *name)
+{
+  gpg_error_t err;
+
+  if (slot < 0 || slot >= DIM (lock_table))
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  err = lock_reader (slot, ctrl);
+  if (err)
+    return err;
+
+  err = check_conflict (slot, name);
+  unlock_reader (slot);
+  return err;
+}
+
+
 /* If called with NAME as NULL, select the best fitting application
    and return a context; otherwise select the application with NAME
    and return a context.  SLOT identifies the reader device. Returns
@@ -54,109 +235,200 @@ is_app_allowed (const char *name)
 gpg_error_t
 select_application (ctrl_t ctrl, int slot, const char *name, app_t *r_app)
 {
-  int rc;
-  app_t app;
+  gpg_error_t err;
+  app_t app = NULL;
   unsigned char *result = NULL;
   size_t resultlen;
+  int want_undefined;
+
+  (void)ctrl;
 
   *r_app = NULL;
+
+  want_undefined = (name && !strcmp (name, "undefined"));
+
+  err = lock_reader (slot, ctrl);
+  if (err)
+    return err;
+
+  /* First check whether we already have an application to share. */
+  err = check_conflict (slot, name);
+  if (err)
+    {
+      unlock_reader (slot);
+      return err;
+    }
+
+  app = lock_table[slot].app;
+
+  /* If we can reuse an application, bump the reference count and
+     return it.  */
+  if (app)
+    {
+      if (app->slot != slot)
+        log_bug ("slot mismatch %d/%d\n", app->slot, slot);
+      app->slot = slot;
+
+      app->ref_count++;
+      *r_app = app;
+      unlock_reader (slot);
+      return 0; /* Okay: We share that one. */
+    }
+
+  /* Need to allocate a new one.  */
   app = xtrycalloc (1, sizeof *app);
   if (!app)
     {
-      rc = gpg_error_from_errno (errno);
-      log_info ("error allocating context: %s\n", gpg_strerror (rc));
-      return rc;
+      err = gpg_error_from_syserror ();
+      log_info ("error allocating context: %s\n", gpg_strerror (err));
+      unlock_reader (slot);
+      return err;
     }
   app->slot = slot;
 
+
   /* Fixme: We should now first check whether a card is at all
      present. */
 
-  /* Try to read the GDO file first to get a default serial number. */
-  rc = iso7816_select_file (slot, 0x3F00, 1, NULL, NULL);
-  if (!rc)
-    rc = iso7816_select_file (slot, 0x2F02, 0, NULL, NULL);
-  if (!rc)
-     rc = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
-  if (!rc)
+  /* Try to read the GDO file first to get a default serial number.
+     We skip this if the undefined application has been requested. */
+  if (!want_undefined)
     {
-      size_t n;
-      const unsigned char *p;
-
-      p = find_tlv (result, resultlen, 0x5A, &n);
-      if (p)
-        resultlen -= (p-result);
-      if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
+      err = iso7816_select_file (slot, 0x3F00, 1, NULL, NULL);
+      if (!err)
+        err = iso7816_select_file (slot, 0x2F02, 0, NULL, NULL);
+      if (!err)
+        err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
+      if (!err)
         {
-          /* The object it does not fit into the buffer.  This is an
-             invalid encoding (or the buffer is too short.  However, I
-             have some test cards with such an invalid encoding and
-             therefore I use this ugly workaround to return something
-             I can further experiment with. */
-          log_debug ("enabling BMI testcard workaround\n");
-          n--;
+          size_t n;
+          const unsigned char *p;
+
+          p = find_tlv_unchecked (result, resultlen, 0x5A, &n);
+          if (p)
+            resultlen -= (p-result);
+          if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
+            {
+              /* The object it does not fit into the buffer.  This is an
+                 invalid encoding (or the buffer is too short.  However, I
+                 have some test cards with such an invalid encoding and
+                 therefore I use this ugly workaround to return something
+                 I can further experiment with. */
+              log_info ("enabling BMI testcard workaround\n");
+              n--;
+            }
+
+          if (p && n <= resultlen)
+            {
+              /* The GDO file is pretty short, thus we simply reuse it for
+                 storing the serial number. */
+              memmove (result, p, n);
+              app->serialno = result;
+              app->serialnolen = n;
+              err = app_munge_serialno (app);
+              if (err)
+                goto leave;
+            }
+          else
+            xfree (result);
+          result = NULL;
         }
-
-      if (p && n <= resultlen)
-        {
-          /* The GDO file is pretty short, thus we simply reuse it for
-             storing the serial number. */
-          memmove (result, p, n);
-          app->serialno = result;
-          app->serialnolen = n;
-          rc = app_munge_serialno (app);
-          if (rc)
-            goto leave;
-        }
-      else
-        xfree (result);
-      result = NULL;
     }
 
   /* For certain error codes, there is no need to try more.  */
-  if (gpg_err_code (rc) == GPG_ERR_CARD_NOT_PRESENT)
+  if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT
+      || gpg_err_code (err) == GPG_ERR_ENODEV)
     goto leave;
-  
 
   /* Figure out the application to use.  */
-  rc = gpg_error (GPG_ERR_NOT_FOUND);
-
-  if (rc && is_app_allowed ("openpgp") && (!name || !strcmp (name, "openpgp")))
-    rc = app_select_openpgp (app);
-  if (rc && is_app_allowed ("nks") && (!name || !strcmp (name, "nks")))
-    rc = app_select_nks (app);
-/*   if (rc && is_app_allowed ("p12") && (!name || !strcmp (name, "p12"))) */
-/*     rc = app_select_p12 (app); */
-  if (rc && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
-    rc = app_select_dinsig (app);
-  if (rc && name)
-    rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
+  if (want_undefined)
+    {
+      /* We switch to the "undefined" application only if explicitly
+         requested.  */
+      app->apptype = "UNDEFINED";
+      err = 0;
+    }
+  else
+    err = gpg_error (GPG_ERR_NOT_FOUND);
+
+  if (err && is_app_allowed ("openpgp")
+          && (!name || !strcmp (name, "openpgp")))
+    err = app_select_openpgp (app);
+  if (err && is_app_allowed ("nks") && (!name || !strcmp (name, "nks")))
+    err = app_select_nks (app);
+  if (err && is_app_allowed ("p15") && (!name || !strcmp (name, "p15")))
+    err = app_select_p15 (app);
+  if (err && is_app_allowed ("geldkarte")
+      && (!name || !strcmp (name, "geldkarte")))
+    err = app_select_geldkarte (app);
+  if (err && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
+    err = app_select_dinsig (app);
+  if (err && is_app_allowed ("sc-hsm") && (!name || !strcmp (name, "sc-hsm")))
+    err = app_select_sc_hsm (app);
+  if (err && name && gpg_err_code (err) != GPG_ERR_OBJ_TERM_STATE)
+    err = gpg_error (GPG_ERR_NOT_SUPPORTED);
 
  leave:
-  if (rc)
+  if (err)
     {
       if (name)
-        log_info ("can't select application `%s': %s\n",
-                  name, gpg_strerror (rc));
+        log_info ("can't select application '%s': %s\n",
+                  name, gpg_strerror (err));
       else
         log_info ("no supported card application found: %s\n",
-                  gpg_strerror (rc));
+                  gpg_strerror (err));
       xfree (app);
-      return rc;
+      unlock_reader (slot);
+      return err;
     }
 
-  app->initialized = 1;
+  app->ref_count = 1;
+
+  lock_table[slot].app = app;
   *r_app = app;
+  unlock_reader (slot);
   return 0;
 }
 
 
-void
-release_application (app_t app)
+char *
+get_supported_applications (void)
 {
-  if (!app)
-    return;
+  const char *list[] = {
+    "openpgp",
+    "nks",
+    "p15",
+    "geldkarte",
+    "dinsig",
+    "sc-hsm",
+    /* Note: "undefined" is not listed here because it needs special
+       treatment by the client.  */
+    NULL
+  };
+  int idx;
+  size_t nbytes;
+  char *buffer, *p;
+
+  for (nbytes=1, idx=0; list[idx]; idx++)
+    nbytes += strlen (list[idx]) + 1 + 1;
+
+  buffer = xtrymalloc (nbytes);
+  if (!buffer)
+    return NULL;
+
+  for (p=buffer, idx=0; list[idx]; idx++)
+    if (is_app_allowed (list[idx]))
+      p = stpcpy (stpcpy (p, list[idx]), ":\n");
+  *p = 0;
+
+  return buffer;
+}
 
+
+/* Deallocate the application. */
+static void
+deallocate_app (app_t app)
+{
   if (app->fnc.deinit)
     {
       app->fnc.deinit (app);
@@ -167,36 +439,84 @@ release_application (app_t app)
   xfree (app);
 }
 
+/* Free the resources associated with the application APP.  APP is
+   allowed to be NULL in which case this is a no-op.  Note that we are
+   using reference counting to track the users of the application and
+   actually deferring the deallocation to allow for a later reuse by
+   a new connection. */
+void
+release_application (app_t app)
+{
+  int slot;
+
+  if (!app)
+    return;
+
+  if (!app->ref_count)
+    log_bug ("trying to release an already released context\n");
+  if (--app->ref_count)
+    return;
+
+  /* Move the reference to the application in the lock table. */
+  slot = app->slot;
+  /* FIXME: We are ignoring any error value.  */
+  lock_reader (slot, NULL);
+  if (lock_table[slot].app != app)
+    {
+      unlock_reader (slot);
+      log_bug ("app mismatch %p/%p\n", app, lock_table[slot].app);
+      deallocate_app (app);
+      return;
+    }
+
+  /* We don't deallocate app here.  Instead, we keep it.  This is
+     useful so that a card does not get reset even if only one session
+     is using the card - this way the PIN cache and other cached data
+     are preserved.  */
+  unlock_reader (slot);
+}
+
 
 
 /* The serial number may need some cosmetics.  Do it here.  This
    function shall only be called once after a new serial number has
-   been put into APP->serialno. 
+   been put into APP->serialno.
 
    Prefixes we use:
-   
+
      FF 00 00 = For serial numbers starting with an FF
      FF 01 00 = Some german p15 cards return an empty serial number so the
-                serial number from the EF(TokeInfo is used instead.
-     
+                serial number from the EF(TokenInfo) is used instead.
+     FF 7F 00 = No serialno.
+
      All other serial number not starting with FF are used as they are.
 */
-int
+gpg_error_t
 app_munge_serialno (app_t app)
 {
   if (app->serialnolen && app->serialno[0] == 0xff)
-    { 
+    {
       /* The serial number starts with our special prefix.  This
          requires that we put our default prefix "FF0000" in front. */
       unsigned char *p = xtrymalloc (app->serialnolen + 3);
       if (!p)
-        return gpg_error (gpg_err_code_from_errno (errno));
+        return gpg_error_from_syserror ();
       memcpy (p, "\xff\0", 3);
       memcpy (p+3, app->serialno, app->serialnolen);
       app->serialnolen += 3;
       xfree (app->serialno);
       app->serialno = p;
     }
+  else if (!app->serialnolen)
+    {
+      unsigned char *p = xtrymalloc (3);
+      if (!p)
+        return gpg_error_from_syserror ();
+      memcpy (p, "\xff\x7f", 3);
+      app->serialnolen = 3;
+      xfree (app->serialno);
+      app->serialno = p;
+    }
   return 0;
 }
 
@@ -208,11 +528,10 @@ app_munge_serialno (app_t app)
    no update time is available the returned value is 0.  Caller must
    free SERIAL unless the function returns an error.  If STAMP is not
    of interest, NULL may be passed. */
-int 
+gpg_error_t
 app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
 {
-  unsigned char *buf, *p;
-  int i;
+  char *buf;
 
   if (!app || !serial)
     return gpg_error (GPG_ERR_INV_VALUE);
@@ -221,12 +540,13 @@ app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
   if (stamp)
     *stamp = 0; /* not available */
 
-  buf = xtrymalloc (app->serialnolen * 2 + 1);
+  if (!app->serialnolen)
+    buf = xtrystrdup ("FF7F00");
+  else
+    buf = bin2hex (app->serialno, app->serialnolen, NULL);
   if (!buf)
-    return gpg_error_from_errno (errno);
-  for (p=buf, i=0; i < app->serialnolen; p +=2, i++)
-    sprintf (p, "%02X", app->serialno[i]);
-  *p = 0;
+    return gpg_error_from_syserror ();
+
   *serial = buf;
   return 0;
 }
@@ -234,21 +554,28 @@ app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
 
 /* Write out the application specifig status lines for the LEARN
    command. */
-int
-app_write_learn_status (APP app, CTRL ctrl)
+gpg_error_t
+app_write_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
 {
+  gpg_error_t err;
+
   if (!app)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.learn_status)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
 
-  if (app->apptype)
+  /* We do not send APPTYPE if only keypairinfo is requested.  */
+  if (app->apptype && !(flags & 1))
     send_status_info (ctrl, "APPTYPE",
                       app->apptype, strlen (app->apptype), NULL, 0);
-
-  return app->fnc.learn_status (app, ctrl);
+  err = lock_reader (app->slot, ctrl);
+  if (err)
+    return err;
+  err = app->fnc.learn_status (app, ctrl, flags);
+  unlock_reader (app->slot);
+  return err;
 }
 
 
@@ -256,18 +583,24 @@ app_write_learn_status (APP app, CTRL ctrl)
    the CERTINFO status lines) and return it in the freshly allocated
    buffer put into CERT and the length of the certificate put into
    CERTLEN. */
-int
+gpg_error_t
 app_readcert (app_t app, const char *certid,
               unsigned char **cert, size_t *certlen)
 {
+  gpg_error_t err;
+
   if (!app)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.readcert)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-
-  return app->fnc.readcert (app, certid, cert, certlen);
+  err = lock_reader (app->slot, NULL/* FIXME*/);
+  if (err)
+    return err;
+  err = app->fnc.readcert (app, certid, cert, certlen);
+  unlock_reader (app->slot);
+  return err;
 }
 
 
@@ -278,9 +611,11 @@ app_readcert (app_t app, const char *certid,
    code returned.
 
    This function might not be supported by all applications.  */
-int
+gpg_error_t
 app_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
 {
+  gpg_error_t err;
+
   if (pk)
     *pk = NULL;
   if (pklen)
@@ -288,204 +623,336 @@ app_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
 
   if (!app || !keyid || !pk || !pklen)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.readkey)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-
-  return app->fnc.readkey (app, keyid, pk, pklen);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err= app->fnc.readkey (app, keyid, pk, pklen);
+  unlock_reader (app->slot);
+  return err;
 }
 
 
 /* Perform a GETATTR operation.  */
-int 
-app_getattr (APP app, CTRL ctrl, const char *name)
+gpg_error_t
+app_getattr (app_t app, ctrl_t ctrl, const char *name)
 {
+  gpg_error_t err;
+
   if (!app || !name || !*name)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
+
+  if (app->apptype && name && !strcmp (name, "APPTYPE"))
+    {
+      send_status_info (ctrl, "APPTYPE",
+                        app->apptype, strlen (app->apptype), NULL, 0);
+      return 0;
+    }
+  if (name && !strcmp (name, "SERIALNO"))
+    {
+      char *serial;
+      time_t stamp;
+      int rc;
+
+      rc = app_get_serial_and_stamp (app, &serial, &stamp);
+      if (rc)
+        return rc;
+      send_status_info (ctrl, "SERIALNO", serial, strlen (serial), NULL, 0);
+      xfree (serial);
+      return 0;
+    }
+
   if (!app->fnc.getattr)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  return app->fnc.getattr (app, ctrl, name);
+  err = lock_reader (app->slot, ctrl);
+  if (err)
+    return err;
+  err =  app->fnc.getattr (app, ctrl, name);
+  unlock_reader (app->slot);
+  return err;
 }
 
 /* Perform a SETATTR operation.  */
-int 
-app_setattr (APP app, const char *name,
-             int (*pincb)(void*, const char *, char **),
+gpg_error_t
+app_setattr (app_t app, const char *name,
+             gpg_error_t (*pincb)(void*, const char *, char **),
              void *pincb_arg,
              const unsigned char *value, size_t valuelen)
 {
+  gpg_error_t err;
+
   if (!app || !name || !*name || !value)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.setattr)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  return app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
+  unlock_reader (app->slot);
+  return err;
 }
 
 /* Create the signature and return the allocated result in OUTDATA.
    If a PIN is required the PINCB will be used to ask for the PIN; it
    should return the PIN in an allocated buffer and put it into PIN.  */
-int 
-app_sign (APP app, const char *keyidstr, int hashalgo,
-          int (pincb)(void*, const char *, char **),
+gpg_error_t
+app_sign (app_t app, const char *keyidstr, int hashalgo,
+          gpg_error_t (*pincb)(void*, const char *, char **),
           void *pincb_arg,
           const void *indata, size_t indatalen,
           unsigned char **outdata, size_t *outdatalen )
 {
-  int rc;
+  gpg_error_t err;
 
   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.sign)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  rc = app->fnc.sign (app, keyidstr, hashalgo,
-                      pincb, pincb_arg,
-                      indata, indatalen,
-                      outdata, outdatalen);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err = app->fnc.sign (app, keyidstr, hashalgo,
+                       pincb, pincb_arg,
+                       indata, indatalen,
+                       outdata, outdatalen);
+  unlock_reader (app->slot);
   if (opt.verbose)
-    log_info ("operation sign result: %s\n", gpg_strerror (rc));
-  return rc;
+    log_info ("operation sign result: %s\n", gpg_strerror (err));
+  return err;
 }
 
 /* Create the signature using the INTERNAL AUTHENTICATE command and
    return the allocated result in OUTDATA.  If a PIN is required the
    PINCB will be used to ask for the PIN; it should return the PIN in
    an allocated buffer and put it into PIN.  */
-int 
-app_auth (APP app, const char *keyidstr,
-          int (pincb)(void*, const char *, char **),
+gpg_error_t
+app_auth (app_t app, const char *keyidstr,
+          gpg_error_t (*pincb)(void*, const char *, char **),
           void *pincb_arg,
           const void *indata, size_t indatalen,
           unsigned char **outdata, size_t *outdatalen )
 {
-  int rc;
+  gpg_error_t err;
 
   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.auth)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  rc = app->fnc.auth (app, keyidstr,
-                      pincb, pincb_arg,
-                      indata, indatalen,
-                      outdata, outdatalen);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err = app->fnc.auth (app, keyidstr,
+                       pincb, pincb_arg,
+                       indata, indatalen,
+                       outdata, outdatalen);
+  unlock_reader (app->slot);
   if (opt.verbose)
-    log_info ("operation auth result: %s\n", gpg_strerror (rc));
-  return rc;
+    log_info ("operation auth result: %s\n", gpg_strerror (err));
+  return err;
 }
 
 
 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
    If a PIN is required the PINCB will be used to ask for the PIN; it
    should return the PIN in an allocated buffer and put it into PIN.  */
-int 
-app_decipher (APP app, const char *keyidstr,
-              int (pincb)(void*, const char *, char **),
+gpg_error_t
+app_decipher (app_t app, const char *keyidstr,
+              gpg_error_t (*pincb)(void*, const char *, char **),
               void *pincb_arg,
               const void *indata, size_t indatalen,
-              unsigned char **outdata, size_t *outdatalen )
+              unsigned char **outdata, size_t *outdatalen,
+              unsigned int *r_info)
 {
-  int rc;
+  gpg_error_t err;
+
+  *r_info = 0;
 
   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.decipher)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  rc = app->fnc.decipher (app, keyidstr,
-                          pincb, pincb_arg,
-                          indata, indatalen,
-                          outdata, outdatalen);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err = app->fnc.decipher (app, keyidstr,
+                           pincb, pincb_arg,
+                           indata, indatalen,
+                           outdata, outdatalen,
+                           r_info);
+  unlock_reader (app->slot);
+  if (opt.verbose)
+    log_info ("operation decipher result: %s\n", gpg_strerror (err));
+  return err;
+}
+
+
+/* Perform the WRITECERT operation.  */
+gpg_error_t
+app_writecert (app_t app, ctrl_t ctrl,
+              const char *certidstr,
+              gpg_error_t (*pincb)(void*, const char *, char **),
+              void *pincb_arg,
+              const unsigned char *data, size_t datalen)
+{
+  gpg_error_t err;
+
+  if (!app || !certidstr || !*certidstr || !pincb)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  if (!app->ref_count)
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
+  if (!app->fnc.writecert)
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+  err = lock_reader (app->slot, ctrl);
+  if (err)
+    return err;
+  err = app->fnc.writecert (app, ctrl, certidstr,
+                            pincb, pincb_arg, data, datalen);
+  unlock_reader (app->slot);
+  if (opt.verbose)
+    log_info ("operation writecert result: %s\n", gpg_strerror (err));
+  return err;
+}
+
+
+/* Perform the WRITEKEY operation.  */
+gpg_error_t
+app_writekey (app_t app, ctrl_t ctrl,
+              const char *keyidstr, unsigned int flags,
+              gpg_error_t (*pincb)(void*, const char *, char **),
+              void *pincb_arg,
+              const unsigned char *keydata, size_t keydatalen)
+{
+  gpg_error_t err;
+
+  if (!app || !keyidstr || !*keyidstr || !pincb)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  if (!app->ref_count)
+    return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
+  if (!app->fnc.writekey)
+    return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+  err = lock_reader (app->slot, ctrl);
+  if (err)
+    return err;
+  err = app->fnc.writekey (app, ctrl, keyidstr, flags,
+                           pincb, pincb_arg, keydata, keydatalen);
+  unlock_reader (app->slot);
   if (opt.verbose)
-    log_info ("operation decipher result: %s\n", gpg_strerror (rc));
-  return rc;
+    log_info ("operation writekey result: %s\n", gpg_strerror (err));
+  return err;
 }
 
 
 /* Perform a SETATTR operation.  */
-int 
-app_genkey (APP app, CTRL ctrl, const char *keynostr, unsigned int flags,
-            int (*pincb)(void*, const char *, char **),
+gpg_error_t
+app_genkey (app_t app, ctrl_t ctrl, const char *keynostr, unsigned int flags,
+            time_t createtime,
+            gpg_error_t (*pincb)(void*, const char *, char **),
             void *pincb_arg)
 {
-  int rc;
+  gpg_error_t err;
 
   if (!app || !keynostr || !*keynostr || !pincb)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.genkey)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  rc = app->fnc.genkey (app, ctrl, keynostr, flags, pincb, pincb_arg);
+  err = lock_reader (app->slot, ctrl);
+  if (err)
+    return err;
+  err = app->fnc.genkey (app, ctrl, keynostr, flags,
+                         createtime, pincb, pincb_arg);
+  unlock_reader (app->slot);
   if (opt.verbose)
-    log_info ("operation genkey result: %s\n", gpg_strerror (rc));
-  return rc;
+    log_info ("operation genkey result: %s\n", gpg_strerror (err));
+  return err;
 }
 
 
-/* Perform a GET CHALLENGE operation.  This fucntion is special as it
+/* Perform a GET CHALLENGE operation.  This function is special as it
    directly accesses the card without any application specific
    wrapper. */
-int
-app_get_challenge (APP app, size_t nbytes, unsigned char *buffer)
+gpg_error_t
+app_get_challenge (app_t app, size_t nbytes, unsigned char *buffer)
 {
+  gpg_error_t err;
+
   if (!app || !nbytes || !buffer)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
-  return iso7816_get_challenge (app->slot, nbytes, buffer);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err = iso7816_get_challenge (app->slot, nbytes, buffer);
+  unlock_reader (app->slot);
+  return err;
 }
 
 
 
 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
-int 
-app_change_pin (APP app, CTRL ctrl, const char *chvnostr, int reset_mode,
-                int (*pincb)(void*, const char *, char **),
+gpg_error_t
+app_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr, int reset_mode,
+                gpg_error_t (*pincb)(void*, const char *, char **),
                 void *pincb_arg)
 {
-  int rc;
+  gpg_error_t err;
 
   if (!app || !chvnostr || !*chvnostr || !pincb)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.change_pin)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  rc = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode, pincb, pincb_arg);
+  err = lock_reader (app->slot, ctrl);
+  if (err)
+    return err;
+  err = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode,
+                             pincb, pincb_arg);
+  unlock_reader (app->slot);
   if (opt.verbose)
-    log_info ("operation change_pin result: %s\n", gpg_strerror (rc));
-  return rc;
+    log_info ("operation change_pin result: %s\n", gpg_strerror (err));
+  return err;
 }
 
 
 /* Perform a VERIFY operation without doing anything lese.  This may
-   be used to initialze a the PION cache for long lasting other
+   be used to initialze a the PIN cache for long lasting other
    operations.  Its use is highly application dependent. */
-int 
-app_check_pin (APP app, const char *keyidstr,
-               int (*pincb)(void*, const char *, char **),
+gpg_error_t
+app_check_pin (app_t app, const char *keyidstr,
+               gpg_error_t (*pincb)(void*, const char *, char **),
                void *pincb_arg)
 {
-  int rc;
+  gpg_error_t err;
 
   if (!app || !keyidstr || !*keyidstr || !pincb)
     return gpg_error (GPG_ERR_INV_VALUE);
-  if (!app->initialized)
+  if (!app->ref_count)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!app->fnc.check_pin)
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
-  rc = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
+  err = lock_reader (app->slot, NULL /*FIXME*/);
+  if (err)
+    return err;
+  err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
+  unlock_reader (app->slot);
   if (opt.verbose)
-    log_info ("operation check_pin result: %s\n", gpg_strerror (rc));
-  return rc;
+    log_info ("operation check_pin result: %s\n", gpg_strerror (err));
+  return err;
 }
-