Take advantage of newer gpg-error features.
[gnupg.git] / agent / command.c
index dc8a4a1..1c6ab8b 100644 (file)
@@ -1,5 +1,5 @@
 /* command.c - gpg-agent command handler
- * Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ * Copyright (C) 2001, 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 /* FIXME: we should not use the default assuan buffering but setup
    some buffering in secure mempory to protect session keys etc. */
 
 #include <config.h>
+
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <unistd.h>
+#include <assert.h>
 
 #include <assuan.h>
 
@@ -38,7 +41,7 @@
 /* maximum allowed size of the key parameters */
 #define MAXLEN_KEYPARAM 1024
 
-#define set_error(e,t) assuan_set_error (ctx, ASSUAN_ ## e, (t))
+#define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
 
 
 #if MAX_DIGEST_LEN < 20
@@ -46,8 +49,9 @@
 #endif
 
 /* Data used to associate an Assuan context with local server data */
-struct server_local_s {
-  ASSUAN_CONTEXT assuan_ctx;
+struct server_local_s
+{
+  assuan_context_t assuan_ctx;
   int message_fd;
   int use_cache_for_signing;
   char *keydesc;  /* Allocated description for the next key
@@ -55,6 +59,20 @@ struct server_local_s {
 };
 
 
+/* An entry for the getval/putval commands. */
+struct putval_item_s
+{
+  struct putval_item_s *next;
+  size_t off;  /* Offset to the value into DATA.  */
+  size_t len;  /* Length of the value.  */
+  char d[1];   /* Key | Nul | value.  */ 
+};
+
+
+/* A list of key value pairs fpr the getval/putval commands.  */
+static struct putval_item_s *putval_list;
+
+
 
 
 \f
@@ -85,16 +103,16 @@ write_and_clear_outbuf (assuan_context_t ctx, membuf_t *mb)
 
   p = get_membuf (mb, &n);
   if (!p)
-    return gpg_error (GPG_ERR_ENOMEM);
+    return out_of_core ();
   ae = assuan_send_data (ctx, p, n);
   memset (p, 0, n);
   xfree (p);
-  return map_assuan_err (ae);
+  return ae;
 }
 
 
 static void
-reset_notify (ASSUAN_CONTEXT ctx)
+reset_notify (assuan_context_t ctx)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
 
@@ -130,10 +148,46 @@ 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 = 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
-parse_hexstring (ASSUAN_CONTEXT ctx, const char *string, size_t *len)
+parse_hexstring (assuan_context_t ctx, const char *string, size_t *len)
 {
   const char *p;
   size_t n;
@@ -142,9 +196,9 @@ parse_hexstring (ASSUAN_CONTEXT ctx, const char *string, size_t *len)
   for (p=string, n=0; hexdigitp (p); p++, n++)
     ;
   if (*p != ' ' && *p != '\t' && *p)
-    return set_error (Parameter_Error, "invalid hexstring");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
   if ((n&1))
-    return set_error (Parameter_Error, "odd number of digits");
+    return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
   *len = n;
   return 0;
 }
@@ -153,7 +207,7 @@ parse_hexstring (ASSUAN_CONTEXT ctx, const char *string, size_t *len)
    provide space for 20 bytes. BUF is not changed if the fucntions
    returns an error. */
 static int
-parse_keygrip (ASSUAN_CONTEXT ctx, const char *string, unsigned char *buf)
+parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
 {
   int rc;
   size_t n;
@@ -164,9 +218,9 @@ parse_keygrip (ASSUAN_CONTEXT ctx, const char *string, unsigned char *buf)
     return rc;
   n /= 2;
   if (n != 20)
-    return set_error (Parameter_Error, "invalid length of keygrip");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of keygrip");
 
-  for (p=string, n=0; n < 20; p += 2, n++)
+  for (p=(const unsigned char*)string, n=0; n < 20; p += 2, n++)
     buf[n] = xtoi_2 (p);
 
   return 0;
@@ -180,7 +234,7 @@ parse_keygrip (ASSUAN_CONTEXT ctx, const char *string, unsigned char *buf)
    Return OK when we have an entry with this fingerprint in our
    trustlist */
 static int
-cmd_istrusted (ASSUAN_CONTEXT ctx, char *line)
+cmd_istrusted (assuan_context_t ctx, char *line)
 {
   int rc, n, i;
   char *p;
@@ -190,7 +244,7 @@ cmd_istrusted (ASSUAN_CONTEXT ctx, char *line)
   for (p=line,n=0; hexdigitp (p); p++, n++)
     ;
   if (*p || !(n == 40 || n == 32))
-    return set_error (Parameter_Error, "invalid fingerprint");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
   i = 0;
   if (n==32)
     {
@@ -201,14 +255,14 @@ cmd_istrusted (ASSUAN_CONTEXT ctx, char *line)
     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
   fpr[i] = 0;
   rc = agent_istrusted (fpr);
-  if (!rc)
-    return 0;
-  else if (rc == -1)
-    return ASSUAN_Not_Trusted;
+  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 map_to_assuan_status (rc);
+      return rc;
     }
 }
 
@@ -216,12 +270,12 @@ cmd_istrusted (ASSUAN_CONTEXT ctx, char *line)
 
    List all entries from the trustlist */
 static int
-cmd_listtrusted (ASSUAN_CONTEXT ctx, char *line)
+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 map_to_assuan_status (rc);
+  return rc;
 }
 
 
@@ -229,7 +283,7 @@ cmd_listtrusted (ASSUAN_CONTEXT ctx, char *line)
 
    Store a new key in into the trustlist*/
 static int
-cmd_marktrusted (ASSUAN_CONTEXT ctx, char *line)
+cmd_marktrusted (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc, n, i;
@@ -241,7 +295,7 @@ cmd_marktrusted (ASSUAN_CONTEXT ctx, char *line)
   for (p=line,n=0; hexdigitp (p); p++, n++)
     ;
   if (!spacep (p) || !(n == 40 || n == 32))
-    return set_error (Parameter_Error, "invalid fingerprint");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
   i = 0;
   if (n==32)
     {
@@ -256,14 +310,14 @@ cmd_marktrusted (ASSUAN_CONTEXT ctx, char *line)
     p++;
   flag = *p++;
   if ( (flag != 'S' && flag != 'P') || !spacep (p) )
-    return set_error (Parameter_Error, "invalid flag - must be P or S");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid flag - must be P or S");
   while (spacep (p))
     p++;
 
   rc = agent_marktrusted (ctrl, p, fpr, flag);
   if (rc)
     log_error ("command marktrusted failed: %s\n", gpg_strerror (rc));
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
@@ -273,7 +327,7 @@ cmd_marktrusted (ASSUAN_CONTEXT ctx, char *line)
   
    Return success when the secret key is available */
 static int
-cmd_havekey (ASSUAN_CONTEXT ctx, char *line)
+cmd_havekey (assuan_context_t ctx, char *line)
 {
   int rc;
   unsigned char buf[20];
@@ -283,7 +337,7 @@ cmd_havekey (ASSUAN_CONTEXT ctx, char *line)
     return rc;
 
   if (agent_key_available (buf))
-    return ASSUAN_No_Secret_Key;
+    return gpg_error (GPG_ERR_NO_SECKEY);
 
   return 0;
 }
@@ -294,7 +348,7 @@ cmd_havekey (ASSUAN_CONTEXT ctx, char *line)
   
    Set the  key used for a sign or decrypt operation */
 static int
-cmd_sigkey (ASSUAN_CONTEXT ctx, char *line)
+cmd_sigkey (assuan_context_t ctx, char *line)
 {
   int rc;
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -307,18 +361,18 @@ cmd_sigkey (ASSUAN_CONTEXT ctx, char *line)
 }
 
 
-/* SETKEYDESC plus_percent_escaped_string:
+/* 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, other wiese the translation of
-   'passphrase" is used.  The description string should not contain
+   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 descrition is only valid for the next PKSIGN or PKDECRYPT
+   The description is only valid for the next PKSIGN or PKDECRYPT
    operation.
 */
 static int
@@ -335,7 +389,7 @@ cmd_setkeydesc (assuan_context_t ctx, char *line)
     *p = 0; /* We ignore any garbage; we might late use it for other args. */
 
   if (!desc || !*desc)
-    return set_error (Parameter_Error, "no description given");
+    return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
 
   /* Note, that we only need to replace the + characters and should
      leave the other escaping in place because the escaped string is
@@ -346,7 +400,7 @@ cmd_setkeydesc (assuan_context_t ctx, char *line)
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = xtrystrdup (desc);
   if (!ctrl->server_local->keydesc)
-    return map_to_assuan_status (gpg_error_from_errno (errno));
+    return out_of_core ();
   return 0;
 }
 
@@ -356,7 +410,7 @@ cmd_setkeydesc (assuan_context_t ctx, char *line)
   The client can use this command to tell the server about the data
   (which usually is a hash) to be signed. */
 static int
-cmd_sethash (ASSUAN_CONTEXT ctx, char *line)
+cmd_sethash (assuan_context_t ctx, char *line)
 {
   int rc;
   size_t n;
@@ -371,7 +425,7 @@ cmd_sethash (ASSUAN_CONTEXT ctx, char *line)
   for (line = endp; *line == ' ' || *line == '\t'; line++)
     ;
   if (!algo || gcry_md_test_algo (algo))
-    return set_error (Unsupported_Algorithm, NULL);
+    return set_error (GPG_ERR_UNSUPPORTED_ALGORITHM, NULL);
   ctrl->digest.algo = algo;
 
   /* parse the hash value */
@@ -380,9 +434,9 @@ cmd_sethash (ASSUAN_CONTEXT ctx, char *line)
     return rc;
   n /= 2;
   if (n != 16 && n != 20 && n != 24 && n != 32)
-    return set_error (Parameter_Error, "unsupported length of hash");
+    return set_error (GPG_ERR_ASS_PARAMETER, "unsupported length of hash");
   if (n > MAX_DIGEST_LEN)
-    return set_error (Parameter_Error, "hash value to long");
+    return set_error (GPG_ERR_ASS_PARAMETER, "hash value to long");
 
   buf = ctrl->digest.value;
   ctrl->digest.valuelen = n;
@@ -397,24 +451,24 @@ cmd_sethash (ASSUAN_CONTEXT ctx, char *line)
 /* PKSIGN <options>
 
    Perform the actual sign operation. Neither input nor output are
-   sensitive to eavesdropping */
+   sensitive to eavesdropping. */
 static int
-cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
+cmd_pksign (assuan_context_t ctx, char *line)
 {
   int rc;
-  int ignore_cache = 0;
+  cache_mode_t cache_mode = CACHE_MODE_NORMAL;
   ctrl_t ctrl = assuan_get_pointer (ctx);
   membuf_t outbuf;
-
+  
   if (opt.ignore_cache_for_signing)
-    ignore_cache = 1;
+    cache_mode = CACHE_MODE_IGNORE;
   else if (!ctrl->server_local->use_cache_for_signing)
-    ignore_cache = 1;
+    cache_mode = CACHE_MODE_IGNORE;
 
   init_membuf (&outbuf, 512);
 
   rc = agent_pksign (ctrl, ctrl->server_local->keydesc,
-                     &outbuf, ignore_cache);
+                     &outbuf, cache_mode);
   if (rc)
     clear_outbuf (&outbuf);
   else
@@ -423,7 +477,7 @@ cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
     log_error ("command pksign failed: %s\n", gpg_strerror (rc));
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = NULL;
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 /* PKDECRYPT <options>
@@ -431,7 +485,7 @@ cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
    Perform the actual decrypt operation.  Input is not 
    sensitive to eavesdropping */
 static int
-cmd_pkdecrypt (ASSUAN_CONTEXT ctx, char *line)
+cmd_pkdecrypt (assuan_context_t ctx, char *line)
 {
   int rc;
   ctrl_t ctrl = assuan_get_pointer (ctx);
@@ -458,7 +512,7 @@ cmd_pkdecrypt (ASSUAN_CONTEXT ctx, char *line)
     log_error ("command pkdecrypt failed: %s\n", gpg_strerror (rc));
   xfree (ctrl->server_local->keydesc);
   ctrl->server_local->keydesc = NULL;
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
@@ -477,7 +531,7 @@ cmd_pkdecrypt (ASSUAN_CONTEXT ctx, char *line)
 */
 
 static int
-cmd_genkey (ASSUAN_CONTEXT ctx, char *line)
+cmd_genkey (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
@@ -492,7 +546,7 @@ cmd_genkey (ASSUAN_CONTEXT ctx, char *line)
 
   init_membuf (&outbuf, 512);
 
-  rc = agent_genkey (ctrl, value, valuelen, &outbuf);
+  rc = agent_genkey (ctrl, (char*)value, valuelen, &outbuf);
   xfree (value);
   if (rc)
     clear_outbuf (&outbuf);
@@ -500,10 +554,58 @@ cmd_genkey (ASSUAN_CONTEXT ctx, char *line)
     rc = write_and_clear_outbuf (ctx, &outbuf);
   if (rc)
     log_error ("command genkey failed: %s\n", gpg_strerror (rc));
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
+
+\f
+/* READKEY <hexstring_with_keygrip>
+  
+   Return the public key for the given keygrip.  */
+static int
+cmd_readkey (assuan_context_t ctx, char *line)
+{
+  ctrl_t ctrl = assuan_get_pointer (ctx);
+  int rc;
+  unsigned char grip[20];
+  gcry_sexp_t s_pkey = NULL;
+
+  rc = parse_keygrip (ctx, line, grip);
+  if (rc)
+    return rc; /* Return immediately as this is already an Assuan error code.*/
+
+  rc = agent_public_key_from_file (ctrl, grip, &s_pkey);
+  if (!rc)
+    {
+      size_t len;
+      unsigned char *buf;
+
+      len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
+      assert (len);
+      buf = xtrymalloc (len);
+      if (!buf)
+        rc = gpg_error_from_syserror ();
+      else
+        {
+          len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, buf, len);
+          assert (len);
+          rc = assuan_send_data (ctx, buf, len);
+          xfree (buf);
+        }
+      gcry_sexp_release (s_pkey);
+    }
+
+  if (rc)
+    log_error ("command readkey failed: %s\n", gpg_strerror (rc));
+  return rc;
+}
+
+
+
+
+
+\f
 /* GET_PASSPHRASE <cache_id> [<error_message> <prompt> <description>]
 
    This function is usually used to ask for a passphrase to be used
@@ -516,7 +618,7 @@ cmd_genkey (ASSUAN_CONTEXT ctx, char *line)
 */
 
 static int
-cmd_get_passphrase (ASSUAN_CONTEXT ctx, char *line)
+cmd_get_passphrase (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
@@ -558,9 +660,9 @@ cmd_get_passphrase (ASSUAN_CONTEXT ctx, char *line)
         }
     }
   if (!cacheid || !*cacheid || strlen (cacheid) > 50)
-    return set_error (Parameter_Error, "invalid length of cacheID");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
   if (!desc)
-    return set_error (Parameter_Error, "no description given");
+    return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
 
   if (!strcmp (cacheid, "X"))
     cacheid = NULL;
@@ -572,7 +674,8 @@ cmd_get_passphrase (ASSUAN_CONTEXT ctx, char *line)
     desc = NULL;
 
   /* Note: we store the hexified versions in the cache. */
-  pw = cacheid ? agent_get_cache (cacheid, &cache_marker) : NULL;
+  pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_NORMAL, &cache_marker)
+               : NULL;
   if (pw)
     {
       assuan_begin_confidential (ctx);
@@ -596,7 +699,7 @@ cmd_get_passphrase (ASSUAN_CONTEXT ctx, char *line)
       if (!rc)
         {
           if (cacheid)
-            agent_put_cache (cacheid, response, 0);
+            agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
           assuan_begin_confidential (ctx);
           rc = assuan_set_okay_line (ctx, response);
           xfree (response);
@@ -605,7 +708,7 @@ cmd_get_passphrase (ASSUAN_CONTEXT ctx, char *line)
 
   if (rc)
     log_error ("command get_passphrase failed: %s\n", gpg_strerror (rc));
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
@@ -616,7 +719,7 @@ cmd_get_passphrase (ASSUAN_CONTEXT ctx, char *line)
 */
 
 static int
-cmd_clear_passphrase (ASSUAN_CONTEXT ctx, char *line)
+cmd_clear_passphrase (assuan_context_t ctx, char *line)
 {
   char *cacheid = NULL;
   char *p;
@@ -629,9 +732,9 @@ cmd_clear_passphrase (ASSUAN_CONTEXT ctx, char *line)
   if (p)
     *p = 0; /* ignore garbage */
   if (!cacheid || !*cacheid || strlen (cacheid) > 50)
-    return set_error (Parameter_Error, "invalid length of cacheID");
+    return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
 
-  agent_put_cache (cacheid, NULL, 0);
+  agent_put_cache (cacheid, CACHE_MODE_USER, NULL, 0);
   return 0;
 }
 
@@ -649,7 +752,7 @@ cmd_clear_passphrase (ASSUAN_CONTEXT ctx, char *line)
 */
 
 static int
-cmd_get_confirmation (ASSUAN_CONTEXT ctx, char *line)
+cmd_get_confirmation (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
@@ -665,7 +768,7 @@ cmd_get_confirmation (ASSUAN_CONTEXT ctx, char *line)
     *p = 0; /* We ignore any garbage -may be later used for other args. */
 
   if (!desc || !*desc)
-    return set_error (Parameter_Error, "no description given");
+    return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
 
   if (!strcmp (desc, "X"))
     desc = NULL;
@@ -680,7 +783,7 @@ cmd_get_confirmation (ASSUAN_CONTEXT ctx, char *line)
   rc = agent_get_confirmation (ctrl, desc, NULL, NULL);
   if (rc)
     log_error ("command get_confirmation failed: %s\n", gpg_strerror (rc));
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
@@ -690,7 +793,7 @@ cmd_get_confirmation (ASSUAN_CONTEXT ctx, char *line)
    Learn something about the currently inserted smartcard.  With
    --send the new certificates are send back.  */
 static int
-cmd_learn (ASSUAN_CONTEXT ctx, char *line)
+cmd_learn (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
@@ -698,7 +801,7 @@ cmd_learn (ASSUAN_CONTEXT ctx, char *line)
   rc = agent_handle_learn (ctrl, has_option (line, "--send")? ctx : NULL);
   if (rc)
     log_error ("command learn failed: %s\n", gpg_strerror (rc));
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
@@ -707,7 +810,7 @@ cmd_learn (ASSUAN_CONTEXT ctx, char *line)
   
    Change the passphrase/PID for the key identified by keygrip in LINE. */
 static int
-cmd_passwd (ASSUAN_CONTEXT ctx, char *line)
+cmd_passwd (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
@@ -721,7 +824,7 @@ cmd_passwd (ASSUAN_CONTEXT ctx, char *line)
                   Assuan error code. */
 
   rc = agent_key_from_file (ctrl, ctrl->server_local->keydesc,
-                            grip, &shadow_info, 1, &s_skey);
+                            grip, &shadow_info, CACHE_MODE_IGNORE, &s_skey);
   if (rc)
     ;
   else if (!s_skey)
@@ -738,10 +841,10 @@ cmd_passwd (ASSUAN_CONTEXT ctx, char *line)
   xfree (shadow_info);
   if (rc)
     log_error ("command passwd failed: %s\n", gpg_strerror (rc));
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
-/* PRESET_PASSPHRASE <hexstring_with_keygrip> <timeout> <passwd>
+/* 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
@@ -749,13 +852,14 @@ cmd_passwd (ASSUAN_CONTEXT ctx, char *line)
    to never expire it).  If passwd is not provided, ask for it via the
    pinentry module.  */
 static int
-cmd_preset_passphrase (ASSUAN_CONTEXT ctx, char *line)
+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);
@@ -769,7 +873,7 @@ cmd_preset_passphrase (ASSUAN_CONTEXT ctx, char *line)
   while (*line && (*line != ' ' && *line != '\t'))
     line++;
   if (!*line)
-    return map_to_assuan_status (gpg_error (GPG_ERR_MISSING_VALUE));
+    return gpg_error (GPG_ERR_MISSING_VALUE);
   *line = '\0';
   line++;
   while (*line && (*line == ' ' || *line == '\t'))
@@ -778,25 +882,31 @@ cmd_preset_passphrase (ASSUAN_CONTEXT ctx, char *line)
   /* Currently, only infinite timeouts are allowed.  */
   ttl = -1;
   if (line[0] != '-' || line[1] != '1')
-    return map_to_assuan_status (gpg_error (GPG_ERR_NOT_IMPLEMENTED));
+    return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
   line++;
   line++;
   while (!(*line != ' ' && *line != '\t'))
     line++;
 
+  /* Syntax check the hexstring.  */
+  rc = parse_hexstring (ctx, line, &len);
+  if (rc)
+    return rc;
+  line[len] = '\0';
+
   /* If there is a passphrase, use it.  Currently, a passphrase is
      required.  */
   if (*line)
     passphrase = line;
   else
-    return map_to_assuan_status (gpg_error (GPG_ERR_NOT_IMPLEMENTED));
+    return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
 
-  rc = agent_put_cache (grip_clear, passphrase, ttl);
+  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 map_to_assuan_status (rc);
+  return rc;
 }
 
 \f
@@ -805,20 +915,184 @@ cmd_preset_passphrase (ASSUAN_CONTEXT ctx, char *line)
    This is a general quote command to redirect everything to the
    SCDAEMON. */
 static int
-cmd_scd (ASSUAN_CONTEXT ctx, char *line)
+cmd_scd (assuan_context_t ctx, char *line)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
   int rc;
 
   rc = divert_generic_cmd (ctrl, line, ctx);
 
-  return map_to_assuan_status (rc);
+  return rc;
 }
 
 
 \f
+/* GETVAL <key>
+
+   Return the value for KEY from the special environment as created by
+   PUTVAL.
+ */
 static int
-option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
+cmd_getval (assuan_context_t ctx, char *line)
+{
+  int rc = 0;
+  char *key = NULL;
+  char *p;
+  struct putval_item_s *vl;
+
+  for (p=line; *p == ' '; p++)
+    ;
+  key = p;
+  p = strchr (key, ' ');
+  if (p)
+    {
+      *p++ = 0; 
+      for (; *p == ' '; p++)
+        ;
+      if (*p)
+        return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
+    }
+  if (!key || !*key)
+    return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
+
+
+  for (vl=putval_list; vl; vl = vl->next)
+    if ( !strcmp (vl->d, key) )
+      break;
+
+  if (vl) /* Got an entry. */
+    rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
+  else
+    return gpg_error (GPG_ERR_NO_DATA);
+
+  if (rc)
+    log_error ("command getval failed: %s\n", gpg_strerror (rc));
+  return 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
+cmd_putval (assuan_context_t ctx, char *line)
+{
+  int rc = 0;
+  char *key = NULL;
+  char *value = NULL;
+  size_t valuelen = 0;
+  char *p;
+  struct putval_item_s *vl, *vlprev;
+
+  for (p=line; *p == ' '; p++)
+    ;
+  key = p;
+  p = strchr (key, ' ');
+  if (p)
+    {
+      *p++ = 0; 
+      for (; *p == ' '; p++)
+        ;
+      if (*p)
+        {
+          value = p;
+          p = strchr (value, ' ');
+          if (p)
+            *p = 0;
+          valuelen = percent_plus_unescape (value);
+        }
+    }
+  if (!key || !*key)
+    return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
+
+
+  for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
+    if ( !strcmp (vl->d, key) )
+      break;
+
+  if (vl) /* Delete old entry. */
+    {
+      if (vlprev)
+        vlprev->next = vl->next;
+      else
+        putval_list = vl->next;
+      xfree (vl);
+    }
+
+  if (valuelen) /* Add entry. */  
+    {
+      vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
+      if (!vl)
+        rc = gpg_error_from_syserror ();
+      else
+        {
+          vl->len = valuelen;
+          vl->off = strlen (key) + 1;
+          strcpy (vl->d, key);
+          memcpy (vl->d + vl->off, value, valuelen);
+          vl->next = putval_list;
+          putval_list = vl;
+        }
+    }
+
+  if (rc)
+    log_error ("command putval failed: %s\n", gpg_strerror (rc));
+  return 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
+cmd_updatestartuptty (assuan_context_t ctx, char *line)
+{
+  ctrl_t ctrl = assuan_get_pointer (ctx);
+
+  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;
+
+  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);
+
+  return 0;
+}
+
+
+\f
+static int
+option_handler (assuan_context_t ctx, const char *key, const char *value)
 {
   ctrl_t ctrl = assuan_get_pointer (ctx);
 
@@ -828,7 +1102,7 @@ option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
         free (ctrl->display);
       ctrl->display = strdup (value);
       if (!ctrl->display)
-        return ASSUAN_Out_Of_Core;
+        return out_of_core ();
     }
   else if (!strcmp (key, "ttyname"))
     {
@@ -838,7 +1112,7 @@ option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
             free (ctrl->ttyname);
           ctrl->ttyname = strdup (value);
           if (!ctrl->ttyname)
-            return ASSUAN_Out_Of_Core;
+            return out_of_core ();
         }
     }
   else if (!strcmp (key, "ttytype"))
@@ -849,7 +1123,7 @@ option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
             free (ctrl->ttytype);
           ctrl->ttytype = strdup (value);
           if (!ctrl->ttytype)
-            return ASSUAN_Out_Of_Core;
+            return out_of_core ();
         }
     }
   else if (!strcmp (key, "lc-ctype"))
@@ -858,7 +1132,7 @@ option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
         free (ctrl->lc_ctype);
       ctrl->lc_ctype = strdup (value);
       if (!ctrl->lc_ctype)
-        return ASSUAN_Out_Of_Core;
+        return out_of_core ();
     }
   else if (!strcmp (key, "lc-messages"))
     {
@@ -866,12 +1140,12 @@ option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
         free (ctrl->lc_messages);
       ctrl->lc_messages = strdup (value);
       if (!ctrl->lc_messages)
-        return ASSUAN_Out_Of_Core;
+        return out_of_core ();
     }
   else if (!strcmp (key, "use-cache-for-signing"))
     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
   else
-    return ASSUAN_Invalid_Option;
+    return gpg_error (GPG_ERR_UNKNOWN_OPTION);
 
   return 0;
 }
