s/AES/AES128/ in diagnostics and --list-config
[gnupg.git] / agent / command.c
index 9c2b8b7..8ae313e 100644 (file)
@@ -1,6 +1,6 @@
 /* command.c - gpg-agent command handler
  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
- *               2006, 2008  Free Software Foundation, Inc.
+ *               2006, 2008, 2009, 2010  Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <ctype.h>
 #include <unistd.h>
 #include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
 
+#include "agent.h"
 #include <assuan.h>
+#include "i18n.h"
+#include "cvt-openpgp.h"
 
-#include "agent.h"
 
-/* maximum allowed size of the inquired ciphertext */
+/* Maximum allowed size of the inquired ciphertext.  */
 #define MAXLEN_CIPHERTEXT 4096
-/* maximum allowed size of the key parameters */
+/* Maximum allowed size of the key parameters.  */
 #define MAXLEN_KEYPARAM 1024
+/* Maximum allowed size of key data as used in inquiries (bytes). */
+#define MAXLEN_KEYDATA 4096
+/* The size of the import/export KEK key (in bytes).  */
+#define KEYWRAP_KEYSIZE (128/8)
 
 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
 
@@ -56,12 +65,15 @@ struct server_local_s
   char *keydesc;  /* Allocated description for the next key
                      operation. */
   int pause_io_logging; /* Used to suppress I/O logging during a command */
-#ifdef HAVE_W32_SYSTEM
   int stopme;    /* If set to true the agent will be terminated after
                     the end of this session.  */
-#endif
   int allow_pinentry_notify; /* Set if pinentry notifications should
                                 be done. */
+  void *import_key;  /* Malloced KEK for the import_key command.  */
+  void *export_key;  /* Malloced KEK for the export_key command.  */
+  int allow_fully_canceled; /* Client is aware of GPG_ERR_FULLY_CANCELED.  */
+  char *last_cache_nonce;   /* Last CACHE_NOCNE sent as status (malloced).  */
+  char *last_passwd_nonce;  /* Last PASSWD_NOCNE sent as status (malloced). */
 };
 
 
@@ -80,7 +92,7 @@ static struct putval_item_s *putval_list;
 
 
 \f
-/* To help polling clients, we keep tarck of the number of certain
+/* To help polling clients, we keep track of the number of certain
    events.  This structure keeps those counters.  The counters are
    integers and there should be no problem if they are overflowing as
    callers need to check only whether a counter changed.  The actual
@@ -101,6 +113,10 @@ struct
 } eventcounter;
 
 
+\f
+/*  Local prototypes.  */
+static int command_has_option (const char *cmd, const char *cmdopt);
+
 
 
 \f
@@ -125,7 +141,7 @@ clear_outbuf (membuf_t *mb)
 static gpg_error_t
 write_and_clear_outbuf (assuan_context_t ctx, membuf_t *mb)
 {
-  assuan_error_t ae;
+  gpg_error_t ae;
   void *p;
   size_t n;
 
@@ -140,19 +156,62 @@ write_and_clear_outbuf (assuan_context_t ctx, membuf_t *mb)
 
 
 static void
-reset_notify (assuan_context_t ctx)
+clear_nonce_cache (ctrl_t ctrl)
+{
+  if (ctrl->server_local->last_cache_nonce)
+    {
+      agent_put_cache (ctrl->server_local->last_cache_nonce,
+                       CACHE_MODE_NONCE, NULL, 0);
+      xfree (ctrl->server_local->last_cache_nonce);
+      ctrl->server_local->last_cache_nonce = NULL;
+    }
+  if (ctrl->server_local->last_passwd_nonce)
+    {
+      agent_put_cache (ctrl->server_local->last_passwd_nonce,
+                       CACHE_MODE_NONCE, NULL, 0);
+      xfree (ctrl->server_local->last_passwd_nonce);
+      ctrl->server_local->last_passwd_nonce = NULL;
+    }
+}
+
+
+static gpg_error_t
+reset_notify (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
 
+  (void) line;
+
   memset (ctrl->keygrip, 0, 20);
   ctrl->have_keygrip = 0;
   ctrl->digest.valuelen = 0;
 
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = NULL;
+
+  clear_nonce_cache (ctrl);
+
+  return 0;
 }
 
 
+/* Skip over options.  
+   Blanks after the options are also removed. */
+static char *
+skip_options (const char *line)
+{
+  while (spacep (line))
+    line++;
+  while ( *line == '-' && line[1] == '-' )
+    {
+      while (*line && !spacep (line))
+        line++;
+      while (spacep (line))
+        line++;
+    }
+  return (char*)line;
+}
+
 /* Check whether the option NAME appears in LINE */
 static int
 has_option (const char *line, const char *name)
@@ -161,6 +220,8 @@ has_option (const char *line, const char *name)
   int n = strlen (name);
 
   s = strstr (line, name);
+  if (s && s >= skip_options (line))
+    return 0;
   return (s && (s == line || spacep (s-1)) && (!s[n] || spacep (s+n)));
 }
 
@@ -174,25 +235,32 @@ has_option_name (const char *line, const char *name)
   int n = strlen (name);
 
   s = strstr (line, name);
+  if (s && s >= skip_options (line))
+    return 0;
   return (s && (s == line || spacep (s-1))
           && (!s[n] || spacep (s+n) || s[n] == '='));
 }
 
-
-/* Skip over options.  It is assumed that leading spaces have been
-   removed (this is the case for lines passed to a handler from
-   assuan).  Blanks after the options are also removed. */
+/* Return a pointer to the argument of the option with NAME.  If such
+   an option is not given, it returns NULL. */
 static char *
-skip_options (char *line)
+option_value (const char *line, const char *name)
 {
-  while ( *line == '-' && line[1] == '-' )
+  char *s;
+  int n = strlen (name);
+
+  s = strstr (line, name);
+  if (s && s >= skip_options (line))
+    return NULL;
+  if (s && (s == line || spacep (s-1))
+      && s[n] && (spacep (s+n) || s[n] == '='))
     {
-      while (*line && !spacep (line))
-        line++;
-      while (spacep (line))
-        line++;
+      s += n + 1;
+      s += strspn (s, " ");
+      if (*s && !spacep(s))
+        return s;
     }
-  return line;
+  return NULL;
 }
 
 
@@ -208,42 +276,6 @@ plus_to_blank (char *s)
 }
 
 
-/* Do the percent and plus/space unescaping in place and return the
-   length of the valid buffer. */
-static size_t
-percent_plus_unescape (char *string)
-{
-  unsigned char *p = (unsigned char *)string;
-  size_t n = 0;
-
-  while (*string)
-    {
-      if (*string == '%' && string[1] && string[2])
-        { 
-          string++;
-          *p++ = xtoi_2 (string);
-          n++;
-          string+= 2;
-        }
-      else if (*string == '+')
-        {
-          *p++ = ' ';
-          n++;
-          string++;
-        }
-      else
-        {
-          *p++ = *string++;
-          n++;
-        }
-    }
-
-  return n;
-}
-
-
-
-
 /* Parse a hex string.  Return an Assuan error code or 0 on success and the
    length of the parsed string in LEN. */
 static int
@@ -270,8 +302,7 @@ static int
 parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
 {
   int rc;
-  size_t n;
-  const unsigned char *p;
+  size_t n = 0;
 
   rc = parse_hexstring (ctx, string, &n);
   if (rc)
@@ -280,8 +311,8 @@ parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
   if (n != 20)
     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of keygrip");
 
-  for (p=(const unsigned char*)string, n=0; n < 20; p += 2, n++)
-    buf[n] = xtoi_2 (p);
+  if (hex2bin (string, buf, 20) < 0)
+    return set_error (GPG_ERR_BUG, "hex2bin");
 
   return 0;
 }
@@ -309,8 +340,21 @@ agent_write_status (ctrl_t ctrl, const char *keyword, ...)
           *p++ = ' ';
           n++;
         }
-      for ( ; *text && n < DIM (buf)-2; n++)
-        *p++ = *text++;
+      for ( ; *text && n < DIM (buf)-3; n++, text++)
+        {
+          if (*text == '\n')
+            {
+              *p++ = '\\';
+              *p++ = 'n';
+            }
+          else if (*text == '\r')
+            {
+              *p++ = '\\';
+              *p++ = 'r';
+            }
+          else
+            *p++ = *text;
+        }
     }
   *p = 0;
   err = assuan_write_status (ctx, keyword, buf);
@@ -320,9 +364,9 @@ agent_write_status (ctrl_t ctrl, const char *keyword, ...)
 }
 
 
-/* Helper to notify the client about a lauchned Pinentry.  Because
-   that might disturb some older clients, this is only done when
-   enabled via an option.  Returns an gpg error code. */
+/* Helper to notify the client about a launched Pinentry.  Because
+   that might disturb some older clients, this is only done if enabled
+   via an option.  Returns an gpg error code. */
 gpg_error_t
 agent_inq_pinentry_launched (ctrl_t ctrl, unsigned long pid)
 {
@@ -336,21 +380,57 @@ agent_inq_pinentry_launched (ctrl_t ctrl, unsigned long pid)
 }
 
 
