s/AES/AES128/ in diagnostics and --list-config
[gnupg.git] / agent / command.c
index f578762..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). */
 };
 
 
@@ -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,7 +302,7 @@ static int
 parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
 {
   int rc;
-  size_t n;
+  size_t n = 0;
 
   rc = parse_hexstring (ctx, string, &n);
   if (rc)
@@ -308,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);
@@ -335,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);
@@ -394,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);
@@ -420,22 +502,21 @@ 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;
@@ -443,16 +524,15 @@ cmd_listtrusted (assuan_context_t ctx, char *line)
   (void)line;
 
   rc = agent_listtrusted (ctx);
-  if (rc)
-    log_error ("command listtrusted failed: %s\n", gpg_strerror (rc));
-  return rc;
+  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);
@@ -485,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;
@@ -531,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);
@@ -575,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;
@@ -596,8 +689,14 @@ 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"))
@@ -622,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 == 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)
@@ -646,20 +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;
   
-  (void)line;
+  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)
@@ -667,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;
@@ -710,38 +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);
 
-  (void)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);
@@ -750,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);
@@ -800,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
@@ -836,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;
@@ -913,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
@@ -933,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;
@@ -985,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);
@@ -1026,85 +1332,174 @@ 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)
-    ;
-  else if (!s_skey)
+  cache_nonce = option_value (line, "--cache-nonce");
+  if (cache_nonce)
     {
-      log_error ("changing a smartcard PIN is not yet supported\n");
-      rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
+      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");
+      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;
@@ -1113,11 +1508,6 @@ cmd_preset_passphrase (assuan_context_t ctx, char *line)
   if (!opt.allow_preset_passphrase)
     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++;
@@ -1138,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;
@@ -1158,18 +1549,17 @@ cmd_preset_passphrase (assuan_context_t ctx, char *line)
   if (!rc)
     rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
 
-  if (rc)
-    log_error ("command preset_passwd failed: %s\n", gpg_strerror (rc));
-
-  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);
@@ -1182,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;
@@ -1220,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;
@@ -1269,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)
@@ -1305,95 +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"))
@@ -1426,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;
@@ -1433,40 +2298,42 @@ 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)
-        xfree (ctrl->display);
-      ctrl->display = xtrystrdup (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)
-            xfree (ctrl->ttyname);
-          ctrl->ttyname = xtrystrdup (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)
-            xfree (ctrl->ttytype);
-          ctrl->ttytype = xtrystrdup (value);
-          if (!ctrl->ttytype)
-            return out_of_core ();
-        }
+        err = session_env_setenv (ctrl->session_env, "TERM", value);
     }
   else if (!strcmp (key, "lc-ctype"))
     {
@@ -1486,28 +2353,20 @@ option_handler (assuan_context_t ctx, const char *key, const char *value)
     }
   else if (!strcmp (key, "xauthority"))
     {
-      if (ctrl->xauthority)
-        xfree (ctrl->xauthority);
-      ctrl->xauthority = xtrystrdup (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)
-        xfree (ctrl->pinentry_user_data);
-      ctrl->pinentry_user_data = xtrystrdup (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;
 }
 
 
@@ -1516,7 +2375,7 @@ 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);
   
@@ -1532,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)))
@@ -1548,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;
 }
 
 
@@ -1558,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;
@@ -1617,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)
     {
@@ -1656,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;
         }
@@ -1684,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);
 
@@ -1691,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;
 }