@@ -879,11 +1153,11 @@ option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
 \f
 /* Tell the assuan library about our commands */
 static int
-register_commands (ASSUAN_CONTEXT ctx)
+register_commands (assuan_context_t ctx)
 {
   static struct {
     const char *name;
-    int (*handler)(ASSUAN_CONTEXT, char *line);
+    int (*handler)(assuan_context_t, char *line);
   } table[] = {
     { "ISTRUSTED",      cmd_istrusted },
     { "HAVEKEY",        cmd_havekey },
@@ -894,6 +1168,7 @@ register_commands (ASSUAN_CONTEXT ctx)
     { "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 },
@@ -905,6 +1180,9 @@ register_commands (ASSUAN_CONTEXT ctx)
     { "INPUT",          NULL }, 
     { "OUTPUT",         NULL }, 
     { "SCD",            cmd_scd },
+    { "GETVAL",         cmd_getval },
+    { "PUTVAL",         cmd_putval },
+    { "UPDATESTARTUPTTY",  cmd_updatestartuptty },
     { NULL }
   };
   int i, rc;
@@ -927,7 +1205,7 @@ void
 start_command_handler (int listen_fd, int fd)
 {
   int rc;
-  ASSUAN_CONTEXT ctx;
+  assuan_context_t ctx;
   struct server_control_s ctrl;
 
   memset (&ctrl, 0, sizeof ctrl);
@@ -943,24 +1221,24 @@ start_command_handler (int listen_fd, int fd)
     }
   else if (listen_fd != -1)
     {
-      rc = assuan_init_socket_server (&ctx, listen_fd);
+      rc = assuan_init_socket_server_ext (&ctx, listen_fd, 0);
     }
   else 
     {
-      rc = assuan_init_connected_socket_server (&ctx, fd);
+      rc = assuan_init_socket_server_ext (&ctx, fd, 2);
       ctrl.connection_fd = fd;
     }
   if (rc)
     {
       log_error ("failed to initialize the server: %s\n",
-                 assuan_strerror(rc));
+                 gpg_strerror(rc));
       agent_exit (2);
     }
   rc = register_commands (ctx);
   if (rc)
     {
       log_error ("failed to register commands with Assuan: %s\n",
-                 assuan_strerror(rc));
+                 gpg_strerror(rc));
       agent_exit (2);
     }
 
@@ -983,14 +1261,14 @@ start_command_handler (int listen_fd, int fd)
         }
       else if (rc)
         {
-          log_info ("Assuan accept problem: %s\n", assuan_strerror (rc));
+          log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
           break;
         }
       
       rc = assuan_process (ctx);
       if (rc)
         {
-          log_info ("Assuan processing failed: %s\n", assuan_strerror (rc));
+          log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
           continue;
         }
     }
@@ -998,6 +1276,9 @@ start_command_handler (int listen_fd, int fd)
   /* Reset the SCD if needed. */
   agent_reset_scd (&ctrl);
 
+  /* Reset the pinentry (in case of popup messages). */
+  agent_reset_query (&ctrl);
+
   assuan_deinit_server (ctx);
   if (ctrl.display)
     free (ctrl.display);
@@ -1009,5 +1290,6 @@ start_command_handler (int listen_fd, int fd)
     free (ctrl.lc_ctype);
   if (ctrl.lc_messages)
     free (ctrl.lc_messages);
+  xfree (ctrl.server_local);
 }