-\f
-/* GETEVENTCOUNTER
+/* Helper to print a message while leaving a command.  */
+static gpg_error_t
+leave_cmd (assuan_context_t ctx, gpg_error_t err)
+{
+  if (err)
+    {
+      const char *name = assuan_get_command_name (ctx);
+      if (!name)
+        name = "?";
+
+      /* Not all users of gpg-agent know about the fully canceled
+         error code; map it back if needed.  */
+      if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
+        {
+          ctrl_t ctrl = assuan_get_pointer (ctx);
 
-   Return a a status line named EVENTCOUNTER with the current values
-   of all event counters.  The values are decimal numbers in the range
-   0 to UINT_MAX and wrapping around to 0.  The actual values should
-   not be relied upon, they shall only be used to detect a change.
+          if (!ctrl->server_local->allow_fully_canceled)
+            err = gpg_err_make (gpg_err_source (err), GPG_ERR_CANCELED);
+        }
 
-   The currently defined counters are:
+      /* Most code from common/ does not know the error source, thus
+         we fix this here.  */
+      if (gpg_err_source (err) == GPG_ERR_SOURCE_UNKNOWN)
+        err = gpg_err_make (GPG_ERR_SOURCE_DEFAULT, gpg_err_code (err));
 
-   ANY  - Incremented with any change of any of the other counters.
-   KEY  - Incremented for added or removed private keys.
-   CARD - Incremented for changes of the card readers stati.
-*/
-static int
+      if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
+        log_error ("command '%s' failed: %s\n", name,
+                   gpg_strerror (err));
+      else
+        log_error ("command '%s' failed: %s <%s>\n", name,
+                   gpg_strerror (err), gpg_strsource (err));
+    }
+  return err;
+}
+
+
+\f
+static const char hlp_geteventcounter[] = 
+  "GETEVENTCOUNTER\n"
+  "\n"
+  "Return a a status line named EVENTCOUNTER with the current values\n"
+  "of all event counters.  The values are decimal numbers in the range\n"
+  "0 to UINT_MAX and wrapping around to 0.  The actual values should\n"
+  "not be relied upon, they shall only be used to detect a change.\n"
+  "\n"
+  "The currently defined counters are:\n"
+  "\n"
+  "ANY  - Incremented with any change of any of the other counters.\n"
+  "KEY  - Incremented for added or removed private keys.\n"
+  "CARD - Incremented for changes of the card readers stati.";
+static gpg_error_t
 cmd_geteventcounter (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -358,6 +438,8 @@ cmd_geteventcounter (assuan_context_t ctx, char *line)
   char key_counter[25];
   char card_counter[25];
 
+  (void)line;
+
   snprintf (any_counter, sizeof any_counter, "%u", eventcounter.any);
   snprintf (key_counter, sizeof key_counter, "%u", eventcounter.key);
   snprintf (card_counter, sizeof card_counter, "%u", eventcounter.card);
@@ -393,11 +475,12 @@ bump_card_eventcounter (void)
 
 
 \f
-/* ISTRUSTED <hexstring_with_fingerprint>
-
-   Return OK when we have an entry with this fingerprint in our
-   trustlist */
-static int
+static const char hlp_istrusted[] = 
+  "ISTRUSTED <hexstring_with_fingerprint>\n"
+  "\n"
+  "Return OK when we have an entry with this fingerprint in our\n"
+  "trustlist";
+static gpg_error_t
 cmd_istrusted (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -419,35 +502,37 @@ cmd_istrusted (assuan_context_t ctx, char *line)
   for (p=line; i < 40; p++, i++)
     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
   fpr[i] = 0;
-  rc = agent_istrusted (ctrl, fpr);
+  rc = agent_istrusted (ctrl, fpr, NULL);
   if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
     return rc;
   else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF )
     return gpg_error (GPG_ERR_NOT_TRUSTED);
   else
-    {
-      log_error ("command is_trusted failed: %s\n", gpg_strerror (rc));
-      return rc;
-    }
+    return leave_cmd (ctx, rc);
 }
 
-/* LISTTRUSTED 
 
-   List all entries from the trustlist */
-static int
+static const char hlp_listtrusted[] = 
+  "LISTTRUSTED\n"
+  "\n"
+  "List all entries from the trustlist.";
+static gpg_error_t
 cmd_listtrusted (assuan_context_t ctx, char *line)
 {
-  int rc = agent_listtrusted (ctx);
-  if (rc)
-    log_error ("command listtrusted failed: %s\n", gpg_strerror (rc));
-  return rc;
-}
+  int rc;
+  
+  (void)line;
 
+  rc = agent_listtrusted (ctx);
+  return leave_cmd (ctx, rc);
+}
 
-/* MARKTRUSTED <hexstring_with_fingerprint> <flag> <display_name>
 
-   Store a new key in into the trustlist*/
-static int
+static const char hlp_martrusted[] = 
+  "MARKTRUSTED <hexstring_with_fingerprint> <flag> <display_name>\n"
+  "\n"
+  "Store a new key in into the trustlist.";
+static gpg_error_t
 cmd_marktrusted (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -480,39 +565,51 @@ cmd_marktrusted (assuan_context_t ctx, char *line)
     p++;
 
   rc = agent_marktrusted (ctrl, p, fpr, flag);
-  if (rc)
-    log_error ("command marktrusted failed: %s\n", gpg_strerror (rc));
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
 
 
 \f
-/* HAVEKEY <hexstring_with_keygrip>
-  
-   Return success when the secret key is available */
-static int
+static const char hlp_havekey[] =
+  "HAVEKEY <hexstrings_with_keygrips>\n"
+  "\n"
+  "Return success if at least one of the secret keys with the given\n"
+  "keygrips is available.";
+static gpg_error_t
 cmd_havekey (assuan_context_t ctx, char *line)
 {
-  int rc;
+  gpg_error_t err;
   unsigned char buf[20];
 
-  rc = parse_keygrip (ctx, line, buf);
-  if (rc)
-    return rc;
-
-  if (agent_key_available (buf))
-    return gpg_error (GPG_ERR_NO_SECKEY);
+  do 
+    {
+      err = parse_keygrip (ctx, line, buf);
+      if (err)
+        return err;
+      
+      if (!agent_key_available (buf))
+        return 0; /* Found.  */
 
-  return 0;
+      while (*line && *line != ' ' && *line != '\t')
+        line++;
+      while (*line == ' ' || *line == '\t')
+        line++;
+    }
+  while (*line);
+    
+  /* No leave_cmd() here because errors are expected and would clutter
+     the log.  */
+  return gpg_error (GPG_ERR_NO_SECKEY);
 }
 
 
-/* SIGKEY <hexstring_with_keygrip>
-   SETKEY <hexstring_with_keygrip>
-  
-   Set the  key used for a sign or decrypt operation */
-static int
+static const char hlp_sigkey[] =
+  "SIGKEY <hexstring_with_keygrip>\n"
+  "SETKEY <hexstring_with_keygrip>\n"
+  "\n"
+  "Set the  key used for a sign or decrypt operation.";
+static gpg_error_t
 cmd_sigkey (assuan_context_t ctx, char *line)
 {
   int rc;
@@ -526,21 +623,21 @@ cmd_sigkey (assuan_context_t ctx, char *line)
 }
 
 
-/* SETKEYDESC plus_percent_escaped_string
-
-   Set a description to be used for the next PKSIGN or PKDECRYPT
-   operation if this operation requires the entry of a passphrase.  If
-   this command is not used a default text will be used.  Note, that
-   this description implictly selects the label used for the entry
-   box; if the string contains the string PIN (which in general will
-   not be translated), "PIN" is used, otherwise the translation of
-   "passphrase" is used.  The description string should not contain
-   blanks unless they are percent or '+' escaped.
-
-   The description is only valid for the next PKSIGN or PKDECRYPT
-   operation.
-*/
-static int
+static const char hlp_setkeydesc[] = 
+  "SETKEYDESC plus_percent_escaped_string\n"
+  "\n"
+  "Set a description to be used for the next PKSIGN, PKDECRYPT, IMPORT_KEY\n"
+  "or EXPORT_KEY operation if this operation requires a passphrase.  If\n"
+  "this command is not used a default text will be used.  Note, that\n"
+  "this description implictly selects the label used for the entry\n"
+  "box; if the string contains the string PIN (which in general will\n"
+  "not be translated), \"PIN\" is used, otherwise the translation of\n"
+  "\"passphrase\" is used.  The description string should not contain\n"
+  "blanks unless they are percent or '+' escaped.\n"
+  "\n"
+  "The description is only valid for the next PKSIGN, PKDECRYPT,\n"
+  "IMPORT_KEY or EXPORT_KEY operation.";
+static gpg_error_t
 cmd_setkeydesc (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -570,11 +667,12 @@ cmd_setkeydesc (assuan_context_t ctx, char *line)
 }
 
 
-/* SETHASH --hash=<name>|<algonumber> <hexstring> 
-
-  The client can use this command to tell the server about the data
-  (which usually is a hash) to be signed. */
-static int
+static const char hlp_sethash[] =
+  "SETHASH (--hash=<name>)|(<algonumber>) <hexstring>\n"
+  "\n"
+  "The client can use this command to tell the server about the data\n"
+  "(which usually is a hash) to be signed.";
+static gpg_error_t
 cmd_sethash (assuan_context_t ctx, char *line)
 {
   int rc;
@@ -591,14 +689,20 @@ cmd_sethash (assuan_context_t ctx, char *line)
     {
       if (has_option (line, "--hash=sha1"))
         algo = GCRY_MD_SHA1;
+      else if (has_option (line, "--hash=sha224"))
+        algo = GCRY_MD_SHA224;
       else if (has_option (line, "--hash=sha256"))
         algo = GCRY_MD_SHA256;
+      else if (has_option (line, "--hash=sha384"))
+        algo = GCRY_MD_SHA384;
+      else if (has_option (line, "--hash=sha512"))
+        algo = GCRY_MD_SHA512;
       else if (has_option (line, "--hash=rmd160"))
         algo = GCRY_MD_RMD160;
       else if (has_option (line, "--hash=md5"))
         algo = GCRY_MD_MD5;
       else if (has_option (line, "--hash=tls-md5sha1"))
-        algo = GCRY_MD_USER_TLS_MD5SHA1;
+        algo = MD_USER_TLS_MD5SHA1;
       else
         return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
     }
@@ -617,15 +721,18 @@ cmd_sethash (assuan_context_t ctx, char *line)
         return set_error (GPG_ERR_UNSUPPORTED_ALGORITHM, NULL);
     }
   ctrl->digest.algo = algo;
+  ctrl->digest.raw_value = 0;
 
   /* Parse the hash value. */
+  n = 0;
   rc = parse_hexstring (ctx, line, &n);
   if (rc)
     return rc;
   n /= 2;
-  if (algo == GCRY_MD_USER_TLS_MD5SHA1 && n == 36)
+  if (algo == MD_USER_TLS_MD5SHA1 && n == 36)
     ;
-  else if (n != 16 && n != 20 && n != 24 && n != 32)
+  else if (n != 16 && n != 20 && n != 24 
+           && n != 28 && n != 32 && n != 48 && n != 64)
     return set_error (GPG_ERR_ASS_PARAMETER, "unsupported length of hash");
 
   if (n > MAX_DIGEST_LEN)
@@ -641,18 +748,30 @@ cmd_sethash (assuan_context_t ctx, char *line)
 }
 
 
-/* PKSIGN <options>
-
-   Perform the actual sign operation. Neither input nor output are
-   sensitive to eavesdropping. */
-static int
+static const char hlp_pksign[] = 
+  "PKSIGN [<options>] [<cache_nonce>]\n"
+  "\n"
+  "Perform the actual sign operation.  Neither input nor output are\n"
+  "sensitive to eavesdropping.";
+static gpg_error_t
 cmd_pksign (assuan_context_t ctx, char *line)
 {
   int rc;
   cache_mode_t cache_mode = CACHE_MODE_NORMAL;
   ctrl_t ctrl = assuan_get_pointer (ctx);
   membuf_t outbuf;
+  char *cache_nonce = NULL;
+  char *p;
+  
+  line = skip_options (line);
   
+  p = line;
+  for (p=line; *p && *p != ' ' && *p != '\t'; p++)
+    ;
+  *p = '\0';
+  if (*line)
+    cache_nonce = xtrystrdup (line);
+
   if (opt.ignore_cache_for_signing)
     cache_mode = CACHE_MODE_IGNORE;
   else if (!ctrl->server_local->use_cache_for_signing)
@@ -660,24 +779,26 @@ cmd_pksign (assuan_context_t ctx, char *line)
 
   init_membuf (&outbuf, 512);
 
-  rc = agent_pksign (ctrl, ctrl->server_local->keydesc,
+  rc = agent_pksign (ctrl, cache_nonce, ctrl->server_local->keydesc,
                      &outbuf, cache_mode);
   if (rc)
     clear_outbuf (&outbuf);
   else
     rc = write_and_clear_outbuf (ctx, &outbuf);
-  if (rc)
-    log_error ("command pksign failed: %s\n", gpg_strerror (rc));
+
+  xfree (cache_nonce);
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = NULL;
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
-/* PKDECRYPT <options>
 
-   Perform the actual decrypt operation.  Input is not 
-   sensitive to eavesdropping */
-static int
+static const char hlp_pkdecrypt[] = 
+  "PKDECRYPT [<options>]\n"
+  "\n"
+  "Perform the actual decrypt operation.  Input is not\n"
+  "sensitive to eavesdropping.";
+static gpg_error_t
 cmd_pkdecrypt (assuan_context_t ctx, char *line)
 {
   int rc;
@@ -686,6 +807,8 @@ cmd_pkdecrypt (assuan_context_t ctx, char *line)
   size_t valuelen;
   membuf_t outbuf;
 
+  (void)line;
+
   /* First inquire the data to decrypt */
   rc = assuan_inquire (ctx, "CIPHERTEXT",
                        &value, &valuelen, MAXLEN_CIPHERTEXT);
@@ -701,36 +824,47 @@ cmd_pkdecrypt (assuan_context_t ctx, char *line)
     clear_outbuf (&outbuf);
   else
     rc = write_and_clear_outbuf (ctx, &outbuf);
-  if (rc)
-    log_error ("command pkdecrypt failed: %s\n", gpg_strerror (rc));
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = NULL;
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
 
-/* GENKEY
-
-   Generate a new key, store the secret part and return the public
-   part.  Here is an example transaction:
-
-   C: GENKEY
-   S: INQUIRE KEYPARAM
-   C: D (genkey (rsa (nbits  1024)))
-   C: END
-   S: D (public-key
-   S: D   (rsa (n 326487324683264) (e 10001)))
-   S  OK key created
-*/
-
-static int
+static const char hlp_genkey[] = 
+  "GENKEY [--no-protection] [<cache_nonce>]\n"
+  "\n"
+  "Generate a new key, store the secret part and return the public\n"
+  "part.  Here is an example transaction:\n"
+  "\n"
+  "  C: GENKEY\n"
+  "  S: INQUIRE KEYPARAM\n"
+  "  C: D (genkey (rsa (nbits  1024)))\n"
+  "  C: END\n"
+  "  S: D (public-key\n"
+  "  S: D   (rsa (n 326487324683264) (e 10001)))\n"
+  "  S: OK key created\n"
+  "\n";
+static gpg_error_t
 cmd_genkey (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
+  int no_protection;
   unsigned char *value;
   size_t valuelen;
   membuf_t outbuf;
+  char *cache_nonce = NULL;
+  char *p;
+  
+  no_protection = has_option (line, "--no-protection");
+  line = skip_options (line);
+
+  p = line;
+  for (p=line; *p && *p != ' ' && *p != '\t'; p++)
+    ;
+  *p = '\0';
+  if (*line)
+    cache_nonce = xtrystrdup (line);
 
   /* First inquire the parameters */
   rc = assuan_inquire (ctx, "KEYPARAM", &value, &valuelen, MAXLEN_KEYPARAM);
@@ -739,24 +873,25 @@ cmd_genkey (assuan_context_t ctx, char *line)
 
   init_membuf (&outbuf, 512);
 
-  rc = agent_genkey (ctrl, (char*)value, valuelen, &outbuf);
+  rc = agent_genkey (ctrl, cache_nonce, (char*)value, valuelen, no_protection,
+                     &outbuf);
   xfree (value);
   if (rc)
     clear_outbuf (&outbuf);
   else
     rc = write_and_clear_outbuf (ctx, &outbuf);
-  if (rc)
-    log_error ("command genkey failed: %s\n", gpg_strerror (rc));
-  return rc;
+  xfree (cache_nonce);
+  return leave_cmd (ctx, rc);
 }
 
 
 
 \f
-/* READKEY <hexstring_with_keygrip>
-  
-   Return the public key for the given keygrip.  */
-static int
+static const char hlp_readkey[] = 
+  "READKEY <hexstring_with_keygrip>\n"
+  "\n"
+  "Return the public key for the given keygrip.";
+static gpg_error_t
 cmd_readkey (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -789,13 +924,149 @@ cmd_readkey (assuan_context_t ctx, char *line)
       gcry_sexp_release (s_pkey);
     }
 
-  if (rc)
-    log_error ("command readkey failed: %s\n", gpg_strerror (rc));
-  return rc;
+  return leave_cmd (ctx, rc);
+}
+
+
+\f
+static const char hlp_keyinfo[] = 
+  "KEYINFO [--list] <keygrip>\n"
+  "\n"
+  "Return information about the key specified by the KEYGRIP.  If the\n"
+  "key is not available GPG_ERR_NOT_FOUND is returned.  If the option\n"
+  "--list is given the keygrip is ignored and information about all\n"
+  "available keys are returned.  The information is returned as a\n"
+  "status line with this format:\n"
+  "\n"
+  "  KEYINFO <keygrip> <type> <serialno> <idstr>\n"
+  "\n"
+  "KEYGRIP is the keygrip.\n"
+  "\n"
+  "TYPE is describes the type of the key:\n"
+  "    'D' - Regular key stored on disk,\n"
+  "    'T' - Key is stored on a smartcard (token),\n"
+  "    '-' - Unknown type.\n"
+  "\n"
+  "SERIALNO is an ASCII string with the serial number of the\n"
+  "         smartcard.  If the serial number is not known a single\n"
+  "         dash '-' is used instead.\n"
+  "\n"
+  "IDSTR is the IDSTR used to distinguish keys on a smartcard.  If it\n"
+  "      is not known a dash is used instead.\n"
+  "\n"
+  "More information may be added in the future.";
+static gpg_error_t
+do_one_keyinfo (ctrl_t ctrl, const unsigned char *grip)
+{
+  gpg_error_t err;
+  char hexgrip[40+1];
+  int keytype;
+  unsigned char *shadow_info = NULL;
+  char *serialno = NULL;
+  char *idstr = NULL;
+  const char *keytypestr;
+
+  err = agent_key_info_from_file (ctrl, grip, &keytype, &shadow_info);
+  if (err)
+    goto leave;
+
+  /* Reformat the grip so that we use uppercase as good style. */
+  bin2hex (grip, 20, hexgrip);
+      
+  if (keytype == PRIVATE_KEY_CLEAR 
+      || keytype == PRIVATE_KEY_PROTECTED)
+    keytypestr = "D";
+  else if (keytype == PRIVATE_KEY_SHADOWED)
+    keytypestr = "T";
+  else 
+    keytypestr = "-";
+      
+  if (shadow_info)
+    {
+      err = parse_shadow_info (shadow_info, &serialno, &idstr);
+      if (err)
+        goto leave;
+    }
+      
+  err = agent_write_status (ctrl, "KEYINFO",
+                            hexgrip,
+                            keytypestr,
+                            serialno? serialno : "-",
+                            idstr? idstr : "-",
+                            NULL);
+ leave:
+  xfree (shadow_info);
+  xfree (serialno);
+  xfree (idstr);
+  return err;
 }
 
 
+static gpg_error_t
+cmd_keyinfo (assuan_context_t ctx, char *line)
+{
+  ctrl_t ctrl = assuan_get_pointer (ctx);
+  int err;
+  unsigned char grip[20];
+  DIR *dir = NULL;
+  int list_mode;
+
+  list_mode = has_option (line, "--list");
+  line = skip_options (line);
+
+  if (list_mode)
+    {
+      char *dirname;
+      struct dirent *dir_entry;
+      char hexgrip[41];
+      
+      dirname = make_filename_try (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
+      if (!dirname)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+      dir = opendir (dirname);
+      if (!dir)
+        {
+          err = gpg_error_from_syserror ();
+          xfree (dirname);
+          goto leave;
+        }
+      xfree (dirname);
 
+      while ( (dir_entry = readdir (dir)) )
+        {
+          if (strlen (dir_entry->d_name) != 44
+              || strcmp (dir_entry->d_name + 40, ".key"))
+            continue;
+          strncpy (hexgrip, dir_entry->d_name, 40);
+          hexgrip[40] = 0;
+
+          if ( hex2bin (hexgrip, grip, 20) < 0 )
+            continue; /* Bad hex string.  */
+
+          err = do_one_keyinfo (ctrl, grip);
+          if (err)
+            goto leave;
+        }
+      err = 0;
+    }
+  else
+    {
+      err = parse_keygrip (ctx, line, grip);
+      if (err)
+        goto leave;
+      err = do_one_keyinfo (ctrl, grip);
+    }
+      
+ leave:
+  if (dir)
+    closedir (dir);
+  if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
+    leave_cmd (ctx, err);
+  return err;
+}
 
 
 \f
@@ -825,39 +1096,59 @@ send_back_passphrase (assuan_context_t ctx, int via_data, const char *pw)
 }
 
 
-/* GET_PASSPHRASE [--data] [--check] <cache_id>
-                  [<error_message> <prompt> <description>]
-
-   This function is usually used to ask for a passphrase to be used
-   for conventional encryption, but may also be used by programs which
-   need specal handling of passphrases.  This command uses a syntax
-   which helps clients to use the agent with minimum effort.  The
-   agent either returns with an error or with a OK followed by the hex
-   encoded passphrase.  Note that the length of the strings is
-   implicitly limited by the maximum length of a command.
-
-   If the option "--data" is used the passphrase is returned by usual
-   data lines and not on the okay line.
-
-   If the option "--check" is used the passphrase constraints checks as
-   implemented by gpg-agent are applied.  A check is not done if the
-   passphrase has been found in the cache.
-*/
-
-static int
+static const char hlp_get_passphrase[] = 
+  "GET_PASSPHRASE [--data] [--check] [--no-ask] [--repeat[=N]]\n"
+  "               [--qualitybar] <cache_id>\n"
+  "               [<error_message> <prompt> <description>]\n"
+  "\n"
+  "This function is usually used to ask for a passphrase to be used\n"
+  "for conventional encryption, but may also be used by programs which\n"
+  "need specal handling of passphrases.  This command uses a syntax\n"
+  "which helps clients to use the agent with minimum effort.  The\n"
+  "agent either returns with an error or with a OK followed by the hex\n"
+  "encoded passphrase.  Note that the length of the strings is\n"
+  "implicitly limited by the maximum length of a command.\n"
+  "\n"
+  "If the option \"--data\" is used the passphrase is returned by usual\n"
+  "data lines and not on the okay line.\n"
+  "\n"
+  "If the option \"--check\" is used the passphrase constraints checks as\n"
+  "implemented by gpg-agent are applied.  A check is not done if the\n"
+  "passphrase has been found in the cache.\n"
+  "\n"
+  "If the option \"--no-ask\" is used and the passphrase is not in the\n"
+  "cache the user will not be asked to enter a passphrase but the error\n"
+  "code GPG_ERR_NO_DATA is returned.  \n"
+  "\n"
+  "If the option \"--qualitybar\" is used a visual indication of the\n"
+  "entered passphrase quality is shown.  (Unless no minimum passphrase\n"
+  "length has been configured.)";
+static gpg_error_t
 cmd_get_passphrase (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
-  const char *pw;
+  char *pw;
   char *response;
   char *cacheid = NULL, *desc = NULL, *prompt = NULL, *errtext = NULL;
+  const char *desc2 = _("Please re-enter this passphrase");
   char *p;
-  void *cache_marker;
-  int opt_data, opt_check;
+  int opt_data, opt_check, opt_no_ask, opt_qualbar;
+  int opt_repeat = 0;
+  char *repeat_errtext = NULL;
 
   opt_data = has_option (line, "--data");
   opt_check = has_option (line, "--check");
+  opt_no_ask = has_option (line, "--no-ask");
+  if (has_option_name (line, "--repeat"))
+    {
+      p = option_value (line, "--repeat");
+      if (p)
+       opt_repeat = atoi (p);
+      else
+       opt_repeat = 1;
+    }
+  opt_qualbar = has_option (line, "--qualitybar");
   line = skip_options (line);
 
   cacheid = line;
@@ -902,13 +1193,14 @@ cmd_get_passphrase (assuan_context_t ctx, char *line)
   if (!strcmp (desc, "X"))
     desc = NULL;
 
-  pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_NORMAL, &cache_marker)
-               : NULL;
+  pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_NORMAL) : NULL;
   if (pw)
     {
       rc = send_back_passphrase (ctx, opt_data, pw);
-      agent_unlock_cache_entry (&cache_marker);
+      xfree (pw);
     }
+  else if (opt_no_ask)
+    rc = gpg_error (GPG_ERR_NO_DATA);
   else
     {
       /* Note, that we only need to replace the + characters and
@@ -922,38 +1214,64 @@ cmd_get_passphrase (assuan_context_t ctx, char *line)
       if (desc)
         plus_to_blank (desc);
 
-      response = NULL;
-      do
-        {
-          xfree (response);
-          rc = agent_get_passphrase (ctrl, &response, desc, prompt, errtext);
-        }
-      while (!rc
-             && opt_check
-             && check_passphrase_constraints (ctrl, response, 0));
-
+    next_try:
+      rc = agent_get_passphrase (ctrl, &response, desc, prompt, 
+                                 repeat_errtext? repeat_errtext:errtext, 
+                                 opt_qualbar);
+      xfree (repeat_errtext);
+      repeat_errtext = NULL;
       if (!rc)
         {
-          if (cacheid)
-            agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
-          rc = send_back_passphrase (ctx, opt_data, response);
+          int i;
+
+          if (opt_check && check_passphrase_constraints (ctrl, response, 0))
+            {
+              xfree (response);
+              goto next_try;
+            }
+          for (i = 0; i < opt_repeat; i++)
+            {
+              char *response2;
+
+              rc = agent_get_passphrase (ctrl, &response2, desc2, prompt,
+                                         errtext, 0);
+              if (rc)
+                break;
+              if (strcmp (response2, response))
+                {
+                  xfree (response2);
+                  xfree (response);
+                  repeat_errtext = try_percent_escape 
+                    (_("does not match - try again"), NULL);
+                  if (!repeat_errtext)
+                    {
+                      rc = gpg_error_from_syserror ();
+                      break;
+                    }
+                  goto next_try;
+                }
+              xfree (response2);
+            }
+          if (!rc)
+            {
+              if (cacheid)
+                agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
+              rc = send_back_passphrase (ctx, opt_data, response);
+            }
           xfree (response);
         }
     }
 
-  if (rc)
-    log_error ("command get_passphrase failed: %s\n", gpg_strerror (rc));
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
 
-/* CLEAR_PASSPHRASE <cache_id>
-
-   may be used to invalidate the cache entry for a passphrase.  The
-   function returns with OK even when there is no cached passphrase.
-*/
-
-static int
+static const char hlp_clear_passphrase[] = 
+  "CLEAR_PASSPHRASE <cache_id>\n"
+  "\n"
+  "may be used to invalidate the cache entry for a passphrase.  The\n"
+  "function returns with OK even when there is no cached passphrase.";
+static gpg_error_t
 cmd_clear_passphrase (assuan_context_t ctx, char *line)
 {
   char *cacheid = NULL;
@@ -974,19 +1292,18 @@ cmd_clear_passphrase (assuan_context_t ctx, char *line)
 }
 
 
-/* GET_CONFIRMATION <description>
-
-   This command may be used to ask for a simple confirmation.
-   DESCRIPTION is displayed along with a Okay and Cancel button.  This
-   command uses a syntax which helps clients to use the agent with
-   minimum effort.  The agent either returns with an error or with a
-   OK.  Note, that the length of DESCRIPTION is implicitly limited by
-   the maximum length of a command. DESCRIPTION should not contain
-   any spaces, those must be encoded either percent escaped or simply
-   as '+'.
-*/
-
-static int
+static const char hlp_get_confirmation[] = 
+  "GET_CONFIRMATION <description>\n"
+  "\n"
+  "This command may be used to ask for a simple confirmation.\n"
+  "DESCRIPTION is displayed along with a Okay and Cancel button.  This\n"
+  "command uses a syntax which helps clients to use the agent with\n"
+  "minimum effort.  The agent either returns with an error or with a\n"
+  "OK.  Note, that the length of DESCRIPTION is implicitly limited by\n"
+  "the maximum length of a command. DESCRIPTION should not contain\n"
+  "any spaces, those must be encoded either percent escaped or simply\n"
+  "as '+'.";
+static gpg_error_t
 cmd_get_confirmation (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -1015,98 +1332,182 @@ cmd_get_confirmation (assuan_context_t ctx, char *line)
   if (desc)
     plus_to_blank (desc);
 
-  rc = agent_get_confirmation (ctrl, desc, NULL, NULL);
-  if (rc)
-    log_error ("command get_confirmation failed: %s\n", gpg_strerror (rc));
-  return rc;
+  rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
+  return leave_cmd (ctx, rc);
 }
 
 
 \f
-/* LEARN [--send]
-
-   Learn something about the currently inserted smartcard.  With
-   --send the new certificates are send back.  */
-static int
+static const char hlp_learn[] =
+  "LEARN [--send]\n"
+  "\n"
+  "Learn something about the currently inserted smartcard.  With\n"
+  "--send the new certificates are send back.";
+static gpg_error_t
 cmd_learn (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
 
   rc = agent_handle_learn (ctrl, has_option (line, "--send")? ctx : NULL);
-  if (rc)
-    log_error ("command learn failed: %s\n", gpg_strerror (rc));
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
 
 \f
-/* PASSWD <hexstring_with_keygrip>
-  
-   Change the passphrase/PID for the key identified by keygrip in LINE. */
-static int
+static const char hlp_passwd[] = 
+  "PASSWD [--cache-nonce=<c>] [--passwd-nonce=<s>] <hexstring_with_keygrip>\n"
+  "\n"
+  "Change the passphrase/PIN for the key identified by keygrip in LINE.";
+static gpg_error_t
 cmd_passwd (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
-  int rc;
+  gpg_error_t err;
+  int c;
+  char *cache_nonce = NULL;
+  char *passwd_nonce = NULL;
   unsigned char grip[20];
   gcry_sexp_t s_skey = NULL;
   unsigned char *shadow_info = NULL;
+  char *passphrase = NULL;
+  char *pend;
 
-  rc = parse_keygrip (ctx, line, grip);
-  if (rc)
-    goto leave;
-
-  ctrl->in_passwd++;
-  rc = agent_key_from_file (ctrl, ctrl->server_local->keydesc,
-                            grip, &shadow_info, CACHE_MODE_IGNORE, &s_skey);
-  if (rc)
+  cache_nonce = option_value (line, "--cache-nonce");
+  if (cache_nonce)
+    {
+      for (pend = cache_nonce; *pend && !spacep (pend); pend++)
+        ;
+      c = *pend;
+      *pend = '\0';
+      cache_nonce = xtrystrdup (cache_nonce);
+      *pend = c;
+      if (!cache_nonce)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+    }
+
+  passwd_nonce = option_value (line, "--passwd-nonce");
+  if (passwd_nonce)
+    {
+      for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
+        ;
+      c = *pend;
+      *pend = '\0';
+      passwd_nonce = xtrystrdup (passwd_nonce);
+      *pend = c;
+      if (!passwd_nonce)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+    }
+
+  line = skip_options (line);
+
+  err = parse_keygrip (ctx, line, grip);
+  if (err)
+    goto leave;
+
+  ctrl->in_passwd++;
+  err = agent_key_from_file (ctrl, cache_nonce, ctrl->server_local->keydesc,
+                             grip, &shadow_info, CACHE_MODE_IGNORE, NULL, 
+                             &s_skey, &passphrase);
+  if (err)
     ;
   else if (!s_skey)
     {
       log_error ("changing a smartcard PIN is not yet supported\n");
-      rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
+      err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     }
   else
-    rc = agent_protect_and_store (ctrl, s_skey);
+    {
+      char *newpass = NULL;
+
+      if (passwd_nonce)
+        newpass = agent_get_cache (passwd_nonce, CACHE_MODE_NONCE);
+      err = agent_protect_and_store (ctrl, s_skey, &newpass);
+      if (!err && passphrase)
+        {
+          /* A passphrase existed on the old key and the change was
+             successful.  Return a nonce for that old passphrase to
+             let the caller try to unprotect the other subkeys with
+             the same key.  */
+          if (!cache_nonce)
+            {
+              char buf[12];
+              gcry_create_nonce (buf, 12);
+              cache_nonce = bin2hex (buf, 12, NULL);
+            }
+          if (cache_nonce 
+              && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
+                                   passphrase, 120 /*seconds*/))
+            {
+              assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
+              xfree (ctrl->server_local->last_cache_nonce);
+              ctrl->server_local->last_cache_nonce = cache_nonce;
+              cache_nonce = NULL;
+            }
+          if (newpass)
+            {
+              /* If we have a new passphrase (which might be empty) we
+                 store it under a passwd nonce so that the caller may
+                 send that nonce again to use it for another key. */
+              if (!passwd_nonce)
+                {
+                  char buf[12];
+                  gcry_create_nonce (buf, 12);
+                  passwd_nonce = bin2hex (buf, 12, NULL);
+                }
+              if (passwd_nonce 
+                  && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
+                                       newpass, 120 /*seconds*/))
+                {
+                  assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
+                  xfree (ctrl->server_local->last_passwd_nonce);
+                  ctrl->server_local->last_passwd_nonce = passwd_nonce;
+                  passwd_nonce = NULL;
+                }
+            }
+        }
+      xfree (newpass);
+    }
   ctrl->in_passwd--;
 
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = NULL;
 
  leave:
+  xfree (passphrase);
   gcry_sexp_release (s_skey);
   xfree (shadow_info);
-  if (rc)
-    log_error ("command passwd failed: %s\n", gpg_strerror (rc));
-  return rc;
+  xfree (cache_nonce);
+  return leave_cmd (ctx, err);
 }
 
-/* PRESET_PASSPHRASE <hexstring_with_keygrip> <timeout> <hexstring>
-  
-   Set the cached passphrase/PIN for the key identified by the keygrip
-   to passwd for the given time, where -1 means infinite and 0 means
-   the default (currently only a timeout of -1 is allowed, which means
-   to never expire it).  If passwd is not provided, ask for it via the
-   pinentry module.  */
-static int
+
+static const char hlp_preset_passphrase[] = 
+  "PRESET_PASSPHRASE <string_or_keygrip> <timeout> <hexstring>\n"
+  "\n"
+  "Set the cached passphrase/PIN for the key identified by the keygrip\n"
+  "to passwd for the given time, where -1 means infinite and 0 means\n"
+  "the default (currently only a timeout of -1 is allowed, which means\n"
+  "to never expire it).  If passwd is not provided, ask for it via the\n"
+  "pinentry module.";
+static gpg_error_t
 cmd_preset_passphrase (assuan_context_t ctx, char *line)
 {
   int rc;
-  unsigned char grip[20];
   char *grip_clear = NULL;
   char *passphrase = NULL;
   int ttl;
   size_t len;
 
   if (!opt.allow_preset_passphrase)
-    return gpg_error (GPG_ERR_NOT_SUPPORTED);
+    return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
 
-  rc = parse_keygrip (ctx, line, grip);
-  if (rc)
-    return rc;
-
-  /* FIXME: parse_keygrip should return a tail pointer.  */
   grip_clear = line;
   while (*line && (*line != ' ' && *line != '\t'))
     line++;
@@ -1127,6 +1528,7 @@ cmd_preset_passphrase (assuan_context_t ctx, char *line)
     line++;
 
   /* Syntax check the hexstring.  */
+  len = 0;
   rc = parse_hexstring (ctx, line, &len);
   if (rc)
     return rc;
@@ -1135,24 +1537,29 @@ cmd_preset_passphrase (assuan_context_t ctx, char *line)
   /* If there is a passphrase, use it.  Currently, a passphrase is
      required.  */
   if (*line)
-    passphrase = line;
+    {
+      /* Do in-place conversion.  */
+      passphrase = line;
+      if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
+        rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
+    }
   else
-    return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
-
-  rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
+    rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
 
-  if (rc)
-    log_error ("command preset_passwd failed: %s\n", gpg_strerror (rc));
+  if (!rc)
+    rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
 
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
+
 \f
-/* SCD <commands to pass to the scdaemon>
-  
-   This is a general quote command to redirect everything to the
-   SCDAEMON. */
-static int
+static const char hlp_scd[] = 
+  "SCD <commands to pass to the scdaemon>\n"
+  " \n"
+  "This is a general quote command to redirect everything to the\n"
+  "SCdaemon.";
+static gpg_error_t
 cmd_scd (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -1165,12 +1572,383 @@ cmd_scd (assuan_context_t ctx, char *line)
 
 
 \f
-/* GETVAL <key>
+static const char hlp_keywrap_key[] =
+  "KEYWRAP_KEY [--clear] <mode>\n"
+  "\n"
+  "Return a key to wrap another key.  For now the key is returned\n"
+  "verbatim and and thus makes not much sense because an eavesdropper on\n"
+  "the gpg-agent connection will see the key as well as the wrapped key.\n"
+  "However, this function may either be equipped with a public key\n"
+  "mechanism or not used at all if the key is a pre-shared key.  In any\n"
+  "case wrapping the import and export of keys is a requirement for\n"
+  "certain cryptographic validations and thus useful.  The key persists\n"
+  "a RESET command but may be cleared using the option --clear.\n"
+  "\n"
+  "Supported modes are:\n"
+  "  --import  - Return a key to import a key into gpg-agent\n"
+  "  --export  - Return a key to export a key from gpg-agent";
+static gpg_error_t
+cmd_keywrap_key (assuan_context_t ctx, char *line)
+{
+  ctrl_t ctrl = assuan_get_pointer (ctx);
+  gpg_error_t err = 0;
+  int clearopt = has_option (line, "--clear");
 
-   Return the value for KEY from the special environment as created by
-   PUTVAL.
- */
-static int
+
+  assuan_begin_confidential (ctx);
+  if (has_option (line, "--import"))
+    {
+      xfree (ctrl->server_local->import_key);
+      if (clearopt)
+        ctrl->server_local->import_key = NULL;
+      else if (!(ctrl->server_local->import_key = 
+                 gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
+        err = gpg_error_from_syserror ();
+      else
+        err = assuan_send_data (ctx, ctrl->server_local->import_key,
+                                KEYWRAP_KEYSIZE);
+    }
+  else if (has_option (line, "--export"))
+    {
+      xfree (ctrl->server_local->export_key);
+      if (clearopt)
+        ctrl->server_local->export_key = NULL;
+      else if (!(ctrl->server_local->export_key = 
+            gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
+        err = gpg_error_from_syserror ();
+      else
+        err = assuan_send_data (ctx, ctrl->server_local->export_key,
+                                KEYWRAP_KEYSIZE);
+    }
+  else
+    err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for MODE");
+  assuan_end_confidential (ctx);
+  
+  return leave_cmd (ctx, err);
+}
+
+
+\f
+static const char hlp_import_key[] =
+  "IMPORT_KEY [<cache_nonce>]\n"
+  "\n"
+  "Import a secret key into the key store.  The key is expected to be\n"
+  "encrypted using the current session's key wrapping key (cf. command\n"
+  "KEYWRAP_KEY) using the AESWRAP-128 algorithm.  This function takes\n"
+  "no arguments but uses the inquiry \"KEYDATA\" to ask for the actual\n"
+  "key data.  The unwrapped key must be a canonical S-expression.";
+static gpg_error_t
+cmd_import_key (assuan_context_t ctx, char *line)
+{
+  ctrl_t ctrl = assuan_get_pointer (ctx);
+  gpg_error_t err;
+  unsigned char *wrappedkey = NULL;
+  size_t wrappedkeylen;
+  gcry_cipher_hd_t cipherhd = NULL;
+  unsigned char *key = NULL;
+  size_t keylen, realkeylen;
+  char *passphrase = NULL;
+  unsigned char *finalkey = NULL;
+  size_t finalkeylen;
+  unsigned char grip[20];
+  gcry_sexp_t openpgp_sexp = NULL;
+  char *cache_nonce = NULL;
+  char *p;
+  
+  if (!ctrl->server_local->import_key)
+    {
+      err = gpg_error (GPG_ERR_MISSING_KEY);
+      goto leave;
+    }
+
+  p = line;
+  for (p=line; *p && *p != ' ' && *p != '\t'; p++)
+    ;
+  *p = '\0';
+  if (*line)
+    cache_nonce = xtrystrdup (line);
+
+  assuan_begin_confidential (ctx);
+  err = assuan_inquire (ctx, "KEYDATA",
+                        &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
+  assuan_end_confidential (ctx);
+  if (err)
+    goto leave;
+  if (wrappedkeylen < 24)
+    {
+      err = gpg_error (GPG_ERR_INV_LENGTH);
+      goto leave;
+    }
+  keylen = wrappedkeylen - 8;
+  key = xtrymalloc_secure (keylen);
+  if (!key)
+    {
+      err = gpg_error_from_syserror ();
+      goto leave;
+    }
+
+  err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
+                          GCRY_CIPHER_MODE_AESWRAP, 0);
+  if (err)
+    goto leave;
+  err = gcry_cipher_setkey (cipherhd,
+                            ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
+  if (err)
+    goto leave;
+  err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
+  if (err)
+    goto leave;
+  gcry_cipher_close (cipherhd);
+  cipherhd = NULL;
+  xfree (wrappedkey);
+  wrappedkey = NULL;
+
+  realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
+  if (!realkeylen)
+    goto leave; /* Invalid canonical encoded S-expression.  */
+  
+  err = keygrip_from_canon_sexp (key, realkeylen, grip);
+  if (err)
+    {
+      /* This might be due to an unsupported S-expression format.
+         Check whether this is openpgp-private-key and trigger that
+         import code.  */
+      if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
+        {
+          const char *tag;
+          size_t taglen;
+          
+          tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
+          if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
+            ;
+          else
+            {
+              gcry_sexp_release (openpgp_sexp);
+              openpgp_sexp = NULL;
+            }
+        }
+      if (!openpgp_sexp)
+        goto leave; /* Note that ERR is still set.  */
+    }
+
+
+  if (openpgp_sexp)
+    {
+      /* In most cases the key is encrypted and thus the conversion
+         function from the OpenPGP format to our internal format will
+         ask for a passphrase.  That passphrase will be returned and
+         used to protect the key using the same code as for regular
+         key import. */
+      
+      err = convert_from_openpgp (ctrl, openpgp_sexp, grip,
+                                  ctrl->server_local->keydesc, cache_nonce,
+                                  &key, &passphrase);
+      if (err)
+        goto leave;
+      realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
+      if (!realkeylen)
+        goto leave; /* Invalid canonical encoded S-expression.  */
+      if (passphrase)
+        {
+          if (!cache_nonce)
+            {
+              char buf[12];
+              gcry_create_nonce (buf, 12);
+              cache_nonce = bin2hex (buf, 12, NULL);
+            }
+          if (cache_nonce 
+              && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
+                                   passphrase, 120 /*seconds*/))
+            assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
+        }
+    }
+  else
+    {
+      if (!agent_key_available (grip))
+        err = gpg_error (GPG_ERR_EEXIST);
+      else
+        err = agent_ask_new_passphrase 
+          (ctrl, _("Please enter the passphrase to protect the "
+                   "imported object within the GnuPG system."),
+           &passphrase);
+      if (err)
+        goto leave;
+    }
+
+  if (passphrase)
+    {
+      err = agent_protect (key, passphrase, &finalkey, &finalkeylen);
+      if (!err)
+        err = agent_write_private_key (grip, finalkey, finalkeylen, 0);
+    }
+  else
+    err = agent_write_private_key (grip, key, realkeylen, 0);
+
+ leave:
+  gcry_sexp_release (openpgp_sexp);
+  xfree (finalkey);
+  xfree (passphrase);
+  xfree (key);
+  gcry_cipher_close (cipherhd);
+  xfree (wrappedkey);
+  xfree (cache_nonce);
+  xfree (ctrl->server_local->keydesc);
+  ctrl->server_local->keydesc = NULL;
+  return leave_cmd (ctx, err);
+}
+
+
+\f
+static const char hlp_export_key[] =
+  "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
+  "\n"
+  "Export a secret key from the key store.  The key will be encrypted\n"
+  "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
+  "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
+  "prior to using this command.  The function takes the keygrip as argument.\n";
+static gpg_error_t
+cmd_export_key (assuan_context_t ctx, char *line)
+{
+  ctrl_t ctrl = assuan_get_pointer (ctx);
+  gpg_error_t err;
+  unsigned char grip[20];
+  gcry_sexp_t s_skey = NULL;
+  unsigned char *key = NULL;
+  size_t keylen;
+  gcry_cipher_hd_t cipherhd = NULL;
+  unsigned char *wrappedkey = NULL;
+  size_t wrappedkeylen;
+  int openpgp;
+  char *cache_nonce;
+  char *passphrase = NULL;
+  
+  openpgp = has_option (line, "--openpgp");
+  cache_nonce = option_value (line, "--cache-nonce");
+  if (cache_nonce)
+    {
+      for (; *line && !spacep (line); line++)
+        ;
+      if (*line)
+        *line++ = '\0';
+      cache_nonce = xtrystrdup (cache_nonce);
+      if (!cache_nonce)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+    }
+  line = skip_options (line);
+
+  if (!ctrl->server_local->export_key)
+    {
+      err = gpg_error (GPG_ERR_MISSING_KEY);
+      goto leave;
+    }
+
+  err = parse_keygrip (ctx, line, grip);
+  if (err)
+    goto leave;
+
+  if (agent_key_available (grip))
+    {
+      err = gpg_error (GPG_ERR_NO_SECKEY);
+      goto leave;
+    }
+
+  /* Get the key from the file.  With the openpgp flag we also ask for
+     the passphrase so that we can use it to re-encrypt it.  */
+  err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
+                             NULL, CACHE_MODE_IGNORE, NULL, &s_skey,
+                             openpgp ? &passphrase : NULL);
+  if (err)
+    goto leave;
+  if (!s_skey)
+    {
+      /* Key is on a smartcard.  Actually we should not see this here
+         because we do not pass a shadow_info variable to the above
+         function, thus it will return this error directly.  */
+      err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
+      goto leave;
+    }
+  
+  if (openpgp)
+    {
+      /* The openpgp option changes the key format into the OpenPGP
+         key transfer format.  The result is already a padded
+         canonical S-expression.  */
+      if (!passphrase)
+        {
+          err = agent_ask_new_passphrase 
+            (ctrl, _("This key (or subkey) is not protected with a passphrase."
+                     "  Please enter a new passphrase to export it."),
+             &passphrase);
+          if (err)
+            goto leave;
+        }
+      err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
+    }
+  else
+    {
+      /* Convert into a canonical S-expression and wrap that.  */
+      err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
+    }
+  if (err)
+    goto leave;
+  gcry_sexp_release (s_skey);
+  s_skey = NULL;
+
+  err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
+                          GCRY_CIPHER_MODE_AESWRAP, 0);
+  if (err)
+    goto leave;
+  err = gcry_cipher_setkey (cipherhd,
+                            ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
+  if (err)
+    goto leave;
+
+  wrappedkeylen = keylen + 8;
+  wrappedkey = xtrymalloc (wrappedkeylen);
+  if (!wrappedkey)
+    {
+      err = gpg_error_from_syserror ();
+      goto leave;
+    }
+
+  err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
+  if (err)
+    goto leave;
+  xfree (key);
+  key = NULL;
+  gcry_cipher_close (cipherhd);
+  cipherhd = NULL;
+
+  assuan_begin_confidential (ctx);
+  err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
+  assuan_end_confidential (ctx);
+  
+
+ leave:
+  xfree (cache_nonce);
+  xfree (passphrase);
+  xfree (wrappedkey);
+  gcry_cipher_close (cipherhd);
+  xfree (key);
+  gcry_sexp_release (s_skey);
+  xfree (ctrl->server_local->keydesc);
+  ctrl->server_local->keydesc = NULL;
+
+  return leave_cmd (ctx, err);
+}
+
+
+
+\f
+static const char hlp_getval[] = 
+  "GETVAL <key>\n"
+  "\n"
+  "Return the value for KEY from the special environment as created by\n"
+  "PUTVAL.";
+static gpg_error_t
 cmd_getval (assuan_context_t ctx, char *line)
 {
   int rc = 0;
@@ -1203,31 +1981,29 @@ cmd_getval (assuan_context_t ctx, char *line)
   else
     return gpg_error (GPG_ERR_NO_DATA);
 
-  if (rc)
-    log_error ("command getval failed: %s\n", gpg_strerror (rc));
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
 
-/* PUTVAL <key> [<percent_escaped_value>]
-
-   The gpg-agent maintains a kind of environment which may be used to
-   store key/value pairs in it, so that they can be retrieved later.
-   This may be used by helper daemons to daemonize themself on
-   invocation and register them with gpg-agent.  Callers of the
-   daemon's service may now first try connect to get the information
-   for that service from gpg-agent through the GETVAL command and then
-   try to connect to that daemon.  Only if that fails they may start
-   an own instance of the service daemon. 
-
-   KEY is an an arbitrary symbol with the same syntax rules as keys
-   for shell environment variables.  PERCENT_ESCAPED_VALUE is the
-   corresponsing value; they should be similar to the values of
-   envronment variables but gpg-agent does not enforce any
-   restrictions.  If that value is not given any value under that KEY
-   is removed from this special environment.
-*/
-static int
+static const char hlp_putval[] = 
+  "PUTVAL <key> [<percent_escaped_value>]\n"
+  "\n"
+  "The gpg-agent maintains a kind of environment which may be used to\n"
+  "store key/value pairs in it, so that they can be retrieved later.\n"
+  "This may be used by helper daemons to daemonize themself on\n"
+  "invocation and register them with gpg-agent.  Callers of the\n"
+  "daemon's service may now first try connect to get the information\n"
+  "for that service from gpg-agent through the GETVAL command and then\n"
+  "try to connect to that daemon.  Only if that fails they may start\n"
+  "an own instance of the service daemon. \n"
+  "\n"
+  "KEY is an an arbitrary symbol with the same syntax rules as keys\n"
+  "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
+  "corresponsing value; they should be similar to the values of\n"
+  "envronment variables but gpg-agent does not enforce any\n"
+  "restrictions.  If that value is not given any value under that KEY\n"
+  "is removed from this special environment.";
+static gpg_error_t
 cmd_putval (assuan_context_t ctx, char *line)
 {
   int rc = 0;
@@ -1252,7 +2028,7 @@ cmd_putval (assuan_context_t ctx, char *line)
           p = strchr (value, ' ');
           if (p)
             *p = 0;
-          valuelen = percent_plus_unescape (value);
+          valuelen = percent_plus_unescape_inplace (value, 0);
         }
     }
   if (!key || !*key)
@@ -1288,93 +2064,130 @@ cmd_putval (assuan_context_t ctx, char *line)
         }
     }
 
-  if (rc)
-    log_error ("command putval failed: %s\n", gpg_strerror (rc));
-  return rc;
+  return leave_cmd (ctx, rc);
 }
 
 
 
 \f
-/* UPDATESTARTUPTTY 
-  
-  Set startup TTY and X DISPLAY variables to the values of this
-  session.  This command is useful to pull future pinentries to
-  another screen.  It is only required because there is no way in the
-  ssh-agent protocol to convey this information.  */
-static int
+static const char hlp_updatestartuptty[] = 
+  "UPDATESTARTUPTTY\n"
+  "\n"
+  "Set startup TTY and X11 DISPLAY variables to the values of this\n"
+  "session.  This command is useful to pull future pinentries to\n"
+  "another screen.  It is only required because there is no way in the\n"
+  "ssh-agent protocol to convey this information.";
+static gpg_error_t
 cmd_updatestartuptty (assuan_context_t ctx, char *line)
 {
+  static const char *names[] = 
+    { "GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
   ctrl_t ctrl = assuan_get_pointer (ctx);
+  gpg_error_t err = 0;
+  session_env_t se;
+  int idx;
+  char *lc_ctype = NULL;
+  char *lc_messages = NULL;
+  
+  (void)line;
 
-  xfree (opt.startup_display); opt.startup_display = NULL;
-  xfree (opt.startup_ttyname); opt.startup_ttyname = NULL;
-  xfree (opt.startup_ttytype); opt.startup_ttytype = NULL;
-  xfree (opt.startup_lc_ctype); opt.startup_lc_ctype = NULL;
-  xfree (opt.startup_lc_messages); opt.startup_lc_messages = NULL;
-  xfree (opt.startup_xauthority); opt.startup_xauthority = NULL;
-
-  if (ctrl->display)
-    opt.startup_display = xtrystrdup (ctrl->display);
-  if (ctrl->ttyname)
-    opt.startup_ttyname = xtrystrdup (ctrl->ttyname);
-  if (ctrl->ttytype)
-    opt.startup_ttytype = xtrystrdup (ctrl->ttytype);
-  if (ctrl->lc_ctype) 
-    opt.startup_lc_ctype = xtrystrdup (ctrl->lc_ctype);
-  if (ctrl->lc_messages)
-    opt.startup_lc_messages = xtrystrdup (ctrl->lc_messages);
-  if (ctrl->xauthority)
-    opt.startup_xauthority = xtrystrdup (ctrl->xauthority);
-  if (ctrl->pinentry_user_data)
-    opt.startup_pinentry_user_data = xtrystrdup (ctrl->pinentry_user_data);
+  se = session_env_new ();
+  if (!se)
+    err = gpg_error_from_syserror ();
 
-  return 0;
+  for (idx=0; !err && names[idx]; idx++)
+    {
+      const char *value = session_env_getenv (ctrl->session_env, names[idx]);
+      if (value)
+        err = session_env_setenv (se, names[idx], value);
+    }
+
+  if (!err && ctrl->lc_ctype) 
+    if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
+      err = gpg_error_from_syserror ();
+
+  if (!err && ctrl->lc_messages)
+    if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
+      err = gpg_error_from_syserror ();
+   
+  if (err)
+    {
+      session_env_release (se);
+      xfree (lc_ctype);
+      xfree (lc_messages);
+    }
+  else
+    {
+      session_env_release (opt.startup_env);
+      opt.startup_env = se;
+      xfree (opt.startup_lc_ctype);
+      opt.startup_lc_ctype = lc_ctype;
+      xfree (opt.startup_lc_messages);
+      opt.startup_lc_messages = lc_messages;
+    }
+
+  return err;
 }
 
 
 \f
-#ifdef HAVE_W32_SYSTEM
-/* KILLAGENT
-
-   Under Windows we start the agent on the fly.  Thus it also make
-   sense to allow a client to stop the agent. */
-static int
+static const char hlp_killagent[] =
+  "KILLAGENT\n"
+  "\n"
+  "If the agent has been started using a standard socket\n"
+  "we allow a client to stop the agent.";
+static gpg_error_t
 cmd_killagent (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
+
+  (void)line;
+  
+  if (!opt.use_standard_socket)
+    return set_error (GPG_ERR_NOT_SUPPORTED, "no --use-standard-socket");
+
   ctrl->server_local->stopme = 1;
-  return 0;
+  return gpg_error (GPG_ERR_EOF);
 }
 
-/* RELOADAGENT
 
-   As signals are inconvenient under Windows, we provide this command
-   to allow reloading of the configuration.  */
-static int
+static const char hlp_reloadagent[] =
+  "RELOADAGENT\n"
+  "\n"
+  "This command is an alternative to SIGHUP\n"
+  "to reload the configuration.";
+static gpg_error_t
 cmd_reloadagent (assuan_context_t ctx, char *line)
 {
+  (void)ctx;
+  (void)line;
+
   agent_sighup_action ();
   return 0;
 }
-#endif /*HAVE_W32_SYSTEM*/
 
 
 \f
-/* GETINFO <what>
-
-   Multipurpose function to return a variety of information.
-   Supported values for 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.
-     ssh_socket_name - Return the name of the ssh socket.
-
- */
-static int
+static const char hlp_getinfo[] = 
+  "GETINFO <what>\n"
+  "\n"
+  "Multipurpose function to return a variety of information.\n"
+  "Supported values for WHAT are:\n"
+  "\n"
+  "  version     - Return the version of the program.\n"
+  "  pid         - Return the process id of the server.\n"
+  "  socket_name - Return the name of the socket.\n"
+  "  ssh_socket_name - Return the name of the ssh socket.\n"
+  "  scd_running - Return OK if the SCdaemon is already running.\n"
+  "  s2k_count   - Return the calibrated S2K count.\n"
+  "  std_session_env - List the standard session environment.\n"
+  "  std_startup_env - List the standard startup environment.\n"
+  "  cmd_has_option\n"
+  "              - Returns OK if the command CMD implements the option OPT\n.";
+static gpg_error_t
 cmd_getinfo (assuan_context_t ctx, char *line)
 {
+  ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc = 0;
 
   if (!strcmp (line, "version"))
@@ -1407,6 +2220,77 @@ cmd_getinfo (assuan_context_t ctx, char *line)
       else
         rc = gpg_error (GPG_ERR_NO_DATA);
     }
+  else if (!strcmp (line, "scd_running"))
+    {
+      rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
+    }
+  else if (!strcmp (line, "s2k_count"))
+    {
+      char numbuf[50];
+
+      snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
+      rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
+    }
+  else if (!strcmp (line, "std_session_env")
+           || !strcmp (line, "std_startup_env"))
+    {
+      int iterator;
+      const char *name, *value;
+      char *string;
+      
+      iterator = 0; 
+      while ((name = session_env_list_stdenvnames (&iterator, NULL)))
+        {
+          value = session_env_getenv_or_default
+            (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
+          if (value)
+            {
+              string = xtryasprintf ("%s=%s", name, value); 
+              if (!string)
+                rc = gpg_error_from_syserror ();
+              else
+                {
+                  rc = assuan_send_data (ctx, string, strlen (string)+1);
+                  if (!rc)
+                    rc = assuan_send_data (ctx, NULL, 0);
+                }
+              if (rc)
+                break;
+            }
+        }
+    }
+  else if (!strncmp (line, "cmd_has_option", 14)
+           && (line[14] == ' ' || line[14] == '\t' || !line[14]))
+    {
+      char *cmd, *cmdopt;
+      line += 14;
+      while (*line == ' ' || *line == '\t')
+        line++;
+      if (!*line)
+        rc = gpg_error (GPG_ERR_MISSING_VALUE);
+      else
+        {
+          cmd = line;
+          while (*line && (*line != ' ' && *line != '\t'))
+            line++;
+          if (!*line)
+            rc = gpg_error (GPG_ERR_MISSING_VALUE);
+          else
+            {
+              *line++ = 0;
+              while (*line == ' ' || *line == '\t')
+                line++;
+              if (!*line)
+                rc = gpg_error (GPG_ERR_MISSING_VALUE);
+              else
+                {
+                  cmdopt = line;
+                  if (!command_has_option (cmd, cmdopt))
+                    rc = gpg_error (GPG_ERR_GENERAL);
+                }
+            }
+        }
+    }
   else
     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
   return rc;
@@ -1414,81 +2298,75 @@ cmd_getinfo (assuan_context_t ctx, char *line)
 
 
 \f
-static int
+static gpg_error_t
 option_handler (assuan_context_t ctx, const char *key, const char *value)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
+  gpg_error_t err = 0;
 
-  if (!strcmp (key, "display"))
+  if (!strcmp (key, "agent-awareness"))
     {
-      if (ctrl->display)
-        free (ctrl->display);
-      ctrl->display = strdup (value);
-      if (!ctrl->display)
-        return out_of_core ();
+      /* The value is a version string telling us of which agent
+         version the caller is aware of.  */
+      ctrl->server_local->allow_fully_canceled = 
+        gnupg_compare_version (value, "2.1.0");
+    }
+  else if (!strcmp (key, "putenv"))
+    {
+      /* Change the session's environment to be used for the
+         Pinentry.  Valid values are:
+          <NAME>            Delete envvar NAME
+          <KEY>=            Set envvar NAME to the empty string
+          <KEY>=<VALUE>     Set envvar NAME to VALUE
+      */
+      err = session_env_putenv (ctrl->session_env, value);
+    }
+  else if (!strcmp (key, "display"))
+    {
+      err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
     }
   else if (!strcmp (key, "ttyname"))
     {
       if (!opt.keep_tty)
-        {
-          if (ctrl->ttyname)
-            free (ctrl->ttyname);
-          ctrl->ttyname = strdup (value);
-          if (!ctrl->ttyname)
-            return out_of_core ();
-        }
+        err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
     }
   else if (!strcmp (key, "ttytype"))
     {
       if (!opt.keep_tty)
-        {
-          if (ctrl->ttytype)
-            free (ctrl->ttytype);
-          ctrl->ttytype = strdup (value);
-          if (!ctrl->ttytype)
-            return out_of_core ();
-        }
+        err = session_env_setenv (ctrl->session_env, "TERM", value);
     }
   else if (!strcmp (key, "lc-ctype"))
     {
       if (ctrl->lc_ctype)
-        free (ctrl->lc_ctype);
-      ctrl->lc_ctype = strdup (value);
+        xfree (ctrl->lc_ctype);
+      ctrl->lc_ctype = xtrystrdup (value);
       if (!ctrl->lc_ctype)
         return out_of_core ();
     }
   else if (!strcmp (key, "lc-messages"))
     {
       if (ctrl->lc_messages)
-        free (ctrl->lc_messages);
-      ctrl->lc_messages = strdup (value);
+        xfree (ctrl->lc_messages);
+      ctrl->lc_messages = xtrystrdup (value);
       if (!ctrl->lc_messages)
         return out_of_core ();
     }
   else if (!strcmp (key, "xauthority"))
     {
-      if (ctrl->xauthority)
-        free (ctrl->xauthority);
-      ctrl->xauthority = strdup (value);
-      if (!ctrl->xauthority)
-        return out_of_core ();
+      err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
     }
   else if (!strcmp (key, "pinentry-user-data"))
     {
-      if (ctrl->pinentry_user_data)
-        free (ctrl->pinentry_user_data);
-      ctrl->pinentry_user_data = strdup (value);
-      if (!ctrl->pinentry_user_data)
-        return out_of_core ();
+      err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
     }
   else if (!strcmp (key, "use-cache-for-signing"))
     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
   else if (!strcmp (key, "allow-pinentry-notify"))
     ctrl->server_local->allow_pinentry_notify = 1;
   else
-    return gpg_error (GPG_ERR_UNKNOWN_OPTION);
+    err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
 
-  return 0;
+  return err;
 }
 
 
@@ -1497,9 +2375,11 @@ option_handler (assuan_context_t ctx, const char *key, const char *value)
 /* Called by libassuan after all commands. ERR is the error from the
    last assuan operation and not the one returned from the command. */
 static void
-post_cmd_notify (assuan_context_t ctx, int err)
+post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
+  
+  (void)err;
 
   /* Switch off any I/O monitor controlled logging pausing. */
   ctrl->server_local->pause_io_logging = 0;
@@ -1511,15 +2391,17 @@ post_cmd_notify (assuan_context_t ctx, int err)
    that the debug output won't get cluttered by this primitive
    command.  */
 static unsigned int
-io_monitor (assuan_context_t ctx, int direction,
+io_monitor (assuan_context_t ctx, void *hook, int direction,
             const char *line, size_t linelen)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
+  
+  (void) hook;
 
   /* Note that we only check for the uppercase name.  This allows to
      see the logging for debugging if using a non-upercase command
      name. */
-  if (ctx && !direction 
+  if (ctx && direction == ASSUAN_IO_FROM_PEER
       && linelen >= 15
       && !strncmp (line, "GETEVENTCOUNTER", 15)
       && (linelen == 15 || spacep (line+15)))
@@ -1527,7 +2409,21 @@ io_monitor (assuan_context_t ctx, int direction,
       ctrl->server_local->pause_io_logging = 1;
     }
 
-  return ctrl->server_local->pause_io_logging? 1:0;
+  return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
+}
+
+
+/* Return true if the command CMD implements the option OPT.  */
+static int
+command_has_option (const char *cmd, const char *cmdopt)
+{
+  if (!strcmp (cmd, "GET_PASSPHRASE"))
+    {
+      if (!strcmp (cmdopt, "repeat"))
+          return 1;
+    }
+      
+  return 0;
 }
 
 
@@ -1537,51 +2433,53 @@ register_commands (assuan_context_t ctx)
 {
   static struct {
     const char *name;
-    int (*handler)(assuan_context_t, char *line);
+    assuan_handler_t handler;
+    const char * const help;
   } table[] = {
-    { "GETEVENTCOUNTER",cmd_geteventcounter },
-    { "ISTRUSTED",      cmd_istrusted },
-    { "HAVEKEY",        cmd_havekey },
-    { "SIGKEY",         cmd_sigkey },
-    { "SETKEY",         cmd_sigkey },
-    { "SETKEYDESC",     cmd_setkeydesc },
-    { "SETHASH",        cmd_sethash },
-    { "PKSIGN",         cmd_pksign },
-    { "PKDECRYPT",      cmd_pkdecrypt },
-    { "GENKEY",         cmd_genkey },
-    { "READKEY",        cmd_readkey },
-    { "GET_PASSPHRASE", cmd_get_passphrase },
-    { "PRESET_PASSPHRASE", cmd_preset_passphrase },
-    { "CLEAR_PASSPHRASE", cmd_clear_passphrase },
-    { "GET_CONFIRMATION", cmd_get_confirmation },
-    { "LISTTRUSTED",    cmd_listtrusted },
-    { "MARKTRUSTED",    cmd_marktrusted },
-    { "LEARN",          cmd_learn },
-    { "PASSWD",         cmd_passwd },
+    { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
+    { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
+    { "HAVEKEY",        cmd_havekey,   hlp_havekey },
+    { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
+    { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
+    { "SETKEY",         cmd_sigkey,    hlp_sigkey },
+    { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
+    { "SETHASH",        cmd_sethash,   hlp_sethash },
+    { "PKSIGN",         cmd_pksign,    hlp_pksign },
+    { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
+    { "GENKEY",         cmd_genkey,    hlp_genkey },
+    { "READKEY",        cmd_readkey,   hlp_readkey },
+    { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
+    { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
+    { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
+    { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
+    { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
+    { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
+    { "LEARN",          cmd_learn,     hlp_learn },
+    { "PASSWD",         cmd_passwd,    hlp_passwd },
     { "INPUT",          NULL }, 
     { "OUTPUT",         NULL }, 
-    { "SCD",            cmd_scd },
-    { "GETVAL",         cmd_getval },
-    { "PUTVAL",         cmd_putval },
-    { "UPDATESTARTUPTTY",  cmd_updatestartuptty },
-#ifdef HAVE_W32_SYSTEM
-    { "KILLAGENT",      cmd_killagent },
-    { "RELOADAGENT",    cmd_reloadagent },
-#endif
-    { "GETINFO",        cmd_getinfo },
+    { "SCD",            cmd_scd,       hlp_scd },
+    { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
+    { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
+    { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
+    { "GETVAL",         cmd_getval,    hlp_getval },
+    { "PUTVAL",         cmd_putval,    hlp_putval },
+    { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
+    { "KILLAGENT",      cmd_killagent,  hlp_killagent },
+    { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
+    { "GETINFO",        cmd_getinfo,   hlp_getinfo },
     { NULL }
   };
   int i, rc;
 
   for (i=0; table[i].name; i++)
     {
-      rc = assuan_register_command (ctx, table[i].name, table[i].handler);
+      rc = assuan_register_command (ctx, table[i].name, table[i].handler,
+                                    table[i].help);
       if (rc)
         return rc;
     } 
-#ifdef HAVE_ASSUAN_SET_IO_MONITOR
   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
-#endif
   assuan_register_reset_notify (ctx, reset_notify);
   assuan_register_option_handler (ctx, option_handler);
   return 0;
@@ -1596,23 +2494,32 @@ void
 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
 {
   int rc;
-  assuan_context_t ctx;
+  assuan_context_t ctx = NULL;
+
+  rc = assuan_new (&ctx);
+  if (rc)
+    {
+      log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
+      agent_exit (2);
+    }
 
   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
     {
-      int filedes[2];
+      assuan_fd_t filedes[2];
 
-      filedes[0] = 0;
-      filedes[1] = 1;
-      rc = assuan_init_pipe_server (&ctx, filedes);
+      filedes[0] = assuan_fdopen (0);
+      filedes[1] = assuan_fdopen (1);
+      rc = assuan_init_pipe_server (ctx, filedes);
     }
   else if (listen_fd != GNUPG_INVALID_FD)
     {
-      rc = assuan_init_socket_server_ext (&ctx, listen_fd, 0);
+      rc = assuan_init_socket_server (ctx, listen_fd, 0);
+      /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
+        this branch is currently not used.  */
     }
   else 
     {
-      rc = assuan_init_socket_server_ext (&ctx, fd, 2);
+      rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
     }
   if (rc)
     {
@@ -1635,17 +2542,12 @@ start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
   ctrl->server_local->use_cache_for_signing = 1;
   ctrl->digest.raw_value = 0;
 
-  if (DBG_ASSUAN)
-    assuan_set_log_stream (ctx, log_get_stream ());
-
-#ifdef HAVE_ASSUAN_SET_IO_MONITOR
-  assuan_set_io_monitor (ctx, io_monitor);
-#endif
+  assuan_set_io_monitor (ctx, io_monitor, NULL);
 
   for (;;)
     {
       rc = assuan_accept (ctx);
-      if (rc == -1)
+      if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
         {
           break;
         }
@@ -1663,6 +2565,9 @@ start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
         }
     }
 
+  /* Reset the nonce caches.  */
+  clear_nonce_cache (ctrl);
+
   /* Reset the SCD if needed. */
   agent_reset_scd (ctrl);
 
@@ -1670,11 +2575,12 @@ start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
   agent_reset_query (ctrl);
 
   /* Cleanup.  */
-  assuan_deinit_server (ctx);
-#ifdef HAVE_W32_SYSTEM
+  assuan_release (ctx);
+  xfree (ctrl->server_local->keydesc);
+  xfree (ctrl->server_local->import_key);
+  xfree (ctrl->server_local->export_key);
   if (ctrl->server_local->stopme)
     agent_exit (0);
-#endif
   xfree (ctrl->server_local);
   ctrl->server_local = NULL;
 }